public async Task <SendEmailResponse> SendGeneralEmailAsync(SendEmailDetails details, string title, string content1, string content2, string buttonText, string buttonUrl)
{
var templateText = default(string);
//read general template from file
using (var reader = new StreamReader(Path.Combine("Email/Templates/GeneralTemplate.html"), Encoding.UTF8))
{
templateText = await reader.ReadToEndAsync();
}
//replace special values
templateText = templateText
.Replace("--Title--", title)
.Replace("--Content1--", content1)
.Replace("--Content2--", content2)
.Replace("--ButtonText--", buttonText)
.Replace("--ButtonUrl--", buttonUrl);
//set details content
details.Content = templateText;
var emailSender = Ioc.IoC.EmailSender;
return(await Ioc.IoC.EmailSender.SendEmailAsync(details));
}
public async Task <SendEmailResponse> SendGeneralEmailAsync(SendEmailDetails details, string title, string content1, string content2, string buttonContent, string buttonUrl)
{
var templateText = default(string);
// Read the general template from file
// TODO: Replace with IoC Flat data provider
using (var reader = new StreamReader(Assembly.GetEntryAssembly().GetManifestResourceStream("Quan.Word.Web.Server.Email.Templates.GeneralTemplate.html"), Encoding.UTF8))
{
// Read file contents
templateText = await reader.ReadToEndAsync();
}
// Replace special values with those inside the template
templateText = templateText.Replace("--Title--", title)
.Replace("--Content1--", content1)
.Replace("--Content2--", content2)
.Replace("--ButtonContent--", buttonContent)
.Replace("--ButtonUrl--", buttonUrl);
// Set the details content to this template content
details.Content = templateText;
// Send Email
return(await DI.EmailSender.SendEmailAsync(details));
}
public async Task <ResponseError> SendEmailAsync(SendEmailDetails details)
{
var apiKey = _configuration["SendGrid:InstaSendApiKey"];
var client = new SendGridClient(apiKey);
var from = new EmailAddress(details.FromEmail, details.FromName);
var to = new EmailAddress(details.ToEmail, details.ToName);
var subject = details.Subject;
var message = MailHelper.CreateSingleEmail(
from,
to,
subject,
details.IsHtml ? null : details.Content,
details.IsHtml ? details.Content : null);
var response = await client.SendEmailAsync(message);
if (response.StatusCode == HttpStatusCode.Accepted)
{
return(new ResponseError());
}
else
{
var bodyResult = await response.Body.ReadAsStringAsync();
var sendEmailResponse = JsonConvert.DeserializeObject <ResponseError>(bodyResult);
return(sendEmailResponse);
}
}
public async Task SendOrderMail(OrderDetailsViewModel model)
{
string content = CreateEmaiContent(model.Email);
SendEmailDetails details = new SendEmailDetails()
{
FromEmail = this.provider.GetService <IConfiguration>()["VerificationEmailDetails:FromEmail"],
FromName = this.provider.GetService <IConfiguration>()["VerificationEmailDetails:FromName"],
ToEmail = model.Email,
ToName = model.FirstName + " " + model.LastName,
Subject = "Confirmation of you CakeIt order.",
Content = content
};
var sendEmailResult = await this.provider.GetService <ICustomEmilSender>().SendEmailAsync(details);
if (!sendEmailResult.Successful)
{
foreach (var error in sendEmailResult.Errors)
{
this.logger.LogDebug(error);
}
}
this.cartService.EmptyCart();
}
public async Task <IActionResult> OnPostSendVerificationEmailAsync()
{
if (!ModelState.IsValid)
{
var errors = this.ModelState.Values.SelectMany(p => p.Errors).Select(e => e.ErrorMessage).ToArray();
this._provider.GetService <IErrorService>().PassErrorParam(errors);
return(RedirectToPage("/Error"));
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
var userId = await _userManager.GetUserIdAsync(user);
var email = await _userManager.GetEmailAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = userId, code = code },
protocol: Request.Scheme);
string content = CreateEmaiContent(Input.Email, callbackUrl);
SendEmailDetails details = new SendEmailDetails()
{
FromEmail = this._provider.GetService <IConfiguration>()["VerificationEmailDetails:FromEmail"],
FromName = this._provider.GetService <IConfiguration>()["VerificationEmailDetails:FromName"],
ToEmail = Input.Email,
ToName = Input.Email,
Subject = "Confirm your email.",
Content = content
};
var sendEmailResult = await this._provider.GetService <ICustomEmilSender>().SendEmailAsync(details);
if (!sendEmailResult.Successful)
{
var mailErrors = sendEmailResult.Errors;
this._provider.GetService <IErrorService>().PassErrorParam(mailErrors);
return(RedirectToPage("/Error"));
}
StatusMessage = "Verification email sent. Please check your email.";
return(RedirectToPage());
}
public async Task <SendEmailResponse> SendEmailAsync(SendEmailDetails details)
{
var apiKey = Configuration["SendGridKey"];
var client = new SendGridClient(apiKey);
var from = new EmailAddress(details.FromEmail, details.FromName);
var to = new EmailAddress(details.ToEmail, details.ToName);
var subject = details.Subject;
var content = details.Content;
var msg = MailHelper.CreateSingleEmail(
from,
to,
subject,
details.IsHtml ? null : details.Content,
details.IsHtml ? details.Content : null);
var response = await client.SendEmailAsync(msg);
if (response.StatusCode == HttpStatusCode.Accepted)
{
return(new SendEmailResponse());
}
try
{
var bodyResult = await response.Body.ReadAsStringAsync();
var sendGridResponse = JsonConvert.DeserializeObject <SendGridResponse>(bodyResult);
var errorResponse = new SendEmailResponse
{
Errors = sendGridResponse?.Errors.Select(f => f.Message).ToList()
};
if (errorResponse.Errors == null || errorResponse.Errors.Count == 0)
{
// Add an unknown error
// TODO: Localization
errorResponse.Errors = new List <string>(new[] { "Unknown error from email sending service. Please contact Synthesis support." });
}
return(errorResponse);
}
catch (Exception ex)
{
// TODO: Localization
// Break if we are debugging
if (Debugger.IsAttached)
{
var error = ex;
Debugger.Break();
}
return(new SendEmailResponse
{
Errors = new List <string>(new[] { "Unknown error occurred" })
});
}
}
public async Task <IActionResult> OnPostAsync()
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(Input.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
// For more information on how to enable account confirmation and password reset please
// visit https://go.microsoft.com/fwlink/?LinkID=532713
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ResetPassword",
pageHandler: null,
values: new { code },
protocol: Request.Scheme);
string content = CreateEmaiContent(Input.Email, callbackUrl);
//if the mail is html the link shoul be HtmlEncoder.Default.Encode(callbackUrl).
SendEmailDetails details = new SendEmailDetails()
{
FromEmail = this._provider.GetService <IConfiguration>()["VerificationEmailDetails:FromEmail"],
FromName = this._provider.GetService <IConfiguration>()["VerificationEmailDetails:FromName"],
ToEmail = Input.Email,
ToName = Input.Email,
Subject = "Reset Password",
Content = content
};
var sendEmailResult = await this._provider.GetService <ICustomEmilSender>().SendEmailAsync(details);
if (!sendEmailResult.Successful)
{
var errors = sendEmailResult.Errors;
this._provider.GetService <IErrorService>().PassErrorParam(errors);
return(RedirectToPage("/Error"));
}
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
return(Page());
}
public async Task <IActionResult> SendEmailAsync(SendEmailDetails emailDetails)
{
emailDetails.ToEmail = _configuration["Email"];
emailDetails.ToName = _configuration["EmailName"];
emailDetails.FromEmail = _configuration["Email"];
var result = await _emailSender.SendEmailAsync(emailDetails);
if (result.Successful != true)
{
ModelState.AddModelError(string.Empty, "Email sender error!");
return(View("Contact", emailDetails));
}
return(RedirectToAction("Contact"));
}
public async Task <SendEmailResponse> SendGeneratedEmailAsync(SendEmailDetails details, string title, string content, string content2, string buttonText, string buttonUrl)
{
var templateText = default(string);
using (var reader = new StreamReader(Assembly.GetEntryAssembly().GetManifestResourceStream("Mailer.Templates.MailerTemplate.html"), Encoding.UTF8))
{
templateText = await reader.ReadToEndAsync();
}
templateText = templateText.Replace("--Title--", title).Replace("--Content1--", content).Replace("--Content2--", content2)
.Replace("--ButtonText--", buttonText).Replace("--ButtonUrl--", buttonUrl);
details.BodyContent = templateText;
return(await _sender.SendEmailAsync(details));
}
public async Task <IActionResult> Reserve(Reservation reservation)
{
reservation.ClientId = _userManager.GetUserId(User);
reservation.IsActive = true;
reservation.IsCancel = false;
var apartment = _context.Apartments.FirstOrDefault(a => a.Id == reservation.ApartmentId);
var days = (reservation.TimeTo.Ticks - reservation.TimeFrom.Ticks) / 863850233856;
reservation.Price = (int)days * apartment.Price;
_context.Add(reservation);
_context.SaveChanges();
var owner = _context.Owners.FirstOrDefault(o => o.Id == apartment.OwnerId);
var clientId = _userManager.GetUserId(User);
var client = _context.Users.FirstOrDefault(c => c.Id == clientId);
var emailDetails = new SendEmailDetails
{
FromName = _configuration["EmailName"],
FromEmail = _configuration["Email"],
ToEmail = client.Email,
ToName = client.UserName,
TemplateId = _configuration["TemplateIdInvoice"],
TemplateData = new EmailTemplateData
{
Number = reservation.Id,
Date = DateTime.Now.ToShortDateString(),
Owner = owner.UserName,
OwnerEmail = owner.Email,
ApartmentName = apartment.Name,
ReservationPrice = reservation.Price
}
};
var result = await _sender.SendEmailAsync(emailDetails);
if (result.Successful == false)
{
_context.Remove(reservation);
_context.SaveChanges();
return(View("ReservationError", reservation));
}
return(RedirectToAction("Index"));
}
public async Task <SendEmailResponse> SendGeneralEmailAsync(SendEmailDetails details, string confirmationUrl)
{
// Read the general template from file
var stream = new FileStream(@"Statics\GeneralTemplate.txt", FileMode.Open);
using var reader = new StreamReader(stream, Encoding.UTF8);
string templateText = await reader.ReadToEndAsync();
// Replace special values with those inside the template
templateText = templateText.Replace("--Title--", details.Subject)
.Replace("--UserName--", details.ToName)
.Replace("--Content--", details.Content)
.Replace("--confirmationUrl--", confirmationUrl);
// Set the details content to this template content
details.Content = templateText;
return(await SendEmailAsync(details.Subject, details.Content, details.ToEmail));
}
public async Task <ResponseError> SendGeneralEmailAsync(SendEmailDetails details, string title, string content1, string content2, string buttonText, string buttonUrl)
{
string templateText;
using (var reader = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("Infrastructure.Email.Templates.GeneralTemplate.htm") !, Encoding.UTF8))
{
templateText = await reader.ReadToEndAsync();
}
templateText = templateText
.Replace("--Title--", title)
.Replace("--Content1--", content1)
.Replace("--Content2--", content2)
.Replace("--ButtonText--", buttonText)
.Replace("--ButtonUrl--", buttonUrl);
details.Content = templateText;
return(await _emailSender.SendEmailAsync(details));
}
public async Task <SendEmailResponse> SendEmailAsync(SendEmailDetails details)
{
// Get the SendGrid key
var apiKey = Configuration["SendGridKey"];
// Create a new SendGrid client
var client = new SendGridClient(apiKey);
// From
var from = new EmailAddress(details.FromEmail, details.FromName);
// To
var to = new EmailAddress(details.ToEmail, details.ToName);
// Subject
var subject = details.Subject;
// Content
var content = details.Content;
// Create Email class ready to send
var msg = MailHelper.CreateSingleEmail(
from,
to,
subject,
// Plain content
details.IsHTML ? null : details.Content,
// HTML content
details.IsHTML ? details.Content : null);
// Finally, send the email...
var response = await client.SendEmailAsync(msg);
// If we succeeded...
if (response.StatusCode == System.Net.HttpStatusCode.Accepted)
{
// Return successful response
return(new SendEmailResponse());
}
// Otherwise, it failed...
try
{
// Get the result in the body
var bodyResult = await response.Body.ReadAsStringAsync();
// Deserialize the response
var sendGridResponse = JsonConvert.DeserializeObject <SendGridResponse>(bodyResult);
// Add any errors to the response
var errorResponse = new SendEmailResponse
{
Errors = sendGridResponse?.Errors.Select(f => f.Message).ToList()
};
// Make sure we have at least one error
if (errorResponse.Errors == null || errorResponse.Errors.Count == 0)
{
// Add an unknown error
// TODO: Localization
errorResponse.Errors = new List <string>(new[] { "Unknown error from email sending service. Please contact Fasetto support." });
}
// Return the response
return(errorResponse);
}
catch (Exception ex)
{
// TODO: Localization
// Break if we are debugging
if (Debugger.IsAttached)
{
var error = ex;
Debugger.Break();
}
// If something unexpected happened, return message
return(new SendEmailResponse
{
Errors = new List <string>(new[] { "Unknown error occurred" })
});
}
}
public async Task <IActionResult> OnGetAsync(string email, string returnUrl = null)
{
if (email == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return(NotFound($"Unable to load user with email '{email}'."));
}
Email = email;
// Once you add a real email sender, you should remove this code that lets you confirm the account
//DisplayConfirmAccountLink = true;
if (DisplayConfirmAccountLink)
{
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
EmailConfirmationUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
}
else
{
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
EmailConfirmationUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
var emailDetails = new SendEmailDetails
{
FromName = _configuration["EmailName"],
FromEmail = _configuration["Email"],
ToEmail = Email,
TemplateId = _configuration["TemplateIdVerify"],
TemplateData = new EmailTemplateData
{
ActionUrl = EmailConfirmationUrl
}
};
ThisPageUrl = $"/Identity/Account/RegisterConfirmation?email={Email}&returnUrl={returnUrl}";
var result = await _sender.SendEmailAsync(emailDetails);
Error = !(result.Successful);
}
return(Page());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new CakeItUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
IdentityResult asigneRoleResult = await _userManager.AddToRoleAsync(user, "User");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
string content = CreateEmaiContent(Input.Email, callbackUrl);
SendEmailDetails details = new SendEmailDetails()
{
FromEmail = this._provider.GetService <IConfiguration>()["VerificationEmailDetails:FromEmail"],
FromName = this._provider.GetService <IConfiguration>()["VerificationEmailDetails:FromName"],
ToEmail = Input.Email,
ToName = Input.Email,
Subject = "Confirm your email.",
Content = content
};
var sendEmailResult = await this._provider.GetService <ICustomEmilSender>().SendEmailAsync(details);
if (!sendEmailResult.Successful)
{
var mailErrors = sendEmailResult.Errors;
this._provider.GetService <IErrorService>().PassErrorParam(mailErrors);
return(RedirectToPage("/Error"));
}
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
var errors = this.ModelState.Values.SelectMany(p => p.Errors).Select(e => e.ErrorMessage).ToArray();
this._provider.GetService <IErrorService>().PassErrorParam(errors);
return(RedirectToPage("/Error"));
}
// If we got this far, something failed, redisplay form
return(Page());
}
