public ActionResult <User> AuthenticateUser([FromBody] AuthenticateUserDTO authenticateUserDTO)
{
var user = userService.Authenticate(authenticateUserDTO.Username, authenticateUserDTO.Password);
if (user == null)
{
return(Unauthorized());
}
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())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(Ok(new
{
user.Id,
user.Username,
user.Name,
Token = tokenString
}));
}
public async Task AddUser(AuthenticateUserDTO user)
{
if (!VerifyIfUserExists(user))
{
await _userRepository.AddUser(user);
}
}
public IHttpActionResult AuthenticateUser(AuthenticateUserDTO authenticateUserDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (authenticateUserDTO == null)
{
return(BadRequest("userDTO should not have been null"));
}
var authenitcationFactor = EAuthenticationFactor.NotAuthenticated;
var user = db.Users.Where(u => u.MobileNo == authenticateUserDTO.MobileNo).FirstOrDefault();
if (user != null)
{
if (string.Compare(user.Password, authenticateUserDTO.Password) == 0)
{
authenitcationFactor = EAuthenticationFactor.OneFactorAuthenticated;
if (string.Compare(user.DeviceId, authenticateUserDTO.DeviceId) == 0)
{
authenitcationFactor = EAuthenticationFactor.TwoFactorAuthenticated;
}
}
}
var result = new List <AuthenticationToken>();
var authenticationToken = new AuthenticationToken()
{
AuthenticationFactor = authenitcationFactor,
User = user
};
result.Add(authenticationToken);
return(Ok(result));
}
public async Task UpdateUser(AuthenticateUserDTO userUpdated)
{
var update = Builders <User> .Update
.Set(user => user.Id, userUpdated.Id);
await _mongoRepository.UpdateOneAsync(user => user.Id == userUpdated.Id, update);
}
public IActionResult Authenticate([FromBody] AuthenticateUserDTO userToAuthenticate)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (userToAuthenticate?.Username == null || userToAuthenticate.Password == null)
{
return(BadRequest());
}
var userAccount = _userServices.GetAllUsers().FirstOrDefault(x => x.Username == userToAuthenticate.Username);
if (userAccount == null || !BCrypt.Net.BCrypt.Verify(userToAuthenticate.Password, userAccount.PasswordHash))
{
return(BadRequest("Invalid credentials"));
}
var claims = new[] {
new Claim(JwtRegisteredClaimNames.Sub, _configuration["Jwt:Subject"]),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, DateTime.UtcNow.ToString()),
new Claim("Id", userAccount.Id.ToString()),
new Claim("UserName", userAccount.Username)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]));
var signIn = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(_configuration["Jwt:Issuer"], _configuration["Jwt:Audience"], claims, expires: DateTime.UtcNow.AddDays(1), signingCredentials: signIn);
return(Ok(new JwtSecurityTokenHandler().WriteToken(token)));
}
public IHttpActionResult AuthenticateUser(AuthenticateUserDTO authenticateUserDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (authenticateUserDTO == null)
{
return(BadRequest("userDTO should not have been null"));
}
EAuthentication eauthenitcation = EAuthentication.NotAuthenticated;
var user = db.Users.Where(u => u.MobileNo == authenticateUserDTO.MobileNo).FirstOrDefault();
if (user != null)
{
if (string.Compare(user.Password, authenticateUserDTO.Password) == 0)
{
eauthenitcation = EAuthentication.TwoFactorAuthenticated;
}
}
var result = new List <EAuthentication>();
result.Add(eauthenitcation);
return(Ok(result));
}
private bool VerifyIfUserExists(AuthenticateUserDTO user)
{
var userAuth = _userRepository.VerifyIfUserExists(user);
if (userAuth == null)
{
return(false);
}
return(true);
}
public async Task AddUser(AuthenticateUserDTO user)
{
var newUser = new User()
{
Email = user.Email,
Password = user.Password,
Name = user.Name
};
await _mongoRepository.InsertOneAsync(newUser);
}
public IActionResult Authenticate(AuthenticateUserDTO authenticateUserDto)
{
var user = _userService.FindByEmailPassword(authenticateUserDto.Email, authenticateUserDto.Password);
if (user == null)
{
return(Forbid());
}
var token = _authenticationService.GenerateToken(user);
return(Ok(new { Token = token }));
}
public bool ValidateUser(AuthenticateUserDTO userAuth)
{
var validUser = _mongoRepository.FindOne(user => user.Email == userAuth.Email && user.Password == userAuth.Password);
if (validUser == null)
{
return(false);
}
else
{
return(true);
}
}
public async Task <IActionResult> Authenticate(AuthenticateUserDTO user)
{
if (user == null)
{
return(BadRequest(Utils.GetResponse("EmptyUser", "The user is null")));
}
var result = await _signInManager.PasswordSignInAsync(user.Email, user.Password, false, true);
if (!result.Succeeded)
{
return(BadRequest(Utils.GetResponse("IncorrectCredentials", "Email or password are incorrect")));
}
var token = BuildToken(user.Email);
return(Ok(Utils.GetResponse("Token", token)));
}
public async Task <IActionResult> CreateToken([FromBody] AuthenticateUserDTO userDTO)
{
if (userDTO.Email == null)
{
return(Ok(new { Status = ReturnStatusCode.NotAuthorized, Message = "Usuário ou senha incorretos" }));
}
bool IsvalidUser = _userService.ValidateUser(userDTO);
var validUser = await _userService.GetUserByLogin(userDTO);
AddParamsToJWT();
if (IsvalidUser)
{
var tokenString = _authService.BuildJWTToken(tokenParams);
return(Ok(new { Status = ReturnStatusCode.Ok, Token = tokenString, TokenExpiresIn = _jwtTokenSettings.TokenExpiry, validUser.Id, UserName = validUser.Name }));
}
else
{
return(Ok(new { Status = ReturnStatusCode.NotAuthorized, Message = "Usuário ou senha incorretos" }));
}
}
public async Task <IActionResult> RegisterLogin([FromBody] AuthenticateUserDTO userDTO)
{
var email = string.IsNullOrEmpty(userDTO.Email);
var password = string.IsNullOrEmpty(userDTO.Password);
var name = string.IsNullOrEmpty(userDTO.Name);
if (email || password || name)
{
return(Unauthorized(new { ReturnStatusCode.NotAuthorized, Message = "Usuário, senha ou nome vazio", IsSignuped = false }));
}
if (userDTO.Password != userDTO.RepeatPassword)
{
return(Unauthorized(new { ReturnStatusCode.NotAuthorized, Message = "Senhas não indenticas", IsSignuped = false }));
}
await _userService.AddUser(userDTO);
AddParamsToJWT();
var validUser = await _userService.GetUserByLogin(userDTO);
var levels = Enum.GetValues(typeof(GameLevelType));
foreach (GameLevelType level in levels)
{
var userProgress = new UserProgressDTO
{
UserId = validUser.Id,
Module = level
};
_userService.InsertUserProgress(userProgress);
}
var tokenString = _authService.BuildJWTToken(tokenParams);
return(Ok(new { StatusCode = ReturnStatusCode.Ok, Message = "Cadastrado com sucesso", Token = tokenString, IsSignuped = true, validUser.Id, UserName = validUser.Name }));
}
public IActionResult RegisterLogin([FromBody] AuthenticateUserDTO userDTO)
{
var email = string.IsNullOrEmpty(userDTO.Email);
var password = string.IsNullOrEmpty(userDTO.Password);
var name = string.IsNullOrEmpty(userDTO.Name);
string tokenString = string.Empty;
if (email || password || name)
{
return(Unauthorized(new { ReturnStatusCode.NotAuthorized, Message = "Usuário, senha ou nome vazio", IsSignuped = false }));
}
if (userDTO.Password != userDTO.RepeatPassword)
{
return(Unauthorized(new { ReturnStatusCode.NotAuthorized, Message = "Senhas não indenticas", IsSignuped = false }));
}
_userService.AddUser(userDTO);
AddParamsToJWT();
tokenString = _authService.BuildJWTToken(tokenParams);
return(Ok(new { StatusCode = ReturnStatusCode.Ok, Message = "Cadastrado com sucesso", IsSignuped = true }));
}
public async Task <IActionResult> Authenticate([FromBody] AuthenticateUserDTO model)
{
var user = await userManager.FindByNameAsync(model.Username);
// check if user with username exists
if (user == null)
{
throw new BadRequestException("Username or password are incorrect.");
}
if (await userManager.CheckPasswordAsync(user, model.Password))
{
var token = await CreateTokenAsync(user);
int userTypeId;
if (await userManager.IsInRoleAsync(user, "administrator"))
{
userTypeId = (int)UserTypeEnum.Administrator;
}
else
{
userTypeId = (int)UserTypeEnum.Korisnik;
}
var result = new AuthenticationResponseDTO
{
Id = user.Id,
Firstname = user.Firstname,
Lastname = user.Lastname,
Token = token.Token,
UserTypeId = userTypeId
};
return(Ok(result));
}
throw new NotAuthorizedException("Username or password are incorrect.");
}
public async Task <OkResult> UpdateUser(AuthenticateUserDTO userDTO)
{
await _userService.UpdateUser(userDTO);
return(Ok());
}
public async Task RemoveUser(AuthenticateUserDTO userRemoved)
{
await _mongoRepository.DeleteOneAsync(
user => user.Email == userRemoved.Email);
}
public User GetUserByLogin(AuthenticateUserDTO user)
{
return(_userRepository.GetUserByLogin(user));
}
public bool ValidateUser(AuthenticateUserDTO user)
{
return(_userRepository.ValidateUser(user));
}
public async Task UpdateUser(AuthenticateUserDTO user)
{
await _userRepository.UpdateUser(user);
}
public async Task RemoveUser(AuthenticateUserDTO userRemoved)
{
await _userRepository.RemoveUser(userRemoved);
}
public User GetUserByLogin(AuthenticateUserDTO userAuth)
{
return(_mongoRepository.FindOne(user => user.Email == userAuth.Email && user.Password == userAuth.Password));
}
public async Task <IActionResult> RegisterUser(AuthenticateUserDTO userDTO)
{
await _userService.AddUser(userDTO);
return(Ok(new { StatusCode = ReturnStatusCode.Ok }));
}
public async Task <User> GetUserByLogin(AuthenticateUserDTO user)
{
return(await _userRepository.GetUserByLogin(user));
}
public User VerifyIfUserExists(AuthenticateUserDTO userAuth)
{
return(_mongoRepository.FindOne(user => user.Email == userAuth.Email));
}
public async Task <User> GetUserByLogin(AuthenticateUserDTO userAuth)
{
return(await _mongoRepository.FindOneAsync(user => user.Email == userAuth.Email && user.Password == userAuth.Password));
}
