public async Task ResetPassword(ResetUserPasswordCommand command)
{
command.Validate();
if (AddNotifications(command))
{
return;
}
LedgerIdentityUser user = await GetByEmail(command.Email);
if (NotifyNullUser(user))
{
return;
}
IdentityResult result = await _userManager.ResetPasswordAsync(user, command.ResetToken, command.NewPassword);
if (!result.Succeeded)
{
AddNotifications(result);
}
else
{
await PublishLocal(new UserResetedPasswordEvent(user.Email));
}
}
public async Task <ApiResponse> ResetPassword([FromBody] ResetUserPasswordCommand model)
{
model.ModifiedById = User.FindFirst(ClaimTypes.NameIdentifier).Value;
model.ModifiedDate = DateTime.UtcNow;
return(await _mediator.Send(model));
}
public async Task <IActionResult> ResetPassword([FromBody] ResetUserPasswordCommand command)
{
var(id, password) = await Mediator.Send(command);
return(Ok(await Mediator.Send(new SendResetedPasswordCommand {
UserId = id, Password = password
})));
}
public Task <JsonResult> PutResetPassword(int userId)
{
var command = new ResetUserPasswordCommand()
{
UserId = userId
};
return(_apiResponseHelper.RunCommandAsync(command));
}
public void Command_Instantiates_EmailUtils_As_EmailProvider_When_None_Passed_In()
{
// Setup
ResetUserPasswordCommand cmd = new ResetUserPasswordCommand(_unitOfWork);
// Verify
Assert.IsNotNull(cmd.EmailProvider, "Command's email provider was null");
Assert.AreEqual(typeof(EmailUtils), cmd.EmailProvider.GetType(), "Command's email provider was an incorrect type");
}
public void Execute_Returns_New_Password_For_User()
{
// Setup
InitializeTestEntities();
// Act
string newPass = new ResetUserPasswordCommand(_unitOfWork, _mock.Object).WithUserEmail(_user.Email).Execute();
User user = _unitOfWork.Users.Fetch().Single();
// Verify
Assert.IsTrue(PasswordUtils.CheckPasswordHash(user.Email, newPass, user.Password), "New password does not validate");
}
public async Task <IdentityResult> Handle(ResetUserPasswordCommand request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByEmailAsync(request.Email) ?? throw new NotFoundException(request.Email);
var result = await _userManager.ResetPasswordAsync(user, request.Code, request.Password);
if (result.Succeeded)
{
await _bus.Publish(new PasswordReset { InitiatorId = Guid.Parse(user.Id), TenantId = user.TenantId, TenantName = _identityService.GetTenantName() });
}
return(result);
}
public void Execute_Sends_Email_To_User()
{
// Setup
InitializeTestEntities();
// Act
string newPass = new ResetUserPasswordCommand(_unitOfWork, _mock.Object).WithUserEmail(_user.Email).Execute();
// Verify
_mock.Verify(x => x.Send(It.Is <string>(y => y == _user.Email),
It.IsAny <string>(),
It.Is <string>(y => y.Contains(newPass)),
It.IsAny <bool>(),
It.IsAny <string>()),
Times.Once());
}
public void ResetUserPasswordCommandHandler_Succeeds()
{
var handler = new ResetUserPasswordCommandHandler(_repository);
var command = new ResetUserPasswordCommand("*****@*****.**", "test", "test2");
var user = Substitute.For <User>();
user.Email.Returns("*****@*****.**");
user.Status.Returns(UserStatus.Active);
user.Password.Returns(new Password("test"));
user.PasswordResetToken.Returns(new TemporaryPassword("test"));
_context.Users.Add(user);
var result = handler.Execute(command);
result.Success.Should().BeTrue();
user.Received().ResetPassword("test2");
user.DidNotReceive().ResetPasswordFailed();
}
public void ResetUserPasswordCommandHandler_Throws_Exception_For_Invalid_User()
{
var handler = new ResetUserPasswordCommandHandler(_repository);
var command = new ResetUserPasswordCommand("*****@*****.**", "test", "test2");
var user = Substitute.For <User>();
user.Email.Returns("*****@*****.**");
user.Status.Returns(UserStatus.Inactive);
user.Password.Returns(new Password("test"));
user.PasswordResetToken.Returns(new TemporaryPassword("test"));
_context.Users.Add(user);
Action commandAction = () => {
var result = handler.Execute(command);
};
commandAction.Should().Throw <InvalidOperationException>();
user.DidNotReceive().ResetPassword(Arg.Any <string>());
user.DidNotReceive().ResetPasswordFailed();
}
public async Task ResetPasswordAsync(ResetUserPasswordCommand command)
{
if (NotifyCommandErrors(command))
{
return;
}
NutrientIdentityUser user = await _userManager.FindByEmailAsync(command.Email);
if (NotifyNullUser(user, command.Email))
{
return;
}
IdentityResult result = await _userManager.ResetPasswordAsync(user, command.ResetToken, command.NewPassword);
if (!result.Succeeded)
{
NotifyIdentityErrors(result);
}
}
public void ResetUserPasswordCommandHandler_Fails_For_Incorrect_Token()
{
var handler = new ResetUserPasswordCommandHandler(_repository);
var command = new ResetUserPasswordCommand("*****@*****.**", "wrong", "test2");
var user = Substitute.For <User>();
user.Email.Returns("*****@*****.**");
user.Status.Returns(UserStatus.Active);
user.Password.Returns(new Password("test"));
user.PasswordResetToken.Returns(new TemporaryPassword("test"));
_context.Users.Add(user);
var result = handler.Execute(command);
result.Errors.Should().HaveCount(1);
result.Errors[0].Expression.Should().BeNull();
result.Errors[0].Message.Should().Be("The password reset link has expired; please request a new one");
user.DidNotReceive().ResetPassword(Arg.Any <string>());
user.Received().ResetPasswordFailed();
}
public void ResetUserPasswordCommandHandler_Fails_For_Expired_Token()
{
var handler = new ResetUserPasswordCommandHandler(_repository);
var command = new ResetUserPasswordCommand("*****@*****.**", "test", "test2");
var user = Substitute.For <User>();
user.Email.Returns("*****@*****.**");
user.Status.Returns(UserStatus.Active);
user.Password.Returns(new Password("test"));
var token = new TemporaryPassword("test");
typeof(TemporaryPassword).GetProperty(nameof(TemporaryPassword.ExpiryDate)).SetValue(token, DateTime.UtcNow.AddSeconds(-60));
user.PasswordResetToken.Returns(token);
_context.Users.Add(user);
var result = handler.Execute(command);
result.Errors.Should().HaveCount(1);
result.Errors[0].Expression.Should().BeNull();
result.Errors[0].Message.Should().Be("The password reset link has expired; please request a new one");
user.DidNotReceive().ResetPassword(Arg.Any <string>());
user.Received().ResetPasswordFailed();
}
public async Task <ActionResult> ResetPasswordAsync([FromBody] ResetUserPasswordCommand command)
{
if (ModelState.IsValid)
{
User user = await userManager.FindByEmailAsync(command.Email);
if (user == null)
{
return(BadRequest());
}
string resetToken = await userManager.GeneratePasswordResetTokenAsync(user);
command.ResetToken = resetToken;
await pipelineService.HandleCommandAsync(command);
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> ResetPasswordAsync([FromBody] ResetUserPasswordCommand command)
{
await _accountService.ResetPasswordAsync(command);
return(CreateResponse());
}
public async Task <IActionResult> ResetPassword([FromBody] ResetUserPasswordCommand command)
{
await _userApplicationService.ResetPassword(command);
return(CreateResponse());
}
public async Task HandleResetUserPasswordAsync(ResetUserPasswordCommand userCommand)
{
User user = await userManager.FindByEmailAsync(userCommand.Email);
await userManager.ResetPasswordAsync(user, userCommand.ResetToken, userCommand.Password);
}
