public async Task <IActionResult> Login(UsuarioLoginVM usuarioLoginVM)
{
if (ModelState.IsValid)
{
var PasswordHash = new PasswordHasher <Usuario>();
var existingUser = _userManager.Users.SingleOrDefault(u => u.Email == usuarioLoginVM.Email);
if (existingUser == null)
{
// We dont want to give to much information on why the request has failed for security reasons
return(NotFound("No se encuentra el usuario con email: " + usuarioLoginVM.Email));
}
// Now we need to check if the user has inputed the right password
var isCorrect = await _userManager.CheckPasswordAsync(existingUser, usuarioLoginVM.Password);
if (isCorrect)
{
return(await generateJwtAsync(existingUser));
}
}
return(BadRequest("Credencial invalida. Vuelva a intentarlo"));
}
public IActionResult Post([FromBody] UsuarioLoginVM usuarioLoginVM)
{
var usuarioLoginDTO = Mapper.Map <UsuarioLoginDTO>(usuarioLoginVM);
var result = _usuarioService.Logar(usuarioLoginDTO);
return(Ok(result));
}
public ActionResult Login(UsuarioLoginVM viewModel, string returnUrl)
{
try
{
Gerente.ValidarLoginESenha(viewModel.Login, viewModel.Senha);
var usuarioLogado = Contexto.Usuarios.SingleOrDefault(u => u.Login == viewModel.Login);
FormsAuthentication.SetAuthCookie(usuarioLogado.Nome, viewModel.ManterConectado);
Sessao.RegistrarUsuarioLogadoEmSessao(UsuarioMapeador.Mapear(usuarioLogado));
Sessao.RegistrarMenuDoUsuarioLogadoEmSessao(usuarioLogado.GrupoDeUsuario.NivelDeAcesso.Nivel);
return(RedirectToLocal(returnUrl));
}
catch (RegraDeNegocioException e)
{
e.CopiarPara(ModelState);
viewModel.Mensagem = "Erro";
return(View(viewModel));
}
//if (ModelState.IsValid && WebSecurity.Login(model.Login, model.Senha, persistCookie: model.ManterConectado))
//{
//return RedirectToLocal(returnUrl);
//}
// If we got this far, something failed, redisplay form
//ModelState.AddModelError("", "The user name or password provided is incorrect.");
//return View(viewModel);
}
public ActionResult Autenticar(UsuarioLoginVM vm)
{
if (ModelState.IsValid)
{
Login(_domain.Login(vm, Session.SessionID));
return(RedirectToAction("Index", "Dashboard"));
}
this.AlertError("Atenção!", "Não foi possível autenticar");
return(View(vm));
}
public UsuarioFuncionario Login(UsuarioLoginVM vm, string sessionId)
{
var user = Get().Single(a => a.Email == vm.Email && a.Senha == vm.Senha && a.Ativo);
RefreshSessionId(sessionId, user.SessionId);
user.SessionId = sessionId;
user.DtAtividade = DateTime.Now;
SaveChanges();
return(user);
}
public async Task <ActionResult> Login(UsuarioLoginVM usuarioLoginVM)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var result = await _signInmanager.PasswordSignInAsync(usuarioLoginVM.Email, usuarioLoginVM.Senha, false, true);
if (result.Succeeded)
{
var usuario = await _usermanager.FindByEmailAsync(usuarioLoginVM.Email);
var roles = await _usermanager.GetRolesAsync(usuario);
var identityClaims = new ClaimsIdentity();
identityClaims.AddClaims(await _usermanager.GetClaimsAsync(usuario));
var token = TokenService.GerarToken(usuario, identityClaims, roles, _tokenConfig);
var response = new LoginResponseVM
{
Token = token,
ExpiraEm = 0,
Usuario = new TokenUsuarioVM
{
Id = usuario.Id,
Email = usuario.Email,
Claims = identityClaims.Claims.Select(c => new ClaimVM {
Tipo = c.Type, Valor = c.Value
})
}
};
_logger.LogInformation($"Novo login usuário: {usuario.Email}");
return(CustomResponse(response));
}
if (result.IsLockedOut)
{
NotificarErro("Usuário temporariamente bloqueado.");
return(CustomResponse());
}
NotificarErro("Usuário inválido");
return(CustomResponse());
}
public async Task <UsuarioRespostaLogin> Login(UsuarioLoginVM usuarioLogin)
{
var loginContent = ObterConteudo(usuarioLogin);
var response = await _httpClient.PostAsync("/api/Auth/Login", loginContent);
if (!TratarErrosResponse(response))
{
return(new UsuarioRespostaLogin()
{
ErroResult = await DeserializarObjetoResponse <ResponseResult>(response)
});
}
var result = await DeserializarObjetoResponse <UsuarioRespostaLogin>(response);
return(result);
}
public async Task <IActionResult> Index(UsuarioLoginVM pModel)
{
try
{
if (!ModelState.IsValid)
{
return(View(pModel));
}
await HttpContext.SignInAsync(_ServiceUsuario.RetornaAutenticacaoUsuario(pModel.Login, pModel.Senha));
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
ViewData[Constantes.ViewDataMensagemErro] = ex.Message;
return(View(pModel));
}
}
public async Task <IActionResult> Login(UsuarioLoginVM model, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var resposta = await _autenticacaoService.Login(model);
if (ResponsePossuiErros(resposta.ErroResult))
{
return(View(model));
}
await _autenticacaoService.RealizarLogin(resposta);
if (!string.IsNullOrWhiteSpace(returnUrl))
{
return(LocalRedirect(returnUrl));
}
return(RedirectToAction("Index", "Catalogo"));
}
public async Task <IActionResult> Login(UsuarioLoginVM usuarioLogin)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var result = await _authenticationService.SignInManager.PasswordSignInAsync(usuarioLogin.Email, usuarioLogin.Senha,
false, true);
if (result.Succeeded)
{
return(CustomResponse(await _authenticationService.GerarJwt(usuarioLogin.Email)));
}
if (result.IsLockedOut)
{
AdicionarErroProcessamento("Usuário temporariamente bloqueado por tentativas inválidas");
return(CustomResponse());
}
AdicionarErroProcessamento("Usuário ou Senha incorretos");
return(CustomResponse());
}