public void ChangeEmbededAttachmentLinks(int tenant, string user)
{
var baseAttachmentFolder = MailStoragePathCombiner.GetMessageDirectory(user, StreamId);
var doc = new HtmlDocument();
doc.LoadHtml(HtmlBody);
var linkNodes = doc.DocumentNode.SelectNodes("//img[@src and (contains(@src,'" + baseAttachmentFolder + "'))]");
if (linkNodes == null)
{
return;
}
foreach (var linkNode in linkNodes)
{
var link = linkNode.Attributes["src"].Value;
_logger.Info("ChangeEmbededAttachmentLinks() Embeded attachment link for changing to cid: {0}", link);
var fileLink = HttpUtility.UrlDecode(link.Substring(baseAttachmentFolder.Length));
var fileName = Path.GetFileName(fileLink);
var attach = CreateEmbbededAttachment(fileName, link, fileLink, user, tenant, MailboxId);
AttachmentsEmbedded.Add(attach);
linkNode.SetAttributeValue("src", "cid:" + attach.contentId);
_logger.Info("ChangeEmbededAttachmentLinks() Attachment cid: {0}", attach.contentId);
}
HtmlBody = doc.DocumentNode.OuterHtml;
}
public string StoreMailBody(int id_tenant, string id_user, MailMessageItem mail)
{
if (string.IsNullOrEmpty(mail.HtmlBody))
{
return(string.Empty);
}
// Using id_user as domain in S3 Storage - allows not to add quota to tenant.
var save_path = MailStoragePathCombiner.GetBodyKey(id_user, mail.StreamId);
var storage = MailDataStore.GetDataStore(id_tenant);
try
{
var safe_body = ReplaceEmbeddedImages(mail);
using (var reader = new MemoryStream(Encoding.UTF8.GetBytes(safe_body)))
{
var res = storage
.UploadWithoutQuota(string.Empty, save_path, reader, "text/html", string.Empty)
.ToString();
_log.Debug("StoreMailBody() tenant='{0}', user_id='{1}', save_body_path='{2}' Result: {3}",
id_tenant, id_user, save_path, res);
return(res);
}
}
catch (Exception)
{
storage.Delete(string.Empty, save_path);
_log.Debug(String.Format("StoreMailBody() Problems with message saving in messageId={0}. Body was deleted.", mail.MimeMessageId));
throw;
}
}
public string StoreMailEml(int tenant, string user, string streamId, MimeMessage message, ILogger log)
{
if (message == null)
{
return(string.Empty);
}
// Using id_user as domain in S3 Storage - allows not to add quota to tenant.
var savePath = MailStoragePathCombiner.GetEmlKey(user, streamId);
var storage = MailDataStore.GetDataStore(tenant);
try
{
using (var stream = new MemoryStream())
{
message.WriteTo(stream);
var res = storage.Save(savePath, stream, MailStoragePathCombiner.EML_FILE_NAME).ToString();
log.Debug("StoreMailEml() tenant='{0}', user_id='{1}', save_eml_path='{2}' Result: {3}", tenant, user, savePath, res);
return(res);
}
}
catch (Exception ex)
{
log.Error("StoreMailEml Exception: {0}", ex.ToString());
}
return(string.Empty);
}
private static MimePart ConvertToMimePart(MailAttachmentData mailAttachmentData, string contentId = null)
{
var contentType = ContentType.Parse(
!string.IsNullOrEmpty(mailAttachmentData.contentType)
? mailAttachmentData.contentType
: MimeMapping.GetMimeMapping(mailAttachmentData.fileName));
var mimePart = new MimePart(contentType)
{
ContentTransferEncoding = ContentEncoding.Base64,
FileName = mailAttachmentData.fileName
};
if (string.IsNullOrEmpty(contentId))
{
mimePart.ContentDisposition = new ContentDisposition(ContentDisposition.Attachment);
}
else
{
mimePart.ContentDisposition = new ContentDisposition(ContentDisposition.Inline);
mimePart.ContentId = contentId;
mimePart.ContentType.Name = mailAttachmentData.fileName;
}
MemoryStream ms;
if (mailAttachmentData.data == null)
{
var s3Key = MailStoragePathCombiner.GerStoredFilePath(mailAttachmentData);
ms = new MemoryStream();
using (var stream = StorageManager
.GetDataStoreForAttachments(mailAttachmentData.tenant)
.GetReadStream(s3Key))
{
stream.StreamCopyTo(ms);
}
}
else
{
ms = new MemoryStream(mailAttachmentData.data);
}
mimePart.Content = new MimeContent(ms);
Parameter param;
if (mimePart.ContentDisposition != null && mimePart.ContentDisposition.Parameters.TryGetValue("filename", out param))
{
param.EncodingMethod = ParameterEncodingMethod.Rfc2047;
}
if (mimePart.ContentType.Parameters.TryGetValue("name", out param))
{
param.EncodingMethod = ParameterEncodingMethod.Rfc2047;
}
return(mimePart);
}
public string StoreMailBody(int tenant, string user, MailMessage messageItem)
{
if (string.IsNullOrEmpty(messageItem.HtmlBody))
{
return(string.Empty);
}
// Using id_user as domain in S3 Storage - allows not to add quota to tenant.
var savePath = MailStoragePathCombiner.GetBodyKey(user, messageItem.StreamId);
var storage = MailDataStore.GetDataStore(tenant);
try
{
using (var reader = new MemoryStream(Encoding.UTF8.GetBytes(messageItem.HtmlBody)))
{
var res = storage
.UploadWithoutQuota(string.Empty, savePath, reader, "text/html", string.Empty)
.ToString();
_log.Debug("StoreMailBody() tenant='{0}', user_id='{1}', save_body_path='{2}' Result: {3}",
tenant, user, savePath, res);
return(res);
}
}
catch (Exception ex)
{
_log.Debug(
"StoreMailBody() Problems with message saving in messageId={0}. \r\n Exception: \r\n {0}\r\n",
messageItem.MimeMessageId, ex.ToString());
storage.Delete(string.Empty, savePath);
throw;
}
}
public static List <string> GetEmbeddedAttachmentLinks(this MailComposeBase draft)
{
var links = new List <string>();
var fckStorage = StorageManager.GetDataStoreForCkImages(draft.Mailbox.TenantId);
//todo: replace selector
var currentMailFckeditorUrl = fckStorage.GetUri(StorageManager.CKEDITOR_IMAGES_DOMAIN, "").ToString();
var currentMailAttachmentFolderUrl = MailStoragePathCombiner.GetMessageDirectory(draft.Mailbox.UserId,
draft.StreamId);
var currentUserStorageUrl = MailStoragePathCombiner.GetUserMailsDirectory(draft.Mailbox.UserId);
var xpathQuery = StorageManager.GetXpathQueryForAttachmentsToResaving(currentMailFckeditorUrl,
currentMailAttachmentFolderUrl,
currentUserStorageUrl);
var doc = new HtmlDocument();
doc.LoadHtml(draft.HtmlBody);
var linkNodes = doc.DocumentNode.SelectNodes(xpathQuery);
if (linkNodes == null)
{
return(links);
}
links.AddRange(linkNodes.Select(linkNode => linkNode.Attributes["src"].Value));
return(links);
}
public static void ChangeEmbeddedAttachmentLinks(this MailDraftData draft, ILog log = null)
{
if (log == null)
{
log = new NullLog();
}
var baseAttachmentFolder = MailStoragePathCombiner.GetMessageDirectory(draft.Mailbox.UserId, draft.StreamId);
var doc = new HtmlDocument();
doc.LoadHtml(draft.HtmlBody);
var linkNodes = doc.DocumentNode.SelectNodes("//img[@src and (contains(@src,'" + baseAttachmentFolder + "'))]");
if (linkNodes == null)
{
return;
}
foreach (var linkNode in linkNodes)
{
var link = linkNode.Attributes["src"].Value;
log.InfoFormat("ChangeEmbededAttachmentLinks() Embeded attachment link for changing to cid: {0}", link);
var fileLink = HttpUtility.UrlDecode(link.Substring(baseAttachmentFolder.Length));
var fileName = Path.GetFileName(fileLink);
var attach = CreateEmbbededAttachment(fileName, link, fileLink, draft.Mailbox.UserId, draft.Mailbox.TenantId, draft.Mailbox.MailBoxId, draft.StreamId);
draft.AttachmentsEmbedded.Add(attach);
linkNode.SetAttributeValue("src", "cid:" + attach.contentId);
log.InfoFormat("ChangeEmbededAttachmentLinks() Attachment cid: {0}", attach.contentId);
}
draft.HtmlBody = doc.DocumentNode.OuterHtml;
}
public string StoreMailBody(int id_tenant, string id_user, MailMessageItem mail)
{
try
{
if (!string.IsNullOrEmpty(mail.HtmlBody))
{
var safe_body = ReplaceEmbeddedImages(mail);
using (var reader = new MemoryStream(Encoding.UTF8.GetBytes(safe_body)))
{
// Using id_user as domain in S3 Storage - allows not to add quota to tenant.
var save_body_path = MailStoragePathCombiner.GetBodyKey(id_user, mail.StreamId);
return(GetDataStore(id_tenant)
.UploadWithoutQuota(string.Empty, save_body_path, reader, "text/html", string.Empty)
.ToString());
}
}
return(string.Empty);
}
catch (Exception)
{
GetDataStore(id_tenant).Delete(string.Empty, MailStoragePathCombiner.GetBodyKey(id_user, mail.StreamId));
_log.Debug(String.Format("Problems with message saving in messageId={0}. Body was deleted.", mail.MessageId));
throw;
}
}
public string StoreMailEml(int tenant, string user, string streamId, Message message)
{
// Using id_user as domain in S3 Storage - allows not to add quota to tenant.
var savePath = MailStoragePathCombiner.GetEmlKey(user, streamId);
var storage = MailDataStore.GetDataStore(tenant);
try
{
using (var reader = new MemoryStream(message.OriginalData))
{
var res = storage
.UploadWithoutQuota(string.Empty, savePath, reader, "message/rfc822", string.Empty)
.ToString();
_log.Debug("StoreMailEml() tenant='{0}', user_id='{1}', save_eml_path='{2}' Result: {3}",
tenant, user, savePath, res);
return(res);
}
}
catch (Exception)
{
storage.Delete(string.Empty, savePath);
throw;
}
}
public void StoreAttachmentCopy(int tenant, string user, MailAttachmentData attachment, string streamId)
{
try
{
if (attachment.streamId.Equals(streamId) && !attachment.isTemp)
{
return;
}
string s3Key;
var dataClient = MailDataStore.GetDataStore(tenant);
if (attachment.needSaveToTemp || attachment.isTemp)
{
s3Key = MailStoragePathCombiner.GetTempStoredFilePath(attachment);
}
else
{
s3Key = MailStoragePathCombiner.GerStoredFilePath(attachment);
}
if (!dataClient.IsFile(s3Key))
{
return;
}
attachment.fileNumber =
!string.IsNullOrEmpty(attachment.contentId) //Upload hack: embedded attachment have to be saved in 0 folder
? 0
: attachment.fileNumber;
var newS3Key = MailStoragePathCombiner.GetFileKey(user, streamId, attachment.fileNumber,
attachment.storedName);
var copyS3Url = dataClient.Copy(s3Key, string.Empty, newS3Key);
attachment.storedFileUrl = MailStoragePathCombiner.GetStoredUrl(copyS3Url);
attachment.streamId = streamId;
attachment.tempStoredUrl = null;
Log.DebugFormat("StoreAttachmentCopy() tenant='{0}', user_id='{1}', stream_id='{2}', new_s3_key='{3}', copy_s3_url='{4}', storedFileUrl='{5}', filename='{6}'",
tenant, user, streamId, newS3Key, copyS3Url, attachment.storedFileUrl, attachment.fileName);
}
catch (Exception ex)
{
Log.ErrorFormat("CopyAttachment(). filename='{0}', ctype='{1}' Exception:\r\n{2}\r\n",
attachment.fileName,
attachment.contentType,
ex.ToString());
throw;
}
}
private void EditDocument(int attachment_id, HttpContext context)
{
var mail_box_manager = new MailBoxManager(0);
var file = mail_box_manager.GetMessageAttachment(attachment_id, TenantId, Username);
var temp_file_url = MailStoragePathCombiner.GetPreSignedUrl(file);
var editor_url = FilesLinkUtility.GetFileWebEditorExternalUrl(temp_file_url, file.fileName);
editor_url = new UriBuilder(CommonLinkUtility.GetFullAbsolutePath(editor_url)).ToString();
context.Response.Redirect(editor_url, false);
}
public static void ChangeEmbeddedAttachmentLinks(this MailDraftData draft, ILog log = null)
{
if (log == null)
{
log = new NullLog();
}
var baseAttachmentFolder = MailStoragePathCombiner.GetMessageDirectory(draft.Mailbox.UserId, draft.StreamId);
var doc = new HtmlDocument();
doc.LoadHtml(draft.HtmlBody);
var linkNodes = doc.DocumentNode.SelectNodes("//img[@src and (contains(@src,'" + baseAttachmentFolder + "') or @x-mail-embedded)]");
if (linkNodes == null)
{
return;
}
foreach (var linkNode in linkNodes)
{
var link = linkNode.Attributes["src"].Value;
log.InfoFormat("ChangeEmbededAttachmentLinks() Embeded attachment link for changing to cid: {0}", link);
var isExternal = link.IndexOf(baseAttachmentFolder) == -1;
var fileLink = isExternal
? link
: HttpUtility.UrlDecode(link.Substring(baseAttachmentFolder.Length));
var fileName = Path.GetFileName(fileLink);
var attach = CreateEmbbededAttachment(fileName, link, fileLink, draft.Mailbox.UserId, draft.Mailbox.TenantId, draft.Mailbox.MailBoxId, draft.StreamId);
if (isExternal)
{
using (var webClient = new WebClient())
{
//webClient.Headers.Add("Authorization", GetPartnerAuthHeader(actionUrl));
try
{
attach.data = webClient.DownloadData(fileLink);
}
catch (WebException we)
{
log.Error(we);
continue;
}
}
}
draft.AttachmentsEmbedded.Add(attach);
linkNode.SetAttributeValue("src", "cid:" + attach.contentId);
log.InfoFormat("ChangeEmbededAttachmentLinks() Attachment cid: {0}", attach.contentId);
}
draft.HtmlBody = doc.DocumentNode.OuterHtml;
}
private void ViewDocument(int attachmentId, HttpContext context)
{
var mailBoxManager = new MailBoxManager();
var file = mailBoxManager.GetMessageAttachment(attachmentId, TenantId, Username);
var tempFileUrl = MailStoragePathCombiner.GetPreSignedUrl(file);
var viewerUrl = FilesLinkUtility.GetFileWebViewerExternalUrl(tempFileUrl, file.fileName);
viewerUrl = new UriBuilder(CommonLinkUtility.GetFullAbsolutePath(viewerUrl)).ToString();
context.Response.Redirect(viewerUrl, false);
}
public static void ChangeSmileLinks(this MailDraftData draft, ILog log = null)
{
if (log == null)
{
log = new NullLog();
}
var baseSmileUrl = MailStoragePathCombiner.GetEditorSmileBaseUrl();
var doc = new HtmlDocument();
doc.LoadHtml(draft.HtmlBody);
var linkNodes = doc.DocumentNode.SelectNodes("//img[@src and (contains(@src,'" + baseSmileUrl + "'))]");
if (linkNodes == null)
{
return;
}
foreach (var linkNode in linkNodes)
{
var link = linkNode.Attributes["src"].Value;
log.InfoFormat("ChangeSmileLinks() Link to smile: {0}", link);
var fileName = Path.GetFileName(link);
var data = StorageManager.LoadLinkData(link, log);
if (!data.Any())
{
continue;
}
var attach = new MailAttachmentData
{
fileName = fileName,
storedName = fileName,
contentId = link.GetMd5(),
data = data
};
log.InfoFormat("ChangeSmileLinks() Embedded smile contentId: {0}", attach.contentId);
linkNode.SetAttributeValue("src", "cid:" + attach.contentId);
if (draft.AttachmentsEmbedded.All(x => x.contentId != attach.contentId))
{
draft.AttachmentsEmbedded.Add(attach);
}
}
draft.HtmlBody = doc.DocumentNode.OuterHtml;
}
private static void EditDocument(int attachmentId, HttpContext context)
{
var engine = new EngineFactory(TenantId, Username);
var file = engine.AttachmentEngine.GetAttachment(
new ConcreteUserAttachmentExp(attachmentId, TenantId, Username));
var tempFileUrl = MailStoragePathCombiner.GetPreSignedUrl(file);
var editorUrl = FilesLinkUtility.GetFileWebEditorExternalUrl(tempFileUrl, file.fileName);
editorUrl = new UriBuilder(CommonLinkUtility.GetFullAbsolutePath(editorUrl)).ToString();
context.Response.Redirect(editorUrl, false);
}
public bool RemoveGarbageMailboxData(MailBox mailbox)
{
if (!mailbox.IsRemoved)
{
return(false);
}
_log.Info(
"Mailbox is removed. All mail's data for this mailboxId = {0} will be removed!",
mailbox.MailBoxId);
try
{
var dataStorage = MailDataStore.GetDataStore(mailbox.TenantId);
var mailboxMessagesIterator = new MailboxMessagesIterator(mailbox, _mailBoxManager);
var message = mailboxMessagesIterator.First();
while (!mailboxMessagesIterator.IsDone)
{
var path = MailStoragePathCombiner.GetMessageDirectory(mailbox.UserId, message.StreamId);
try
{
if (dataStorage.IsDirectory(string.Empty, path))
{
_log.Debug("Trying remove files on path '{0}'", path);
dataStorage.DeleteDirectory(string.Empty, path);
}
}
catch (Exception)
{
_log.Error("Can't remove stored mail data in path = '{0}' for mailboxId = {0} on tenant {1}",
path, mailbox.MailBoxId, mailbox.TenantId);
}
_log.Info("Clear MessageId = {1}", mailbox.MailBoxId, message.Id);
message = mailboxMessagesIterator.Next();
}
_log.Debug("Trying remove garbage from db");
_garbageManager.ClearMailboxData(mailbox);
}
catch (Exception)
{
_log.Error("Can't remove all stored mail data for mailboxId = {0} on tenant {1}", mailbox.MailBoxId, mailbox.TenantId);
return(false);
}
return(true);
}
public string StoreMailBody(MailBox mailBox, MailMessage messageItem)
{
if (string.IsNullOrEmpty(messageItem.HtmlBody) && (messageItem.HtmlBodyStream == null || messageItem.HtmlBodyStream.Length == 0))
{
return(string.Empty);
}
// Using id_user as domain in S3 Storage - allows not to add quota to tenant.
var savePath = MailStoragePathCombiner.GetBodyKey(mailBox.UserId, messageItem.StreamId);
var storage = MailDataStore.GetDataStore(mailBox.TenantId);
storage.QuotaController = null;
try
{
string response;
if (messageItem.HtmlBodyStream != null && messageItem.HtmlBodyStream.Length > 0)
{
messageItem.HtmlBodyStream.Seek(0, SeekOrigin.Begin);
response = storage
.Save(savePath, messageItem.HtmlBodyStream, MailStoragePathCombiner.BODY_FILE_NAME)
.ToString();
}
else
{
using (var reader = new MemoryStream(Encoding.UTF8.GetBytes(messageItem.HtmlBody)))
{
response = storage
.Save(savePath, reader, MailStoragePathCombiner.BODY_FILE_NAME)
.ToString();
}
}
_log.Debug("StoreMailBody() tenant='{0}', user_id='{1}', save_body_path='{2}' Result: {3}",
mailBox.TenantId, mailBox.UserId, savePath, response);
return(response);
}
catch (Exception ex)
{
_log.Debug(
"StoreMailBody() Problems with message saving in messageId={0}. \r\n Exception: \r\n {0}\r\n",
messageItem.MimeMessageId, ex.ToString());
storage.Delete(string.Empty, savePath);
throw;
}
}
public void StoreAttachmentWithoutQuota(int tenant, string user, MailAttachment attachment, IDataStore storage)
{
try
{
if (attachment.data == null || attachment.data.Length == 0)
{
return;
}
if (string.IsNullOrEmpty(attachment.fileName))
{
attachment.fileName = "attachment.ext";
}
var contentDisposition = MailStoragePathCombiner.PrepareAttachmentName(attachment.fileName);
var ext = Path.GetExtension(attachment.fileName);
attachment.storedName = CreateNewStreamId();
if (!string.IsNullOrEmpty(ext))
{
attachment.storedName = Path.ChangeExtension(attachment.storedName, ext);
}
attachment.fileNumber =
!string.IsNullOrEmpty(attachment.contentId) //Upload hack: embedded attachment have to be saved in 0 folder
? 0
: attachment.fileNumber;
var attachmentPath = MailStoragePathCombiner.GerStoredFilePath(attachment);
using (var reader = new MemoryStream(attachment.data))
{
var uploadUrl = storage.UploadWithoutQuota(string.Empty, attachmentPath, reader, attachment.contentType, contentDisposition);
attachment.storedFileUrl = MailStoragePathCombiner.GetStoredUrl(uploadUrl);
}
}
catch (Exception e)
{
_log.Error("StoreAttachmentWithoutQuota(). filename: {0}, ctype: {1} Exception:\r\n{2}\r\n",
attachment.fileName,
attachment.contentType,
e.ToString());
throw;
}
}
public void StoreAttachmentCopy(int id_tenant, string id_user, MailAttachment attachment, string stream_id)
{
try
{
if (attachment.streamId.Equals(stream_id))
{
return;
}
var s3_key = MailStoragePathCombiner.GerStoredFilePath(attachment);
var data_client = MailDataStore.GetDataStore(id_tenant);
if (!data_client.IsFile(s3_key))
{
return;
}
attachment.fileNumber =
!string.IsNullOrEmpty(attachment.contentId) //Upload hack: embedded attachment have to be saved in 0 folder
? 0
: attachment.fileNumber;
var new_s3_key = MailStoragePathCombiner.GetFileKey(id_user, stream_id, attachment.fileNumber,
attachment.storedName);
var copy_s3_url = data_client.Copy(s3_key, string.Empty, new_s3_key);
attachment.storedFileUrl = MailStoragePathCombiner.GetStoredUrl(copy_s3_url);
attachment.streamId = stream_id;
_log.Debug("StoreAttachmentCopy() tenant='{0}', user_id='{1}', stream_id='{2}', new_s3_key='{3}', copy_s3_url='{4}', storedFileUrl='{5}', filename='{6}'",
id_tenant, id_user, stream_id, new_s3_key, copy_s3_url, attachment.storedFileUrl, attachment.fileName);
}
catch (Exception ex)
{
_log.Error("CopyAttachment(). filename='{0}', ctype='{1}' Exception:\r\n{2}\r\n",
attachment.fileName,
attachment.contentType,
ex.ToString());
throw;
}
}
public static string RemoveProxyHttpUrls(string html)
{
var baseHandlerUrl = MailStoragePathCombiner.GetProxyHttpHandlerUrl() + "?url=";
var doc = new HtmlDocument();
doc.LoadHtml(html);
var nodesWithProxy = doc.DocumentNode.DescendantsAndSelf()
.Where(n => n.HasAttributes && n.Attributes.Any(a => a.Value.Contains(baseHandlerUrl)))
.ToList();
var needRewrite = false;
foreach (var n in nodesWithProxy)
{
var attributes = n.Attributes.Where(a => a.Value.Contains(baseHandlerUrl));
foreach (var attribute in attributes)
{
var splited = attribute.Value.Split(new[] { baseHandlerUrl },
StringSplitOptions.RemoveEmptyEntries);
if (!splited.Any())
{
continue;
}
var raw = splited.Length > 1 ? splited[1] : splited[0];
var end = raw.IndexOfAny(new[] { '\"', ')' });
var encodedUrl = end == -1 ? raw : raw.Substring(0, end);
var url = Encoding.UTF8.GetString(Convert.FromBase64String(encodedUrl));
attribute.Value = attribute.Value.Replace(baseHandlerUrl + encodedUrl, url);
needRewrite = true;
}
}
return(needRewrite ? doc.DocumentNode.OuterHtml : html);
}
private static void RemoveUserMailDirectory(int tenant, string userId, ILogger log)
{
log.Debug("MailDataStore.GetDataStore(Tenant = {0})", tenant);
var dataStorage = MailDataStore.GetDataStore(tenant);
var userMailDir = MailStoragePathCombiner.GetUserMailsDirectory(userId);
try
{
log.Info("RemoveUserMailDirectory(Path: {0}, Tenant = {1} User = '******')", userMailDir, tenant, userId);
dataStorage.DeleteDirectory(userMailDir);
}
catch (Exception ex)
{
log.Error("MailDataStore.DeleteDirectory(path: {0}) failed. Error: {1}", userMailDir, ex.ToString());
}
}
private static MimePart CreateAttachment(MailAttachment attachment, bool load_attachments)
{
var ret_val = new MimePart();
var s3_key = MailStoragePathCombiner.GerStoredFilePath(attachment);
var file_name = attachment.fileName ?? Path.GetFileName(s3_key);
if (load_attachments)
{
var byte_array = attachment.data;
if (byte_array == null || byte_array.Length == 0)
{
using (var stream = StorageManager.GetDataStoreForAttachments(attachment.tenant).GetReadStream(s3_key))
{
byte_array = stream.GetCorrectBuffer();
}
}
ret_val = new MimePart(byte_array, file_name);
if (attachment.contentId != null)
{
ret_val.ContentId = attachment.contentId;
}
}
else
{
var conent_type = Common.Web.MimeMapping.GetMimeMapping(s3_key);
ret_val.ContentType = new ContentType {
Type = conent_type
};
ret_val.Filename = file_name;
if (attachment.contentId != null)
{
ret_val.ContentId = attachment.contentId;
}
ret_val.TextContent = "";
}
return(ret_val);
}
public static MimePart ToMimePart(this MailAttachment attachment, bool loadAttachments)
{
var retVal = new MimePart();
var s3Key = MailStoragePathCombiner.GerStoredFilePath(attachment);
var fileName = attachment.fileName ?? Path.GetFileName(s3Key);
if (loadAttachments)
{
var byteArray = attachment.data;
if (byteArray == null || byteArray.Length == 0)
{
using (var stream = StorageManager.GetDataStoreForAttachments(attachment.tenant).GetReadStream(s3Key))
{
byteArray = stream.ReadToEnd();
}
}
retVal = new MimePart(byteArray, fileName);
if (!string.IsNullOrEmpty(attachment.contentId))
{
retVal.ContentId = attachment.contentId;
}
}
else
{
var conentType = MimeMapping.GetMimeMapping(s3Key);
retVal.ContentType = new ContentType {
Type = conentType
};
retVal.Filename = fileName;
if (attachment.contentId != null)
{
retVal.ContentId = attachment.contentId;
}
retVal.TextContent = "";
}
return(retVal);
}
public string GetMailEmlUrl(int tenant, string user, string streamId)
{
// Using id_user as domain in S3 Storage - allows not to add quota to tenant.
var emlPath = MailStoragePathCombiner.GetEmlKey(user, streamId);
var dataStore = MailDataStore.GetDataStore(tenant);
try
{
var emlUri = dataStore.GetUri(string.Empty, emlPath);
var url = MailStoragePathCombiner.GetStoredUrl(emlUri);
return(url);
}
catch (Exception ex)
{
_log.Error("GetMailEmlUrl() tenant='{0}', user_id='{1}', save_eml_path='{2}' Exception: {3}",
tenant, user, emlPath, ex.ToString());
}
return("");
}
public bool RemoveTerminatedUserGarbageMailData(int tenant, string user)
{
var userInfo = GetUserInfo(tenant, user);
if (userInfo == null || userInfo.Status != EmployeeStatus.Terminated)
{
return(false);
}
_log.Info(
"User is terminated. All mail's data for this user = '******' (Tenant={1}) will be removed!",
user, tenant);
try
{
var dataStorage = MailDataStore.GetDataStore(tenant);
var path = MailStoragePathCombiner.GetUserMailsDirectory(userInfo.ID.ToString());
if (dataStorage.IsDirectory(string.Empty, path))
{
_log.Debug("Trying remove all user mail's files from storage '{0}' on path '{1}'",
Defines.MODULE_NAME, path);
dataStorage.DeleteDirectory(string.Empty, path);
}
}
catch (Exception ex)
{
_log.Error("Can't remove all stored mail data for user '{0}' on tenant {1}\r\nException: {2}", user,
tenant, ex.ToString());
return(false);
}
_log.Debug("Trying remove garbage from db");
_garbageManager.ClearUserMailData(tenant, userInfo);
return(true);
}
public string StoreCKeditorImageWithoutQuota(int tenant, string user, int mailboxId, string fileName, byte[] imageData, IDataStore storage)
{
try
{
if (imageData == null || imageData.Length == 0)
{
throw new ArgumentNullException("imageData");
}
var ext = string.IsNullOrEmpty(fileName) ? ".jpg" : Path.GetExtension(fileName);
if (string.IsNullOrEmpty(ext))
{
ext = ".jpg";
}
var storeName = imageData.GetMd5();
storeName = Path.ChangeExtension(storeName, ext);
var contentDisposition = ContentDispositionUtil.GetHeaderValue(storeName);
var contentType = MimeTypesHelper.GetMimeqType(ext);
var signatureImagePath = MailStoragePathCombiner.GerStoredSignatureImagePath(mailboxId, storeName);
using (var reader = new MemoryStream(imageData))
{
var uploadUrl = storage.UploadWithoutQuota(user, signatureImagePath, reader, contentType, contentDisposition);
return(MailStoragePathCombiner.GetStoredUrl(uploadUrl));
}
}
catch (Exception e)
{
_log.Error("StoreCKeditorImageWithoutQuota(). filename: {0} Exception:\r\n{1}\r\n", fileName,
e.ToString());
throw;
}
}
public void StoreAttachmentCopy(int id_tenant, string id_user, MailAttachment attachment, string stream_id)
{
try
{
if (!attachment.streamId.Equals(stream_id))
{
var s3_key = attachment.GerStoredFilePath();
var data_client = GetDataStore(id_tenant);
if (data_client.IsFile(s3_key))
{
attachment.fileNumber =
!string.IsNullOrEmpty(attachment.contentId) //Upload hack: embedded attachment have to be saved in 0 folder
? 0
: attachment.fileNumber;
var new_s3_key = MailStoragePathCombiner.GetFileKey(id_user, stream_id, attachment.fileNumber,
attachment.storedName);
var copy_s3_url = data_client.Copy(s3_key, string.Empty, new_s3_key);
attachment.storedFileUrl = MailStoragePathCombiner.GetStoredUrl(copy_s3_url);
attachment.streamId = stream_id;
}
}
}
catch (Exception ex)
{
_log.Error("CopyAttachment(). filename: {0}, ctype: {1} Exception:\r\n{2}\r\n",
attachment.fileName,
attachment.contentType,
ex.ToString());
throw;
}
}
public MailMessageGarbage(string user, int id, string stream)
{
_id = id;
_path = MailStoragePathCombiner.GetBodyKey(user, stream);
}
private List <MailAttachmentData> FixHtmlBodyWithEmbeddedAttachments(MailComposeBase compose)
{
var embededAttachmentsForSaving = new List <MailAttachmentData>();
var embeddedLinks = compose.GetEmbeddedAttachmentLinks();
if (!embeddedLinks.Any())
{
return(embededAttachmentsForSaving);
}
var fckStorage = StorageManager.GetDataStoreForCkImages(compose.Mailbox.TenantId);
var attachmentStorage = StorageManager.GetDataStoreForAttachments(compose.Mailbox.TenantId);
var currentMailFckeditorUrl = fckStorage.GetUri(StorageManager.CKEDITOR_IMAGES_DOMAIN, "").ToString();
var currentUserStorageUrl = MailStoragePathCombiner.GetUserMailsDirectory(compose.Mailbox.UserId);
var engine = new EngineFactory(compose.Mailbox.TenantId, compose.Mailbox.UserId);
StorageManager storage = null;
foreach (var embeddedLink in embeddedLinks)
{
try
{
var isFckImage = embeddedLink.StartsWith(currentMailFckeditorUrl);
var prefixLength = isFckImage
? currentMailFckeditorUrl.Length
: embeddedLink.IndexOf(currentUserStorageUrl, StringComparison.Ordinal) +
currentUserStorageUrl.Length + 1;
var fileLink = HttpUtility.UrlDecode(embeddedLink.Substring(prefixLength));
var fileName = Path.GetFileName(fileLink);
var attach = new MailAttachmentData
{
fileName = fileName,
storedName = fileName,
contentId = embeddedLink.GetMd5(),
storedFileUrl = fileLink,
streamId = compose.StreamId,
user = compose.Mailbox.UserId,
tenant = compose.Mailbox.TenantId,
mailboxId = compose.Mailbox.MailBoxId
};
var savedAttachment =
engine.AttachmentEngine.GetAttachment(
new ConcreteContentAttachmentExp(compose.Id, attach.contentId));
var savedAttachmentId = savedAttachment == null ? 0 : savedAttachment.fileId;
var attachmentWasSaved = savedAttachmentId != 0;
var currentImgStorage = isFckImage ? fckStorage : attachmentStorage;
var domain = isFckImage ? StorageManager.CKEDITOR_IMAGES_DOMAIN : compose.Mailbox.UserId;
if (compose.Id == 0 || !attachmentWasSaved)
{
attach.data = StorageManager.LoadDataStoreItemData(domain, fileLink, currentImgStorage);
if (storage == null)
{
storage = new StorageManager(compose.Mailbox.TenantId, compose.Mailbox.UserId);
}
storage.StoreAttachmentWithoutQuota(attach);
embededAttachmentsForSaving.Add(attach);
}
if (attachmentWasSaved)
{
attach = engine.AttachmentEngine.GetAttachment(
new ConcreteUserAttachmentExp(savedAttachmentId, compose.Mailbox.TenantId, compose.Mailbox.UserId));
var path = MailStoragePathCombiner.GerStoredFilePath(attach);
currentImgStorage = attachmentStorage;
attach.storedFileUrl =
MailStoragePathCombiner.GetStoredUrl(currentImgStorage.GetUri(path));
}
compose.HtmlBody = compose.HtmlBody.Replace(embeddedLink, attach.storedFileUrl);
}
catch (Exception ex)
{
Log.ErrorFormat("ChangeEmbededAttachmentLinksForStoring() failed with exception: {0}", ex.ToString());
}
}
return(embededAttachmentsForSaving);
}
public MailAttachGarbage(string user, int attachId, string stream, int number, string storedName)
{
_id = attachId;
_path = MailStoragePathCombiner.GetFileKey(user, stream, number, storedName);
}
