public async Task <Unit> Handle(ChangeUserPasswordCommand request, CancellationToken cancellationToken)
{
var original = await userRepository.GetAsync(request.Id); // -> Get entity from db.
if (original == null) // -> If it is null, notificate and stop to avoid null exception.
{
await bus.InvokeDomainNotificationAsync("Not found.");
return(Unit.Value);
}
request // -> Data validadtion
.IsNullEmptyOrWhitespace(e => e.Password, async() => await bus.InvokeDomainNotificationAsync("Invalid password."))
.Is(e => e.PasswordConfirmation != e.Password, async() => await bus.InvokeDomainNotificationAsync("Invalid password confirmation."));
// -> Set new info
original.ChangePassword(request.Password);
// -> Db persist
await userRepository.UpdateAsync(original);
Commit();
await bus.InvokeAsync(new ChangeUserPasswordEvent(original.Id, original.Password));
return(Unit.Value);
}
public async Task Handler_should_update_password_for_user()
{
//Arrange
var fakeUser = new User
{
Id = Guid.NewGuid().ToString(),
};
var password = "******";
var passwordHash = new PasswordHasher <User>().HashPassword(fakeUser, password);
_userManagerMock.Setup(x => x.FindByIdAsync(fakeUser.Id)).Returns(Task.FromResult(fakeUser));
_userManagerMock.Setup(x => x.IsInRoleAsync(fakeUser, AuthSettings.Roles.Supervisor))
.Returns(Task.FromResult(false));
var cancellationToken = new CancellationToken();
var command = new ChangeUserPasswordCommand(fakeUser.Id, password, password);
var handler =
new ChangeUserPasswordCommandHandler(_userManagerMock.Object);
//Act
await handler.Handle(command, cancellationToken);
//Assert
Assert.NotEqual(passwordHash, fakeUser.PasswordHash);
}
public void ChangeUserPassword(ChangeUserPasswordCommand command)
{
var user = GetExistingUser(command.TenantId, command.Username);
user.ChangePassword(command.CurrentPassword, command.ChangedPassword);
this.unitOfWork.Commit();
}
public async Task Handler_manager_should_update_user()
{
//Arrange
var password = "******";
var fakeUser = new User
{
Id = Guid.NewGuid().ToString(),
};
_userManagerMock.Setup(x => x.FindByIdAsync(fakeUser.Id)).Returns(Task.FromResult(fakeUser));
_userManagerMock.Setup(x => x.IsInRoleAsync(fakeUser, AuthSettings.Roles.Supervisor))
.Returns(Task.FromResult(false));
var cancellationToken = new CancellationToken();
var command = new ChangeUserPasswordCommand(fakeUser.Id, password, password);
var handler =
new ChangeUserPasswordCommandHandler(_userManagerMock.Object);
//Act
await handler.Handle(command, cancellationToken);
//Assert
_userManagerMock.Verify(x => x.UpdateAsync(It.Is <User>(it => it == fakeUser)), Times.Once);
}
public async Task <ApiResponse> ChangePassword([FromBody] ChangeUserPasswordCommand model)
{
model.ModifiedById = User.FindFirst(ClaimTypes.NameIdentifier).Value;
model.ModifiedDate = DateTime.UtcNow;
return(await _mediator.Send(model));
}
public async Task ChangePassword(ChangeUserPasswordCommand command)
{
command.Validate();
if (AddNotifications(command))
{
return;
}
LedgerIdentityUser user = await GetByEmail(command.Email);
if (NotifyNullUser(user))
{
return;
}
IdentityResult result = await _userManager.ChangePasswordAsync(user, command.Password, command.NewPassword);
if (!result.Succeeded)
{
AddNotifications(result);
}
else
{
await PublishLocal(new UserChangedPasswordEvent(user.Email));
}
}
public void ChangeUserPassword(Guid userId, string password)
{
userContext.CheckPermission(Permissions.UserMaintenance);
var command = new ChangeUserPasswordCommand(userId, password);
commandBus.Value.Send(Envelope.Create(command));
}
public ActionResult ChangePassword(ChangeUserPasswordCommand command)
{
if (ModelState.IsValid)
{
this.dispatcher.Push(command);
return(RedirectToAction("ChangePasswordByEmailSuccess", "Account"));
}
return(View(command));
}
public void Handle(ChangeUserPasswordCommand command)
{
List <Domain.User> users = _userDao.GetUsersByPersonIntegrationCode(command.IntegrationCode);
foreach (var item in users)
{
var repository = this.contextFactory();
Domain.User user = repository.Get(x => x.UserId == item.UserId);
user.LoginPassword = command.Password;
user.UserHistory.Add(this.CreateUserHistory(user));
repository.Update(user);
}
}
public async Task <IActionResult> ChangePassword(ChangeUserPasswordCommand command)
{
var id = Guid.Parse(HttpContext.User.FindFirstValue(JwtRegisteredClaimNames.Sid));
var result = await _handler.Handle(command, id);
if (!_handler.IsValid())
{
return(BadRequest(_handler.GetErrors()));
}
return(Ok(result));
}
public async Task <IActionResult> ChangePassword([FromBody] ChangeUserPasswordCommand command)
{
if (command == null)
{
return(BadRequest());
}
var response = await _mediator.Send(command);
if (response.Errors.Any())
{
return(BadRequest(response));
}
return(Ok(response));
}
public async Task Handler_should_throw_not_found_exception_if_user_doesnt_exist()
{
//Arrange
_userManagerMock.Setup(x => x.FindByIdAsync(Guid.NewGuid().ToString())).Returns(Task.FromResult <User>(null));
_userManagerMock.Setup(x => x.Users).Returns(_identityDataContextMock.Object.Users);
var cancellationToken = new CancellationToken();
var command = new ChangeUserPasswordCommand("123", "123", "123");
var handler =
new ChangeUserPasswordCommandHandler(_userManagerMock.Object);
//Act
Task Act() => handler.Handle(command, cancellationToken);
//Assert
await Assert.ThrowsAsync <UserNotFoundException>(Act);
}
public void ChangeUserPasswordCommandHandler_Succeeds()
{
var handler = new ChangeUserPasswordCommandHandler(_repository);
var command = new ChangeUserPasswordCommand("*****@*****.**", "test", "test2");
var user = Substitute.For <User>();
user.Email.Returns("*****@*****.**");
user.Password.Returns(new Password("test"));
user.Status.Returns(UserStatus.Active);
_context.Users.Add(user);
var result = handler.Execute(command);
result.Success.Should().BeTrue();
user.Received().ChangePassword("test2");
user.DidNotReceive().ChangePasswordFailed();
}
public async Task <ICommandResult> Handle(ChangeUserPasswordCommand command, Guid id)
{
if (!command.IsValid())
{
AddNotifications(command.Notifications);
return(null);
}
var user = await _userRepository.GetById(id);
var sha256 = SHA256.Create();
var hashedBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(command.Password));
var passwordHashed = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
user.Password = passwordHashed;
await _userRepository.Commit();
return(new ChangeUserPasswordCommandResult());
}
public async Task change_password_returns_unathorized_if_old_password_does_not_match(string oldPassword)
{
//Given
HttpClient client = await CreateAuthorizedClient();
var changePasswordCommand = new ChangeUserPasswordCommand()
{
CurrentPassword = oldPassword,
NewPassword = "******"
};
var payload = GetPayload(changePasswordCommand);
//When
var response = await client.PutAsync(Url("password"), payload);
//Then
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.Unauthorized);
}
public async Task Handle(ChangeUserPasswordCommand command)
{
try
{
var user = await Repository.GetByKeyAsync<Domain.Models.User>(command.UserId);
user.ChangePassword(command.Password);
await Repository.SaveChangesAsync();
var @event = new UserPasswordChangedEvent(command.UserId);
EventBus.RaiseEvent(@event);
}
catch (Exception ex)
{
var @event = new UserPasswordNotChangedEvent(command.UserId, ex.Message);
EventBus.RaiseEvent(@event);
throw;
}
}
public void ChangeUserPasswordCommandHandler_Throws_Exception_For_Invalid_User()
{
var handler = new ChangeUserPasswordCommandHandler(_repository);
var command = new ChangeUserPasswordCommand("*****@*****.**", "test", "test2");
var user = Substitute.For <User>();
user.Email.Returns("*****@*****.**");
user.Password.Returns(new Password("test"));
user.Status.Returns(UserStatus.Inactive);
_context.Users.Add(user);
Action commandAction = () => {
var result = handler.Execute(command);
};
commandAction.Should().Throw <InvalidOperationException>();
user.DidNotReceive().ChangePassword(Arg.Any <string>());
user.DidNotReceive().ChangePasswordFailed();
}
public void ChangeUserPasswordCommandHandler_Fails_For_Wrong_Password()
{
var handler = new ChangeUserPasswordCommandHandler(_repository);
var command = new ChangeUserPasswordCommand("*****@*****.**", "wrong", "test2");
var user = Substitute.For <User>();
user.Email.Returns("*****@*****.**");
user.Password.Returns(new Password("test"));
user.Status.Returns(UserStatus.Active);
_context.Users.Add(user);
var result = handler.Execute(command);
result.Errors.Should().HaveCount(1);
result.Errors[0].Expression.ToString().Should().Be("p => p.CurrentPassword");
result.Errors[0].Message.Should().Be("Invalid password");
user.DidNotReceive().ChangePassword(Arg.Any <string>());
user.Received().ChangePasswordFailed();
}
public async Task change_password_on_unathorized_request_returns_unathorized_code()
{
//Given
var client = Factory.CreateClient();
var user = await AddUserWithoutInvestorToRepoAndGetAsync();
var changePasswordCommand = new ChangeUserPasswordCommand()
{
CurrentPassword = user.Password,
NewPassword = "******"
};
var payload = GetPayload(changePasswordCommand);
//When
var response = await client.PutAsync(Url("password"), payload);
//Then
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.Unauthorized);
}
public async Task <IActionResult> ChangePassword([FromBody] PasswordChangePutModel passwordChangePutModel)
{
Guid userIdFromToken = GetUserIdFromToken();
if (userIdFromToken != passwordChangePutModel.UserId)
{
ModelStateDictionary mds = new ModelStateDictionary();
mds.AddModelError("Password", "Password cannot be changed for different user.");
return(BadRequest(mds));
}
ChangeUserPasswordCommand changeUserPasswordCommand = new ChangeUserPasswordCommand
{
UserId = userIdFromToken,
Password = passwordChangePutModel.NewPassword
};
await _commandBus.Send(changeUserPasswordCommand);
return(Ok());
}
public async Task ChangePasswordAsync(ChangeUserPasswordCommand command)
{
if (NotifyCommandErrors(command))
{
return;
}
NutrientIdentityUser user = await _userManager.FindByIdAsync(command.UserId.ToString());
if (NotifyNullUser(user, command.UserId.ToString()))
{
return;
}
IdentityResult result = await _userManager.ChangePasswordAsync(user, command.Password, command.NewPassword);
if (!result.Succeeded)
{
NotifyIdentityErrors(result);
}
}
public async Task change_password_on_success_returns_no_content()
{
//Given
var user = await AddUserWithoutInvestorToRepoAndGetAsync();
HttpClient client = await CreateAuthorizedClient(user);
var changePasswordCommand = new ChangeUserPasswordCommand()
{
CurrentPassword = user.Password,
NewPassword = "******"
};
var payload = GetPayload(changePasswordCommand);
//When
var response = await client.PutAsync(Url("password"), payload);
//Then
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.NoContent);
}
public async Task change_password_returns_bad_request_if_new_password_is_not_valid(string newPw)
{
//Given
var user = await AddUserWithoutInvestorToRepoAndGetAsync();
HttpClient client = await CreateAuthorizedClient(user);
var changePasswordCommand = new ChangeUserPasswordCommand()
{
CurrentPassword = user.Password,
NewPassword = newPw
};
var payload = GetPayload(changePasswordCommand);
//When
var response = await client.PutAsync(Url("password"), payload);
//Then
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.BadRequest);
}
public async Task Handler_should_return_true()
{
//Arrange
var fakeUser = new User
{
Id = Guid.NewGuid().ToString()
};
_userManagerMock.Setup(x => x.FindByIdAsync(fakeUser.Id)).Returns(Task.FromResult(fakeUser));
_userManagerMock.Setup(x => x.IsInRoleAsync(fakeUser, AuthSettings.Roles.Supervisor))
.Returns(Task.FromResult(false));
var cancellationToken = new CancellationToken();
var command = new ChangeUserPasswordCommand(fakeUser.Id, "123", "123");
var handler =
new ChangeUserPasswordCommandHandler(_userManagerMock.Object);
//Act
var result = await handler.Handle(command, cancellationToken);
//Assert
Assert.True(result);
}
public async Task <IActionResult> UpdateUserPassword(int id,
[FromBody] UserForPasswordUpdateDto userForPasswordUpdate)
{
if (userForPasswordUpdate == null)
{
ModelState.AddModelError("Message", "Unable to locate payload for new request");
return(BadRequest(ModelState));
}
var command = new ChangeUserPasswordCommand(id, userForPasswordUpdate.Password);
_logger.LogInformation(
"----- Sending command: ChangeUserPasswordCommand - {userId}",
command.UserId);
var commandResult = await _mediator.Send(command);
if (!commandResult)
{
return(BadRequest("Command not created"));
}
return(Ok());
}
public async Task Handler_should_throw_unable_to_change_state_exception_if_user_is_supervisor()
{
//Arrange
var fakeUser = new User
{
Id = Guid.NewGuid().ToString()
};
_userManagerMock.Setup(x => x.FindByIdAsync(fakeUser.Id)).Returns(Task.FromResult(fakeUser));
_userManagerMock.Setup(x => x.IsInRoleAsync(fakeUser, AuthSettings.Roles.Supervisor))
.Returns(Task.FromResult(true));
var cancellationToken = new CancellationToken();
var command = new ChangeUserPasswordCommand(fakeUser.Id, "123", "123");
var handler =
new ChangeUserPasswordCommandHandler(_userManagerMock.Object);
//Act
Task Act() => handler.Handle(command, cancellationToken);
//Assert
await Assert.ThrowsAsync <UserUnableToChangeStateException>(Act);
}
public async Task <IActionResult> Put([FromBody] ChangeUserPasswordCommand command)
{
await Send(command);
return(NoContent());
}
public async Task <IActionResult> ChangePasswordAsync([FromBody] ChangeUserPasswordCommand command)
{
await _accountService.ChangePasswordAsync(command);
return(CreateResponse());
}
public void Put(ChangeUserPasswordCommand command)
{
_changeUserPasswordCommandHandler.Handle(command);
}
public async Task <IActionResult> ChangePassword([FromBody] ChangeUserPasswordCommand command)
{
await _userApplicationService.ChangePassword(command);
return(CreateResponse());
}
public async Task <IActionResult> ChangePassword([FromBody] ChangeUserPasswordCommand command)
{
await bus.SendAsync(command);
return(Response());
}
