public async Task <IdentityToken> CreateAccessTokenAsync(string token)
{
var refreshToken = await _refreshTokenRepository.GetAsync(token);
if (refreshToken == null)
{
throw new ServiceException("refresh_token_not_found", $"Refresh token was not found.");
}
if (refreshToken.Revoked)
{
throw new ServiceException("refresh_token_not_revoked", $"Refresh token: '{refreshToken.Id.ToString()}' was revoked");
}
var user = await _userRepository.GetAsync(refreshToken.UserId);
if (user == null)
{
throw new ServiceException("user_not_found", $"User: '******' was not found.");
}
var jwt = _jwtHandler.CreateToken(user.Id, user.Role);
return(new IdentityToken
{
AccessToken = jwt.AccessToken,
Expires = jwt.Expires,
RefreshToken = refreshToken.Token,
Role = user.Role,
UserId = user.Id
});
}
public async Task <AuthDto> UseAsync(string refreshToken)
{
var token = await _refreshTokenRepository.GetAsync(refreshToken);
if (token is null)
{
throw new InvalidRefreshTokenException();
}
token.Use(_dateTimeProvider.Now);
var user = await _userRepository.GetAsync(token.UserId);
if (user is null)
{
throw new UserNotFoundException(token.UserId);
}
var claims = user.Permissions.Any()
? new Dictionary <string, IEnumerable <string> >
{
["permissions"] = user.Permissions
}
: null;
var auth = _jwtProvider.Create(token.UserId, user.Name, user.Role, claims: claims);
var newRefreshToken = _refreshTokenFactory.Create(user.Id);
await _refreshTokenRepository.AddAsync(newRefreshToken);
await _refreshTokenRepository.UpdateAsync(token);
auth.RefreshToken = newRefreshToken.Token;
return(auth);
}
public async Task <JsonWebToken> CreateAccessTokenAsync(string token)
{
var refreshToken = await _refreshTokenRepository.GetAsync(token);
if (refreshToken is null)
{
throw new ServiceException(ExceptionCode.RefreshTokenNotFound,
"Refresh token was not found.");
}
if (refreshToken.Revoked)
{
throw new ServiceException(ExceptionCode.RefreshTokenAlreadyRevoked,
"Refresh token: '{refreshToken.Id}' was revoked.");
}
var user = await _userRepository.GetAsync(refreshToken.UserId);
if (user is null)
{
throw new ServiceException(ExceptionCode.UserNotExists,
$"User: '******' was not found.");
}
var claims = await _claimsProvider.GetAsync(user.Id);
var jwt = _jwtHandler.CreateToken(user.Id.ToString("N"), user.Role, claims);
jwt.RefreshToken = refreshToken.Token;
return(jwt);
}
public async Task <IdentityToken> CreateAccessTokenAsync(string token)
{
var refreshToken = await _refreshTokenRepository.GetAsync(token);
if (refreshToken == null)
{
throw new Exception("Refresh token was not found.");
}
if (refreshToken.Revoked)
{
throw new Exception($"Refresh token was revoked");
}
var account = await _accountRepository.GetAsync(refreshToken.UserId);
if (account == null)
{
throw new Exception($"Account was not found.");
}
var jwt = _jwtHandler.Create(account.Username, account.Role, account.Id);
return(new IdentityToken
{
AccessToken = jwt.AccessToken,
Expires = jwt.Expires,
RefreshToken = refreshToken.Token,
Role = account.Role,
UserId = account.Id
});
}
public async Task <JsonWebToken> CreateAccessTokenAsync(string token)
{
var refreshToken = await _refreshTokenRepository.GetAsync(token);
if (refreshToken == null)
{
throw new VirtualMarketException(Codes.RefreshTokenNotFound,
"Refresh token was not found.");
}
if (refreshToken.Revoked)
{
throw new VirtualMarketException(Codes.RefreshTokenAlreadyRevoked,
$"Refresh token: '{refreshToken.Id}' was revoked.");
}
var user = await _userRepository.GetAsync(refreshToken.UserId);
if (user == null)
{
throw new VirtualMarketException(Codes.UserNotFound,
$"User: '******' was not found.");
}
var claims = await _claimsProvider.GetAsync(user.Id);
var jwt = _jwtHandler.CreateToken(user.Id.ToString("N"), user.Role, claims);
jwt.RefreshToken = refreshToken.Token;
await _busPublisher.PublishAsync(new AccessTokenRefreshed(user.Id), CorrelationContext.Empty);
return(jwt);
}
public async Task <JsonWebToken> CreateAccessTokenAsync(string token)
{
var refreshToken = await _refreshTokenRepository.GetAsync(token);
if (refreshToken == null)
{
throw new ServiceException(ErrorCodes.RefreshTokenNotFound,
"Refresh token was not found.");
}
if (refreshToken.Revoked)
{
throw new ServiceException(ErrorCodes.RefreshTokenAlreadyRevoked,
$"Refresh token: '{refreshToken.Id}' was revoked.");
}
var user = await _userRepository.GetAsync(refreshToken.UserId);
if (user == null)
{
throw new ServiceException(ErrorCodes.UserNotFound,
$"User: '******' was not found.");
}
var jwt = _jwtHandler.CreateToken(user.SerialNumber, user.Role);
jwt.RefreshToken = refreshToken.Token;
return(jwt);
}
public async Task <JsonWebToken> CreateAccessTokenAsync(string token)
{
var refreshToken = await _refreshTokenRepository.GetAsync(token);
if (refreshToken == null)
{
throw new ServiceException("refresh_token_not_found",
"Refresh token was not found.");
}
if (refreshToken.Revoked)
{
throw new ServiceException("refresh_token_not_revoked",
$"Refresh token: '{refreshToken.Id}' was revoked.");
}
var user = await _userRepository.GetAsync(refreshToken.UserId);
if (user == null)
{
throw new ServiceException("user_not_found",
$"User: '******' was not found.");
}
var jwt = _jwtHandler.CreateToken(user.Id, user.Role);
jwt.RefreshToken = refreshToken.Token;
return(jwt);
}
public async Task <JwtDTO> RefreshAccessToken(string refreshToken)
{
var token = await _refreshTokens.GetAsync(refreshToken);
if (token == null)
{
throw new NewException("Token was not found.");
}
if (token.Revoked)
{
throw new NewException("Token was revoked.");
}
var user = await _userRepository.GetAsync(token.UserId);
if (user == null)
{
throw new NewException("User was not found.");
}
var jwt = _jwtHandler.CreateToken(user.Id);
var jwtDto = new JwtDTO()
{
AccessToken = jwt.AccessToken, Expires = jwt.Expires, RefreshToken = token.Token
};
return(jwtDto);
}
public async Task UseAsync_ShouldReturnJwtDto_WhenRefreshTokenExists(int id, string userName, string role)
{
var token = "randomTestToken";
var refreshToken = _fixture.Build <RefreshToken>()
.With(t => t.UserId, id)
.Create();
var user = _fixture.Build <UserDto>()
.With(u => u.Id, id)
.With(u => u.UserName, userName)
.With(u => u.Role, role)
.Create();
var jwtDto = _fixture.Build <JwtDto>()
.With(j => j.UserId, id)
.With(j => j.Username, userName)
.With(j => j.Role, role)
.Create();
_refreshTokenRepository.GetAsync(token).Returns(refreshToken);
_userService.GetAsync(id).Returns(user);
_jwtHandler.CreateToken(id, userName, role).Returns(jwtDto);
var jwt = await _sut.UseAsync(token);
jwt.ShouldNotBeNull();
jwt.UserId.ShouldBe(id);
jwt.Username.ShouldBe(userName);
jwt.Role.ShouldBe(role);
await _refreshTokenRepository.Received(1).AddAsync(Arg.Any <RefreshToken>());
await _refreshTokenRepository.Received(1).UpdateAsync(Arg.Any <RefreshToken>());
}
public async Task RevokeAsync(string refreshToken)
{
var token = await _refreshTokenRepository.GetAsync(refreshToken);
if (token is null)
{
throw new InvalidRefreshTokenException();
}
token.Revoke(DateTime.UtcNow);
await _refreshTokenRepository.UpdateAsync(token);
}
public async Task HandleAsync(UseRefreshToken command)
{
var token = await _refreshTokenRepository.GetAsync(command.RefreshToken);
if (token is null)
{
throw new InvalidRefreshTokenException();
}
if (token.Revoked)
{
throw new RevokedRefreshTokenException();
}
var user = await _userRepository.GetAsync(token.UserId);
if (user is null)
{
throw new UserNotFoundException(token.UserId);
}
var claims = user.Permissions.Any()
? new Dictionary <string, IEnumerable <string> >
{
["permissions"] = user.Permissions
}
: null;
var auth = _jwtProvider.Create(token.UserId, user.Name, user.Role, claims: claims);
auth.RefreshToken = command.RefreshToken;
_storage.Set(command.Id, auth);
}
public async Task <Result <object> > Handle(DeleteUserCommand request, CancellationToken cancellationToken)
{
var cacheKey = $"User-{request.UserId}";
if (!await _cacheService.IsExistsAsync(cacheKey))
{
var userInDb = await _userRepository.GetAsync(u => u.Id == request.UserId);
userInDb.CheckForNull();
}
var token = await _tokenRepository.GetAsync(t => t.Id == request.UserId);
if (token is not null)
{
await _tokenRepository.DeleteAsync(t => t.Id == token.Id);
await _sender.PublishAsync(token, cancellationToken);
}
await _userRepository.DeleteAsync(u => u.Id == request.UserId);
await _cacheService.RemoveAsync(cacheKey);
return(Result <object> .Success());
}
public async Task <AuthDto> HandleAsync(UseRefreshToken request)
{
var token = await _refreshTokenRepository.GetAsync(request.RefreshToken);
if (token is null)
{
throw new InvalidRefreshTokenException();
}
if (token.Revoked)
{
throw new RevokedRefreshTokenException();
}
var user = await _userRepository.GetAsync(token.UserId);
if (user is null)
{
throw new UserNotFoundException(token.UserId);
}
var auth = _jwtProvider.Create(token.UserId, user.Role);
auth.RefreshToken = request.RefreshToken;
return(auth);
}
public async Task <JsonWebToken> HandleAsync(AccessTokenQuery query)
{
var refreshToken = await _refreshTokenRepository.GetAsync(query.Token);
if (refreshToken == null)
{
throw new DomainException(Codes.RefreshTokenNotFound, MessagesCode.RefreshTokenNotFound);
}
if (refreshToken.Revoked)
{
throw new DomainException(Codes.RefreshTokenAlreadyRevoked, string.Format(MessagesCode.RefreshTokenAlreadyRevoked, refreshToken.Id));
}
var user = await _userRepository.GetAsync(refreshToken.UserId);
if (user == null)
{
throw new DomainException(Codes.UserNotFound, string.Format(MessagesCode.UserNotFound, refreshToken.UserId));
}
var rolesName = user.UserRoles.Select(x => x.Role.RoleName).ToList();
var jwt = _jwtHandler.CreateToken(user.Id.ToString("N"), rolesName);
jwt.RefreshToken = refreshToken.Token;
return(jwt);
}
public async Task <JsonWebToken> CreateAccessTokenAsync(string token)
{
var refreshToken = await _refreshTokenRepository.GetAsync(token);
if (refreshToken == null)
{
throw new ToolBoxException(Codes.RefreshTokenNotFound,
"Refresh token was not found.");
}
//var user = await _userRepository.GetAsync(refreshToken.UserId);
if (refreshToken.User == null || refreshToken.UserId == null || refreshToken.UserId == Guid.Empty)
{
throw new ToolBoxException(Codes.UserNotFound,
$"User: '******' was not found.");
}
var claims = await _claimsProvider.GetAsync(refreshToken.User);
var jwt = _jwtHandler.CreateToken(refreshToken.UserId.ToString(), null, claims);
jwt.RefreshToken = refreshToken.Token;
await _busClient.PublishAsync(new AccessTokenRefreshed(Guid.NewGuid(), refreshToken.UserId));
// await _busClient.PublishAsync(new AccessTokenRefreshed(user.Id), CorrelationContext.Empty);
return(jwt);
}
public async Task <RefreshTokenDTO> GetAsync(string refreshToken)
{
var result = await _refreshTokenRepository.GetAsync(item => item.RefreshToken == refreshToken);
if (result == null)
{
throw new HttpStatusCodeException(
HttpStatusCode.NotFound, "Such refresh token doesn't exist");
}
return(new RefreshTokenDTO
{
Id = result.Id,
UserId = result.UserId,
IsActive = result.IsActive,
RefreshToken = result.RefreshToken,
DaysToExpire = result.DaysToExpire
});
}
public async Task HandleAsync(RevokeRefreshToken command)
{
var token = await _refreshTokenRepository.GetAsync(command.RefreshToken);
if (token is null)
{
throw new InvalidRefreshTokenException();
}
token.Revoke(DateTime.UtcNow);
await _refreshTokenRepository.UpdateAsync(token);
}
public async Task HandleAsync(RevokeRefreshTokenCommand command, ICorrelationContext context)
{
var refreshToken = await _refreshTokenRepository.GetAsync(command.Token);
if (refreshToken == null || refreshToken.UserId != command.UserId)
{
throw new DomainException(Codes.RefreshTokenNotFound, MessagesCode.RefreshTokenNotFound);
}
refreshToken.Revoke();
await _refreshTokenRepository.UpdateAsync(refreshToken);
}
// Refreshing token
public async Task <JwtDto> UseAsync(string refreshToken)
{
var token = await _refreshTokenRepository.GetAsync(refreshToken);
if (token is null)
{
throw new InvalidRefreshTokenException();
}
token.Use(_dateTimeProvider.Now);
var user = await _userService.GetAsync(token.UserId);
var jwt = _jwtHandler.CreateToken(token.UserId, user.UserName, user.Role);
var newRefreshToken = _refreshTokenFactory.Create(user.Id);
await _refreshTokenRepository.AddAsync(newRefreshToken);
await _refreshTokenRepository.UpdateAsync(token);
jwt.RefreshToken = newRefreshToken.Token;
return(jwt);
}
public async Task RevokeAsync(string token, Guid userId)
{
var refreshToken = await _refreshTokenRepository.GetAsync(token);
if (refreshToken == null || refreshToken.UserId != userId)
{
throw new MinotaurException(Codes.RefreshTokenNotFound,
"Refresh token was not found.");
}
refreshToken.Revoke();
await _refreshTokenRepository.UpdateAsync(refreshToken);
await _busPublisher.PublishAsync(new RefreshTokenRevoked(refreshToken.UserId), CorrelationContext.Empty);
}
public async Task <IActionResult> RequestToken([FromBody] Login credenciais)
{
// https://medium.com/@renato.groffe/asp-net-core-2-0-jwt-implementando-refresh-tokens-7fa525ffb461
Usuario userData = null;
bool credenciaisValidas = false;
if (credenciais != null && !string.IsNullOrWhiteSpace(credenciais.Email))
{
userData = await _userRepository.GetByEmailAsync(credenciais.Email);
if (credenciais.GrantType == "password")
{
credenciaisValidas = (userData != null && credenciais.Password.Encrypt() == userData.Senha);
}
else if (credenciais.GrantType == "refresh_token" && !string.IsNullOrWhiteSpace(credenciais.RefreshToken) && userData != null)
{
// verificar se o token é válido
var refreshTokenData = await _refreshTokenRepository.GetAsync(userData.Id, credenciais.RefreshToken);
credenciaisValidas = (refreshTokenData != null && credenciais.RefreshToken == refreshTokenData.Token);
if (credenciaisValidas)
{
_refreshTokenRepository.Del(refreshTokenData);
await _uow.CommitAsync();
}
}
}
if (credenciaisValidas)
{
// Add o token no header também
// Request.HttpContext.Response.Headers.Add("x-access-token", new JwtSecurityTokenHandler().WriteToken(token));
return(await GenerateToken(userData.Id, userData.Nome, userData.Email));
}
else
{
return(BadRequest("Credenciais inválidas..."));
}
}
public async Task <Result <object> > Handle(LogoutCommand request, CancellationToken cancellationToken)
{
var user = await _userRepository.GetAsync(u => u.Id == request.UserId);
if (user == null)
{
throw Result <User> .Failure("id", "Invalid id");
}
user.SessionId = null;
var token = await _tokenRepository.GetAsync(t => t.User.Id == request.UserId);
await _tokenRepository.DeleteAsync(t => t.Id == token.Id);
await _sender.PublishAsync(new UpdatedUser(user), cancellationToken);
await _sender.PublishAsync(new DeletedToken(token.Id), cancellationToken);
return(Result <object> .Success());
}
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 <Result <UserDto> > Handle(UpdateUserCommand request, CancellationToken cancellationToken)
{
var cacheKey = $"User-{request.UserId}";
User userInDb;
if (!await _cacheService.IsExistsAsync(cacheKey))
{
userInDb = await _userRepository.GetAsync(u => u.Id == request.UserId);
userInDb.CheckForNull();
}
var userDto = _mapper.Map <UserDto>(request.User) with {
Id = request.UserId
};
userInDb = _mapper.Map <User>(userDto);
var token = await _tokenRepository.GetAsync(t => t.User.Id == request.UserId);
LogDto log =
new(Guid.NewGuid().ToString(), request.UserName, "edited user", JsonSerializer.Serialize(userDto,
CommandExtensions.JsonSerializerOptions), DateTime.UtcNow);
if (token is not null)
{
token.User = userInDb;
await _tokenRepository.UpdateAsync(t => t.Id == token.Id, token);
}
await _userRepository.UpdateAsync(u => u.Id == userInDb.Id, userInDb);
await _cacheService.UpdateAsync(cacheKey, userInDb, _userSettings);
await _sender.PublishAsync(log, cancellationToken);
return(Result <UserDto> .Success(userDto));
}
}
public async Task <RefreshToken> FindRefreshTokenAsync(string hashedTokenId)
{
return(await _repository.GetAsync(hashedTokenId));
}