public async Task <string> Authenticate(UserAuthenticateDTO userAuthenticate)
{
if (string.IsNullOrEmpty(userAuthenticate.Login))
{
throw new Exception("É necessário informar o login para autenticar!");
}
if (string.IsNullOrEmpty(userAuthenticate.Password))
{
throw new Exception("É necessário informar a senha para autenticar!");
}
var user = await _userRepository.GetByUsername(userAuthenticate.Login);
if (user == null)
{
throw new Exception("Usuário informado não existe no sistema!");
}
var encryptedPassword = GenerateHash.ComputeSha256Hash(userAuthenticate.Password);
if (encryptedPassword != user.Password)
{
throw new Exception("Não foi possível recuperar o token!");
}
return(TokenService.GenerateToken(user));
}
public async Task <IActionResult> Authenticate(UserAuthenticateDTO userAuthenticateDto)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(userAuthenticateDto.Email);
if (user == null)
{
return(NotFound());
}
var result =
await _signInManager.PasswordSignInAsync(user, userAuthenticateDto.Password, userAuthenticateDto.RememberMe, false);
if (result.Succeeded)
{
// проверяем, принадлежит ли URL приложению
if (!string.IsNullOrEmpty(userAuthenticateDto.ReturnUrl) && Url.IsLocalUrl(userAuthenticateDto.ReturnUrl))
{
return(Redirect(userAuthenticateDto.ReturnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "Неправильный логин и (или) пароль");
}
}
return(View(userAuthenticateDto));
}
public async Task <User> GetUserForPasswordAndUsername(UserAuthenticateDTO userAuthenticateDTO)
{
//Feito pois existe uma regra de hash no password
var userAux = _mapper.Map <UserAuthenticateDTO, User>(userAuthenticateDTO);
User user = await _context.TbUsers
.Where(w => w.UserName.Equals(userAux.UserName) && w.Password.Equals(userAux.Password))
.AsNoTracking()
.SingleOrDefaultAsync();
return(user);
}
public async Task <ActionResult <dynamic> > Authenticate([FromBody] UserAuthenticateDTO userAuthenticate)
{
try
{
var token = await _userService.Authenticate(userAuthenticate);
return(Ok(new { token }));
}
catch (Exception ex)
{
return(Problem(ex.Message));
}
}
public async Task <ActionResult <dynamic> > AuthenticateAsync([FromBody] UserAuthenticateDTO userAuthenticateDTO)
{
try
{
if (!ModelState.IsValid)
{
throw new Exception($"{ModelState.GenerateValidation()}");
}
User validUser = await _userService.GetUserForPasswordAndUsername(userAuthenticateDTO);
if (validUser == null)
{
return(NotFound(new { Message = "Usuário não encontrado!" }));
}
if (validUser.DeletedAt != null)
{
return(BadRequest(new
{
Message = $"O usuário {validUser.FName} {validUser.LName}, foi bloqueado na data {validUser.DeletedAt}!"
}));
}
var token = _tokenService.GenerateToken(validUser);
validUser.SetPassword("");
return(new OkObjectResult(new
{
BearerToken = token,
User = validUser
}));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
