public async Task GivenEmployeeModel_WhenPutUpdatePasswordRequest_ThenReturnOk() { // Arrange const string NEW_PASSWORD = "******"; var model = _fixture.Context.Users.ToList().ElementAt(5); var viewModel = new UpdatePasswordViewModel { UserName = model.UserName, Password = NEW_PASSWORD, }; // Act var response = await _fixture.Client.PutAsJsonAsync($"{API_URL}/update-password", viewModel); // Assert response.EnsureSuccessStatusCode(); var assertLogin = await AuthExtensions.GetJwt( _fixture, new LoginViewModel { UserName = model.UserName, Password = NEW_PASSWORD, } ); Assert.NotEmpty(assertLogin); }
public async Task <IActionResult> UpdatePassword(string id, [FromBody] UpdatePasswordViewModel vm) { if (!ModelState.IsValid) { var errorMessage = ModelState["Password"].Errors.First().ErrorMessage; return(HttpBadRequest(errorMessage)); } var user = await _userManager.FindByIdAsync(id); if (user == null) { return(HttpNotFound()); } if (!string.IsNullOrWhiteSpace(vm.Password)) { await _userManager.RemovePasswordAsync(user); var result = _userManager.AddPasswordAsync(user, vm.Password); if (result.Result == IdentityResult.Success) { return(new HttpOkResult()); } var error = result.Result.Errors.First().Description; return(HttpBadRequest(error)); } return(HttpBadRequest()); }
public async Task <ActionResult> UpdatePassword(UpdatePasswordViewModel model) { if (ModelState.IsValid) { var user = await UserManager.FindByIdAsync(User.Identity.GetUserId()); if (user == null) { // Не показывать, что пользователь не существует или не подтвержден return(View("ChangePasswordError")); } { var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.Password); if (result.Succeeded) { return(RedirectToAction("ChangePasswordConfirmation", "Account")); } // Дополнительные сведения о включении подтверждения учетной записи и сброса пароля см. на странице https://go.microsoft.com/fwlink/?LinkID=320771. // Отправка сообщения электронной почты с этой ссылкой return(View("ChangePasswordError")); } } // Появление этого сообщения означает наличие ошибки; повторное отображение формы return(View("ChangePasswordError")); }
public async Task <ActionResult> UpdatePassword(UpdatePasswordViewModel model, string userId, string newPassword) { SWGDealerDbContext context = new SWGDealerDbContext(); UserStore <AppUser> store = new UserStore <AppUser>(context); UserManager <AppUser> userManager = new UserManager <AppUser>(store); userId = User.Identity.GetUserId(); if (!ModelState.IsValid) { return(View("UpdatePassword")); } else { newPassword = model.ConfirmPassword; string hashedNewPassword = userManager.PasswordHasher.HashPassword(newPassword); AppUser identityUser = await store.FindByIdAsync(userId); await store.SetPasswordHashAsync(identityUser, hashedNewPassword); await store.UpdateAsync(identityUser); TempData["PasswordUpdate"] = "Password has been successfully updated!"; return(View("UpdatePassword")); } }
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var user = await userService.UpdatePasswordAsync(model.UserId, model.Password); return(Ok()); } catch (NullReferenceException ex) { logger.LogError(ex.Message, ex); return(NotFound()); } catch (Exception ex) { logger.LogError(ex.Message, ex); ModelState.AddModelError(String.Empty, "Cannot update user password"); return(BadRequest(ModelState)); } }
public async Task <ApiResponseDto> UpdatePassword(UpdatePasswordViewModel parameters) { ApiResponseDto apiResponse = await _accountApiClient.UpdatePassword(parameters); NotifyAuthenticationStateChanged(GetAuthenticationStateAsync()); return(apiResponse); }
public async Task <ActionResult> UpdatePassword(UpdatePasswordViewModel viewModel) { var updateResult = await _profileAppService.UpdatePassword(new UpdatePasswordDto { CurrentPassword = viewModel.CurrentPassword, NewPassword = viewModel.NewPassword }); if (updateResult.Succeeded) { return(Ok()); } var errorDesc = ""; foreach (var error in updateResult.Errors) { errorDesc = error.Description; //if (error.Code == "PasswordMismatch") throw new UserFriendlyException(error.Description); } return(BadRequest(errorDesc)); //return StatusCode(200); }
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await GetCurrentUserAsync(); if (user != null) { byte[] bytes = Convert.FromBase64String(model.OldPassword); string oldPassword = Encoding.UTF8.GetString(bytes); var result = await _userManager.ChangePasswordAsync(user, oldPassword, model.NewPassword); if (result.Succeeded) { await _signInManager.SignInAsync(user, isPersistent : false); _logger.LogInformation(3, "User changed their password successfully."); return(RedirectToAction("Index", "Home")); } AddErrors(result); return(View(model)); } return(RedirectToAction("Index", "Home")); }
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model) { if (ModelState.IsValid) { if (model.NewPassword == model.ConfirmPassword) { var result = await _userManager.ChangePasswordAsync(await _userManager.GetUserAsync(User), model.CurrentPassword, model.NewPassword); if (result.Succeeded) { TempData["success"] = "Password updated!"; return(RedirectToAction("Profile")); } else { TempData["error"] = $"Error: "; foreach (var error in result.Errors) { TempData["error"] += $"{error.Description}. "; } return(View()); } } else { TempData["error"] = $"Passwords do not match"; return(RedirectToAction("UpdatePassword")); } } return(RedirectToAction("Profile")); }
public async Task <JsonResult> Put(int id, [FromBody] UpdatePasswordViewModel password) { Logger.Fatal(this.Request.Log()); var isAuthorized = await CheckUserAuthorized(id); if (isAuthorized.StatusCode != 200) { return(isAuthorized); } // All was well var pass = await _context.Password.FirstOrDefaultAsync(x => x.Id == id); if (pass == null) { return(404.ErrorStatusCode()); } // Update old pass pass.PasswordText = password.PasswordText.Encrypt(_configuration.GetConnectionString("Enc")); pass.Hint = password.Hint; // Save changes _context.Password.Update(pass); _context.SaveChanges(); return(202.SuccessStatusCode()); }
public async Task <IActionResult> UpdatePassword(string userId) { if (userId == null) { return(NotFound()); } var user = await _userManager.FindByIdAsync(userId); if (user == null) { return(NotFound()); } var loggedInUser = await _userManager.FindByNameAsync(HttpContext.User.Identity.Name); if (user.Id != loggedInUser.Id) { return(NotFound()); } var updatePasswordViewModel = new UpdatePasswordViewModel { UserId = user.Id }; return(View()); }
public IActionResult UpdatePassword(UpdatePasswordViewModel model) { ViewData[AccountConstants.SuccessPasswordUpdate] = false; if (ModelState.IsValid) { try { var updateUserPasswordContract = new UpdateUserPasswordContract { NewPassword = model.Password, OldPassword = model.OldPassword }; var client = GetUserClient(); client.UpdateCurrentPassword(updateUserPasswordContract); ViewData[AccountConstants.SuccessPasswordUpdate] = true; return(PartialView("UserProfile/_UpdatePassword", null)); } catch (HttpErrorCodeException e) { AddErrors(e); } catch (MainServiceException e) { AddErrors(e); } } return(PartialView("UserProfile/_UpdatePassword", model)); }
public async Task <JsonResult> UpdatePassword(UpdatePasswordViewModel model) { if (HasPassword()) { if (ModelState.IsValid) { IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (result.Succeeded) { return(Json(new { result = "success" })); } else { return(Json(new { result = "failed", })); } } } return(Json(new { result = "failed", data = ModelState.Select(x => new { Field = x.Key, Error = x.Value.Errors }).ToList() })); }
public ApiResult <UpdatePasswordViewModel> UpdatePassword(UpdatePasswordViewModel model) { var dbResult = new ApiResult <UpdatePasswordViewModel>(); try { // Validate dữ liệu if (!ValidateUpdatePassword(model).Succeeded) { return(ValidateUpdatePassword(model)); } // Đặt lại mật khẩu trong database model.NewPassword = Libs.GetMd5(model.NewPassword + EncryptCore.PassKey); model.NewPassword = model.NewPassword; dbResult = userDAL.UpdatePassword(model); return(dbResult); } catch (Exception ex) { dbResult.Failed(new ErrorObject() { Code = Constants.ERR_EXCEPTION, Description = ex.Message }); return(dbResult); } }
public ActionResult Index(string option, string userType) { if (option != null) { switch (option.ToLower()) { case "updateinfo": { _viewModel = new UpdateInfoViewModel(); CreateLayoutView("Cập nhật thông tin"); break; } case "updatepassword": { _viewModel = new UpdatePasswordViewModel(); CreateLayoutView("Cập nhật mật khẩu"); break; } case "updatesetting": { _viewModel = new UpdateSettingViewModel(); CreateLayoutView("Cài đặt"); break; } case "notification": { _viewModel = new NotificationViewModel(); CreateLayoutView("Thông báo"); break; } case "requests": { _viewModel = new RequestsViewModel(); CreateLayoutView("Lời mời kết bạn"); break; } default: { _viewModel = new UpdateInfoViewModel(); CreateLayoutView("Cập nhật thông tin"); break; } } } else { _viewModel = new UpdateInfoViewModel(); CreateLayoutView("Cập nhật thông tin"); } ViewBag.newMember = userType; ViewBag.listRequest = _friendService.GetRelationship(User.Identity.GetUserId()).Count - 1; ViewBag.listNotification = _notificationService.getAllNotification(User.Identity.GetUserId()).Count - 1; return(View(_viewModel)); }
public async Task <IActionResult> UpdatePassword([Bind("ProjectId, AssetId, Password")] UpdatePasswordViewModel updatePasswordViewModel) { if (updatePasswordViewModel == null) { throw new ArgumentNullException(nameof(updatePasswordViewModel)); } if (ModelState.IsValid) { // check valid project, do not decrypt, checks access var project = await _projectsService.GetProject(updatePasswordViewModel.ProjectId, true); if (project == null) { return(NotFound()); } // get the current user IP string accessIpAddress = HttpContext?.Connection?.RemoteIpAddress?.ToString(); // Perform the credential update await _assetService.UpdateAssetPasswordAsync( updatePasswordViewModel.ProjectId, updatePasswordViewModel.AssetId, updatePasswordViewModel.Password, accessIpAddress); } else { return(BadRequest("Model is invalid.")); } return(RedirectToAction(nameof(Details), new { id = updatePasswordViewModel.ProjectId })); }
public async Task <IActionResult> ChangePassword([FromBody] UpdatePasswordViewModel model) { if (!ModelState.IsValid) { return(BadRequest()); } var adminUser = _userRepository.GetByKey(model.UserId.Value); if (adminUser == null) { return(new JsonResult(new { success = false, Message = "修改失败" })); } var pwdVerification = _passwordHasher.VerifyHashedPassword( adminUser, adminUser.UserPassword, model.CurrentPassword); if (pwdVerification == PasswordVerificationResult.Success || pwdVerification == PasswordVerificationResult.SuccessRehashNeeded) { adminUser.UserPassword = _passwordHasher.HashPassword(adminUser, model.NewPassword); _userRepository.Update(adminUser); var state = await _unitOfWork.SaveAsync(); return(Json(state)); } return(Json(false)); }
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model) { if (ModelState.IsValid) { var user = await userHelper.FindByEmailAsync(User.Identity.Name); if (user != null) { var result = await userHelper.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { return(RedirectToAction(nameof(Settings))); } else { ModelState.AddModelError(string.Empty, result.Errors.FirstOrDefault().Description); } } else { ModelState.AddModelError(string.Empty, "Usuario no encontrado"); } } return(View(model)); }
public ActionResult UpdatePasswordDB(UpdatePasswordViewModel vm) { if (!ModelState.IsValid) { return(View("UpdatePassword", vm)); } int id = (int)Session["User"]; if (Hash(vm.Password) == _context.NWUsers.SingleOrDefault(x => x.Id.Equals(id)).Password)//db.GetUserById((int)Session["User"]).Password) { _context.NWUsers.SingleOrDefault(x => x.Id.Equals(id)).Password = Hash(vm.NewPassword); _context.SaveChanges(); return(RedirectToAction("ViewUserData")); //if (db.UpdatePassword((int)Session["User"], vm.NewPassword)) //{ // ViewBag.Error = null; // return RedirectToAction("ViewUserData"); //} //else //{ // ViewBag.Error = "Adatbázis hiba történt!"; // return View("ViewUserData"); //} } else { ViewBag.Error = "Nem jól adta meg jelenlegi jelszavát!"; return(View("UpdatePassword")); } }
public IActionResult UpdatePassword(UpdatePasswordViewModel UpdatePasswordViewModel) { var account = _authRepository.CheckByToken(_user.Token); if (ModelState.IsValid) { if (!Crypto.VerifyHashedPassword(account.Password, UpdatePasswordViewModel.CurrentPassword)) { return Ok(new { message = "Password is Not Valid!", status=false }); } if(_authRepository.UpdatePassword(_user.Id, UpdatePasswordViewModel.Password)) { return Ok(new { message = "Password Updated Successfully!", status = true }); } } return View("Views/Pages/Chat1.cshtml", new GeneralViewModel { UpdatePasswordViewModel = UpdatePasswordViewModel, AccountDetailViewModel = _mapper.Map<Account, AccountDetailViewModel>(_authRepository.CheckByToken(_user.Token)) }); }
public async Task <IActionResult> UpdatePassword(UpdatePasswordViewModel model) { var user = await _userManager.GetUserAsync(HttpContext.User); if (ModelState.IsValid) { var verifyHashed = _passwordHasher.VerifyHashedPassword(user, user.PasswordHash, model.OldPassword); if (verifyHashed == PasswordVerificationResult.Success) { user.PasswordHash = _passwordHasher.HashPassword(user, model.NewPassword); var result = await _userManager.UpdateAsync(user); if (result.Succeeded) { await _signInManager.SignOutAsync(); await _signInManager.SignInAsync(user, true); return(RedirectToAction("Index")); } ModelState.AddIdentityError(result.Errors); return(View(model)); } ModelState.AddModelError(nameof(model.OldPassword), Messages.OldPasswordFail); return(View(model)); } return(View(model)); }
public async Task <IActionResult> AlterarSenhaUsuarioLogado([FromBody] UpdatePasswordViewModel model, int version) { if (version == 2) { return(Response(new { Message = "API V2 não disponível" })); } var userEF = await _userManager.FindByIdAsync(model.Id); if (userEF == null || string.IsNullOrEmpty(userEF.Email) || userEF.Email != model.Email) { return(Response(new { Message = "Não foi possível localizar o usuário na base de dados." })); } if (!ModelState.IsValid) { NotifyErrorInvalidModel(); return(Response()); } var result = await _userManager.ChangePasswordAsync(userEF, model.SenhaAtual, model.NovaSenha); if (result.Succeeded) { _logger.LogInformation(1, "Senha alterada com sucesso!"); var response = new { Message = "Senha alterada com sucesso!" }; return(Response(response)); } AddIdentityErrors(result); return(Response(model)); }
public ActionResult UpdatePassword() { UpdatePasswordViewModel updatePasswordViewModel = new UpdatePasswordViewModel(); AdminProfileViewModel adminProfileViewModel = (AdminProfileViewModel)Session["EmployeeObj"]; updatePasswordViewModel.EmployeeID = adminProfileViewModel.EmployeeID; return(View(updatePasswordViewModel)); }
public IActionResult UpdatePassword() { var loginId = User.Identity.Name; var model = new UpdatePasswordViewModel(); return(View(model)); }
/// <summary> /// 修改密碼 /// </summary> /// <returns></returns> public ActionResult Password() { var model = new UpdatePasswordViewModel { ExistPassword = service.ExistPassword(SessionManager.UserID) }; return(PartialView(ViewName("Member", "Password"), model)); }
public ActionResult UpdatePassword() { _viewModel = new UpdatePasswordViewModel(); CreateLayoutView("Quản lý tài khoản"); ViewBag.listRequest = _friendService.GetRelationship(User.Identity.GetUserId()).Count - 1; ViewBag.listNotification = _notificationService.getAllNotification(User.Identity.GetUserId()).Count - 1; return(PartialView("_UpdatePassword", UpdatePasswordViewModel)); }
public async Task <IActionResult> UpdatePassword() { var user = await _userService.FetchCurrentUser(); var model = new UpdatePasswordViewModel(); model.Kund = _userService.FetchCurrentCustomer(user.Id); return(View(model)); }
public async Task <IActionResult> OnGet() { var user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound()); } UpdatePasswordViewModel = new UpdatePasswordViewModel(); return(Page()); }
public ActionResult Password(UpdatePasswordViewModel model) { var result = service.UpdatePassword(SessionManager.UserID, model); //重新登入 if (result.IsSuccess) { SessionManager.RemoveAll(); } return(Json(result)); }
public ActionResult ChangePassword(UpdatePasswordViewModel model) { if (CurrentUser == null) { return(new HttpUnauthorizedResult()); } model.CurrentUser = CurrentUser; model.UserId = CurrentUser.Id; return(View(model)); }