public async Task <IActionResult> Logout([FromBody] AuthTokensDto dto)
{
var principal = _tokenBl.GetPrincipalFromExpiredAccessToken(dto.AccessToken);
await _tokenBl.DeleteRefreshTokenAsync(principal);
return(Ok());
}
public async Task <IActionResult> Refresh([FromBody] AuthTokensDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var principal = jwtService.GetPrincipalFromExpiredAccessToken(dto.AccessToken);
var user = await userService.GetUserById(principal.Claims.Single(claim => claim.Type == JwtCustomClaimNames.UserID).Value);
if (user.ApprovalStatus != true)
{
ModelState.AddModelError("loginFailure", "Рєстрація не підтверджена");
return(BadRequest(ModelState));
}
if (user.IsBlocked == true)
{
ModelState.AddModelError("loginFailure", "Аккаунт заблокований");
return(BadRequest(ModelState));
}
var userClaims = await jwtService.GetClaimsAsync(user);
dto.AccessToken = jwtService.GenerateJwtAccessToken(userClaims);
dto.RefreshToken = await jwtService.UpdateRefreshTokenAsync(dto.RefreshToken, principal);
dto.ExpireOn = jwtService.ExpirationTime;
return(Ok(dto));
}
public static async Task <TestToken> ProduceInstance(HttpClient httpClient, Login login)
{
var responseToken = await httpClient.PostAsJsonAsync("/api/auth/login", new
{
login.Email,
login.Password
});
string response = responseToken.Content.ReadAsStringAsync().Result;
if (!responseToken.IsSuccessStatusCode)
{
throw new ApplicationException(responseToken.ReasonPhrase);
}
AuthTokensDto authToken = JsonConvert.DeserializeObject <AuthTokensDto>(response);
var tempJwt = new JwtSecurityToken(authToken.AccessToken);
return(new TestToken
{
AuthToken = authToken,
JwtToken = tempJwt,
UserID = tempJwt.Claims.First(c => c.Type == "uid").Value,
UserName = tempJwt.Claims.First(c => c.Type == "sub").Value,
UserEmail = tempJwt.Claims.First(c => c.Type == "email").Value
});
}
public async Task <IActionResult> Refresh([FromBody] AuthTokensDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var principal = jwtService.GetPrincipalFromExpiredAccessToken(dto.AccessToken);
if (principal == null)
{
ModelState.AddModelError("loginFailure", "Failure tokrn");
return(BadRequest(ModelState));
}
var user = await userService.GetUserByIdAsync(principal.Claims.Single(claim => claim.Type == "uid").Value);
if (user.IsBlocked == true)
{
ModelState.AddModelError("loginFailure", "Account has been blocked");
return(BadRequest(ModelState));
}
var userClaims = await jwtService.GetClaimsAsync(user);
dto.AccessToken = jwtService.GenerateJwtAccessToken(userClaims);
dto.RefreshToken = await jwtService.UpdateRefreshTokenAsync(dto.RefreshToken, principal);
dto.ExpireOn = jwtService.ExpirationTime;
return(Ok(dto));
}
public async Task LoginWithCorrectParametersReturnsJwtTokensAsync(string accessToken, string refreshToken)
{
var userClaims = It.IsAny <Claim[]>();
var expectedAccessToken = accessToken;
var expectedRefreshToken = refreshToken;
var expectedTime = DateTime.Now.AddMinutes(120);
var expectedTokens = new AuthTokensDto
{
AccessToken = expectedAccessToken,
RefreshToken = expectedRefreshToken,
ExpireOn = expectedTime
};
mockUser.Setup(user => user.ApprovalStatus).Returns(true);
mockUser.Setup(user => user.IsBlocked).Returns(false);
mockUserService.Setup(userService => userService.GetUserByEmail(It.IsAny <string>())).ReturnsAsync(mockUser.Object);
mockUserService.Setup(userService => userService.CheckPassword(mockUser.Object, It.IsAny <string>())).ReturnsAsync(true);
mockJwtService.Setup(jwtService => jwtService.GetClaimsAsync(mockUser.Object)).ReturnsAsync(userClaims);
mockJwtService.Setup(jwtService => jwtService.GenerateJwtAccessToken(userClaims)).Returns(expectedAccessToken);
mockJwtService.Setup(jwtService => jwtService.GenerateJwtRefreshToken()).Returns(expectedRefreshToken);
mockJwtService.Setup(jwtService => jwtService.LoginByRefreshTokenAsync(Guid.NewGuid().ToString(), expectedRefreshToken));
mockJwtService.Setup(jwtService => jwtService.ExpirationTime).Returns(expectedTime);
AuthController authController = new AuthController(mockNotificationService.Object, mockUserService.Object, mockJwtService.Object, mockMapperService.Object);
var result = await authController.Login(mockAuthLoginDto.Object);
var okResult = Assert.IsType <OkObjectResult>(result);
var actualTokens = Assert.IsAssignableFrom <AuthTokensDto>(okResult.Value);
Assert.Equal(expectedTokens, actualTokens);
}
public async Task CorrectlyLoginTestAsync(string accessToken, string refreshToken)
{
// Arrange
var userClaims = It.IsAny <Claim[]>();
var expectedAccessToken = accessToken;
var expectedRefreshToken = refreshToken;
var expectedTime = DateTime.Now.AddMinutes(120);
var expectedTokens = new AuthTokensDto
{
AccessToken = expectedAccessToken,
RefreshToken = expectedRefreshToken,
ExpireOn = expectedTime
};
mockUserService.Setup(userService => userService.FindUserByEmailAsync(It.IsAny <string>())).ReturnsAsync(mockUser.Object);
mockUserService.Setup(userService => userService.CheckPasswordAsync(mockUser.Object, It.IsAny <string>())).ReturnsAsync(true);
mockJwtService.Setup(jwtService => jwtService.GetClaimsAsync(mockUser.Object)).ReturnsAsync(userClaims);
mockJwtService.Setup(jwtService => jwtService.GenerateJwtAccessToken(userClaims)).Returns(expectedAccessToken);
mockJwtService.Setup(jwtService => jwtService.GenerateJwtRefreshToken()).Returns(expectedRefreshToken);
mockJwtService.Setup(jwtService => jwtService.LoginByRefreshTokenAsync(Guid.NewGuid().ToString(), expectedRefreshToken));
mockJwtService.Setup(jwtService => jwtService.ExpirationTime).Returns(expectedTime);
//Act
AuthController authController = new AuthController(mockJwtService.Object, mockUserService.Object);
var result = await authController.LoginAsync(mockAuthLoginDto.Object);
//Assert
var okResult = Assert.IsType <OkObjectResult>(result);
var actualTokens = Assert.IsAssignableFrom <AuthTokensDto>(okResult.Value);
Assert.Equal(expectedTokens, actualTokens);
}
public async Task <IActionResult> Login([FromBody] AuthLoginDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationUser user = null;
bool userNotFound = false;
try
{
user = await userService.GetUserByEmail(dto.Email);
}
catch (CurrentEntryNotFoundException)
{
userNotFound = true;
}
if (userNotFound || !await userService.CheckPassword(user, dto.Password))
{
ModelState.AddModelError("loginFailure", "Пароль або пошта не відповідає критеріям");
return(BadRequest(ModelState));
}
if (!(user.ApprovalStatus ?? false))
{
ModelState.AddModelError("loginFailure", "Аккаунт не підтвердежний");
return(BadRequest(ModelState));
}
if (user.IsBlocked ?? false)
{
ModelState.AddModelError("loginFailure", "Аккаунт заблокований");
return(BadRequest(ModelState));
}
var userClaims = await jwtService.GetClaimsAsync(user);
var accessToken = jwtService.GenerateJwtAccessToken(userClaims);
var refreshToken = jwtService.GenerateJwtRefreshToken();
await jwtService.LoginByRefreshTokenAsync(user.Id, refreshToken);
var tokens = new AuthTokensDto
{
AccessToken = accessToken,
RefreshToken = refreshToken,
ExpireOn = jwtService.ExpirationTime
};
return(Ok(tokens));
}
public async Task <IActionResult> Login([FromBody] AuthLoginDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationUser user = null;
bool userNotFound = false;
try
{
user = await userService.GetUserByEmail(dto.Email);
}
catch (CurrentEntryNotFoundException)
{
userNotFound = true;
}
if (userNotFound || !await userService.CheckPassword(user, dto.Password))
{
ModelState.AddModelError("loginFailure", "Invalid email or password");
return(BadRequest(ModelState));
}
if (!(user.ApprovalStatus ?? false))
{
ModelState.AddModelError("loginFailure", "Not approved yet");
return(BadRequest(ModelState));
}
if (user.IsBlocked ?? false)
{
ModelState.AddModelError("loginFailure", "Account has been blocked");
return(BadRequest(ModelState));
}
var userClaims = await jwtService.GetClaimsAsync(user);
var accessToken = jwtService.GenerateJwtAccessToken(userClaims);
var refreshToken = jwtService.GenerateJwtRefreshToken();
await jwtService.LoginByRefreshTokenAsync(user.Id, refreshToken);
var tokens = new AuthTokensDto
{
AccessToken = accessToken,
RefreshToken = refreshToken,
ExpireOn = jwtService.ExpirationTime
};
return(Ok(tokens));
}
public async Task <IActionResult> Refresh([FromBody] AuthTokensDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var principal = _tokenBl.GetPrincipalFromExpiredAccessToken(dto.AccessToken);
var user = await _accountBl.GetUserById(principal.Claims.Single(claim => claim.Type == "uid").Value);
var userClaims = await _tokenBl.GetClaimsAsync(user);
dto.AccessToken = _tokenBl.GenerateJwtAccessToken(userClaims);
dto.RefreshToken = await _tokenBl.UpdateRefreshTokenAsync(dto.RefreshToken, principal);
dto.ExpireOn = _tokenBl.ExpirationTime;
return(Ok(dto));
}
public async Task <object> Login([FromBody] LoginDto userData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.SelectMany(e => e.Value.Errors.Select(e => e.ErrorMessage))));
}
User user = null;
bool userNotFound = false;
try
{
user = await _accountBl.GetUserByName(userData.Name);
}
catch (NotFoundResponseException)
{
userNotFound = true;
}
if (userNotFound || !await _accountBl.CheckPassword(user, userData.Password))
{
ModelState.AddModelError("loginFailure", "Invalid email or password");
return(BadRequest(ModelState));
}
var userClaims = await _tokenBl.GetClaimsAsync(user);
var accessToken = _tokenBl.GenerateJwtAccessToken(userClaims);
var refreshToken = _tokenBl.GenerateJwtRefreshToken();
await _tokenBl.LoginByRefreshTokenAsync(user.Id, refreshToken);
var tokens = new AuthTokensDto
{
AccessToken = accessToken,
RefreshToken = refreshToken,
ExpireOn = _tokenBl.ExpirationTime
};
return(Ok(tokens));
}
public async Task Login_WithCorrectParameters_ReturnsJwtTokensAsync(string accessToken, string refreshToken)
{
var userClaims = It.IsAny <Claim[]>();
var expectedAccessToken = accessToken;
var expectedRefreshToken = refreshToken;
var expectedTime = DateTime.Now.AddMinutes(120);
var expectedTokens = new AuthTokensDto
{
AccessToken = expectedAccessToken,
RefreshToken = expectedRefreshToken,
ExpireOn = expectedTime
};
mockAccountBl.Setup(accountBl => accountBl.GetUserByName(It.IsAny <string>())).ReturnsAsync(mockUser.Object);
mockAccountBl.Setup(accountBl => accountBl.CheckPassword(mockUser.Object, It.IsAny <string>())).ReturnsAsync(true);
mockJwtTokenBl.Setup(jwtBl => jwtBl.GetClaimsAsync(mockUser.Object)).ReturnsAsync(userClaims);
mockJwtTokenBl.Setup(jwtBl => jwtBl.GenerateJwtAccessToken(userClaims)).Returns(expectedAccessToken);
mockJwtTokenBl.Setup(jwtBl => jwtBl.GenerateJwtRefreshToken()).Returns(expectedRefreshToken);
mockJwtTokenBl.Setup(jwtBl => jwtBl.LoginByRefreshTokenAsync(Guid.NewGuid().ToString(), expectedRefreshToken));
mockJwtTokenBl.Setup(jwtBl => jwtBl.ExpirationTime).Returns(expectedTime);
AccountController AccountController = new AccountController(mockJwtTokenBl.Object, mockUserBl.Object,
mockAccountBl.Object, mockNotificationBl.Object, mockMapper.Object);
var result = await AccountController.Login(new LoginDto()
{
Name = "someName",
Password = "******"
});
var okResult = Assert.IsType <OkObjectResult>(result);
var actualTokens = Assert.IsAssignableFrom <AuthTokensDto>(okResult.Value);
Assert.Equal(expectedTokens, actualTokens);
}
