public IActionResult Login(UsuarioModel usuarioModel)
{
UsuarioDTO usuarioDTO = ConverterModelParaDTO(usuarioModel);
AutenticacaoDTO auth = null;
if (usuarioDTO != null && !String.IsNullOrWhiteSpace(usuarioDTO.Login) && !String.IsNullOrWhiteSpace(usuarioDTO.Senha))
{
auth = AutenticarUsuario(usuarioDTO);
if (auth != null)
{
if (usuarioModel.PreReserva)
{
return(RedirectToAction("ConcluirReserva", "Reserva", null));
}
return(RedirectToAction("Index", "Home"));
}
}
else if (VerificarUsuarioLogado())
{
return(RedirectToAction("Index", "CadastroCliente"));
}
base.PreencherViewBagUsuarioLogado();
return(View("Login", usuarioModel));
}
public AutenticacaoModel(AutenticacaoDTO autenticacaoDTO)
{
Cliente = new ClienteModel(autenticacaoDTO?.Cliente);
Usuario = new UsuarioModel(autenticacaoDTO?.Usuario);
Token = autenticacaoDTO?.Token;
if (Usuario != null)
{
Usuario.NomeUsuario = Cliente?.Nome;
}
}
public async Task <ActionResult <RespostaApi> > AutenticarUsuario([FromBody] AutenticacaoDTO autenticacao, [FromServices] IAutenticarUsuarioUseCase autenticarUsuarioUseCase)
{
try
{
return(Ok(await autenticarUsuarioUseCase.Executar(autenticacao.Cpf, autenticacao.Senha, autenticacao.DispositivoId)));
}
catch (System.Exception ex)
{
return(BadRequest(ex));
}
}
private bool AutenticarComIdentity(AutenticacaoDTO autenticacao)
{
if (autenticacao.Usuario == "teste" && autenticacao.Senha == "123456")
{
return(true);
}
else
{
return(false);
}
}
public async Task <ResultadoAutenticacaoDTO> Autenticar(AutenticacaoDTO autenticacao)
{
ResultadoAutenticacaoDTO resultado = new ResultadoAutenticacaoDTO();
if (autenticacao == null || string.IsNullOrEmpty(autenticacao.Usuario) || string.IsNullOrEmpty(autenticacao.Senha))
{
resultado.Status = EnumResultadoAutenticacao.FALHA_CREDENCIAIS;
}
else
{
try
{
using (AmazonCognitoIdentityProviderClient provider = new AmazonCognitoIdentityProviderClient(
new Amazon.Runtime.AnonymousAWSCredentials(),
RegionEndpoint.GetBySystemName(this._awsConfigAdapter.Cognito.PoolRegion)))
{
CognitoUserPool userPool = new CognitoUserPool(
this._awsConfigAdapter.Cognito.PoolID,
this._awsConfigAdapter.Cognito.ClientID,
provider,
this._awsConfigAdapter.Cognito.ClientSecret);
CognitoUser user = new CognitoUser(
autenticacao.Usuario,
this._awsConfigAdapter.Cognito.ClientID,
userPool,
provider,
this._awsConfigAdapter.Cognito.ClientSecret);
InitiateSrpAuthRequest authRequest = new InitiateSrpAuthRequest()
{
Password = autenticacao.Senha
};
AuthFlowResponse authResponse = await user.StartWithSrpAuthAsync(authRequest);
resultado.Status = EnumResultadoAutenticacao.SUCESSO;
resultado.Token = authResponse.AuthenticationResult.IdToken;
}
}
catch (Amazon.CognitoIdentityProvider.Model.NotAuthorizedException naEx)
{
this._logger.LogError(naEx, "Tentativa de login bloqueada. Usuario: {0} / Senha: {1}", autenticacao.Usuario, autenticacao.Senha);
resultado.Status = EnumResultadoAutenticacao.FALHA_CREDENCIAIS;
}
catch (Exception ex)
{
this._logger.LogError(ex, "Erro no processo de autenticação");
resultado.Status = EnumResultadoAutenticacao.ERRO_NAO_TRATADO;
}
}
return(resultado);
}
public async Task <IActionResult> Autenticar([FromBody] AutenticacaoDTO autenticacao)
{
var token = await this._loginService.Autenticar(autenticacao);
if (token == null)
{
return(Unauthorized());
}
return(Ok(token));
}
public string GetHashUsuario([FromBody] AutenticacaoDTO login)
{
if (Token.ValidarToken(login.Hash, _memoryCache))
{
return(HashApi.GerarHash(login.Login, _memoryCache));
}
else
{
return(null);
}
}
public string ValidarLogin([FromBody] AutenticacaoDTO login)
{
if (Token.ValidarToken(login.Hash, _memoryCache))
{
return(new UsuarioRepository().ValidarLogin(login.Login, login.Senha));
}
else
{
return("Falha na autenticação do serviço!");
}
}
public IActionResult Post([FromBody] AutenticacaoDTO dto)
{
string nome = dto.Usuario.Trim();
string senha = dto.Senha.Trim();
var autentica = _context.Autenticacao.Where(a => a.Usuario == dto.Usuario && a.Senha == dto.Senha).ToList();
if (autentica.Count == 0)
{
return(Unauthorized());
}
return(Ok(Autenticacao.geraToken()));
}
public void Login(AutenticacaoDTO usuarioDTO)
{
var preferencesEditor = _sharedPreferences.Edit();
preferencesEditor.PutInt("UsuarioId", usuarioDTO.Id);
preferencesEditor.PutString("Login", usuarioDTO.Login);
preferencesEditor.PutString("Nome", usuarioDTO.Nome);
preferencesEditor.PutString("Token", usuarioDTO.Token);
preferencesEditor.PutString("TokenExpiracao", usuarioDTO.Expires.ToString());
preferencesEditor.PutString("Perfil", usuarioDTO.Perfil);
if (usuarioDTO.Classes != null)
{
preferencesEditor.PutString("Classes", JsonConvert.SerializeObject(usuarioDTO.Classes));
}
preferencesEditor.Commit();
}
public IActionResult Token(AutenticacaoDTO autenticacao)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponse.FromModelState(ModelState)));
}
//Implementar o Identity
//var result = _signInManager.PasswordSignAsync(autenticacao.Login, autenticacao.Password, true, true);
if (AutenticarComIdentity(autenticacao))
{
string token = CriarTokenJwt(autenticacao.Usuario);
return(Ok(token));
}
else
{
return(Unauthorized());
}
}
public IActionResult RegistrarUsuario(UsuarioModel usuarioModel)
{
var usuarioDTO = ConverterModelParaDTO(usuarioModel);
AutenticacaoDTO auth = null;
if (usuarioDTO != null)
{
var usuario = _usuarioBLL.RegistrarUsuario(usuarioDTO);
auth = AutenticarUsuario(usuario);
}
if (usuarioModel.PreReserva)
{
return(RedirectToAction("ConcluirReserva", "Reserva"));
}
if (auth != null)
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(RedirectToAction("Cadastrar", "CadastroUsuario", usuarioModel));
}
}
public AutenticacaoDTO EfeturaLogin(UsuarioDTO usuario)
{
AutenticacaoDTO retorno = Post <AutenticacaoDTO>(_rotaAutenticacao, null, usuario);
return(retorno);
}
public IActionResult Autenticar([FromBody] UsuarioDTO dto)
{
var usuario = UnidadeTrabalho.UsuarioRepositorio.ObterPorLoginSenha(dto.Login, Hash.GerarHash(dto.Senha ?? ""));
if (usuario == null)
{
return(Unauthorized());
}
var chave = Encoding.ASCII.GetBytes(_configuracoesApp.ChaveSecreta);
var expires = DateTime.UtcNow.AddDays(7);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, usuario.Id.ToString()),
new Claim(ClaimTypes.Role, usuario.Perfil)
}),
Expires = expires,
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(chave), SecurityAlgorithms.HmacSha256Signature)
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
var resultado = new AutenticacaoDTO
{
Id = usuario.Id,
Login = dto.Login,
Nome = usuario.Nome,
Token = tokenHandler.WriteToken(token),
Expires = expires,
Perfil = usuario.Perfil
};
IEnumerable <Classe> classes;
switch (usuario.Perfil)
{
case Perfil.Admin:
classes = UnidadeTrabalho.ClasseRepositorio.Todos(include: x => x.Congregacao);
break;
case Perfil.Coordenador:
var coordenador = UnidadeTrabalho.CoordenadorRepositorio.ObterPorUsuario(usuario.Id);
if (coordenador == null)
{
return(NotFound());
}
var congregacoes = UnidadeTrabalho.CoordenadorCongregacaoRepositorio.ObterCongregacoesPorCoordenadorId(coordenador.Id).ToList();
if (!congregacoes.Any())
{
return(BadRequest()); // TODO: Criar objeto de erro para retornar
}
classes = UnidadeTrabalho.ClasseRepositorio.TodosPorCongregacoes(congregacoes);
break;
case Perfil.Professor:
var professor = UnidadeTrabalho.ProfessorRepositorio.ObterPorUsuario(usuario.Id);
if (professor == null)
{
return(NotFound());
}
classes = UnidadeTrabalho.ProfessorClasseRepositorio.ObterClassesPorProfessorId(professor.Id);
break;
default:
return(BadRequest()); // TODO: Criar objeto de erro para retornar
}
resultado.Classes = ModeloParaDTO(classes);
return(Ok(resultado));
}
