public async Task <IActionResult> RefreshAsync([FromRoute] string refreshToken)
{
var command = new RefreshTokenCommand(refreshToken, DateTime.Now);
var result = await _bus.Send(command);
return(Ok(_mapper.Map <TokenResponse>(result)));
}
public async Task <ResultWrapper <RefreshTokenOutput> > Handle(RefreshTokenCommand request, CancellationToken cancellationToken)
{
ResultWrapper <RefreshTokenOutput> refreshTokenOutput = new ResultWrapper <RefreshTokenOutput>();
RefreshTokenRequest refreshTokenReq = new RefreshTokenRequest()
{
refresh_token = request.RefreshToken,
grant_type = AppEnums.FireBaseRequestEnum.refresh_token.ToString(),
};
ResultWrapper <RefreshTokenResponse> refreshTokenResult = await _fireBaseTool.RefreshToken(refreshTokenReq);
if (!refreshTokenResult.Status)
{
refreshTokenOutput.Status = false;
refreshTokenOutput.Message = refreshTokenResult.Message;
return(refreshTokenOutput);
}
refreshTokenOutput.Status = true;
refreshTokenOutput.Result = new RefreshTokenOutput()
{
Token = refreshTokenResult.Result.id_token,
RefreshToken = refreshTokenResult.Result.refresh_token
};
return(refreshTokenOutput);
}
public async Task <ActionResult> RefreshAccessToken([FromBody] RefreshAccessTokenDto refreshAccessTokenDto)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
if (!Request.Cookies.TryGetValue("X-Refresh-Token", out var refreshToken))
{
return(BadRequest());
}
var email = refreshAccessTokenDto.Email;
if (string.IsNullOrEmpty(email) || refreshToken == null)
{
return(BadRequest());
}
var command = new RefreshTokenCommand(email, refreshToken);
var result = await _mediator.Send(command);
if (result.Value == null)
{
return(new BadRequestObjectResult(result.ErrorMessages));
}
AddCookie("X-Access-Token", result.Value.Token);
AddCookie("X-Refresh-Token", result.Value.RefreshToken);
return(new OkObjectResult(result.Value));
}
public async Task Handle_Should_Succeed()
{
var user = new User("*****@*****.**", "firstname", "lastname", false, "salt", "password", DateTime.UtcNow, DateTime.UtcNow);
var token = "token generated by login process";
var refreshToken = "refresh token";
_userRepositoryMock.Setup(m => m.Get(It.IsAny <string>()))
.ReturnsAsync(user);
_refreshTokenRepositoryMock.Setup(m => m.GetRefreshToken(user.Email))
.ReturnsAsync(refreshToken);
_tokenServiceMock.Setup(m => m.GenerateToken(It.IsAny <UserInfo>()))
.Returns(token);
var command = new RefreshTokenCommand("*****@*****.**", refreshToken);
var result = await _handler.Handle(command, GetCancellationToken());
result.Should().NotBeNull();
result.Value.Should().NotBeNull();
result.ErrorMessages.Should().BeEmpty();
result.Value.Token.Should().Be(token);
result.Value.RefreshToken.Should().NotBeNull();
}
public async Task Should_RefreshToken()
{
var client = _factory.CreateClient();
var user = await _factory.Util.GetUser();
var refreshToken = new RefreshTokenFake(user).Builder.Generate();
await _factory.Util.SaveEntity(refreshToken);
var request = new RefreshTokenCommand()
{
Token = refreshToken.Token
};
var json = _factory.Util.AsJsonContent(request);
var response = await client.PostAsync("api/refresh_token", json);
response.EnsureSuccessStatusCode();
var responseMessage = await response.Content.ReadAsStringAsync();
var refreshTokenResponse = _factory.Util.Deserialize <RefreshTokenResponse>(responseMessage);
Assert.NotNull(refreshTokenResponse);
Assert.NotNull(refreshTokenResponse.AccessToken);
Assert.NotEmpty(refreshTokenResponse.AccessToken.Token);
Assert.NotNull(refreshTokenResponse.RefreshToken);
Assert.NotEmpty(refreshTokenResponse.AccessToken.Token);
}
public async Task <IActionResult> GetRefreshToken([FromQuery] string token)
{
var cmd = new RefreshTokenCommand(this.currentUser, token);
var result = await this.mediator.Send(cmd);
return(this.Ok(new { token = result }));
}
public async Task <IActionResult> RefreshToken([FromBody] RefreshTokenCommand model)
{
ResultWrapper <RefreshTokenOutput> result = new ResultWrapper <RefreshTokenOutput>();
result = await _mediator.Send(model);
return(Ok(result));
}
public async Task <ActionResult <AuthenticateResponse> > RefreshToken([FromBody] RefreshTokenRequest model, CancellationToken cancellationToken)
{
var refreshToken = model.RefreshToken ?? Request.Cookies["refreshToken"];
var command = new RefreshTokenCommand(refreshToken);
await _commandProcessor.SendAsync(command, cancellationToken : cancellationToken);
setTokenCookie(command.Response.RefreshToken);
return(Ok(_accountRenderer.Render(command.Response)));
}
public async Task <IActionResult> Handle(RefreshTokenCommand request)
{
var response = await Mediator.Send(request);
return(Ok(new {
AccessToken = response.AccessToken,
RefreshToken = response.RefreshToken,
Message = "Token refrescado con éxito"
}));
}
public async Task <IActionResult> Refresh([FromBody] RefreshTokenCommand command)
{
var result = await Mediator.Send(command);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result.Errors));
}
public async Task <Result <UserToken> > Handle(RefreshTokenCommand request, CancellationToken cancellationToken)
{
var errors = new List <string>();
var user = await _userRepository.Get(request.Email);
if (user == null)
{
errors.Add(Invalid_Refresh_Token);
return(new Result <UserToken>(default, default, errors));
public async Task Handle_Should_ReturnErorIfUserNotFound()
{
var command = new RefreshTokenCommand("*****@*****.**", "refresh token");
var result = await _handler.Handle(command, GetCancellationToken());
result.Should().NotBeNull();
result.Value.Should().BeNull();
result.ErrorMessages.Should().Contain(RefreshTokenCommandHandler.Invalid_Refresh_Token);
}
public async Task <Result <RefreshTokenResponse> > Handle(RefreshTokenCommand request, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var claimsPrincipal = _tokenFactory.GetPrincipalFromExpiredToken(request.AccessToken);
var dto = await _tokenFactory.GenerateToken(claimsPrincipal.Identity.Name, request.AccessToken, request.RefreshToken, cancellationToken);
return(Result.Ok(_autoMapper.Map <RefreshTokenResponse>(dto)));
}
public async Task <TokenResponse> Refresh(RefreshTokenCommand refreshTokenCommand)
{
try
{
return(await _mediator.Send(refreshTokenCommand));
}
catch (Exception ex)
{
throw;
}
}
public async Task <ActionResult <AuthenticationVM> > Refresh([FromBody] RefreshTokenCommand command)
{
AuthenticationVM authenticationVM = await CommandAsync(command);
if (!authenticationVM.Success)
{
return(BadRequest(authenticationVM));
}
return(Ok(authenticationVM));
}
public async Task RefreshTokenAsync(RefreshTokenCommand refreshTokenCommand)
{
var userId = await _tokenRepository.GetUserIdAsync(refreshTokenCommand.RefreshToken);
var tokenCommand = new GetTokenCommand()
{
IdRequest = refreshTokenCommand.IdRequest,
UserId = userId
};
await GenerateTokenAsync(tokenCommand);
}
public async Task <IActionResult> RefreshToken([FromBody] RefreshTokenCommand command)
{
var idRequest = RequestExtension.GenerateIdRequest();
command.IdRequest = idRequest;
await _tokenService.RefreshTokenAsync(command);
var token = _tokenService.GetToken(idRequest);
return(Ok(token));
}
public async Task RefreshToken_AoSolicitarUmNovoTokenComComandoInvalido_RetornarNotificacoesComFalha()
{
// Arrange
var command = new RefreshTokenCommand("", "", "");
// Act
var responseResult = await _handler.Handle(command, CancellationToken.None);
// Assert
Assert.True(responseResult.HasFails);
Assert.Equal(4, responseResult.Fails.Count());
}
public async Task <IActionResult> RefreshToken(RefreshTokenRequest request)
{
var command = new RefreshTokenCommand
{
Token = request.Token,
RefreshToken = request.RefreshToken.Trim()
};
var result = await _mediator.Send(command);
return(Ok(result));
}
public async Task <IActionResult> RefreshTokenAsync()
{
var refreshToken = Request.Cookies["refresh-token"];
var command = RefreshTokenCommand.CreateFromInput(refreshToken, CurrentUser);
IdentityResponseDto result = await Mediator.Send(command);
if (!string.IsNullOrEmpty(result.RefreshToken))
{
SetRefreshTokenInCookie(result.RefreshToken, result.RefreshTokenExpiration);
}
return(Ok(result));
}
public async Task <IActionResult> RefreshToken([FromBody] RefreshTokenCommand command)
{
var result = await _dispatcher.DispatchAsync(command);
if (result.Succeeded)
{
return(Ok(result));
}
else
{
return(BadRequest(result));
}
}
public async Task ShouldRegisterAndAuthenticateUserUsingCommands()
{
// Arrange (Sign-up, create user)
var command = new SignUpUserCommand
{
First = "Long",
Last = "Le",
Email = Email,
Password = Password
};
var mediator = _provider.GetService <IMediator>();
// Act
var user = await mediator.Send(command);
// Assert
user.ShouldBeOfType <User>();
user.Email.ShouldBe(Email);
user.Token.ShouldNotBeNull();
user.Token.ShouldNotBeEmpty();
// Arrange (Login, created user)
var loginUserCommand = new LoginUserCommand
{
Email = user.Email,
Password = Password
};
// Act
user = await mediator.Send(loginUserCommand);
/// Assert
user.ShouldBeOfType <User>();
user.Email.ShouldBe(Email);
user.Token.ShouldNotBeNull();
user.Token.ShouldNotBeEmpty();
// Arrange (Refresh Token)
var refreshTokenCommand = new RefreshTokenCommand
{
Token = user.Token,
RefreshToken = user.RefreshToken
};
var refresh = await mediator.Send(refreshTokenCommand);
refresh.Token.ShouldNotBeNullOrEmpty();
refresh.RefreshToken.ShouldNotBeNullOrEmpty();
}
public async Task Handle_Should_ReturnErorIfTokenIsNotFound()
{
var user = new User("*****@*****.**", "firstname", "lastname", false, "salt", "password", DateTime.UtcNow, DateTime.UtcNow);
_userRepositoryMock.Setup(m => m.Get(It.IsAny <string>()))
.ReturnsAsync(user);
var command = new RefreshTokenCommand("*****@*****.**", "refresh token");
var result = await _handler.Handle(command, GetCancellationToken());
result.Should().NotBeNull();
result.Value.Should().BeNull();
result.ErrorMessages.Should().Contain(RefreshTokenCommandHandler.Invalid_Refresh_Token);
}
public async Task <CurrentUserResource> RefreshTokenAsync(RefreshTokenCommand command)
{
var json = JsonConvert.SerializeObject(command);
var requestMessage = new HttpRequestMessage(HttpMethod.Post, "Login");
requestMessage.Content = new StringContent(json);
requestMessage.Content.Headers.ContentType =
new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
var response = await _httpClient.SendAsync(requestMessage);
var statusCode = response.StatusCode;
var responseBody = await response.Content.ReadAsStringAsync();
var userResource = JsonConvert.DeserializeObject <CurrentUserResource>(responseBody);
return(await Task.FromResult(userResource));
}
public async Task <ApiResponse> Refresh([FromBody] RefreshTokenCommand command)
{
LoginRequestCommandResponse commandResponse = await this._refreshTokenCommandHandler.Handle(command);
if (commandResponse.ValidationResult.IsValid)
{
var response = ApiResponse.CreateSuccess(new
{
token = commandResponse.AccessToken,
refreshToken = commandResponse.RefreshToken
});
return(response);
}
else
{
return(ApiResponse.CreateError(commandResponse.ValidationResult));
}
}
public async Task RefreshToken_AoSolicitarUmNovoTokenComRefreshTokenInvalido_RetornarNotificacoesComFalha()
{
// Arrange
var command = new RefreshTokenCommand("*****@*****.**", "123", "123");
//Obter usuario
var usuarioId = Guid.NewGuid();
var usuario = Usuario.Criar("test", "*****@*****.**", 0, 0, UsuarioRole.Cliente);
usuario.AdicionarRefreshToken("invalido", DateTime.Now);
_mocker.GetMock <IUnitOfWork>()
.Setup(p => p.Usuarios.ObterPorEmailAsync(usuario.Email))
.Returns(Task.FromResult(usuario));
// Act
var responseResult = await _handler.Handle(command, CancellationToken.None);
// Assert
Assert.True(responseResult.HasFails);
}
public async Task <ActionResult <ResponseResult> > Refresh([FromBody] RefreshTokenCommand command)
{
var principal = ObterClaimsTokenExpirado(command.Token);
var email = principal.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Email)?.Value;
if (email != command.Email)
{
var responseEmail = new ResponseResult();
responseEmail.AddNotification(new Notification("refresh_token", "email não autorizado"));
return(BadRequest(responseEmail.Fails));
}
var response = await EventBus.SendCommand(command);
if (response.HasFails)
{
return(BadRequest(response.Fails));
}
return(Ok(response.Data));
}
public async Task <Result <UserAuthenticatedDto> > Handle(RefreshTokenCommand request,
CancellationToken cancellationToken)
{
var user = await _userRepository.GetAsync(u => u.Id == request.UserId);
user.SessionId = Guid.NewGuid().ToString();
var userDto = _mapper.Map <UserDto>(user);
var refreshTokenInDb = await
_tokenRepository.GetAsync(t => t.User.Id == request.UserId && t.Token == request.Token.Name);
refreshTokenInDb.CheckForNull();
IsValid(refreshTokenInDb);
var jwtToken = JwtExtensions.GenerateJwtToken(userDto, _tokenConfiguration);
var tokenString = JwtExtensions.GenerateRefreshToken();
var userInDb = _mapper.Map <User>(user);
var refreshToken = new RefreshToken
{
Id = Guid.NewGuid().ToString(),
DateCreated = DateTime.UtcNow,
DateExpires = DateTime.UtcNow.AddMinutes(_tokenConfiguration.RefreshTokenExpirationMinutes),
Token = tokenString,
User = userInDb
};
await _tokenRepository.CreateAsync(refreshToken);
await _tokenRepository.DeleteAsync(t => t.Id == refreshTokenInDb.Id);
await _sender.PublishAsync(new UpdatedUser(user), cancellationToken);
await _sender.PublishAsync(new CreatedToken(refreshToken), cancellationToken);
UserAuthenticatedDto authenticatedDto = new(userDto, jwtToken, refreshToken.Token);
return(Result <UserAuthenticatedDto> .Success(authenticatedDto));
}
public async Task Usuario_RevalidaToken_RetornarToken200Sucesso()
{
//Arrange
// Criar Usuario
var criarUsuarioCommand = new CriarUsuarioCommand("*****@*****.**", "Maria", -23.5950753, -46.645421, "Admin123@");
await _testsFixture.Client.PostAsJsonAsync("/api/usuarios/registrar", criarUsuarioCommand);
//Logar Usuario
var loginUsuarioCommand = new LoginUsuarioCommand("*****@*****.**", "Admin123@");
var response = await _testsFixture.Client.PostAsJsonAsync("/api/usuarios/login", loginUsuarioCommand);
var data = await response.Content.ReadAsStringAsync();
var jwtDto = JsonConvert.DeserializeObject <JsonWebTokenTestDto>(data);
var refToken = new RefreshTokenCommand(jwtDto.Email, jwtDto.Jwt.Token, jwtDto.Jwt.RefreshToken.Token);
// Act
var responseRefresh = await _testsFixture.Client.PostAsJsonAsync("/api/usuarios/refresh", refToken);
// Assert
responseRefresh.EnsureSuccessStatusCode();
}
public Task <AuthToken> Handle(RefreshTokenCommand request, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
