public async Task <ApplicationUser> RegisterNewUserAsync(string userName, string email, string password, bool requireConfirmEmail)
{
var user = new ApplicationUser
{
UserName = userName,
Email = email
};
var result = password == null ?
await _userManager.CreateAsync(user) :
await _userManager.CreateAsync(user, password);
if (!result.Succeeded)
{
throw new DomainException(string.Join(",", result.Errors.Select(i => i.Description)));
}
await _userManager.AddClaimsAsync(user, new Claim[] {
new Claim(Policies.IsUser, string.Empty),
new Claim(JwtClaimTypes.Name, user.UserName),
new Claim(JwtClaimTypes.Email, user.Email),
new Claim(JwtClaimTypes.EmailVerified, "false", ClaimValueTypes.Boolean)
});
if (await _roleManager.RoleExistsAsync(DefaultRoleNames.User))
{
await _userManager.AddToRoleAsync(user, DefaultRoleNames.User);
}
_logger.LogInformation("New user registered: {0}", user);
var emailMessage = new EmailMessageDto();
if (requireConfirmEmail)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = $"{_configuration["BlazorBoilerplate:ApplicationUrl"]}/Account/ConfirmEmail/{user.Id}?token={token}";
emailMessage.BuildNewUserConfirmationEmail(user.UserName, user.Email, callbackUrl, user.Id.ToString(), token); //Replace First UserName with Name if you want to add name to Registration Form
}
else
{
emailMessage.BuildNewUserEmail(user.FullName, user.UserName, user.Email, password);
}
emailMessage.ToAddresses.Add(new EmailAddressDto(user.Email, user.Email));
try
{
await _emailManager.SendEmailAsync(emailMessage);
}
catch (Exception ex)
{
_logger.LogError("New user email failed: Body: {0}, Error: {1}", emailMessage.Body, ex.GetBaseException().Message);
}
return(user);
}
async Task SendMailAsync(EmailMessageDto emailMessage)
{
var message = new MimeMessage();
message.From.Add(new MailboxAddress(_mailSettings.SenderName, _mailSettings.Email));
message.To.Add(new MailboxAddress(emailMessage.ToName, emailMessage.ToAddress));
message.Subject = emailMessage.Subject;
message.Body = new TextPart("plain")
{
Text = emailMessage.Text
};
using (var client = new SmtpClient())
{
await client.ConnectAsync(_mailSettings.SmtpServer, _mailSettings.Port);
client.AuthenticationMechanisms.Remove("XOAUTH2");
await client.AuthenticateAsync(_mailSettings.Email, _mailSettings.Password);
await client.SendAsync(message);
await client.DisconnectAsync(true);
}
}
public ResultDto SendMessage(EmailMessageDto messageDto)
{
if (messageDto.Sender.Id == messageDto.Receiver.Id)
{
return new ResultDto()
{
Message = "You cannot send e-mail to yourself", RequestStatus = RequestStatus.Error
}
}
;
var message = new EmailMessage()
{
DateSent = DateTime.Now,
IsRead = false,
ReceiverId = messageDto.Receiver.Id,
SenderId = messageDto.Sender.Id,
RequestDeliveryNote = messageDto.RequestDeliveryNote,
Message = messageDto.Message,
Title = messageDto.Title
};
_messageRepository.SaveAndSendMessage(message);
return(new ResultDto()
{
Message = "E-mail has been sent", RequestStatus = RequestStatus.Success
});
}
public virtual void Email(int invoiceUid, int templateUid, EmailMessageDto emailMessage)
{
TasksRunner tasksRunner = new TasksRunner(this.WSAccessKey, this.FileUid);
tasksRunner.Tasks.Add(this.CreateEmailTask(invoiceUid, templateUid, emailMessage));
this.HandleEmailResult(tasksRunner.Execute());
}
public async Task SendTestMail2()
{
//Arrange
var settings = new ConfigSettingsDto
{
RelayAddress = "10.200.7.116"
};
var accessor = new EmailAccessor(settings);
var msg = new EmailMessageDto
{
To = "",
From = "no-repy@",
Subject = "Test2",
Body = "This is a test with zipped excel.",
FileName = "sample.zip",
AttatchmentMime = "application/zip",
File = GetEmbededFileByName("stuff.zip")
};
//Act
await accessor.SendEmail(msg);
//Assert
}
public override async Task <CreateEmailMessageResponse> CreateEmailMessage(
CreateEmailMessageRequest request, ServerCallContext context)
{
var emailMessage = new EmailMessageDto()
{
From = request.Message.From,
Tos = request.Message.Tos,
CCs = request.Message.CCs,
BCCs = request.Message.BCCs,
Subject = request.Message.Subject,
Body = request.Message.Body,
};
var result = await mediator.Send(new CreateEmailMessageCommand(emailMessage));
var response = new CreateEmailMessageResponse
{
Message = new EmailMessage
{
Id = result.Message.Id.ToString()
}
};
return(response);
}
public async Task SendMailAsync(string toName, string toAddress, string subject, string text)
{
if (!_mailSettings.IsEnabled)
{
return;
}
var email = new EmailMessageDto {
ToName = toName, ToAddress = toAddress, Subject = subject, Text = text
};
await _messagePublisher.Publish(email);
//var message = new MimeMessage();
//message.From.Add(new MailboxAddress(_mailSettings.SenderName, _mailSettings.Email));
//message.To.Add(new MailboxAddress(toName, toAddress));
//message.Subject = subject;
//message.Body = new TextPart("plain")
//{
// Text = text
//};
//using (var client = new SmtpClient())
//{
// await client.ConnectAsync(_mailSettings.SmtpServer, _mailSettings.Port);
// client.AuthenticationMechanisms.Remove("XOAUTH2");
// await client.AuthenticateAsync(_mailSettings.Email, _mailSettings.Password);
// await client.SendAsync(message);
// await client.DisconnectAsync(true);
//}
}
public async Task <ApiResponse> QueueEmail(EmailMessageDto emailMessage, EmailType emailType)
{
try
{
_dbContext.QueuedEmails.Add(new QueuedEmail()
{
Email = JsonConvert.SerializeObject(emailMessage), EmailType = emailType
});
await _dbContext.SaveChangesAsync();
QueueSync.Release();
var msg = $"Email to {string.Join(" - ", emailMessage.ToAddresses.Select(i => i.Address))} queued";
_logger.LogInformation(msg);
return(new ApiResponse(Status200OK, msg));
}
catch (Exception ex)
{
_logger.LogError($"QueueEmail failed {ex.GetBaseException().Message} {ex.StackTrace}");
return(new ApiResponse(Status500InternalServerError, ex.GetBaseException().Message));
}
}
public IActionResult Index(EmailMessageDto email)
{
try
{
var result = _teacherService.SendEmailToParent(email);
if (result)
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(RedirectToAction("Index", "Teacher"));
}
}
catch (Exception e)
{
if (e is ArgumentNullException || e is ArgumentException)
{
ViewBag.Info = e.Message;
return(View());
}
return(View("Error"));
}
}
public virtual void UpdateAndEmail(InvoiceDto invoice, int templateUid, EmailMessageDto emailMessage)
{
TasksRunner tasksRunner = new TasksRunner(this.WSAccessKey, this.FileUid);
tasksRunner.Tasks.Add(this.CreateUpdateTask(invoice, templateUid, emailMessage));
this.HandleUpdateResult(tasksRunner.Execute(), invoice);
invoice.IsSent = true; // Reaches here - no error. Assume invoice has been sent successfully.
}
//Used by API
public async Task <ApiResponse> SendTestEmail(EmailDto parameters)
{
EmailMessageDto email = _emailFactory.BuildTestEmail(parameters.ToName);
email.ToAddresses.Add(new EmailAddressDto(parameters.ToName, parameters.ToAddress));
return(parameters.Queued ? await QueueEmail(email, EmailType.Test) : await SendEmail(email));
}
public async Task <ApiResponse> SendEmailAsync(EmailMessageDto emailMessage)
{
var message = new MimeMessage();
// Set From Address it was not set
if (emailMessage.FromAddresses.Count == 0)
{
emailMessage.FromAddresses.Add(new EmailAddressDto(_emailConfiguration.FromName, _emailConfiguration.FromAddress));
}
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.Cc.AddRange(emailMessage.CcAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
message.Bcc.AddRange(emailMessage.BccAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
//Use for testing - send a copy of any email to from address when in debug mode
//if (System.Diagnostics.Debugger.IsAttached)
//{
// message.To.Clear();
// message.To.Add(new MailboxAddress(_emailConfiguration.FromName, _emailConfiguration.FromAddress));
//}
message.Subject = emailMessage.Subject;
message.Body = emailMessage.IsHtml ? new BodyBuilder {
HtmlBody = emailMessage.Body
}.ToMessageBody() : new TextPart("plain")
{
Text = emailMessage.Body
};
//TODO store all emails in Database
//Be careful that the SmtpClient class is the one from Mailkit not the framework!
using (var emailClient = new SmtpClient())
{
if (!_emailConfiguration.SmtpUseSSL)
{
emailClient.ServerCertificateValidationCallback = (object sender2, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) => true;
}
await emailClient.ConnectAsync(_emailConfiguration.SmtpServer, _emailConfiguration.SmtpPort, _emailConfiguration.SmtpUseSSL);
//Remove any OAuth functionality as we won't be using it.
emailClient.AuthenticationMechanisms.Remove("XOAUTH2");
if (!string.IsNullOrWhiteSpace(_emailConfiguration.SmtpUsername))
{
await emailClient.AuthenticateAsync(_emailConfiguration.SmtpUsername, _emailConfiguration.SmtpPassword);
}
await emailClient.SendAsync(message);
await emailClient.DisconnectAsync(true);
return(new ApiResponse(Status203NonAuthoritative));
}
}
protected virtual ITask CreateEmailTask(int invoiceUid, int templateUid, EmailMessageDto emailMessage)
{
EmailPdfInvoiceTask task = new EmailPdfInvoiceTask();
task.InvoiceUid = invoiceUid;
task.TemplateUid = templateUid;
task.EmailMessage = emailMessage;
return(task);
}
public async Task <ApplicationUser> RegisterNewUserAsync(string userName, string email, string password, bool requireConfirmEmail)
{
var user = new ApplicationUser
{
UserName = userName,
Email = email
};
var createUserResult = password == null ?
await _userManager.CreateAsync(user) :
await _userManager.CreateAsync(user, password);
if (!createUserResult.Succeeded)
{
throw new DomainException(createUserResult.Errors.FirstOrDefault()?.Description);
}
await _userManager.AddClaimsAsync(user, new Claim[] {
new Claim(Policies.IsUser, ""),
new Claim(JwtClaimTypes.Name, user.UserName),
new Claim(JwtClaimTypes.Email, user.Email),
new Claim(JwtClaimTypes.EmailVerified, "false", ClaimValueTypes.Boolean)
});
//Role - Here we tie the new user to the "User" role
await _userManager.AddToRoleAsync(user, "User");
_logger.LogInformation("New user registered: {0}", user);
var emailMessage = new EmailMessageDto();
if (requireConfirmEmail)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string callbackUrl = string.Format("{0}/Account/ConfirmEmail/{1}?token={2}", _configuration["BlazorBoilerplate:ApplicationUrl"], user.Id, token);
emailMessage.BuildNewUserConfirmationEmail(user.UserName, user.Email, callbackUrl, user.Id.ToString(), token); //Replace First UserName with Name if you want to add name to Registration Form
}
else
{
emailMessage.BuildNewUserEmail(user.FullName, user.UserName, user.Email, password);
}
emailMessage.ToAddresses.Add(new EmailAddressDto(user.Email, user.Email));
try
{
await _emailService.SendEmailAsync(emailMessage);
}
catch (Exception ex)
{
_logger.LogInformation("New user email failed: Body: {0}, Error: {1}", emailMessage.Body, ex.Message);
}
return(user);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email, Email = Input.Email, Surname = Input.Surname
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme);
EmailMessageDto emailMessage = new EmailMessageDto();
emailMessage.ToAddresses = new List <EmailAddressDto>();
emailMessage.ToAddresses.Add(new EmailAddressDto("", Input.Email));
emailMessage.Subject = "Confirm your email";
emailMessage.Body = $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.";
emailMessage.IsHtml = true;
await _emailSender.SendEmailAsync(emailMessage);
//await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
// $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public IHttpActionResult SendEmail(EmailMessageDto messageDto)
{
messageDto.Sender = new ApplicationUserDto()
{
Id = User.Identity.GetUserId()
};
var result = _messageService.SendMessage(messageDto);
return(this.ReturnHttpResponse(result));
}
public EmailMessageDto BuildTestEmail(string recipient)
{
var emailMessage = new EmailMessageDto();
emailMessage.Body = L["TestEmail.template"].Value
.FormatWith(new { baseUrl = BaseUrl, user = recipient, testDate = DateTime.Now });
emailMessage.Subject = L["TestEmail.subject", recipient];
return(emailMessage);
}
public EmailMessageDto BuildTestEmail()
{
var emailMessage = new EmailMessageDto();
emailMessage.Body = L["TestEmail.template"].Value
.FormatWith(new { user = emailMessage.ToAddresses[0].Name, testDate = DateTime.Now });
emailMessage.Subject = L["TestEmail.subject", emailMessage.ToAddresses[0].Name];
return(emailMessage);
}
public EmailMessageDto BuildPasswordResetEmail(string userName)
{
var emailMessage = new EmailMessageDto();
emailMessage.Body = L["PasswordReset.template"].Value
.FormatWith(new { baseUrl, userName });
emailMessage.Subject = L["PasswordReset.subject", userName];
return(emailMessage);
}
public EmailMessageDto BuildNewUserEmail(string fullName, string userName, string emailAddress, string password)
{
var emailMessage = new EmailMessageDto();
emailMessage.Body = L["NewUserEmail.template"].Value
.FormatWith(new { baseUrl, fullName = userName, userName, email = emailAddress, password });
emailMessage.Subject = L["NewUserEmail.subject", fullName];
return(emailMessage);
}
public EmailMessageDto BuildForgotPasswordEmail(string name, string callbackUrl, string token)
{
var emailMessage = new EmailMessageDto();
emailMessage.Body = L["ForgotPassword.template"].Value
.FormatWith(new { baseUrl, name, callbackUrl, token });
emailMessage.Subject = L["ForgotPassword.subject", name];
return(emailMessage);
}
public EmailMessageDto BuildNewUserConfirmationEmail(string fullName, string userName, string callbackUrl)
{
var emailMessage = new EmailMessageDto();
emailMessage.Body = L["NewUserConfirmationEmail.template"].Value
.FormatWith(new { baseUrl, name = fullName, userName, callbackUrl });
emailMessage.Subject = L["NewUserConfirmationEmail.subject", fullName];
return(emailMessage);
}
public EmailMessageDto BuildNewUserConfirmationEmail(string recepientName, string userName, string callbackUrl, string userId, string token)
{
var emailMessage = new EmailMessageDto();
emailMessage.Body = L["NewUserConfirmationEmail.template"].Value
.FormatWith(new { name = recepientName, userName, callbackUrl, userId, token });
emailMessage.Subject = L["NewUserConfirmationEmail.subject", recepientName];
return(emailMessage);
}
public Task SendAsync(EmailMessageDto message)
{
Guard.Against.Null(message, nameof(message));
logger.LogCritical("Sending email");
// Likely use something like SendGrid here.
// Consider sending the email message to a queue so that retries can be handled.
return(Task.CompletedTask);
}
public async Task <ApiResponse> ReceiveMailImapAsync()
{
using (var emailClient = new ImapClient())
{
try
{
// use this if you need to specify using ssl; MailKit should usually be able to autodetect the appropriate settings
// await emailClient.ConnectAsync(_emailConfiguration.ImapServer, _emailConfiguration.ImapPort, _emailConfiguration.ImapUseSSL).ConfigureAwait(false);
await emailClient.ConnectAsync(_emailConfiguration.ImapServer, _emailConfiguration.ImapPort).ConfigureAwait(false);
emailClient.AuthenticationMechanisms.Remove("XOAUTH2");
if (!string.IsNullOrWhiteSpace(_emailConfiguration.ImapUsername))
{
await emailClient.AuthenticateAsync(_emailConfiguration.ImapUsername, _emailConfiguration.ImapPassword).ConfigureAwait(false);
}
List <EmailMessageDto> emails = new List <EmailMessageDto>();
await emailClient.Inbox.OpenAsync(MailKit.FolderAccess.ReadOnly);
//TODO implement email results filtering
var uids = await emailClient.Inbox.SearchAsync(SearchQuery.All);
foreach (var uid in uids)
{
var message = await emailClient.Inbox.GetMessageAsync(uid);
var emailMessage = new EmailMessageDto
{
Body = !string.IsNullOrEmpty(message.HtmlBody) ? message.HtmlBody : message.TextBody,
Subject = message.Subject
};
emailMessage.ToAddresses.AddRange(message.To.Select(x => (MailboxAddress)x).Select(x => new EmailAddressDto(x.Name, x.Address)));
emailMessage.FromAddresses.AddRange(message.From.Select(x => (MailboxAddress)x).Select(x => new EmailAddressDto(x.Name, x.Address)));
emails.Add(emailMessage);
}
await emailClient.DisconnectAsync(true);
return(new ApiResponse(200, null, emails));
}
catch (Exception ex)
{
_logger.LogError("Imap Email Retrieval failed: {0}", ex.Message);
return(new ApiResponse(500, ex.Message));
}
}
}
public async Task <IActionResult> SendEmail([FromBody] EmailMessageDto mail)
{
try
{
await _exchangeService.SendEmailAsync(mail);
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
private static async Task SendEmail(string key, EmailMessageDto requestedMessageToSend)
{
var client = new SendGridClient(key);
var msg = new SendGridMessage();
msg.SetFrom(new EmailAddress("*****@*****.**", "EmailSender app"));
msg.AddTo(requestedMessageToSend.To);
msg.SetSubject(requestedMessageToSend.Title);
msg.PlainTextContent = requestedMessageToSend.Body;
await client.SendEmailAsync(msg);
}
public EmailMessageDto BuilNewUserNotificationEmail(string creator, string name, string userName, string company, string roles)
{
var emailMessage = new EmailMessageDto();
//placeholder not actually implemented
emailMessage.Body = L["NewUserNotificationEmail.template"].Value
.FormatWith(new { baseUrl, creator, name, userName, roles, company });
emailMessage.Subject = L["NewUserNotificationEmail.subject", userName];
return(emailMessage);
}
public EmailMessageDto GetPlainTextTestEmail(DateTime date)
{
var emailMessage = new EmailMessageDto();
emailMessage.Body = L["PlainTextTestEmail.template"].Value
.FormatWith(new { date });
emailMessage.Subject = L["PlainTextTestEmail.subject", emailMessage.ToAddresses[0].Name];
emailMessage.IsHtml = false;
return(emailMessage);
}
public async Task <ApiResponse> ResetPassword(ResetPasswordDto parameters)
{
if (!ModelState.IsValid)
{
return(new ApiResponse(400, "User Model is Invalid"));
}
var user = await _userManager.FindByIdAsync(parameters.UserId);
if (user == null)
{
_logger.LogInformation("User does not exist: {0}", parameters.UserId);
return(new ApiResponse(404, "User does not exist"));
}
#region Reset Password Successful Email
try
{
IdentityResult result = await _userManager.ResetPasswordAsync(user, parameters.Token, parameters.Password);
if (result.Succeeded)
{
#region Email Successful Password change
var email = new EmailMessageDto();
email.ToAddresses.Add(new EmailAddressDto(user.Email, user.Email));
email.BuildPasswordResetEmail(user.UserName); //Replace First UserName with Name if you want to add name to Registration Form
_logger.LogInformation("Reset Password Successful Email Sent: {0}", user.Email);
await _emailService.SendEmailAsync(email);
#endregion Email Successful Password change
return(new ApiResponse(200, String.Format("Reset Password Successful Email Sent: {0}", user.Email)));
}
else
{
_logger.LogInformation("Error while resetting the password!: {0}", user.UserName);
return(new ApiResponse(400, string.Format("Error while resetting the password!: {0}", user.UserName)));
}
}
catch (Exception ex)
{
_logger.LogInformation("Reset Password failed: {0}", ex.Message);
return(new ApiResponse(400, string.Format("Error while resetting the password!: {0}", ex.Message)));
}
#endregion Reset Password Successful Email
}
