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 });
}
}
