private void _saveButton_Click(object sender, EventArgs e)
{
int smtpPort;
int.TryParse(_smtpPortTextBox.Text, out smtpPort);
if (smtpPort == 0)
{
smtpPort = 25;
}
MailOptions options = new MailOptions
{
FromAddress = _fromAddressTextBox.Text,
SmtpHost = _smtpHostTextBox.Text,
SmtpPassword = _smtpPasswordTextBox.Text,
SmtpPort = smtpPort,
SmtpUsername = _smtpUsernameTextBox.Text,
ToAddresses = new List <string>(_toAddressesTextBox.Text.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()))
};
MailOptionsRepository.Set(options);
MessageBox.Show("Email settings saved!", "Email Settings", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
}
public EmailSenderService(IOptions <MailOptions> mailOptions)
{
_mailOptions = mailOptions.Value;
_smtpClient = new SmtpClient(_mailOptions.Host, _mailOptions.Port);
_smtpClient.Credentials = new NetworkCredential(_mailOptions.UserName, _mailOptions.Password);
_smtpClient.EnableSsl = true;
}
private void SendMail()
{
ButtonProgressAssist.SetIsIndicatorVisible(Send, true);
ClientOptions clientOptions = Utils.ReadConfig();
MailOptions mailOptions = new MailOptions
{
From = From.Text.Trim(),
To = GetItems(To),
Cc = GetItems(Cc),
Subject = Subject.Text.Trim(),
Body = Body.Text.Trim()
};
MailClient mailClient = new MailClient(clientOptions);
mailClient.Sended += () =>
{
Utils.InvokeUIThread(() =>
{
ButtonProgressAssist.SetIsIndicatorVisible(Send, false);
ShowMessage("Mail Sended!");
});
};
mailClient.Send(mailOptions);
}
public async Task <int> SendVerificationEmail(string email)
{
int verificationCode = MailOptions.getCode();
var emailMessage = new MimeMessage();
emailMessage.From.Add(new MailboxAddress(MailOptions.mailTitle, MailOptions.mailLogin));
emailMessage.To.Add(new MailboxAddress("", email));
emailMessage.Subject = "Email verification";
emailMessage.Body = new TextPart(MimeKit.Text.TextFormat.Html)
{
Text = $"Verification code = {verificationCode}"
};
using (var client = new SmtpClient())
{
await client.ConnectAsync(MailOptions.server, 587, false);
await client.AuthenticateAsync(MailOptions.mailLogin, MailOptions.password);
await client.SendAsync(emailMessage);
await client.DisconnectAsync(true);
}
return(verificationCode);
}
public WebHooksController(IOptions <FacebookOptions> fbOptions, IOptions <MailOptions> mailOptions,
ILogger <WebHooksController> logger)
{
_fbOptions = fbOptions.Value;
_mailOptions = mailOptions.Value;
_log = logger;
}
public ActivationLinkCreatedEventHandler(LinkGenerator generator, IMailService mailService, MailOptions mailOptions, IUserRepository userRepository)
{
_generator = generator;
_mailService = mailService;
_mailOptions = mailOptions;
_userRepository = userRepository;
}
/// <summary>
/// The AddSendGridNotificationModule
/// </summary>
/// <param name="services">The <see cref="IServiceCollection"/></param>
/// <param name="config">The <see cref="IConfiguration"/></param>
/// <param name="configsection">The <see cref="string"/></param>
public static void UseCallistNotification(this IServiceCollection services,
IConfiguration config,
MailOptions mailOptions)
{
services.AddTransient <IEmailSender, SimpleSendGridEmailSender>();
services.AddSingleton <ISendGridMalFactory, SendGridMailFactory>();
services.AddTransient <INotificationModule, NotificationModule>();
}
public ForgotPasswordIntegrationEventHandler(IMailService mailService,
MailOptions options,
ILogger <ForgotPasswordIntegrationEventHandler> logger)
{
_mailService = mailService;
_options = options;
_logger = logger;
}
public MailSender(IViewRender viewRender, IServiceProvider serviceProvider, IOptions <MailOptions> mailOptionsAccessor, ILogger <MailSender> logger, IHub sentry)
{
_viewRender = viewRender;
_serviceProvider = serviceProvider;
_logger = logger;
_sentry = sentry;
_mailOptions = mailOptionsAccessor.Value;
}
public WebHooksController(IOptions <FacebookOptions> fbOptions, IOptions <MailOptions> mailOptions,
ILogger <WebHooksController> logger, IRepository <FacebookAdsLog> facebookAdsLogRepo, IRepository <FacebookAdsFormData> facebookAdsFormDataRepo)
{
_fbOptions = fbOptions.Value;
_mailOptions = mailOptions.Value;
_log = logger;
_facebookAdsLogRepo = facebookAdsLogRepo;
_facebookAdsFormDataRepo = facebookAdsFormDataRepo;
}
public MailService(MailOptions mailOptions, ISmtpClientWrapper client)
{
_client = client;
_message = new MimeMessage();
_client.Connect(Server.Host, Server.Port, Server.UseSsl);
_client.Authenticate(mailOptions.Username, mailOptions.Password);
MapMessage(mailOptions);
}
private void MapMessage(MailOptions mailOptions)
{
_message.From.Add(new MailboxAddress(mailOptions.Username));
_message.To.Add(new MailboxAddress(mailOptions.Recipient));
_message.Subject = mailOptions.Subject;
_message.Body = new TextPart("plain")
{
Text = mailOptions.Message
};
}
public SignUpHandler(
IUserRepository userRepository,
IUniqueEmailRule uniqueEmailRule,
IPasswordHasher <User> passwordHasher,
MailOptions mailOptions)
{
_userRepository = userRepository;
_uniqueEmailRule = uniqueEmailRule;
_passwordHasher = passwordHasher;
_mailOptions = mailOptions;
}
private void _RefreshMailOptions()
{
MailOptions options = MailOptionsRepository.Get();
_fromAddressTextBox.Text = options.FromAddress;
_smtpHostTextBox.Text = options.SmtpHost;
_smtpPasswordTextBox.Text = options.SmtpPassword;
_smtpPortTextBox.Text = options.SmtpPort.ToString();
_smtpUsernameTextBox.Text = options.SmtpUsername;
_toAddressesTextBox.Text = options.ToAddresses.Aggregate(string.Empty, (joined, address) => string.Concat(joined, address, ";"));
}
static void RunOptions(MailOptions options)
{
var serviceProvider = new ServiceCollection()
.AddSingleton <ISmtpClientWrapper, SmtpClientWrapper>()
.BuildServiceProvider();
var client = serviceProvider.GetService <ISmtpClientWrapper>();
var mailService = new MailService(options, client);
mailService.Send().Wait();
}
public static void SendSingleMail(MailOptions <SingleMailDto> options)
{
using (BaseSmtpClient client = SmtpClientCreator.GMail(options.Data.SenderEmail, options.Data.Password))
{
var mail = new Email(client, options.Data.SenderEmail, options.Data.SenderName);
mail
.To(options.Data.ReceiverEmail, options.Data.ReceiverName)
.Subject(options.Data.Subject).Body(options.Data.Body)
.Send()
;
}
}
public SendPasswordResetHandler(IUserRepository userRepository,
IAuthTokenService authTokenService,
IMailService mailService,
MailOptions mailOptions,
LinkGenerator linkGenerator)
{
_userRepository = userRepository;
_authTokenService = authTokenService;
_mailService = mailService;
_mailOptions = mailOptions;
_linkGenerator = linkGenerator;
}
/// <summary>
/// Constructor of Email Service.
/// </summary>
/// <param name="sendGridOptions">The configuration.</param>
/// <param name="mailOptions">The options.</param>
/// <param name="logger">The logger.</param>
public MailService(
IOptions <SendGridOptions> sendGridOptions,
IOptions <MailOptions> mailOptions,
ILogger logger)
{
_mailOptions = mailOptions.Value;
_sendGridOptions = sendGridOptions.Value;
_logger = logger;
Argument.IsNotNullOrEmpty(_mailOptions.EmailAddress);
Argument.IsNotNullOrEmpty(_mailOptions.Sender);
Argument.IsNotNullOrEmpty(_sendGridOptions.Key);
}
public Guid Send(MailMessage message, MailOptions options)
{
var messageForDispatch = new SentMailMessage(message)
{
IsSigned = options.Sign,
IsEncrypted = options.Encrypt,
DeliveryStatus = options.Suspend ? DeliveryStatus.Suspended : DeliveryStatus.Pending,
DelayUntil = options.DelayUntil
};
db.Add(messageForDispatch);
return(messageForDispatch.Id);
}
public static void SendListMail(MailOptions <ListMailDto> options)
{
for (int i = 0; i < options.Data.ReceiverEmails.Count; i++)
{
MailManager.SendSingleMail(new MailOptions <SingleMailDto>
{
Data = new SingleMailDto
{
SenderEmail = options.Data.SenderEmail,
SenderName = options.Data.SenderName,
Subject = options.Data.Subject,
Body = options.Data.Body,
ReceiverEmail = options.Data.ReceiverEmails[i],
ReceiverName = options.Data.ReceiverName[i],
}
});
}
}
public void Init()
{
MailOptions = new MailOptions();
/* Edit settings:
* **********************************************************/
MailOptions.Username = "******";
MailOptions.Password = "******";
MailOptions.From = "*****@*****.**";
MailOptions.SMTPHost = "smtp.gmail.com";
MailOptions.SMTPPort = 587;
MailOptions.UseSsl = true;
/* Do not edit the settings below:
************************************************************/
MailOptions.To = "*****@*****.**";
MailOptions.Body = "Net Utilities";
}
public MailErrorSender(IOptions <MailOptions> options, IMailSender mailSender)
{
_mailSender = mailSender ?? throw new ArgumentNullException(nameof(mailSender));
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_options = options.Value;
if (string.IsNullOrEmpty(_options.Subject))
{
throw new ArgumentNullException(nameof(_options.Subject));
}
if (_options.Tos == null)
{
throw new ArgumentNullException(nameof(_options.Tos));
}
}
public async Task SendMailAsync(string address, string token)
{
MailOptions config = mailOptions.Value;
if (!config.EnableMailing)
{
logger.LogWarning("Mailing is disabled. \"{0}\" will not receive the token \"{1}\".", address, token);
return;
}
string url = GetConfirmationUrl(token).AbsoluteUri;
var message = new MimeMessage();
message.From.Add(new MailboxAddress(config.SenderName, config.SenderAddress));
message.To.Add(new MailboxAddress(address));
message.Subject = "Confirm your email address";
BodyBuilder builder = new BodyBuilder
{
TextBody = GetMailText()
.Replace("$ADDRESS", address, StringComparison.Ordinal)
.Replace("$URL", url, StringComparison.Ordinal),
HtmlBody = GetMailHtml()
.Replace("$ADDRESS", address, StringComparison.Ordinal)
.Replace("$URL", url, StringComparison.Ordinal)
};
message.Body = builder.ToMessageBody();
using var client = new SmtpClient();
await client.ConnectAsync(config.SmtpHost, config.SmtpPort, config.UseSsl).ConfigureAwait(false);
await client.AuthenticateAsync(config.SmtpUsername, config.SmtpPassword).ConfigureAwait(false);
await client.SendAsync(message).ConfigureAwait(false);
await client.DisconnectAsync(quit : true).ConfigureAwait(false);
}
public void Send(string mailAddress, string title, string mess)
{
MailOptions <SingleMailDto> options = new MailOptions <SingleMailDto>();
options.Data = new SingleMailDto();
options.Data.SenderEmail = "*****@*****.**";
options.Data.Password = "******";
options.Data.SenderName = "Admin Zero Online";
options.Data.ReceiverEmail = mailAddress;
options.Data.ReceiverName = "Nguoi choi zer online";
options.Data.Subject = title;
options.Data.Body = mess;
using (BaseSmtpClient client = SmtpClientCreator.GMail(options.Data.SenderEmail, options.Data.Password))
{
var mail = new Email(client, options.Data.SenderEmail, options.Data.SenderName);
mail
.To(options.Data.ReceiverEmail, options.Data.ReceiverName)
.Subject(options.Data.Subject)
.Body(options.Data.Body)
.BodyAsHtml()
.Send()
;
}
}
public MailSender(MailOptions options, IMapperService mapper, ILogger <MailSender> logger)
{
this.options = options;
this.mapper = mapper;
this.logger = logger;
}
public AmericanApiController(PortableRecipesContext context, IHostingEnvironment env, IOptions <MailOptions> mailOptionsAccessor)
{
_context = context;
_mailOptions = mailOptionsAccessor.Value;
this.env = env;
}
public SendGridEmailSender(IOptions <MailOptions> optionsAccessor)
{
mailConfiguration = optionsAccessor.Value;
client = new SendGridClient(mailConfiguration.Key);
}
public MailServiceTests()
{
_client = Substitute.For <ISmtpClientWrapper>();
_options = new MailOptionsBuilder().Build();
}
public LecturesController(MonadicComponentsContext context, IHostingEnvironment env, IOptions <MailOptions> mailOptionsAccessor)
{
_context = context;
_mailOptions = mailOptionsAccessor.Value;
this.env = env;
}
public MailSender(IOptions <MailOptions> options)
{
this.options = options.Value;
}
