public async Task <ActionResult <string> > Authenticate([FromBody] AuthorizationRequest authorizationRequest)
{
RoadkillIdentityUser identityUser = await _userManager.FindByEmailAsync(authorizationRequest.Email);
if (identityUser == null)
{
return(NotFound($"The user with the email {authorizationRequest.Email} could not be found."));
}
SignInResult result = await _signInManager.PasswordSignInAsync(identityUser, authorizationRequest.Password, true, false);
if (result.Succeeded)
{
IList <Claim> existingClaims = await _userManager.GetClaimsAsync(identityUser);
if (existingClaims.Count == 0)
{
return(Forbid());
}
string token = _jwtTokenProvider.CreateToken(existingClaims, identityUser.Email);
return(Ok(token));
}
return(Forbid());
}
public async Task <HttpResult <string> > Login(Login model, CancellationToken token = default(CancellationToken))
{
var result = new HttpResult <string>();
var user = _unitOfWork.GetUser(model.Username);
if (user == null)
{
result.Error = new System.Collections.Generic.Dictionary <string, string[]>
{
{ "Username", new [] { "Username not found" } }
};
return(result);
}
if (!_passwordManager.Compare(user, model.Password))
{
result.Error = new System.Collections.Generic.Dictionary <string, string[]>
{
{ "Password", new [] { "Invalid password" } }
};
}
;
var claims = await _unitOfWork.GetUserClaims(user);
await _unitOfWork.UpdateLastLogin(user);
result.Data = _jwtTokenProvider.CreateToken(user, claims);
return(await Task.FromResult(result));
}
public async Task <IActionResult> Login([FromBody] Login model)
{
var user = _unitOfWork.GetUser(model.Username);
if (user == null)
{
ModelState.AddModelError("Login", Errors.USER_NOT_FOUND);
return(BadRequest(ModelState));
}
if (!_passwordManager.Compare(user, model.Password))
{
ModelState.AddModelError("Password", Errors.INVALID_PASSWORD);
return(BadRequest(ModelState));
}
;
var claims = await _unitOfWork.GetUserClaims(user);
await _unitOfWork.UpdateLastLogin(user);
var token = _jwtTokenProvider.CreateToken(user, claims);
return(new ObjectResult(token));
}
public async Task Authenticate_should_return_token_from_provider()
{
// given
string jwtToken = "jwt token";
string email = "*****@*****.**";
string password = "******";
var roadkillUser = new RoadkillIdentityUser()
{
Id = "1",
UserName = email,
NormalizedUserName = email.ToUpperInvariant(),
Email = email,
NormalizedEmail = email.ToUpperInvariant(),
RoleClaims = new List <string>()
};
var model = new AuthorizationRequest()
{
Email = email,
Password = password
};
_userManagerMock.FindByEmailAsync(email)
.Returns(Task.FromResult(roadkillUser));
_signinManagerMock.PasswordSignInAsync(roadkillUser, password, true, false)
.Returns(Task.FromResult(SignInResult.Success));
var claims = new List <Claim>()
{
new Claim("any", "thing")
} as IList <Claim>;
_userManagerMock.GetClaimsAsync(roadkillUser)
.Returns(Task.FromResult(claims));
_jwtTokenProvider.CreateToken(claims, roadkillUser.Email)
.Returns(jwtToken);
// when
ActionResult <string> actionResult = await _authorizationController.Authenticate(model);
// then
actionResult.Result.ShouldBeOfType <OkObjectResult>();
var okResult = actionResult.Result as OkObjectResult;
okResult.Value.ShouldBe(jwtToken);
}
public IActionResult GenerateToken()
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, "1"),
new Claim(ClaimTypes.Name, "userName"),
new Claim("FirstName", "firstName"),
new Claim("LastName", "lastName"),
new Claim(ClaimTypes.Email, "*****@*****.**"),
};
var token = _jwtTokenProvider.CreateToken(claims);
return(Ok(new
{
_jwtTokenProvider.TokenType,
Token = token,
}));
}