static async Task Main(string[] args)
{
var sender = new SmtpSender(() => new System.Net.Mail.SmtpClient("localhost")
{
EnableSsl = false, //test perposes only
DeliveryMethod = System.Net.Mail.SmtpDeliveryMethod.Network,
Port = 25 //Port number for the smtp server
//DeliveryMethod = System.Net.Mail.SmtpDeliveryMethod.SpecifiedPickupDirectory,
//PickupDirectoryLocation = @"C:\Demos"
});
StringBuilder template = new();
template.AppendLine("Dear @Model.FriendName");
template.AppendLine("<p> My Name Is @Model.FirstName , I am .net developer </p>");
template.AppendLine("Best Wishes");
Email.DefaultSender = sender;
Email.DefaultRenderer = new RazorRenderer(); //As to render the templete as razor text
var email = await Email.
From("*****@*****.**") //the client name not the server from which I send the mail {server name maybe gmail}
.To("*****@*****.**")
.Subject("You are welcome")
.UsingTemplate(template.ToString(), new { FriendName = "Ahmed", FirstName = "Mohamed" })
//.Body("If I don't have a templete I sue the body to write what I want.")
.SendAsync();
}
static async System.Threading.Tasks.Task Main(string[] args)
{
Console.WriteLine("Testando fluentEmail");
Console.ReadKey();
var sender = new SmtpSender(() => new SmtpClient("localhost")
{
EnableSsl = false,
DeliveryFormat = (SmtpDeliveryFormat)SmtpDeliveryMethod.SpecifiedPickupDirectory, //forma de envio para uma pasta
PickupDirectoryLocation = @"c:\Dados\Email"
});
Email.DefaultSender = sender;
var email = await Email.From("*****@*****.**")
.To("*****@*****.**")
.Subject("FluentEmail - Testado...")
.Body("Testando o fluentEmail")
.SendAsync();
if (email.Successful)
{
Console.WriteLine("Email enviado com sucesso.");
}
else
{
Console.WriteLine("Falha ao enviar o email");
}
Console.ReadKey();
}
static async Task Main(string[] args)
{
var sender = new SmtpSender(() => new SmtpClient("localhost")
{
EnableSsl = false,
DeliveryMethod = SmtpDeliveryMethod.Network,
Port = 25,
});
Email.DefaultSender = sender;
Email.DefaultRenderer = new RazorRenderer();
StringBuilder template = new();
template.AppendLine("Sayın @Model.Fullname,");
template.AppendLine("<p>Satın aldığınız ürün: @Model.Product. Bizi tercih ettiğiniz için teşekkür ederiz. </p>");
template.AppendLine("X Company");
var email = await Email
.From("*****@*****.**")
.To("*****@*****.**", "Ali Veli")
.Subject("Tebrikler!")
.UsingTemplate(template.ToString(), new { Fullname = "Ali Veli", Product = "Apple Macbook 13" }, true)
.SendAsync();
if (email.Successful)
{
Console.WriteLine("Eposta gönderimi başarılı.");
}
else
{
Console.WriteLine("Eposta gönderilemedi, bir hata oluştu.");
}
}
static async Task Main(string[] args)
{
/// "localhost" for sending email to computer, but could be used with other mail servers
var sender = new SmtpSender(() => new SmtpClient(host: "localhost")
{
// Saves to directory as a file.
EnableSsl = false,
DeliveryMethod = SmtpDeliveryMethod.Network,
Port = 25
// DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
// PickupDirectoryLocation = @"C:\Demos"
});
// inherits from FluentEmail.Razor Template
StringBuilder template = new StringBuilder();
template.AppendLine("Dear @Model.FirstName");
template.AppendLine("<p> We have changed our transaction polcy. Please review carefully below for further details");
template.AppendLine("-Wild World Games");
Email.DefaultSender = sender;
Email.DefaultRenderer = new RazorRenderer();
// Sends email to client
var email = await Email // Does actual sending
.From("*****@*****.**")
.To("*****@*****.**", "Hana")
.Subject("Regarding Transaction Policy")
.UsingTemplate(template.ToString(), new { FirstName = "Rami", ProductName = "TrialsofPower" })
//.Body("Hello Dear Customer, we have changed the way we do process transactions.")
.SendAsync();
}
static async Task Main(string[] args)
{
var sender = new SmtpSender(() => new SmtpClient("localhost")
{
EnableSsl = false,
// Sends via SMTP (Papercut)
DeliveryMethod = SmtpDeliveryMethod.Network,
Port = 25
// Stores as file in chosen directory
//DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
//PickupDirectoryLocation = @"C:\Demos"
});
StringBuilder template = new StringBuilder();
template.AppendLine("Dear @Model.FirstName,");
template.AppendLine("<p>Thanks for purchasing @Model.ProductName. We hope you enjoy it.</p>");
template.AppendLine("- Brandon Ltd");
Email.DefaultSender = sender;
Email.DefaultRenderer = new RazorRenderer();
var email = await Email
.From("*****@*****.**")
.To("*****@*****.**", "Bethany")
.Subject("Thanks!")
.UsingTemplate(template.ToString(), new { FirstName = "Brandon", ProductName = "Best-Product" })
//.Body("Thanks for buying our product.")
.SendAsync();
}
/// <summary>
/// Запускается после создания файла
/// </summary>
private void OnCreated(object source, FileSystemEventArgs e)
{
Logger.Info("Обнаружен новый документ: " + e.FullPath);
FileSystemWatcher _watcher = null;
try
{
Logger.Info("Процесс отправки и удаления: " + e.FullPath);
_watcher = (FileSystemWatcher)source;
var _task = SmtpSender.SendEmailAsync(e.FullPath);
Task.WaitAll(_task);
Logger.Info("Удалении файла: " + e.FullPath);
File.Delete(e.FullPath);
Logger.Info("Файл удален: " + e.FullPath);
}
catch (FileNotFoundException ex)
{
Logger.Error("Ошибка при удалении файла." + ex.Message);
Logger.Trace(ex.StackTrace);
}
finally
{
if (_watcher != null)
{
_watcher.Created -= new FileSystemEventHandler(OnCreated);
_watcher.Created += new FileSystemEventHandler(OnCreated);
}
}
}
static async Task Main(string[] args)
{
var sender = new SmtpSender(() => new SmtpClient("smtp.gmail.com")
{
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
Port = 587,
Credentials = new NetworkCredential("*****@*****.**", "PASSWORD GOES HERE")
});
StringBuilder template = new();
template.AppendLine("@Model.Greet,")
.AppendLine("<p>You are the one who pushes me up whenever I am down. Thank you for helping me do things that I thought I couldn't. Loving you is the best thing that has happened to me.</p>")
.AppendLine("<p>I Love You Baby</p>")
.AppendLine("-Andre");
Email.DefaultSender = sender;
Email.DefaultRenderer = new RazorRenderer();
var email = await Email
.From("*****@*****.**", "P Victor")
.To("*****@*****.**", "Marie Victor")
.Subject("Happy Valentines Day Baby")
.UsingTemplate(template.ToString(), new { Greet = "Babe" })
.SendAsync();
}
static async Task Main(string[] args)
{
var sender = new SmtpSender(() => new SmtpClient("localhost")
{
EnableSsl = false,
DeliveryMethod = SmtpDeliveryMethod.Network,
Port = 25
// DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
// PickupDirectoryLocation = @"C:\oni\Demos"
});
StringBuilder template = new();
template.AppendLine("Dear @Model.FirstName,");
template.AppendLine("<p>Thnaks for purchasing @Model.ProductName. We hope you enjoyed it. </p>");
template.AppendLine("- The OniCo Team");
Email.DefaultSender = sender;
Email.DefaultRenderer = new RazorRenderer();
var email = await Email
.From("*****@*****.**")
.To("*****@*****.**", "ayo")
.Subject("Thanks")
.UsingTemplate(template.ToString(), new { FirstName = "Oni", ProductName = "Boli-wrapped Boli" })
//.Body("Thanks for buying our product")
.SendAsync();
}
static async Task Main(string[] args)
{
var fromAddress = new MailAddress("*****@*****.**", "LatisPro");
var fromPassword = "******";
var toAddress = new MailAddress("*****@*****.**");
var sender = new SmtpSender(() => new SmtpClient("localhost")
{
EnableSsl = true,
Host = "smtp.gmail.com",
Port = 587,
DeliveryMethod = SmtpDeliveryMethod.Network,
UseDefaultCredentials = false,
Credentials = new NetworkCredential(fromAddress.Address, fromPassword)
});;
StringBuilder template = new();
template.AppendLine("Estimado, @Model.FirstName");
template.AppendLine("<p>Gracias por comprar <b>@Model.ProductName</b>. Esperamos que lo disfrues.</p>");
template.AppendLine("<br/>");
template.AppendLine("Latis");
Email.DefaultSender = sender;
Email.DefaultRenderer = new RazorRenderer();
var email = await Email.From(fromAddress.Address, fromAddress.DisplayName)
.To("*****@*****.**")
.Subject("Prueba Fluent Email")
.UsingTemplate(template.ToString(), new { FirstName = "Eliseo", ProductName = "Latis/Pro" })
//.Body("Gracias por usuar Fluen Email")
.SendAsync();
}
public void SendingMailShouldWork()
{
var client = new SmtpSender("localhost", 25, true, 1000, false)
{
Sender = new MailAddress("*****@*****.**", "Dr Evil"),
Recipients = new List <MailAddress> {
new MailAddress("*****@*****.**", "Jouko Pouko")
}
};
const string msgBody = "<html><head /><body><table><tbody><tr><td>Secret Plans</td></tr><tr><td>Ransom 100 billion dollars, btw you rule!</td></tr></tbody></table></body></html>";
const string msgSubject = "Plans of World destruction";
client.SendReport(msgBody, msgSubject);
Assert.AreEqual(1, smtpServer.ReceivedEmailCount, "1 mails sent");
var mail = smtpServer.ReceivedEmail.First();
Assert.AreEqual("*****@*****.**", mail.Headers["To"], "Receiver");
Assert.AreEqual("\"Dr Evil\" <*****@*****.**>", mail.Headers["From"], "Sender");
Assert.AreEqual(msgSubject, mail.Headers["Subject"], "Subject");
var body = ParseMessageBody(mail.Body);
Assert.That(body, Does.Contain(msgBody));
}
public async Task SendEmail()
{
var recipients = new List <Address>();
foreach (var emailAdress in _info.EmailRecipients)
{
recipients.Add(new Address(emailAdress));
}
var sender = new SmtpSender(() => new SmtpClient("smtp.gmail.com")
{
EnableSsl = true,
Port = 587,
Credentials = new System.Net.NetworkCredential(_info.MailerAddress, _info.MailerPassword)
});
Email.DefaultSender = sender;
var email = await Email
.From(_info.MailerAddress)
.To(recipients)
.Subject($"Washington Uploads: {DateTime.Now}")
.Body("See attachment below for logs")
.AttachFromFilename(_logger.StreamLocation)
.SendAsync();
if (email.Successful)
{
Console.WriteLine("Email sent successfully");
}
else
{
Console.WriteLine("Could not send email");
}
}
/**
* Returns the SMTP transport
*
* @return \Swift_SmtpTransport
*/
protected ISender getSmtpInstance()
{
var host = (string)(this.config.getSystemValue("mail_smtphost", "127.0.0.1"));
var port = (int)(this.config.getSystemValue("mail_smtpport", 25));
var smtpClient = new SmtpClient(host, port);
var timeout = (int)(this.config.getSystemValue("mail_smtptimeout", 10));
smtpClient.Timeout = timeout;
var credentials = new NetworkCredential();
if ((bool)this.config.getSystemValue("mail_smtpauth", false))
{
var username = (string)(this.config.getSystemValue("mail_smtpname", ""));
var password = (string)(this.config.getSystemValue("mail_smtppassword", ""));
var authMode = (string)(this.config.getSystemValue("mail_smtpauthtype", "LOGIN"));
credentials.Password = password;
credentials.UserName = username;
}
var smtpSecurity = (string)this.config.getSystemValue("mail_smtpsecure", "");
if (smtpSecurity.IsNotEmpty())
{
var encryption = (smtpSecurity);
}
var streamingOptions = this.config.getSystemValue("mail_smtpstreamoptions", new Dictionary <string, string>());
// if (is_array(streamingOptions) && !empty(streamingOptions)) {
// var streamOptions = (streamingOptions);
// }
smtpClient.Credentials = credentials;
var sender = new SmtpSender(smtpClient);
return(sender);
}
public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var sender = new SmtpSender();
var authenticationService = new AuthenticationService(_context, sender);
var password = authenticationService.RecoverPassword(viewModel.Email);
if (password != null)
{
var notificationService = new NotificationService(_context, sender);
await Task.Run(() => notificationService.SendRecoverPasswordNotification(viewModel.Email, password))
.ConfigureAwait(false);
ViewBag.Message = "We sent an e-mail to you with your password.";
}
else
{
ViewBag.Message = "";
ModelState.AddModelError("EmailNaoEncontrado", "E-mail not found");
}
return(View(viewModel));
}
public async Task Handle(UserRegisteredMessage message, CancellationToken cancellationToken)
{
Console.WriteLine($"Email: {message.Email}, Password: {message.Password}");
var sender = new SmtpSender(() => new SmtpClient("localhost")
{
EnableSsl = false,
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
PickupDirectoryLocation = @"C:\Demos"
});
Email.DefaultSender = sender;
SendResponse email;
EmailServiceLog log;
try
{
email = await Email.From("*****@*****.**")
.To(message.Email, message.Email)
.Subject("GreenField registration")
.Body($"You have been successfully registered in GreenField platform." +
$"Your credentials: Email: {message.Email}, Password: {message.Password}.")
.SendAsync();
}
catch (Exception ex)
{
log = new EmailServiceLog()
{
Date = DateTime.Now,
Message = $"Error occured while sending email. Error message: {ex.Message}",
Status = LogStatus.Info
};
await _repository.AddAsync(log);
return;
}
if (email.Successful)
{
log = new EmailServiceLog()
{
Date = DateTime.Now,
Message = $"Email was successfully sent for user {message.Email}",
Status = LogStatus.Info
};
}
else
{
log = new EmailServiceLog()
{
Date = DateTime.Now,
Message = $"Error occured while sending email. Error message: {email.ErrorMessages.FirstOrDefault()}",
Status = LogStatus.Error
};
}
await _repository.AddAsync(log);
}
public void SmtpSendMethodParamException2()
{
Mock <ILogger> mockNlog = new Mock <ILogger>();
ISmtpSender mailClient = new SmtpSender("*****@*****.**", "str", "str", "*****@*****.**", "str", "str", mockNlog.Object);
var ex = Assert.ThrowsAsync <System.ArgumentException>(async() => await mailClient.SendEmailAsync(""));
Assert.That(ex.Message, Is.EqualTo("Параметр 'fileName' не может быть пустой строкой.\r\nИмя параметра: fileName"));
}
public void SmtpSendMethodParamException3()
{
Mock <ILogger> mockNlog = new Mock <ILogger>();
ISmtpSender mailClient = new SmtpSender("*****@*****.**", "str", "str", "*****@*****.**", "str", "str", mockNlog.Object);
var ex = Assert.ThrowsAsync <System.ArgumentNullException>(async() => await mailClient.SendEmailAsync(null));
Assert.That(ex.Message, Is.EqualTo("Значение не может быть неопределенным.\r\nИмя параметра: fileName"));
}
public void SmtpConstructorParamException()
{
Mock <ILogger> mockNlog = new Mock <ILogger>();
ISmtpSender mailClient = new SmtpSender("", "", "", "", "", "", mockNlog.Object);
var ex = Assert.ThrowsAsync <System.ArgumentException>(async() => await mailClient.SendEmailAsync("C:\\MailFolder\\d"));
Assert.That(ex.Message, Is.EqualTo("Параметр 'address' не может быть пустой строкой.\r\nИмя параметра: address"));
}
public static void NotifyStartUp(IServiceProvider serviceProvider)
{
if (notifyStarted)
{
return;
}
lock (syncRoot)
{
if (notifyStarted)
{
return;
}
var configuration = serviceProvider.GetService <IConfiguration>();
var cacheNotify = serviceProvider.GetService <ICacheNotify <NotifyMessage> >();
var cacheInvoke = serviceProvider.GetService <ICacheNotify <NotifyInvoke> >();
var options = serviceProvider.GetService <IOptionsMonitor <ILog> >();
var telegramHelper = serviceProvider.GetService <TelegramHelper>();
NotifyContext = new NotifyContext(serviceProvider);
INotifySender jabberSender = new NotifyServiceSender(cacheNotify, cacheInvoke);
INotifySender emailSender = new NotifyServiceSender(cacheNotify, cacheInvoke);
INotifySender telegramSender = new TelegramSender(options, telegramHelper);
var postman = configuration["core:notify:postman"];
if ("ases".Equals(postman, StringComparison.InvariantCultureIgnoreCase) || "smtp".Equals(postman, StringComparison.InvariantCultureIgnoreCase))
{
jabberSender = new JabberSender(serviceProvider);
var properties = new Dictionary <string, string>
{
["useCoreSettings"] = "true"
};
if ("ases".Equals(postman, StringComparison.InvariantCultureIgnoreCase))
{
emailSender = new AWSSender(serviceProvider, options);
properties["accessKey"] = configuration["ses:accessKey"];
properties["secretKey"] = configuration["ses:secretKey"];
properties["refreshTimeout"] = configuration["ses:refreshTimeout"];
}
else
{
emailSender = new SmtpSender(serviceProvider, options);
}
emailSender.Init(properties);
}
NotifyContext.NotifyService.RegisterSender(Constants.NotifyEMailSenderSysName, new EmailSenderSink(emailSender, serviceProvider, options));
NotifyContext.NotifyService.RegisterSender(Constants.NotifyMessengerSenderSysName, new JabberSenderSink(jabberSender, serviceProvider));
NotifyContext.NotifyService.RegisterSender(Constants.NotifyTelegramSenderSysName, new TelegramSenderSink(telegramSender, serviceProvider));
NotifyContext.NotifyEngine.BeforeTransferRequest += NotifyEngine_BeforeTransferRequest;
NotifyContext.NotifyEngine.AfterTransferRequest += NotifyEngine_AfterTransferRequest;
notifyStarted = true;
}
}
public void SetUp()
{
var sender = new SmtpSender(new SmtpClient("localhost"))
{
UseSsl = false
};
Email.DefaultSender = sender;
}
private static void NotifyStartUp()
{
if (notifyStarted)
{
return;
}
lock (syncRoot)
{
if (notifyStarted)
{
return;
}
notifyContext = new NotifyContext();
INotifySender jabberSender = new NotifyServiceSender();
INotifySender emailSender = new NotifyServiceSender();
var postman = ConfigurationManager.AppSettings["core.notify.postman"];
if ("ases".Equals(postman, StringComparison.InvariantCultureIgnoreCase) || "smtp".Equals(postman, StringComparison.InvariantCultureIgnoreCase))
{
jabberSender = new JabberSender();
var properties = new Dictionary <string, string>();
var s = CoreContext.Configuration.SmtpSettings;
properties["host"] = s.Host;
properties["port"] = s.Port.GetValueOrDefault(25).ToString();
properties["enableSsl"] = s.EnableSSL.ToString();
properties["userName"] = s.CredentialsUserName;
properties["password"] = s.CredentialsUserPassword;
properties["domain"] = s.CredentialsDomain;
if ("ases".Equals(postman, StringComparison.InvariantCultureIgnoreCase))
{
emailSender = new AWSSender();
properties["accessKey"] = ConfigurationManager.AppSettings["ses.accessKey"];
properties["secretKey"] = ConfigurationManager.AppSettings["ses.secretKey"];
properties["refreshTimeout"] = ConfigurationManager.AppSettings["ses.refreshTimeout"];
}
else
{
emailSender = new SmtpSender();
}
emailSender.Init(properties);
}
notifyContext.NotifyService.RegisterSender(Constants.NotifyEMailSenderSysName, new EmailSenderSink(emailSender));
notifyContext.NotifyService.RegisterSender(Constants.NotifyMessengerSenderSysName, new JabberSenderSink(jabberSender));
notifyContext.NotifyEngine.Scheduling = ConfigurationManager.AppSettings["core.notify.scheduling"] != "false";
notifyContext.NotifyEngine.BeforeTransferRequest += NotifyEngine_BeforeTransferRequest;
notifyContext.NotifyEngine.AfterTransferRequest += NotifyEngine_AfterTransferRequest;
notifyStarted = true;
}
}
public void UseSslPropertyIsInSyncWithSmtpClient()
{
var client = new SmtpClient("localhost")
{
EnableSsl = false
};
var sender = new SmtpSender(client);
Assert.AreEqual(client.EnableSsl, sender.UseSsl);
}
public void SetUp()
{
var sender = new SmtpSender(() => new SmtpClient("localhost")
{
EnableSsl = false,
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
PickupDirectoryLocation = tempDirectory
});
Email.DefaultSender = sender;
Directory.CreateDirectory(tempDirectory);
}
private void btnSendAtOnce_Click(object Sender, RoutedEventArgs e)
{
// Извлекаем исходные параметры по возможности
if (!(cbSenderSelect.SelectedItem is Sender sender))
{
return;
}
if (!(RecipientsList.SelectedItem is Recipient recipient))
{
return;
}
if (!(cbSmtpSelect.SelectedItem is Server server))
{
return;
}
if (!(MessagesList.SelectedItem is Message message))
{
return;
}
// Если одни из параметров невозможно получить, то выходим
// Создаём объект-рассыльщик и заполняем параметры сервера
var mail_sender = new SmtpSender(
server.Address, server.Port, server.UseSSL,
server.Login, server.Password);
// При отправке почты может возникнуть проблема. Ставим перехват исключения.
try
{
// Запускаем таймер
var timer = Stopwatch.StartNew();
// И запускаем процесс отправки почты
mail_sender.Send(
sender.Address, recipient.Address,
message.Tittle, message.Body);
timer.Stop(); // По завершении останавливаем таймер
// Если почта успешно отправлена, то отображаем диалоговое окно
MessageBox.Show(
$"Почта успешно отправлена за {timer.Elapsed.TotalSeconds:0.##}c",
"Отправка почты",
MessageBoxButton.OK,
MessageBoxImage.Information);
}
// Если случилась ошибка, то перехватываем исключение
catch (SmtpException) // Перехватывает строго нужное нам исключение!
{
MessageBox.Show(
"Ошибка при отправке почты",
"Отправка почты",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
public SmtpMailSender(SmtpClient smtpClient, ILogger logger)
{
_smtpSender = new SmtpSender(smtpClient);
_smtpSettings = new
{
Host = smtpClient.Host,
Port = smtpClient.Port,
Ssl = smtpClient.EnableSsl,
Timeout = smtpClient.Timeout
};
_logger = logger;
}
private static void NotifyStartUp()
{
if (notifyStarted)
{
return;
}
lock (syncRoot)
{
if (notifyStarted)
{
return;
}
notifyContext = new NotifyContext();
INotifySender jabberSender = new NotifyServiceSender();
INotifySender emailSender = new NotifyServiceSender();
var postman = ConfigurationManager.AppSettings["core:notify:postman"];
if ("ases".Equals(postman, StringComparison.InvariantCultureIgnoreCase) || "smtp".Equals(postman, StringComparison.InvariantCultureIgnoreCase))
{
jabberSender = new JabberSender();
var properties = new Dictionary <string, string>
{
["useCoreSettings"] = "true"
};
if ("ases".Equals(postman, StringComparison.InvariantCultureIgnoreCase))
{
emailSender = new AWSSender();
properties["accessKey"] = ConfigurationManager.AppSettings["ses:accessKey"];
properties["secretKey"] = ConfigurationManager.AppSettings["ses:secretKey"];
properties["refreshTimeout"] = ConfigurationManager.AppSettings["ses:refreshTimeout"];
}
else
{
emailSender = new SmtpSender();
}
emailSender.Init(properties);
}
notifyContext.NotifyService.RegisterSender(Constants.NotifyEMailSenderSysName, new EmailSenderSink(emailSender));
notifyContext.NotifyService.RegisterSender(Constants.NotifyMessengerSenderSysName, new JabberSenderSink(jabberSender));
notifyContext.NotifyEngine.BeforeTransferRequest += NotifyEngine_BeforeTransferRequest;
notifyContext.NotifyEngine.AfterTransferRequest += NotifyEngine_AfterTransferRequest;
notifyStarted = true;
}
}
protected override void Load(ContainerBuilder builder)
{
// TODO: Do not register entire settings in container, pass necessary settings to services which requires them
// ex:
// builder.RegisterType<QuotesPublisher>()
// .As<IQuotesPublisher>()
// .WithParameter(TypedParameter.From(_settings.CurrentValue.QuotesPublication))
builder.RegisterInstance(_log)
.As <ILog>()
.SingleInstance();
builder.RegisterType <HealthService>()
.As <IHealthService>()
.SingleInstance();
builder.RegisterType <StartupManager>()
.As <IStartupManager>();
builder.RegisterType <ShutdownManager>()
.As <IShutdownManager>();
builder.RegisterType <Lkk2yToChf>()
.As <ILkk2yToChf>();
builder.RegisterType <ShutdownManager>()
.As <IShutdownManager>();
builder.RegisterType <RateConverterService>()
.As <RateConverterService>();
// TODO: Add your dependencies here
var settingsInstance = _settings.CurrentValue;
builder.Populate(_services);
BindRepositories(builder);
var smtpSender = new SmtpSender(settingsInstance.SmtpSettings);
builder.RegisterInstance(smtpSender);
builder.RegisterInstance(
new TransctionMailSender(settingsInstance.Lkk2Y_ApiService.EmailTemplateUrl, smtpSender));
builder.RegisterInstance <IRateConverterClient>(
new RateConverterClient(settingsInstance.Lkk2Y_ApiService.RateConverterUrl));
}
public void Initialize(SendRequest sendRequest)
{
if (sendRequest.NetworkCredential == null)
{
sendRequest.NetworkCredential = new System.Net.NetworkCredential(AppSettingsUtil.GetString("email.username"), AppSettingsUtil.GetString("email.password"));
}
var sender = new SmtpSender(() => new SmtpClient(sendRequest.SmtpClientHost)
{
EnableSsl = sendRequest.EnableSsl,
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory,
Credentials = sendRequest.NetworkCredential
});
EmailSend.DefaultSender = sender;
}
public void GetSender_Give_NotNull_Stub_Test()
{
var stub = Mock.Of <IStatistic>();
_MailService = new SmtpMailService(stub);
var address = "*****@*****.**";
var port = 25;
var useSsl = true;
var login = "******";
var password = "******".Encrypt();
var expected = new SmtpSender(address, port, useSsl, login, password, stub);
var actual = _MailService.GetSender(address, port, useSsl, login, password);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.ToString(), actual.ToString());
}
static async Task Main(string[] args)
{
var sender = new SmtpSender(() => new SmtpClient(host: "localhost")
{
EnableSsl = false, //Como estamos fazendo local, nao precisamos configurar segurança, por isso eu deixo ele em false
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory, //Aqui estou dizendo que vou salvar em um diretorio os dados que chegarem desse envio
PickupDirectoryLocation = @"C:\Demos" //Aqui estou especificando onde vai ficar registrado/guardado, para fins de teste
});
Email.DefaultSender = sender; //Aqui to setando quem vai estar mandando o email, e como eu setei em 'sender' partirá do meu localhost
var email = await Email
.From(emailAddress : "*****@*****.**") //Quem ta enviando o email
.To(emailAddress: "*****@*****.**") //Para quem ta enviando o email
.Subject(subject: "Coleee") //O título do email
.Body(body: "Valeu pela ajuda") //O conteúdo do email
.SendAsync(); //Enviar o email
}
public void EmptyUserpasswordShouldWork()
{
var client = new SmtpSender("localhost", 25, false, 1000, "foo", null, useSsl: false)
{
Recipients = new List <MailAddress> {
new MailAddress("*****@*****.**")
},
Sender = new MailAddress("*****@*****.**")
};
client.SendReport("<Perfect/>", "Foo");
Assert.That(smtpServer.ReceivedEmailCount, Is.EqualTo(1));
var body = ParseMessageBody(smtpServer.ReceivedEmail.Single().Body);
Assert.That(body, Does.Contain("<Perfect/>"));
}
public void TestSetup()
{
_smtpSender = new SmtpSender("localhost");
File.WriteAllText(_filename, "Test Data");
}
