842 lines
35 KiB
C#
842 lines
35 KiB
C#
/*
|
|
*
|
|
* (c) Copyright Ascensio System Limited 2010-2018
|
|
*
|
|
* This program is freeware. You can redistribute it and/or modify it under the terms of the GNU
|
|
* General Public License (GPL) version 3 as published by the Free Software Foundation (https://www.gnu.org/copyleft/gpl.html).
|
|
* In accordance with Section 7(a) of the GNU GPL its Section 15 shall be amended to the effect that
|
|
* Ascensio System SIA expressly excludes the warranty of non-infringement of any third-party rights.
|
|
*
|
|
* THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR
|
|
* FITNESS FOR A PARTICULAR PURPOSE. For more details, see GNU GPL at https://www.gnu.org/copyleft/gpl.html
|
|
*
|
|
* You can contact Ascensio System SIA by email at sales@onlyoffice.com
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions of ONLYOFFICE must display
|
|
* Appropriate Legal Notices, as required under Section 5 of the GNU GPL version 3.
|
|
*
|
|
* Pursuant to Section 7 § 3(b) of the GNU GPL you must retain the original ONLYOFFICE logo which contains
|
|
* relevant author attributions when distributing the software. If the display of the logo in its graphic
|
|
* form is not reasonably feasible for technical reasons, you must include the words "Powered by ONLYOFFICE"
|
|
* in every copy of the program you distribute.
|
|
* Pursuant to Section 7 § 3(e) we decline to grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
*/
|
|
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net.Mime;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
using ASC.Api.Core;
|
|
using ASC.Api.CRM;
|
|
using ASC.Api.Documents;
|
|
using ASC.Common.Web;
|
|
using ASC.Core;
|
|
using ASC.CRM.ApiModels;
|
|
using ASC.CRM.Core;
|
|
using ASC.CRM.Core.Dao;
|
|
using ASC.CRM.Core.Entities;
|
|
using ASC.CRM.Core.Enums;
|
|
using ASC.MessagingSystem;
|
|
using ASC.Web.Api.Routing;
|
|
using ASC.Web.CRM.Services.NotifyService;
|
|
using ASC.Web.Files.Classes;
|
|
using ASC.Web.Files.Utils;
|
|
|
|
using AutoMapper;
|
|
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
|
|
using OrderBy = ASC.CRM.Core.Entities.OrderBy;
|
|
|
|
namespace ASC.CRM.Api
|
|
{
|
|
public class RelationshipEventsController : BaseApiController
|
|
{
|
|
private readonly FileUploader _fileUploader;
|
|
private readonly ASC.Files.Core.Data.DaoFactory _filesDaoFactory;
|
|
private readonly FileWrapperHelper _fileWrapperHelper;
|
|
private readonly FilesSettingsHelper _filesSettingsHelper;
|
|
private readonly ApiContext _apiContext;
|
|
private readonly MessageService _messageService;
|
|
private readonly MessageTarget _messageTarget;
|
|
private readonly SecurityContext _securityContext;
|
|
private readonly NotifyClient _notifyClient;
|
|
|
|
public RelationshipEventsController(
|
|
CrmSecurity crmSecurity,
|
|
DaoFactory daoFactory,
|
|
ApiContext apiContext,
|
|
MessageTarget messageTarget,
|
|
MessageService messageService,
|
|
FileWrapperHelper fileWrapperHelper,
|
|
ASC.Files.Core.Data.DaoFactory filesDaoFactory,
|
|
FileUploader fileUploader,
|
|
SecurityContext securityContext,
|
|
NotifyClient notifyClient,
|
|
FilesSettingsHelper filesSettingsHelper,
|
|
IMapper mapper)
|
|
: base(daoFactory, crmSecurity, mapper)
|
|
{
|
|
_apiContext = apiContext;
|
|
_messageTarget = messageTarget;
|
|
_messageService = messageService;
|
|
_fileWrapperHelper = fileWrapperHelper;
|
|
_filesDaoFactory = filesDaoFactory;
|
|
_fileUploader = fileUploader;
|
|
_securityContext = securityContext;
|
|
_notifyClient = notifyClient;
|
|
_filesSettingsHelper = filesSettingsHelper;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns the list of all events matching the parameters specified in the request
|
|
/// </summary>
|
|
/// <short>
|
|
/// Get event list
|
|
/// </short>
|
|
/// <category>History</category>
|
|
/// <param optional="true" name="entityType" remark="Allowed values: opportunity, contact or case">Related entity type</param>
|
|
/// <param optional="true" name="entityId">Related entity ID</param>
|
|
/// <param optional="true" name="categoryId">Task category ID</param>
|
|
/// <param optional="true" name="createBy">Event author</param>
|
|
/// <param optional="true" name="fromDate">Earliest task due date</param>
|
|
/// <param optional="true" name="toDate">Latest task due date</param>
|
|
/// <returns>
|
|
/// Event list
|
|
/// </returns>
|
|
[Read(@"history/filter")]
|
|
public IEnumerable<RelationshipEventDto> GetHistory(
|
|
string entityType,
|
|
int entityId,
|
|
int categoryId,
|
|
Guid createBy,
|
|
ApiDateTime fromDate,
|
|
ApiDateTime toDate)
|
|
{
|
|
var entityTypeObj = ToEntityType(entityType);
|
|
|
|
switch (entityTypeObj)
|
|
{
|
|
case EntityType.Contact:
|
|
var contact = _daoFactory.GetContactDao().GetByID(entityId);
|
|
if (contact == null || !_crmSecurity.CanAccessTo(contact))
|
|
throw new ItemNotFoundException();
|
|
break;
|
|
case EntityType.Case:
|
|
var cases = _daoFactory.GetCasesDao().GetByID(entityId);
|
|
if (cases == null || !_crmSecurity.CanAccessTo(cases))
|
|
throw new ItemNotFoundException();
|
|
break;
|
|
case EntityType.Opportunity:
|
|
var deal = _daoFactory.GetDealDao().GetByID(entityId);
|
|
if (deal == null || !_crmSecurity.CanAccessTo(deal))
|
|
throw new ItemNotFoundException();
|
|
break;
|
|
default:
|
|
if (entityId != 0)
|
|
{
|
|
throw new ArgumentException();
|
|
}
|
|
break;
|
|
}
|
|
|
|
RelationshipEventByType eventByType;
|
|
|
|
IEnumerable<RelationshipEventDto> result;
|
|
|
|
OrderBy eventOrderBy;
|
|
|
|
if (ASC.CRM.Classes.EnumExtension.TryParse(_apiContext.SortBy, true, out eventByType))
|
|
{
|
|
eventOrderBy = new OrderBy(eventByType, !_apiContext.SortDescending);
|
|
}
|
|
else if (string.IsNullOrEmpty(_apiContext.SortBy))
|
|
{
|
|
eventOrderBy = new OrderBy(RelationshipEventByType.Created, false);
|
|
}
|
|
else
|
|
{
|
|
eventOrderBy = null;
|
|
}
|
|
|
|
if (eventOrderBy != null)
|
|
{
|
|
result = ToListRelationshipEventDto(_daoFactory.GetRelationshipEventDao().GetItems(
|
|
_apiContext.FilterValue,
|
|
entityTypeObj,
|
|
entityId,
|
|
createBy,
|
|
categoryId,
|
|
fromDate,
|
|
toDate,
|
|
(int)_apiContext.StartIndex,
|
|
(int)_apiContext.Count,
|
|
eventOrderBy));
|
|
|
|
_apiContext.SetDataPaginated();
|
|
_apiContext.SetDataFiltered();
|
|
_apiContext.SetDataSorted();
|
|
}
|
|
else
|
|
{
|
|
result = ToListRelationshipEventDto(_daoFactory.GetRelationshipEventDao().GetItems(
|
|
_apiContext.FilterValue,
|
|
entityTypeObj,
|
|
entityId,
|
|
createBy,
|
|
categoryId,
|
|
fromDate,
|
|
toDate,
|
|
0,
|
|
0,
|
|
null));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes the event with the ID specified in the request and all the files associated with this event
|
|
/// </summary>
|
|
/// <short>
|
|
/// Delete event and related files
|
|
/// </short>
|
|
/// <category>History</category>
|
|
/// <param name="id">Event ID</param>
|
|
/// <exception cref="ArgumentException"></exception>
|
|
/// <exception cref="ItemNotFoundException"></exception>
|
|
/// <returns>
|
|
/// Event
|
|
/// </returns>
|
|
[Delete(@"history/{id:int}")]
|
|
public RelationshipEventDto DeleteHistory(int id)
|
|
{
|
|
if (id <= 0) throw new ArgumentException();
|
|
|
|
var item = _daoFactory.GetRelationshipEventDao().GetByID(id);
|
|
if (item == null) throw new ItemNotFoundException();
|
|
var wrapper = _mapper.Map<RelationshipEventDto>(item);
|
|
|
|
_daoFactory.GetRelationshipEventDao().DeleteItem(id);
|
|
|
|
var messageAction = GetHistoryDeletedAction(item.EntityType, item.ContactID);
|
|
var entityTitle = wrapper.Contact == null ? wrapper.Entity.EntityTitle : wrapper.Contact.DisplayName;
|
|
_messageService.Send(messageAction, _messageTarget.Create(item.ID), entityTitle, wrapper.Category.Title);
|
|
|
|
return wrapper;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a text (.txt) file in the selected folder with the title and contents sent in the request
|
|
/// </summary>
|
|
/// <short>Create txt</short>
|
|
/// <category>Files</category>
|
|
/// <param name="entityType">Entity type</param>
|
|
/// <param name="entityid">Entity ID</param>
|
|
/// <param name="title">File title</param>
|
|
/// <param name="content">File contents</param>
|
|
/// <returns>
|
|
/// File info
|
|
/// </returns>
|
|
[Create(@"{entityType:regex(contact|opportunity|case)}/{entityid:int}/files/text")]
|
|
public FileWrapper<int> CreateTextFile(
|
|
[FromRoute] string entityType,
|
|
[FromRoute] int entityid,
|
|
[FromForm] string title,
|
|
[FromForm] string content)
|
|
{
|
|
if (title == null) throw new ArgumentNullException("title");
|
|
if (content == null) throw new ArgumentNullException("content");
|
|
|
|
var folderid = GetRootFolderID();
|
|
|
|
FileWrapper<int> result;
|
|
|
|
var extension = ".txt";
|
|
if (!string.IsNullOrEmpty(content))
|
|
{
|
|
if (Regex.IsMatch(content, @"<([^\s>]*)(\s[^<]*)>"))
|
|
{
|
|
extension = ".html";
|
|
}
|
|
}
|
|
|
|
using (var memStream = new MemoryStream(Encoding.UTF8.GetBytes(content)))
|
|
{
|
|
title = title.EndsWith(extension, StringComparison.OrdinalIgnoreCase) ? title : (title + extension);
|
|
result = SaveFile(folderid, memStream, title);
|
|
}
|
|
|
|
AttachFiles(entityType, entityid, new List<int> { (int)result.Id });
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Upload file
|
|
/// </summary>
|
|
/// <short>Upload file</short>
|
|
/// <category>Files</category>
|
|
/// <remarks>
|
|
/// <![CDATA[
|
|
/// Upload can be done in 2 different ways:
|
|
/// <ol>
|
|
/// <li>Single file upload. You should set Content-Type & Content-Disposition header to specify filename and content type, and send file in request body</li>
|
|
/// <li>Using standart multipart/form-data method</li>
|
|
/// </ol>]]>
|
|
/// </remarks>
|
|
/// <param name="entityType">Entity type</param>
|
|
/// <param name="entityid">Entity ID</param>
|
|
/// <param name="file" visible="false">Request Input stream</param>
|
|
/// <param name="contentType" visible="false">Content-Type Header</param>
|
|
/// <param name="contentDisposition" visible="false">Content-Disposition Header</param>
|
|
/// <param name="files" visible="false">List of files when posted as multipart/form-data</param>
|
|
/// <param name="storeOriginalFileFlag" visible="false">If True, upload documents in original formats as well</param>
|
|
/// <returns>
|
|
/// File info
|
|
/// </returns>
|
|
[Create(@"{entityType:regex(contact|opportunity|case)}/{entityid:int}/files/upload")]
|
|
public FileWrapper<int> UploadFileInCRM([FromForm] UploadFileInCRMRequestDto inDto)
|
|
{
|
|
string entityType = inDto.EntityType;
|
|
int entityid = inDto.Entityid;
|
|
Stream file = inDto.File;
|
|
ContentType contentType = inDto.ContentType;
|
|
ContentDisposition contentDisposition = inDto.ContentDisposition;
|
|
IEnumerable<IFormFile> files = inDto.Files;
|
|
bool storeOriginalFileFlag = inDto.StoreOriginalFileFlag;
|
|
|
|
_filesSettingsHelper.StoreOriginalFiles = storeOriginalFileFlag;
|
|
|
|
var folderid = GetRootFolderID();
|
|
|
|
var fileNames = new List<string>();
|
|
|
|
FileWrapper<int> uploadedFile = null;
|
|
if (files != null && files.Any())
|
|
{
|
|
//For case with multiple files
|
|
foreach (var postedFile in files)
|
|
{
|
|
using var fileStream = postedFile.OpenReadStream();
|
|
uploadedFile = SaveFile(folderid, fileStream, postedFile.FileName);
|
|
fileNames.Add(uploadedFile.Title);
|
|
}
|
|
}
|
|
else if (file != null)
|
|
{
|
|
uploadedFile = SaveFile(folderid, file, contentDisposition.FileName);
|
|
fileNames.Add(uploadedFile.Title);
|
|
}
|
|
|
|
return uploadedFile;
|
|
}
|
|
|
|
private FileWrapper<int> SaveFile(int folderid, Stream file, string fileName)
|
|
{
|
|
var resultFile = _fileUploader.Exec<int>(folderid, fileName, file.Length, file);
|
|
|
|
return _fileWrapperHelper.Get<int>(resultFile);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates the event with the parameters specified in the request
|
|
/// </summary>
|
|
/// <short>
|
|
/// Create event
|
|
/// </short>
|
|
/// <category>History</category>
|
|
/// <param optional="true" name="contactId">Contact ID</param>
|
|
/// <param optional="true" name="entityType" remark="Allowed values: opportunity or case">Related entity type</param>
|
|
/// <param optional="true" name="entityId">Related entity ID</param>
|
|
/// <remarks>
|
|
/// <![CDATA[
|
|
/// You should obligatorily set the value for 'contactId' if 'entityId' is not set or the value for parameters 'entityId' and 'entityType' if 'contactId' is not set.
|
|
/// ]]>
|
|
/// </remarks>
|
|
/// <param optional="false" name="content">Contents</param>
|
|
/// <param optional="false" name="categoryId">Category ID</param>
|
|
/// <param optional="true" name="created">Event creation date</param>
|
|
/// <param optional="true" name="fileId">List of IDs of the files associated with the event</param>
|
|
/// <param optional="true" name="notifyUserList">User field list</param>
|
|
/// <returns>
|
|
/// Created event
|
|
/// </returns>
|
|
[Create(@"history")]
|
|
public RelationshipEventDto AddHistoryTo([FromForm] AddHistoryToRequestDto inDto)
|
|
{
|
|
string entityType = inDto.EntityType;
|
|
int entityId = inDto.EntityId;
|
|
int contactId = inDto.ContactId;
|
|
string content = inDto.Content;
|
|
int categoryId = inDto.CategoryId;
|
|
ApiDateTime created = inDto.Created;
|
|
IEnumerable<int> fileId = inDto.FileId;
|
|
IEnumerable<Guid> notifyUserList = inDto.NotifyUserList;
|
|
|
|
if (!string.IsNullOrEmpty(entityType) &&
|
|
!(
|
|
string.Compare(entityType, "opportunity", StringComparison.OrdinalIgnoreCase) == 0 ||
|
|
string.Compare(entityType, "case", StringComparison.OrdinalIgnoreCase) == 0)
|
|
)
|
|
throw new ArgumentException();
|
|
|
|
var entityTypeObj = ToEntityType(entityType);
|
|
|
|
var entityTitle = "";
|
|
if (contactId > 0)
|
|
{
|
|
var contact = _daoFactory.GetContactDao().GetByID(contactId);
|
|
if (contact == null || !_crmSecurity.CanAccessTo(contact))
|
|
throw new ArgumentException();
|
|
entityTitle = contact.GetTitle();
|
|
}
|
|
|
|
if (entityTypeObj == EntityType.Case)
|
|
{
|
|
var cases = _daoFactory.GetCasesDao().GetByID(entityId);
|
|
if (cases == null || !_crmSecurity.CanAccessTo(cases))
|
|
throw new ArgumentException();
|
|
if (contactId <= 0)
|
|
{
|
|
entityTitle = cases.Title;
|
|
}
|
|
}
|
|
if (entityTypeObj == EntityType.Opportunity)
|
|
{
|
|
var deal = _daoFactory.GetDealDao().GetByID(entityId);
|
|
if (deal == null || !_crmSecurity.CanAccessTo(deal))
|
|
throw new ArgumentException();
|
|
if (contactId <= 0)
|
|
{
|
|
entityTitle = deal.Title;
|
|
}
|
|
}
|
|
|
|
var relationshipEvent = new RelationshipEvent
|
|
{
|
|
CategoryID = categoryId,
|
|
EntityType = entityTypeObj,
|
|
EntityID = entityId,
|
|
Content = content,
|
|
ContactID = contactId,
|
|
CreateOn = created,
|
|
CreateBy = _securityContext.CurrentAccount.ID
|
|
};
|
|
|
|
var category = _daoFactory.GetListItemDao().GetByID(categoryId);
|
|
if (category == null) throw new ArgumentException();
|
|
|
|
var item = _daoFactory.GetRelationshipEventDao().CreateItem(relationshipEvent);
|
|
|
|
|
|
notifyUserList = notifyUserList != null ? notifyUserList.ToList() : new List<Guid>();
|
|
var needNotify = notifyUserList.Any();
|
|
|
|
var fileListInfoHashtable = new Hashtable();
|
|
|
|
if (fileId != null)
|
|
{
|
|
var fileIds = fileId.ToList();
|
|
var files = _filesDaoFactory.GetFileDao<int>().GetFiles(fileIds.ToArray());
|
|
|
|
if (needNotify)
|
|
{
|
|
foreach (var file in files)
|
|
{
|
|
var extension = Path.GetExtension(file.Title);
|
|
if (extension == null) continue;
|
|
|
|
var fileInfo = string.Format("{0} ({1})", file.Title, extension.ToUpper());
|
|
if (!fileListInfoHashtable.ContainsKey(fileInfo))
|
|
{
|
|
fileListInfoHashtable.Add(fileInfo, file.DownloadUrl);
|
|
}
|
|
else
|
|
{
|
|
fileInfo = string.Format("{0} ({1}, {2})", file.Title, extension.ToUpper(), file.UniqID);
|
|
fileListInfoHashtable.Add(fileInfo, file.DownloadUrl);
|
|
}
|
|
}
|
|
}
|
|
|
|
_daoFactory.GetRelationshipEventDao().AttachFiles(item.ID, fileIds.ToArray());
|
|
|
|
if (files.Any())
|
|
{
|
|
var fileAttachAction = GetFilesAttachAction(entityTypeObj, contactId);
|
|
|
|
_messageService.Send(fileAttachAction, _messageTarget.Create(item.ID), entityTitle, files.Select(x => x.Title));
|
|
}
|
|
}
|
|
|
|
if (needNotify)
|
|
{
|
|
_notifyClient.SendAboutAddRelationshipEventAdd(item, fileListInfoHashtable, _daoFactory, notifyUserList.ToArray());
|
|
}
|
|
|
|
var historyCreatedAction = GetHistoryCreatedAction(entityTypeObj, contactId);
|
|
|
|
_messageService.Send(historyCreatedAction, _messageTarget.Create(item.ID), entityTitle, category.Title);
|
|
|
|
return _mapper.Map<RelationshipEventDto>(item);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Associates the selected file(s) with the entity with the ID or type specified in the request
|
|
/// </summary>
|
|
/// <short>
|
|
/// Associate file with entity
|
|
/// </short>
|
|
/// <param name="entityType">Entity type</param>
|
|
/// <param name="entityid">Entity ID</param>
|
|
/// <param name="fileids">List of IDs of the files</param>
|
|
/// <category>Files</category>
|
|
/// <returns>Entity with the file attached</returns>
|
|
[Create(@"{entityType:regex(contact|opportunity|case)}/{entityid:int}/files")]
|
|
public RelationshipEventDto AttachFiles(
|
|
[FromRoute] string entityType,
|
|
[FromRoute] int entityid,
|
|
[FromForm] IEnumerable<int> fileids)
|
|
{
|
|
if (entityid <= 0 || fileids == null) throw new ArgumentException();
|
|
|
|
var files = _filesDaoFactory.GetFileDao<int>().GetFiles(fileids.ToArray());
|
|
|
|
var folderid = GetRootFolderID();
|
|
|
|
if (files.Exists(file => file.FolderID.ToString() != folderid.ToString()))
|
|
throw new ArgumentException("invalid file folder");
|
|
|
|
var entityTypeObj = ToEntityType(entityType);
|
|
|
|
DomainObject entityObj;
|
|
|
|
var entityTitle = GetEntityTitle(entityTypeObj, entityid, true, out entityObj);
|
|
|
|
switch (entityTypeObj)
|
|
{
|
|
case EntityType.Contact:
|
|
var relationshipEvent1 = _daoFactory.GetRelationshipEventDao().AttachFiles(entityid, EntityType.Any, 0, fileids.ToArray());
|
|
var messageAction = entityObj is Company ? MessageAction.CompanyAttachedFiles : MessageAction.PersonAttachedFiles;
|
|
_messageService.Send(messageAction, _messageTarget.Create(entityid), entityTitle, files.Select(x => x.Title));
|
|
return _mapper.Map<RelationshipEventDto>(relationshipEvent1);
|
|
case EntityType.Opportunity:
|
|
var relationshipEvent2 = _daoFactory.GetRelationshipEventDao().AttachFiles(0, entityTypeObj, entityid, fileids.ToArray());
|
|
_messageService.Send(MessageAction.OpportunityAttachedFiles, _messageTarget.Create(entityid), entityTitle, files.Select(x => x.Title));
|
|
return _mapper.Map<RelationshipEventDto>(relationshipEvent2);
|
|
case EntityType.Case:
|
|
var relationshipEvent3 = _daoFactory.GetRelationshipEventDao().AttachFiles(0, entityTypeObj, entityid, fileids.ToArray());
|
|
_messageService.Send(MessageAction.CaseAttachedFiles, _messageTarget.Create(entityid), entityTitle, files.Select(x => x.Title));
|
|
return _mapper.Map<RelationshipEventDto>(relationshipEvent3);
|
|
default:
|
|
throw new ArgumentException();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the ID for the root folder used to store the files for the CRM module
|
|
/// </summary>
|
|
/// <short>Get root folder ID</short>
|
|
/// <category>Files</category>
|
|
/// <returns>
|
|
/// Root folder ID
|
|
/// </returns>
|
|
[Read(@"files/root")]
|
|
public int GetRootFolderID()
|
|
{
|
|
return _daoFactory.GetFileDao().GetRoot();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the list of all files for the entity with the ID or type specified in the request
|
|
/// </summary>
|
|
/// <param name="entityType">Entity type</param>
|
|
/// <param name="entityid">Entity ID</param>
|
|
/// <short>Get file list</short>
|
|
/// <category>Files</category>
|
|
/// <returns>
|
|
/// File list
|
|
/// </returns>
|
|
[Read(@"{entityType:regex(contact|opportunity|case)}/{entityid:int}/files")]
|
|
public IEnumerable<FileWrapper<int>> GetFiles(string entityType, int entityid)
|
|
{
|
|
if (entityid <= 0) throw new ArgumentException();
|
|
|
|
var entityTypeObj = ToEntityType(entityType);
|
|
|
|
switch (entityTypeObj)
|
|
{
|
|
case EntityType.Contact:
|
|
return _daoFactory.GetRelationshipEventDao().GetAllFiles(new[] { entityid }, EntityType.Any, 0).ConvertAll(file => _fileWrapperHelper.Get<int>(file));
|
|
case EntityType.Opportunity:
|
|
case EntityType.Case:
|
|
return _daoFactory.GetRelationshipEventDao().GetAllFiles(null, entityTypeObj, entityid).ConvertAll(file => _fileWrapperHelper.Get<int>(file));
|
|
default:
|
|
throw new ArgumentException();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes the file with the ID specified in the request
|
|
/// </summary>
|
|
/// <short>Delete file</short>
|
|
/// <category>Files</category>
|
|
/// <param name="fileid">File ID</param>
|
|
/// <exception cref="ArgumentException"></exception>
|
|
/// <exception cref="ItemNotFoundException"></exception>
|
|
/// <returns>
|
|
/// File Info
|
|
/// </returns>
|
|
[Delete(@"files/{fileid:int}")]
|
|
public FileWrapper<int> DeleteCRMFile(int fileid)
|
|
{
|
|
if (fileid < 0) throw new ArgumentException();
|
|
|
|
var file = _filesDaoFactory.GetFileDao<int>().GetFile(fileid);
|
|
if (file == null) throw new ItemNotFoundException();
|
|
var result = _fileWrapperHelper.Get<int>(file);
|
|
|
|
var _eventsDao = _daoFactory.GetRelationshipEventDao();
|
|
var eventIDs = _eventsDao.RemoveFile(file);
|
|
var events = new List<RelationshipEvent>();
|
|
|
|
eventIDs.ForEach(id => events.Add(_eventsDao.GetByID(id)));
|
|
|
|
foreach (var evt in events)
|
|
{
|
|
DomainObject entityObj;
|
|
var entityTitle = evt.ContactID > 0
|
|
? GetEntityTitle(EntityType.Contact, evt.ContactID, false, out entityObj)
|
|
: GetEntityTitle(evt.EntityType, evt.EntityID, false, out entityObj);
|
|
var messageAction = GetFilesDetachAction(evt.EntityType, evt.ContactID);
|
|
|
|
_messageService.Send(messageAction, _messageTarget.Create(file.ID), entityTitle, file.Title);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private IEnumerable<RelationshipEventDto> ToListRelationshipEventDto(List<RelationshipEvent> itemList)
|
|
{
|
|
if (itemList.Count == 0) return new List<RelationshipEventDto>();
|
|
|
|
var result = new List<RelationshipEventDto>();
|
|
|
|
var contactIDs = new List<int>();
|
|
var eventIDs = new List<int>();
|
|
var categoryIDs = new List<int>();
|
|
var entityDtosIDs = new Dictionary<EntityType, List<int>>();
|
|
|
|
|
|
foreach (var item in itemList)
|
|
{
|
|
eventIDs.Add(item.ID);
|
|
|
|
if (!categoryIDs.Contains(item.CategoryID))
|
|
{
|
|
categoryIDs.Add(item.CategoryID);
|
|
}
|
|
|
|
if (item.ContactID > 0 && !contactIDs.Contains(item.ContactID))
|
|
{
|
|
contactIDs.Add(item.ContactID);
|
|
}
|
|
|
|
if (item.EntityID <= 0) continue;
|
|
|
|
if (!entityDtosIDs.ContainsKey(item.EntityType))
|
|
{
|
|
entityDtosIDs.Add(item.EntityType, new List<int>
|
|
{
|
|
item.EntityID
|
|
});
|
|
}
|
|
else if (!entityDtosIDs[item.EntityType].Contains(item.EntityID))
|
|
{
|
|
entityDtosIDs[item.EntityType].Add(item.EntityID);
|
|
}
|
|
}
|
|
|
|
var entityDtos = new Dictionary<string, EntityDto>();
|
|
|
|
foreach (var entityType in entityDtosIDs.Keys)
|
|
{
|
|
switch (entityType)
|
|
{
|
|
case EntityType.Opportunity:
|
|
_daoFactory.GetDealDao().GetDeals(entityDtosIDs[entityType].Distinct().ToArray())
|
|
.ForEach(item =>
|
|
{
|
|
if (item == null) return;
|
|
|
|
entityDtos.Add(
|
|
string.Format("{0}_{1}", (int)entityType, item.ID),
|
|
new EntityDto
|
|
{
|
|
EntityId = item.ID,
|
|
EntityTitle = item.Title,
|
|
EntityType = "opportunity"
|
|
});
|
|
});
|
|
break;
|
|
case EntityType.Case:
|
|
_daoFactory.GetCasesDao().GetByID(entityDtosIDs[entityType].ToArray())
|
|
.ForEach(item =>
|
|
{
|
|
if (item == null) return;
|
|
|
|
entityDtos.Add(
|
|
string.Format("{0}_{1}", (int)entityType, item.ID),
|
|
new EntityDto
|
|
{
|
|
EntityId = item.ID,
|
|
EntityTitle = item.Title,
|
|
EntityType = "case"
|
|
});
|
|
});
|
|
break;
|
|
default:
|
|
throw new ArgumentException();
|
|
}
|
|
}
|
|
|
|
var categories = _daoFactory.GetListItemDao().GetItems(categoryIDs.ToArray()).ToDictionary(x => x.ID, x => _mapper.Map<HistoryCategoryDto>(x));
|
|
|
|
var files = _daoFactory.GetRelationshipEventDao().GetFiles(eventIDs.ToArray());
|
|
|
|
var contacts = _daoFactory.GetContactDao().GetContacts(contactIDs.ToArray()).ToDictionary(item => item.ID, x => _mapper.Map<ContactBaseDto>(x));
|
|
|
|
foreach (var item in itemList)
|
|
{
|
|
var eventObjWrap = _mapper.Map<RelationshipEventDto>(item);
|
|
|
|
if (contacts.ContainsKey(item.ContactID))
|
|
{
|
|
eventObjWrap.Contact = contacts[item.ContactID];
|
|
}
|
|
|
|
if (item.EntityID > 0)
|
|
{
|
|
var entityStrKey = string.Format("{0}_{1}", (int)item.EntityType, item.EntityID);
|
|
|
|
if (entityDtos.ContainsKey(entityStrKey))
|
|
{
|
|
eventObjWrap.Entity = entityDtos[entityStrKey];
|
|
}
|
|
}
|
|
|
|
eventObjWrap.Files = files.ContainsKey(item.ID) ? files[item.ID].ConvertAll(file =>
|
|
_fileWrapperHelper.Get<int>(file)) : new List<FileWrapper<int>>();
|
|
|
|
if (categories.ContainsKey(item.CategoryID))
|
|
{
|
|
eventObjWrap.Category = categories[item.CategoryID];
|
|
}
|
|
|
|
result.Add(eventObjWrap);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
private MessageAction GetHistoryCreatedAction(EntityType entityType, int contactId)
|
|
{
|
|
if (contactId > 0)
|
|
{
|
|
var contact = _daoFactory.GetContactDao().GetByID(contactId);
|
|
return contact is Company ? MessageAction.CompanyCreatedHistoryEvent : MessageAction.PersonCreatedHistoryEvent;
|
|
}
|
|
|
|
switch (entityType)
|
|
{
|
|
case EntityType.Opportunity:
|
|
return MessageAction.OpportunityCreatedHistoryEvent;
|
|
case EntityType.Case:
|
|
return MessageAction.CaseCreatedHistoryEvent;
|
|
case EntityType.Any:
|
|
var contact = _daoFactory.GetContactDao().GetByID(contactId);
|
|
return contact is Company ? MessageAction.CompanyCreatedHistoryEvent : MessageAction.PersonCreatedHistoryEvent;
|
|
default:
|
|
throw new ArgumentException("Invalid entityType: " + entityType);
|
|
}
|
|
}
|
|
|
|
private MessageAction GetHistoryDeletedAction(EntityType entityType, int contactId)
|
|
{
|
|
if (contactId > 0)
|
|
{
|
|
var contact = _daoFactory.GetContactDao().GetByID(contactId);
|
|
return contact is Company ? MessageAction.CompanyDeletedHistoryEvent : MessageAction.PersonDeletedHistoryEvent;
|
|
}
|
|
|
|
switch (entityType)
|
|
{
|
|
case EntityType.Opportunity:
|
|
return MessageAction.OpportunityDeletedHistoryEvent;
|
|
case EntityType.Case:
|
|
return MessageAction.CaseDeletedHistoryEvent;
|
|
case EntityType.Any:
|
|
var contact = _daoFactory.GetContactDao().GetByID(contactId);
|
|
return contact is Company ? MessageAction.CompanyDeletedHistoryEvent : MessageAction.PersonDeletedHistoryEvent;
|
|
default:
|
|
throw new ArgumentException("Invalid entityType: " + entityType);
|
|
}
|
|
}
|
|
|
|
private MessageAction GetFilesAttachAction(EntityType entityType, int contactId)
|
|
{
|
|
if (contactId > 0)
|
|
{
|
|
var contact = _daoFactory.GetContactDao().GetByID(contactId);
|
|
return contact is Company ? MessageAction.CompanyAttachedFiles : MessageAction.PersonAttachedFiles;
|
|
}
|
|
|
|
switch (entityType)
|
|
{
|
|
case EntityType.Opportunity:
|
|
return MessageAction.OpportunityAttachedFiles;
|
|
case EntityType.Case:
|
|
return MessageAction.CaseAttachedFiles;
|
|
case EntityType.Any:
|
|
var contact = _daoFactory.GetContactDao().GetByID(contactId);
|
|
return contact is Company ? MessageAction.CompanyAttachedFiles : MessageAction.PersonAttachedFiles;
|
|
default:
|
|
throw new ArgumentException("Invalid entityType: " + entityType);
|
|
}
|
|
}
|
|
|
|
private MessageAction GetFilesDetachAction(EntityType entityType, int contactId)
|
|
{
|
|
if (contactId > 0)
|
|
{
|
|
var contact = _daoFactory.GetContactDao().GetByID(contactId);
|
|
return contact is Company ? MessageAction.CompanyDetachedFile : MessageAction.PersonDetachedFile;
|
|
}
|
|
|
|
switch (entityType)
|
|
{
|
|
case EntityType.Opportunity:
|
|
return MessageAction.OpportunityDetachedFile;
|
|
case EntityType.Case:
|
|
return MessageAction.CaseDetachedFile;
|
|
case EntityType.Any:
|
|
var contact = _daoFactory.GetContactDao().GetByID(contactId);
|
|
return contact is Company ? MessageAction.CompanyDetachedFile : MessageAction.PersonAttachedFiles;
|
|
default:
|
|
throw new ArgumentException("Invalid entityType: " + entityType);
|
|
}
|
|
}
|
|
}
|
|
} |