private async Task <ClaimsIdentity> GetClaimsIdentity(CredentialsParams credentials)
{
if (string.IsNullOrEmpty(credentials.Email) || string.IsNullOrEmpty(credentials.Password))
{
return(await Task.FromResult <ClaimsIdentity>(null));
}
// get the user to verify
var userToVerify = _usersManager.Users.FirstOrDefault(u => u.Email == credentials.Email);
if (userToVerify == null)
{
return(await Task.FromResult <ClaimsIdentity>(null));
}
// check the credentials
if (await _usersManager.CheckPasswordAsync(userToVerify, credentials.Password))
{
credentials.UserName = userToVerify.UserName;
return(await Task.FromResult(
_jwtFactory.GenerateClaimsIdentity(userToVerify.Email, userToVerify.Id)));
}
// Credentials are invalid, or account doesn't exist
return(await Task.FromResult <ClaimsIdentity>(null));
}
public async Task <IActionResult> Register([FromBody] CredentialsParams model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _accountsManager.CreateUserAsync(model);
return(Ok());
}
public async Task <string> GetUserTokenAsync(CredentialsParams credentials)
{
var identity = await GetClaimsIdentity(credentials);
if (identity == null)
{
throw new AuthenticationException("Invalid username or password");
}
return(await GenerateJwt(identity, _jwtFactory, credentials.UserName, _jwtOptions));
}
public async Task <bool?> Authenticate(CredentialsParams credentials)
{
var user = await _context.Pilots
.FirstOrDefaultAsync(p => p.FirstName == credentials.FirstName && p.LastName == credentials.LastName);
if (user == null)
{
return(null);
}
return(user.PhoneNumber == credentials.PhoneNumber);
}
public async Task CreateUserAsync(CredentialsParams credentialsParams)
{
var userIdentity = _mapper.Map <UserEntity>(credentialsParams);
var result = await _usersManager.CreateAsync(userIdentity, credentialsParams.Password);
if (!result.Succeeded)
{
throw new System.Exception("Cannot add user");
}
await _dbContext.Users.AddAsync(userIdentity);
await _dbContext.SaveChangesAsync();
}
public async Task <IActionResult> Login([FromBody] CredentialsParams credentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var token = await _accountsManager.GetUserTokenAsync(credentials);
var deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject(token);
return(new OkObjectResult(deserialized));
}
catch (AuthenticationException)
{
return(Unauthorized());
}
}
public async Task <ActionResult <TokenDto> > GetToken([FromBody] CredentialsParams credentials)
{
//Authenticate
var isKnow = await _authService.Authenticate(credentials);
if (isKnow == null)
{
return(NotFound("User not found"));
}
if ((bool)!isKnow)
{
return(Unauthorized("Wrong user"));
}
var myTokenDto = _authService.GenerateJwt(credentials.FirstName, credentials.LastName, _appSettings.Secret);
if (myTokenDto.Token == null)
{
return(Unauthorized("Something went wrong"));
}
return(Ok(myTokenDto));
}
