public async Task ChangePassword(int id, ChangeUserPasswordModel model) { var user = Get(id); user.Password = model.Password.WithBCrypt(); await _uow.CommitAsync(); }
public async Task <IActionResult> ChangePassword(ChangeUserPasswordModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await _userManager.GetUserAsync(User); if (user == null) { throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'."); } var changePasswordResult = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (!changePasswordResult.Succeeded) { AddErrors(changePasswordResult); return(View(model)); } await _signInManager.SignInAsync(user, isPersistent : false); _logger.LogInformation("User changed their password successfully."); StatusMessage = "Your password has been changed."; return(RedirectToAction(nameof(ChangePassword))); }
public IActionResult ChangeUserPassword(long id) { var model = new ChangeUserPasswordModel { UserId = id }; return(View(model)); }
public IHttpActionResult ChangePassword(long id, [FromBody] ChangeUserPasswordModel model) { using (var t = Repository.BeginTransaction()) { var user = UserService.ChangePassword(id, model.CurrentPassword, model.NewPassword); t.Commit(); return(Json(user)); } }
public async Task <IActionResult> ChangeUserPassword([FromBody] ChangeUserPasswordModel changeUserPasswordModel) { return(await OnActionWorkAsync(async() => { await _userService.ChangeUserPassword(changeUserPasswordModel); return Ok(); })); }
public string ChangePassword([FromBody] ChangeUserPasswordModel userData) { if (ModelState.IsValid) { var id = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Name) .Select(c => c.Value).SingleOrDefault(); UserReturnModel user = _repo.GetUserById(id); return(_repo.ChangeUserPassword(userData)); } return("Invalid Creds"); }
public string ChangePassword([FromBody] ChangeUserPasswordModel user) { if (ModelState.IsValid) { var email = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Email).Select(c => c.Value).SingleOrDefault(); var sessionUser = _db.GetUserByEmail(email); if (sessionUser.Id == user.Id) { return(_db.ChangeUserPassword(user)); } } return("How you do what you do?"); }
public string ChangePassword([FromBody] ChangeUserPasswordModel user) { if (ModelState.IsValid) { var id = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Name) .Select(c => c.Value).SingleOrDefault(); var sessionUser = _db.GetUserById(id); if (sessionUser.Id == user.Id) { return(_db.ChangeUserPassword(user)); } } return("How did you even get here?"); }
public ActionResult ChangeUserPassword(ChangeUserPasswordModel model, Guid userId) { if (ModelState.IsValid) { MembershipUser usr = Membership.GetUser(userId); usr.ChangePassword(usr.ResetPassword(), model.Password); Membership.UpdateUser(usr); return(RedirectToAction("UserList")); } UserInfo nfo = db.UserInfos.Single(p => p.UserId == userId); GetOrgPosInfo(nfo); return(View(model)); }
public ActionResult ChangeUserPassword(Guid userId) { UserInfo nfo = db.UserInfos.Single(p => p.UserId == userId); ChangeUserPasswordModel model = new ChangeUserPasswordModel(); model.UserName = nfo.AspNetUser.UserName; model.FullName = nfo.FullName; model.JobTitle = nfo.JobTitle; model.IsRCP = nfo.IsRiskOwner; var usr = db.AspNetUsers.Single(u => u.Id == userId.ToString()); model.Email = usr.Email; GetOrgPosInfo(nfo); return(View(model)); }
public ActionResult ChangeUserPassword(ChangeUserPasswordModel model, Guid userId) { if (ModelState.IsValid) { var usr = db.AspNetUsers.Single(u => u.Id == userId.ToString()); usr.PasswordHash = (new PasswordHasher()).HashPassword(model.Password); db.SaveChanges(); return(RedirectToAction("Index")); } UserInfo nfo = db.UserInfos.Single(p => p.UserId == userId); GetOrgPosInfo(nfo); return(View(model)); }
/// <inheritdoc/> public async Task ChangeUserPasswordAsync(Guid id, ChangeUserPasswordModel model, CancellationToken cancellationToken) { using (var scope = _serviceProvider.CreateScope()) using (var context = scope.ServiceProvider.GetRequiredService <DatabaseContext>()) { var user = await context.Users.FirstOrDefaultAsync(x => x.Id == id, cancellationToken).ConfigureAwait(false); if (user == null) { throw new ArgumentException("User not found"); } user.Password = _cryptoProvider.EncodeValue(model.NewPassword); await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false); } }
public async Task ChangePasswordShouldCallUserQueryWithCurrentUser() { var user = new User { Id = _random.Next() }; _context.SetupGet(x => x.User).Returns(user); var requestModel = new ChangeUserPasswordModel { Password = _random.Next().ToString() }; _userQueryProcessor.Setup(x => x.ChangePassword(user.Id, requestModel)) .Returns(Task.FromResult(0)) .Verifiable(); await _query.ChangePassword(requestModel); _userQueryProcessor.Verify(); }
public async Task <IActionResult> PostChangePasswordAsync(Guid userId, [FromBody] ChangeUserPasswordModel changeUserPasswordModel) { if (!ModelState.IsValid) { return(BadRequest()); } var identityName = (User.Identity as ClaimsIdentity).Claims.FirstOrDefault(en => en.Type == ClaimTypes.NameIdentifier)?.Value; if (identityName == null || !Guid.TryParse(identityName, out var currentUserId)) { return(Unauthorized()); } var currentUser = await userRepository.FindByUserIdAsync(new UserId(currentUserId)); var commandResult = await commandDispatcher.PostAsync <ChangeUserPasswordCommand, bool>(new ChangeUserPasswordCommand(new UserId(userId), changeUserPasswordModel.Password), currentUser); return(ResultHelper.HandleResult(commandResult, failureMessageService)); }
/// <summary> /// Changes the password. /// </summary> /// <param name="changeUserPasswordModel">The change password model.</param> /// <returns> /// <see cref="Task" /> /// </returns> public async Task ChangeUserPassword(ChangeUserPasswordModel changeUserPasswordModel) { var user = await _userManager.FindByIdAsync(changeUserPasswordModel.Id); if (user == null) { throw new NotFoundException(); } var result = await _passwordValidator.ValidateAsync(_userManager, user, changeUserPasswordModel.NewPassword); result.Verify(); result = await _userManager.ChangePasswordAsync(user, changeUserPasswordModel.CurrentPassword, changeUserPasswordModel.NewPassword); result.Verify(); }
internal string ChangeUserPassword(ChangeUserPasswordModel user) { User savedUser = _db.QueryFirstOrDefault <User>(@" SELECT * FROM users WHERE id = @Id ", user); var valid = BCrypt.Net.BCrypt.Verify(user.OldPassword, savedUser.Password); if (valid) { user.NewPassword = BCrypt.Net.BCrypt.HashPassword(user.NewPassword); var i = _db.Execute(@" UPDATE users SET password = @NewPassword Where id = @Id ", user); return("Password Changed Successfully"); } return("Password Change Unsuccessful, Please try again"); }
public string ChangeUserPassword(ChangeUserPasswordModel user) { User savedUser = _db.QueryFirstOrDefault <User>(@" SELECT * FROM users WHERE id = @id ", user); var valid = BCrypt.Net.BCrypt.Verify(user.OldPassword, savedUser.Password); if (valid) { user.NewPassword = BCrypt.Net.BCrypt.HashPassword(user.NewPassword); var i = _db.Execute(@" UPDATE users SET password = @NewPassword WHERE id = @id ", user); return("Good Job!"); } return("Ummm Nope!"); }
public async Task <IActionResult> ChangeUserPassword(ChangeUserPasswordModel model) { if (!ModelState.IsValid) { return(View(model)); } User user = await _userManager.FindByIdAsync(model.UserId.ToString()); if (user == null) { return(UserNotFound()); } await _userManager.RemovePasswordAsync(user); await _userManager.AddPasswordAsync(user, model.Password); return(RedirectToAction("Index", new { msg = "Пароль изменен" })); }
internal string ChangeUserPassword(ChangeUserPasswordModel user) { User savedUser = _db.QueryFirstOrDefault <User>(@" SELECT * FROM users WHERE id = @id ", user); var valid = BCrypt.Net.BCrypt.Verify(user.OldPassword, savedUser.Password); if (valid) { user.NewPassword = BCrypt.Net.BCrypt.HashPassword(user.NewPassword); var i = _db.Execute(@" UPDATE users SET password = @NewPassword WHERE id = @id ", user); return("You've changed your password!"); } return("No bueno Julio!"); }
internal string ChangeUserPassword(ChangeUserPasswordModel user) { User savedUser = _db.QueryFirstOrDefault <User>(@" SELECT * FROM users WHERE id = @id ", user); var valid = BCrypt.Net.BCrypt.Verify(user.OldPassword, savedUser.Password); if (valid) { user.NewPassword = BCrypt.Net.BCrypt.HashPassword(user.NewPassword); var i = _db.Execute(@" UPDATE users SET password = @NewPassword WHERE id = @id ", user); return("Successfully Changed Password"); } return("Unable to Set New Password"); }
public async Task <HttpResponseMessage> UpdatePassword(ChangeUserPasswordModel model) { try { bool result = await userService.UpdatePasswordAsync(model.UserId, model.OldPassword, model.NewPassword); if (result) { return(Request.CreateResponse(HttpStatusCode.OK, "Password updated.")); } else { return(Request.CreateResponse(HttpStatusCode.BadRequest, "Update failed.")); } } catch (Exception ex) { return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message)); } }
public async Task <BaseApiResponse> ChangePasswordAsync(ChangeUserPasswordModel model, UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager) { if (!IsAuthenticated) { return(new BaseApiResponse(false, ValidationMessages.YouAreNotAuthorized)); } var validation = ValidateModel(model); if (!validation.IsSucceeded) { return(validation); } if (model.NewPassword == model.OldPassword) { return(new BaseApiResponse(false, "Новый и старый пароль совпадют")); } var user = await userManager.FindByIdAsync(UserId); if (user == null) { return(new BaseApiResponse(false, "Пользователь не найден по указанному идентификатору")); } var result = await userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(new BaseApiResponse(false, "Неправильно указан старый пароль")); } if (user != null) { await signInManager.SignInAsync(user, true); } return(new BaseApiResponse(true, "Ваш пароль изменен")); }
public async Task <IActionResult> ChangePassword() { var user = await _userManager.GetUserAsync(User); if (user == null) { throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'."); } var hasPassword = await _userManager.HasPasswordAsync(user); if (!hasPassword) { return(RedirectToAction(nameof(SetPassword))); } var model = new ChangeUserPasswordModel { StatusMessage = StatusMessage }; return(View(model)); }
public async Task ChangePasswordShouldCallUserQueryWithCurrentUserAsync() { // arrange var user = new UserEntity { Id = Guid.NewGuid() }; _securityContextMock.SetupGet(x => x.UserEntity).Returns(user); var model = new ChangeUserPasswordModel { Password = _random.Next().ToString() }; _userQueryProcessorMock.Setup(x => x.ChangePassword(user.Id, model)) .Returns(Task.FromResult(0)) .Verifiable(); // act await _accountQueryProcessor.ChangePassword(model); // assert _userQueryProcessorMock.Verify(); }
public async Task ChangePassword([FromBody] ChangeUserPasswordModel requestModel) { await _query.ChangePassword(requestModel); }
public IActionResult ChangeUserPassword(ChangeUserPasswordModel model) { _userService.ChangeUserPassword(CurrentUserId, model.OldPassword, model.NewPassword); return(Ok()); }
public IActionResult ChangePassword([FromBody] ChangeUserPasswordModel model) { _accountQuery.ChangePassword(model); return(Ok()); }
public async Task ChangePassword(ChangeUserPasswordModel requestModel) { await _usersQuery.ChangePassword(_context.User.ID, requestModel); }
/// <summary> /// Updates user passowrd /// </summary> /// <param name="userId">user id</param> /// <param name="oldPassword">old password</param> /// <param name="newPassword">new password</param> /// <returns>True is success</returns> public async Task<bool> UpdatePasswordAsync(string userId, string oldPassword, string newPassword) { try { HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, url + "UpdatePassword/" + userId); // Content and authorization ChangeUserPasswordModel modelToSend = new ChangeUserPasswordModel(oldPassword, newPassword); string toSend = JsonConvert.SerializeObject(modelToSend); request.Content = new StringContent(toSend, Encoding.UTF8, "application/json"); request.Headers.Add("Authorization", "Bearer " + GameStore.WindowsApp.Common.UserInfo.Token); // Response HttpResponseMessage response = await client.SendAsync(request); if (response.IsSuccessStatusCode) return true; else return false; } catch (Exception ex) { throw ex; } }
public async Task <IActionResult> ChangeUserPassword(Guid userId, ChangeUserPasswordModel model) { if (!await UserExists(userId)) { return(NotFound()); } const string actionViewPath = ViewsDirectoryPath + nameof(ChangeUserPassword) + ".cshtml"; var currentUserId = new Guid(_userManager.GetUserId(HttpContext.User)); if (!await _databaseContext.UserPermissionsOperator.GetUserDataEditPermissionAsync(userId, currentUserId)) { return(Forbid()); } model.UserId = userId; if (!ModelState.IsValid) { return(View(actionViewPath)); } var userObject = await _userManager.FindByIdAsync(userId.ToString()); if (userId == currentUserId) { if (string.IsNullOrWhiteSpace(model.OldPassword)) { ModelState.AddModelError( nameof(ChangeUserPasswordModel.OldPassword), _localizer["Ви маєте вказати свій попередній пароль!"] ); return(View(actionViewPath)); } if (!await _userManager.CheckPasswordAsync(userObject, model.OldPassword)) { ModelState.AddModelError( nameof(ChangeUserPasswordModel.OldPassword), _localizer["Ви ввели неправильний пароль від свого облікового запису!"] ); return(View(actionViewPath)); } } var identityResult = await _userManager.ResetPasswordAsync( userObject, await _userManager.GeneratePasswordResetTokenAsync(userObject), model.NewPassword ); if (identityResult.Succeeded) { return(RedirectToAction("UserProfile", "Users", new { area = "Social", userId })); } foreach (var identityError in identityResult.Errors) { ModelState.AddModelError(string.Empty, $"Error #{identityError.Code}: {identityError.Description}"); } return(View(actionViewPath, model)); }
public async Task <IActionResult> ChangeUserPassword(ChangeUserPasswordModel model) { await _UserService.ChangeUserPassword(CurrentUserId, model.OldPassword, model.NewPassword); return(Ok()); }
public async Task<HttpResponseMessage> UpdatePassword(string id,ChangeUserPasswordModel model) { try { bool result = await userService.UpdatePasswordAsync(id, model.OldPassword, model.NewPassword); if (result) { return Request.CreateResponse(HttpStatusCode.OK, "Password updated."); } else { return Request.CreateResponse(HttpStatusCode.BadRequest, "Update failed."); } } catch (Exception ex) { return Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message); } }