public void DeleteMessageAttachments(int tenant, string user, int messageId, List <int> attachmentIds)
{
var engine = new EngineFactory(tenant, user);
long usedQuota;
int attachCount;
using (var daoFactory = new DaoFactory())
{
using (var tx = daoFactory.DbManager.BeginTransaction(IsolationLevel.ReadUncommitted))
{
var exp = new ConcreteMessageAttachmentsExp(messageId, tenant, user, attachmentIds,
onlyEmbedded: null);
var daoAttachment = daoFactory.CreateAttachmentDao(tenant, user);
usedQuota = daoAttachment.GetAttachmentsSize(exp);
daoAttachment.SetAttachmnetsRemoved(exp);
attachCount = daoAttachment.GetAttachmentsCount(
new ConcreteMessageAttachmentsExp(messageId, tenant, user));
var daoMailInfo = daoFactory.CreateMailInfoDao(tenant, user);
daoMailInfo.SetFieldValue(
SimpleMessagesExp.CreateBuilder(tenant, user)
.SetMessageId(messageId)
.Build(),
MailTable.Columns.AttachCount,
attachCount);
engine.ChainEngine.UpdateMessageChainAttachmentsFlag(daoFactory, tenant, user, messageId);
tx.Commit();
}
}
if (attachCount == 0)
{
var data = new MailWrapper
{
HasAttachments = false
};
engine.IndexEngine.Update(data, s => s.Where(m => m.Id, messageId), wrapper => wrapper.HasAttachments);
}
if (usedQuota <= 0)
{
return;
}
engine.QuotaEngine.QuotaUsedDelete(usedQuota);
}
public long GetAttachmentsSize(IAttachmentsExp exp)
{
using (var daoFactory = new DaoFactory())
{
var daoAttachment = daoFactory.CreateAttachmentDao(Tenant, User);
var size = daoAttachment.GetAttachmentsSize(exp);
return(size);
}
}
public List <MailAttachmentData> GetAttachments(IAttachmentsExp exp)
{
using (var daoFactory = new DaoFactory())
{
var daoAttachment = daoFactory.CreateAttachmentDao(Tenant, User);
var attachments = daoAttachment.GetAttachments(exp);
return(attachments.ConvertAll(ToAttachmentData));
}
}
public MailAttachmentData GetAttachment(IAttachmentExp exp)
{
using (var daoFactory = new DaoFactory())
{
var daoAttachment = daoFactory.CreateAttachmentDao(Tenant, User);
var attachment = daoAttachment.GetAttachment(exp);
return(ToAttachmentData(attachment));
}
}
public int GetAttachmentNextFileNumber(IAttachmentsExp exp)
{
using (var daoFactory = new DaoFactory())
{
var daoAttachment = daoFactory.CreateAttachmentDao(Tenant, User);
var number = daoAttachment.GetAttachmentsMaxFileNumber(exp);
number++;
return(number);
}
}
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);
}
public MailAttachmentData AttachFile(int tenant, string user, MailMessageData message,
string name, Stream inputStream, long contentLength, string contentType = null, bool needSaveToTemp = false)
{
if (message == null)
{
throw new AttachmentsException(AttachmentsException.Types.MessageNotFound, "Message not found.");
}
if (string.IsNullOrEmpty(message.StreamId))
{
throw new AttachmentsException(AttachmentsException.Types.MessageNotFound, "StreamId is empty.");
}
var messageId = message.Id;
var engine = new EngineFactory(tenant, user);
var totalSize =
engine.AttachmentEngine.GetAttachmentsSize(new ConcreteMessageAttachmentsExp(messageId, tenant, user));
totalSize += contentLength;
if (totalSize > Defines.ATTACHMENTS_TOTAL_SIZE_LIMIT)
{
throw new AttachmentsException(AttachmentsException.Types.TotalSizeExceeded,
"Total size of all files exceeds limit!");
}
var fileNumber =
engine.AttachmentEngine.GetAttachmentNextFileNumber(new ConcreteMessageAttachmentsExp(messageId, tenant,
user));
var attachment = new MailAttachmentData
{
fileName = name,
contentType = string.IsNullOrEmpty(contentType) ? MimeMapping.GetMimeMapping(name) : contentType,
needSaveToTemp = needSaveToTemp,
fileNumber = fileNumber,
size = contentLength,
data = inputStream.ReadToEnd(),
streamId = message.StreamId,
tenant = tenant,
user = user,
mailboxId = message.MailboxId
};
engine.QuotaEngine.QuotaUsedAdd(contentLength);
try
{
var storage = new StorageManager(tenant, user);
storage.StoreAttachmentWithoutQuota(attachment);
}
catch
{
engine.QuotaEngine.QuotaUsedDelete(contentLength);
throw;
}
if (!needSaveToTemp)
{
int attachCount;
using (var daoFactory = new DaoFactory())
{
var db = daoFactory.DbManager;
using (var tx = db.BeginTransaction())
{
var daoAttachment = daoFactory.CreateAttachmentDao(tenant, user);
attachment.fileId = daoAttachment.SaveAttachment(attachment.ToAttachmnet(messageId));
attachCount = daoAttachment.GetAttachmentsCount(
new ConcreteMessageAttachmentsExp(messageId, tenant, user));
var daoMailInfo = daoFactory.CreateMailInfoDao(tenant, user);
daoMailInfo.SetFieldValue(
SimpleMessagesExp.CreateBuilder(tenant, user)
.SetMessageId(messageId)
.Build(),
MailTable.Columns.AttachCount,
attachCount);
engine.ChainEngine.UpdateMessageChainAttachmentsFlag(daoFactory, tenant, user, messageId);
tx.Commit();
}
}
if (attachCount == 1)
{
var data = new MailWrapper
{
HasAttachments = true
};
engine.IndexEngine.Update(data, s => s.Where(m => m.Id, messageId), wrapper => wrapper.HasAttachments);
}
}
return(attachment);
}
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);
}
