public List <CrmContactData> GetLinkedCrmEntitiesId(int messageId)
{
using (var daoFactory = new DaoFactory())
{
var daoCrmLink = daoFactory.CreateCrmLinkDao(Tenant, User);
var daoMail = daoFactory.CreateMailDao(Tenant, User);
var mail = daoMail.GetMail(new ConcreteUserMessageExp(messageId, Tenant, User));
return(daoCrmLink.GetLinkedCrmContactEntities(mail.ChainId, mail.MailboxId));
}
}
public void UnmarkChainAsCrmLinked(int messageId, IEnumerable <CrmContactData> contactIds)
{
using (var daoFactory = new DaoFactory())
{
var db = daoFactory.DbManager;
var daoCrmLink = daoFactory.CreateCrmLinkDao(Tenant, User);
using (var tx = db.BeginTransaction(IsolationLevel.ReadUncommitted))
{
var daoMail = daoFactory.CreateMailDao(Tenant, User);
var mail = daoMail.GetMail(new ConcreteUserMessageExp(messageId, Tenant, User));
daoCrmLink.RemoveCrmLinks(mail.ChainId, mail.MailboxId, contactIds);
tx.Commit();
}
}
}
public void AddRelationshipEventForLinkedAccounts(MailBoxData mailbox, MailMessageData messageItem, string httpContextScheme)
{
try
{
using (var daoFactory = new DaoFactory())
{
var dao = daoFactory.CreateCrmLinkDao(mailbox.TenantId, mailbox.UserId);
messageItem.LinkedCrmEntityIds = dao.GetLinkedCrmContactEntities(messageItem.ChainId, mailbox.MailBoxId);
}
if (!messageItem.LinkedCrmEntityIds.Any())
{
return;
}
AddRelationshipEvents(messageItem, httpContextScheme);
}
catch (Exception ex)
{
Log.Warn(string.Format("Problem with adding history event to CRM. mailId={0}", messageItem.Id), ex);
}
}
public MailMessage Save(MailComposeBase compose)
{
var embededAttachmentsForSaving = FixHtmlBodyWithEmbeddedAttachments(compose);
var message = compose.ToMailMessage();
var engine = new EngineFactory(compose.Mailbox.TenantId, compose.Mailbox.UserId);
var addIndex = compose.Id == 0;
var attachmentsToRestore = message.Attachments.Where(att => att.streamId != message.StreamId || att.isTemp).ToList();
var needRestoreAttachments = attachmentsToRestore.Any();
if (needRestoreAttachments)
{
message.Attachments.ForEach(
attachment =>
engine.AttachmentEngine.StoreAttachmentCopy(compose.Mailbox.TenantId, compose.Mailbox.UserId,
attachment, compose.StreamId));
}
MessageEngine.StoreMailBody(compose.Mailbox, message, Log);
long usedQuota;
using (var daoFactory = new DaoFactory())
{
var db = daoFactory.DbManager;
using (var tx = db.BeginTransaction(IsolationLevel.ReadUncommitted))
{
compose.Id = engine.MessageEngine.MailSave(daoFactory, compose.Mailbox, message, compose.Id, message.Folder, message.Folder, null,
string.Empty, string.Empty, false, out usedQuota);
message.Id = compose.Id;
if (compose.AccountChanged)
{
engine.ChainEngine.UpdateChain(daoFactory, message.ChainId, message.Folder, null, compose.PreviousMailboxId,
compose.Mailbox.TenantId, compose.Mailbox.UserId);
}
var daoMailInfo = daoFactory.CreateMailInfoDao(compose.Mailbox.TenantId, compose.Mailbox.UserId);
if (compose.Id > 0 && needRestoreAttachments)
{
var daoAttachment = daoFactory.CreateAttachmentDao(compose.Mailbox.TenantId, compose.Mailbox.UserId);
var existingAttachments = daoAttachment.GetAttachments(
new ConcreteMessageAttachmentsExp(compose.Id, compose.Mailbox.TenantId, compose.Mailbox.UserId));
foreach (var attachment in message.Attachments)
{
if (existingAttachments.Any(x => x.Id == attachment.fileId))
{
continue;
}
var attach = attachment.ToAttachmnet(compose.Id);
attach.Id = 0;
var newId = daoAttachment.SaveAttachment(attach);
attachment.fileId = newId;
}
if (message.Attachments.Any())
{
var count = daoAttachment.GetAttachmentsCount(
new ConcreteMessageAttachmentsExp(compose.Id, compose.Mailbox.TenantId, compose.Mailbox.UserId));
daoMailInfo.SetFieldValue(
SimpleMessagesExp.CreateBuilder(compose.Mailbox.TenantId, compose.Mailbox.UserId)
.SetMessageId(compose.Id)
.Build(),
MailTable.Columns.AttachCount,
count);
}
}
if (compose.Id > 0 && embededAttachmentsForSaving.Any())
{
var daoAttachment = daoFactory.CreateAttachmentDao(compose.Mailbox.TenantId, compose.Mailbox.UserId);
foreach (var attachment in embededAttachmentsForSaving)
{
var newId = daoAttachment.SaveAttachment(attachment.ToAttachmnet(compose.Id));
attachment.fileId = newId;
}
if (message.Attachments.Any())
{
var count = daoAttachment.GetAttachmentsCount(
new ConcreteMessageAttachmentsExp(compose.Id, compose.Mailbox.TenantId, compose.Mailbox.UserId));
daoMailInfo.SetFieldValue(
SimpleMessagesExp.CreateBuilder(compose.Mailbox.TenantId, compose.Mailbox.UserId)
.SetMessageId(compose.Id)
.Build(),
MailTable.Columns.AttachCount,
count);
}
}
engine.ChainEngine.UpdateChain(daoFactory, message.ChainId, message.Folder, null, compose.Mailbox.MailBoxId, compose.Mailbox.TenantId,
compose.Mailbox.UserId);
if (compose.AccountChanged)
{
var daoCrmLink = daoFactory.CreateCrmLinkDao(compose.Mailbox.TenantId, compose.Mailbox.UserId);
daoCrmLink.UpdateCrmLinkedMailboxId(message.ChainId, compose.PreviousMailboxId,
compose.Mailbox.MailBoxId);
}
tx.Commit();
}
}
if (usedQuota > 0)
{
engine.QuotaEngine.QuotaUsedDelete(usedQuota);
}
if (addIndex)
{
engine.IndexEngine.Add(message.ToMailWrapper(compose.Mailbox.TenantId, new Guid(compose.Mailbox.UserId)));
}
else
{
engine.IndexEngine.Update(new List <MailWrapper>
{
message.ToMailWrapper(compose.Mailbox.TenantId,
new Guid(compose.Mailbox.UserId))
});
}
try
{
var tempStorage = MailDataStore.GetDataStore(compose.Mailbox.TenantId);
tempStorage.DeleteDirectory("attachments_temp", compose.Mailbox.UserId + "/" + compose.StreamId + "/");
}
catch (Exception ex)
{
Log.ErrorFormat("Clearing temp storage failed with exception: {0}", ex.ToString());
}
return(message);
}
private void ReleaseSendingDraftOnSuccess(MailDraftData draft, MailMessage message)
{
var engine = new EngineFactory(draft.Mailbox.TenantId, draft.Mailbox.UserId);
using (var daoFactory = new DaoFactory())
{
var db = daoFactory.DbManager;
using (var tx = db.BeginTransaction(IsolationLevel.ReadUncommitted))
{
// message was correctly send - lets update its chains id
var draftChainId = message.ChainId;
// before moving message from draft to sent folder - lets recalculate its correct chain id
var chainInfo = engine.MessageEngine.DetectChain(daoFactory, draft.Mailbox,
message.MimeMessageId, message.MimeReplyToId, message.Subject);
message.ChainId = chainInfo.Id;
if (message.ChainId.Equals(message.MimeMessageId))
{
message.MimeReplyToId = null;
}
var daoMailInfo = daoFactory.CreateMailInfoDao(draft.Mailbox.TenantId, draft.Mailbox.UserId);
if (!draftChainId.Equals(message.ChainId))
{
daoMailInfo.SetFieldValue(
SimpleMessagesExp.CreateBuilder(Tenant, User)
.SetMessageId(message.Id)
.Build(),
MailTable.Columns.ChainId,
message.ChainId);
engine.ChainEngine.UpdateChain(daoFactory, draftChainId, FolderType.Sending, null, draft.Mailbox.MailBoxId,
draft.Mailbox.TenantId, draft.Mailbox.UserId);
var daoCrmLink = daoFactory.CreateCrmLinkDao(draft.Mailbox.TenantId, draft.Mailbox.UserId);
daoCrmLink.UpdateCrmLinkedChainId(draftChainId, draft.Mailbox.MailBoxId, message.ChainId);
}
engine.ChainEngine.UpdateChain(daoFactory, message.ChainId, FolderType.Sending, null, draft.Mailbox.MailBoxId,
draft.Mailbox.TenantId, draft.Mailbox.UserId);
var listObjects = engine.ChainEngine.GetChainedMessagesInfo(daoFactory, new List <int> {
draft.Id
});
if (!listObjects.Any())
{
return;
}
engine.MessageEngine.SetFolder(daoFactory, listObjects, FolderType.Sent);
daoMailInfo.SetFieldValue(
SimpleMessagesExp.CreateBuilder(Tenant, User)
.SetMessageId(draft.Id)
.Build(),
MailTable.Columns.FolderRestore,
FolderType.Sent);
tx.Commit();
}
}
}
public void LinkChainToCrm(int messageId, List <CrmContactData> contactIds, string httpContextScheme)
{
using (var scope = DIHelper.Resolve())
{
var factory = scope.Resolve <CRM.Core.Dao.DaoFactory>();
foreach (var crmContactEntity in contactIds)
{
switch (crmContactEntity.Type)
{
case CrmContactData.EntityTypes.Contact:
var crmContact = factory.ContactDao.GetByID(crmContactEntity.Id);
CRMSecurity.DemandAccessTo(crmContact);
break;
case CrmContactData.EntityTypes.Case:
var crmCase = factory.CasesDao.GetByID(crmContactEntity.Id);
CRMSecurity.DemandAccessTo(crmCase);
break;
case CrmContactData.EntityTypes.Opportunity:
var crmOpportunity = factory.DealDao.GetByID(crmContactEntity.Id);
CRMSecurity.DemandAccessTo(crmOpportunity);
break;
}
}
}
using (var daoFactory = new DaoFactory())
{
var db = daoFactory.DbManager;
var daoMail = daoFactory.CreateMailDao(Tenant, User);
var mail = daoMail.GetMail(new ConcreteUserMessageExp(messageId, Tenant, User));
var daoMailInfo = daoFactory.CreateMailInfoDao(Tenant, User);
var chainedMessages = daoMailInfo.GetMailInfoList(
SimpleMessagesExp.CreateBuilder(Tenant, User)
.SetChainId(mail.ChainId)
.Build());
if (!chainedMessages.Any())
{
return;
}
var linkingMessages = new List <MailMessageData>();
var engine = new EngineFactory(Tenant, User);
foreach (var chainedMessage in chainedMessages)
{
var message = engine.MessageEngine.GetMessage(chainedMessage.Id,
new MailMessageData.Options
{
LoadImages = true,
LoadBody = true,
NeedProxyHttp = false
});
message.LinkedCrmEntityIds = contactIds;
linkingMessages.Add(message);
}
var daoCrmLink = daoFactory.CreateCrmLinkDao(Tenant, User);
using (var tx = db.BeginTransaction(IsolationLevel.ReadUncommitted))
{
daoCrmLink.SaveCrmLinks(mail.ChainId, mail.MailboxId, contactIds);
foreach (var message in linkingMessages)
{
try
{
AddRelationshipEvents(message, httpContextScheme);
}
catch (ApiHelperException ex)
{
if (!ex.Message.Equals("Already exists"))
{
throw;
}
}
}
tx.Commit();
}
}
}
public MailMessage Save(MailComposeBase draft)
{
var embededAttachmentsForSaving = FixHtmlBodyWithEmbeddedAttachments(draft);
var message = draft.ToMailMessage();
var engine = new EngineFactory(draft.Mailbox.TenantId, draft.Mailbox.UserId);
var addIndex = draft.Id == 0;
var needRestoreAttachments = draft.Id == 0 && message.Attachments.Any();
if (needRestoreAttachments)
{
message.Attachments.ForEach(
attachment =>
engine.AttachmentEngine.StoreAttachmentCopy(draft.Mailbox.TenantId, draft.Mailbox.UserId,
attachment, draft.StreamId));
}
MessageEngine.StoreMailBody(draft.Mailbox, message, Log);
long usedQuota;
using (var daoFactory = new DaoFactory())
{
var db = daoFactory.DbManager;
using (var tx = db.BeginTransaction(IsolationLevel.ReadUncommitted))
{
draft.Id = engine.MessageEngine.MailSave(daoFactory, draft.Mailbox, message, draft.Id, message.Folder, message.Folder, null,
string.Empty, string.Empty, false, out usedQuota);
message.Id = draft.Id;
if (draft.AccountChanged)
{
engine.ChainEngine.UpdateChain(daoFactory, message.ChainId, message.Folder, null, draft.PreviousMailboxId,
draft.Mailbox.TenantId, draft.Mailbox.UserId);
}
var daoMailInfo = daoFactory.CreateMailInfoDao(draft.Mailbox.TenantId, draft.Mailbox.UserId);
if (draft.Id > 0 && needRestoreAttachments)
{
var daoAttachment = daoFactory.CreateAttachmentDao(draft.Mailbox.TenantId, draft.Mailbox.UserId);
foreach (var attachment in message.Attachments)
{
var attach = attachment.ToAttachmnet(draft.Id);
attach.Id = 0;
var newId = daoAttachment.SaveAttachment(attach);
attachment.fileId = newId;
}
if (message.Attachments.Any())
{
var count = daoAttachment.GetAttachmentsCount(
new ConcreteMessageAttachmentsExp(draft.Id, draft.Mailbox.TenantId, draft.Mailbox.UserId));
daoMailInfo.SetFieldValue(
SimpleMessagesExp.CreateBuilder(draft.Mailbox.TenantId, draft.Mailbox.UserId)
.SetMessageId(draft.Id)
.Build(),
MailTable.Columns.AttachCount,
count);
}
}
if (draft.Id > 0 && embededAttachmentsForSaving.Any())
{
var daoAttachment = daoFactory.CreateAttachmentDao(draft.Mailbox.TenantId, draft.Mailbox.UserId);
foreach (var attachment in embededAttachmentsForSaving)
{
var newId = daoAttachment.SaveAttachment(attachment.ToAttachmnet(draft.Id));
attachment.fileId = newId;
}
if (message.Attachments.Any())
{
var count = daoAttachment.GetAttachmentsCount(
new ConcreteMessageAttachmentsExp(draft.Id, draft.Mailbox.TenantId, draft.Mailbox.UserId));
daoMailInfo.SetFieldValue(
SimpleMessagesExp.CreateBuilder(draft.Mailbox.TenantId, draft.Mailbox.UserId)
.SetMessageId(draft.Id)
.Build(),
MailTable.Columns.AttachCount,
count);
}
}
engine.ChainEngine.UpdateChain(daoFactory, message.ChainId, message.Folder, null, draft.Mailbox.MailBoxId, draft.Mailbox.TenantId,
draft.Mailbox.UserId);
if (draft.AccountChanged)
{
var daoCrmLink = daoFactory.CreateCrmLinkDao(draft.Mailbox.TenantId, draft.Mailbox.UserId);
daoCrmLink.UpdateCrmLinkedMailboxId(message.ChainId, draft.PreviousMailboxId,
draft.Mailbox.MailBoxId);
}
tx.Commit();
}
}
if (usedQuota > 0)
{
engine.QuotaEngine.QuotaUsedDelete(usedQuota);
}
if (addIndex)
{
engine.IndexEngine.Add(message.ToMailWrapper(draft.Mailbox.TenantId, new Guid(draft.Mailbox.UserId)));
}
else
{
engine.IndexEngine.Update(new List <MailWrapper>
{
message.ToMailWrapper(draft.Mailbox.TenantId,
new Guid(draft.Mailbox.UserId))
});
}
return(message);
}