public static void SendMail(SmtpConfig smtpConfig, string strContactName, string strContactEmail, string strContactMessage)
{
MimeKit.MimeMessage message = new MimeKit.MimeMessage();
message.From.Add(new MimeKit.MailboxAddress(strContactEmail, strContactEmail));
message.To.Add(new MimeKit.MailboxAddress("Noob", "*****@*****.**"));
message.To.Add(new MimeKit.MailboxAddress("Noob2", "*****@*****.**"));
message.Subject = "Neue Nachricht von www.daniel-steiger.ch";
message.Body = new MimeKit.TextPart("plain")
{
Text = strContactMessage
};
string pw = CoinBaseSharp.StringHelper.ReverseGraphemeClusters(smtpConfig.Pass);
using (MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient())
{
// client.Connect("smtp.gmail.com", 587);
////Note: only needed if the SMTP server requires authentication
// client.Authenticate("*****@*****.**", "mypassword");
client.Connect(smtpConfig.Server, smtpConfig.Port, false);
client.Authenticate(smtpConfig.User, pw);
client.Send(message);
client.Disconnect(true);
}
}
public void Send(EmailMessage emailMessage)
{
var message = new MimeMessage();
message.To.AddRange(emailMessage.ToAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
message.From.AddRange(emailMessage.FromAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
message.Subject = emailMessage.Subject;
//We will say we are sending HTML. But there are options for plaintext etc.
message.Body = new TextPart(TextFormat.Html)
{
Text = emailMessage.Content
};
//Be careful that the SmtpClient class is the one from Mailkit not the framework!
using (var emailClient = new MailKit.Net.Smtp.SmtpClient())
{
//The last parameter here is to use SSL (Which you should!)
emailClient.Connect(_emailConfiguration.SmtpServer, _emailConfiguration.SmtpPort, false);
//Remove any OAuth functionality as we won't be using it.
emailClient.AuthenticationMechanisms.Remove("XOAUTH2");
emailClient.Authenticate(_emailConfiguration.SmtpUsername, _emailConfiguration.SmtpPassword);
emailClient.Send(message);
emailClient.Disconnect(true);
}
}
/// <inheritdoc/>
public void SendEmail(Email email)
{
// First build the body
BodyBuilder bodyBuilder = new BodyBuilder();
bodyBuilder.TextBody = email.TextContents.FirstOrDefault(text => text.MimeType == Constants.TextMimeType)?.RawText;
bodyBuilder.HtmlBody = email.TextContents.FirstOrDefault(text => text.MimeType == Constants.HtmlMimeType)?.RawText;
foreach (Interfaces.Models.Attachment attachment in email.Attachments)
{
bodyBuilder.Attachments.Add(GetAttachment(attachment));
}
// Build the message
MimeMessage mimeMessage = new MimeMessage();
mimeMessage.Subject = email.Subject;
mimeMessage.Body = bodyBuilder.ToMessageBody();
mimeMessage.From.Add(GetInternetAddress(email.From));
foreach (MailAddress from in email.To)
{
mimeMessage.To.Add(GetInternetAddress(from));
}
// Send the message
using (SmtpClient smtpClient = new SmtpClient())
{
smtpClient.ServerCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
smtpClient.Connect(Localhost, _options.SmtpPort);
smtpClient.Send(mimeMessage);
}
}
public async void Send(string toAddress, string subject, string body, bool sendAsync = true)
{
var mimeMessage = new MimeMessage(); // MIME : Multipurpose Internet Mail Extension
mimeMessage.From.Add(new MailboxAddress(_fromAddressTitle, _fromAddress));
mimeMessage.To.Add(new MailboxAddress(toAddress));
mimeMessage.Subject = subject;
var bodyBuilder = new MimeKit.BodyBuilder
{
HtmlBody = body
};
IEnumerable <InternetAddress> ccList = new List <InternetAddress>();
foreach (var itemAppUser in _userDal.Users)
{
InternetAddress address = new MailboxAddress(itemAppUser.Email);
mimeMessage.Cc.Add(address);
}
mimeMessage.Body = bodyBuilder.ToMessageBody();
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect(_smtpServer, _smtpPort, _enableSsl);
client.Authenticate(_username, _password); // If using GMail this requires turning on LessSecureApps : https://myaccount.google.com/lesssecureapps
if (sendAsync)
{
await client.SendAsync(mimeMessage);
}
else
{
client.Send(mimeMessage);
}
client.Disconnect(true);
}
}
/// <summary>
/// 发送邮件
/// </summary>
/// <param name="title"></param>
/// <param name="msg"></param>
/// <param name="mail"></param>
/// <returns></returns>
public static void SendMail(SendMailModel model)
{
try
{
var message = new MimeMessage();
message.From.Add(new MailboxAddress(model.MailInfo.MailFrom, model.MailInfo.MailFrom));
foreach (var mailTo in model.MailInfo.MailTo.Replace("；", ";").Replace("，", ";").Replace(",", ";").Split(';'))
{
message.To.Add(new MailboxAddress(mailTo, mailTo));
}
message.Subject = string.Format(model.Title);
message.Body = new TextPart("html")
{
Text = model.Content
};
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect(model.MailInfo.MailHost, 465, true);
client.Authenticate(model.MailInfo.MailFrom, model.MailInfo.MailPwd);
client.Send(message);
client.Disconnect(true);
}
}
catch (System.Exception)
{
}
}
//string title, string msg, MailEntity mail = null
/// <summary>
/// 发送邮件
/// </summary>
/// <param name="title"></param>
/// <param name="msg"></param>
/// <param name="mail"></param>
/// <returns></returns>
public async Task <bool> SendMail([FromBody] SendMailModel model)
{
try
{
if (model.MailInfo == null)
{
model.MailInfo = await GetMailInfo();
}
var message = new MimeMessage();
message.From.Add(new MailboxAddress(model.MailInfo.MailFrom, model.MailInfo.MailFrom));
foreach (var mailTo in model.MailInfo.MailTo.Replace("；", ";").Replace("，", ";").Replace(",", ";").Split(';'))
{
message.To.Add(new MailboxAddress(mailTo, mailTo));
}
message.Subject = string.Format(model.Title);
message.Body = new TextPart("html")
{
Text = model.Content
};
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect(model.MailInfo.MailHost, 465, true);
client.Authenticate(model.MailInfo.MailFrom, model.MailInfo.MailPwd);
client.Send(message);
client.Disconnect(true);
}
return(true);
}
catch (System.Exception)
{
return(false);
}
}
/// <summary>
/// Method for sending email
/// </summary>
/// <param name="DisplayName">Display name of email</param>
/// <param name="emailSubject">Subject of email</param>
/// <param name="emailBody">Body of email</param>
/// <param name="emailAddress">Receiver's email address</param>
/// <returns>send Mail</returns>
public async Task SendMail(string DisplayName, string emailSubject, string emailBody, string emailAddress)
{
try
{
var message = new MimeMessage();
message.From.Add(new MailboxAddress(DisplayName, _configuration["MailSetting:MailId"]));
message.To.Add(MailboxAddress.Parse(emailAddress));
message.Subject = emailSubject;
message.Body = new TextPart(TextFormat.Html)
{
Text = emailBody
};
using var smtp = new MailKit.Net.Smtp.SmtpClient();
smtp.Connect(_configuration["MailSetting:Host"], int.Parse(_configuration["MailSetting:Port"]), SecureSocketOptions.StartTlsWhenAvailable);
smtp.Authenticate(_configuration["MailSetting:Username"], _configuration["MailSetting:Password"]);
smtp.ServerCertificateValidationCallback = (s, c, h, e) => true;
await smtp.SendAsync(message);
smtp.Disconnect(true);
}
catch (Exception exception)
{
Logger.Info(exception.Message, exception);
}
}
private static string SendBySMTP(MimeMessage message, Cuenta cuenta)
{
string res = "error";
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
// For demo-purposes, accept all SSL certificates (in case the server supports STARTTLS)
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect(cuenta.ServCorreoSal, (int)cuenta.PuertoCorreoSal, false);
// Note: since we don't have an OAuth2 token, disable
// the XOAUTH2 authentication mechanism.
client.AuthenticationMechanisms.Remove("XOAUTH2");
// Note: only needed if the SMTP server requires authentication
client.Authenticate(cuenta.Usuario, cuenta.Clave);
client.Send(message);
client.Disconnect(true);
res = "ok";
}
return(res);
}
/// <summary>
/// Sends an email based on the method-parameters
/// </summary>
/// <param name="toMail">Recipients emaila</param>
/// <param name="fromMail">Senders email</param>
/// <param name="senderName">senders name</param>
/// <param name="recipientName">recipients name</param>
/// <param name="subject">Email subject</param>
/// <param name="bodyMessage">Email message</param>
/// <param name="type">Enum message type: 1=New customer, 2=Forgot Password, 3=OrderConfirmation, 4=Contact Form</param>
/// <returns>True if successful, else false</returns>
private bool SendMail(string toMail, string fromMail, string senderName, string recipientName, string subject, string bodyMessage, string type = "text")
{
try
{
// Create a MailKit object
var message = new MimeMessage();
message.From.Add(new MailboxAddress(senderName, fromMail));
message.To.Add(new MailboxAddress(recipientName, toMail));
message.Subject = subject;
message.Body = new TextPart(type)
{
Text = bodyMessage
};
// Send away...
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect(_config["Mail:SMTP"], int.Parse(_config["Mail:Port"]), false);
client.Authenticate(_config["Mail:Address"], _config["Mail:Password"]);
client.Send(message);
client.Disconnect(true);
}
}
catch (Exception)
{
// Handle error here, log...
return(false);
}
return(true);
}
public async Task SendEmailAsync(string email, string subject, string htmlMessage)
{
var message = new MimeMessage();
message.Sender = new MailboxAddress(mailSettings.DisplayName, mailSettings.Mail);
message.From.Add(new MailboxAddress(mailSettings.DisplayName, mailSettings.Mail));
message.To.Add(MailboxAddress.Parse(email));
message.Subject = subject;
var builder = new BodyBuilder();
builder.HtmlBody = htmlMessage;
message.Body = builder.ToMessageBody();
// dùng SmtpClient của MailKit
using var smtp = new MailKit.Net.Smtp.SmtpClient();
try {
smtp.Connect(mailSettings.Host, mailSettings.Port, SecureSocketOptions.StartTls);
smtp.Authenticate(mailSettings.Mail, mailSettings.Password);
await smtp.SendAsync(message);
} catch (Exception ex) {
// Gửi mail thất bại, nội dung email sẽ lưu vào thư mục mailssave
System.IO.Directory.CreateDirectory("mailssave");
var emailsavefile = string.Format(@"mailssave/{0}.eml", Guid.NewGuid());
await message.WriteToAsync(emailsavefile);
logger.LogInformation("Lỗi gửi mail, lưu tại - " + emailsavefile);
logger.LogError(ex.Message);
}
smtp.Disconnect(true);
logger.LogInformation("send mail to: " + email);
}
public async Task MailKitSendAsync(string to, string subject, string message)
{
var mimeMessage = new MimeMessage(); // MIME : Multipurpose Internet Mail Extension
mimeMessage.From.Add(new MailboxAddress(_fromAddressTitle, _fromAddress));
mimeMessage.To.Add(new MailboxAddress(to, to));
mimeMessage.Subject = subject;
var bodyBuilder = new MimeKit.BodyBuilder
{
HtmlBody = message,
};
mimeMessage.Body = bodyBuilder.ToMessageBody();
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect(_smtpServer, _smtpPort, _enableSsl);
client.Authenticate(_username, _password); // If using GMail this requires turning on LessSecureApps : https://myaccount.google.com/lesssecureapps
await client.SendAsync(mimeMessage);
client.Disconnect(true);
}
}
private async Task <string> EmailSendAsync(UsrEmail usrEmail)
{
try
{
MimeMessage message = new MimeMessage();
message.From.Add(new MailboxAddress(senderName, emailFrom));
message.To.Add(new MailboxAddress(emailTo));
message.Subject = emailSubject;
message.Body = new BodyBuilder()
{
HtmlBody = $"<div><p>Новое сообщение от {usrEmail.Name}</p><p>{usrEmail.TextMessage}</p><p>адрес для ответа: {usrEmail.EMail}</p></div>"
}.ToMessageBody();
MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient();
client.Connect(smtpServer, (int)port, (bool)useSSL);
client.Authenticate(login, password);
await client.SendAsync(message);
client.Disconnect(true);
return(null);
}
catch (Exception ex)
{
_logger.LogError(ex, "Fail send email");
return("Fail send email");
}
}
public void SendEmailCustom(string email, string url)
{
try
{
MimeMessage message = new MimeMessage();
message.From.Add(new MailboxAddress("Confirm registration", "*****@*****.**"));
message.To.Add(new MailboxAddress(email));
message.Subject = "Confirm registration";
message.Body = new BodyBuilder()
{
HtmlBody = "<div style=\"color: green;\">Confirm registration <a href=" + '"' + url + '"' + ">here</a> and enjoy</div>"
}.ToMessageBody();
using (MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient())
{
IConfigurationSection EmailAuthSection =
Configuration.GetSection("Email:MailKit");
client.Connect("smtp.gmail.com", 587, SecureSocketOptions.StartTls);
client.Authenticate(EmailAuthSection["Login"], EmailAuthSection["Password"]);
client.Send(message);
client.Disconnect(true);
logger.LogInformation("Register confirmation email has been sent successfully");
}
}
catch (Exception e)
{
logger.LogError(e.GetBaseException().Message);
}
}
/// <summary>
/// 发送电子邮件。
/// </summary>
/// <param name="settings">网站配置。</param>
/// <param name="message">消息实例。</param>
/// <returns>返回发送任务。</returns>
protected virtual async Task SendAsync(EmailSettings settings, Email message)
{
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
await client.ConnectAsync(settings.SmtpServer, settings.SmtpPort, settings.UseSsl);
await client.AuthenticateAsync(settings.SmtpUserName, settings.SmtpPassword);
var mail = new MimeMessage();
mail.From.Add(new MailboxAddress(settings.SmtpUserName));
mail.To.Add(new MailboxAddress(message.To));
mail.Subject = message.Title;
var html = new TextPart("Html")
{
Text = message.Content
};
var multipart = await InitAsync(mail, message);
if (multipart != null)
{
multipart.Insert(0, html);
mail.Body = multipart;
}
else
{
mail.Body = html;
}
await client.SendAsync(mail);
}
}
public async Task SendMail(MailBody mailBody, MailServerConfig mailServer, Action messageSentAction = null)
{
if (mailBody == null)
{
throw new ArgumentException("参数为null");
}
var mimeMessage = new MimeMessage();
mimeMessage.Subject = mailBody.Subject;
mimeMessage.From.Add(new MailboxAddress(mailBody.Sender, mailBody.SenderAddress));
mimeMessage.Body = new TextPart(mailBody.BodyType)
{
Text = mailBody.Body
};
mimeMessage.To.Add(new MailboxAddress(mailBody.Revicer, mailBody.RevicerAddress));
using (var smtp = new MailKit.Net.Smtp.SmtpClient())
{
if (messageSentAction != null)
{
smtp.MessageSent += (sender, e) =>
{
messageSentAction();
};
}
smtp.ServerCertificateValidationCallback = (s, c, h, e) => true;
await smtp.ConnectAsync(mailServer.Server, mailServer.Port, SecureSocketOptions.SslOnConnect);
await smtp.AuthenticateAsync(mailServer.Account, mailServer.Password);
await smtp.SendAsync(mimeMessage);
await smtp.DisconnectAsync(true);
}
}
public async Task SendEmailAsync(Message j)
{
try
{
var mes = new MimeMessage();
mes.From.Add(new MailboxAddress("*****@*****.**"));
var adresses = j.To.Split(";");
foreach (var to in adresses)
{
mes.To.Add(new MailboxAddress(to.Trim()));
}
mes.Subject = j.Subject;
mes.Body = new BodyBuilder()
{
TextBody = j.Body
}.ToMessageBody();
using (MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect("smtp.gmail.com", 25, false);
client.Authenticate("*****@*****.**", "svic..azen92276");
await client.SendAsync(mes);
client.Disconnect(true);
}
}
catch
{
}
}
public async Task <bool> SendEmailAsync(SmtpConfig config, string toAddress, string toName, string subject, string messages)
{
try
{
var message = new MimeMessage();
message.From.Add(new MailboxAddress(config.FromName, config.FromAddress));
message.To.Add(new MailboxAddress(toName, toAddress));
message.Subject = subject;
message.Body = new TextPart("plain")
{
Text = messages
};
using var client = new MailKit.Net.Smtp.SmtpClient
{
ServerCertificateValidationCallback = (s, c, h, e) => true
};
client.Connect(config.Server, config.Port, config.UseSsl);
client.Authenticate(config.Username, config.Password);
client.Disconnect(true);
client.Send(message);
await client.SendAsync(message);
return(true);
}
catch (Exception)
{
return(false);
}
}
static void smtp_send(MimeMessage message)
{
// all our outgoing emails get sent from what's
// configured in config file
var from_address = new MailboxAddress(
bd_config.get(bd_config.OutgoingEmailDisplayName),
bd_config.get(bd_config.SmtpUser));
message.From.Add(from_address);
if (bd_config.get(bd_config.DebugSkipSendingEmails) == 0)
{
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect(
bd_config.get(bd_config.SmtpHost),
bd_config.get(bd_config.SmtpPort),
MailKit.Security.SecureSocketOptions.Auto);
string smtp_user = bd_config.get(bd_config.SmtpUser);
string smtp_password = bd_config.get(bd_config.SmtpPassword);
client.Authenticate(smtp_user, smtp_password);
client.Send(message);
client.Disconnect(true);
}
}
}
/// <summary>
/// Sends an email
/// </summary>
/// <param name="emailAccount">Email account to use</param>
/// <param name="subject">Subject</param>
/// <param name="body">Body</param>
/// <param name="fromAddress">From address</param>
/// <param name="fromName">From display name</param>
/// <param name="toAddress">To address</param>
/// <param name="toName">To display name</param>
public virtual async Task SendEmail(MailOptions emailAccount, string subject, string body,
string fromAddress, string fromName, string toAddress, string toName)
{
var message = new MimeMessage();
//from, to, reply to
message.From.Add(new MailboxAddress(fromName, fromAddress));
message.To.Add(new MailboxAddress(toName, toAddress));
//subject
message.Subject = subject;
//content
var builder = new BodyBuilder
{
HtmlBody = body
};
message.Body = builder.ToMessageBody();
//send email
using var smtpClient = new MailKit.Net.Smtp.SmtpClient();
//smtpClient.ServerCertificateValidationCallback = (s, c, h, e) => emailAccount.UseServerCertificateValidation;
await smtpClient.ConnectAsync(emailAccount.Server, emailAccount.Port, SecureSocketOptions.Auto);
await smtpClient.AuthenticateAsync(emailAccount.Account, emailAccount.Password);
await smtpClient.SendAsync(message);
await smtpClient.DisconnectAsync(true);
}
private static async Task <bool> KlncEPostasınaŞifreGönder(Kullanıcı klnc)
{
try
{
var clnt = new MailKit.Net.Smtp.SmtpClient();
clnt.Send(
new MimeKit.MimeMessage()
{
Body = new MimeKit.TextPart(MimeKit.Text.TextFormat.Text)
{
Text = ""
},
Subject = ""
},
new MimeKit.MailboxAddress(""),
new List <MimeKit.MailboxAddress>()
{
new MimeKit.MailboxAddress("")
});
return(true);
}
catch (Exception ex)
{
await HazırlaWebYardımcı.HataKaydet(ex);
throw ex;
}
}
public void SendEmail(byte[] content, params string[] emails)
{
foreach (var email in emails)
{
var message = new MimeMessage();
message.From.Add(new MailboxAddress("Стремный график", "*****@*****.**"));
message.To.Add(new MailboxAddress(email));
message.Subject = "Твой график";
var builder = new BodyBuilder {
HtmlBody = "<div style=\"color: green;\">Твой странный график ы</div>"
};
builder.Attachments.Add("Your graph.jpeg", content);
builder.Attachments.Add("тихон.jpg");
message.Body = builder
.ToMessageBody();
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect("smtp.gmail.com", 465, true);
client.Authenticate("*****@*****.**", "tupyegraphiki");
client.Send(message);
client.Disconnect(true);
}
}
}
public EmailMessage NewSendMail(EmailMessage emailMessage)
{
//Using Mail Kit
var message = new MimeMessage();
message.To.AddRange(emailMessage.ToAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
message.From.AddRange(emailMessage.FromAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
message.Subject = emailMessage.Subject;
message.Body = new TextPart(TextFormat.Text)
{
Text = emailMessage.Content
};
using (var emailClient = new MailKit.Net.Smtp.SmtpClient())
{
emailClient.ServerCertificateValidationCallback = (s, c, ch, e) => true;
emailClient.Connect(appSettings.SmtpServer, appSettings.SmtpPort, SecureSocketOptions.StartTls);
emailClient.AuthenticationMechanisms.Remove("XOAUTH2");
emailClient.Authenticate(appSettings.Username, appSettings.Password);
emailClient.Send(message);
emailClient.Disconnect(true);
return(emailMessage);
}
}
private async Task <SmtpClient> CreateConnectedSmtpClientAsync(CancellationToken cancellationToken)
{
var smtpClient = new SmtpClient();
try
{
await smtpClient.ConnectAsync(
this._mailSettings.Host,
this._mailSettings.Port,
this._mailSettings.EnableSSL,
cancellationToken
);
if (this._mailSettings.HasAuthenticationInfo)
{
await smtpClient.AuthenticateAsync(
this._mailSettings.UserName,
this._mailSettings.Password,
cancellationToken
);
}
return(smtpClient);
}
catch (Exception ex)
{
this._logger.LogError(ex, $"Unable to create SMTP client for {this._mailSettings.Host}:{this._mailSettings.Port}");
smtpClient?.Dispose();
throw new MailServiceException($"Unable to create SMTP client for host {this._mailSettings.Host}", ex);
}
}
public void SendEmail(string toEmail, string subject, string textMessage, Stream attachment = null, string attachmentName = null)
{
try
{
var settings = _context.Settings.FirstOrDefault();
var message = new MimeMessage();
message.From.Add(new MailboxAddress(settings.FromEmail));
message.To.Add(new MailboxAddress(toEmail));
message.Subject = subject;
var bodyBuilder = new BodyBuilder
{
HtmlBody = textMessage,
TextBody = textMessage
};
message.Body = bodyBuilder.ToMessageBody();
if (!string.IsNullOrEmpty(attachmentName))
{
bodyBuilder.Attachments.Add(attachmentName, attachment);
}
using var client = new MailKit.Net.Smtp.SmtpClient();
client.Connect(settings.SmtpHost, settings.SmtpPort, SecureSocketOptions.StartTls);
client.Authenticate(settings.FromEmail, settings.FromEmailPassword);
client.Send(message);
client.Disconnect(true);
}
catch (Exception ex)
{
_logger.LogError("Error Sending Email", ex);
}
}
public void Send(EmailMessage msg)
{
var message = new MimeMessage();
message.To.AddRange(msg.ToAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
message.From.AddRange(msg.FromAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
message.Subject = msg.Subject;
message.Body = new TextPart("plain")
{
Text = msg.Content
};
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect(_eConfig.SmtpServer, _eConfig.SmtpPort);
client.AuthenticationMechanisms.Remove("XOAUTH2");
client.Authenticate(_eConfig.SmtpUsername, _eConfig.SmtpPassword);
client.Send(message);
client.Disconnect(true);
}
}
private async Task Send(MimeMessage message, EmailNotificationSettings settings)
{
try
{
using (var client = new SmtpClient())
{
client.Connect(settings.EmailHost, settings.EmailPort); // Let MailKit figure out the correct SecureSocketOptions.
// Note: since we don't have an OAuth2 token, disable
// the XOAUTH2 authentication mechanism.
client.AuthenticationMechanisms.Remove("XOAUTH2");
if (settings.Authentication)
{
client.Authenticate(settings.EmailUsername, settings.EmailPassword);
}
Log.Info("sending message to {0} \r\n from: {1}\r\n Are we authenticated: {2}", message.To, message.From, client.IsAuthenticated);
await client.SendAsync(message);
await client.DisconnectAsync(true);
}
}
catch (Exception e)
{
Log.Error(e);
}
}
public Task SendEmailAsync(string email, string subject, string htmlMessage)
{
try
{
var message = new MimeMessage();
message.From.Add(new MailboxAddress("Bus Application", "*****@*****.**"));
message.To.Add(new MailboxAddress("Client", email));
message.Subject = subject;
message.Body = new TextPart("html")
{
Text = htmlMessage
};
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.Connect("smtp.poczta.onet.pl", 465, true);
client.Authenticate("*****@*****.**", "asdasDsdf4g#g&dsSdD3@sd@fsd@");
client.Send(message);
client.Disconnect(true);
}
}
catch (Exception ex)
{
}
return(Task.CompletedTask);
}
private async Task <MailKit.IMailTransport> CreateTransport()
{
SecureSocketOptions secureSocketOptions = SecureSocketOptions.SslOnConnect;
MailKit.Net.Smtp.SmtpClient smtpClient = new MailKit.Net.Smtp.SmtpClient();
smtpClient.ServerCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
try {
await smtpClient.ConnectAsync(_Settings.SmtpMailServer, _Settings.SmtpPort, secureSocketOptions);
var authMech = smtpClient.AuthenticationMechanisms;
if (smtpClient.IsConnected)
{
await smtpClient.AuthenticateAsync(_Settings.SenderLogin, _Settings.SenderPassword);
}
if (!smtpClient.IsAuthenticated)
{
return(smtpClient);
}
}
catch (AggregateException e) {
_Logger?.LogError(e, e.Message);
throw;
}
return(smtpClient);
}
private async Task SendEmailAsync(Action <InternetAddressList> action, string subject, string content)
{
var settings = _settingsManager.GetSettings <EmailSettings>();
if (!settings.Enabled)
{
return;
}
var site = _settingsManager.GetSettings <SiteSettings>();
var message = new MimeMessage();
message.From.Add(new MailboxAddress(site.SiteName, settings.SmtpUserName));
action(message.To);
message.Subject = ReplaceKeyWords(site, subject);
var html = new TextPart("html");
html.Text = ReplaceKeyWords(site, content);
message.Body = html;
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.AuthenticationMechanisms.Remove("XOAUTH2");
await client.ConnectAsync(settings.SmtpServer, settings.SmtpPort, settings.UseSsl);
await client.AuthenticateAsync(settings.SmtpUserName, settings.SmtpPassword);
await client.SendAsync(message);
await client.DisconnectAsync(true);
}
}
public IActionResult SendBroadcast(string title, string message)
{
var msg = new MimeMessage();
var user = from i in _AppDbContext.employees.OrderBy(x => x.Id) select i;
foreach (var i in user)
{
var nama = i.Name;
var emailAddress = i.Email;
msg.From.Add(new MailboxAddress("HR", "*****@*****.**"));
msg.To.Add(new MailboxAddress(nama, emailAddress));
msg.Subject = title;
msg.Body = new TextPart("Plain")
{
Text = message
};
using (var client = new MailKit.Net.Smtp.SmtpClient())
{
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect("smtp.mailtrap.io", 587, false);
client.Authenticate("785fd04dea6d9c", "6057ae43ba12a4");
client.Send(msg);
client.Disconnect(true);
}
}
return(RedirectToAction("Send", "Broadcast"));
}