/// <summary>
/// Adds the <c>IEmailSender</c> services to the specified <c>Microsoft.Extensions.DependencyInjection.IServiceCollection</c>.
/// <c>EmailOptions</c> will be loaded from the the settings configuration,
/// if any; otherwise, default <c>EmailOptions</c> will be used instead.
/// </summary>
/// <param name="services">The <c>Microsoft.Extensions.DependencyInjection.IServiceCollection</c> to add the service to.</param>
/// <param name="settings">
/// The settings used to bind configurations to the <c>EmailOptions</c>.
/// Make sure the Configuration and EmailOptionsConfigurationKey property are set.
/// </param>
/// <returns>A reference to this instance after the operation has completed.</returns>
public static IServiceCollection AddForEvolveEmailSender(this IServiceCollection services, ForEvolveAspNetCoreSettings settings)
{
var emailOptions = new EmailOptions();
settings.Configuration?.Bind(settings.EmailOptionsConfigurationKey, emailOptions);
return(services.AddForEvolveEmailSender(emailOptions));
}
public async Task <bool> AddNewUser(UserInputViewModel userInputVm)
{
var user = new User {
UserName = userInputVm.Username, Email = userInputVm.Email
};
var randomPassword = RandomString.GenerateRandomString();
var result = await _userService.CreateAsync(user, randomPassword);
if (!result.Succeeded)
{
return(false);
}
await _userService.AddUserToRolesAsync(user, userInputVm.Roles);
var context = _httpContextAccessor.HttpContext;
var code = await _userService.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = _urlHelperExtension.EmailConfirmationLink(user.Id, code, context.Request.Scheme);
var emailOptions = new EmailOptions
{
Url = callbackUrl,
Password = randomPassword,
UserName = userInputVm.Username
};
await _emailSender.SendEmailAsync(userInputVm.Email, "", emailOptions, EmailType.AccountConfirm);
return(true);
}
public EmailService(
IOptions <EmailOptions> options,
ILogger <EmailService> logger)
{
_emailOptions = options.Value ?? throw new ArgumentNullException(nameof(options));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
private static IServiceCollection AddForEvolveAspNetCore(this IServiceCollection services, ForEvolveAspNetCoreSettings settings)
{
// Setup configs
services.AddSingleton(settings);
// Error and OperationResults
services
.AddForEvolveErrorFactory()
.AddForEvolveOperationResults()
;
// Others
services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.TryAddSingleton <IHttpRequestValueFinder, HttpRequestValueFinder>();
// Emails
services.TryAddScoped <IViewRenderer, ViewRenderer>();
services.TryAddSingleton <IEmailSender, DefaultEmailSender>();
var emailOptions = new EmailOptions();
settings.Configuration?.Bind(settings.EmailOptionsConfigurationKey, emailOptions);
services.TryAddSingleton(emailOptions);
return(services);
}
public async Task SendEmailAsync(EmailOptions emailOptions)
{
var fromAddress = new MailAddress("*****@*****.**", "Dave Armstrong");
var toAddress = new MailAddress(emailOptions.Email, "Idris");
string fromPassword = "******";
string subject = emailOptions.Subject;
string body = emailOptions.Content;
var smtp = new System.Net.Mail.SmtpClient
{
Host = "smtp.gmail.com",
Port = 587,
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
Credentials = new NetworkCredential(fromAddress.Address, fromPassword),
Timeout = 20000
};
using (var message = new MailMessage(fromAddress, toAddress)
{
Subject = subject,
Body = body,
IsBodyHtml = true
})
{
smtp.Send(message);
}
}
public async Task SendEmails(EmailOptions emailOptions)
{
MailMessage mail = new MailMessage()
{
Subject = emailOptions.Subject,
Body = emailOptions.Body,
From = new MailAddress(_smtpConfig.SenderAddress, _smtpConfig.SenderDisplayName),
IsBodyHtml = _smtpConfig.IsBodyHtml
};
foreach (var receiver in emailOptions.EmailReceivers)
{
mail.To.Add(receiver);
}
NetworkCredential networkCredential = new NetworkCredential(_smtpConfig.UserName, _smtpConfig.Password);
SmtpClient smtpClient = new SmtpClient()
{
Host = _smtpConfig.Host,
Port = _smtpConfig.Port,
EnableSsl = _smtpConfig.EnableSSL,
UseDefaultCredentials = _smtpConfig.UseDefaultCredential,
Credentials = networkCredential,
};
mail.BodyEncoding = Encoding.Default;
await smtpClient.SendMailAsync(mail);
}
private async Task SendEmail(EmailOptions emailOptions)
{
MailMessage mail = new MailMessage()
{
Subject = emailOptions.Subject,
Body = emailOptions.Body,
From = new MailAddress(_smtpOptions.SenderAddress, _smtpOptions.SenderDisplayName),
IsBodyHtml = _smtpOptions.IsBodyHtml
};
foreach (var email in emailOptions.EmailReceivers)
{
mail.To.Add(email);
}
NetworkCredential networkCredential = new NetworkCredential(_smtpOptions.UserName, _smtpOptions.Password);
SmtpClient smtpClient = new SmtpClient
{
Host = _smtpOptions.Host,
Port = _smtpOptions.Port,
EnableSsl = _smtpOptions.EnableSSL,
UseDefaultCredentials = true,
Credentials = networkCredential
};
//SmtpClient smtpClient = new SmtpClient("smtp.gmail.com", 587);
//smtpClient.UseDefaultCredentials = true;
//smtpClient.EnableSsl = true;
//smtpClient.Credentials = networkCredential;
mail.BodyEncoding = Encoding.Default;
await smtpClient.SendMailAsync(mail);
}
public async Task SendTestEmail(EmailOptions emailOptions)
{
emailOptions.Subject = UpdatePlaceHolders("Greetings {{Username}}.", emailOptions.PlaceHolders);
emailOptions.Body = UpdatePlaceHolders(GetEmailBody("Email"), emailOptions.PlaceHolders);
await SendEmail(emailOptions);
}
public async Task SendEmailVerificationEmail(EmailOptions emailOptions)
{
emailOptions.Subject = UpdatePlaceHolders("Please verify your email.", emailOptions.PlaceHolders);
emailOptions.Body = UpdatePlaceHolders(GetEmailBody("EmailVerification"), emailOptions.PlaceHolders);
await SendEmail(emailOptions);
}
public static EmailOptions ReadFromConfiguration(IConfiguration config, AppOptions appOptions)
{
var options = new EmailOptions();
options.EnableDailySummary = config.GetValue(nameof(options.EnableDailySummary), appOptions.AppMode == AppMode.Production);
options.AllowedOutboundAddresses = config.GetValueList(nameof(options.AllowedOutboundAddresses)).Select(v => v.ToLowerInvariant()).ToList();
options.TestEmailAddress = config.GetValue(nameof(options.TestEmailAddress), appOptions.AppMode == AppMode.Development ? "test@localhost" : "");
string emailConnectionString = config.GetConnectionString("Email");
if (!String.IsNullOrEmpty(emailConnectionString))
{
var uri = new SmtpUri(emailConnectionString);
options.SmtpHost = uri.Host;
options.SmtpPort = uri.Port;
options.SmtpUser = uri.User;
options.SmtpPassword = uri.Password;
}
options.SmtpFrom = config.GetValue(nameof(options.SmtpFrom), appOptions.AppMode == AppMode.Development ? "Exceptionless <noreply@localhost>" : "");
options.SmtpEncryption = config.GetValue(nameof(options.SmtpEncryption), GetDefaultSmtpEncryption(options.SmtpPort));
if (String.IsNullOrWhiteSpace(options.SmtpUser) != String.IsNullOrWhiteSpace(options.SmtpPassword))
{
throw new ArgumentException("Must specify both the SmtpUser and the SmtpPassword, or neither.");
}
return(options);
}
public SendGridEmailService(HttpClient httpClient, IFileService fileService, SendGridOptions sendGridOptions, EmailOptions emailOptions)
{
_httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
_fileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
_sendGridOptions = sendGridOptions ?? throw new ArgumentNullException(nameof(sendGridOptions));
_emailOptions = emailOptions ?? throw new ArgumentNullException(nameof(emailOptions));
}
public ChangeEmailController(IEmailPublisher email, UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, IOptions <EmailOptions> options)
{
_email = email;
_userManager = userManager;
_signInManager = signInManager;
_options = options.Value;
}
public async Task SendEmailAsync(EmailEnvelop emailEnvelop, EmailOptions emailOptions = null)
{
if (emailOptions == null)
{
emailOptions = _emailOptions.CurrentValue;
}
if (emailOptions.SkipMode)
{
return;
}
var client = new SmtpClient(emailOptions.Host, emailOptions.Port)
{
Credentials = new NetworkCredential(emailOptions.UserName, emailOptions.Password),
EnableSsl = emailOptions.EnableSSL
};
#pragma warning disable CA2000 // Dispose objects before losing scope
await client.SendMailAsync(
new MailMessage(emailOptions.From, emailEnvelop?.To, emailEnvelop.Subject, emailEnvelop.Body)
{ IsBodyHtml = true }
).ConfigureAwait(false);
#pragma warning restore CA2000 // Dispose objects before losing scope
client.Dispose();
}
public EmailService(
IOptions <EmailOptions> emailOptions,
IHostingEnvironment env)
{
_emailOptions = emailOptions.Value;
_env = env;
}
public void CreateMimeMessage_GeneratesMimeMessageCorrectly()
{
// Arrange
string emailAddress = "*****@*****.**";
string subject = "subject";
string message = "message";
EmailOptions emailOptions = new EmailOptions();
Mock <IOptions <EmailOptions> > mockOptions = new Mock <IOptions <EmailOptions> >();
mockOptions.Setup(o => o.Value).Returns(emailOptions);
EmailService emailSender = new EmailService(mockOptions.Object, null);
// Act
MimeMessage mimeMessage = emailSender.CreateMimeMessage(emailAddress, subject, message);
// Assert
mockOptions.VerifyAll();
Assert.Equal(message, mimeMessage.TextBody);
Assert.Equal(subject, mimeMessage.Subject);
Assert.Equal($"\"{emailAddress}\" <{emailAddress}>", mimeMessage.To.ToString());
Assert.Equal($"\"{emailOptions.Name}\" <{emailOptions.EmailAddress}>", mimeMessage.From.ToString());
}
private void AddEmailButton_Click(object sender, EventArgs e)
{
using (AddEmailDlg dlg = new AddEmailDlg())
{
if (dlg.ShowDialog() == DialogResult.OK)
{
EmailOptions options = new EmailOptions(dlg.EmailAddress, dlg.CooldownTime) // We do need to track changes here because each email has numerous properties
{
EndTime = new DateTime(2020, 1, 1, 23, 59, 59),
StartTime = new DateTime(2020, 1, 1, 0, 0, 0),
Active = true,
NumberOfImages = 1
};
_area.Notifications.Email.Add(options);
ListViewItem item = new ListViewItem(new string[] { dlg.EmailAddress, dlg.CooldownTime.ToString() });
emailsList.Items.Add(item);
int index = item.Index;
emailsList.Items[index].Tag = options;
emailsList.Items[index].Focused = true;
emailsList.Items[index].Selected = true;
SetEmailControls(options);
item.Checked = true;
emailsList.Select();
}
}
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordViewModel model)
{
var user = await _userService.FindByEmailAsync(model.Email);
if (user == null || !(await _userService.IsEmailConfirmedAsync(user)))
{
return(Ok());
}
var token = await _userService.GeneratePasswordResetTokenAsync(user);
await _userService.ToggleRequestPasswordStatusByEmail(model.Email);
await _userService.SaveResetPasswordRequest(token, model.Email);
var callbackUrl = _urlHelper.ResetPasswordCallbackLink(model.Email, token, Request.Scheme);
var emailOptions = new EmailOptions
{
Url = callbackUrl,
Token = token
};
await _emailSender.SendEmailAsync(model.Email, "", emailOptions, EmailType.ForgotPassword);
return(Ok());
}
public void SerializeEmailOptions()
{
EmailOptions s = new EmailOptions();
s.FromAddress = TestContext.CurrentContext.Random.GetString();
s.Host = TestContext.CurrentContext.Random.GetString();
s.Password = new EncryptedData()
{
Data = TestContext.CurrentContext.Random.GetString(),
Mode = TestContext.CurrentContext.Random.Next(),
Salt = TestContext.CurrentContext.Random.GetString()
};
s.Port = TestContext.CurrentContext.Random.Next();
s.UseDefaultCredentials = true;
s.Username = TestContext.CurrentContext.Random.GetString();
s.UseSsl = true;
EmailOptions n = JsonConvert.DeserializeObject <EmailOptions>(JsonConvert.SerializeObject(s));
Assert.AreEqual(s.FromAddress, n.FromAddress);
Assert.AreEqual(s.Host, n.Host);
Assert.AreEqual(s.Password.Salt, n.Password.Salt);
Assert.AreEqual(s.Password.Mode, n.Password.Mode);
Assert.AreEqual(s.Password.Data, n.Password.Data);
Assert.AreEqual(s.Port, n.Port);
Assert.AreEqual(s.UseDefaultCredentials, n.UseDefaultCredentials);
Assert.AreEqual(s.Username, n.Username);
Assert.AreEqual(s.UseSsl, n.UseSsl);
}
public EmailViewModel(EmailOptions model, RandomNumberGenerator rng, INotifiableEventPublisher eventPublisher)
{
this.model = model;
this.rng = rng;
this.DisplayName = "Email";
eventPublisher.Register(this);
}
public EmailSender(
IEnumerable <IEmailProviderType> emailProviderTypes,
IOptions <EmailOptions> options,
IStorageFactory storageFactory,
ITemplateLoaderFactory templateLoaderFactory)
{
this.options = options.Value;
var providerType = emailProviderTypes
.FirstOrDefault(x => x.Name == this.options.Provider.Type);
if (providerType == null)
{
throw new ArgumentNullException("ProviderType", $"The provider type {this.options.Provider.Type} does not exist. Maybe you are missing a reference or an Add method call in your Startup class.");
}
this.provider = providerType.BuildProvider(this.options.Provider);
if (!string.IsNullOrWhiteSpace(this.options.TemplateStorage))
{
var store = storageFactory.GetStore(this.options.TemplateStorage);
if (store == null)
{
throw new ArgumentNullException("TemplateStorage", $"There is no file store configured with name {this.options.TemplateStorage}. Unable to initialize email templating.");
}
this.templateLoader = templateLoaderFactory.Create(store);
}
}
private JObject CreateMessage(EmailOptions options)
{
var from = new JObject
{
{ Constants.Mailjet.Email, this.mailjetApiSettings.Sender },
{ Constants.Mailjet.Name, this.mailjetApiSettings.SenderName }
};
var to = new JArray
{
new JObject
{
{ Constants.Mailjet.Email, options.ToEmail },
{ Constants.Mailjet.Name, options.ToName }
}
};
var message = new JObject
{
{ Constants.Mailjet.From, from },
{ Constants.Mailjet.To, to },
{ Constants.Mailjet.Subject, options.Subject }
};
return(message);
}
public async Task SendConfirmationEmailAsync(string userName)
{
var user = await this.userSharedService.FindByEmailAsync(userName);
if (!user.EmailConfirmed)
{
this.localizer.Get("EmailAlreadyConfirmed");
}
var token = await this.userManager.GenerateEmailConfirmationTokenAsync(user);
var link = this.GenerateConfirmationEmailLink(user, token);
var settings = new EmailOptions
{
Subject = this.localizer.Get("ConfirmationEmailSubject"),
ToEmail = user.Email,
ToName = null,
TemplateId = this.localizer.Get("ConfirmationEmailBody")
};
settings.Variables.Add(Constants.Mailjet.Keys.ConfirmationEmailLink, link);
await this.mailjetService.Send(settings);
}
/// <summary>
/// Prepare Email options for various system requests
/// </summary>
/// <param name="requestViewModel"></param>
/// <returns></returns>
private EmailOptions PrepareEmailOptions(RequestViewModel requestViewModel)
{
var emailOptions = new EmailOptions();
var msgBody = SendGridMailHelper.MailBody(_hostingEnvironment, emailOptions.Template);
if (!string.IsNullOrEmpty(msgBody))
{
emailOptions.Subject = "Request Received - SubQuip";
emailOptions.CcMail = new MailUser {
Name = requestViewModel.MailUsers[0].Name, Email = requestViewModel.MailUsers[0].Email
};
emailOptions.HtmlBody = msgBody.Replace("{Name}", emailOptions.CcMail.Name).Replace("{Email}", emailOptions.CcMail.Email).Replace("{Company}", requestViewModel.Company).Replace("{PhoneNumber}", requestViewModel.PhoneNumber).Replace("{FromDate}", requestViewModel.FromDate.ToString("dd-MM-yyyy")).Replace("{ToDate}", requestViewModel.ToDate.ToString("dd-MM-yyyy")).Replace("{Description}", requestViewModel.Description).Replace("{Type}", requestViewModel.Type.ToString());
emailOptions.PlainBody = string.Empty;
emailOptions.Template = MailTemplate.Request;
emailOptions.ToMailsList = new List <MailUser> {
new MailUser {
Name = "SubQuip", Email = _configuration["requestEmail"]
}
};
emailOptions.Attachments = new List <Attachment>
{
new Attachment()
{
Content = System.Text.Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(requestViewModel)),
Name = "Request.json",
ContentType = "text/json"
}
};
}
return(emailOptions);
}
public CssInliner(EmailOptions options)
{
if (EmailCssContent == null && options.CssPath != null)
{
EmailCssContent = File.ReadAllText(options.CssPath, Encoding.UTF8);
}
}
public MailgunMessageSender(IMailgunApi api, IOptionsSnapshot <MailgunOptions> mailgunOptions, ILogger <MailgunMessageSender> logger, IOptionsSnapshot <EmailOptions> emailOptions)
{
_api = api;
_mailgunOptions = mailgunOptions.Value;
_logger = logger;
_emailOptions = emailOptions.Value;
}
/// <summary>
/// Adds the <c>IEmailSender</c> services to the specified <c>Microsoft.Extensions.DependencyInjection.IServiceCollection</c>.
/// Default <c>EmailOptions</c> will be used.
/// </summary>
/// <param name="services">The <c>Microsoft.Extensions.DependencyInjection.IServiceCollection</c> to add the service to.</param>
/// <param name="emailOptionsAction">The action used to configure the <c>EmailOptions</c>.</param>
/// <returns>A reference to this instance after the operation has completed.</returns>
public static IServiceCollection AddForEvolveEmailSender(this IServiceCollection services, Action <EmailOptions> emailOptionsAction = null)
{
var emailOptions = new EmailOptions();
emailOptionsAction?.Invoke(emailOptions);
return(services.AddForEvolveEmailSender(emailOptions));
}
private void SizeImageToNumeric_ValueChanged(object sender, EventArgs e)
{
if (emailsList.SelectedIndices.Count > 0)
{
EmailOptions opt = (EmailOptions)emailsList.Items[emailsList.SelectedIndices[0]].Tag;
opt.SizeDownToPercent = (int)sizeImageToNumeric.Value;
}
}
private void NumberOfImages_ValueChanged(object sender, EventArgs e)
{
if (emailsList.SelectedIndices.Count > 0)
{
EmailOptions opt = (EmailOptions)emailsList.Items[emailsList.SelectedIndices[0]].Tag;
opt.NumberOfImages = (int)numberOfImages.Value;
}
}
private void SelectionChanged(object sender, EventArgs e)
{
if (emailsList.SelectedItems.Count > 0)
{
EmailOptions opt = (EmailOptions)emailsList.SelectedItems[0].Tag; // to avoid clutter
SetEmailControls(opt);
}
}
public SecretRekeyProvider(IDialogCoordinator dialogCoordinator, ILogger <SecretRekeyProvider> logger, AuthenticationOptions authnOptions, EmailOptions emailOptions, IProtectedSecretProvider secretProvider)
{
this.dialogCoordinator = dialogCoordinator;
this.logger = logger;
this.authnOptions = authnOptions;
this.emailOptions = emailOptions;
this.secretProvider = secretProvider;
}
public static void SendEmail(EmailOptions options, string to, string from, string subject, string message)
{
var client = new SmtpClient {
Host = options.SmtpServer,
Port = options.Port,
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
UseDefaultCredentials = false,
Credentials = new NetworkCredential(options.Username, options.Password)
};
var mailMessage = new MailMessage() {
From = new MailAddress(from, "CHABS No Reply"),
To = { to },
Body = message,
Subject = subject
};
try {
client.Send(mailMessage);
} catch (Exception ex) {
throw new Exception("Could not send email", ex);
}
}
private bool sendMessage(Email mail, EmailOptions options)
{
try
{
int port;
int.TryParse(options.SmtpPort, out port);
//Настройки сервера
SmtpClient Smtp = new SmtpClient(options.SmtpServer, port)
{
Credentials = new NetworkCredential(options.User, options.Password),
EnableSsl = true,
Timeout = 60000
};
//Формирование письма
MailMessage Message = new MailMessage
{
From = new MailAddress(options.EmailSender, options.Sender, Encoding.UTF8),
Subject = mail.Topic,
Body = mail.Body,
HeadersEncoding = Encoding.UTF8,
SubjectEncoding = Encoding.UTF8
};
//Формирование MailTo
string[] mailToGroup = mail.SendTo.Split(';');
foreach (string ardess in mailToGroup)
{
if (ardess.Trim() != "")
{
Message.To.Add(new MailAddress(ardess.Trim()));
}
}
//Send
Smtp.Send(Message);
//eventLog.WriteEntry(string.Format("Письмо на адрес: '{0}' отослано!", mail.SendTo));
return true;
}
catch (Exception exp)
{
//eventLog.WriteEntry(
//string.Format("Произошла ошибка при отправке почты.\r\nСообщение об ошибке: {0}\r\n{1}",
//exp.Message, exp.InnerException != null ? exp.InnerException.Message : "..."));
return false;
}
}
/// <summary>
/// <para>Sets the authenticated user’s email preferences. POST
/// </para>
/// REQUIRES AUTHENTICATION.
/// </summary>
/// <param name="request">EmailOptions</param>
/// <returns>XDocument: EmailOptions.</returns>
public XDocument SetEmailPreferences(EmailOptions request)
{
var query = String.Format(Constants.Culture, "{0}/EmailOptions{1}", Constants.MY_TRADEME, Constants.XML);
return _connection.Post(request, query, true);
}
/// <summary>
/// <para>Sets the authenticated user’s email preferences. POST
/// </para>
/// REQUIRES AUTHENTICATION.
/// </summary>
/// <param name="request">EmailOptions</param>
/// <returns>XDocument: EmailOptions.</returns>
public XDocument SetEmailPreferences(EmailOptions request)
{
if (_myTradeMe == null)
{
_myTradeMe = new MyTradeMeMethods(_connection);
}
return _myTradeMe.SetEmailPreferences(request);
}