public ICommandResult <Notificacao> Handler(LoginUsuarioCommand command)
{
try
{
string login = command.Login;
string senha = command.Senha;
if (!_repository.CheckLogin(login))
{
AddNotificacao("Login", "Login incorreto! Esse login de usuário não existe");
}
if (Invalido)
{
return(new CommandResult <Notificacao>("Inconsistência(s) no(s) dado(s)", Notificacoes));
}
UsuarioQueryResult usuario = _repository.Logar(login, senha);
if (usuario != null)
{
return(new CommandResult <Notificacao>("Usuário logado com sucesso!", usuario));
}
else
{
AddNotificacao("Senha", "Senha incorreta!");
return(new CommandResult <Notificacao>("Inconsistência(s) no(s) dado(s)", Notificacoes));
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public ICommandResult Handle(LoginUsuarioCommand command)
{
// Fail Fast Validations
command.Validar();
if (command.Invalid)
{
AddNotifications(command);
return(new CommandResult(false, "Não foi possível efetuar o login"));
}
var result = _signInManager.PasswordSignInAsync(command.UserName, command.Password, false, false);
if (!result.Result.Succeeded)
{
AddNotification("falha", "Não foi possível realizar login");
return(new CommandResult(false, "Não foi possível realizar esta operação"));
}
// Retornar informações
return(new CommandResult(true, "Operação realizada com sucesso"));
}
public void Erro_ao_efetuar_login_com_email_nao_cadastrado()
{
var cmd = new LoginUsuarioCommand("*****@*****.**", "123456");
var hdl = new LoginUsuarioHandler(_repositorio.Object);
var result = (ResponseCommandResult)hdl.Handle(cmd);
Assert.IsTrue(!result.Valid, result.Message);
}
public async Task <IActionResult> Login([FromBody] LoginUsuarioCommand logarModel)
{
var loginModel = await _mediator.Send(logarModel);
if (loginModel == null)
{
return(BadRequest());
}
return(Ok(loginModel));
}
private async Task <object> GerarTokenUsuario(LoginUsuarioCommand login)
{
var user = await _userManager.FindByNameAsync(login.UserName);
var userClaims = await _userManager.GetClaimsAsync(user);
userClaims.Add(new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()));
userClaims.Add(new Claim(JwtRegisteredClaimNames.Email, user.Email));
userClaims.Add(new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()));
userClaims.Add(new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(DateTime.UtcNow).ToString(), ClaimValueTypes.Integer64));
// Necessário converver para IdentityClaims
var identityClaims = new ClaimsIdentity();
identityClaims.AddClaims(userClaims);
var handler = new JwtSecurityTokenHandler();
var signingConf = new SigningCredentialsConfiguration();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = _tokenDescriptor.Issuer,
Audience = _tokenDescriptor.Audience,
SigningCredentials = signingConf.SigningCredentials,
Subject = identityClaims,
NotBefore = DateTime.Now,
Expires = DateTime.Now.AddMinutes(_tokenDescriptor.MinutesValid)
});
var encodedJwt = handler.WriteToken(securityToken);
var response = new
{
access_token = encodedJwt,
expires_in = DateTime.Now.AddMinutes(_tokenDescriptor.MinutesValid),
user = new
{
id = user.Id,
nome = user.UserName,
matricula = user.Matricula,
email = user.Email,
claims = userClaims.Select(c => new { c.Type, c.Value })
}
};
return(response);
}
public async Task <ActionResult <ResponseResult> > Login([FromBody] LoginUsuarioCommand command)
{
var response = await EventBus.SendCommand(command);
if (response.HasFails)
{
return(BadRequest(response.Fails));
}
return(Ok(response.Data));
}
public async Task Login_AoRealizarLoginComComandoInvalido_RetornarNotificacoesComFalha()
{
// Arrange
var command = new LoginUsuarioCommand("", "");
// Act
var responseResult = await _handler.Handle(command, CancellationToken.None);
// Assert
Assert.True(responseResult.HasFails);
}
public void Erro_ao_efetuar_login_com_senha_invalida()
{
var cmd = new LoginUsuarioCommand("*****@*****.**", "123456");
_repositorio.Setup(x => x.ObterEntidade(It.IsAny <Expression <Func <Dominio.Entidades.Usuario, bool> > >()))
.Returns(new Dominio.Entidades.Usuario("fulano xpto", cmd.Email, "5684582", "candidato", false));
var hdl = new LoginUsuarioHandler(_repositorio.Object);
var result = (ResponseCommandResult)hdl.Handle(cmd);
Assert.IsTrue(!result.Valid, result.Message);
}
public async Task RealizarLoginApi()
{
var userCommand = new LoginUsuarioCommand("*****@*****.**", "123");
var response = await Client.PostAsJsonAsync("/api/usuarios/login", userCommand);
response.EnsureSuccessStatusCode();
var data = await response.Content.ReadAsStringAsync();
var jwt = JsonConvert.DeserializeObject <JsonWebTokenTestDto>(data);
Token = jwt.Jwt.Token;
}
public async Task Usuario_RealizarLogin_RetornarToken200Sucesso()
{
// Arrange
var criarUsuarioCommand = new CriarUsuarioCommand("*****@*****.**", "Maria", -23.5950753, -46.645421, "Admin123@");
await _testsFixture.Client.PostAsJsonAsync("/api/usuarios/registrar", criarUsuarioCommand);
var loginUsuarioCommand = new LoginUsuarioCommand("*****@*****.**", "Admin123@");
// Act
var postResponseLogin = await _testsFixture.Client.PostAsJsonAsync("/api/usuarios/login", loginUsuarioCommand);
// Assert
postResponseLogin.EnsureSuccessStatusCode();
}
public async Task Login_AoRealizarLoginComEmailQueNaoExiste_RetornarNotificacoesComFalha()
{
// Arrange
var command = new LoginUsuarioCommand("*****@*****.**", "Admin123!");
//Obter usuario
_mocker.GetMock <IUnitOfWork>()
.Setup(p => p.Usuarios.ObterPorEmailAsync(command.Email));
// Act
var responseResult = await _handler.Handle(command, CancellationToken.None);
// Assert
Assert.True(responseResult.HasFails);
}
public UsuarioDTO Authenticate(LoginUsuarioCommand command)
{
try
{
Usuario usuario = usuarioDomainService.Get(command.EMail, command.Senha);
var user = mapper.Map <UsuarioDTO>(usuario);
if (user != null)
{
user.AccessToken = tokenService.GenerateToken(command.EMail);
return(user);
}
return(null);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task <IActionResult> Login([FromBody] LoginUsuarioCommand command)
{
var user = await _userManager.FindByNameAsync(command.UserName);
if (user == null)
{
return(BadRequest("O usuário informado não existe"));
}
var result = _usuarioHandler.Handle(command);
if (_usuarioHandler.Notifications.Any())
{
return(Response(result, _usuarioHandler.Notifications));
}
var response = await GerarTokenUsuario(command);
return(Response(response, _usuarioHandler.Notifications));
}
public IActionResult Autenthicate(LoginUsuarioCommand command)
{
try
{
var user = usuarioApplicationService.Authenticate(command);
if (user != null)
{
return(Ok(new
{
message = "Usuário autenticado com sucesso!",
user = user
}));
}
return(StatusCode(418, "e-mail e/ou senha inválidos"));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public async Task Login_AoRealizarLoginComSenhaInvalida_RetornarNotificacoesComFalha()
{
// Arrange
var command = new LoginUsuarioCommand("*****@*****.**", "senhaerrada");
var usuario = Usuario.Criar("test", "*****@*****.**", 0, 0, UsuarioRole.Cliente);
usuario.AdicionarPassword("teste");
//Obter usuario
_mocker.GetMock <IUnitOfWork>()
.Setup(p => p.Usuarios.ObterPorEmailAsync(command.Email))
.Returns(Task.FromResult(usuario));
// Act
var responseResult = await _handler.Handle(command, CancellationToken.None);
// Assert
Assert.True(responseResult.HasFails);
}
public async Task Usuario_RevalidaToken_RetornarToken200Sucesso()
{
//Arrange
// Criar Usuario
var criarUsuarioCommand = new CriarUsuarioCommand("*****@*****.**", "Maria", -23.5950753, -46.645421, "Admin123@");
await _testsFixture.Client.PostAsJsonAsync("/api/usuarios/registrar", criarUsuarioCommand);
//Logar Usuario
var loginUsuarioCommand = new LoginUsuarioCommand("*****@*****.**", "Admin123@");
var response = await _testsFixture.Client.PostAsJsonAsync("/api/usuarios/login", loginUsuarioCommand);
var data = await response.Content.ReadAsStringAsync();
var jwtDto = JsonConvert.DeserializeObject <JsonWebTokenTestDto>(data);
var refToken = new RefreshTokenCommand(jwtDto.Email, jwtDto.Jwt.Token, jwtDto.Jwt.RefreshToken.Token);
// Act
var responseRefresh = await _testsFixture.Client.PostAsJsonAsync("/api/usuarios/refresh", refToken);
// Assert
responseRefresh.EnsureSuccessStatusCode();
}
public ActionResult <ApiResponse <UsuarioQueryResult, Notificacao> > UsuarioLogin([FromBody] LoginUsuarioCommand command)
{
try
{
if (Request.Headers["ChaveAPI"].ToString() != _ChaveAPI)
{
return(StatusCode(StatusCodes.Status401Unauthorized, new ApiResponse <object, Notificacao>("Acesso negado", new List <Notificacao>()
{
new Notificacao("Chave da API", "ChaveAPI não corresponde com a chave esperada")
})));
}
if (command == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, new ApiResponse <object, Notificacao>("Parâmentros inválidos", new List <Notificacao>()
{
new Notificacao("Parâmetros de entrada", "Parâmetros de entrada estão nulos")
})));
}
if (!command.ValidarCommand())
{
return(StatusCode(StatusCodes.Status400BadRequest, new ApiResponse <object, Notificacao>("Parâmentros inválidos", command.Notificacoes)));
}
var result = _handler.Handler(command);
if (result.Sucesso)
{
UsuarioQueryResult usuarioQR = (UsuarioQueryResult)result.Dados;
string token = _tokenService.GenerateToken(usuarioQR);
UsuarioTokenQueryResult usuarioTokenQR = new UsuarioTokenQueryResult()
{
Id = usuarioQR.Id,
Login = usuarioQR.Login,
Senha = usuarioQR.Senha,
Privilegio = usuarioQR.Privilegio,
Token = token
};
return(StatusCode(StatusCodes.Status200OK, new ApiResponse <object, Notificacao>(result.Mensagem, usuarioTokenQR)));
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, new ApiResponse <object, Notificacao>(result.Mensagem, result.Erros)));
}
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new ApiResponse <object, Notificacao>("Erro", new List <Notificacao>()
{
new Notificacao("Erro", e.Message)
})));
}
}
public async Task <ActionResult <BaseApiResponse <UsuarioDto> > > Login(LoginUsuarioCommand command)
{
return(Ok(await Mediator.Send(command)));
}
