public async Task <IActionResult> Create([Bind("Id,FromUser,ToUser,IsEmail,Body")] UserMessageModel userMessageModel)
{
if (ModelState.IsValid)
{
userMessageModel.Id = Guid.NewGuid();
var toEmail = userMessageModel.ToUser;
userMessageModel.FromUser = (await _userManager.FindByNameAsync(User.Identity.Name)).Id;
userMessageModel.ToUser = (await _userManager.FindByNameAsync(userMessageModel.ToUser)).Id;
// Check wether message doesn't be sent to myself
if (!userMessageModel.FromUser.Equals(userMessageModel.ToUser))
{
_context.Add(userMessageModel);
await _context.SaveChangesAsync();
if (userMessageModel.IsEmail && _sender != null)
{
var bodyBuilder = new System.Text.StringBuilder();
bodyBuilder.AppendFormat("<h2>You have new message from {0}</h2>.<br />", User.Identity.Name);
bodyBuilder.AppendFormat("<div class=\"message\">{0}</div><br /><br />", userMessageModel.Body);
bodyBuilder.AppendFormat("<div class=\"footer\">Pure MVC {0}</div>", DateTime.UtcNow.Year);
await _sender.SendEmailAsync(toEmail, "Pure MVC user messages subsystem.", bodyBuilder.ToString());
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(userMessageModel));
}
public async Task <IActionResult> OrderReady(int OrderId)
{
await orderService.OrderReady(OrderId);
//Email logic to notify user that order is ready for pickup
var order = await orderService.GetOrderHeaderById(OrderId);
var subject = "Spicy - Order Ready " + OrderId.ToString();
var msg = "The Order Has been Ready for pichup.";
var applicationUser = await userService.GetUserById(order.UserId);
await emailSender.SendEmailAsync(applicationUser.Email, subject, msg);
return(RedirectToAction("ManageOrder", "Order"));
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
return(RedirectToAction(nameof(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.ResetPasswordCallbackLink(user.Id, code, Request.Scheme);
await _emailSender.SendEmailAsync(model.Email, "Reset Password",
$"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
return(RedirectToAction(nameof(ForgotPasswordConfirmation)));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> OnPostAsync()
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(UserId);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToPage("./CheckEmail"));
}
if (user.Email != Input.Email)
{
var errors = new List <IdentityError>();
if (_userManager.Options.User.RequireUniqueEmail)
{
var owner = await _userManager.FindByEmailAsync(Input.Email);
if (owner != null && !string.Equals
(await _userManager.GetUserIdAsync(owner),
await _userManager.GetUserIdAsync(user)))
{
ModelState.AddModelError(string.Empty,
new IdentityErrorDescriber().DuplicateEmail(Input.Email).Description);
return(Page());
}
}
await _userManager.SetEmailAsync(user, Input.Email);
}
var result = await _userManager.UpdateSecurityStampAsync(user);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
return(Page());
}
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email", $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
return(RedirectToPage("./CheckEmail"));
}
return(Page());
}
public async Task <IActionResult> OnPostAsync()
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(Input.Email);
if (user == null)
{
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ResetPassword",
pageHandler: null,
values: new { area = "Identity", code },
protocol: Request.Scheme);
var message = new Message(new string[] { Input.Email }, "Resetowanie hasła", "VetSys otrzymał prośbę o utworzenie nowego hasła powiązanego z twoim adresem email. Jeżeli chcesz zresetować hasło wejdź na link: " + callbackUrl);
await _emailSender.SendEmailAsync(message);
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
return(Page());
}
public async Task <IActionResult> OnPostSendVerificationEmailAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.FindByEmailAsync(Input.Email);
if (user == null)
{
ModelState.AddModelError(string.Empty, "Verification email sent. Please check your email.");
}
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
null,
new { userId = userId, code = code },
Request.Scheme);
await _emailSender.SendEmailAsync(
Input.Email,
"Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
ModelState.AddModelError(string.Empty, "Verification email sent. Please check your email.");
return(Page());
}
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);
await _emailSender.SendEmailAsync(
Input.Email,
"Reset Password",
$"Please reset your password by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
return(Page());
}
public async Task <IActionResult> OnPostSendVerificationEmailAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
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);
await _emailSender.SendEmailAsync(
email,
"Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
StatusMessage = "Verification email sent. Please check your email.";
return(RedirectToPage());
}
public async Task <IActionResult> FAQ(
[FromServices] Services.IEmailSender emailSender,
[FromServices] IOptionsSnapshot <Models.AppSettings> appSettings,
string email,
string message,
int hideMe
)
{
string str = "";
if (hideMe == 4)
{
this.ctx.Messages.Add(new Message()
{
Msg = message,
Email = email,
TimeStamp = DateTime.UtcNow
});
this.ctx.SaveChanges();
str = "Thanks!";
try
{
await emailSender.SendEmailAsync(appSettings.Value.Email, "Private message from AwardHacks", email + " said " + message);
}
catch { }
}
return(View((object)str));
}
public async Task <IActionResult> OnPostSendVerificationEmailAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.FindByEmailAsync(Input.Email);
if (user == null)
{
ModelState.AddModelError(string.Empty, "Verification email sent. Please check your email.");
}
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = userId, code = code },
protocol: Request.Scheme);
var message = new Message(new string[] { Input.Email }, "Resetowanie hasła", "VetSys otrzymał prośbę o utworzenie nowego hasła powiązanego z twoim adresem email. Jeżeli chcesz zresetować hasło wejdź na link: " + callbackUrl);
await _emailSender.SendEmailAsync(message);
ModelState.AddModelError(string.Empty, "Verification email sent. Please check your email.");
return(Page());
}
public async Task <IActionResult> OnPostChangeEmailAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!ModelState.IsValid)
{
await LoadAsync(user);
return(Page());
}
var email = await _userManager.GetEmailAsync(user);
if (Input.NewEmail != email && user.EmailConfirmed == true)
{
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateChangeEmailTokenAsync(user, Input.NewEmail);
var callbackUrl = Url.Page(
"/Account/ConfirmEmailChange",
pageHandler: null,
values: new { userId = userId, email = Input.NewEmail, code = code },
protocol: Request.Scheme);
var message = new Message(new string[] { Input.NewEmail }, "Zmiana adresu email", "VetSys otrzymał prośbę o zmianę adresu email konta powiązanego z twoim adresem email. Jeżeli chcesz zmienić email wejdź na link:" + callbackUrl);
await _emailSender.SendEmailAsync(message);
StatusMessage = "Link uprawniający do zmiany adresu email został przesłany. Proszę sprawdź swój email.";
return(RedirectToPage());
}
else if (user.EmailConfirmed == false)
{
StatusMessage = "Proszę aktywuj konto.";
return(RedirectToPage());
}
StatusMessage = "Link uprawniający do zmiany adresu email został przesłany. Proszę sprawdź swój email.";
return(RedirectToPage());
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
null,
new { area = "Identity", userId = userId, code = code },
Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
public async Task <IActionResult> OnPostChangeEmailAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!ModelState.IsValid)
{
await LoadAsync(user);
return(Page());
}
var email = await _userManager.GetEmailAsync(user);
if (Input.NewEmail != email)
{
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateChangeEmailTokenAsync(user, Input.NewEmail);
var callbackUrl = Url.Page(
"/Account/ConfirmEmailChange",
null,
new { userId = userId, email = Input.NewEmail, code = code },
Request.Scheme);
await _emailSender.SendEmailAsync(
Input.NewEmail,
"Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
StatusMessage = "Confirmation link to change email sent. Please check your email.";
return(RedirectToPage());
}
StatusMessage = "Your email is unchanged.";
return(RedirectToPage());
}
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
};
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",
null,
new { area = "Identity", userId = user.Id, code = code },
Request.Scheme);
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, 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 async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new IdentityUser {
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.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
//await _signInManager.SignInAsync(user, isPersistent: false);
//return LocalRedirect(returnUrl);
return(RedirectToPage("./CheckEmail"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> SendAlerts(
[FromServices] Services.IViewRenderService render,
[FromServices] Services.IEmailSender sender,
bool dryRun = true, string secret = null)
{
if (secret == appSettings.Secret)
{
var changes = ctx.AllChanges.Include(c => c.Route).Where(c => c.Route.Crawl && c.Route.Show && (c.Business > 0 || c.Go > 0 || c.Plus > 0))
.ToList().Where(c => c.HasIncrease(CabinClass.All)).ToList();
var alerts = ctx.Alerts.Where(a => !a.ToDate.HasValue || a.ToDate >= DateTime.Now.Date).ToList();
var newMails = new Dictionary <string, AlertMailModel>();
foreach (var change in changes)
{
var matches = alerts.Where(a => a.Created < change.CrawlDate && a.RouteId == change.RouteId && a.Return == change.Return && a.IsInRange(change.TravelDate));
matches = matches.Where(a => a.Matches(CabinClass.Go, change.Go) || a.Matches(CabinClass.Plus, change.Plus) || a.Matches(CabinClass.Business, change.Business)).ToList();
foreach (var alert in matches)
{
if (change.HasIncrease(alert.CabinClass))
{
if (dryRun || !ctx.SentMail.Any(sm => sm.UserId == alert.UserId && sm.Crawl.RouteId == alert.RouteId && sm.Crawl.Return == alert.Return && sm.Crawl.TravelDate == change.TravelDate))
{
if (!newMails.ContainsKey(alert.UserId))
{
var user = ctx.Users.FirstOrDefault(u => u.Id == alert.UserId);
newMails[alert.UserId] = new AlertMailModel
{
User = user,
Rows = new List <MailContainer>()
};
}
newMails[alert.UserId].Rows.Add(new MailContainer {
Crawl = change, Pax = (uint)alert.Passengers, CabinClass = alert.CabinClass
});
}
}
}
}
var countHash = newMails.Values.SelectMany(m => m.Rows).GroupBy(c => c.Crawl.Id).ToDictionary(g => g.Key, g => g.Count());
if (dryRun)
{
foreach (var mail in newMails.Values.Take(5))
{
mail.CountHash = countHash;
var html = await render.RenderToStringAsync("Alerts/AlertMail", mail);
await sender.SendEmailAsync(appSettings.Email, "AwardHacks found new seats for you", html);
}
}
else
{
foreach (var mail in newMails.Values)
{
try
{
mail.CountHash = countHash;
mail.Rows = mail.Rows.OrderBy(c => c.Crawl.TravelDate).Distinct().ToList();
var html = await render.RenderToStringAsync("Alerts/AlertMail", mail);
foreach (var c in mail.Rows.Select(r => r.Crawl))
{
var sm = new SentMail
{
UserId = mail.User.Id,
CrawlId = c.Id,
Date = DateTime.UtcNow
};
ctx.SentMail.Add(sm);
}
ctx.SaveChanges();
await sender.SendEmailAsync(mail.User.Email, "AwardHacks found new seats for you", html);
}
catch (Exception ex)
{
//Todo: log
}
//return Content(html, "text/html");
}
}
}
return(Ok());
}
public async Task <IActionResult> SummaryPost(string stripeEmail, string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)this.User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
var applicationUser = await userService.GetUserById(claim.Value);
DetailsCart.listCart = (await shoppingCartService.GetShoppingCartsByUserId(claim.Value)).ToList();
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
DetailsCart.OrderHeader.Status = SD.PaymentStatusPending;
DetailsCart.OrderHeader.UserId = claim.Value;
DetailsCart.OrderHeader.PickUpTime =
Convert.ToDateTime(DetailsCart.OrderHeader.PickUpDate.ToShortDateString()
+ " " + DetailsCart.OrderHeader.PickUpTime.ToShortTimeString());
DetailsCart.OrderHeader.OrderDate = DateTime.Now;
await orderService.AddOrderHeaderAsync(DetailsCart.OrderHeader);
DetailsCart.OrderHeader.OrderTotalOriginal = 0;
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
foreach (var item in DetailsCart.listCart)
{
item.MenuItem = await menuItemService.GetMenuItemById(item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = DetailsCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
DetailsCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
orderDetailsList.Add(orderDetails);
}
await orderService.AddOrdersDetailsAsync(orderDetailsList);
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
DetailsCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await couponService.GetCouponByName(DetailsCart.OrderHeader.CouponCode.ToLower());
DetailsCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, DetailsCart.OrderHeader.OrderTotalOriginal);
}
else
{
DetailsCart.OrderHeader.OrderTotal = DetailsCart.OrderHeader.OrderTotalOriginal;
}
DetailsCart.OrderHeader.CouponCodeDiscount = DetailsCart.OrderHeader.OrderTotalOriginal - DetailsCart.OrderHeader.OrderTotal;
await orderService.CommitAsync();
await shoppingCartService.RemoveShoppingCarts(DetailsCart.listCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
var options = new ChargeCreateOptions()
{
Amount = Convert.ToInt32(DetailsCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order Id : " + DetailsCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options);
if (charge.BalanceTransactionId == null)
{
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
DetailsCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
var subject = "Spicy - Order Created " + DetailsCart.OrderHeader.Id.ToString();
var msg = "The Order Has been created successfully";
await emailSender.SendEmailAsync(applicationUser.Email, subject, msg);
//emailSender.SendMailkit(applicationUser.Name,applicationUser.Email);
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
DetailsCart.OrderHeader.Status = SD.StatusSubmitted;
await orderService.CommitAsync();
}
else
{
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
await orderService.CommitAsync();
}
return(RedirectToAction("Confirm", "Order", new { id = DetailsCart.OrderHeader.Id }));
//return RedirectToAction("Index", "Home");
}
