2019-05-15 14:56:09 +00:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* (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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
namespace ASC.Core.Notify.Senders;
|
|
|
|
|
|
|
|
[Singletone(Additional = typeof(SmtpSenderExtension))]
|
|
|
|
public class SmtpSender : INotifySender
|
2020-10-19 15:53:15 +00:00
|
|
|
{
|
2022-02-15 11:52:43 +00:00
|
|
|
protected ILog Logger { get; set; }
|
|
|
|
protected readonly IConfiguration Configuration;
|
|
|
|
protected IServiceProvider ServiceProvider;
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
private string _host;
|
|
|
|
private int _port;
|
|
|
|
private bool _ssl;
|
|
|
|
private ICredentials _credentials;
|
|
|
|
protected bool UseCoreSettings;
|
|
|
|
const int NetworkTimeout = 30000;
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
public SmtpSender(
|
|
|
|
IServiceProvider serviceProvider,
|
|
|
|
IOptionsMonitor<ILog> options)
|
|
|
|
{
|
|
|
|
Logger = options.Get("ASC.Notify");
|
|
|
|
Configuration = serviceProvider.GetService<IConfiguration>();
|
|
|
|
ServiceProvider = serviceProvider;
|
|
|
|
}
|
2019-05-15 14:56:09 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
public virtual void Init(IDictionary<string, string> properties)
|
|
|
|
{
|
|
|
|
if (properties.ContainsKey("useCoreSettings") && bool.Parse(properties["useCoreSettings"]))
|
|
|
|
{
|
|
|
|
UseCoreSettings = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_host = properties["host"];
|
|
|
|
_port = properties.ContainsKey("port") ? int.Parse(properties["port"]) : 25;
|
|
|
|
_ssl = properties.ContainsKey("enableSsl") && bool.Parse(properties["enableSsl"]);
|
|
|
|
if (properties.TryGetValue("userName", out var property))
|
|
|
|
{
|
|
|
|
_credentials = new NetworkCredential(property, properties["password"]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
private void InitUseCoreSettings(CoreConfiguration configuration)
|
|
|
|
{
|
|
|
|
var s = configuration.SmtpSettings;
|
2019-05-15 14:56:09 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
_host = s.Host;
|
|
|
|
_port = s.Port;
|
|
|
|
_ssl = s.EnableSSL;
|
|
|
|
_credentials = !string.IsNullOrEmpty(s.CredentialsUserName)
|
|
|
|
? new NetworkCredential(s.CredentialsUserName, s.CredentialsUserPassword)
|
|
|
|
: null;
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
public virtual NoticeSendResult Send(NotifyMessage m)
|
|
|
|
{
|
|
|
|
using var scope = ServiceProvider.CreateScope();
|
|
|
|
var scopeClass = scope.ServiceProvider.GetService<SmtpSenderScope>();
|
|
|
|
var (tenantManager, configuration) = scopeClass;
|
2022-02-25 17:16:00 +00:00
|
|
|
tenantManager.SetCurrentTenant(m.TenantId);
|
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
var smtpClient = GetSmtpClient();
|
|
|
|
var result = NoticeSendResult.TryOnceAgain;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
if (UseCoreSettings)
|
|
|
|
{
|
|
|
|
InitUseCoreSettings(configuration);
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
var mail = BuildMailMessage(m);
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
Logger.DebugFormat("SmtpSender - host={0}; port={1}; enableSsl={2} enableAuth={3}", _host, _port, _ssl, _credentials != null);
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
smtpClient.Connect(_host, _port,
|
|
|
|
_ssl ? SecureSocketOptions.Auto : SecureSocketOptions.None);
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
if (_credentials != null)
|
|
|
|
{
|
|
|
|
smtpClient.Authenticate(_credentials);
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
smtpClient.Send(mail);
|
|
|
|
result = NoticeSendResult.OK;
|
|
|
|
}
|
|
|
|
catch (Exception e)
|
|
|
|
{
|
2022-02-25 17:16:00 +00:00
|
|
|
Logger.ErrorFormat("Tenant: {0}, To: {1} - {2}", m.TenantId, m.Reciever, e);
|
2022-02-15 11:52:43 +00:00
|
|
|
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (ObjectDisposedException)
|
|
|
|
{
|
|
|
|
result = NoticeSendResult.SendingImpossible;
|
|
|
|
}
|
|
|
|
catch (InvalidOperationException)
|
|
|
|
{
|
|
|
|
result = string.IsNullOrEmpty(_host) || _port == 0
|
|
|
|
? NoticeSendResult.SendingImpossible
|
|
|
|
: NoticeSendResult.TryOnceAgain;
|
|
|
|
}
|
|
|
|
catch (IOException)
|
|
|
|
{
|
|
|
|
result = NoticeSendResult.TryOnceAgain;
|
|
|
|
}
|
|
|
|
catch (MailKit.Net.Smtp.SmtpProtocolException)
|
|
|
|
{
|
|
|
|
result = NoticeSendResult.SendingImpossible;
|
|
|
|
}
|
|
|
|
catch (MailKit.Net.Smtp.SmtpCommandException e)
|
|
|
|
{
|
|
|
|
switch (e.StatusCode)
|
|
|
|
{
|
|
|
|
case MailKit.Net.Smtp.SmtpStatusCode.MailboxBusy:
|
|
|
|
case MailKit.Net.Smtp.SmtpStatusCode.MailboxUnavailable:
|
|
|
|
case MailKit.Net.Smtp.SmtpStatusCode.ExceededStorageAllocation:
|
|
|
|
result = NoticeSendResult.TryOnceAgain;
|
|
|
|
break;
|
|
|
|
case MailKit.Net.Smtp.SmtpStatusCode.MailboxNameNotAllowed:
|
|
|
|
case MailKit.Net.Smtp.SmtpStatusCode.UserNotLocalWillForward:
|
|
|
|
case MailKit.Net.Smtp.SmtpStatusCode.UserNotLocalTryAlternatePath:
|
|
|
|
result = NoticeSendResult.MessageIncorrect;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (e.StatusCode != MailKit.Net.Smtp.SmtpStatusCode.Ok)
|
2022-02-14 21:02:57 +00:00
|
|
|
{
|
2022-02-15 11:52:43 +00:00
|
|
|
result = NoticeSendResult.TryOnceAgain;
|
2022-02-14 21:02:57 +00:00
|
|
|
}
|
2022-02-15 11:52:43 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (Exception)
|
|
|
|
{
|
|
|
|
result = NoticeSendResult.SendingImpossible;
|
|
|
|
}
|
|
|
|
finally
|
|
|
|
{
|
|
|
|
if (smtpClient.IsConnected)
|
|
|
|
{
|
|
|
|
smtpClient.Disconnect(true);
|
|
|
|
}
|
2019-05-15 14:56:09 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
smtpClient.Dispose();
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
private MimeMessage BuildMailMessage(NotifyMessage m)
|
|
|
|
{
|
|
|
|
var mimeMessage = new MimeMessage
|
|
|
|
{
|
|
|
|
Subject = m.Subject
|
|
|
|
};
|
2022-02-25 17:16:00 +00:00
|
|
|
|
|
|
|
var fromAddress = MailboxAddress.Parse(ParserOptions.Default, m.Sender);
|
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
mimeMessage.From.Add(fromAddress);
|
2022-02-25 17:16:00 +00:00
|
|
|
|
|
|
|
foreach (var to in m.Reciever.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries))
|
2022-02-15 11:52:43 +00:00
|
|
|
{
|
|
|
|
mimeMessage.To.Add(MailboxAddress.Parse(ParserOptions.Default, to));
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
if (m.ContentType == Pattern.HtmlContentType)
|
|
|
|
{
|
|
|
|
var textPart = new TextPart("plain")
|
|
|
|
{
|
|
|
|
Text = HtmlUtil.GetText(m.Content),
|
|
|
|
ContentTransferEncoding = ContentEncoding.QuotedPrintable
|
|
|
|
};
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
var multipartAlternative = new MultipartAlternative { textPart };
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
var htmlPart = new TextPart("html")
|
|
|
|
{
|
|
|
|
Text = GetHtmlView(m.Content),
|
|
|
|
ContentTransferEncoding = ContentEncoding.QuotedPrintable
|
|
|
|
};
|
2022-02-25 17:16:00 +00:00
|
|
|
|
|
|
|
if (m.Attachments != null && m.Attachments.Count > 0)
|
2022-02-15 11:52:43 +00:00
|
|
|
{
|
|
|
|
var multipartRelated = new MultipartRelated
|
|
|
|
{
|
|
|
|
Root = htmlPart
|
|
|
|
};
|
2022-02-25 17:16:00 +00:00
|
|
|
|
|
|
|
foreach (var attachment in m.Attachments)
|
2022-02-14 21:02:57 +00:00
|
|
|
{
|
2022-02-15 11:52:43 +00:00
|
|
|
var mimeEntity = ConvertAttachmentToMimePart(attachment);
|
|
|
|
if (mimeEntity != null)
|
|
|
|
{
|
|
|
|
multipartRelated.Add(mimeEntity);
|
2022-02-25 17:16:00 +00:00
|
|
|
}
|
2022-02-14 21:02:57 +00:00
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
multipartAlternative.Add(multipartRelated);
|
2022-02-14 21:02:57 +00:00
|
|
|
}
|
2022-02-15 11:52:43 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
multipartAlternative.Add(htmlPart);
|
2020-09-15 13:11:05 +00:00
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
mimeMessage.Body = multipartAlternative;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
mimeMessage.Body = new TextPart("plain")
|
|
|
|
{
|
|
|
|
Text = m.Content,
|
|
|
|
ContentTransferEncoding = ContentEncoding.QuotedPrintable
|
|
|
|
};
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
if (!string.IsNullOrEmpty(m.ReplyTo))
|
|
|
|
{
|
|
|
|
mimeMessage.ReplyTo.Add(MailboxAddress.Parse(ParserOptions.Default, m.ReplyTo));
|
|
|
|
}
|
|
|
|
|
|
|
|
mimeMessage.Headers.Add("Auto-Submitted", string.IsNullOrEmpty(m.AutoSubmitted) ? "auto-generated" : m.AutoSubmitted);
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
return mimeMessage;
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
protected string GetHtmlView(string body)
|
|
|
|
{
|
|
|
|
return $@"<!DOCTYPE html PUBLIC ""-//W3C//DTD HTML 4.01 Transitional//EN"">
|
2022-02-14 21:02:57 +00:00
|
|
|
<html>
|
|
|
|
<head>
|
|
|
|
<meta content=""text/html;charset=UTF-8"" http-equiv=""Content-Type"">
|
|
|
|
</head>
|
|
|
|
<body>{body}</body>
|
2022-02-15 11:52:43 +00:00
|
|
|
</html>";
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
private MailKit.Net.Smtp.SmtpClient GetSmtpClient()
|
2020-08-24 18:41:06 +00:00
|
|
|
{
|
2022-02-15 11:52:43 +00:00
|
|
|
var smtpClient = new MailKit.Net.Smtp.SmtpClient
|
|
|
|
{
|
|
|
|
Timeout = NetworkTimeout
|
|
|
|
};
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
return smtpClient;
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
private static MimePart ConvertAttachmentToMimePart(NotifyMessageAttachment attachment)
|
|
|
|
{
|
|
|
|
try
|
2020-07-28 14:24:21 +00:00
|
|
|
{
|
2022-02-15 11:52:43 +00:00
|
|
|
if (attachment == null || string.IsNullOrEmpty(attachment.FileName) || string.IsNullOrEmpty(attachment.ContentId) || attachment.Content == null)
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
var extension = Path.GetExtension(attachment.FileName);
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
if (string.IsNullOrEmpty(extension))
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
return new MimePart("image", extension.TrimStart('.'))
|
|
|
|
{
|
|
|
|
ContentId = attachment.ContentId,
|
|
|
|
Content = new MimeContent(new MemoryStream(attachment.Content.ToByteArray())),
|
|
|
|
ContentDisposition = new ContentDisposition(ContentDisposition.Attachment),
|
|
|
|
ContentTransferEncoding = ContentEncoding.Base64,
|
|
|
|
FileName = attachment.FileName
|
|
|
|
};
|
|
|
|
}
|
|
|
|
catch (Exception)
|
2020-09-30 14:47:42 +00:00
|
|
|
{
|
2022-02-15 11:52:43 +00:00
|
|
|
return null;
|
2020-09-30 14:47:42 +00:00
|
|
|
}
|
2022-02-15 11:52:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
[Scope]
|
|
|
|
public class SmtpSenderScope
|
|
|
|
{
|
|
|
|
private readonly TenantManager _tenantManager;
|
|
|
|
private readonly CoreConfiguration _coreConfiguration;
|
|
|
|
|
|
|
|
public SmtpSenderScope(TenantManager tenantManager, CoreConfiguration coreConfiguration)
|
|
|
|
{
|
|
|
|
_tenantManager = tenantManager;
|
|
|
|
_coreConfiguration = coreConfiguration;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void Deconstruct(out TenantManager tenantManager, out CoreConfiguration coreConfiguration)
|
|
|
|
{
|
|
|
|
(tenantManager, coreConfiguration) = (_tenantManager, _coreConfiguration);
|
|
|
|
}
|
|
|
|
}
|
2022-02-25 17:16:00 +00:00
|
|
|
|
2022-02-15 11:52:43 +00:00
|
|
|
public static class SmtpSenderExtension
|
|
|
|
{
|
|
|
|
public static void Register(DIHelper services)
|
|
|
|
{
|
|
|
|
services.TryAdd<SmtpSenderScope>();
|
|
|
|
}
|
|
|
|
}
|