public async Task <ActionResult <UsuarioData> > Login(UsuarioLoginDTO parametros)
{
var usuario = await this._userManager.FindByNameAsync(parametros.UserName);
if (usuario == null)
{
return(BadRequest("Usuario no encontrado"));
}
var resultado = await this._signInManager.CheckPasswordSignInAsync(usuario, parametros.Password, false);
if (resultado.Succeeded)
{
return(new UsuarioData
{
Nombre = usuario.Nombre,
UserName = usuario.UserName,
Email = usuario.Email,
IdUsuario = usuario.Id,
Apellido = usuario.Apellido
});
}
else
{
return(BadRequest("Contraseña incorrecta"));
}
}
public ActionResult Login(UsuarioLoginDTO userDTO)
{
try
{
var teste = ModelState.Values.SelectMany(x => x.Errors);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(x => x.Errors)));
}
var usuario = _usuarioService.Login(userDTO);
if (usuario == null)
{
return(NotFound("Usuário não encontrado!"));
}
var token = TokenService.GenerateToken(usuario);
return(Ok(new { usuario, token }));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Login([FromBody] UsuarioLoginDTO usuario)
{
try
{
var usr = await _acessoRepository.ObterUsuario(usuario.Login, usuario.Senha);
if (usr == null)
{
return(NoContent());
}
else
{
return(Ok(new LoginResponse {
Sucess = true, Token = await GenerateTokenAsync(usr)
}));
}
}
catch (Exception ex)
{
Console.WriteLine($"=====>{ex.Message}");
return(BadRequest(new LoginResponse {
Sucess = false, Message = MessageError.MensagemResponse
}));
}
}
public async Task <TokenUserDTO> GetTokenLogin([FromBody] UsuarioLoginDTO user)
{
try
{
/* FAZ O LOGIN */
var userExists = await _signInManager.PasswordSignInAsync(user.Email, user.Password, true, false);
TokenUserDTO token = null;
if (userExists.Succeeded)
{
/* Ele existe... logo loga... */
Usuario usuario = await _rep.GetUserByEmail(user.Email);
var tokenGerado = GetAuth.GenerateToken(usuario);
token = new TokenUserDTO()
{
TokenUrsao = tokenGerado,
};
return(token);
}
else
{
throw new UsuarioNaoEncontradoException("usuario nao encontrado :P");
}
}
catch (Exception e)
{
return(new TokenUserDTO()
{
TokenUrsao = "Puuuxa não foi dessa vez... Mas ligue novamente para 4002-8922 q vc será atendido pelo SBT! --- SACANAGEM... KKKKK na real a msg é essa mano: Ocorreu algum erro interno na aplicação, por favor tente novamente... Erro: " + e.Message,
});
}
}
//autenticacao da plataforma
public ActionResult LoginForm(FormCollection loginForm)
{
//acessar passar os dados vindos da view autenticacao
var dados = "";
dados += "&username="******"Email"].ToString();
dados += "&password="******"Senha"].ToString();
IRestResponse respondelogin = helper.Login(urlacessoplataforma, dados);
if (respondelogin.StatusCode.ToString() == "OK")
{
//criacao da sessao
Session["EstaLogado"] = loginForm.ToString();
Session["TokenUsuario"] = loginForm.ToString();
string json = respondelogin.Content.ToString();
UsuarioLoginDTO item = Newtonsoft.Json.JsonConvert.DeserializeObject <UsuarioLoginDTO>(json);
int IDUsuario = item.IDUsuario;
string email = item.Email;
string nome = item.Nome;
string token = item.access_token;
UsuarioLoginDTO Token = new UsuarioLoginDTO();
{
Token.access_token = token;
};
Session["IDUsuario"] = item.IDUsuario.ToString();
Session["Nome"] = item.Nome.ToString();
// Session["Email"] = item.Email.ToString();
Session["TokenUsuario"] = item.access_token.ToString();
return(RedirectToAction("Index", "Home"));
}
TempData["SuccessErrorS"] = "Ocorreu um problema ao processar sua autenticação!";
return(View("index"));
}
public UsuarioLogeadoDTO CheckUsuario(UsuarioLoginDTO usuarioLoginDTO)
{
UsuarioLogeadoDTO usuarioLogeado = new UsuarioLogeadoDTO();
Cliente cliente = _us.CheckCliente(usuarioLoginDTO);
if (cliente != null)
{
List <Dieta> dietas = _di.GetAllDietasByUser(cliente.ClienteId);
usuarioLogeado.DietasComidas = new List <DietaComida>();
foreach (var d in dietas)
{
List <DietaComida> dc = _dc.GetDietaConComidas(d.DietaId);
foreach (var dc1 in dc)
{
usuarioLogeado.DietasComidas.Add(dc1);
}
}
List <Rutina> rutinas = _ru.GetAllRutinasByUser(cliente.ClienteId);
usuarioLogeado.RutinasEjercicios = new List <RutinaEjercicio>();
foreach (var r in rutinas)
{
List <RutinaEjercicio> re = _re.GetRutinaConEjercicios(r.RutinaId);
foreach (var re1 in re)
{
usuarioLogeado.RutinasEjercicios.Add(re1);
}
}
List <Asistencia> asis = _as.GetAsistenciasByUser(cliente.ClienteId);
foreach (var a in asis)
{
AsistenciaCalendar ac = new AsistenciaCalendar();
ac.title = "Asistencia";
ac.start = a.Fecha.ToString("yyyy-MM-dd");
ac.end = a.Fecha.ToString("yyyy-MM-dd");
usuarioLogeado.Asistencias.Add(ac);
}
usuarioLogeado.Cliente = cliente;
usuarioLogeado.Mensaje = "Cliente logueado correctamente";
return(usuarioLogeado);
}
else
{
usuarioLogeado.Empleado = _us.CheckEmpleado(usuarioLoginDTO);
if (usuarioLogeado.Empleado != null)
{
usuarioLogeado.Mensaje = "Empleado logueado correctamente";
return(usuarioLogeado);
}
else
{
usuarioLogeado.Mensaje = "Error al intentar loguear";
return(usuarioLogeado);
}
}
}
public IActionResult Autenticar([FromBody] UsuarioLoginDTO usvm)
{
UsuarioLogadoDTO ulDTO;
if (!_usuarioService.Autenticar(usvm.Usuario, usvm.Senha, out ulDTO))
{
return(Unauthorized());
}
return(Ok(ulDTO));
}
public int Logar(UsuarioLoginDTO usuarioLoginDTO)
{
var usuario = _context.Usuario.Where(x => x.Login == usuarioLoginDTO.Usuario).ToList();
if (!usuario.Any())
{
return(0);
}
else
{
var result = VerificaSenha(usuarioLoginDTO, usuario);
return(result);
}
}
public IActionResult Usuario(UsuarioLoginDTO usuario)
{
try
{
return(new JsonResult(this._service.Login(usuario))
{
StatusCode = 200
});
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public string Login(UsuarioLoginDTO usuario)
{
//validamos que el usuario ingresado existe en la db
var usuariodb = this.GetBy(x => x.Email == usuario.Email, new string[] { "UsuarioRolNavigator" })
.FirstOrDefault();
if (usuariodb == null)
{
throw new Exception("El usuario ingresado no existe. Por favor registrese.");
}
var verificarContraseña = GetHash(usuario.Contraseña);
if (usuariodb.Contraseña != verificarContraseña)
{
throw new Exception("La contraseña ingresada no es valida");
}
var rol = usuariodb.UsuarioRolNavigator.Select(x => x.RolId).FirstOrDefault();
// se crea el header //
var _symmetricSecurityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(this._configuration.GetSection("Authentication:SecretKey").Value));
var _signingCredentials = new SigningCredentials(_symmetricSecurityKey, SecurityAlgorithms.HmacSha256);
var header = new JwtHeader(_signingCredentials);
// se crea los claim
var claims = new[] {
new Claim("Nombre", usuariodb.Nombre),
new Claim("Apellido", usuariodb.Apellido),
new Claim("Rol", rol.ToString()),
new Claim("UsuarioId", usuariodb.UsuarioId.ToString())
};
// creacion del payload del token
var payload = new JwtPayload(
issuer: "",
audience: "",
claims: claims,
notBefore: DateTime.UtcNow,
// vence en un dia.
expires: DateTime.UtcNow.AddDays(1)
);
// con los claims y payload se crea el token
var token = new JwtSecurityToken(header, payload);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
private void GenerarTickectAutenticacion(UsuarioLoginDTO u)
{
UsuarioModel usuarioModel = new UsuarioModel();
usuarioModel.Username = u.Username;
usuarioModel.RolId = u.RolId;
usuarioModel.RolNombre = u.RolNombre;
usuarioModel.TimeZoneId = ConfigurationAppSettings.TimeZoneId();
usuarioModel.TimeZoneGMT = ConfigurationAppSettings.TimeZoneGMT();
AuthenticationHelper.CreateAuthenticationTicket(usuarioModel.Username, usuarioModel.TimeZoneId);
WebSession.Usuario = usuarioModel;
WebSession.Formularios = SeguridadBL.Instancia.GetFormulario().Where(p => p.RolId == usuarioModel.RolId);
}
public async Task <ActionResult> Login([FromBody] UsuarioLoginDTO loginDTO)
{
string username = loginDTO.Username;
string password = loginDTO.Password;
//Si el usuario ya esta logeado no puede acceder
if (User.Identity.IsAuthenticated)
{
return(StatusCode(StatusCodes.Status403Forbidden, "Ya estas autenticado."));
}
//Comprobando que los datos sean correctos
if (!ModelState.IsValid)
{
string mensajeDeError = ModelState.Values.First().Errors[0].ErrorMessage;
return(BadRequest(mensajeDeError));
}
//Obteniendo y comprobando si el usuario existe
Usuario usuario = UsuarioDAO.Get(_context, username, password);
if (usuario == null)
{
return(NotFound("No se encuentra el usuario."));
}
//Preparando proceso de autenticación
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, usuario.Id.ToString())
};
var claimsIdentity = new ClaimsIdentity(
claims, CookieAuthenticationDefaults.AuthenticationScheme);
var authProperties = new AuthenticationProperties
{
AllowRefresh = true,
IsPersistent = true
};
await HttpContext.SignInAsync(
CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(claimsIdentity),
authProperties);
return(Ok($"Usuario con username '{username}' autenticado exitosamente."));
}
public ActionResult <string> Login([FromBody, BindRequired] UsuarioLoginDTO login)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var obj = this._service.BuscarPorEmailSenha(login.Email, login.Senha);
if (obj == null)
{
return(Unauthorized());
}
var result = this._service.GerarToken(obj);
return(Ok(result));
}
private int VerificaSenha(UsuarioLoginDTO usuarioLoginDTO, List <Usuario> usuarios)
{
foreach (var usuario in usuarios)
{
if (usuario.Senha.Equals(usuarioLoginDTO.Senha))
{
if (usuario.Delete.HasValue && usuario.Delete.Value)
{
return(2);
}
else if (usuario.Bloqueado.HasValue && usuario.Bloqueado.Value)
{
return(3);
}
else
{
return(4);
}
}
}
return(1);
}
public async Task <TokenUserDTO> GetTokenLogin([FromBody] UsuarioLoginDTO user)
{
try
{
/* FAZ O LOGIN */
var userExists = await _signInManager.PasswordSignInAsync(user.Email, user.Password, true, false);
TokenUserDTO token = null;
if (userExists.Succeeded)
{
/* Ele existe... logo loga... */
Usuario usuario = await _rep.GetUsuarioPorEmail(new UsuarioPorEmailDTO()
{
Email = user.Email
});
var tokenGerado = GetAuth.GenerateToken(usuario);
token = new TokenUserDTO()
{
Token = tokenGerado,
};
return(token);
}
else
{
throw new UsuarioNaoEncontradoException("usuario nao encontrado");
}
}
catch (Exception e)
{
return(new TokenUserDTO()
{
Token = "Ocorreu algum erro interno na aplicação, por favor tente novamente... Erro: " + e.Message,
});
}
}
public async Task <LoginResponse> Login(UsuarioLoginDTO usuario)
{
try
{
var loginResult = await ApiService.PostItem <LoginResponse>("login", usuario);
if (!loginResult.Sucess)
{
return(loginResult);
}
await _localStorage.SetItemAsync("authToken", loginResult.Token);
await((TokenAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(usuario.Login);
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", loginResult.Token);
return(loginResult);
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
public Empleado CheckEmpleado(UsuarioLoginDTO usuarioLoginDTO)
{
return(_db.Empleados.FirstOrDefault(x => x.NombreUsuario == usuarioLoginDTO.Usuario && x.Contrasenia == usuarioLoginDTO.Contrasenia));
}
public Cliente CheckCliente(UsuarioLoginDTO usuarioLoginDTO)
{
return(_db.Clientes.FirstOrDefault(x => x.NombreUsuario == usuarioLoginDTO.Usuario && x.Contrasenia == usuarioLoginDTO.Contrasenia));
}
public int Logar(UsuarioLoginDTO usuarioLoginDTO)
{
var result = _usuarioRepository.Logar(usuarioLoginDTO);
return(result);
}
public UsuarioLogeadoDTO CheckUsuario(UsuarioLoginDTO usuarioLoginDTO)
{
UsuarioLogeadoDTO usuarioLogeado = _us.CheckUsuario(usuarioLoginDTO);
return(usuarioLogeado);
}
public Usuario Login(UsuarioLoginDTO usuarioDTO)
{
var user = GetAll().FirstOrDefault(x => x.Username.ToLower().Equals(usuarioDTO.Username.ToLower()) && x.Password.Equals(usuarioDTO.Password));
return(user);
}
