public IActionResult Login(UsuarioLoginModel model)
{
if (ModelState.IsValid)
{
var jsonContent = JsonSerializer.Serialize(model);
var postContent = new StringContent(jsonContent, Encoding.UTF8, "application/json");
using (var client = new HttpClient())
{
var post = client.PostAsync("https://localhost:44376/api/login", postContent).GetAwaiter().GetResult();
var retorno = post.Content.ReadAsStringAsync().GetAwaiter().GetResult();
JWT jwt = JsonSerializer.Deserialize <JWT>(retorno);
HttpContext.Session.SetString("token", jwt.accessToken);
ClaimsIdentity identity = new ClaimsIdentity(new GenericIdentity(model.Login, "Login"),
new[]
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, model.Login),
new Claim(ClaimTypes.Sid, jwt.accessToken)
}
);
HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(identity));
}
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public UsuarioLogin Login(UsuarioLoginModel usuarioLogin)
{
string usuario = usuarioLogin.usuario;
string clave = usuarioLogin.clave;
return(this._gestorDeUsuarios.Login(usuario, clave));
}
public ActionResult Edit(int id)
{
var usuario = new UsuarioLoginModel();
using (var db = new RoboContext())
{
usuario = db.TB_LOGIN_ROBO
.AsNoTracking()
.Where(t => t.CO_SEQ_USUARIO == id)
.AsParallel()
.Select(t => new UsuarioLoginModel
{
Id = t.CO_SEQ_USUARIO,
strUsuario = t.DS_NOME,
strSenha = t.DS_SENHA,
Convenio = t.DS_CONVENIO,
PropostaUF = t.DS_PROPOSTA_UF,
Sistema = t.DS_SISTEMA,
Responsavel = t.DS_RESPONSAVEL,
DataDesativacao = t.DT_DESATIVACAO,
DataExecucao = t.DT_EXECUCAO,
EmManutencao = t.ST_EMMANUTENCAO
}).FirstOrDefault();
}
return(View(usuario));
}
public override void Given()
{
// Arrange
model = new LivroCadastroModel
{
Autor = "Autor Teste",
DataPublicacao = DateTime.Now,
ImagemCapaUrl = "imageurl/imagename.png",
ISBN = 12345,
Nome = "Nome Livro Teste",
Preco = 10
};
loginModel = new UsuarioLoginModel
{
Login = "******",
Senha = "12345"
};
usuarioAppService.Setup(x => x.FindByLoginAndSenha(It.IsAny <UsuarioLoginModel>()))
.Returns(new Domain.Entities.Usuario
{
IdUsuario = 1,
Nome = "Usuario teste",
Senha = "senhacriptografada",
Login = "******"
});
livroDomainService.Setup(x => x.Insert(It.IsAny <Domain.Entities.Livro>())).Throws(new Exception("ISBN já está cadastrado."));
}
public ActionResult Edit(UsuarioLoginModel usuario)
{
try
{
using (var db = new RoboContext())
{
var registro = db.TB_LOGIN_ROBO.Where(t => t.CO_SEQ_USUARIO == usuario.Id).SingleOrDefault();
registro.DS_SENHA = usuario.strSenha;
registro.DT_DESATIVACAO = usuario.DataDesativacao;
registro.ST_EMMANUTENCAO = usuario.EmManutencao;
registro.ST_DESBLOQUEAR = usuario.Desbloquear;
db.Entry(registro).State = EntityState.Modified;
db.SaveChanges();
}
ViewBag.Mensagem = "Registro alterado com sucesso.";
}
catch (DbEntityValidationException e)
{
IList <string> errorList = new List <string>();
foreach (var eve in e.EntityValidationErrors)
{
errorList.Add(string.Format("Tipo de entidade \"{0}\" no estado \"{1}\" tem o seguinte erro de validação:",
eve.Entry.Entity.GetType().Name, eve.Entry.State));
foreach (var ve in eve.ValidationErrors)
{
errorList.Add(string.Format("- Propriedade: \"{0}\", Erro: \"{1}\"", ve.PropertyName, ve.ErrorMessage));
}
}
ViewBag.MensagemErro = e.Message;
}
return(RedirectToAction("Index"));
}
public ActionResult Index(UsuarioLoginModel model)
{
if (ModelState.IsValid)
{
try
{
Criptografia c = new Criptografia();
UsuarioRep rep = new UsuarioRep();
Usuario u = rep.FindByNamePass(model.Login, c.ToEncrypt(model.Senha));
if (u != null)
{
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(u.Nome, false, 5);
HttpCookie cookie = new HttpCookie(FormsAuthentication.FormsCookieName, FormsAuthentication.Encrypt(ticket));
Response.Cookies.Add(cookie);
Session["usuario"] = u;
return(RedirectToAction("Index", "Logged"));
}
else
{
ViewBag.Mensagem = "Acesso Negado.";
}
}
catch (Exception e)
{
ViewBag.Mensagem = e.Message;
}
}
return(View());
}
public IActionResult Login(UsuarioLoginModel model, String redirect)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var entity = Db.Usuario.FirstOrDefault(u => u.Username == model.Username);
if (entity == null)
{
// TODO mover cadena de error
ModelState.AddModelError("Username", "El usuario no existe.");
return(View(model));
}
var password = PasswordHash.Plain(model.Password);
if (!password.Equals(entity.Password))
{
// TODO mover cadena de error
ModelState.AddModelError("Password", "Password incorrecto.");
return(View(model));
}
UserSession.StartUserSession(entity);
return(Redirect(redirect));
}
public ActionResult AutenticarUsuario(UsuarioLoginModel model)
{
if (ModelState.IsValid)
{
try
{
UsuarioData d = new UsuarioData(); //persistencia...
Usuario u = d.Authenticate(model.Login,
Criptografia.GetMD5Hash(model.Senha));
if (u != null) //usuario foi encontrado....
{
//Gerar um Ticket de Acesso para o usuario...
FormsAuthentication.SetAuthCookie(u.Login, false);
//Armazenar o objeto Usuario em sessão...
Session.Add("usuariologado", u);
//redirecionar para a Agenda...
return(RedirectToAction("Index", "Agenda"));
}
else //usuario nao encontrado...
{
ViewBag.Mensagem = "Acesso Negado.";
}
}
catch (Exception e)
{
ViewBag.Mensagem = e.Message;
}
}
return(View("Login"));
}
public override void Given()
{
// Arrange
model = new LivroCadastroModel
{
Autor = "",
DataPublicacao = DateTime.MinValue,
ImagemCapaUrl = "",
ISBN = 0,
Nome = "",
Preco = 0
};
loginModel = new UsuarioLoginModel
{
Login = "******",
Senha = "a3eilm"
};
usuarioAppService.Setup(x => x.FindByLoginAndSenha(It.IsAny <UsuarioLoginModel>()))
.Returns(new Domain.Entities.Usuario
{
IdUsuario = 1,
Nome = "Usuario teste",
Senha = "senhacriptografada",
Login = "******"
});
}
public async Task <UsuarioLoginModel> Login(UsuarioLoginModel request)
{
var hashPassword = HashUtils.GetHashSha256(request.Senha);
var user = await _usuarioRepository.GetByEmailAndPassword(request.Email, hashPassword);
if (user != null)
{
var newUser = new UsuarioLoginModel
{
Email = user.Email,
NiveisAcesso = (int)user.NivelAcesso
};
var tokenString = GetTokenJWT(newUser);
return(new UsuarioLoginModel
{
Id = user.Id,
Nome = user.Nome,
Email = user.Email,
Senha = user.Senha,
DataCriacao = user.DataCriacao,
DataNascimento = user.DataNascimento,
Token = tokenString
});
}
throw new Exception("Credenciais inválidas.");
}
public override void Given()
{
// Arrange
model = new LivroEdicaoModel
{
IdLivro = 1,
Autor = "Novo",
DataPublicacao = DateTime.Now,
ImagemCapaUrl = "imageurl/imagenamenovo.png",
ISBN = 99999,
Nome = "Novo",
Preco = 99
};
loginModel = new UsuarioLoginModel
{
Login = "******",
Senha = "12345"
};
usuarioAppService.Setup(x => x.FindByLoginAndSenha(It.IsAny <UsuarioLoginModel>()))
.Returns(new Domain.Entities.Usuario
{
IdUsuario = 1,
Nome = "Usuario teste",
Senha = "senhacriptografada",
Login = "******"
});
}
public override void Given()
{
// Arrange
model = new UsuarioLoginModel
{
Login = "",
Senha = "",
};
}
// GET: Sso
public ActionResult Index()
{
var usuario = new UsuarioLoginModel
{
RecadastrarSenha = false,
UsuarioBloqueado = false
};
return(View(usuario));
}
public async Task <UsuarioLoginModel> Login([FromBody] UsuarioLoginModel request)
{
try
{
return(await _usuarioService.Login(request));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public override void Given()
{
// Arrange
model = new UsuarioLoginModel
{
Login = "******",
Senha = "naoexistente",
};
appService.Setup(x => x.FindByLoginAndSenha(It.IsAny <UsuarioLoginModel>()))
.Returns((Domain.Entities.Usuario)null);
}
public void agregarUsuario(UsuarioLoginModel newUsuario)
{
var nuevoUsuario = new UsuarioLog();
nuevoUsuario.NombreUser = newUsuario.nombreUsuario;
nuevoUsuario.EmailUser = newUsuario.emailUsuario;
string salt = EncryptSC.crearSalt(5);
nuevoUsuario.PasswordUser = salt + EncryptSC.GetSHA256(newUsuario.passwordUsuario);
dbContext.UsuarioLogs.Add(nuevoUsuario);
dbContext.SaveChanges();
}
public ActionResult Login(UsuarioLoginModel model)
{
using (SynsTicketContext context = new SynsTicketContext())
{
var usuario = context.UsuarioEntity.FirstOrDefault(u => u.Login == model.Login && u.Senha == model.Senha);
if (usuario != null)
{
FormsAuthentication.SetAuthCookie(model.Login, false);
return(RedirectToAction("Index"));
}
return(View(model));
}
}
public override void Given()
{
// Arrange
model = new UsuarioLoginModel
{
Login = "******",
Senha = "senhateste",
};
appService.Setup(x => x.FindByLoginAndSenha(It.IsAny <UsuarioLoginModel>()))
.Returns(new Domain.Entities.Usuario
{
IdUsuario = 1,
Nome = "Usuario teste",
Senha = "senhacriptografada",
Login = "******"
});
}
public override void Given()
{
// Arrange
loginModel = new UsuarioLoginModel
{
Login = "******",
Senha = "12345"
};
usuarioAppService.Setup(x => x.FindByLoginAndSenha(It.IsAny <UsuarioLoginModel>()))
.Returns(new Domain.Entities.Usuario
{
IdUsuario = 1,
Nome = "Usuario teste",
Senha = "senhacriptografada",
Login = "******"
});
appService.Setup(x => x.FindAll()).Returns(new List <LivroConsultaModel>
{
new LivroConsultaModel
{
Autor = "Autor 01",
DataPublicacao = DateTime.Now,
IdLivro = 1,
ImagemCapaUrl = "imgurl",
ISBN = 12345,
Nome = "Nome do Livro 01",
Preco = 10
},
new LivroConsultaModel
{
Autor = "Autor 02",
DataPublicacao = DateTime.Now,
IdLivro = 1,
ImagemCapaUrl = "imgurl",
ISBN = 54321,
Nome = "Nome do Livro 02",
Preco = 20
},
});
}
public async Task <string> Login(UsuarioLoginModel usuarioLoginModel)
{
try
{
HttpResponseMessage respuesta = await httpClient.PostAsJsonAsync <UsuarioLoginModel>($"{urlBase}cuentas/login", usuarioLoginModel);
if (respuesta.IsSuccessStatusCode)
{
string userTokeSerialice = respuesta.Content.ReadAsStringAsync().Result;
UserTokenModel userToken = JsonConvert.DeserializeObject <UserTokenModel>(userTokeSerialice);
return(userTokeSerialice);
}
return(null);
}
catch (Exception)
{
throw;
}
}
public ActionResult Index(UsuarioLoginModel usuario)
{
if (!bool.TryParse(ConfigurationManager.AppSettings.Get("RecadastrarSenha"), out _recadastrarSenha))
{
_recadastrarSenha = false;
}
if (!bool.TryParse(ConfigurationManager.AppSettings.Get("UsuarioBloqueado"), out _usuarioBloqueado))
{
_usuarioBloqueado = false;
}
usuario.RecadastrarSenha = _recadastrarSenha;
usuario.UsuarioBloqueado = _usuarioBloqueado;
if (!_recadastrarSenha && !_usuarioBloqueado)
{
return(RedirectToAction("Menu"));
}
return(View(usuario));
}
public int Login([FromBody] UsuarioLoginModel login)
{
ClientesDAO DaoCLiente = new ClientesDAO();
if (login.Cpf.Length == 11)
{
var Usuario = DaoCLiente.PesquisaLogin(login.Cpf, login.Senha) as Clientes;
if (Usuario != null)
{
return(Usuario.codigo);
}
else
{
return(0);
}
}
else
{
return(0);
}
}
public ActionResult Login(UsuarioLoginModel login, string ReturnUrl = "")
{
string mensagem = "";
var v = _usuarioApp.ObterUsuarioPeloEmail(login.Email);
if (v != null)
{
if (string.Compare(Crypto.Hash(login.Senha), v.Senha) == 0)
{
int timeout = login.ManterConectado ? 525600 : 20; // 525600 min = 1 year
var ticket = new FormsAuthenticationTicket(login.Email, login.ManterConectado, timeout);
string encrypted = FormsAuthentication.Encrypt(ticket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encrypted);
cookie.Expires = DateTime.Now.AddMinutes(timeout);
cookie.HttpOnly = true;
Response.Cookies.Add(cookie);
if (Url.IsLocalUrl(ReturnUrl))
{
return(Redirect(ReturnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
mensagem = "Credenciais inválidas.";
}
}
else
{
mensagem = "Credenciais inválidas.";
}
ViewBag.Message = mensagem;
return(View());
}
public IHttpActionResult Login(UsuarioLoginModel model)
{
try
{
if (model != null)
{
SegurityViewModel token = new SegurityViewModel();
token = UsuarioBLL.Login(model.email, model.password);
if (token.token != null)
{
return(Content(HttpStatusCode.OK, token));
}
}
return(Content(HttpStatusCode.BadRequest, "Datos incorrectos"));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.Conflict, ex));
throw;
}
}//end
private string GetTokenJWT(UsuarioLoginModel user)
{
var accessLevel = "";
switch (user.NiveisAcesso)
{
case 0:
accessLevel = NiveisAcesso.Administrador.ToString();
break;
case 1:
accessLevel = NiveisAcesso.UsuarioLoja1.ToString();
break;
default:
accessLevel = NiveisAcesso.UsuarioLoja2.ToString();
break;
}
var claims = new[]
{
new Claim(ClaimTypes.Email, user.Email),
new Claim(ClaimTypes.Role, accessLevel),
};
var token = new JwtSecurityToken(
issuer: "ControleEstoque",
audience: "ErickBaitola",
expires: DateTime.Now.AddMonths(3),
claims: claims,
signingCredentials: new SigningCredentials(
new SymmetricSecurityKey(Encoding.UTF8.GetBytes("KAINBHU@#MKBKAKM9776JKINJI!!@#IBNHUOGA@UUHBN#NK")),
SecurityAlgorithms.HmacSha256
)
);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public RespuestaDeLogin Login(UsuarioLoginModel usuarioLogin)
{
RespuestaDeLogin respuestaDeLogin = new RespuestaDeLogin();
string usuario = usuarioLogin.NombreUsuario;
string contrasena = Security.HashSHA1(usuarioLogin.Contrasena);
UsuarioLogin respuestaLogin = this._gestorDeUsuarios.Login(usuario, contrasena, usuarioLogin.IdAplicacion);
if (respuestaLogin == null)
{
respuestaDeLogin.FueExitosa = false;
respuestaDeLogin.Mensaje = "Las credenciales son incorrectas.";
}
else
{
if (respuestaLogin.IdEmpleado == 0)
{
respuestaDeLogin.FueExitosa = false;
respuestaDeLogin.Mensaje = "Usted no tiene permisos para ingresar a esta aplicación.";
}
else
{
if (!respuestaLogin.LoginEstado)
{
UsuarioLogin usuarioConModulos = _gestorDeUsuarios.ObtenerMenu(respuestaLogin);
respuestaDeLogin.FueExitosa = true;
respuestaDeLogin.Token = this._gestorDeToken.GenerarToken(respuestaLogin);
}
else
{
respuestaDeLogin.FueExitosa = false;
respuestaDeLogin.Mensaje = "El usuario ya se encuentra logueado en otra máquina.";
}
}
}
return(respuestaDeLogin);
}
public async Task <ActionResult> Autenticar(UsuarioLoginModel usuarioLogin)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var result = await signInManager.PasswordSignInAsync(usuarioLogin.Email, usuarioLogin.Senha, isPersistent : false, lockoutOnFailure : true);
if (result.Succeeded)
{
return(CustomResponse(await GerarJwt(usuarioLogin.Email)));
}
if (result.IsLockedOut)
{
AddErroProcessamento(USUARIO_BLOQUEADO_POR_TENTATIVAS);
return(CustomResponse());
}
AddErroProcessamento(USUARIO_SENHA_INVALIDOS);
return(CustomResponse());
}
public IActionResult Post(UsuarioLoginModel model,
[FromServices] TokenConfiguration tokenConfiguration,
[FromServices] LoginConfiguration loginConfiguration)
{
if (ModelState.IsValid)
{
try
{
//instanciando a classe de criptografia
Criptografia criptografia = new Criptografia();
//buscar no banco de dados o usuario que possui o login e senha informados.
Usuario usuario = repository.ObterPorLoginESenha(model.Login, criptografia.MD5Encrypt(model.Senha));
//verificar se o usuario foi encontrado
if (usuario != null)
{
//retornar um TOKEN!!
#region Criando as credenciais do usuario
//criando as credenciais do usuario
var identity = new ClaimsIdentity(new GenericIdentity(usuario.Login, "Login"),
new[]
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Login)
});
//gerando o token
var dataCriacao = DateTime.Now;
var dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfiguration.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(
new SecurityTokenDescriptor
{
Issuer = tokenConfiguration.Issuer,
Audience = tokenConfiguration.Audience,
SigningCredentials = loginConfiguration.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
}
);
//processando o token
var token = handler.WriteToken(securityToken);
//criando um objeto para retornar o resultado da API
var result = new
{
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expires = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token
};
return(StatusCode(200, result));
#endregion
}
else
{
return(StatusCode(400, "Acesso negado. Usuário inválido."));
}
}
catch (Exception e)
{
//retorna um status de erro 500 (Erro interno de servidor)
return(StatusCode(500, e.Message));
}
}
else
{
//retornar um status de erro 400 (BadRequest)
return(StatusCode(400, "Ocorreram erros de validação."));
}
}
public ActionResult Index(UsuarioLoginModel usuario)
{
return(View(new UsuarioLoginModel()));
}
public IActionResult Post(UsuarioLoginModel model)
{
if (ModelState.IsValid)
{
try
{
//buscar no repositorio se existe algum
//usuario com o email e a senha informados..
var usuario = usuarioRepository.Obter(model.Email, Criptografia.MD5Encrypt(model.Senha));
//verificar se o usuario foi encontrado..
if (usuario != null)
{
try
{//criando a identificação do usuário..
ClaimsIdentity identity = new ClaimsIdentity(new GenericIdentity(usuario.Email, "Login"),
new[]
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Email)
});
//montando o TOKEN..
var dataCriacao = DateTime.Now;
var dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfiguration.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken
(new SecurityTokenDescriptor {
Issuer = tokenConfiguration.Issuer, Audience = tokenConfiguration.Audience, SigningCredentials = loginConfiguration.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao
});
//gerando o token
var token = handler.WriteToken(securityToken);
var result = new
{
mensagem = "Usuário autenticado com sucesso.", token, //TOKEN DE ACESSO!
criadoEm = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiraEm = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss")
};
return(Ok(result));
}
catch (Exception e)
{
return(StatusCode(500, "Erro: " + e.Message));
}
}
else
{
return(Unauthorized()); //acesso negado!
}
}
catch (Exception e)
{
return(StatusCode(500, "Ocorreu um erro: " + e.Message));
}
}
else
{
return(BadRequest("Ocorreram erros de validação."));
}
}
