public async Task <IActionResult> Reset(Guid userId, string token)
{
var model = new ResetViewModel
{
UserId = userId,
Token = token
};
var user = await _userManager.FindByIdAsync(userId.ToString());
if (user is null)
{
model.Errors = new string[] { "Invalid user ID." };
}
else
{
// https://stackoverflow.com/a/51651691
model.UserAndTokenAreValid = await _userManager.VerifyUserTokenAsync(
user,
_userManager.Options.Tokens.PasswordResetTokenProvider,
UserManager <DejarixUser> .ResetPasswordTokenPurpose,
token);
if (!model.UserAndTokenAreValid)
{
model.Errors = new string[] { "Invalid token." }
}
;
}
return(View(model));
}
public ActionResult Reset([Bind(Include = "NewPassword,ConfirmPassword,Key,Token")] ResetViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = UserManager.FindById(model.Key);
if (user == null)
{
ModelState.AddModelError("", AuthResources.RequestMailNoUser);
return(View(model));
}
var result = UserManager.ResetPassword(user.Id, model.Token, model.NewPassword);
if (!result.Succeeded)
{
AddErrors(result);
return(View(model));
}
SignInLogModel log = new SignInLogModel();
log.ClientIp = GetClientIp();
log.UserModelId = user.Id;
log.UserCode = user.UserName;
log.SetStatus(2);
dbContext.SignInLogModels.Add(log);
dbContext.SaveChanges();
UserManager.ResetAccessFailedCount(user.Id);
return(View("ResetComplete"));
}
public ActionResult Reset(ResetViewModel model)
{
if (!string.IsNullOrWhiteSpace(model.Password) && !string.IsNullOrWhiteSpace(model.ConfirmPassword))
{
if (!model.Password.Equals(model.ConfirmPassword, StringComparison.Ordinal))
{
ModelState.AddModelError("Confirmation", "The passwords you entered do not match.");
}
}
if (!ModelState.IsValid)
{
return(View(model));
}
var result = _tokenService.RedeemPasswordToken(model.Token, model.EmailAddress, model.Password);
if (!string.IsNullOrWhiteSpace(result))
{
ModelState.AddModelError("Execution", result);
return(View(model));
}
return(RedirectToAction(nameof(Index), "Home", new { area = "" }));
}
public IActionResult Reset(ResetViewModel vm, string userid, string email, string token)
{
ViewData["status"] = "";
ValidateReset(vm, userid, email, token);
if (ModelState.IsValid)
{
try
{
Auth0.ManagementApi.Models.User userResult = null;
SalesforceService.Response hashResponse = SalesforceService.CheckHash(_sfdcTokenManager.instance_url, _sfdcTokenManager.access_token, System.Net.WebUtility.HtmlDecode(email), token).Result;
_logger.LogInformation("Hash Code Response: {0}", hashResponse.code);
_logger.LogInformation("User Id: {0}", userid);
//Hash matches
if (hashResponse.code == "10014")
{
string accessToken = GetClientToken().Result;
userResult = UpdateUserPassword(accessToken, System.Net.WebUtility.HtmlDecode(userid), vm.NewPassword1).Result;
ViewData["status"] = userResult.UpdatedAt;
}
else
{
ModelState.AddModelError("", "Token has expired");
}
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
}
}
return(View(vm));
}
public object Any(ResetViewModel request)
{
ValidationResult validations = new ResetAccountValidator().Validate(request);
if (!validations.IsValid)
{
request.ResponseResult.ResultStatus = ResultStatuses.Error;
foreach (var item in validations.Errors)
{
request.ResponseResult.Messages.Add(item.ErrorMessage);
}
return(request);
}
string de = request.Hash.Decrypt("hash");
var userAuth = UserAuthRepository.GetUserAuthByUserName(de);
if (userAuth != null)
{
UserAuthRepository.UpdateUserAuth(userAuth, userAuth, request.Password);
}
request.ResponseResult.ResultStatus = ResultStatuses.Success;
request.ResponseResult.Messages.Clear();
return(request);
}
public async Task <IActionResult> Reset([FromBody] ResetViewModel vm)
{
if (string.IsNullOrWhiteSpace(vm.Code) || string.IsNullOrWhiteSpace(vm.UserId) || string.IsNullOrEmpty(vm.Password))
{
ModelState.AddModelError("Message", "User Id, Code and Password are required");
return(BadRequest(ModelState));
}
var user = await _userManager.FindByIdAsync(vm.UserId);
if (user == null)
{
ModelState.AddModelError("Message", "Cannot find the user");
return(BadRequest(ModelState));
}
var codeDecodedBytes = WebEncoders.Base64UrlDecode(vm.Code);
var codeDecoded = Encoding.UTF8.GetString(codeDecodedBytes);
IdentityResult result = await _userManager.ResetPasswordAsync(user, codeDecoded, vm.Password);
if (!result.Succeeded)
{
ModelState.AddModelError("Message", result.Errors.FirstOrDefault().Description);
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <IActionResult> NewPassword(string code = null)
{
//Ensure user has not completed the registration process
var result = await CheckUserRegisteredOkAsync();
if (result != null)
{
return(result);
}
var passwordResult = UnwrapPasswordReset(code);
if (passwordResult.Result != null)
{
return(passwordResult.Result);
}
var model = new ResetViewModel();
model.Resetcode = code;
StashModel(model);
//Start new user registration
return(View("NewPassword", model));
}
public object Any(ResetViewModel request)
{
ValidationResult validations = new ResetAccountValidator().Validate(request);
if (!validations.IsValid)
{
request.ResponseResult.ResultStatus = ResultStatuses.Error;
foreach (var item in validations.Errors)
{
request.ResponseResult.Messages.Add(item.ErrorMessage);
}
return request;
}
string de = request.Hash.Decrypt("hash");
var userAuth = UserAuthRepository.GetUserAuthByUserName(de);
if (userAuth != null)
{
UserAuthRepository.UpdateUserAuth(userAuth, userAuth, request.Password);
}
request.ResponseResult.ResultStatus = ResultStatuses.Success;
request.ResponseResult.Messages.Clear();
return request;
}
public async Task <IActionResult> Reset(ResetViewModel model)
{
//token not useable, start over
var result = await ValidateResetTokenAsync(model.Token);
if (!result.success)
{
return(View("Forgot", new ForgotViewModel()));
}
if (!ModelState.IsValid)
{
return(View(model));
}
var user = result.user !; //result.user cannot be null when result.success == true
var salt = PwdUtil.NewSalt();
var hash = PwdUtil.Hash(model.Password !, salt); //model.Password cannot be null if ModelState.IsValid == true
user.Hash = hash;
user.Salt = salt;
await DbContext.SaveChangesAsync();
await SignInAsync(user);
return(RedirectFromLogin());
}
public async Task <ResponseViewModel <bool> > Reset(ResetViewModel vm)
{
var data = new ResponseViewModel <bool>();
if (vm.LoginPassword != vm.ReLoginPassword)
{
data.Code = 1;
data.Msg = _localizer["password"];
return(data);
}
var verify = _verifyProvider.GetVerifyInfo(vm.ReLoginPassword, VerifyTypeEnum.Password);
if (verify != null)
{
var user = await _userProvider.GetUserInfo(verify.UserId);
user.LoginPassword = MD5Util.TextToMD5(vm.LoginPassword);
data.Code = 0;
data.Msg = _localizer["reset.success"];
data.Data = await _userProvider.UpdateUser(user);
await _verifyProvider.VerifySuccess(vm.LoginPassword);
}
else
{
data.Code = 1;
data.Msg = _localizer["reset.verify"];
}
return(data);
}
public async Task <IActionResult> ResetPassword(ResetViewModel 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)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View());
}
//if the user is lockedout when he resets his password
//we set the lock out end date to now
if (await userManager.IsLockedOutAsync(user))
{
await userManager.SetLockoutEndDateAsync(user, DateTime.UtcNow);
}
ViewBag.Comment = "Kindly Go ahead to Login";
var msg = "Swal.fire({position: 'top-end',icon: 'success',title: 'Password Reset Successful. Kindly Login ', showConfirmButton: false, timer: 3500})";
TempData["message"] = $"<script type='text/javascript'> {msg} </script>";
return(RedirectToAction("Login"));
}
ModelState.AddModelError("", "Invalid Request");
}
return(View());
}
public async Task <authData> resetPwd(ResetViewModel reset)
{
authData adata = new authData();
Utility utility = new Utility(appsetting, context);
try
{
string pwd = Utility.RandomString(appsetting.Value.pLength);
var ot = await utility.resetUser(reset);
if (ot != null)
{
//ot.password = hashPass(pwd);
if (ot._id > 0)
{
//call notification service
adata.message = "success";
}
}
}
catch (Exception ex)
{
Console.Write(ex.ToString());
}
return(adata);
}
public ActionResult Reset()
{
var model = new ResetViewModel {
Email = Request.QueryString["e"], Token = Request.QueryString["t"]
};
return(View(model));
}
public IActionResult ResetPassword(string token, string email)
{
var model = new ResetViewModel {
Token = token, Email = email
};
return(View(model));
}
public async Task <ActionResult> Reset(ResetViewModel model)
{
if (model.Email == "*****@*****.**")
{
ModelState.AddModelError("lName", "You are not allowed to change the password on the demo site");
return(View(model));
}
if (!ModelState.IsValid)
{
ModelState.AddModelError("lName", "Last Name not found");
return(View(model));
}
var provider = new MachineKeyProtectionProvider();
UserManager.UserTokenProvider = new DataProtectorTokenProvider <ApplicationUser, Guid>(provider.Create("PasswordReset"));
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
ModelState.AddModelError("", "Invalid email address.");
return(View(model));
}
// todo: locked out & not active:
//if (!user.LockoutEndDateUtc)
//{
// ModelState.AddModelError("", "Invalid email address.");
// return View(model);
//}
var result = await UserManager.ResetPasswordAsync(user.Id, model.Token, model.Password);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View(model));
}
var message = new MailMessage();
message.To.Add(new MailAddress(user.Email));
message.Subject = "Password Changed";
message.Body = user.FirstName + Environment.NewLine;
message.Body += Environment.NewLine;
message.Body += "Your password has been changed." + Environment.NewLine;
Utilities.Email.SendMail(message, Settings);
if (!user.EmailConfirmed)
{
user.EmailConfirmed = true;
}
await UserManager.UpdateAsync(user);
return(RedirectToAction("Login", new { msg = "passwordchanged" }));
}
public IActionResult Edit(int Id)
{
ResetViewModel resetViewModel = new ResetViewModel();
User userData = context.Users.FirstOrDefault(c => c.ID == Id);
// resetViewModel.Password = userData.Password;
ViewBag.Title = "Reset Password " + userData.Username;
ViewBag.LoginId = Id;
return(View(resetViewModel));
}
public ActionResult Reset(string key, string code)
{
if (string.IsNullOrWhiteSpace(key) || string.IsNullOrWhiteSpace(code))
{
return(View("RequestMailError"));
}
ResetViewModel model = new ResetViewModel();
model.Key = Convert.ToInt32(key);
model.Token = code;
return(View(model));
}
public IActionResult Edit(ResetViewModel resetViewModel)
{
User user = context.Users.FirstOrDefault(c => c.ID == resetViewModel.UserId);
if (ModelState.IsValid)
{
user.Password = resetViewModel.Password;
context.SaveChanges();
ViewBag.Title = "Password changed";
return(View("Welcome"));
}
ViewBag.Title = "Reset Password failed";
return(View(resetViewModel));
}
public async Task <IActionResult> NewPassword(ResetViewModel model)
{
//Ensure user has not completed the registration process
var result = await CheckUserRegisteredOkAsync();
if (result != null)
{
return(result);
}
ModelState.Remove(nameof(model.EmailAddress));
ModelState.Remove(nameof(model.ConfirmEmailAddress));
//Validate the submitted fields
if (!ModelState.IsValid)
{
this.CleanModelErrors <ResetViewModel>();
return(View("NewPassword", model));
}
var m = UnstashModel <ResetViewModel>();
if (m == null || string.IsNullOrWhiteSpace(m.Resetcode))
{
return(View("CustomError", WebService.ErrorViewModelFactory.Create(0)));
}
var passwordResult = UnwrapPasswordReset(m.Resetcode);
if (passwordResult.Result != null)
{
return(passwordResult.Result);
}
ClearStash();
//Save the user to ensure UserId>0 for new status
_accountService.UserRepository.UpdateUserPasswordUsingPBKDF2(passwordResult.User, model.Password);
VirtualUser.ResetAttempts = 0;
VirtualUser.ResetSendDate = null;
await SharedBusinessLogic.DataRepository.SaveChangesAsync();
//Send completed notification email
await SharedBusinessLogic.SendEmailService.SendResetPasswordCompletedAsync(passwordResult.User
.EmailAddress);
//Send the verification code and showconfirmation
return(View("CustomError", WebService.ErrorViewModelFactory.Create(1127)));
}
public async Task <ActionResult> Reset(ResetViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
//string username, string password, string confirmPassword, string token
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
ModelState.AddModelError("", "Invalid email address.");
return(View(model));
}
// todo: locked out & not active:
//if (!user.LockoutEndDateUtc)
//{
// ModelState.AddModelError("", "Invalid email address.");
// return View(model);
//}
var result = await UserManager.ResetPasswordAsync(user.Id, model.Token, model.Password);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View(model));
}
var message = new MailMessage();
message.To.Add(new MailAddress(user.Email));
message.Subject = "Password Changed";
message.Body = user.FirstName + Environment.NewLine;
message.Body += Environment.NewLine;
message.Body += "Your password has been changed." + Environment.NewLine;
Utilities.Email.SendMail(message, Settings);
if (!user.EmailConfirmed)
{
user.EmailConfirmed = true;
}
await UserManager.UpdateAsync(user);
return(RedirectToAction("Login", new { msg = "passwordchanged" }));
}
public IActionResult SendUsername(ResetViewModel vm)
{
var usernames = _context.UserRepository.GetAllUsernamesFromEmail(vm.Email);
if (usernames.Count < 1)
{
return(RedirectToAction("Index", new { usernameErrorMessage = "No user exists with that email." }));
}
_emailService.SendUsernamesToEmail(usernames, vm.Email);
var basevm = _viewModelFactory.Resolve <BaseViewModel>();
return(View("UsernameSentConfirmation", basevm));
}
public async Task <IActionResult> Reset([FromBody] ResetViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(GetModelStateErrorResponse(ModelState)));
}
var resp = await ResetAccount(model.EmailOrUsername);
if (resp.Type != ResponseType.Success)
{
return(BadRequest(resp));
}
return(Ok(resp));
}
public IActionResult Reset(ResetViewModel viewModel)
{
if (ModelState.IsValid)
{
if (_account.ResetPassword(viewModel.ActiveCode, viewModel.Password))
{
return(RedirectToAction(nameof(Login)));
}
else
{
ModelState.AddModelError("ActiveCode", "کد تایید شما اشتباه است");
}
}
return(View(viewModel));
}
public async Task <IActionResult> ResetPost()
{
var request = HttpContext.Request;
var formData = await request.ReadFormAsync();
var textUserId = formData["reset-user-id"].FirstOrDefault();
var token = formData["reset-token"].FirstOrDefault();
var password = formData["reset-password"].FirstOrDefault();
var confirmPassword = formData["reset-password-confirm"].FirstOrDefault();
var model = new ResetViewModel
{
UserId = Guid.Parse(textUserId),
Token = token
};
if (password != confirmPassword)
{
model.Errors = new string[] { "Passwords do not match." };
}
else
{
var user = await _userManager.FindByIdAsync(textUserId);
if (user is null)
{
model.Errors = new string[] { "Invalid user ID." };
}
else
{
model.UserAndTokenAreValid = true;
var result = await _userManager.ResetPasswordAsync(user, token, password);
if (result.Succeeded)
{
model.Success = "Password successfully reset!";
}
else
{
model.Errors = result.Errors.Select(e => e.Description).ToArray();
}
}
}
return(View("Reset", model));
}
public ActionResult Reset(ResetViewModel model)
{
if (ModelState.IsValid)
{
var myid = User.Identity.GetUserId <int>();
var user = DB.Users.Find(myid);
user.Hash = InServiceIUser.GetPasswordHash(user.LoginID, model.Password);
if (TryUpdateModel(user))
{
DB.SaveChanges();
Request.GetOwinContext().Authentication.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
return(RedirectToAction(nameof(ResetDone)));
}
}
ViewBag.Title = "Reset";
return(View());
}
public IActionResult Index(Boolean sendCode, ResetViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
if (sendCode)
{
this.passwordResetService.SendResetCode(model.Email);
}
return(this.View("CodeVerification", new ResetCodeVerificationViewModel
{
Email = model.Email
}));
}
public IActionResult SendEmail(ResetViewModel vm)
{
// Get user details from username
IUser user;
var userExists = _context.UserRepository.GetUserIfExists(vm.Username, out user);
if (!userExists)
{
return(RedirectToAction("Index", new { errorMessage = "User with that username does not exist." }));
}
// Send email to user
_passwordResetService.GenerateAndSendToken(user);
var basevm = _viewModelFactory.Resolve <BaseViewModel>();
return(View("EmailSentConfirmation", basevm));
}
public async Task <ActionResult> Reset(ResetViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByIdAsync(model.UserId);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction("Index", "Home", new { area = "" }));
}
var result = await UserManager.ResetPasswordAsync(user.Id, model.Token, model.Password);
return(RedirectToAction("Index", "Home", new { area = "" }));
}
public ActionResult Reset(ResetViewModel user)
{
try
{
if (user.Protect.IsNotNullAndWhiteSpace() && _dataProtector.Unprotect(user.Protect) == user.ResetToken)
{
if (_userService.ResetPassWord(user.ResetToken, user.PassWordNew))
{
return(RedirectToAction("SignIn"));
}
}
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
ViewBag.Errormessage = "重置密码失败";
return(View(user));
}
private void OnReset()
{
var vm = new ResetViewModel(settings, port, logger);
var result = ShowDialog(vm);
if (result)
{
ShowDialog(new NotificationResetViewModel());
}
if (!result && vm.Exception != null)
{
ShowDialog(new NotificationErrorViewModel((vm.Exception.InnerException != null) ?
vm.Exception.InnerException.Message :
vm.Exception.Message));
}
RaiseCanExecuteChanged();
}
public ActionResult Reset(ResetViewModel user)
{
try
{
var dataProtector = _dataProtectionProvider.CreateProtector("ResetPassword");
if (user.Protect.IsNotNullAndWhiteSpace() && dataProtector.Unprotect(user.Protect) == user.ResetToken)
{
if (_userService.ResetPassWord(user.ResetToken, user.PassWordNew))
{
return(RedirectToAction("SignIn"));
}
}
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
ViewBag.Errormessage = _localize.Get("Reset password failed!");
return(View(user));
}
