public async Task <TokenDTO> Create(ApplicationUser user, IEnumerable <string> roles)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_JWTSettings.Secret);
var cliams = new List <Claim>();
cliams.Add(new Claim(ClaimTypes.Name, user.Id));
roles.ToList().ForEach(r => cliams.Add(new Claim(ClaimTypes.Role, r)));
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(cliams),
Expires = DateTime.Now.AddMinutes(_JWTSettings.MinutesLife),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha256Signature),
};
var token = tokenHandler.WriteToken(tokenHandler.CreateToken(tokenDescriptor));
var refreshToken = _refreshTokenFactory.Create(token, user.UserName);
await _refreshTokenRepository.Create(refreshToken);
var tokenDTO = new TokenDTO()
{
AccessToken = token,
RefreshToken = refreshToken.Token,
Roles = roles,
Email = user.Email,
Id = user.Id
};
return(tokenDTO);
}
private async Task <AuthTokenModel> GenerateToken(User user)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(authorizationConfigs.TokenKey);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(
new[]
{
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Email, user.Email),
}),
Expires = DateTime.UtcNow.AddMinutes(authorizationConfigs.TokenExpiratinInMinutes),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var refreshToken = GenerateRefreshToken();
await refreshTokenRepository.Create(new RefreshToken()
{
UserId = user.Id,
Token = refreshToken
});
return(new AuthTokenModel
{
Token = tokenHandler.WriteToken(token),
ExpiredIn = new DateTimeOffset(tokenDescriptor.Expires.Value).ToUnixTimeMilliseconds(),
RefreshToken = refreshToken
});
}
public async Task CreateRefreshToken_ShouldReturnTheCreatedRefreshToken_AndIncreaseTheRefreshTokensCount()
{
var refreshToken = new RefreshTokenEntity
{
Id = 444,
Token = "token 123",
User = new UserEntity
{
UserName = "******",
Email = "*****@*****.**"
}
};
var expectedNumberOfRefreshTokens = DbContext.RefreshTokens.Count() + 1;
// Act
var createdRefreshToken = await _refreshTokenRepository.Create(refreshToken);
// Assert
Assert.NotNull(createdRefreshToken);
Assert.Equal(refreshToken.Token, createdRefreshToken.Token);
Assert.Equal(refreshToken.User.UserName, createdRefreshToken.User.UserName);
Assert.Equal(refreshToken.User.Email, createdRefreshToken.User.Email);
Assert.True(refreshToken.Id != 0);
Assert.Equal(expectedNumberOfRefreshTokens, DbContext.RefreshTokens.Count());
}
/// <summary>
/// To save a given refresh token using the token repository
/// </summary>
/// <param name="refreshToken"></param>
/// <returns>Task/bool</returns>
public async Task <bool> SaveRefreshToken(RefreshToken refreshToken)
{
await _refreshTokenRepository.Create(refreshToken);
var result = await _refreshTokenRepository.Save();
return(result > 0);
}
public Task <RefreshTokenEntity> Create(string token, DateTime validFor, UserEntity user)
{
return(_refreshTokenRepository.Create(new RefreshTokenEntity
{
Token = token,
User = user,
ValidFor = validFor,
}));
}
public async Task RegisterRefreshToken(string refreshToken, Guid userId)
{
await _refreshTokenRepository.Create(new RefreshToken
{
Id = Guid.Parse(refreshToken),
UserId = userId,
ExpirationDate = DateTimeOffset.Now.AddDays(RefreshTokenLifeTime)
});
}
public async Task <AccessTokenDto> CreateAccessTokenAsync(User user)
{
var jwtToken = GenerateJwtToken(CreateUserClaims(user));
var refreshToken = new RefreshToken
{
UserId = user.Id,
Token = GenerateRefreshToken()
};
if (await _refreshTokenRepository.AnyByUserIdAsync(user.Id))
{
_refreshTokenRepository.Update(refreshToken);
}
else
{
_refreshTokenRepository.Create(refreshToken);
}
await _saveProvider.SaveAsync();
return(new AccessTokenDto {
RefreshToken = refreshToken.Token, Token = jwtToken
});
}
public async Task <Guid> Generate(ApplicationUser user, string ipAddress)
{
var refreshTokenValue = Guid.NewGuid();
var refreshToken = new RefreshToken()
{
CreatedByIp = ipAddress,
CreateDateTime = DateTime.Now,
ExpireDateTime = DateTime.Now.AddDays(1),
Token = refreshTokenValue,
UserId = user.Id
};
await refreshTokenRepository.Create(refreshToken);
return(refreshTokenValue);
}
public async Task <AuthenticatedUserResponse> Authenticate(User user)
{
string accessToken = _accessTokenGenerator.GenerateToken(user);
string refreshToken = _refreshTokenGenerator.GenerateToken();
RefreshToken refreshTokenDTO = new RefreshToken()
{
Token = refreshToken,
UserId = user.Id
};
await _refreshTokenRepository.Create(refreshTokenDTO);
return(new AuthenticatedUserResponse()
{
AccessToken = accessToken,
RefreshToken = refreshToken
});
}
public async Task <LoginSuccessResponse> Login(LoginRequest request)
{
var user = await _userManager.GetUserByLogin(request.Login);
if (user == null)
{
throw new UserNotFoundException();
}
var signInResult = await _signInManager.PasswordSignInAsync(user, request.Password, false, true);
if (!signInResult.Succeeded)
{
throw new InvalidCredentialsException(ProcessErrorResult(signInResult));
}
var principal = await _signInManager.CreateUserPrincipalAsync(user);
var jwt = _tokenFactory.GenerateJwtToken(principal);
if (principal.IsServiceAccount())
{
return(new LoginSuccessResponse
{
Jwt = jwt,
});
}
var refreshToken = await _refreshTokenRepository.Create(new RefreshToken
{
Location = request.Location,
User = user.Id,
Useragent = request.UserAgent,
IpAddress = request.IpAddress,
LastUsed = DateTime.Now,
Value = _uuidService.GenerateUuId("session"),
});
return(new LoginSuccessResponse
{
Jwt = jwt,
RefreshToken = refreshToken.Value,
});
}
public async Task <Result> HandleAsync(CreateRefreshTokenCommand command)
{
if (!(await VerifyNotExisting(command.TicketId)).Succeeded)
{
return(await Task.FromResult(Result.Fail($"RefreshToken {command.TicketId} is already register in the system")));
}
var token = new RefreshToken
{
Id = new RefreshTokenId(Guid.NewGuid().ToString()),
TicketId = command.TicketId,
ClientId = new Domain.Membership.Clients.ClientId(command.ClientId),
UserId = new Domain.Membership.IdentityUserId(command.UserId),
IpAddress = command.IpAddress,
ExpiresUtc = command.ExpiresUtc,
IssuedUtc = command.IssuedUtc
};
await _repo.Create(token);
return(Result.Ok());
}
private async Task <string> GenerateRefreshToken(Guid userId)
{
await _refreshTokenRepository.DeleteExpired(userId);
var randomNumber = new byte[256];
using (var rng = RandomNumberGenerator.Create())
{
rng.GetBytes(randomNumber);
var token = Convert.ToBase64String(randomNumber);
_refreshTokenRepository.Create(new RefreshToken
{
UserId = userId,
Value = token,
ExpirationDate = DateTime.Now.AddDays(14)
});
await _refreshTokenRepository.SaveChanges();
return(token);
}
}
private async Task CreateToken(RefreshToken refreshToken)
{
refreshToken.Token = tokenService.CreateRefreshToken();
refreshToken.ExpiresAt = timeService.GetCurrentTime().AddDays(30);
await refreshTokenRepo.Create(refreshToken);
}
