public async Task <IActionResult> SetNew(SetNewPasswordViewModel viewModel)
{
if (!HasAccess(SetNewPasswordAccessKey))
{
return(RedirectToAction("Initiate"));
}
if (!ModelState.IsValid)
{
return(RedirectToAction("SetNew"));
}
var ipAddress = Request.HttpContext?.Connection?.RemoteIpAddress?.ToString();
var userAgent = Request.Headers["User-Agent"];
return(await _userService.CompletePasswordResetAsync(viewModel.Email,
viewModel.Token, viewModel.Password, ipAddress, userAgent)
.Execute(
onSuccess: () =>
{
SetAccess(ResetPasswordAccessKey);
return RedirectToAction("Complete");
},
onFailure: ex =>
{
Notify(FlashNotificationType.Error, ex.Message);
return RedirectToAction("SetNew", new { email = viewModel.Email, token = viewModel.Token });
}));
}
public ActionResult SetNewPassword(SetNewPasswordViewModel model)
{
if (ModelState.IsValid)
{
if (model.NewPassword != model.NewPasswordConfirm)
{
ModelState.AddModelError("", string.Format(Resources.Messages.E048));
}
else
{
using (TransactionScope transaction = new TransactionScope())
{
if (_service.UpdatePassword(model.UserId, SafePassword.GetSaltedPassword(model.NewPassword), model.PasswordLockTarget, model.CompanyCode) > 0)
{
if (_service.DeletePasswordResetInfo(model.Email, model.CompanyCode) > 0)
{
transaction.Complete();
FormsAuthentication.SignOut();
Session.Clear();
ViewBag.MessageSuccess = String.Format(Resources.Messages.I017);
}
}
}
}
}
return(View("SetNewPassword", model));
}
public async Task <IActionResult> NewUserSetPassword(SetNewPasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(model.UserId);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction(nameof(AccountController.NewUserSetPassword)));
}
var result = await _userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (!result.Succeeded)
{
AddErrors(result);
return(View(model));
}
//ViewData["ReturnUrl"] = model.ReturnUrl;
return(RedirectToAction(nameof(AccountController.ResetPasswordDone), new { returnUrl = model.ReturnUrl }));
}
return(View(model));
}
/// <summary>
/// Function Create a object SetNewPasswordViewModel
/// </summary>
/// <param name="userId">userId</param>
/// <param name="password_lock_target">password_lock_target</param>
/// <param name="email">email</param>
/// <returns>Set Password View</returns>
private SetNewPasswordViewModel MakeSetNewPasswordViewModel(int userId, string password_lock_target, string email)
{
var model = new SetNewPasswordViewModel();
model.UserId = userId;
model.PasswordLockTarget = password_lock_target;
model.Email = email;
return(model);
}
public ActionResult SetNew(int u, Guid t)
{
var viewModel = new SetNewPasswordViewModel()
{
UserId = u,
PasswordResetToken = t,
IsPasswordResetTokenValid = UserRegistrationService.IsPasswordResetTokenValid(u, t)
};
return(View(viewModel));
}
public ActionResult SetNewPassword(string infor)
{
FormsAuthentication.SignOut();
Session.Clear();
var model = new SetNewPasswordViewModel();
bool flag = true;
try
{
var passwordReset = _service.GetPasswordResetInfo(infor);
if (passwordReset != null)
{
var user = _service.CheckEmail(passwordReset.mail_address, passwordReset.company_code);
if (user != null)
{
if (Utility.GetCurrentDateTime() < passwordReset.apply_time.AddHours(_service.GetReissueMailEffectiveTime(user.company_code)))
{
model.UserId = user.user_sys_id;
model.Email = passwordReset.mail_address;
model.PasswordLockTarget = user.password_lock_target;
model.CompanyCode = user.company_code;
}
else
{
flag = false;
}
}
else
{
flag = false;
}
}
else
{
flag = false;
}
}
catch
{
flag = false;
}
if (!flag)
{
return(View("ErrorResetPassword"));
}
return(View(model));
}
public async Task <IActionResult> SetNew(string email, string token)
{
return(await _userService.ValidatePasswordResetTokenAsync(email, token)
.Execute(
onSuccess: () =>
{
SetAccess(SetNewPasswordAccessKey);
var viewModel = new SetNewPasswordViewModel
{
Email = email,
Token = token
};
return View(viewModel);
},
onFailure: ex =>
{
Notify(FlashNotificationType.Error, ex.Message);
return RedirectToAction("Initiate");
}));
}
public ActionResult SetNew(SetNewPasswordViewModel viewModel)
{
UserRegistrationService.ResetPassword(viewModel.UserId, viewModel.PasswordResetToken, viewModel.Password);
return(RedirectToAction("passwordchanged"));
}
public async Task <IActionResult> NewUserSetPassword(string userId, string code, string ru)
{
if (userId == null || code == null)
{
return(View("Error"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(View("Error"));
}
var result = await _userManager.VerifyUserTokenAsync(user, nameof(ConnectCustomTokenProvider <User>), "NewUserPassword", code);
if (!result)
{
return(View("Error", new ErrorViewModel()
{
Error = new IdentityServer4.Models.ErrorMessage
{
ErrorDescription = "Invalid Token."
}
}));
}
//Since user is trying to get to this password reset page, meaning email is verified as well.
var emailVerificationToken = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var emailConfirmResult = await _userManager.ConfirmEmailAsync(user, emailVerificationToken);
if (!emailConfirmResult.Succeeded)
{
AddErrors(emailConfirmResult);
return(View("Error", new ErrorViewModel()
{
Error = new IdentityServer4.Models.ErrorMessage
{
ErrorDescription = emailConfirmResult.Errors.FirstOrDefault()?.Description
}
}));
}
//if all checks out for this user....
//Generate token for updating the password.
var passwordResetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
SetNewPasswordViewModel model = new SetNewPasswordViewModel
{
UserId = user.Id,
Token = passwordResetToken,
UserName = user.DisplayName,
ReturnUrl = ru
};
return(View(model));
}
