public AutenticacaoModel LoginNormal(LoginModel login)
{
try
{
if (login.SenhaConfere())
{
AutenticacaoModel autenticacao = new AutenticacaoModel();
ConfereOperador(login, autenticacao);
ConfereCliente(login, autenticacao);
if (autenticacao.Login == null)
{
autenticacao = LoginInvalido(login);
}
return(autenticacao);
}
else
{
return(LoginInvalido(login));
}
} catch (Exception e)
{
Log.Error("Erros: " + e.Message);
return(new AutenticacaoModel
{
Login = login.Login,
Autenticado = false,
Mensagem = e.Message
});
}
}
public async Task <ActionResult> AutenticarUsuario(AutenticacaoModel autenticacao)
{
try
{
if (!ModelState.IsValid)
{
return(Unauthorized());
}
var credenciaisValidas =
await _contexto.Usuarios.AnyAsync(c => c.Email == autenticacao.Email && c.Senha == autenticacao.Senha);
if (!credenciaisValidas)
{
return(Unauthorized("Email/Senha inválidos."));
}
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public ActionResult Login(AutenticacaoModel usuario)
{
try
{
if (ModelState.IsValid)
{
foreach (var cookieKey in Request.Cookies.AllKeys.Where(c => !c.Equals("__RequestVerificationToken")))
{
var deleteCookie = new HttpCookie(cookieKey);
deleteCookie.Expires = DateTime.Now;
Response.Cookies.Add(deleteCookie);
}
AutorizacaoProvider.Logar(usuario);
if (!string.IsNullOrWhiteSpace(usuario.Nome))
{
return(Json(new { url = usuario.Nome.Replace("$", "&") }));
}
else
{
return(Json(new { url = Url.Action(ConfigurationManager.AppSettings["Web:DefaultAction"], ConfigurationManager.AppSettings["Web:DefaultController"]) }));
}
}
return(View(usuario));
}
catch (Exception ex)
{
return(Json(new { alerta = ex.Message, titulo = "Oops! Problema ao realizar login..." }));
}
}
public ActionResult Login(AutenticacaoModel usuario)
{
try
{
if (ModelState.IsValid)
{
string msgErro = string.Empty;
AutorizacaoProvider.LogIn(usuario, out msgErro);
if (AutorizacaoProvider.UsuarioAutenticado.Permissoes.Where(a => a.Perfil.Equals("Empregado")).Count() > 0)
{
Empregado emp = EmpregadoBusiness.Consulta.FirstOrDefault(a =>
string.IsNullOrEmpty(a.UsuarioExclusao) &&
a.CPF.ToUpper().Trim().Replace(".", "").Replace("-", "").Equals(usuario.Login.ToUpper().Trim().Replace(".", "").Replace("-", "")));
if (emp != null)
{
return(Json(new { url = Url.Action("Desktop", "Empregado", new { id = emp.UniqueKey }) }));
}
}
return(Json(new { url = Url.Action(ConfigurationManager.AppSettings["Web:DefaultAction"], ConfigurationManager.AppSettings["Web:DefaultController"]) }));
}
return(View(usuario));
}
catch (Exception ex)
{
return(Json(new { alerta = ex.Message, titulo = "Oops! Problema ao realizar login..." }));
}
}
public ActionResult LoginComCaptcha(AutenticacaoModel usuario)
{
MvcCaptcha.ResetCaptcha("LoginCaptcha");
ViewBag.IncluirCaptcha = Convert.ToBoolean(ConfigurationManager.AppSettings["AD:DMZ"]);
try
{
if (ModelState.IsValid)
{
AutorizacaoProvider.Logar(usuario);
if (!string.IsNullOrWhiteSpace(usuario.Nome))
{
return(Json(new { url = usuario.Nome.Replace("$", "&") }));
}
else
{
return(Json(new { url = Url.Action(ConfigurationManager.AppSettings["Web:DefaultAction"], ConfigurationManager.AppSettings["Web:DefaultController"]) }));
}
}
return(View("Login", usuario));
}
catch (Exception ex)
{
return(Json(new { alerta = ex.Message, titulo = "Oops! Problema ao realizar login..." }));
}
}
/// <summary>
/// Armazena a autenticação em uma sessão
/// </summary>
/// <param name="autenticacaoModel"></param>
/// <param name="msgErro"></param>
/// <returns></returns>
public bool Autenticar(AutenticacaoModel autenticacaoModel, out string msgErro, string grupo = "administrador")
{
msgErro = String.Empty;
var usuario = adminRepository.Admins.Where(x => x.Login == autenticacaoModel.Login).FirstOrDefault();
if (usuario == null)
{
msgErro = "Login não pertenece a nenhum usuario";
return(false);
}
if (usuario.Senha != autenticacaoModel.Senha)
{
msgErro = "Senha Incorreta";
return(false);
}
HttpContext.Current.Session["autenticacao"] = new AutenticacaoModel
{
Grupo = "administrador",
Login = autenticacaoModel.Login,
Senha = autenticacaoModel.Senha,
NomeTratamento = usuario.NomeTratamento
};
return(true);
}
public Usuario ValidarCredenciais(AutenticacaoModel autenticacaoModel)
{
autenticacaoModel.Login = autenticacaoModel.Login.Trim();
//Buscar usuário sem validar senha, para poder determinar se a validação da senha será com AD ou com a senha interna do GIS
List <Usuario> lUsuarios = Consulta.Where(u => u.Login.Equals(autenticacaoModel.Login) ||
u.CPF.Equals(autenticacaoModel.Login) ||
u.Email.Equals(autenticacaoModel.Login)).ToList();
if (lUsuarios.Count > 1 || lUsuarios.Count < 1)
{
throw new Exception("Não foi possível identificar o seu cadastro.");
}
else
{
if (lUsuarios[0].TipoDeAcesso.Equals(0))
{
//Login, validando a senha no AD
if (Convert.ToBoolean(ConfigurationManager.AppSettings["AD:DMZ"]))
{
//Chamar web service para validar a senha no AD
return(null);
}
else
{
Empresa emp = EmpresaBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.IDEmpresa.Equals(lUsuarios[0].IDEmpresa));
using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, emp.URL_AD))
{
if (pc.ValidateCredentials(autenticacaoModel.Login, autenticacaoModel.Senha))
{
return(null);
}
else
{
throw new Exception("Login ou senha incorretos.");
}
}
}
}
else
{
//Login, validando a senha interna do GIS
string IDUsuario = lUsuarios[0].IDUsuario;
string senhaTemp = CreateHashFromPassword(autenticacaoModel.Senha);
Usuario oUsuario = Consulta.FirstOrDefault(p => p.IDUsuario.Equals(IDUsuario) && p.Senha.Equals(senhaTemp));
if (oUsuario != null)
{
return(oUsuario);
}
else
{
throw new Exception("Login ou senha incorretos.");
}
}
}
}
public AutenticacaoModel ValidarCredenciais(AutenticacaoModel autenticacaoModel)
{
autenticacaoModel.Login = autenticacaoModel.Login.Trim().ToUpper();
//Buscar usuário sem validar senha, para poder determinar se a validação da senha será com AD ou com a senha interna do GIS
List <Usuario> lUsuarios = Consulta.Where(u => string.IsNullOrEmpty(u.UsuarioExclusao) &&
(u.Login.Equals(autenticacaoModel.Login) || u.Email.Equals(autenticacaoModel.Login))).ToList();
if (lUsuarios.Count == 0)
{
throw new Exception("Não foi possível identificar o seu cadastro. Entre em contato com o Administrador do sistema.");
}
else if (lUsuarios.Count > 1)
{
throw new Exception("Não foi possível identificar o seu cadastro.");
}
else
{
if (lUsuarios[0].TipoDeAcesso == TipoDeAcesso.AD)
{
throw new Exception("Login através do AD não implementado. Favor acionar o administrador para maiores detalhes.");
}
else
{
//Login, validando a senha interna no CIS
string IDUsuario = lUsuarios[0].UniqueKey;
string senhaCrypt = CreateHashFromPassword(autenticacaoModel.Senha);
Usuario oUsuario = Consulta.FirstOrDefault(p => p.UniqueKey.Equals(IDUsuario) && p.Senha.Equals(senhaCrypt));
//Usuario oUsuario = Consulta.FirstOrDefault(p => p.UniqueKey.Equals(IDUsuario));
if (oUsuario != null)
{
List <VMPermissao> listapermissoes = new List <VMPermissao>();
listapermissoes.AddRange(from usuarioperfil in UsuarioPerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList()
join perfil in PerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList() on usuarioperfil.UKPerfil equals perfil.UniqueKey
where usuarioperfil.UKUsuario.Equals(IDUsuario)
select new VMPermissao {
Perfil = perfil.Nome
});
if (listapermissoes.Count == 0)
{
throw new Exception("O usuário não possui permissão para acessar o sistema. Entre em contato com o Administrador.");
}
return(new AutenticacaoModel()
{
UniqueKey = IDUsuario, Login = oUsuario.Login, Nome = oUsuario.Nome, Email = oUsuario.Email, TipoDeAcesso = lUsuarios[0].TipoDeAcesso, Permissoes = listapermissoes
});
}
else
{
throw new Exception("Login ou senha incorretos.");
}
}
}
}
public string GerarTicketEncriptado(AutenticacaoModel autenticacaoModel, int expiracaoEmMinuto = 180)
{
var autenticacaoModelSerializado = Serializador.Serializar(autenticacaoModel);
var ticket = new FormsAuthenticationTicket(1, autenticacaoModel.Login,
DateTime.Now, DateTime.Now.AddMinutes(expiracaoEmMinuto), false, autenticacaoModelSerializado,
FormsAuthentication.FormsCookiePath);
var ticketEncriptado = FormsAuthentication.Encrypt(ticket);
return(ticketEncriptado);
}
private void GerarTicketEArmazenarComoCookie(AutenticacaoModel autenticacaoModel, int expiracaoEmMinutos = 480)
{
var ticketEncriptado = GerarTicketEncriptado(autenticacaoModel, expiracaoEmMinutos);
var authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, ticketEncriptado);
authCookie.Expires = DateTime.Now.AddMinutes(expiracaoEmMinutos);
HttpContext.Current.Response.Cookies.Add(authCookie);
}
protected void RegistrarLoginCookie(AutenticacaoModel autenticacao)
{
if (autenticacao != null)
{
CookieOptions cookieOptions = new CookieOptions();
cookieOptions.Expires = DateTime.Now.AddMinutes(30);
string value = JsonSerializer.Serialize <AutenticacaoModel>(autenticacao);
Response.Cookies.Append(_chaveCookieAuth, value, cookieOptions);
}
}
public static string Serializar(AutenticacaoModel autenticacaoModel)
{
var serializer = new XmlSerializer(typeof(AutenticacaoModel));
var sw = new StringWriter();
var xw = XmlWriter.Create(sw);
serializer.Serialize(xw, autenticacaoModel);
var autenticacaoModelSerializado = sw.ToString();
return(autenticacaoModelSerializado);
}
private void ConfereOperador(LoginModel login, AutenticacaoModel autenticacao)
{
Operador operador = _operadorRepository.Obter(login.Login, login.Senha);
if (operador != null)
{
autenticacao.Login = operador.Matricula;
autenticacao.Perfil = operador.PerfilId;
autenticacao.Autenticado = true;
autenticacao.Mensagem = "Login realizado com sucesso.";
autenticacao.ObjetoReferencia = operador;
}
}
public ActionResult Entrar(AutenticacaoModel autenticacaoModel, string returnUrl)
{
if (ModelState.IsValid)
{
string msgErro;
if (autenticacaoProvider.Autenticar(autenticacaoModel, out msgErro, "administrador"))
{
return(Redirect(returnUrl ?? Url.Action("Entrar", "Autenticacao")));
}
TempData["Mensagem"] = msgErro;
}
return(RedirectToAction("Entrar"));
}
private void ConfereCliente(LoginModel login, AutenticacaoModel autenticacao)
{
Cliente cliente = _clienteRepository.Obter(login.Login, login.Senha);
if (cliente != null)
{
autenticacao.Login = cliente.Cpf;
autenticacao.Perfil = cliente.PerfilId;
autenticacao.Autenticado = true;
autenticacao.Mensagem = "Login realizado com sucesso.";
autenticacao.ObjetoReferencia = cliente;
}
}
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 IActionResult RequestToken([FromBody] AutenticacaoModel autenticacao)
{
try
{
Cliente cli = null;
ErroModel erro = null;
using (var db = new ZupContext())
{
string senha = UtilsHelper.CriptografaSenha(autenticacao.Senha);
cli = db.Cliente.Where(w => w.Email.Equals(autenticacao.Email) && w.Senha.Equals(senha)).FirstOrDefault();
}
if (cli != null)
{
var claims = new[]
{
new Claim(ClaimTypes.Email, autenticacao.Email),
new Claim(ClaimTypes.Role, "Admin"),
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["SecurityKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "teste",
audience: "teste",
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
erro = new ErroModel()
{
Mensagem = "Usuário ou senha inválidos."
};
return(NotFound(erro));
} catch (Exception er)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, new ErroModel()
{
Mensagem = er.Message,
StackTrace = er.StackTrace
}));
}
}
public ActionResult Login(AutenticacaoModel usuario)
{
try
{
if (ModelState.IsValid)
{
AutorizacaoProvider.Logar(usuario);
return(Json(new { url = Url.Action("Index", "Painel") }));
}
return(View(usuario));
}
catch (Exception ex)
{
return(Json(new { alerta = ex.Message, titulo = "Oops! Problema ao realizar login..." }));
}
}
public ActionResult Entrar(AutenticacaoModel autenticacaoModel, string ReturnUrl)
{
if (ModelState.IsValid)
{
string msgErro;
if (autenticacaoProvider.Autenticar(autenticacaoModel, out msgErro, "administrador"))
{
//Transfere para o index de CursoController. ActionResult , Controller
//caso nao tenha nenhum endereço redireciona para Index
FormsAuthentication.SetAuthCookie(autenticacaoModel.Login, false);
return(Redirect(ReturnUrl ?? Url.Action("Index", "Admin")));
}
TempData["Mensagem"] = msgErro;
return(RedirectToAction("Entrar"));
}
return(View());
}
public ActionResult Login(AutenticacaoModel usuario)
{
try
{
if (ModelState.IsValid)
{
string msgErro = string.Empty;
AutorizacaoProvider.LogIn(usuario, out msgErro);
return(Json(new { url = Url.Action(ConfigurationManager.AppSettings["Web:DefaultAction"], ConfigurationManager.AppSettings["Web:DefaultController"]) }));
}
return(View(usuario));
}
catch (Exception ex)
{
return(Json(new { alerta = ex.Message, titulo = "Oops! Problema ao realizar login..." }));
}
}
public async Task <IActionResult> Post(AutenticacaoModel model)
{
var usuario = await _usuarioRepository.Obter(model.Login);
if (usuario == null)
{
return(BadRequest("Usuário inválido!"));
}
var senhaCriptografada = new Senha(model.Senha);
if (usuario.Senha != senhaCriptografada.Valor)
{
return(BadRequest("Senha inválida!"));
}
return(Ok("Ok"));
}
public IActionResult AutenticaUsuario([FromBody] AutenticacaoModel autenticacao)
{
string token = string.Empty;
if (_iUsuarioBSService.AutenticarUsuario(autenticacao.Email, autenticacao.Senha) != null)
{
token = _iTokenService.GerarToken(autenticacao.Email, 1);
}
if (!String.IsNullOrEmpty(token))
{
return(Ok(token));
}
else
{
return(NotFound("Credenciais inválidas!"));
}
}
public static async Task <bool> ValidaAutenticacao(AutenticacaoModel request)
{
var uri = new Uri(string.Format("{0}/ValidaAutenticacao/", urlBase));
using (var cliente = new HttpClient())
{
var data = JsonConvert.SerializeObject(request);
var content = new StringContent(data, Encoding.UTF8, "application/json");
HttpResponseMessage response = await cliente.PostAsync(uri, content);
if (response.IsSuccessStatusCode)
{
return(true);
}
}
return(false);
}
public async Task <AutenticacaoResponsePost> Post([FromBody] AutenticacaoRequestPost request)
{
AutenticacaoResponsePost result = new AutenticacaoResponsePost();
if (request.Email == "*****@*****.**" && request.Password == "123456")
{
AutenticacaoModel autenticacaoModel = new AutenticacaoModel
{
Token = "dfadsfa4567"
};
result.Autenticacao = autenticacaoModel;
result.IsValid = 1;
}
else
{
result.IsValid = 0;
}
return(result);
}
public void Logar(AutenticacaoModel autenticacaoModel)
{
usuarioPersistido = UsuarioBusiness.ValidarCredenciais(autenticacaoModel);
if (usuarioPersistido == null)
{
throw new Exception("Não foi possível relacionar um usuário com as permissões do módulo " + ConfigurationManager.AppSettings["Web:NomeModulo"] + " à credencial fornecida. Por favor, entre em contato com um dos administradores do módulo.");
}
else
{
int expiracao;
try
{
expiracao = Convert.ToInt32(FormsAuthentication.Timeout.TotalMinutes);
}
catch { expiracao = 120; }
token = SalvarEmCacheEGerarToken(usuarioPersistido, expiracao);
GerarTicketEArmazenarComoCookie(token, usuarioPersistido.Login);
}
}
public async Task <ActionResult> Autentica(AutenticacaoModel model)
{
if (ModelState.IsValid)
{
AutenticacaoMOD usuario = new AutenticacaoMOD
{
Senha = model.Senha,
Usuario = model.Usuario
};
if (await _autenticacaoBLL.ValidaUsuario(usuario))
{
Session["user"] = usuario.Usuario;
return(RedirectToAction("Index", "Intranet"));
}
}
return(View("Index", new AutenticacaoModel()
{
Mensagem = "Usuário ou senha inválidos"
}));
}
public async Task <IActionResult> ObterAutenticacao(AutenticacaoModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var autenticacao = _servicoDeAplicacaoUsuario.ObterAutenticacao(model.Email, model.Senha);
if (autenticacao == null)
{
return(BadRequest("Autenticação inválida!"));
}
autenticacao.Token = GerarModelParaToken(new TokenModel()
{
UsuarioEmail = autenticacao.UsuarioEmail,
UsuarioId = autenticacao.UsuarioId
});
return(Ok(autenticacao));
}
public ActionResult Perfil()
{
Usuario usr = UsuarioBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.UniqueKey.Equals(AutorizacaoProvider.UsuarioAutenticado.UniqueKey));
AutenticacaoModel aut = AutorizacaoProvider.UsuarioAutenticado;
aut.Telefone = usr.Telefone;
try
{
Departamento dep = DepartamentoBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.UniqueKey.Equals(usr.UKDepartamento));
aut.Departamento = dep.Sigla + " [" + dep.Codigo + "]";
}
catch { }
try
{
Empresa emp = EmpresaBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.UniqueKey.Equals(usr.UKEmpresa));
aut.Empresa = emp.NomeFantasia;
}
catch { }
return(View(aut));
}
public static async Task <bool> ValidaAutenticacao(AutenticacaoModel request)
{
return(await AutenticacaoApiAdapter.ValidaAutenticacao(request));
}
public AutenticacaoModel ValidarCredenciais(AutenticacaoModel autenticacaoModel)
{
autenticacaoModel.Login = autenticacaoModel.Login.Trim().ToUpper().Replace(".", "").Replace("-", "").Replace("/", "");
autenticacaoModel.Login = autenticacaoModel.Login.Trim();
//Buscar usuário sem validar senha, para poder determinar se a validação da senha será com AD ou com a senha interna do GIS
List <Usuario> lUsuarios = Consulta.Where(u => string.IsNullOrEmpty(u.UsuarioExclusao) &&
(u.Login.Equals(autenticacaoModel.Login) || u.Email.Equals(autenticacaoModel.Login))).ToList();
string teste = "teste";
if (lUsuarios.Count == 0)
{
throw new Exception("Não foi possível identificar o seu cadastro.");
}
else if (lUsuarios.Count > 1)
{
throw new Exception("Não foi possível identificar o seu cadastro.");
}
else
{
if (lUsuarios[0].TipoDeAcesso == TipoDeAcesso.AD)
{
throw new Exception("Autenticação via AD não habilitada. Favor acionar a empresa de suporte.");
//Login, validando a senha no AD
//Guid UKEmpresa = lUsuarios[0].UKEmpresa;
//Empresa emp = EmpresaBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.UniqueKey.Equals(UKEmpresa));
//if (emp == null)
//{
// throw new Exception("Nâo foi possível encontrar a empresa vinculada ao perfil do usuário.");
//}
//else
//{
// if (Convert.ToBoolean(ConfigurationManager.AppSettings["AD:DMZ"]))
// {
// //Chamar web service para validar a senha no AD
// //ws.Url = emp.URL_WS;
// string rs = ws.LoginAD(autenticacaoModel.Login, autenticacaoModel.Senha);
// if (rs.Equals("\"-1\""))
// {
// throw new Exception("Login ou senha incorreto.");
// }
// else
// {
// Guid IDUsuario = lUsuarios[0].UniqueKey;
// List<VMPermissao> listapermissoes = new List<VMPermissao>();
// listapermissoes.AddRange(from usuarioperfil in UsuarioPerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList()
// join perfil in PerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList() on usuarioperfil.UKPerfil equals perfil.UniqueKey
// join empresa in EmpresaBusiness.Consulta.Where(a => string.IsNullOrEmpty(a.UsuarioExclusao)).ToList() on usuarioperfil.UKConfig equals empresa.UniqueKey
// where usuarioperfil.UKUsuario.Equals(IDUsuario)
// select new VMPermissao { UKPerfil = perfil.UniqueKey, Perfil = perfil.Nome, UKConfig = empresa.UniqueKey, Config = empresa.NomeFantasia });
// listapermissoes.AddRange(from usuarioperfil in UsuarioPerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList()
// join perfil in PerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList() on usuarioperfil.UKPerfil equals perfil.UniqueKey
// join dep in DepartamentoBusiness.Consulta.Where(a => string.IsNullOrEmpty(a.UsuarioExclusao)).ToList() on usuarioperfil.UKConfig equals dep.UniqueKey
// where usuarioperfil.UKUsuario.Equals(IDUsuario)
// select new VMPermissao { UKPerfil = perfil.UniqueKey, Perfil = perfil.Nome, UKConfig = dep.UniqueKey, Config = dep.Sigla });
// if (listapermissoes.Count == 0)
// {
// throw new Exception("O usuário não possui permissão para acessar o sistema. Entre em contato com o Administrador.");
// }
// return new AutenticacaoModel() { UniqueKey = lUsuarios[0].UniqueKey, Login = lUsuarios[0].Login, Nome = lUsuarios[0].Nome, Email = lUsuarios[0].Email, TipoDeAcesso = lUsuarios[0].TipoDeAcesso, Permissoes = listapermissoes };
// }
// }
// else
// {
// using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, emp.URL_AD))
// {
// if (pc.ValidateCredentials(autenticacaoModel.Login, autenticacaoModel.Senha))
// return null;
// else
// throw new Exception("Login ou senha incorretos.");
// }
// }
//}
}
else
{
//Login, validando a senha interna no CIS
Guid IDUsuario = lUsuarios[0].UniqueKey;
string senhaCifrada = CreateHashFromPassword(autenticacaoModel.Senha);
Usuario oUsuario = Consulta.FirstOrDefault(p => p.UniqueKey.Equals(IDUsuario) && p.Senha.Equals(senhaCifrada));
if (oUsuario != null)
{
List <VMPermissao> listapermissoes = new List <VMPermissao>();
listapermissoes.AddRange(from usuarioperfil in UsuarioPerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList()
join perfil in PerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList() on usuarioperfil.UKPerfil equals perfil.UniqueKey
join area in DepartamentoBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList() on usuarioperfil.UKConfig equals area.UniqueKey
where usuarioperfil.UKUsuario.Equals(IDUsuario)
select new VMPermissao {
Perfil = perfil.Nome, Config = area.Sigla
});
//listapermissoes.AddRange(from usuarioperfil in UsuarioPerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList()
// join perfil in PerfilBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList() on usuarioperfil.UKPerfil equals perfil.UniqueKey
// where usuarioperfil.UKUsuario.Equals(IDUsuario)
// select new VMPermissao { Perfil = perfil.Nome });
if (listapermissoes.Count == 0)
{
throw new Exception("O usuário não possui permissão para acessar o sistema. Entre em contato com o Administrador.");
}
return(new AutenticacaoModel()
{
UniqueKey = IDUsuario, Login = oUsuario.Login, Nome = oUsuario.Nome, Email = oUsuario.Email, TipoDeAcesso = lUsuarios[0].TipoDeAcesso, Permissoes = listapermissoes
});
}
else
{
throw new Exception("Login ou senha incorretos.");
}
}
}
}
