public async Task <IActionResult> ResetPassword(ResetPasswordVM model)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(RedirectToAction("Login"));
}
var result = await _userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View());
}
await _signInManager.RefreshSignInAsync(user);
return(View("ResetPasswordConfirmation"));
}
return(View(model));
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM model)
{
try
{
if (ModelState.IsValid)
{
var passwordResetRequest = await _userAccountManager.GetPasswordResetRequest(model.ActivationCode);
if (passwordResetRequest != null)
{
await _userAccountManager.UpdatePassword(model.Password, passwordResetRequest.UserId);
// delete the request may be ?
return(RedirectToAction(nameof(AccountController.PasswordUpdated)));
}
return(View("NotFound"));
}
return(View(model));
}
catch (Exception ex)
{
tc.TrackException(ex);
return(View("Error"));
}
}
public async Task <IActionResult> ResetPassword(string id, ResetPasswordVM reset)
{
if (!ModelState.IsValid)
{
return(View());
}
if (id == null)
{
return(NotFound());
}
AppUser user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
string token = await _userManager.GeneratePasswordResetTokenAsync(user);
await _userManager.ResetPasswordAsync(user, token, reset.Password);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> PromjenaPassworda(ResetPasswordVM obj)
{
if (ModelState.IsValid)
{
var user = await UserM.FindByEmailAsync(obj.email);
if (user != null)
{
var rezultat = await UserM.ResetPasswordAsync(user, obj.token, obj.password);
if (rezultat.Succeeded)
{
return(View("UspjesnaPromjena"));
}
else
{
foreach (var error in rezultat.Errors)
{
ModelState.AddModelError("", error.Description);
}
ViewBag.email = obj.email;
ViewBag.token = obj.token;
return(View(obj));
}
}
return(View("UspjesnaPromjena"));
}
ViewBag.email = obj.email;
ViewBag.token = obj.token;
return(View(obj));
}
public async Task <JsonResult> ResetPassword(ResetPasswordVM ResetVM)
{
eCommerceContext context = new eCommerceContext();
var UserManager = new UserManager <eCommerceUser>(new UserStore <eCommerceUser>(context));
JsonResult jResult = new JsonResult();
eCommerceUser user = await userApiService.GetUserById(ResetVM.UserId);
if (user != null)
{
var result = await UserManager.ChangePasswordAsync(ResetVM.UserId, ResetVM.OldPassword, ResetVM.NewPassword);
if (result.Succeeded)
{
await userApiService.Save();
jResult.Data = new { Success = true, Messages = "Your password has been reset. Please login with your updated credentials now." };
return(jResult);
}
else
{
jResult.Data = new { Success = false, Messages = "Unable to reset password." };
}
}
return(jResult);
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM model)
{
if (model.Password != model.ConfirmPassword)
{
ModelState.AddModelError(nameof(model.ConfirmPassword), "Podane hasła są różne!");
}
if (!ModelState.IsValid)
{
return(View());
}
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(View("Error"));
}
var result = await _userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(View("Error"));
}
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM model)
{
if (ModelState.IsValid)
{
var user = await _userManagerService.FindByEmailAsync(model.Email);
if (user != null)
{
var result = await _userManagerService.ResetPasswordAsync(user, model.Token, model.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View());
}
if (await _userManagerService.IsLockedOutAsync(user))
{
await _userManagerService.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow);
}
return(View("Success"));
}
ModelState.AddModelError("", "Invalid Request");
}
return(View());
}
public async Task <IActionResult> ResetPasswordConfirmation(ResetPasswordVM forgotPasswordVM)
{
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, forgotPasswordVM.Password);
if (result.Succeeded)
{
await userManager.UpdateSecurityStampAsync(user);
return(Redirect("ForgotPasswordConfirmation"));
}
else
{
foreach (var item in result.Errors)
{
ModelState.AddModelError("", item.Description);
}
}
}
else
{
ModelState.AddModelError("", "Bir hata meydana gelmiştir. Lütfen daha sonra tekrar deneyiniz");
}
return(View());
}
public async Task <ActionResult> ResetPassword(ResetPasswordVM resetPasswordVM)
{
if (!ModelState.IsValid)
{
return(View(resetPasswordVM));
}
var user = await _userService.GetAsync(x => x.Id == resetPasswordVM.UserId);
if (user != null)
{
var passwordHash = new Microsoft.AspNet.Identity.PasswordHasher();
var hashedPassword = passwordHash.HashPassword(resetPasswordVM.NewPassword);
user.PasswordHash = hashedPassword;
user.IsActive = true;
await _userService.UpdateAsync(user, string.Empty);
TempData["PasswordChanged"] = "Password changed successfully! Please login using the newly set password.";
var emailFormat = _genericService.EmailFormats.GetAll().Where(x => x.Category == "PasswordReset").FirstOrDefault();
string body = string.Format(emailFormat.Format, user.FullName);
EmailHelper.SendMail(user.Email, "Password changed successfully", body);
return(RedirectToAction("Login", "Account"));
}
return(null);
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM model)
{
var user = await _userManager.Users.FirstOrDefaultAsync(x => x.Email == model.Email);
if (user == null)
{
return(BadRequest("user_with_this_email_not_found"));
}
if (await _userManager.IsInRoleAsync(user, "Customer"))
{
if (!user.PhoneNumberConfirmed)
{
throw new Exception("please_confirm_your_account_first");
}
}
if (await _userManager.IsInRoleAsync(user, "Distributor"))
{
if (!user.EmailConfirmed)
{
throw new Exception("please_confirm_your_account_first");
}
}
var result = await _userManager.AddPasswordAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
return(Ok());
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM thisModel)
{
System.Threading.Thread.Sleep(2000);
ViewBag.Message = "";
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(thisModel.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return(View("ResetConfirm"));
}
var result = await _userManager.ResetPasswordAsync(user, thisModel.Code, thisModel.Password);
if (result.Succeeded)
{
return(View("ResetConfirm"));
}
var errorList = new List <string>();
foreach (var errors in result.Errors)
{
errorList.Add(errors.Description);
}
ViewBag.ErrorMessage = errorList;
}
return(View(thisModel));
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM resetPasswordVM)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(resetPasswordVM.Email);
if (user != null)
{
var result = await _userManager.ResetPasswordAsync(user, resetPasswordVM.Code, resetPasswordVM.Password);
if (result.Succeeded)
{
return(RedirectToAction("Login", "Auth"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(resetPasswordVM));
}
}
return(RedirectToAction("Login", "Auth"));
}
return(View(resetPasswordVM));
}
public ActionResult VerifyPassword(string id)
{
try
{
bool stat = false;
#region//forgot password verification against the activation code(id)
bool status = registrationInfo.VerifyAccount(id);
#endregion
if (status)
{
ResetPasswordVM resetPassword = new ResetPasswordVM();
resetPassword.ActivationCode = new Guid(id);
stat = true;
ViewBag.Status = stat;
return(View(resetPassword));
}
else
{
return(View());
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM Input)
{
if (!ModelState.IsValid)
{
return(View());
}
Input.PhoneNumber = Input.PhoneNumber.PersianToEnglish();
Input.Code = Input.Code.PersianToEnglish();
Input.Password = Input.Password.PersianToEnglish();
var user = await _userManager.FindByNameAsync(Input.PhoneNumber);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToPage("ResetPasswordConfirmation"));
}
var result = await _userManager.ResetPasswordAsync(user, Input.Code, Input.Password);
if (result.Succeeded)
{
return(RedirectToPage("ResetPasswordConfirmation"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View());
}
public async Task <IActionResult> ResetPassword(string id, ResetPasswordVM reset)
{
if (!ModelState.IsValid)
{
return(View());
}
if (id == null)
{
return(NotFound());
}
AppUser user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
string token = await _userManager.GeneratePasswordResetTokenAsync(user);
var result = await _userManager.ResetPasswordAsync(user, token, reset.Password);
if (result.Succeeded)
{
return(Content("succeed"));
}
//await _userManager.RemovePasswordAsync(user);
//await _userManager.AddPasswordAsync(user,reset.Password);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public ActionResult ResetPassword(ResetPasswordVM model)
{
var message = "";
if (ModelState.IsValid)
{
using (DotrADb db = new DotrADb())
{
var user = db.Members.Where(x => x.ResetPasswordCode == model.ResetCode).FirstOrDefault();
if (user != null)
{
var keyNew = hash.GeneratePassword(10);
user.HashCode = keyNew;
var password = hash.EncodePassword(model.NewPassword, keyNew);
user.Password = password;
user.ResetPasswordCode = "";
db.Configuration.ValidateOnSaveEnabled = false;
db.SaveChanges();
message = "新密碼已成功更新. New password updated successfully.";
}
}
}
else
{
message = "無效的操作. Something invalid.";
}
ViewBag.Message = message;
return(View());
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordVM model)
{
if (ModelState.IsValid)
{
string email = User.Identity.Name;
User user = await db.Users.FirstOrDefaultAsync(u => u.Email == email);
if (user != null)
{
if (user.Password != model.Password)
{
db.Users.Attach(user);
user.Password = model.Password;
db.Users.Update(user);
await db.SaveChangesAsync();
return(Json(new { Message = "Reset successfull" }));
}
else
{
return(Json(new { Error = "This password is already used", ErrorType = "Password_In_Use" }));
}
}
else
{
return(Json(new { Error = "This email don't exist", ErrorType = "Email_Dont_Exist" }));
}
}
else
{
return(Json(new { Error = "Error", ErrorType = ModelState.Values.First().Errors.First().ErrorMessage }));
}
return(Json(new { Error = "Bad request", ErrorType = "Bad_Request" }));
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM resetPass)
{
if (ModelState.IsValid)
{
// Find the user by email
var user = await _userManager.FindByEmailAsync(resetPass.Email);
if (user != null)
{
// reset the user password
var result = await _userManager.ResetPasswordAsync(user, resetPass.Token, resetPass.Password);
if (result.Succeeded)
{
ModelState.AddModelError(string.Empty, "Şifrəniz sıfırlandı");
return(View());
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(resetPass));
}
ModelState.AddModelError(string.Empty, "Xəta meydana gəldi");
return(View());
}
return(View(resetPass));
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM model)
{
logger.Trace("POST ResetPassword()");
if (!ModelState.IsValid)
{
logger.Trace("Model is not valid - showing view again");
return(View(model));
}
logger.Trace("Finding user by email {0}", model.Email);
var user = await userManager.FindByEmailAsync(model.Email);
if (user == null)
{
logger.Trace("User does not exist: pretending to be successful");
return(RedirectToAction("Success", "ForgotPassword"));
}
logger.Trace("Resetting password with code = {0}", model.Code);
var result = await userManager.ResetPasswordAsync(user, model.Code, model.Password);
if (result.Succeeded)
{
logger.Trace("Reset Password for {0} succeeded", model.Email);
return(RedirectToAction("Success", "ForgotPassword"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
logger.Error("Reset Password form had issues - re-displaying");
return(View(model));
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM 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.UtcNow);
}
return(View("ResetPasswordConfirmation"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
public async Task <ActionResult> ResetPassword(ResetPasswordVM viewModel)
{
if (ModelState.IsValid)
{
try
{
var result = await _account.ResetPasswordAsync(viewModel.UserId, viewModel.Code, viewModel.Password);
if (result.Succeeded)
{
return(View("ResetPasswordConfirmation", viewModel));
}
else
{
Array.ForEach(result.Errors.ToArray(), e => ModelState.AddModelError("", e));
}
}
catch (Exception ex)
{
Logger.GetLogger().Error("ResetPassword failed.", ex);
ModelState.AddModelError("", ex);
}
}
// If we got this far, something failed, redisplay form
return(View(viewModel));
}
public async Task <ActionResult> ResetPassword(ResetPasswordVM resetPassword)
{
if (string.IsNullOrWhiteSpace(resetPassword.Code))
{
ModelState.AddModelError("", "Code are required");
return(BadRequest(ModelState));
}
var accountInDB = _context.Accounts.Where(a => a.Id == resetPassword.AccountId && a.IsDeleted == false).FirstOrDefault();
if (accountInDB == null)
{
return(NotFound());
}
var codeDecodedBytes = WebEncoders.Base64UrlDecode(resetPassword.Code);
var codeDecoded = Encoding.UTF8.GetString(codeDecodedBytes);
IdentityResult result = await _userManager.ResetPasswordAsync(accountInDB, codeDecoded, resetPassword.Password);
if (result.Succeeded)
{
accountInDB.LockoutEnabled = false;
await _context.SaveChangesAsync();
return(new JsonResult("Success"));
}
else
{
var message = string.Join(", ", result.Errors.Select(x => "Code " + x.Code + " Description" + x.Description));
return(new JsonResult(message));
}
}
public JsonResult ChangePassword(ResetPasswordVM Model)
{
if (ModelState.IsValid)
{
try
{
if (Model.Email != "" || Model.Email != null)
{
Model.EndUserID = UserID;
if (_UserRepo.ChangePassword(Model))
{
return(Json(new JsonResponse("Success", Resource.PassChangeMessage, true), JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new JsonResponse("Error", Resource.InvalidUserMessage, null), JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception ex)
{
if (ex.InnerException != null)
{
return(Json(new JsonResponse("Error", ex.InnerException.Message.ToString(), null), JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new JsonResponse("Error", ex.Message.ToString(), null), JsonRequestBehavior.AllowGet));
}
}
}
return(Json(new JsonResponse("Error", Resource.NullErrorMessage, null), JsonRequestBehavior.AllowGet));
}
// GET: ResetPassword
public ActionResult ResetPassword()
{
ResetPasswordVM model = new ResetPasswordVM();
model.UserName = CurrentUser.User.UserName;
return(View(model));
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM 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)
{
return(RedirectToAction("ConfirmationResetPassword"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
return(RedirectToAction("ConfirmationResetPassword"));
}
return(View(model));
}
public async Task <IActionResult> ResetPassword([FromForm] ResetPasswordVM model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(BadRequest("No user associated with email"));
}
if (model.NewPassword != model.ConfirmPassword)
{
return(BadRequest("Password doesn't match its confirmation"));
}
if (ModelState.IsValid)
{
var decodedToken = WebEncoders.Base64UrlDecode(model.Token);
string normalToken = Encoding.UTF8.GetString(decodedToken);
var result = await _userManager.ResetPasswordAsync(user, normalToken, model.NewPassword);
if (result.Succeeded)
{
return(Ok("Password has been reset successfully!"));
}
}
return(BadRequest("Some properties are not valid"));
}
public async Task <IActionResult> ResetPassword(ResetPasswordVM resetPasswordVM)
{
if (!ModelState.IsValid)
{
return(View(resetPasswordVM));
}
AppUser appUser = await _userManager.FindByEmailAsync(resetPasswordVM.Email);
if (appUser == null)
{
ModelState.AddModelError("", "Email is invalid!");
return(View(resetPasswordVM));
}
var result = await _userManager.ResetPasswordAsync(appUser, resetPasswordVM.Token, resetPasswordVM.Password);
if (result.Succeeded)
{
return(RedirectToAction("Login", "Auth"));
}
else
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(resetPasswordVM));
}
}
public ActionResult ResetPassword(ResetPasswordVM psw)
{
var errorCode = ErrorCode.NoError;
ModelState.Remove("UserId");
psw.UserId = int.Parse(Session["CurrentUserId"].ToString());
if (ModelState.IsValid)
{
errorCode = UserSvc.ResetPassWord(psw);
if (errorCode == ErrorCode.PasswordNotCorrect)
{
//MyAjaxHelper.RedirectAjax(errorCode, null);
//return Redirect("/ResetPassword/Index");
//return MyAjaxHelper.RedirectAjax(errorCode, "/ResetPassword/Index", "/ResetPassword/Index");
return View("index");
}
else if (errorCode == ErrorCode.NoError)
{
return MyAjaxHelper.RedirectAjax(errorCode, "/Home/Index", "");
}
else
return View();
}
else
{
var error = ModelState.Values.First(o => o.Errors.Count > 0).Errors[0].ErrorMessage;
return MyAjaxHelper.RedirectAjax(AjaxStatusCode.Error, error, null, "");
}
}
public ActionResult ResetPassword(string reset)
{
var userObj = db.UserAccounts.Where(u => u.ResetCode.Equals(reset)).FirstOrDefault();
ResetPasswordVM resetObj = new ResetPasswordVM();
resetObj.ResetUser = userObj.UserName;
return(View(resetObj));
}
//
// GET: /ResetPassword/
public override ActionResult Index()
{
var userid = int.Parse(Session["CurrentUserId"].ToString());
var rpw = new ResetPasswordVM
{
UserId = userid
};
return View(rpw);
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordVM model)
{
var result = await _identityService.ResetPasswordAsync(model);
if (result.Succeeded)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IActionResult ResetPassword(string email, string token)
{
ResetPasswordVM model = new ResetPasswordVM()
{
Email = email,
Token = token
};
return(View(model));
}
//用于重置密码的函数
public ErrorCode ResetPassWord(ResetPasswordVM uvm)
{
try
{
if (uvm.ConfirmPsw != uvm.NewPsw)
return ErrorCode.PasswordNotMatch;
int p_len = uvm.NewPsw.Length;
if ((p_len < 6) || (p_len > 30))
return ErrorCode.PasswordFormatError;
User user = UserDAL.GetById(uvm.UserId, null);
user.Password = Encrypt.Encode(uvm.NewPsw);
UserDAL.Update(user);
return ErrorCode.NoError;
}
catch (Exception)
{
return ErrorCode.ServerError;
}
}
public ActionResult reset(string id)
{
var vm = new ResetPasswordVM();
return View(vm);
}
public ActionResult ResetPassword(ResetPasswordVM model)
{
if (ModelState.IsValid)
{
var updatePasswordResult = accountManager.ResetPassword(model.ActivationCode, model.Password);
if (updatePasswordResult)
{
return RedirectToAction("passwordupdated");
}
}
return View(model);
}
public async Task<ActionResult> ResetPassword(ResetPasswordVM model)
{
if (!ModelState.IsValid)
{
return View(model);
}
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return RedirectToAction("ResetPasswordConfirmation", "Account");
}
var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
if (result.Succeeded)
{
return RedirectToAction("ResetPasswordConfirmation", "Account");
}
AddErrors(result);
return View();
}
