public void AutenticarTest()
{
//Arrange
var id = new Guid("a566c99b-1ca7-48f9-a85e-68efd6ce2c2f");
var senha = "ErAyJqbYvpxujNXlXcbHkgyqo53xSquS1ePqk0DRyKTT0LjkMU8fbvExukvxzrkYarh8gBrw1clbG++4ztriuQ==";
var usuario = new Usuario
{
UsuarioId = id,
Nome = "Ale",
Senha = senha,
Email = "*****@*****.**",
Token = "456",
Telefones = new List <Telefone>()
};
_mockUsuarioService.Setup(a => a.Autenticar(usuario.Email, usuario.Senha, usuario.Token))
.Returns(It.IsAny <bool>())
.Verifiable();
_mockUsuarioRepository.Setup(a => a.Get(It.IsAny <Func <Usuario, bool> >())).Returns(usuario).Verifiable();
_mockUsuarioRepository.Setup(a => a.Atualizar(usuario)).Returns(usuario).Verifiable();
//Act
_usuarioService.Autenticar(usuario.Email, usuario.Senha, usuario.Token);
//Assert
_repository.VerifyAll();
}
public ActionResult Acessar(Guid codigo)
{
try
{
var usuario = usuarioService.Autenticar(codigo);
return(Autenticar(usuario));
}
catch (Exception e)
{
return(RedirectToAction("Index", new { erro = e.Message }));
}
}
public IActionResult Authenticate([FromBody] UsuarioRequest usuario)
{
Usuario user = Service.Autenticar(usuario.Email, usuario.Senha);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = config.Value.Secret;
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.ID.ToString()),
new Claim(ClaimTypes.Role, user.Perfil.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes(key)), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new { token = tokenHandler.WriteToken(token), user }));
}
public async Task AutenticarUsuario_AutenticadoComSucesso()
{
// Arrange
var autenticacaoViewModel = new AutenticacaoRequisicaoViewModel {
Email = "*****@*****.**",
Senha = "abc"
};
var autenticacaoRespostaViewModel = new AutenticacaoRespostaViewModel();
var autenticacao = new Usuario(Guid.NewGuid(), "Guilherme", "*****@*****.**", "123456");
var usuarioDto = new UsuarioDto()
{
Id = Guid.NewGuid()
};
// Act
var mapper = new Mock <IMapper>();
var mockUsuario = new Mock <IUsuarioRepository>();
var mockSecurity = new Mock <ISecurityService>();
mapper.Setup(c => c.Map <Usuario>(autenticacaoViewModel)).Returns(autenticacao);
mockUsuario.Setup(c => c.ObterPorEmailESenha(autenticacao)).Returns(Task.FromResult(autenticacao));
mapper.Setup(c => c.Map <AutenticacaoRespostaViewModel>(autenticacao)).Returns(autenticacaoRespostaViewModel);
mapper.Setup(c => c.Map <UsuarioDto>(autenticacao)).Returns(usuarioDto);
mockSecurity.Setup(c => c.gerarJwtToken(usuarioDto)).Returns("asfgvbv");
var service = new UsuarioService(mapper.Object, mockUsuario.Object, mockSecurity.Object);
var adicionar = await service.Autenticar(autenticacaoViewModel);
// Assert
Assert.IsType(typeof(AutenticacaoRespostaViewModel), adicionar);
}
public bool Autenticar(string rut, string clave)
{
return(_usuarioService.Autenticar(new UsuarioAutenticador
{
Clave = clave,
Rut = rut
}));
}
public object Autenticar(String login, String senha)
{
String jwt = usuarioService.Autenticar(new Usuario {
login = login, senha = senha
});
return(new { JWT = jwt });
}
public async Task Autentica_Ok_DadoQueEstaRegistrado()
{
await DadoUnUsuarioRegistrado();
var result = await _service.Autenticar(USERNAME, PASSWORD);
result.Should().BeOfType <Usuario>();
}
public ActionResult <dynamic> Autenticar([FromBody] Usuario _usuario)
{
var retorno = _usuarioService.Autenticar(_usuario);
if (Settings.IsPropertyExist(retorno, "message"))
{
return(NotFound(retorno.GetType().GetProperty("message").GetValue(retorno, null).ToString()));
}
else
{
return(Ok(retorno));
}
}
public IHttpActionResult Autenticar([FromBody] AutenticacaoModel dados)
{
try
{
var usuario = usuarioService.Autenticar(dados.email, dados.senha);
var model = new UsuarioModel(usuario);
return(Ok(model));
}
catch (Exception e)
{
return(Ok(new MensagemModel(MensagemModel.Tipos.Erro, e.Message)));
}
}
public ActionResult Entrar(UsuarioViewModel usuarioViewModel)
{
AutenticacaoUsuario usuarioParaAutenticar = new AutenticacaoUsuario();
usuarioParaAutenticar.Usuario = AutoMapper.Mapper.Map <Usuario>(usuarioViewModel);
UsuarioService usuarioService = new UsuarioService();
var usuarioCadastrado = usuarioService.Autenticar(usuarioParaAutenticar);
if (!usuarioCadastrado.EstaValido)
{
ModelState.AddModelError("", "Senha ou código(s) incorreto(s)."); //ou algum outro problema, investigar
return(View("Index"));
}
else
{
Session[Login.ChaveUsuarioSession] = usuarioCadastrado.Sucesso; // pra poder gerar o token
var professorUsuario = new ProfessorService().ObterPeloIdUsuario(usuarioCadastrado.Sucesso.Usuario.Id);
//if (true) { }
if (professorUsuario.Sucesso == null && !professorUsuario.EstaValido)
{
var alunoUsuario = new AlunoService().ObterPeloIdUsuario(usuarioCadastrado.Sucesso.Usuario.Id);
if (alunoUsuario.Sucesso == null && !alunoUsuario.EstaValido)
{
ModelState.AddModelError("", "Erro interno. O código do usuário está cadastrado mas não existe nenhum professor ou aluno com este código.");
return(View("Index"));
}
else
{
alunoUsuario.Sucesso.Codigo = usuarioCadastrado.Sucesso.Usuario.Codigo;
alunoUsuario.Sucesso.Senha = usuarioCadastrado.Sucesso.Usuario.Senha;
var autenticacaoAluno = new AutenticacaoAluno(alunoUsuario.Sucesso, usuarioCadastrado.Sucesso.Token);
Session[Login.ChaveUsuarioSession] = autenticacaoAluno;
return(RedirectToAction("Index", "Home"));
}
}
else
{
professorUsuario.Sucesso.Codigo = usuarioCadastrado.Sucesso.Usuario.Codigo;
professorUsuario.Sucesso.Senha = usuarioCadastrado.Sucesso.Usuario.Senha;
var autenticacaoProfessor = new AutenticacaoProfessor(professorUsuario.Sucesso, usuarioCadastrado.Sucesso.Token);
Session[Login.ChaveUsuarioSession] = autenticacaoProfessor;
return(RedirectToAction("Index", "Home"));
}
}
}
public object Autenticar([FromBody] Usuario usuario,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
bool credenciaisValidas = UsuarioService.Autenticar(usuario.Email, usuario.Senha);
if (credenciaisValidas)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(usuario.Email, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Email)
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao +
TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
return(new
{
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK"
});
}
else
{
return(new
{
authenticated = false,
message = "Falha ao autenticar"
});
}
}
private void toolStripButton_entrar_Click(object sender, EventArgs e)
{
UsuarioService userS = new UsuarioService();
if (userS.Autenticar(textBox_usuario.Text, textBox_senha.Text) || (textBox_usuario.Text.Equals("g") && textBox_senha.Text.Equals("g")))
{
this.DialogResult = DialogResult.OK;
logado = textBox_usuario.Text;
}
else
{
MessageBox.Show("Usuario ou senha incorretos!", "Erro de Autenticação", MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
}
private void Autenticacao_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Enter)
{
UsuarioService userS = new UsuarioService();
if (userS.Autenticar(textBox_usuario.Text, textBox_senha.Text) || (textBox_usuario.Text.Equals("g") && textBox_senha.Text.Equals("g")))
{
this.DialogResult = DialogResult.OK;
this.Close();
}
else
{
MessageBox.Show("Usuario ou senha incorretos!", "Erro de Autenticação", MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
}
}
public async Task AutenticarUsuario_Validar_DeveRetornarErro(string email)
{
// Arrange
var autenticacao = new AutenticacaoRequisicaoViewModel {
Email = email,
Senha = string.Empty
};
// Act
var service = new UsuarioService(_mapper.Object, _mockusuario.Object, _mockSecurity.Object);
var autenticar = await service.Autenticar(autenticacao);
// Assert
Assert.Null(autenticar);
Assert.False(autenticacao.ValidationResult.IsValid);
}
private void Autenticacao_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Enter)
{
UsuarioService userS = new UsuarioService();
if (userS.Autenticar(textBox_usuario.Text, textBox_senha.Text))
{
this.DialogResult = DialogResult.OK;
UsuarioLogado = new UsuarioDAO().BuscarUsuario(textBox_usuario.Text);
logado = textBox_usuario.Text;
}
else
{
MessageBox.Show("Usuario ou senha incorretos!", "Erro de Autenticação", MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
}
}
public IActionResult Index([FromForm] string Email, [FromForm] string Senha)
{
if (UsuarioService.Autenticar(Email, Senha))
{
TempData["Nome"] = UsuarioService.ObterNome(Email);
return(RedirectToAction("Index", "Home", new { area = "PainelAdministrativo" }));
//TODO: Implementar sistema de controle de acesso em páginas específicas
}
else
{
ViewBag.Error = true;
ViewBag.UltimoEmail = Email;
ViewData["Title"] = "Login";
return(View());
}
}
public async Task <ActionResult> Login(string email, string senha)
{
try
{
UsuarioDTO user = await userService.Autenticar(email, senha);
//se chegou aqui sucesso
HttpCookie cookie = new HttpCookie("USERIDENTITY", user.ID.ToString());
cookie.Expires = DateTime.Now.AddMinutes(25);
Response.Cookies.Add(cookie);
return(RedirectToAction("Index", "Cliente"));
}
catch (Exception ex)
{
ViewBag.Erros = ex.Message;
}
return(View());
}
public async Task AutenticarUsuario_UsuarioInvalido_RetornarNull()
{
// Arrange
var autenticacaoViewModel = new AutenticacaoRequisicaoViewModel();
var autenticacao = new Usuario(Guid.NewGuid(), "Guilherme", "*****@*****.**", "123456");
// Act
var mapper = new Mock <IMapper>();
var mock = new Mock <IUsuarioRepository>();
mapper.Setup(c => c.Map <Usuario>(autenticacaoViewModel)).Returns(autenticacao);
mock.Setup(c => c.ObterPorEmailESenha(autenticacao)).Returns(Task.FromResult <Usuario>(null));
var service = new UsuarioService(mapper.Object, mock.Object, _mockSecurity.Object);
var autenticar = await service.Autenticar(autenticacaoViewModel);
// Assert
Assert.Null(autenticar);
}
private Task <ClaimsIdentity> ObterClaims(AutenticarCommand command)
{
var usuarioService = new UsuarioService();
var usuario = usuarioService.Autenticar(command.Usuario, command.Senha);
if (usuario == null)
{
return(Task.FromResult <ClaimsIdentity>(null));
}
_usuario = usuario;
return(Task.FromResult(new ClaimsIdentity(
new GenericIdentity(_usuario.Nome, "Token"),
new[] {
new Claim("JwtValidation", "Usuario")
})));
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
await Task.Run(() =>
{
try
{
var user = _service.Autenticar(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", "Usuário ou senha incorreto!");
return;
}
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim(ClaimTypes.Name, user.Email));
identity.AddClaim(new Claim(ClaimTypes.GivenName, user.Nome));
GenericPrincipal principal = new GenericPrincipal(identity, null);
Thread.CurrentPrincipal = principal;
var props = new AuthenticationProperties(new Dictionary <string, string>());
//Formatters
var jsonSettings = new HttpConfiguration().Formatters.JsonFormatter.SerializerSettings;
jsonSettings.Formatting = Formatting.Indented;
jsonSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
//props.Dictionary.Add(new KeyValuePair<string, string>("DadosUsuario", JsonConvert.SerializeObject(Mapper.Map<Usuario, UsuarioViewModel>(user), jsonSettings)));
props.Dictionary.Add(new KeyValuePair <string, string>("email", user.Email));
props.Dictionary.Add(new KeyValuePair <string, string>("nome", user.Nome));
context.Validated(new AuthenticationTicket(identity, props));
}
catch (Exception)
{
context.SetError("error_grant", "Usuário não existe!");
}
});
}
protected void btnIniciarSesion_OnClick(object sender, EventArgs e)
{
_usuarioService = new UsuarioService(string.Empty);
var token = _usuarioService.Autenticar(txtRut.Text, txtContrasena.Text);
if (token == null)
{
ScriptManager.RegisterStartupScript(Page, Page.GetType(), "errorToken", "Swal.fire('Error','El usuario y contraseña no coinciden', 'error');", true);
return;
}
_usuarioService = new UsuarioService(token.access_token);
Session["token"] = token;
var usuario = _usuarioService.ObtenerPorRut(txtRut.Text);
if (usuario != null)
{
Session["usuario"] = usuario;
Response.Redirect("../Mantenedores/inicio");
}
}
static void Main(string[] args)
{
Console.WriteLine("\n\nAutenticação");
try
{
UsuarioAutenticarDTO usuarioAutenticarDTO = new UsuarioAutenticarDTO();
Console.Write("\nLogin: "******"\nSenha: ");
usuarioAutenticarDTO.Senha = Console.ReadLine();
UsuarioService usuarioService = new UsuarioService(new UsuarioDAL());
Console.Clear();
var respostaAutenticarUsuario = usuarioService.Autenticar(ref usuarioAutenticarDTO);
if (respostaAutenticarUsuario.Erros.Count() > 0)
{
ExibirErros(respostaAutenticarUsuario.Erros);
}
if (respostaAutenticarUsuario.RetornoAutenticacaoUsuario)
{
var respostaPerfilUsuario = usuarioService.ListarPerfilsDeUsuario(usuarioAutenticarDTO);
if (respostaPerfilUsuario.Erros.Count() > 0)
{
ExibirErros(respostaPerfilUsuario.Erros);
}
ApresentarDadosUsuario(usuarioAutenticarDTO, respostaPerfilUsuario.PerfilsDeUsuario);
int opcao = ObterOpcao();
while (opcao != 0)
{
Console.Clear();
switch (opcao)
{
case 1:
if (respostaPerfilUsuario.PerfilsDeUsuario.Any(l => l.IdPerfil == (int)EPerfil.Operacao))
{
CadastrarCliente(usuarioAutenticarDTO);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nAcesso negado");
Console.ForegroundColor = ConsoleColor.White;
}
break;
case 2:
if (respostaPerfilUsuario.PerfilsDeUsuario.Any(l => l.IdPerfil == (int)EPerfil.Operacao))
{
EnviarAnaliseGerencia(usuarioAutenticarDTO);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nAcesso negado");
Console.ForegroundColor = ConsoleColor.White;
}
break;
case 3:
if (respostaPerfilUsuario.PerfilsDeUsuario.Any(l => l.IdPerfil == (int)EPerfil.Gerencia))
{
EnviarAnaliseControleDeRisco(usuarioAutenticarDTO); // juntar com aprovar
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nAcesso negado");
Console.ForegroundColor = ConsoleColor.White;
}
break;
case 4:
if (respostaPerfilUsuario.PerfilsDeUsuario.Any(l => l.IdPerfil == (int)EPerfil.Gerencia || l.IdPerfil == (int)EPerfil.Controle_de_risco))
{
AprovarFluxo(usuarioAutenticarDTO);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nAcesso negado");
Console.ForegroundColor = ConsoleColor.White;
}
break;
case 5:
if (respostaPerfilUsuario.PerfilsDeUsuario.Any(l => l.IdPerfil == (int)EPerfil.Gerencia || l.IdPerfil == (int)EPerfil.Controle_de_risco))
{
ReprovarFluxo(usuarioAutenticarDTO);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nAcesso negado");
Console.ForegroundColor = ConsoleColor.White;
}
break;
case 6:
if (respostaPerfilUsuario.PerfilsDeUsuario.Any(l => l.IdPerfil == (int)EPerfil.Gerencia || l.IdPerfil == (int)EPerfil.Controle_de_risco))
{
CorrecaoDeCadastro(usuarioAutenticarDTO);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nAcesso negado");
Console.ForegroundColor = ConsoleColor.White;
}
break;
case 7:
if (respostaPerfilUsuario.PerfilsDeUsuario.Any(l => l.IdPerfil == (int)EPerfil.Operacao))
{
DevolverCadastro(usuarioAutenticarDTO);
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nAcesso negado");
Console.ForegroundColor = ConsoleColor.White;
}
break;
default:
Console.Clear();
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nOpção inválida!!!");
Console.ForegroundColor = ConsoleColor.White;
break;
}
ApresentarDadosUsuario(usuarioAutenticarDTO, respostaPerfilUsuario.PerfilsDeUsuario);
opcao = ObterOpcao();
}
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nAcesso negado");
Console.ForegroundColor = ConsoleColor.White;
}
Console.WriteLine("\n\nAté a próxima!!!");
Console.ReadKey();
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(e.Message);
Console.ForegroundColor = ConsoleColor.White;
}
}
public IActionResult Autenticar([FromBody] Usuario entidade)
{
return(Ok(_servico.Autenticar(entidade.Login, entidade.Senha)));
}