public async Task <LoginResponse <AuthenticatedUserDTO> > LoginUser(PostUserDTO UserCredentials)
{
var user = await _userRepository.FindByEmail(UserCredentials.Email);
if (user == null)
{
var errorMessage = $"Password or login is incorrect";
Log.Error(errorMessage);
return(new LoginResponse <AuthenticatedUserDTO> {
Message = errorMessage, Success = false
});
}
if (!UserCredentials.Password.Equals(user.Password))
{
var errorMessage = $"Password or login is incorrect";
Log.Error(errorMessage);
return(new LoginResponse <AuthenticatedUserDTO> {
Message = errorMessage, Success = false
});
}
var token = GenerateJwtToken(user);
var authenticatedUserDTO = new AuthenticatedUserDTO()
{
Email = user.Email,
Token = token
};
return(new LoginResponse <AuthenticatedUserDTO> {
Data = authenticatedUserDTO
});
}
public AuthenticatedUserDTO ExchangeKeyForToken(string exchangeKey, string username)
{
AuthenticatedUserDTO returnUser = new AuthenticatedUserDTO();
UserProfileDTO searchResult = _securityService.GetUserProfile(username);
if (searchResult != null)
{
if (_securityService.VerifyAccessKey(exchangeKey))
{
var claims = _securityService.GetUserClaims(username);
if (claims != null)
{
string userJWTToken = BuildUserJwtToken(username, claims);
if (!string.IsNullOrEmpty(userJWTToken))
{
returnUser = new AuthenticatedUserDTO();
returnUser.RefreshToken = BuildRefreshToken(username);
returnUser.BearerToken = userJWTToken;
returnUser.IsAuthenticated = true;
returnUser.Username = username;
foreach (var claim in claims)
{
returnUser.UserClaims.Add(claim);
}
}
}
}
}
return(returnUser);
}
public async Task <AuthenticatedUserDTO> Authenticate(string login, string password)
{
var user = await _usersRepository.FindUserForAuthentication(login, password);
// return null if user not found
if (user == null)
{
return(null);
}
// authentication successful so generate jwt token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString()),
new Claim(ClaimTypes.Role, user.Role.ToString()) //dzięki temu, że dałam tutaj tą role możemy autoryzować po tym kto strzela(w sensie czy admin czy laborant czy..)
}),
Expires = DateTime.UtcNow.AddHours(5), //data wygaśnięcia tokenu, ustawiłam na 5h
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
var authenticatedUser = new AuthenticatedUserDTO(user.Id, user.Name, user.Surname, user.Login, user.Role, tokenString);
return(authenticatedUser);
}
public User CreateUserAuthenticateEntity(AuthenticatedUserDTO userDTO)
{
return(new User()
{
Id = userDTO.Id,
//AuthToken = user.AuthToken
});
}
public void Admin_login_fail()
{
var adminStubRepository = CreateAdminStubRepository();
AuthenticationService service = new AuthenticationService(adminStubRepository);
AuthenticatedUserDTO user = service.Authenticate("pera", "pera1978");
user.ShouldBeNull();
}
public void Admin_login_success()
{
var adminStubRepository = CreateAdminStubRepository();
AuthenticationService service = new AuthenticationService(adminStubRepository);
AuthenticatedUserDTO user = service.Authenticate("markic", "marko1978");
user.ShouldNotBeNull();
}
public void Patient_login_fail()
{
var patientStubRepository = CreatePatientStubRepository();
AuthenticationService service = new AuthenticationService(patientStubRepository);
AuthenticatedUserDTO user = service.Authenticate("markic", "marko1978");
user.ShouldBeNull();
}
public void Patient_login_success()
{
var patientStubRepository = CreatePatientStubRepository();
AuthenticationService service = new AuthenticationService(patientStubRepository);
AuthenticatedUserDTO user = service.Authenticate("pera", "pera1978");
user.ShouldNotBeNull();
}
public IActionResult Authenticate(AuthenticationDTO authenticationDTO)
{
AuthenticatedUserDTO auteAuthenticatedUserDto = _authenticationService.Authenticate(authenticationDTO.Username, authenticationDTO.Password);
if (auteAuthenticatedUserDto == null)
{
return(BadRequest("Username or password is incorrect"));
}
return(Ok(auteAuthenticatedUserDto));
}
public ActionResult <AuthenticatedUserDTO> TokenRefresh([FromBody] AuthenticatedUserDTO currentUser)
{
var returnUser = _securityManager.RefreshToken(currentUser);
if (returnUser != null)
{
return(returnUser);
}
else
{
return(BadRequest());
}
}
public string Login(string username, string password)
{
string token = null;
AuthenticationDTO dto = new AuthenticationDTO(username, password);
using HttpClient client = _factoryUsers.CreateClient();
AuthenticatedUserDTO auteAuthenticatedUserDto = null;
StringContent content = new StringContent(JsonConvert.SerializeObject(dto), System.Text.Encoding.UTF8, "application/json");
var task = client.PostAsync(GetUsersDomain() + "/api/authentication/authenticate", content)
.ContinueWith((taskWithResponse) =>
{
var message = taskWithResponse.Result;
var json = message.Content.ReadAsStringAsync();
json.Wait();
auteAuthenticatedUserDto = JsonConvert.DeserializeObject <AuthenticatedUserDTO>(json.Result);
token = auteAuthenticatedUserDto.Token;
});
task.Wait();
return(token);
}
public async Task <ActionResult <AuthenticatedUserDTO> > LoginAsync([FromBody] LoginDTO dto)
{
var user = await _appUsers.LoginAsync(dto.UserName, dto.Password);
if (user == null)
{
return(Unauthorized());
}
var loggedInUserDTO = new AuthenticatedUserDTO();
loggedInUserDTO.User = Mappers.GetAppUserDTO(user);
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.Email, user.Email)
};
foreach (var role in user.GetRoles())
{
claims.Add(new Claim(ClaimTypes.Role, role));
}
if (!string.IsNullOrEmpty(user.FirstName))
{
claims.Add(new Claim(ClaimTypes.GivenName, user.FirstName));
}
if (!string.IsNullOrEmpty(user.LastName))
{
claims.Add(new Claim(ClaimTypes.Surname, user.LastName));
}
loggedInUserDTO.Token = BuildToken(claims);
return(Ok(loggedInUserDTO));
}
public AuthenticatedUserDTO RefreshToken(AuthenticatedUserDTO currentUser)
{
AuthenticatedUserDTO returnUser = null;
JwtSecurityToken currentRefreshToken = new JwtSecurityToken(currentUser.RefreshToken);
var claims = _securityService.GetUserClaims(currentUser.Username);
if (claims != null)
{
string newUserToken = BuildUserJwtToken(currentUser.Username, claims);
returnUser = new AuthenticatedUserDTO();
returnUser.BearerToken = newUserToken;
returnUser.IsAuthenticated = true;
returnUser.RefreshToken = currentUser.RefreshToken;
returnUser.Username = currentUser.Username;
foreach (var claim in claims)
{
returnUser.UserClaims.Add(claim);
}
}
return(returnUser);
}
