public async Task <IActionResult> ChangePassword(Guid id, ChangePasswordCommand input) { input.Id = id; await _mediator.Publish(input); return(Ok()); }
public async Task ChangePasswordInProfileAsync(ChangePasswordCommand command) { var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == command.Id); if (user == null) { throw new GfsException(ErrorCode.UserNotFound, _dictionary.UserNotFound); } if (!await _userManager.CheckPasswordAsync(user, command.OldPassword)) { throw new GfsException(ErrorCode.WrongPassword, _dictionary.WrongPassword); } if (command.NewPassword == null) { throw new GfsException(ErrorCode.EmptyPassword, _dictionary.EmptyPassword); } var hash = _userManager.PasswordHasher.HashPassword(user, command.NewPassword); if (hash == null) { throw new GfsException(ErrorCode.EmptyPassword, _dictionary.EmptyPassword); } user.PasswordHash = hash; await _context.SaveChangesAsync(); }
public async Task ChangePassword_Anonymous_ThrowException() { // Arrange var currentUserResolver = new Mock <ICurrentUserResolver>(); currentUserResolver .Setup(r => r.ResolveAsync()) .ReturnsAsync((User)null); var authenticationService = InstantiateAuthenticationService( new Tuple <Type, object>(typeof(ICurrentUserResolver), currentUserResolver.Object) ); var command = new ChangePasswordCommand() { OldPassword = "******", NewPassword = "******", NewPasswordConfirm = "mypassword123" }; // Act // Assert await Assert.ThrowsAsync <ChangePasswordException>( () => authenticationService.ChangePassword(command) ); }
public ActionResult ChangePassword(ChangePasswordFormModel form) { if (ModelState.IsValid) { EFMVCUser efmvcUser = HttpContext.User.GetEFMVCUser(); var command = new ChangePasswordCommand { UserId = efmvcUser.UserId, OldPassword = form.OldPassword, NewPassword = form.NewPassword }; IEnumerable <ValidationResult> errors = commandBus.Validate(command); ModelState.AddModelErrors(errors); if (ModelState.IsValid) { var result = commandBus.Submit(command); if (result.Success) { return(RedirectToAction("ChangePasswordSuccess")); } else { ModelState.AddModelError("", "The current password is incorrect or the new password is invalid."); } } } // If we got this far, something failed, redisplay form return(View(form)); }
public ActionResult ChangePassword(string newPassword, string currentPassword, string confirmPassword) { ViewData["PasswordLength"] = membershipReadModel.MinPasswordLength; if (!ValidateChangePassword(currentPassword, newPassword, confirmPassword)) { return(View()); } try { var userId = ((NerdIdentity)User.Identity).UserId; var changePasswordCommand = new ChangePasswordCommand { NewPassword = newPassword, UserId = userId }; if (commandService.ChangePassword(changePasswordCommand)) { return(RedirectToAction("ChangePasswordSuccess")); } ModelState.AddModelError("_FORM", "The current password is incorrect or the new password is invalid."); return(View()); } catch { ModelState.AddModelError("_FORM", "The current password is incorrect or the new password is invalid."); return(View()); } }
public async Task ServiceValidationAttribute_ServiceAvailable_ComplexityRequirementsMet() { var services = new ServiceCollection(); services.Configure <PasswordOptions>(options => { options.RequiredLength = 6; options.RequireDigit = true; options.RequireNonAlphanumeric = true; options.RequireLowercase = true; options.RequiredUniqueChars = 2; }); services.AddSingleton <IValidator <PasswordAttribute>, PasswordValidator>(); var command = new ChangePasswordCommand { UserName = "******", NewPassword = "******", }; await using var sp = services.BuildServiceProvider(); DataAnnotationsValidator.Validate(command); }
public async Task <Result <UserInfo> > Handle(ChangePasswordCommand request, CancellationToken cancellationToken) { var errorMessages = Validate(request); if (errorMessages.Any()) { return(new Result <UserInfo>(default, default, errorMessages));
public async Task <RequestResponse> ChangePasswordUserAsync(ChangePasswordCommand changePassword) { var email = _encryptionService.DecryptData(changePassword.Email); var oldPassword = _encryptionService.DecryptData(changePassword.OldPassword); var newPassword = _encryptionService.DecryptData(changePassword.NewPassword); var newConfirmPassword = _encryptionService.DecryptData(changePassword.NewConfirmPassword); var user = await _userManager.FindByEmailAsync(email); if (user == null) { throw new Exception("The user does not exist"); } if (!await _userManager.CheckPasswordAsync(user, oldPassword)) { throw new Exception("The credential is not valid"); } if (!newPassword.Equals(newConfirmPassword)) { throw new Exception("Passwords do not match"); } await _userManager.ChangePasswordAsync(user, oldPassword, newPassword); return(RequestResponse.Success()); }
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordViewModel ViewModel) { var command = new ChangePasswordCommand(ViewModel, User); var result = await mediator.Send(command); return(Ok(result)); }
public async Task HandleAsync_Should_Throw_ValidationException_When_Account_Has_No_Password() { var changePasswordCommand = new ChangePasswordCommand(Guid.NewGuid(), "OldPassword", "NewPassword"); var account = Account.Builder() .SetId(Guid.NewGuid()) .SetEmail("*****@*****.**") .SetConfirmed(true) .SetPasswordHash("PasswordHash") .SetSecurityStamp(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetRoles(new List <Guid> { Guid.NewGuid() }) .Build(); var getAccountResult = GetResult <Account> .Ok(account); var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.PasswordIsNotSet, AccountErrorMessage.PasswordIsNotSet) }; var passwordIsSetVerificationResult = VerificationResult.Fail(errors); _accountGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getAccountResult); _accountVerificationServiceMock.Setup(x => x.VerifyPasswordIsSet(It.IsAny <string>())) .Returns(passwordIsSetVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(changePasswordCommand); var exceptionResult = await result.Should().ThrowAsync <ValidationException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public async Task ChangePassword_Fail_ThrowException() { // Arrange var currentUserResolver = new Mock <ICurrentUserResolver>(); currentUserResolver.Setup(r => r.ResolveAsync()) .ReturnsAsync(new User()); var userManagerMock = new Mock <IAspNetIdentityUserManager>(); userManagerMock .Setup(um => um.ChangePasswordAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .ReturnsAsync(IdentityResult.Failed()); var authenticationService = InstantiateAuthenticationService( new Tuple <Type, object>(typeof(ICurrentUserResolver), currentUserResolver.Object), new Tuple <Type, object>(typeof(IAspNetIdentityUserManager), userManagerMock.Object) ); var command = new ChangePasswordCommand() { OldPassword = "******", NewPassword = "******", NewPasswordConfirm = "mypassword123" }; // Act // Assert await Assert.ThrowsAsync <ChangePasswordException>( () => authenticationService.ChangePassword(command) ); }
public IActionResult ChangePassword(Guid id, ChangePasswordRequest request) { var command = new ChangePasswordCommand(id, request.OldPassword, request.NewPassword); Result result = _dispatcher.Dispatch(command); return(FromResult(result)); }
public async Task Handle_GivenNoUserAppearsToBeAuthenticate_ExpectFailedResult() { var user = new Mock <IUser>(); var userRepository = new Mock <IUserRepository>(); var unitOfWork = new Mock <IUnitOfWork>(); unitOfWork.Setup(x => x.SaveEntitiesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(() => true); userRepository.Setup(x => x.UnitOfWork).Returns(unitOfWork.Object); userRepository.Setup(x => x.Find(It.IsAny <Guid>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => Maybe.From(user.Object)); var currentAuthenticatedUserProvider = new Mock <ICurrentAuthenticatedUserProvider>(); currentAuthenticatedUserProvider.Setup(x => x.CurrentAuthenticatedUser) .Returns(Maybe <ISystemUser> .Nothing); var securitySettings = new Mock <IOptions <SecuritySettings> >(); var clock = new Mock <IClock>(); var handler = new ChangePasswordCommandHandler(currentAuthenticatedUserProvider.Object, userRepository.Object, securitySettings.Object, clock.Object); var cmd = new ChangePasswordCommand("current-password", "new-password"); var result = await handler.Handle(cmd, CancellationToken.None); Assert.True(result.IsFailure); Assert.Equal(ErrorCodes.UserNotFound, result.Error.Code); }
private async void SaveChangesAsync() { if (Validate()) { var command = new ChangePasswordCommand { CurrentPassword = _currentPassword.Value, NewPassword = _newPassword.Value, Email = Settings.LastUsedEmail }; try { await _accountService.ChangePassword(GlobalSetting.Instance.AuthToken, command); await NavigationService.Close(this); DependencyService.Get <IMessage>().LongAlert("Password successfully updated.", System.Drawing.Color.Empty); } catch (HttpResponseEx ex) { DependencyService.Get <IMessage>().LongAlert(ex.Scenario, Color.Red); } } }
public async Task InputDataIsok_Executed_ReturnUnitValue() { var fixture = new Fixture(); var userRepository = new Mock <IUserRepository>(); var authService = new Mock <IAuthService>(); var user = new User(1, "abc", "*****@*****.**", "6f2cb9dd8f4b65e24e1c3f3fa5bc57982349237f11abceacd45bbcb74d621c25", "admin"); var newPassoword = "6f2cb9dd8f4b65e24e1c3f3fa5bc57982349237f11abceacd45bbcb74d621c25"; userRepository.Setup(u => u.GetByIdAsync(user.Id)).Returns(ConverUserInTaskUser(user)); authService.Setup(u => u.ComputeSha256Hash(newPassoword)).Returns(newPassoword); var changePasswordCommand = new ChangePasswordCommand(1, "6f2cb9dd8f4b65e24e1c3f3fa5bc57982349237f11abceacd45bbcb74d621c25", newPassoword); var changePasswordCommandHandler = new ChangePasswordCommandHandler(userRepository.Object, authService.Object); var id = await changePasswordCommandHandler.Handle(changePasswordCommand, new System.Threading.CancellationToken()); Assert.IsType <Unit>(id); Assert.True(Unit.Value.Equals(id)); userRepository.Verify(g => g.GetByIdAsync(1), Times.Once); userRepository.Verify(g => g.SaveChangesAsync(), Times.Once); }
public BaseViewModel ChangePassword(ChangePasswordCommand command) { BaseViewModel vm = new BaseViewModel(); vm = userBL.ChangePassword(command); return(vm); }
public void Arrange() { _passwordService = new Mock <IPasswordService>(); _passwordService.Setup(s => s.VerifyAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .Returns(Task.FromResult(false)); _passwordService.Setup(s => s.VerifyAsync(CurrentPassword, CurrentPasswordHash, Salt, PasswordProfileId)) .Returns(Task.FromResult(true)); _configurationService = new Mock <IConfigurationService>(); _configurationService.Setup(s => s.GetAsync <EmployerUsersConfiguration>()) .ReturnsAsync(new EmployerUsersConfiguration { Account = new AccountConfiguration { NumberOfPasswordsInHistory = 3 } }); _validator = new ChangePasswordCommandValidator(_passwordService.Object, _configurationService.Object); _command = new ChangePasswordCommand { User = new Domain.User { Id = UserId, Password = CurrentPasswordHash, PasswordProfileId = PasswordProfileId, Salt = Salt, PasswordHistory = new Domain.HistoricalPassword[0] }, CurrentPassword = CurrentPassword, NewPassword = NewPassword, ConfirmPassword = NewPassword, }; }
public ActionResult ChangePassword(ChangePasswordFormModel form) { if (ModelState.IsValid) { var user = HttpContext.User; var command = new ChangePasswordCommand { UserId = int.Parse(user.Identity.GetUserId()), OldPassword = form.OldPassword, NewPassword = form.NewPassword }; IEnumerable <ValidationResult> errors = commandBus.Validate(command); ModelState.AddModelErrors(errors); if (ModelState.IsValid) { var result = commandBus.Submit(command); if (result.Success) { return(RedirectToAction("ChangePasswordSuccess")); } else { ModelState.AddModelError("", "The current password is incorrect or the new password is invalid."); } } } return(View(form)); }
public async Task When_change_password_handler_receive_a_valid_dto_and_it_does_not_comply_with_business_rules_it_returns_failure_and_response_body_and_does_not_publish() { //This requires better use of builders or fixtures, the property values for the Dto should be in one place //So they match in all tests. var changePasswordDto = new ChangePasswordDto() { UserName = "******", CurrentPassword = "******", NewPassword = "******", NewPasswordConfirmation = "previousPassword1" }; var changePasswordCommand = new ChangePasswordCommand(changePasswordDto); _passwordHistoryRepo.Setup(mock => mock.GetPasswordHistory(changePasswordDto.UserName, It.IsAny <bool>())).Returns ( new PasswordHistoryBuilder().withUserName(changePasswordDto.UserName).Build() ); var changePasswordResponse = await _changePasswordHandler.Handle(changePasswordCommand, CancellationToken.None); _externalEventPublisher.Verify(publisher => publisher.PublishAsync(It.IsAny <ExternalEvent>()), Times.Never); changePasswordResponse.UserName.Should().Be(changePasswordDto.UserName); changePasswordResponse.Success.Should().BeFalse(); }
public async Task When_change_password_handler_receive_a_valid_dto_and_it_complies_with_business_rules_it_returns_success_and_response_body_and_publishes() { var changePasswordDto = new ChangePasswordDto() { UserName = "******", CurrentPassword = "******", NewPassword = "******", NewPasswordConfirmation = "newPassword" }; var changePasswordCommand = new ChangePasswordCommand(changePasswordDto); _passwordHistoryRepo.Setup(mock => mock.GetPasswordHistory(changePasswordDto.UserName, It.IsAny <bool>())).Returns ( new PasswordHistoryBuilder().withUserName(changePasswordDto.UserName).Build() ); var changePasswordResponse = await _changePasswordHandler.Handle(changePasswordCommand, CancellationToken.None); var passwordChangedExternalEvent = PasswordChangedData.CreateExternalEvent ( changePasswordDto.UserName, new Password(changePasswordDto.NewPassword) ); //It's better to pass the specific paramenter and not use It.IsAny<ExternalEvent>() //_externalEventPublisher.Verify(mock => mock.PublishAsync(It.IsAny<ExternalEvent>())); _externalEventPublisher.Verify(publisher => publisher.PublishAsync(passwordChangedExternalEvent)); changePasswordResponse.UserName.Should().Be(changePasswordDto.UserName); changePasswordResponse.Success.Should().BeTrue(); }
public IActionResult ChangePassword(ChangePasswordCommand command) { // 过滤请求数据 if (null == command) { return(Json(new { code = -1, msg = "Error:数据不正确", url = string.Empty })); } else if (command.NewPassword.IsNullOrWhitespace() || command.ConfirmNewPassword.IsNullOrWhitespace() || command.OldPassword.IsNullOrWhitespace()) { return(Json(new { code = -1, msg = "Error:数据不正确", url = string.Empty })); } else if (command.NewPassword != command.ConfirmNewPassword) { return(Json(new { code = -1, msg = "Error:两次输入密码不一致", url = string.Empty })); } // 得到当前登录的账号 command.UserAccount = HttpContext.User.FindFirst(ClaimTypes.Sid).Value; // 执行修改密码命令 var commandResult = this._commandInvokerFactory.Handle <ChangePasswordCommand, CommandResult>(command); // 执行发生错误 if (!commandResult.IsSuccess) { return(Json(new { code = -1, msg = $"Error:{commandResult.GetErrors()[0]}", url = string.Empty })); } // 执行成功,清除登陆痕迹返回结果 AccountLoginManager.SetLoginOut(HttpContext); return(Json(new { code = 1, msg = "Success:修改成功", url = "/Account/Index" })); }
public async Task PasswordInvalid_Executed_ReturnInvalidOperation() { var fixture = new Fixture(); var userRepository = new Mock <IUserRepository>(); var authService = new Mock <IAuthService>(); var user = new User(1, "abc", "*****@*****.**", "321", "admin"); userRepository.Setup(u => u.GetByIdAsync(user.Id)).Returns(ConverUserInTaskUser(user)); authService.Setup(u => u.ComputeSha256Hash("123")) .Returns((string pass) => { if (pass == "123") { return("123"); } else { return(string.Empty); } }); var changePasswordCommand = new ChangePasswordCommand(1, "222", "3213"); var changePasswordCommandHandler = new ChangePasswordCommandHandler(userRepository.Object, authService.Object); InvalidOperationException except = await Assert.ThrowsAsync <InvalidOperationException>(() => changePasswordCommandHandler.Handle(changePasswordCommand, new System.Threading.CancellationToken())); Assert.Equal("Senha Digitada e inválida!", except.Message); userRepository.Verify(g => g.GetByIdAsync(1), Times.Once); }
public async Task Handle_Should_ChangePassword() { ChangePasswordCommand command = GetChangePasswordCommandHandlerObject(); var user = new User("*****@*****.**", "firstname", "lastname", false, "salt", "password", DateTime.UtcNow, DateTime.UtcNow); var newHash = "new hash"; var newSalt = "new salt"; _passwordValidatorMock.Setup(m => m.Validate(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>())) .Returns(Enumerable.Empty <string>()); _emailValidatorMock.Setup(m => m.Validate(It.IsAny <string>())) .Returns(true); _userRepositoryMock.Setup(m => m.Get(It.IsAny <string>())) .ReturnsAsync(user); _encryptorMock.Setup(m => m.ComputeHash(command.OriginalPassword, It.IsAny <string>())) .Returns(user.PasswordHash); _encryptorMock.Setup(m => m.ComputeHash(command.Password, It.IsAny <string>())) .Returns(newHash); _encryptorMock.Setup(m => m.GenerateSalt()).Returns(newSalt); var result = await _handler.Handle(command, GetCancellationToken()); result.Should().NotBeNull(); result.ErrorMessages.Should().BeEmpty(); result.Value.Should().NotBeNull(); result.Message.Should().Be(ChangePasswordCommandHandler.Password_Updated); }
public UserMessage ChangePassword(ChangePasswordCommand command) { EnsureIsValid(command); try { var user = _deps.Users.Find(command.UserId); if (user == null || user.Deleted) { throw NotFound.ExceptionFor <User>(command.UserId); } if (!user.ValidatePassword(command.CurrentPassword)) { throw AccessFailure.ExceptionBecause(AccessFailureReason.BadCredentials); } user.UpdatePassword(command.NewPassword); _deps.Tokens.Delete(DbQuery.For <ApplicationToken>().FilterBy(x => x.User.Id == command.UserId)); Commit(); return(UserMessage.Resource(() => Messages.PasswordChanged)); } catch (ServiceException) { throw; } catch (Exception ex) { throw new ServiceException("Can't change password.", ex); } }
public ActionResult ChangePassword(ChangePasswordFormModel form) { if (ModelState.IsValid) { EFMVCUser efmvcUser = HttpContext.User.GetEFMVCUser(); var command = new ChangePasswordCommand { UserId = efmvcUser.UserId, OldPassword=form.OldPassword, NewPassword = form.NewPassword }; IEnumerable<ValidationResult> errors = commandBus.Validate(command); ModelState.AddModelErrors(errors); if (ModelState.IsValid) { var result = commandBus.Submit(command); if (result.Success) { return RedirectToAction("ChangePasswordSuccess"); } else { ModelState.AddModelError("", "The current password is incorrect or the new password is invalid."); } } } // If we got this far, something failed, redisplay form return View(form); }
public async Task ServiceValidationAttribute_ServiceAvailable_ComplexityRequirementsNotMet() { var services = new ServiceCollection(); services.Configure <PasswordOptions>(options => { options.RequiredLength = 6; options.RequireDigit = true; options.RequireNonAlphanumeric = true; options.RequireLowercase = true; options.RequiredUniqueChars = 2; }); services.AddSingleton <IStringLocalizerFactory>(NullStringLocalizerFactory.Instance); services.AddTransient(typeof(IStringLocalizer <>), typeof(StringLocalizer <>)); services.AddSingleton <IValidator <PasswordAttribute>, PasswordValidator>(); var command = new ChangePasswordCommand { UserName = "******", NewPassword = "******", }; await using var sp = services.BuildServiceProvider(); var validationEx = Assert.Throws <ValidationException>(() => DataAnnotationsValidator.Validate(command, sp)); Assert.IsType <ExtendedValidationResult>(validationEx.ValidationResult); Assert.IsType <PasswordAttribute>(validationEx.ValidationAttribute); Assert.Equal(new[] { nameof(command.NewPassword) }, validationEx.ValidationResult.MemberNames); }
public void UserChangePasswordTest() { using (var lifetime = container.BeginLifetimeScope()) { IUserRepository userRepository = lifetime.Resolve <IUserRepository>(); DefaultCommandBus commandBus = lifetime.Resolve <DefaultCommandBus>(); User user = userRepository.Get(c => c.Email == "*****@*****.**"); Assert.IsNotNull(user, "Error: User was not found"); ChangePasswordCommand command = new ChangePasswordCommand(); command.UserId = user.UserId; command.OldPassword = "******"; command.NewPassword = "******"; IValidationHandler <ChangePasswordCommand> validationHandler = lifetime.Resolve <IValidationHandler <ChangePasswordCommand> >(); IEnumerable <ValidationResult> validations = commandBus.Validate(command, validationHandler); foreach (var val in validations) { Assert.IsNull(val, "Error: User password change did not validate " + val.Message); } ICommandHandler <ChangePasswordCommand> commnadHandler = lifetime.Resolve <ICommandHandler <ChangePasswordCommand> >(); ICommandResult result = commandBus.Submit(command, commnadHandler); Assert.IsNotNull(result, "Error: User password change did not work"); Assert.IsTrue(result.Success, "Error: User password change did not work"); } }
public void Constructor_GiveValidArguments_PropertiesAreSet() { var command = new ChangePasswordCommand("current-password", "new-password"); Assert.Equal("current-password", command.CurrentPassword); Assert.Equal("new-password", command.NewPassword); }
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordCommand command) { command.UserId = int.Parse(GetUser(RequestExtensions.GetToken(Request.Headers["Authorization"].ToString())) ?? string.Empty); await _passwordService.ChangePassword(command); return(Ok()); }
public async Task <ActionResult> ChangePassword(ChangePasswordCommand command) { await _identityService.ChangePasswordAsync(command.Bind(c => c.UserId, UserId).UserId, command.CurrentPassword, command.NewPassword); return(NoContent()); }
public AccountController(GetUsersQuery getUsersQuery, ChangeDepartmentCommand changeDepartmentCommand, ChangePasswordCommand changePasswordCommand, AuthenticateUserCommand authenticateUserCommand, TaskExecutor.TaskExecutor taskExecutor) { this.authenticateUserCommand = authenticateUserCommand; this.changePasswordCommand = changePasswordCommand; this.changeDepartmentCommand = changeDepartmentCommand; this.getUsersQuery = getUsersQuery; this.taskExecutor = taskExecutor; }
public void Change_Password_With_Incorrect_Existing_Password() { var createClientCommand = new CreateClientCommand("test", "*****@*****.**", "123456", "brag", 23.565, 12.34, 1); ExecuteCommand(createClientCommand); var client = Session.QueryOver<Client>().FutureValue(); var changePasswordCommand = new ChangePasswordCommand(client.Value.Id, "987654", "456789"); ExecuteCommand(changePasswordCommand); Assert.IsFalse(changePasswordCommand.Result); }
private dynamic ChangePassword(ChangePasswordCommand command) { var commandResult = _commandInvokerFactory.Handle<ChangePasswordCommand, CommandResult>(command); if (commandResult.Success) { AddMessage("密码已经被成功修改", "success"); return View["ChangePassword"]; } AddMessage("修改密码过程中发生问题", "warning"); return View["ChangePassword"]; }
public JsonResult ChangePassword(ChangePasswordViewModel changePasswordView) { if (!ModelState.IsValid) { return Json(new { Success = false, Message = Resources.ValidationFailed }); } var command = new ChangePasswordCommand(UserInfo.Id, changePasswordView.CurrentPassword, changePasswordView.NewPassword); var result = ExecuteCommand(command); if (result) { TempData[ViewDataKeys.Message] = new SuccessMessage(Resources.PasswordChangeSuccess); return Json(new { Success = true }); } else { return Json(new { Success = false, Message = Resources.IncorrectCurrentPassword }); } }