public async Task Endpoint_PasswordResetWithCorrectToken_ShouldReturnOk()
{
// Assert
var newPassword = "******";
var httpGetToken = await client.GetAsync("api/v1/users/request-password-reset/user");
var responseToken = await httpGetToken.Content.ReadAsStringAsync();
var passwordToken = Guid.Parse(responseToken);
var password = new PasswordResetViewModel()
{
Token = passwordToken, Password = newPassword
};
var user = new LoginViewModel()
{
Username = "******", Password = newPassword
};
// Act
var passwordHttpResponse = await client.PostAsJsonAsync("api/v1/users/password-reset", password);
var loginhttpResponse = await client.PostAsJsonAsync("api/v1/users/login", user);
// Assert
passwordHttpResponse.StatusCode.Should().Be(HttpStatusCode.OK);
loginhttpResponse.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task Endpoint_PasswordResetWithInCorrectToken_ShouldReturnBadRequest()
{
// Assert
var newPassword = "******";
var password = new PasswordResetViewModel()
{
Token = Guid.NewGuid(), Password = newPassword
};
var user = new LoginViewModel()
{
Username = "******", Password = newPassword
};
// Act
var passwordHttpResponse = await client.PostAsJsonAsync("api/v1/users/password-reset", password);
var passwordResponseMessage = await passwordHttpResponse.Content.ReadAsStringAsync();
var loginhttpResponse = await client.PostAsJsonAsync("api/v1/users/login", user);
// Assert
passwordHttpResponse.StatusCode.Should().Be(HttpStatusCode.BadRequest);
passwordResponseMessage.Should().Be("Sorry the password wasn't reset");
loginhttpResponse.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public async Task <IActionResult> ResetPassword(PasswordResetViewModel model)
{
if (ModelState.IsValid)
{
var user = await userManager.FindByEmailAsync(model.Email);
if (user != null)
{
var result = await userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (result.Succeeded)
{
if (await userManager.IsLockedOutAsync(user))
{
await userManager.SetLockoutEndDateAsync(user, DateTimeOffset.Now);
}
return(View("PasswordReset"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
ViewBag.ErrorTitle = "Not Found";
ViewBag.ErrorMessage = $"the user with email {model.Email} was not found";
return(View("Error"));
}
ModelState.AddModelError("", "Invalid Password");
return(View(model));
}
[HttpPost]//Bind[PasswordNew in anlami su icindeki viewModelinin icindeki sadece PasswordNew kismini al diger kisimlara gerek yok anlamina geliyor]
public async Task <IActionResult> ResetPasswordConfirm([Bind("PasswordNew")] PasswordResetViewModel passwordResetViewModel)
{
string userId = TempData["userId"].ToString();
string token = TempData["token"].ToString();
AppUser user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
IdentityResult result = await _userManager.ResetPasswordAsync(user, token, passwordResetViewModel.PasswordNew);
if (result.Succeeded)
{
await _userManager.UpdateSecurityStampAsync(user);
TempData["passwordResetInfo"] = "şifreniz başarılıyla yenilenmiştir.Yeni şifreniz ile giriş yapabilirsiniz";
ViewBag.status = "success";
}
else
{
AddModelError(result);
}
}
else
{
ModelState.AddModelError("", "Bir Hata Meydana Geldi Lütfen Daha Sonra Tekrar Deneyiniz");
}
return(View(passwordResetViewModel));
}
public async Task <IActionResult> PasswordReset(PasswordResetViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
ModelState.AddModelError("", $"User with the email {model.Email} does not exist");
return(View(model));
}
var result = await _userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (!result.Succeeded)
{
foreach (var err in result.Errors)
{
ModelState.AddModelError("", err.Description);
}
return(View(model));
}
return(RedirectToAction("PasswordConfirmationPage", "Account"));
}
// PasswordResetViewModel 'den ayrica email'de geliyor lakin buna ihtiyacimiz yok. o yuzden sadece password icin bind kullaniyoruz. sadece PasswordNew dolacak
public async Task <IActionResult> ResetPasswordConfirm([Bind("PasswordNew")] PasswordResetViewModel passwordResetViewModel)
{
string token = TempData["token"].ToString();
string userId = TempData["userId"].ToString();
AppUser user = await userManager.FindByIdAsync(userId);
if (user != null)
{
IdentityResult result = await userManager.ResetPasswordAsync(user, token, passwordResetViewModel.PasswordNew);
if (result.Succeeded)
{
await userManager.UpdateSecurityStampAsync(user); // kullanicilarin kritik bilgilerinin degisip degismedigini anladigimiz security stamp'i guncelliyoruz. sifre degistiginde baska bi cihazdaki baglantida logine atar bu sayede.
ViewBag.status = "success";
}
else
{
AddModelError(result);
}
}
else
{
ModelState.AddModelError("", "hata meydana gelmiştir. Lütfen daha sonra tekrar deneyiniz.");
}
return(View(passwordResetViewModel));
}
public ActionResult ResetPassword(PasswordResetViewModel model)
{
if (model.ConfirmNewPassword != model.NewPassword)
{
ModelState.AddModelError(nameof(PasswordResetViewModel.ConfirmNewPassword), Resources.Global.PasswordConfirmation_NoMatch);
model.NewPassword = null;
model.ConfirmNewPassword = null;
return(View(model));
}
if (!ModelState.IsValid)
{
model.NewPassword = null;
model.ConfirmNewPassword = null;
return(View(model));
}
var user = _userRepository.GetUserWithoutProtectedData(model.UserId);
if (user == null)
{
return(View("Message", model: Resources.Global.PasswordReset_TokenInvalid));
}
if (!_passwordResetTokenSource.Validate(user.GetPasswordResetTokenGenerationInputString(), model.Token))
{
ModelState.AddModelError(nameof(PasswordResetViewModel.Token), Resources.Global.PasswordReset_TokenInvalid);
return(View(model));
}
// all good, reset password
_userRepository.SetPassword(_mapper.Map <PasswordResetModel>(model));
return(View("Message", model: Resources.Global.PasswordReset_Success));
}
public async Task <IActionResult> ResetPasswordConfirm([Bind("PasswordNew")] PasswordResetViewModel passwordResetViewModel)
{
var token = TempData["token"].ToString();
var userId = TempData["userID"].ToString();
var user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
IdentityResult result = await _userManager.ResetPasswordAsync(user, token.ToString(), passwordResetViewModel.PasswordNew);
if (result.Succeeded)
{
//Kullanıcı eğer şifre değiştirmişse web siteden çıkıp tekrar giriş yapmasını sağlayan kod
await _userManager.UpdateSecurityStampAsync(user);
ViewBag.Status = "success";
}
else
{
AddModelError(result);
}
}
else
{
ModelState.AddModelError("", "Hata meydana gelmiştir.");
}
return(View());
}
public MediatorResponse <PasswordResetViewModel> ResetPassword(PasswordResetViewModel resetViewModel)
{
//Password Reset Code is verified in VerifyPasswordReset.
//Initially assume the reset code is valid as a full check requires hitting the repo.
resetViewModel.IsPasswordResetCodeValid = true;
var validationResult = _passwordResetViewModelServerValidator.Validate(resetViewModel);
if (!validationResult.IsValid)
{
return(GetMediatorResponse(RegisterMediatorCodes.ResetPassword.FailedValidation, resetViewModel, validationResult));
}
resetViewModel = _candidateServiceProvider.VerifyPasswordReset(resetViewModel);
if (resetViewModel.HasError())
{
return(GetMediatorResponse(RegisterMediatorCodes.ResetPassword.FailedToResetPassword, resetViewModel, resetViewModel.ViewModelMessage, UserMessageLevel.Warning));
}
if (resetViewModel.UserStatus == UserStatuses.Locked)
{
return(GetMediatorResponse(RegisterMediatorCodes.ResetPassword.UserAccountLocked, resetViewModel));
}
if (!resetViewModel.IsPasswordResetCodeValid)
{
validationResult = _passwordResetViewModelServerValidator.Validate(resetViewModel);
return(GetMediatorResponse(RegisterMediatorCodes.ResetPassword.InvalidResetCode, resetViewModel, validationResult));
}
return(GetMediatorResponse(RegisterMediatorCodes.ResetPassword.SuccessfullyResetPassword, resetViewModel, PasswordResetPageMessages.SuccessfulPasswordReset, UserMessageLevel.Success));
}
public async Task <IActionResult> ResetPassword(PasswordResetViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ModelState.AddModelError("UserId", "It is strange but we cannot find this user!");
return(View(model));
}
var resetPasswordResult = await _userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (!resetPasswordResult.Succeeded)
{
resetPasswordResult.Errors.ToList().ForEach(error =>
{
_logger.LogError($"User {user.Email} failed to reset password with error {error.Description}");
});
ModelState.AddModelError("Passwoprd", "Your password could not be reset. Contact support!");
return(View(model));
}
return(RedirectToAction("SignIn"));
}
public async Task <IActionResult> PasswordReset(PasswordResetViewModel passwordResetViewModel)
{
var user = await _userManager.FindByEmailAsync(passwordResetViewModel.Email);
if (user != null) // && await _userManager.IsEmailConfirmedAsync(user)
{
string token;
try
{
token = await _userManager.GeneratePasswordResetTokenAsync(user);
}
catch (Exception)
{
throw;
}
var callbackUrl = Url.Page(
"/Account/ResetPassword",
pageHandler: null,
values: new { token },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(
passwordResetViewModel.Email,
"Reset Password",
$"Please reset your password by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
return(Ok());
}
else
{
return(Ok(new { message = "something bad happended" }));
}
}
public async Task <IActionResult> PasswordReset(PasswordResetViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user != null)
{
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.Action(
nameof(PasswordResetSubmit),
"Authentication",
values: new { userId = user.Id, code },
protocol: Request.Scheme);
await _emailSender.SendPasswordResetAsync(model.Email, callbackUrl);
}
else
{
ModelState.AddModelError(string.Empty, "User with that Email does not exists");
}
}
return(View());
}
public ActionResult PasswordReset(string userId, string email, string code)
{
if (userId == null || email == null || code == null)
{
return(View("Error"));
}
var usermanager = IdentityTools.NewUserManager();
var kullanici = usermanager.FindByEmail(email);
if (kullanici == null)
{
return(View("Error"));
}
else
{
if (kullanici.Id != userId)
{
return(View("Error"));
}
else
{
if (!UserManager.VerifyUserTokenAsync(kullanici.Id, "ResetPassword", code).Result)
{
return(View("Error"));
}
else
{
PasswordResetViewModel model = new PasswordResetViewModel();
model.Email = email;
model.Code = code;
return(View("PasswordReset", model));
}
}
}
}
public ActionResult PasswordReset(Guid key, Guid userGuid)
{
var response = _userService.IsValidKey(
new IsValidKeyRequest(
key,
userGuid));
if (response.Code != ResponseCode.Success)
{
//this.AddErrorMessage("There has been a problem restting your password. Please contact IT.");
return(RedirectToAction("requestpasswordreset", "login"));
}
if (!response.Entity)
{
//this.AddErrorMessage("The provided link is no longer valid, please request a new one.");
return(RedirectToAction("requestpasswordreset", "login"));
}
var model = new PasswordResetViewModel(
key,
userGuid);
return(View(model));
}
public async Task <IActionResult> PasswordReset(string id, PasswordResetViewModel model)
{
TempData["PasswordResetStatus"] = "Incomplete";
if (id == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var result = await _userManager.ResetPasswordAsync(user, model.Code, model.NewPassword);
if (result.Succeeded)
{
TempData["PasswordResetStatus"] = "Complete";
}
else
{
AddErrors(result);
}
return(View());
}
public IActionResult ResetPassword([Bind("Email")] PasswordResetViewModel passwordResetViewModel)
{
AppUser user = _userManager.FindByEmailAsync(passwordResetViewModel.Email).Result;
if (user != null)
{
string passwordResetToken = _userManager.GeneratePasswordResetTokenAsync(user).Result;
string passwordResetLink = Url.Action("ResetPasswordConfirm", "Home", new
{
userId = user.Id,
token = passwordResetToken
}, HttpContext.Request.Scheme);
var result = _passwordReset.PasswordResetSendEmail(user.Email, passwordResetLink);
if (result)
{
ViewBag.Status = "success";
}
}
else
{
ModelState.AddModelError("", "Sistemde kayıtlı mail adresi bulunamamıştır.");
}
return(View());
}
public async Task <IActionResult> PasswordReset(int id)
{
try
{
var user = await _userService.GetDetails(id);
SetPageTitle(user);
PasswordResetViewModel viewModel = new PasswordResetViewModel()
{
Id = id,
HouseholdCount = await _userService
.FamilyMemberCountAsync(user.HouseholdHeadUserId ?? id),
HeadOfHouseholdId = user.HouseholdHeadUserId,
HasAccount = !string.IsNullOrWhiteSpace(user.Username)
};
return(View(viewModel));
}
catch (GraException gex)
{
ShowAlertWarning("Unable to view participant's password reset: ", gex);
return(RedirectToAction("Index"));
}
}
public async Task <IActionResult> PasswordReset([FromRoute] int userId, [FromQuery] string token)
{
if (TempData.ContainsKey("Error"))
{
ViewData["Error"] = TempData["Error"];
}
if (TempData.ContainsKey("Message"))
{
ViewData["Message"] = TempData["Message"];
}
TempData.Clear();
var user = await _userLogic.Get(userId);
var isResetTokenValid = await _userManager.VerifyUserTokenAsync(user, TokenOptions.DefaultProvider, "ResetPassword", token);
if (!isResetTokenValid)
{
TempData["Error"] = "Password Reset link is not valid!";
return(RedirectToAction("PasswordResetRequest"));
}
var viewModel = new PasswordResetViewModel
{
Email = user.Email,
Username = user.UserName,
Token = token,
Id = user.Id
};
return(View(viewModel));
}
public async Task <ActionResult> ResetPassword(PasswordResetViewModel model)
{
return(await Task.Run(() =>
{
var response = _loginMediator.ResetPassword(model);
switch (response.Code)
{
case LoginMediatorCodes.ResetPassword.FailedValidation:
case LoginMediatorCodes.ResetPassword.InvalidResetCode:
response.ValidationResult.AddToModelState(ModelState, string.Empty);
return View(response.ViewModel);
case LoginMediatorCodes.ResetPassword.FailedToResetPassword:
SetUserMessage(response.Message.Text, response.Message.Level);
return View(model);
case LoginMediatorCodes.ResetPassword.UserAccountLocked:
UserData.Push(UserDataItemNames.EmailAddress, model.EmailAddress);
return RedirectToRoute(RouteNames.Unlock);
case LoginMediatorCodes.ResetPassword.SuccessfullyResetPassword:
SetUserMessage(response.Message.Text);
return SetUserContextAndRedirectToAction(model.EmailAddress);
default:
throw new InvalidMediatorCodeException(response.Code);
}
}));
}
public IActionResult ResetPassword(PasswordResetViewModel passwordResetViewModel)
{
AppUser user = userManager.FindByEmailAsync(passwordResetViewModel.Email).Result; // resut demek sonuclanincaya kadar bekle, alt satira gecme. boyle bir kullanici var mi yok mu kontrol ediliyor.
if (user != null) // kayitli bir kullanici varsa
{
string passwordResetToken = userManager.GeneratePasswordResetTokenAsync(user).Result; // user bilgilerinden olusan token olusturuyor.
// kullanici linke tikladiginda home controller'daki ResetPasswordConfirm func. calisacak.
string passwordResetLink = Url.Action("ResetPasswordConfirm", "Home", new
{
userId = user.Id,
token = passwordResetToken
}, HttpContext.Request.Scheme);
// www.t4h4.net/Home/ResetPasswordConfirm?userId=sdjfsjf&token=dfjkdjfdjf
Helper.PasswordReset.PasswordResetSendEmail(passwordResetLink, user.Email);
ViewBag.status = "success"; // view'e mesaj gonderiyoruz.
TempData["durum"] = true.ToString();
}
else
{
ModelState.AddModelError("", "Sistemde kayıtlı email adresi bulunamamıştır.");
}
return(View(passwordResetViewModel));
}
public async Task <ActionResult> ResetPassword(PasswordResetViewModel model)
{
if (ModelState.IsValid)
{
if (!string.IsNullOrEmpty(model.Email) && !string.IsNullOrEmpty(model.Code))
{
if (_authRepository.CanResetPassword(model.Email, model.Code))
{
var result = _authRepository.ResetPassword(model.Email, model.Password);
if (result.Success)
{
MvcCaptcha.ResetCaptcha("ChangePasswordCaptcha");
_logger.Debug(string.Format("The password for {0} has successfully been reset.", model.Email));
return(RedirectToAction("ResetPasswordConfirmation"));
}
}
MvcCaptcha.ResetCaptcha("ChangePasswordCaptcha");
return(RedirectToAction("ResetFailed"));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult ResetPassword(PasswordResetViewModel postedModel)
{
var pr = RavenSession.Query <PasswordReset>().FirstOrDefault(x => x.Token == postedModel.Token);
if (pr == null || pr.Generated > DateTime.Now.AddHours(2))
{
return(View("Reset", new PasswordResetViewModel()));
}
if (postedModel.Password != postedModel.ConfirmPassword)
{
ModelState.AddModelError("NoMatch", "Passwords must match.");
return(View("Reset", postedModel));
}
var user = RavenSession.Load <User>("users/" + pr.UserId);
if (user == null)
{
ModelState.AddModelError("NoUserMatch", "User account not found.");
return(View("Reset", postedModel));
}
var pw = Hash(postedModel.Password);
user.Password = pw;
RavenSession.Delete(pr);
RavenSession.SaveChanges();
HighFive("Your password has been changed.");
return(RedirectToAction("Login"));
}
public ActionResult PasswordReset(PasswordResetViewModel pass)
{
var message = "";
if (ModelState.IsValid)
{
using (ClinicSysDbEntities dc = new ClinicSysDbEntities())
{
var user = dc.Users.Where(a => a.ResetPasswordCode == pass.ResetCode).FirstOrDefault();
if (user != null)
{
user.Password = Encryption.PasswordHash(pass.NewPassword);
user.ResetPasswordCode = "";
dc.Configuration.ValidateOnSaveEnabled = false;
dc.SaveChanges();
message = "New password updated successfully";
}
}
}
else
{
message = "Error!";
}
ViewBag.Message = message;
return(View(pass));
}
public IActionResult ResetPassword(PasswordResetViewModel passwordResetViewModel)
{
AppUser user = _userManager.FindByEmailAsync(passwordResetViewModel.Email).Result;
if (user != null)
{
string passwordResetToken = _userManager.GeneratePasswordResetTokenAsync(user).Result;
string passwordResetLink = Url.Action("ResetPasswordConfirm", "Home", new {
userId = user.Id,
token = passwordResetToken
}, HttpContext.Request.Scheme);
_emailSender.SendEmailAsync(passwordResetViewModel.Email, "mail sifirlama", $"<h2>Şifrenizi Yenilemek için lütfen aşağıdaki linke tıklayınız</h2><hr/><a href='{passwordResetLink}'>şifre yenileme linki</a>");
ViewBag.status = "success";
}
else
{
ModelState.AddModelError("", "Sistemde kayıtlı email adresi bulunamamıştır.");
}
return(View(passwordResetViewModel));
}
public ActionResult Index(PasswordResetViewModel viewModel)
{
UserRegistrationService.SendPasswordResetEmail(viewModel.Email);
viewModel.Email = "";
viewModel.ShowSuccessMessage = true;
return(View(viewModel));
}
public async Task <IActionResult> ResetPasswordTokenAsync(PasswordResetViewModel viewModel)
{
if (viewModel.password == viewModel.Confirmpassword)
{
}
else
{
ViewBag.userId = viewModel.userId;
ViewBag.code = viewModel.code;
TempData["Message"] = "Passwords do not match";
return(RedirectToAction("Reset", "Account"));
}
var user = await userManager.FindByIdAsync(viewModel.userId);
var result = await userManager.ResetPasswordAsync(user, viewModel.code, viewModel.password);
if (result.Succeeded)
{
TempData["Message"] = "Password changed.";
return(RedirectToAction("Home", "Index"));
}
TempData["Message"] = "Password not changed. Try again.";
return(RedirectToAction("Home", "Index"));
}
public async Task <IActionResult> ResetPassword(PasswordResetViewModel model)
{
if (!ModelState.IsValid)
{
return(View("ResetPasswordConfirmation"));
}
User user = await userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(View("ResetPasswordConfirmation"));
}
IdentityResult result = await userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Feed"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(model));
}
public async Task <IActionResult> ResetPasswordVAsync(PasswordResetViewModel vm)
{
var user = await userManager.FindByEmailAsync(vm.email);
var code = await userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.Action("Reset", "Account", new { userId = user.Id, code }, HttpContext.Request.Scheme);
var client = new SendGridClient(SendGridDetails.APIKEY);
var msg = new SendGridMessage
{
From = new EmailAddress("*****@*****.**", "TSRS Social Initiatives"),
Subject = "Password Recovery",
HtmlContent = $"Change your password by <a href='{callbackUrl}'>clicking here</a>."
};
msg.AddTo(new EmailAddress(user.Email));
// Disable click tracking.
// See https://sendgrid.com/docs/User_Guide/Settings/tracking.html
msg.SetClickTracking(false, false);
await client.SendEmailAsync(msg);
TempData["Message"] = "Check your inbox for password reset link";
return(RedirectToAction("Home", "Index"));
}
public async Task <IActionResult> Post([FromBody] PasswordResetViewModel viewModel)
{
return(await ExecuteAsync(() =>
{
return _authenticationService.ResetPasswordAsync(viewModel.Email, viewModel.Password, viewModel.ResetCode);
}));
}
public ActionResult UpdatePassword(PasswordResetViewModel passwordViewModel)
{
ResponseOut responseOut = new ResponseOut();
IUserBL userBL = new UserEngine();
try
{
if (passwordViewModel != null)
{
int user_id = Convert.ToInt32(HttpContext.Session[SessionKey.CurrentUserID]);
responseOut = userBL.ResetUserPassword(passwordViewModel, user_id);
}
else
{
responseOut.message = ActionMessage.ProbleminData;
responseOut.status = ActionStatus.Fail;
}
}
catch (Exception ex)
{
responseOut.message = ActionMessage.ApplicationException;
responseOut.status = ActionStatus.Fail;
}
return(Json(responseOut, JsonRequestBehavior.AllowGet));
}
public ActionResult ResetPassword(PasswordResetViewModel passwordResetViewModel)
{
if (!this.ValidateAndAppendMessages(passwordResetViewModel))
{
return View();
}
string token = null;
using(var unitOfWork = this.UnitOfWorkFactory.NewUnitOfWork())
{
// Generate Token
token = this.UserLoginService.CreateUserAuthToken(passwordResetViewModel.EmailAddress);
if(token == null)
{
this.AppendMessage(new ErrorMessage { Text = "The email address you entered could not be found" });
return View();
}
unitOfWork.Commit();
}
// Send the Email Message
var passwordResetEmailMessage = (PasswordResetEmailMessage)this.EmailMessageFactory.Make(EmailMessageType.PasswordReset);
passwordResetEmailMessage.SetAuthToken(token);
passwordResetEmailMessage.ToRecipients.Add(passwordResetViewModel.EmailAddress);
this.EmailSender.Send(passwordResetEmailMessage);
if (!string.IsNullOrWhiteSpace(Request.Form["LoginViaDialog"]))
{
this.ForwardMessage(new SuccessMessage { Text = "Please check your email for instructions on how to reset your password" });
return RedirectToAction("LoginViaDialog", new { LoginViaDialog = true });
}
// Append Message and Redirect
this.AppendMessage(new SuccessMessage { Text = "Please check your email for instructions on how to reset your password" });
return View();
}
