public IActionResult UserLogin([FromForm] UsuarioConsultaDto objUsuarioConsultaDto)
{
objUsuarioConsultaDto.Password = Encriptador.Encriptar(objUsuarioConsultaDto.Password);
if (string.IsNullOrWhiteSpace(objUsuarioConsultaDto.Password))
{
ViewBag.Error = "Ingrese Usuario o Contraseña";
return(View("Index"));
}
HttpContext.Session.SetString("Usu", objUsuarioConsultaDto.Usuarios);
HttpContext.Session.SetString("Pas", objUsuarioConsultaDto.Password);
try
{
objUsuarioConsultaDto = _Usuario.UsuarioLogin(objUsuarioConsultaDto);
if (string.IsNullOrEmpty(objUsuarioConsultaDto.Correo))
{
ViewBag.Error = "Usuario o Contraseña Incorrecto";
UsuarioLoginDto objUsuarioLoginDto = new UsuarioLoginDto();
objUsuarioLoginDto.Tipo = "Login";
return(View("Index", objUsuarioLoginDto));
}
GenerateTicketAuthentication(objUsuarioConsultaDto);
Log.Information("INICIO");
HttpContext.Session.SetString("_TipoEmpresa", GetPerfil());
// HttpContext.Session.SetString("_TipoEmpresa",objUsuarioConsultaDto.TipoEmpresa);
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
Log.Error(ex.Message);
ViewBag.Error = "Usuario o Contraseña Incorrecto";
return(View("Index"));
}
}
public async Task <IActionResult> Login(UsuarioLoginDto usuarioLoginDto)
{
try
{
var usuario = await _usuarioManager.FindByEmailAsync(usuarioLoginDto.Email.ToUpper());
var result = await _signInManager.CheckPasswordSignInAsync(usuario, usuarioLoginDto.Senha, false);
if (!result.Succeeded)
{
return(Unauthorized());
}
var appUsuario = await _usuarioManager.Users
.FirstOrDefaultAsync(u => u.NormalizedUserName == usuarioLoginDto.Email.ToUpper());
var pessoa = await _servicosPessoas.BuscarPessoaPorId(usuario.IdPessoa);
return(Ok(new
{
Token = GenerateJwtToken(appUsuario).Result,
Usuario = new
{
Nome = pessoa.Nome
}
}));
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError,
"Erro na autenticação!"));
}
}
public async Task <IActionResult> Post([FromBody] UsuarioLoginDto usuarioLoginDto,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
var tokenDto = await _usuarioService.ValidarLogin(usuarioLoginDto);
switch (tokenDto.SituacaoAutenticacaoUsuario)
{
case EnumSituacaoAutenticacaoUsuario.Autenticado:
var name = $"{tokenDto.Login}_PhoenixEs";
var identity = new ClaimsIdentity(
new GenericIdentity(name, ApiResource.Login),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, name)
}
);
var dataCriacao = DateTime.Now;
var 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);
tokenDto.AccessToken = token;
tokenDto.CriadoEm = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss");
tokenDto.ExpiraEm = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss");
tokenDto.Mensagem = ApiResource.OK;
return(Ok(tokenDto));
case EnumSituacaoAutenticacaoUsuario.NaoEncontrado:
tokenDto.Mensagem = ApiResource.Usuario_nao_encontrado;
return(NotFound(tokenDto));
case EnumSituacaoAutenticacaoUsuario.Bloqueado:
tokenDto.Mensagem = ApiResource.Usuario_bloqueado;
return(Unauthorized(tokenDto));
case EnumSituacaoAutenticacaoUsuario.SenhaInvalida:
tokenDto.Mensagem = ApiResource.Senha_invalida;
return(Unauthorized(tokenDto));
case EnumSituacaoAutenticacaoUsuario.UsuarioOuSenhaNaoInformado:
tokenDto.Mensagem = ApiResource.Usuario_ou_senha_nao_foi_informado;
return(Unauthorized(tokenDto));
default:
return(BadRequest());
}
}
private UsuarioTokenDto BuildToken(UsuarioLoginDto usuarioDto)
{
var claims = new[]
{
new Claim(ClaimTypes.Name, usuarioDto.Nombre),
new Claim(JwtRegisteredClaimNames.UniqueName, usuarioDto.UserName),
new Claim("apellido", usuarioDto.Apellido),
new Claim("idusuario", usuarioDto.IdUsuario.ToString()),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:Key"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expiration = DateTime.UtcNow.AddHours(1);
JwtSecurityToken token = new JwtSecurityToken(
issuer: null,
audience: null,
claims: claims,
expires: expiration,
signingCredentials: creds
);
return(new UsuarioTokenDto()
{
Token = new JwtSecurityTokenHandler().WriteToken(token),
Expiracion = expiration
});
}
public IActionResult Index()
{
//Comprobar si hay registros de los principales en el sistema
try
{
var ok = Utils.IniciarSistema();
_logger.LogInformation("get login initial");
if (string.IsNullOrWhiteSpace(GetUsuarioActual()))
{
var modelo = new UsuarioLoginDto
{
Usuarios = "",
Password = ""
};
return(View(modelo));
}
else
{
return(Redirect("/Home"));
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
ViewBag.Error = "No hay conexion con el servidor de datos :(";
return(View());
}
}
public async Task <IActionResult> Login(UsuarioLoginDto usuarioLoginDto)
{
try
{
var usuario = await _UsuarioManager.FindByNameAsync(usuarioLoginDto.UserName);
var result = await _signInManager.CheckPasswordSignInAsync(usuario, usuarioLoginDto.Password, false);
if (!result.Succeeded)
{
return(Unauthorized());
}
var appUsuario = await _UsuarioManager.Users
.FirstOrDefaultAsync(u => u.NormalizedUserName == usuarioLoginDto.UserName.ToUpper());
var usuarioToReturn = _mapper.Map <UsuarioNovoDto>(usuario);
return(Ok(new
{
Token = GenerateJwtToken(appUsuario).Result,
Usuario = usuarioToReturn
}));
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError,
"Erro na autenticação!"));
}
}
public UsuarioLoginDto ObtenerPorLogin(UsuarioCredencialesDto modelo)
{
UsuarioLoginDto resultado = new UsuarioLoginDto();
try
{
const string query = "Seguridad.usp_Usuario_ObtenerPorLogeo";
using (var cn = HelperClass.ObtenerConeccion())
{
if (cn.State == ConnectionState.Closed)
{
cn.Open();
}
/*los alias en el parametro son opcionales si la propiedad del modelo tiene la misma denominacion*/
resultado = cn.QuerySingleOrDefault <UsuarioLoginDto>(query, new
{
UserName = modelo.Usuario,
modelo.Contrasenia
}, commandType: CommandType.StoredProcedure);
}
}
catch (Exception ex)
{
Log(Level.Error, (ex.InnerException == null ? ex.Message : ex.InnerException.Message));
}
return(resultado);
}
private ResponseUsuarioLoginDto BuildToken(UsuarioLoginDto usuarioDto)
{
//var claims = new[]
//{
// new Claim(ClaimTypes.Name, usuarioDto.Nombre),
// new Claim(JwtRegisteredClaimNames.UniqueName, usuarioDto.CorreoElectronico),
// new Claim("apellido", usuarioDto.Apellido),
// new Claim("idusuario", usuarioDto.IdUsuario.ToString()),
// new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
//};
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, usuarioDto.Nombre),
new Claim(JwtRegisteredClaimNames.UniqueName, usuarioDto.CorreoElectronico),
new Claim("apellido", usuarioDto.Apellido),
new Claim("idusuario", usuarioDto.IdUsuario.ToString()),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
if (usuarioDto.ListaRol == null)
{
usuarioDto.ListaRol = new List <RolObtenerPorIdUsuarioDto>();
}
if (usuarioDto.ListaRol.Any())
{
foreach (var item in usuarioDto.ListaRol)
{
claims.Add(new Claim(ClaimTypes.Role, item.Descripcion));
}
}
else
{
claims.Add(new Claim(ClaimTypes.Role, "Ninguno"));
}
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:Key"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expiration = DateTime.UtcNow.AddHours(1);
//var expiration = DateTime.UtcNow.AddMinutes(1);
JwtSecurityToken token = new JwtSecurityToken(
issuer: null,
audience: null,
claims: claims,
expires: expiration,
signingCredentials: creds
);
return(new ResponseUsuarioLoginDto()
{
Token = new JwtSecurityTokenHandler().WriteToken(token),
Expiracion = expiration,
IdUsuario = usuarioDto.IdUsuario,
Nombre = usuarioDto.Nombre,
Apellido = usuarioDto.Apellido,
CorreoElectronico = usuarioDto.CorreoElectronico,
UrlImagen = usuarioDto.UrlImagen
});
}
public async Task <JsonResponseAutenticacionUsuario> AutenticacionLogin(LoginModel model)
{
var obj = new UsuarioLoginDto
{
CodigoUsuario = model.CodigoUsuario,
ClaveSecreta = model.ClaveSecreta
};
return(await requestclient.PostAsync <JsonResponseAutenticacionUsuario>(Constante.Api.Login.AutentificacionUsuario, obj));
}
public async Task <ActionResult <TokenUsuarioDto> > Autenticar([FromBody] UsuarioLoginDto usuarioLogin)
{
var token = await _servicoUsuario.Autenticar(usuarioLogin.Email, usuarioLogin.Senha);
if (token == null)
{
return(BadRequest(new { message = "Credenciais inválidas" }));
}
return(Ok(token));
}
public async Task <IActionResult> GerarToken([FromBody] UsuarioLoginDto usuarioLoginDto, TipoUsuario tipoUsuario)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var resultado = await _authenticantionService.GerarJwt(usuarioLoginDto);
return(CustomResponse(resultado));
}
public ActionResult Login(UsuarioLoginDto usuarioDto)
{
try
{
if (ModelState.IsValid)
{
var usuario = _usuarioRepository.Get(u => u.NomeUsuario == usuarioDto.NomeUsuario && u.Senha == usuarioDto.Senha);
if (usuario != null)
{
var customPrincripal = new CustomPrincipalSerializeModel()
{
UsuarioId = usuario.Id,
Nome = usuario.Nome,
Sobrenome = usuario.NomeUsuario == usuario.NomeUsuario.Substring(usuario.NomeUsuario.IndexOf(usuario.NomeUsuario), usuario.NomeUsuario.Length).Trim() ? string.Empty : usuario.NomeUsuario.Substring(usuario.NomeUsuario.IndexOf(usuario.NomeUsuario), usuario.NomeUsuario.Length).Trim(),
Roles = usuario.NivelAcesso.Tipo
};
System.Web.HttpContext.Current.Session.Add("__USUARIO__", customPrincripal);
var userData = JsonConvert.SerializeObject(customPrincripal);
var authTicket = new FormsAuthenticationTicket(
1,
usuario.Email,
DateTime.Now,
DateTime.Now.AddMinutes(60),
usuarioDto.LembrarMe,
userData);
var encTicket = FormsAuthentication.Encrypt(authTicket);
var faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
return(RedirectToAction("Index", "Home"));
}
else
{
ViewBag.ErrorMessage = "Usuário e/ou senha incorretos";
}
}
else
{
ViewBag.ErrorMessage = "Ocorreu um erro ao tentar realizar o login";
}
}
catch (Exception ex)
{
throw new HttpException(ex.Message);
}
return(View("Login"));
}
public IActionResult Post(
[FromBody] UsuarioLoginDto usuario,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
bool credenciaisValidas = false;
if (usuario == null || string.IsNullOrEmpty(usuario.Login))
{
return(this.BadRequest("Usuário não informado."));
}
UsuarioDto usuarioBase = this.UsuarioService.ObterUsuarioPorEmail(usuario.Login);
credenciaisValidas = (usuarioBase != null && usuario.Login == usuarioBase.Email && usuario.Senha == usuarioBase.ChaveAcesso);
if (!credenciaisValidas)
{
return(this.Forbid());
}
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(usuario.Login, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Login)
}
);
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);
var result = new Framework.Domain.Dtos.ResponseTokenDto(true, dataCriacao, dataExpiracao, token);
return(this.Ok(result));
}
public UsuarioAuthenticationDto Authentication(UsuarioLoginDto dto, SigningConfigurations signingConfigurations, TokenConfigurations tokenConfigurations)
{
var usuario = GetById(dto.Usuario);
CryptographyHelper cryptHelper = new CryptographyHelper();
bool authenticated = cryptHelper.VerifyPassword(dto.Senha, usuario.Senha);
if (authenticated)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(usuario.Usuario, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Usuario)
}
);
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 UsuarioAuthenticationDto
{
authenticated = true,
message = "OK",
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
usuario = usuario.Usuario,
});
}
else
{
throw new Exception("Falha ao autenticar");
}
}
public async Task <ActionResult> Login([FromBody] UsuarioLoginDto model)
{
var oUsuarioLoginDto = await _iLoginService.GetLogin(model.UsuarioId, model.Contrasenia);
var oUsuarioDto = _mapper.Map <UsuarioDto>(oUsuarioLoginDto);
if (!string.IsNullOrEmpty(oUsuarioLoginDto.UsuarioId))
{
var oJwtHelper = new JwtHelper(_configuration);
return(Ok(oJwtHelper.BuildToken(oUsuarioDto)));
}
else
{
return(BadRequest("Username or password invalid"));
}
}
// LOGAR USUARIO
public async Task <Usuario> Login(UsuarioLoginDto usuarioLoginDto)
{
var usuario = await _userManager.FindByEmailAsync(usuarioLoginDto.Email);
var usuarioLogado = await _signInManager.CheckPasswordSignInAsync(usuario, usuarioLoginDto.Password, false);
if (usuarioLogado.Succeeded)
{
var appUser = await _userManager.Users.FirstOrDefaultAsync(u => u.Email == usuarioLoginDto.Email);
var userLoginDto = _map.Map <Usuario>(appUser);
return(userLoginDto);
}
throw new UnauthorizedAccessException("Email ou Senha Incorretos!");
}
public IActionResult Login([FromQuery] UsuarioLoginDto user)
{
try {
var UserLogin = _queriesUser.VerificarUsuario(user.Login, user.Senha);
if (UserLogin != null)
{
return(Ok(new { Token = JwtService.GenerateToken(UserLogin, _config), User = UserLogin }));
}
else
{
return(Ok("Usuario não existe"));
}
} catch (Exception ex) {
return(Ok(ex));
}
}
public async Task <IActionResult> Login([FromBody] UsuarioLoginDto usuarioLoginDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (usuarioLoginDto == null)
{
return(Unauthorized());
}
var usuarioLogin = new Usuario {
CodUsuario = usuarioLoginDto.CodUsuario
};
var usuarioGrupoUsuario = new UsuarioGrupoUsuario {
GrupoUsuarioId = usuarioLoginDto.GrupoUsuarioId
};
var userFromRepo = await _usuario.LoginUsuario(usuarioLoginDto.Contrasena, usuarioLogin, usuarioGrupoUsuario);
if (userFromRepo == null)
{
return(Unauthorized());
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_configuration.GetSection("AppSettings:Token").Value);
var tokenDescriptor = new SecurityTokenDescriptor {
Subject = new ClaimsIdentity(new Claim[] {
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.CodUsuario),
new Claim(ClaimTypes.Role, usuarioLoginDto.GrupoUsuarioId.ToString())
}),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(Ok(new { tokenString }));
}
public async Task <IActionResult> Autenticar([FromBody] UsuarioLoginDto login)
{
if (login == null)
{
return(BadRequest());
}
var identity = await GetClaimsIdentity(login.Usuario, login.Password);
if (identity == null)
{
return(BadRequest());
}
var jwt = await Tokens.GenerateJwt(identity, _jwtFactory, login.Usuario, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
public IActionResult RecuperarUsuario([FromForm] UsuarioConsultaDto objUsuarioConsultaDto)
{
if (string.IsNullOrWhiteSpace(objUsuarioConsultaDto.Usuarios))
{
ViewBag.Error = "Ingrese Usuario o correo";
return(View("Index"));
}
try
{
objUsuarioConsultaDto = _Usuario.UsuarioRecuperar(objUsuarioConsultaDto);
if (string.IsNullOrEmpty(objUsuarioConsultaDto.Correo))
{
ViewBag.Error = "Usuario o correo no registrado";
return(View("Index"));
}
ParametrosCorreoDto parametrosCorreoDto = new ParametrosCorreoDto();
parametrosCorreoDto.IdEmpresa = objUsuarioConsultaDto.IdEmpresa;
parametrosCorreoDto = _Empresa.ConsultaParametrosCorreo(parametrosCorreoDto);
if (string.IsNullOrEmpty(parametrosCorreoDto.Correo))
{
ViewBag.Error = "Falta de configuracion en el emsior de correos, comuniquece con el administrador";
UsuarioLoginDto objUsuarioLoginDto = new UsuarioLoginDto();
objUsuarioLoginDto.Tipo = "Recuperar";
objUsuarioLoginDto.Password = "******";
objUsuarioLoginDto.Usuarios = " ";
return(View("Index", objUsuarioLoginDto));
}
objUsuarioConsultaDto.Password = Encriptador.Desencriptar(objUsuarioConsultaDto.Password);
EnviarCorreoUsuarioRecuperado(parametrosCorreoDto, objUsuarioConsultaDto);
ViewBag.Success = "Se ha recuperado su usuario, revise su correo personal";
UsuarioLoginDto objUsuarioLoginDtos = new UsuarioLoginDto();
objUsuarioLoginDtos.Tipo = "Recuperar";
objUsuarioLoginDtos.Password = "******";
objUsuarioLoginDtos.Usuarios = " ";
return(View("Index", objUsuarioLoginDtos));
}
catch (Exception ex)
{
Log.Error(ex.Message);
ViewBag.Error = "Usuario o Contraseña Incorrecto";
return(View("Index"));
}
}
public IActionResult Index()
{
//Comprobar si hay registros de los principales en el sistema
var ok = Utils.IniciarSistema();
Log.Information("ok");
if (string.IsNullOrWhiteSpace(GetUsuarioActual()))
{
var modelo = new UsuarioLoginDto
{
Usuarios = "",
Password = ""
};
return(View(modelo));
}
else
{
return(Redirect("/Home"));
}
}
public async Task <IActionResult> Login(UsuarioLoginDto usuarioLoginDto)
{
try
{
var usuarioLogado = await _service.Login(usuarioLoginDto);
return(Ok(new {
token = _service.GerarToken(usuarioLogado).Result,
usuario = usuarioLoginDto
}
));
}
catch (UnauthorizedAccessException e)
{
return(Unauthorized($"{e.Message}"));
}
catch (ArgumentException e)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"{e.Message}"));
}
}
public ActionResult <UsuarioDataDto> ValidarIngreso([FromBody] UsuarioLoginDto UsuarioLogin)
{
try
{
UsuarioDataDto usuarioData = _usuarioService.GetDatosUsuario(UsuarioLogin.Dni, UsuarioLogin.Contrasena);
var usuarioGen = new
{
usuariotoken = GenerateToken(usuarioData).Result,
usuario = usuarioData
};
return(Ok(usuarioGen));
}
catch (UserLoginIncorrectException UserIncorrect)
{
return(BadRequest(UserIncorrect.ExceptionDto));
}
catch (UserLoginNotFoundException UserNotFound)
{
return(BadRequest(UserNotFound.ExceptionDto));
}
}
public async Task <TokenDto> ValidarLogin(UsuarioLoginDto usuarioLoginDto)
{
if (string.IsNullOrEmpty(usuarioLoginDto?.Usuario) || string.IsNullOrEmpty(usuarioLoginDto.Senha))
{
return new TokenDto
{
SituacaoAutenticacaoUsuario = EnumSituacaoAutenticacaoUsuario.UsuarioOuSenhaNaoInformado
}
}
;
var usuario = await _usuarioRepository.GetByLogin(usuarioLoginDto.Usuario);
if (usuario == null)
{
return new TokenDto
{
SituacaoAutenticacaoUsuario = EnumSituacaoAutenticacaoUsuario.NaoEncontrado
}
}
;
if (!usuario.Senha.Equals(usuarioLoginDto.Senha))
{
return new TokenDto
{
SituacaoAutenticacaoUsuario = EnumSituacaoAutenticacaoUsuario.SenhaInvalida
}
}
;
return(new TokenDto
{
SituacaoAutenticacaoUsuario = EnumSituacaoAutenticacaoUsuario.Autenticado,
Nome = usuario.Nome,
Login = usuario.Login
});
}
public async Task <IActionResult> Login(UsuarioLoginDto usuarioLoginDto)
{
var usuarioRepo = await _repo.Login(usuarioLoginDto.Login.ToLower(), usuarioLoginDto.Senha);
if (usuarioRepo == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, usuarioRepo.Id.ToString()),
new Claim(ClaimTypes.Name, usuarioRepo.Login)
};
var key = new SymmetricSecurityKey(Encoding.UTF8
.GetBytes(_config.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
var usuario = _mapper.Map <Usuario>(usuarioRepo);
return(Ok(new
{
token = tokenHandler.WriteToken(token),
usuario
}));
}
public async Task <UsuarioJwtDto> GerarJwt(UsuarioLoginDto usuarioLoginDto)
{
if (await EmailExiste(usuarioLoginDto.Email))
{
}
var result = await _signInManager.PasswordSignInAsync(usuarioLoginDto.Email, usuarioLoginDto.Senha,
false, true);
if (result.Succeeded)
{
return(await _JWTService.GerarJwt(usuarioLoginDto.Email));
}
if (result.IsLockedOut)
{
Notificar("Usuário temporariamente bloqueado por tentativas inválidas");
return(null);
}
Notificar("Usuário e/ou senha incorretos");
return(null);
}
public IActionResult Login([FromBody] UsuarioLoginDto dto)
{
if (dto == null)
{
return(Unauthorized());
}
if (!repository.Exist(x => x.UsuarioVar == dto.UsuarioVar && x.PasswordVar == dto.PasswordVar && x.IsActiveBit == true))
{
return(Unauthorized());
}
var user = repository.GetByValues(x => x.UsuarioVar == dto.UsuarioVar && x.PasswordVar == dto.PasswordVar).FirstOrDefault();
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, user.UsuarioIdInt.ToString()),
new Claim(ClaimTypes.Name, user.UsuarioVar.ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(config.GetSection("AppSettings:Token").Value));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = credentials
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new
{
token = tokenHandler.WriteToken(token)
}));;
}
public object Authentication([FromBody] UsuarioLoginDto dto, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations)
{
return(_business.Authentication(dto, signingConfigurations, tokenConfigurations));
}
public async Task <IActionResult> Login(UsuarioLoginDto usuarioLoginDto)
{
Usuario usuario = null;
string claveEncrypt = usuarioLoginDto.Clave.Encrypt();
usuario = await _service.Login(usuarioLoginDto.NombreUsuario, claveEncrypt);
if (usuario == null)
{
return(StatusCode(Status.Unauthorized, new
{
error = "El nombre de usuario o la clave ha sido indicado de manera incorrecta"
}));
}
if (!usuario.Activo)
{
return(StatusCode(Status.Unauthorized, new
{
error = "El usuario ha sido desactivado"
}));
}
var cacheExpirationOptions =
new MemoryCacheEntryOptions
{
AbsoluteExpiration = DateTime.Now.AddMinutes(20),
Priority = CacheItemPriority.Normal,
SlidingExpiration = TimeSpan.FromMinutes(5)
};
_memoryCache.Set("cUsuario", usuario, cacheExpirationOptions);
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, usuario.Guid.ToString()),
new Claim(ClaimTypes.Name, usuario.NombreUsuario)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var claimsIdentity = new ClaimsIdentity(claims);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = claimsIdentity,
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(StatusCode(Status.OK, new
{
token = tokenHandler.WriteToken(token),
usuario
}));
}
public UsuarioInfoDto ValidarLogin(UsuarioLoginDto usuarioLogin)
{
throw new NotImplementedException();
}
