public async Task <IActionResult> ConfirmEmailAsync([FromRoute] string id, [FromBody] ConfirmEmailCommand confirmEmailCommand)
{
confirmEmailCommand.Id = id;
await _mediator.Publish(confirmEmailCommand);
return(Ok());
}
public async Task <Result <bool> > Handle(ConfirmEmailCommand request, CancellationToken cancellationToken)
{
try
{
var user = await _userRepository.GetUserByEmail(request.Email);
if (user == null)
{
return(Result <bool> .BadRequest($"User with {request.Email} email doesn't exist!"));
}
if (user.IsConfirmed)
{
return(Result <bool> .BadRequest($"User is already activated!"));
}
var isValidToken = TokenHelper.IsValidToken(request.Token, user.PasswordSalt);
if (!isValidToken)
{
return(Result <bool> .BadRequest($"Activation link is not valid or expired!"));
}
user.IsConfirmed = true;
await _userRepository.Update(user);
return(Result <bool> .Ok(true));
}
catch (Exception e)
{
return(Result <bool> .Failure(e.Message));
}
}
public async Task <IActionResult> ConfirmEmail(ConfirmEmailCommand command)
{
var validation = ValidateCommand <ConfirmEmailCommand, ConfirmEmailCommandValidator>(command, v =>
{
v.RuleFor(c => c.Id.ToString()).Equal(User.Claims.FirstOrDefault(c => c.Value.Equals("userId"))?.Value);
});
if (!validation.IsValid)
{
return(BadRequest(validation.Errors));
}
var response = await _mediator.Send(command);
if (!response.UserExists)
{
return(BadRequest(new string[] { "User doesn't exist" }));
}
if (response.EmailAlreadyConfirmed.Value)
{
return(BadRequest(new string[] { "User email is already confirmed" }));
}
if (!response.IsPasswordCorrect.Value)
{
return(BadRequest(new string[] { "Password is incorrect" }));
}
return(Ok());
}
public async Task <Response <bool> > Handle(ConfirmEmailCommand request, CancellationToken cancellationToken)
{
var user = await userManager.FindByIdAsync(request.UserId);
if (user != null && user.EmailConfirmed == false)
{
return(await ConfirmEmailAsync(user, request.Token));
}
return(Response.Fail <bool>("کاربری با چنین مشخصاتی یافت نشد", StatusCodeEnum.NOTAUTHORIZE));
}
public async Task <IActionResult> CONFIRM_CODE([FromQuery] ConfirmEmailCommand command)
{
var response = await _mediator.Send(command);
if (response.Status.IsSuccessful)
{
return(Ok(response));
}
return(BadRequest(response));
}
public async Task <IActionResult> ConfirmEmail(string userId, string token)
{
var command = new ConfirmEmailCommand
{
UserId = userId,
Token = token
};
return(await _mediator.Send(command));
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmEmailCommand registerCommand)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _mediator.Send(registerCommand);
return(StatusCodeResult(result));
}
public async Task <ActionResult <User> > ConfirmEmail(string userId, string emailConfirmationCode)
{
var confirmEmailQuery = new ConfirmEmailCommand
{
UserId = userId,
EmailConfirmationCode = emailConfirmationCode
};
var user = await _mediator.Send(confirmEmailQuery);
return(Ok(user));
}
public void ShoulBeErrors_WhenFieldsAreNullOrEmpty(string id, string token)
{
var command = new ConfirmEmailCommand()
{
Id = id,
Token = token
};
var result = _validator.TestValidate(command);
result.ShouldHaveValidationErrorFor(command => command.Id);
result.ShouldHaveValidationErrorFor(command => command.Token);
}
public async Task Handle(ConfirmEmailCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
NotifyValidationErrors(request);
return;
}
var result = await _userService.ConfirmEmailAsync(request.Email, request.Code);
if (result.HasValue)
{
await Bus.RaiseEvent(new EmailConfirmedEvent(request.Email, request.Code, result.Value));
}
}
public async Task <IActionResult> ConfirmEmail(ConfirmEmailCommand command)
{
if (!ModelState.IsValid)
{
return(ErrorModelResult());
}
try {
var result = await _commandDispatcher.DispatchAsync <ConfirmEmailCommand, Result>(command);
return(ToResult(result));
}
catch (FailureResult reqEx)
{
return(ErrorResult(reqEx));
}
}
public ConfirmEmailCommandHandlerTests(AuthenticationFixture fixture)
{
_mockUserManager = fixture.UserManager;
_mockJwtGenerator = fixture.JwtGenerator;
_mockEventBus = fixture.EventBus;
_mockFailedIdentityResult = fixture.FailedIdentityResult;
_user = fixture.TestUser;
_user.EmailConfirmed = true;
_userId = "100kjdkwdu8";
_emailConfirmationToken = "1010d1d120e";
_command = new ConfirmEmailCommand
{
UserId = _userId,
EmailConfirmationCode = "1092093dk0230-2"
};
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmEmailCommand request)
{
var authResult = await _mediator.Send(request);
if (authResult.Success is false)
{
if (authResult.Message is "Email not found")
{
return(NotFound(new
{
authResult.Success,
authResult.Message
}));
}
return(BadRequest(new
{
authResult.Success,
authResult.Message
}));
}
return(Ok(authResult.Message));
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmEmailCommand command)
{
return(Created(CurrentUri, await Mediator.Send(command)));
}
public async Task <IActionResult> ConfirmEmailAsync([FromQuery] string userName, [FromQuery] string code)
{
var command = ConfirmEmailCommand.CreateFromInput(userName, code, CurrentUser);
return(Ok(await Mediator.Send(command)));
}
public async Task <IActionResult> Confirm(ConfirmEmailCommand model)
{
await this.Mediator.Send(model);
return(this.Ok());
}
public async Task <Response <bool> > confirmEmail([FromBody] ConfirmEmailCommand command)
{
return(await mediator.Send(command));
}
public async Task <IActionResult> ConfirmEmail([FromQuery] ConfirmEmailCommand command)
{
return(await _mediator.ExecuteCommandReturnActionResult(command));
}
