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