public async Task <AuthenticationModel> GetTokenAsync(GetTokenQuery query)
{
var authenticationModel = new AuthenticationModel();
var user = await _userManagerWrapper.FindByEmailAsync(query.Email);
if (user == null)
{
throw new IncorrectCredentialsException(query.Email);
}
if (!await _userManagerWrapper.CheckPasswordAsync(user, query.Password))
{
throw new IncorrectCredentialsException(query.Email);
}
authenticationModel.IsAuthenticated = true;
var jwtSecurityToken = await CreateJwtToken(user);
authenticationModel.Token = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);
authenticationModel.Email = user.Email;
authenticationModel.UserName = user.UserName;
var rolesList = await _userManagerWrapper.GetRolesAsync(user).ConfigureAwait(false);
authenticationModel.Roles = rolesList.ToList();
return(authenticationModel);
}
public void GetTokenAsync_OnIncorrectCredentials_ThrowsIncorrectCredentialsException()
{
var userManagerWrapperMock = new Mock <IUserManagerWrapper>();
var jwtTokenMock = new Mock <IOptions <JWT> >();
userManagerWrapperMock
.Setup(x => x.FindByEmailAsync(It.IsAny <string>()))
.Returns(Task.FromResult(Mock.Of <ApplicationUser>()));
userManagerWrapperMock
.Setup(x => x.CheckPasswordAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()))
.Returns(Task.FromResult(false));
var sut = new UserService(userManagerWrapperMock.Object, jwtTokenMock.Object);
var getTokenQuery = new GetTokenQuery
{
Email = "*****@*****.**",
Password = "******"
};
Action act = () => sut.GetTokenAsync(getTokenQuery).GetAwaiter().GetResult();
act.Should().ThrowExactly <IncorrectCredentialsException>();
}
public async Task <ActionResult> Login([FromBody] LoginUserRequest request)
{
var query = new GetTokenQuery(request.Username, request.Password);
var response = await _mediator.Send(query);
return(response != null ? (ActionResult)Ok(response) : BadRequest());
}
public async Task <IActionResult> Login(GetTokenQuery getTokenQuery)
{
var result = await _mediator.Send(getTokenQuery);
if (string.IsNullOrEmpty(result))
{
return(Forbid());
}
return(Json(result));
}
public async Task <IActionResult> GetToken([FromQuery] GetTokenQuery query)
{
try
{
var token = await _mediator.Send(query, this.HttpContext.RequestAborted);
return(Ok(token));
}
catch (GetTokenQueryException e)
{
return(BadRequest(e.Message));
}
}
public async Task <TokenRespose> Handle(GetTokenQuery request, CancellationToken cancellationToken)
{
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("grant_type", "authorization_code")
, new KeyValuePair <string, string>("code", request.AccessCode)
, new KeyValuePair <string, string>("redirect_uri", config.Value.RedirectUri)
, new KeyValuePair <string, string>("client_id", config.Value.ClientId)
, new KeyValuePair <string, string>("client_secret", config.Value.ClientSecret)
});
var client = httpHelpers.GetClient(config.Value.OAuthServerUrl);
var response = await client.PostAsync("/connect/token", content);
if (response.IsSuccessStatusCode)
{
dynamic result = JsonConvert.DeserializeObject <dynamic>(await response.Content.ReadAsStringAsync());
var jwtSecurityHandler = new JwtSecurityTokenHandler();
var token = (JwtSecurityToken)jwtSecurityHandler.ReadJwtToken(result.access_token.ToString());
var tokens = new TokenDetails
{
AccessToken = result.access_token,
RefreshToken = request.AccessCode,
ExpiryDate = FromUnixTime(token.Claims.Where(x => x.Type == "exp").FirstOrDefault().Value)
};
tokenStorage.Clear();
tokenStorage.Store(tokens, config.Value.TokenKey);
var user = await userService.GetInfo();
tokenStorage.Store(user, "userInfo");
return(new TokenRespose {
Response = tokens
});
}
return(new TokenRespose());
}
public async Task <ActionResult <ServiceResult <LoginResponse> > > Create(GetTokenQuery query)
{
return(Ok(await Mediator.Send(query)));
}
public void GetTokenAsync_OnCredentials_ReturnsAuthenticationModel()
{
var claims = new List <Claim>()
{
new Claim("roles", "test")
} as IList <Claim>;
var roles = new List <string>()
{
"User"
} as IList <string>;
var applicationUser = new ApplicationUser
{
Id = Guid.NewGuid().ToString(),
Email = "*****@*****.**",
UserName = "******"
};
var jwt = new JWT
{
Audience = "test",
DurationInMinutes = 50,
Issuer = "test",
Key = "some_big_key_value_here_secret_123"
};
var userManagerWrapperMock = new Mock <IUserManagerWrapper>();
var jwtTokenMock = new Mock <IOptions <JWT> >();
jwtTokenMock.Setup(x => x.Value)
.Returns(jwt);
userManagerWrapperMock
.Setup(x => x.FindByEmailAsync(It.IsAny <string>()))
.Returns(Task.FromResult(applicationUser));
userManagerWrapperMock
.Setup(x => x.CheckPasswordAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()))
.Returns(Task.FromResult(true));
userManagerWrapperMock
.Setup(x => x.GetClaimsAsync(It.IsAny <ApplicationUser>()))
.Returns(Task.FromResult(claims));
userManagerWrapperMock
.Setup(x => x.GetRolesAsync(It.IsAny <ApplicationUser>()))
.Returns(Task.FromResult(roles));
var sut = new UserService(userManagerWrapperMock.Object, jwtTokenMock.Object);
var getTokenQuery = new GetTokenQuery
{
Email = "*****@*****.**",
Password = "******"
};
var result = sut.GetTokenAsync(getTokenQuery).GetAwaiter().GetResult();
result.Should().NotBeNull();
result.Email.Should().Be("*****@*****.**");
result.IsAuthenticated.Should().Be(true);
result.UserName.Should().Be("*****@*****.**");
}
public async Task <IActionResult> Token([FromBody] GetTokenQuery query)
{
return(Ok(await Mediator.Send(query)));
}
public async Task <IActionResult> Post([FromQuery] GetTokenQuery credentials)
{
return(Ok(await Mediator.Send(credentials)));
}
