private void ExcluiUsuarioSeExistir(AutenticarUsuarioCommand request, Dominio.Entidades.Usuario usuarioRetorno)
{
if (usuarioRetorno != null)
{
_repository.ExcluirUsuario(request.Cpf);
}
}
private AtualizarPrimeiroAcessoCommand MapearAtualizarPrimeiroAcessoCommand(Dominio.Entidades.Usuario usuario)
{
return(new AtualizarPrimeiroAcessoCommand
{
Id = usuario.Id,
PrimeiroAcesso = false
});
}
/// <summary>
/// Funcion que permite buscar todas las facturas en la base de datos
/// </summary>
/// <returns>Retorna la lista con todas las facturas</returns>
public List <Entidad> ConsultarTodos()
{
List <Parametro> parameters = new List <Parametro>();
Parametro theParam = new Parametro();
List <Entidad> listProducto = new List <Entidad>();
try
{
//Guardo la tabla que me regresa el procedimiento de consultar contactos
DataTable dt = EjecutarStoredProcedureTuplas(RecursoUsuario.ConsultUsuario, parameters);
//Guardar los datos
foreach (DataRow row in dt.Rows)
{
int _id = int.Parse(row[RecursoUsuario.UsuarioId].ToString());
string _nombre = row[RecursoUsuario.UsuarioNombre].ToString();
string _apellido = row[RecursoUsuario.UsuarioApellido].ToString();
string _cedula = row[RecursoUsuario.UsuarioCedula].ToString();
DateTime _fechaNacimiento = DateTime.Parse(row[RecursoUsuario.UsuarioFechaNac].ToString());
DateTime _fechaCreacion = DateTime.Parse(row[RecursoUsuario.UsuarioFechaCre].ToString());
string _email = row[RecursoUsuario.UsuarioEmail].ToString();
string _telefono = row[RecursoUsuario.UsuarioTelefono].ToString();
string _celular = row[RecursoUsuario.UsuarioCelular].ToString();
int _activo = int.Parse(row[RecursoUsuario.UsuarioActivo].ToString());
Dominio.Entidades.Usuario _ElUsuario = new Dominio.Entidades.Usuario(_id, _nombre, _apellido, _cedula, _telefono, _celular,
_fechaNacimiento, _fechaCreacion, _email, _activo);
//_ElUsuario.Id = facId;
listProducto.Add(_ElUsuario);
}
}
catch (FormatException ex)
{
/* throw new ExcepcionesTangerine.M8.WrongFormatException(RecursoUsuario.Codigo,
* RecursoUsuario.MensajeFormato, ex);*/
}
catch (ArgumentNullException ex)
{
/* throw new ExcepcionesTangerine.M8.NullArgumentException(RecursoUsuario.Codigo,
* RecursoUsuario.MensajeNull, ex);*/
}
catch (ExceptionCcConBD ex)
{
/*throw new ExceptionsCity(RecursoUsuario.Codigo,
* RecursoUsuario.MensajeSQL, ex);*/
}
catch (Exception ex)
{
/*throw new ExceptionsCity(RecursoUsuario.Codigo,
* RecursoUsuario.MensajeOtro, ex);*/
}
return(listProducto);
}
public static async Task <Dominio.Entidades.Usuario> Executar(IMediator mediator, string cpf)
{
Dominio.Entidades.Usuario usuario = await mediator.Send(new ObterUsuarioPorCpfCommand(cpf));
if (usuario == null)
{
throw new UsuarioNaoEncontradoException();
}
return(usuario);
}
public async Task <Guid> Handle(CriarUsuarioCommand request, CancellationToken cancellationToken)
{
var entidade = new Dominio.Entidades.Usuario(request.Login, request.Senha, request.ValorMinimo, request.ValorMaxino, (PapelAprovacao)request.Papel);
_context.Usuarios.Add(entidade);
await _context.SaveChangesAsync(cancellationToken);
return(entidade.Id);
}
private async Task CriarUsuarioOuAssociarGrupo(NovaSenhaDto novaSenhaDto, Dominio.Entidades.Usuario usuario, RetornoUsuarioCoreSSO usuarioCoreSSO, string nomeUsuario)
{
if (usuarioCoreSSO != null)
{
await AssociarGrupoEAlterarSenha(novaSenhaDto, usuarioCoreSSO);
}
else
{
await CriarUsuario(novaSenhaDto, usuario, nomeUsuario);
}
}
private Dominio.Entidades.Usuario MapearDominioUsuario(RetornoUsuarioEol usuarioEol, bool primeiroAcesso)
{
var usuario = new Dominio.Entidades.Usuario
{
Cpf = usuarioEol.Cpf,
Excluido = false,
UltimoLogin = DateTime.Now,
PrimeiroAcesso = primeiroAcesso
};
return(usuario);
}
public void Crear(long empleadoId, string apellidoEmpleado, string nombreEmpleado)
{
var nuevoUsuario = new Dominio.Entidades.Usuario
{
EstaEliminado = false,
EmpleadoId = empleadoId,
EstaBloqueado = false,
Nombre = ObtenerNombreUsuario(apellidoEmpleado, nombreEmpleado),
Password = Encriptar(PasswordPorDefecto)
};
_unidadDeTrabajo.UsuarioRepositorio.Insertar(nuevoUsuario);
_unidadDeTrabajo.Commit();
}
public ResultadoRegistroUsuario Registrar([FromBody] RegistroUsuario usuario)
{
try {
GerarErroSeNaoInformado(usuario.Senha, "senha");
GerarErroSeNaoInformado(usuario.CPF, "CPF");
GerarErroSeNaoInformado(usuario.Login, "login");
GerarErroSeNaoInformado(usuario.DataNascimento, "data de nascimento");
if (usuarios.ExisteComLogin(usuario.Login))
{
throw new Exception("Já existe um usuário cadastrado com esse login");
}
if (usuarios.ExisteComCPF(usuario.CPF))
{
throw new Exception("Já existe um usuário cadastrado com esse CPF");
}
var dadosUsuario = dadosUsuarioQuery.RecuperarUsuario(usuario.Login, usuario.CPF, usuario.DataNascimento);
if (dadosUsuario == null)
{
throw new Exception("Não foram encontrados dados deste usuário no sistema");
}
var senhaCriptografada = CalcularHash(usuario.Senha);
var novoUsuario = new Dominio.Entidades.Usuario {
Login = usuario.Login,
CPF = usuario.CPF,
DataNascimento = usuario.DataNascimento,
Senha = senhaCriptografada
};
try {
usuarios.Salvar(novoUsuario);
} catch (Exception e) {
throw new Exception($"Não foi possível criar um novo usuário com os dados enviados: {e.Message}");
}
return(new ResultadoRegistroUsuario {
Status = true,
MotivoCritica = String.Empty,
UsuarioLogado = dadosUsuario
});
} catch (Exception e) {
return(new ResultadoRegistroUsuario {
Status = false, MotivoCritica = $"Ocorreu um erro ao criar um novo usuário: {e.Message}"
});
}
}
private RespostaApi MapearResposta(RetornoUsuarioEol usuarioEol, Dominio.Entidades.Usuario usuarioApp, bool primeiroAcesso, bool informarCelularEmail)
{
RespostaAutenticar usuario = new RespostaAutenticar
{
Cpf = usuarioEol.Cpf,
Email = usuarioApp.Email,
Id = usuarioApp.Id,
Nome = usuarioEol.Nome,
PrimeiroAcesso = primeiroAcesso,
InformarCelularEmail = informarCelularEmail,
Celular = usuarioApp.Celular,
Token = ""
};
return(RespostaApi.Sucesso(usuario));
}
private async Task <RespostaApi> AutenticarUsuario(RedefinirSenhaDto dto, Dominio.Entidades.Usuario usuario)
{
var autenticacao = await mediator.Send(new AutenticarUsuarioCommand(usuario.Cpf, dto.Senha));
if (!autenticacao.Ok)
{
throw new NegocioException(string.Join(',', autenticacao.Erros));
}
var token = await mediator.Send(new CriarTokenCommand(usuario.Cpf));
await mediator.Send(new UsuarioDispositivoCommand(usuario.Cpf, dto.DispositivoId));
((RespostaAutenticar)autenticacao.Data).Token = token;
return(autenticacao);
}
private RespostaApi MapearResposta(RetornoUsuarioEol usuarioEol, Dominio.Entidades.Usuario usuarioApp, bool primeiroAcesso, bool atualizarDadosCadastrais)
{
RespostaAutenticar usuario = new RespostaAutenticar
{
Cpf = usuarioEol.Cpf,
Email = usuarioEol.Email,
Id = usuarioApp.Id,
Nome = usuarioEol.Nome,
DataNascimento = usuarioEol.DataNascimentoResponsavel,
NomeMae = usuarioEol.NomeMae,
PrimeiroAcesso = primeiroAcesso,
AtualizarDadosCadastrais = atualizarDadosCadastrais,
Celular = usuarioEol.ObterCelularComDDD(),
Token = "",
UltimaAtualizacao = usuarioEol.DataAtualizacao
};
return(RespostaApi.Sucesso(usuario));
}
public IActionResult Login(LoginModel model)
{
if (!ModelState.IsValid)
{
ViewBag.ErrorMessage = "Dados de Login Invalidos.";
ModelState.Clear();
return(View("Index"));
}
try
{
string senhaCript = Criptografia.Criptografar(model.Senha);
user = IoC.Resolver <IUsuarioAppServico>().ObterPorLoginSenha(model.Usuario, senhaCript);
if (user != null)
{
HttpContext.Session.SetString("userId", user.Id.ToString());
user.Logado = true;
user.UltimaConexao = DateTime.Now;
IoC.Resolver <IUsuarioAppServico>().Atualizar(user);
usuarioLogado = true;
idPerfilUsuario = user.IdPerfil;
return(RedirectToAction("PaginaInicial", "Home"));
}
else
{
ViewBag.ErrorMessage = "Dados de Login Invalidos.";
ModelState.Clear();
return(View("Index"));
}
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.Message;
}
return(View());
}
public Usuario Find(params object[] keyValues)
{
Dominio.Entidades.Usuario data = null;
try
{
//if (session != null)
// _repositoryUsuario.UnitOfWork.SetConnectionDb(session.ConnectionString);
// Domain Services?
data = _repositoryUsuario.Find(keyValues);
}
catch (Exception ex)
{
//LoggerFactory.CreateLog().Error(ex);
}
//LoggerFactory.CreateLog().Stop();
//return Mapper.Map<Usuario>(data);
return(data);
}
private async Task EnvioEmail(ResponsavelAlunoEolResumidoDto usuarioEol, Dominio.Entidades.Usuario usuario)
{
try
{
string caminho = $"{Directory.GetCurrentDirectory()}/wwwroot/ModelosEmail/RecuperacaoSenha.html";
var textoArquivo = await File.ReadAllTextAsync(caminho);
var urlFrontEnd = variaveisGlobaisOptions.UrlArquivosEstaticos;
var textoEmail = textoArquivo
.Replace("#NOME", usuarioEol.Nome)
.Replace("#CODIGO", usuario.Token)
.Replace("#URL_BASE#", urlFrontEnd)
.Replace("#VALIDADE", usuario.ValidadeToken?.ToString("dd/MM/yyyy HH:mm"));
await emailServico.Enviar(usuarioEol.Nome, usuarioEol.Email, "Redefinição de Senha Escola Aqui", textoEmail);
}
catch (Exception ex)
{
SentrySdk.CaptureException(ex);
throw new NegocioException("Não foi possivel realizar o envio de email, por favor contate o suporte");
}
}
private CriarUsuarioCoreSSOCommand MapearCriarUsuarioCoreSSOCommand(NovaSenhaDto novaSenhaDto, Dominio.Entidades.Usuario usuario, string nomeUsuario)
{
return(new CriarUsuarioCoreSSOCommand()
{
Usuario = new UsuarioCoreSSODto
{
Cpf = usuario.Cpf,
Nome = nomeUsuario,
Senha = novaSenhaDto.NovaSenha,
}
});
}
private async Task CriarUsuarioOuAssociarGrupo(IMediator mediator, NovaSenhaDto novaSenhaDto, Dominio.Entidades.Usuario usuario, RetornoUsuarioCoreSSO usuarioCoreSSO)
{
if (usuarioCoreSSO != null)
{
await AssociarGrupoEAlterarSenha(mediator, novaSenhaDto, usuarioCoreSSO);
}
else
{
await CriarUsuario(mediator, novaSenhaDto, usuario);
}
}
private async Task <Dominio.Entidades.Usuario> CriaUsuarioEhSeJaExistirAtualizaUltimoLogin(AutenticarUsuarioCommand request, Dominio.Entidades.Usuario usuarioRetorno, RetornoUsuarioEol usuario, bool primeiroAcesso)
{
usuario.Cpf = request.Cpf;
if (usuarioRetorno != null)
{
usuarioRetorno.AtualizarLogin(primeiroAcesso);
await _repository.AltualizarUltimoAcessoPrimeiroUsuario(usuarioRetorno);
}
else
{
await _repository.SalvarAsync(MapearDominioUsuario(usuario, primeiroAcesso));
}
return(await _repository.ObterUsuarioNaoExcluidoPorCpf(request.Cpf));
}
private async Task CriarUsuario(NovaSenhaDto novaSenhaDto, Dominio.Entidades.Usuario usuario, string nomeUsuario)
{
var comandoCriaUsuario = MapearCriarUsuarioCoreSSOCommand(novaSenhaDto, usuario, nomeUsuario);
await mediator.Send(comandoCriaUsuario);
}
public SalvarUsuarioCommand(Dominio.Entidades.Usuario usuario)
{
Usuario = usuario;
}
