public async Task ExecuteAsync()
{
var usuarioDb = _usuarioRepository.GetUsuarioByEmail("*****@*****.**");
if (usuarioDb == null)
{
var tipoUsuarioDb = _tipoUsuarioRepository.GetByDescricao(TipoUsuarioDefaultValuesAccess.GetValue(TipoUsuarioDefaultValues.Administrador));
var statusUsuarioDb = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaAtiva));
// Criação do usuário
Usuario usuario = null;
try
{
string nome = "Administrador Padrão";
string email = "*****@*****.**";
string senha = "admin12345";
// Gera o código HASH da senha
var senhaHash = new PasswordHasher <Usuario>().HashPassword(usuario, senha);
usuario = new Usuario(nome, email, senhaHash, tipoUsuarioDb.Id);
}
catch (Exception)
{
}
// Cria o usuário no banco de dados
var usuarioAdmDb = _usuarioRepository.Create(usuario);
// Cria o 1° histórico do usuário
HistoricoStatusUsuario historicoUsuario = null;
try
{
historicoUsuario = new HistoricoStatusUsuario(statusUsuarioDb.Id, usuarioAdmDb.Id);
}
catch (Exception)
{
}
_historicoStatusUsuarioRepository.Create(historicoUsuario);
// Criação do UsuarioAdministrador
UsuarioAdministrador usuarioAdm = null;
try
{
usuarioAdm = new UsuarioAdministrador("123456", usuarioAdmDb.Id);
}
catch (Exception)
{
}
// Cria o UsuarioAdministrador no banco de dados
_usuarioAdministradorRepository.Create(usuarioAdm);
// Salva as Alterações na DB
await _usuarioAdministradorRepository.UnitOfWork.SaveDbChanges();
}
}
public async Task ExecuteAsync()
{
for (int i = 0; i < 3; i++)
{
var defaultValue = (StatusUsuarioDefaultValues)i;
var stringDefaultValue = StatusUsuarioDefaultValuesAcess.GetValue(defaultValue);
var statusUsuarioDb = _statusUsuarioRepository.GetByDescricao(stringDefaultValue);
if (statusUsuarioDb == null)
{
statusUsuarioDb = new StatusUsuario(stringDefaultValue);
_statusUsuarioRepository.Create(statusUsuarioDb);
await _statusUsuarioRepository.UnitOfWork.SaveDbChanges();
}
}
}
public List <AlunoViewModel> GetAllAlunos()
{
// Busca statusUsuario Excluido na DB
var statusUsuarioExcluidoDb = _ctx.StatusUsuarios.FirstOrDefault(x => x.Descricao == StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaExcluida));
// Busca todos os históricos com o StatusUsuarioId diferente de excluido
var historicoStatusDb = _ctx.HistoricoStatusUsuarios.Where(x => x.StatusUsuarioId != statusUsuarioExcluidoDb.Id);
// Busca todos os alunos que não estejam com contas excluídas
var candidatosDb = _ctx.UsuarioCandidatoAlunos.Where(x => historicoStatusDb.Any(y => y.UsuarioId == x.UsuarioId));
// Busca todos os alunos cadastrados na plataforma
var alunos = _mapper.Map <List <AlunoViewModel> >(_ctx.Alunos.Where(x => candidatosDb.Any(y => y.AlunoId == x.Id)));
// Itera entre todos os alunos para preencher todos os objetos
alunos.ForEach(x =>
{
// Preenche TermoOuEgresso do aluno
x.TermoOuEgressoAluno = _mapper.Map <TermoOuEgressoAlunoViewModel>(_ctx.TermoOuEgressoAlunos.FirstOrDefault(y => y.Id == x.TermoOuEgressoAluno.Id));
// Preenche o tipoCurso do aluno
x.TipoCurso = _mapper.Map <TipoCursoViewModel>(_ctx.TipoCursos.FirstOrDefault(y => y.Id == x.TipoCurso.Id));
// Busca vinculo entre usuario X candidato no BD
var usuarioCandidatoDb = _ctx.UsuarioCandidatoAlunos.FirstOrDefault(y => y.AlunoId == x.Id);
// Caso existir, acrescenta o Perfil do Candidato (linkExterno + SobreOCandidato)
if (usuarioCandidatoDb != null)
{
x.PerfilCandidato = _mapper.Map <PerfilUsuarioCandidatoAlunoViewModel>(_ctx.PerfilUsuarioCandidatoAlunos.FirstOrDefault(y => y.UsuarioCandidatoAlunoId == usuarioCandidatoDb.Id));
}
});
return(alunos);
}
public async Task <IActionResult> CriarUsuarioAdministrador(CriarUsuarioAdministradorInput input)
{
// Verifica se existe um usuário com mesmo email cadastrado no sistema
var usuarioDb = _usuarioRepository.GetUsuarioByEmail(input.Email);
if (usuarioDb != null)
{
return(StatusCode(400, "Já existe um usuário cadastrado com este email."));
}
// Verifica se existe um aluno cadastrado com mesmo email
var alunoDb = _alunoRepository.BuscarPorEmail(input.Email);
if (alunoDb != null)
{
return(StatusCode(400, $"Já existe um aluno cadastrado com email [{input.Email}] no sistema."));
}
var tipoAdmDb = _tipoUsuarioRepository.GetByDescricao(TipoUsuarioDefaultValuesAccess.GetValue(TipoUsuarioDefaultValues.Administrador));
var statusUsuarioDb = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaAtiva));
// Cria o usuário
Usuario usuario = null;
try
{
// Gera Hash da senha
var senhaHash = new PasswordHasher <Usuario>().HashPassword(usuario, input.Senha);
usuario = new Usuario(input.Nome, input.Email, senhaHash, tipoAdmDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o usuário."));
}
usuarioDb = _usuarioRepository.Create(usuario);
// Cria o 1° histórico do usuário
HistoricoStatusUsuario historicoUsuario = null;
try
{
historicoUsuario = new HistoricoStatusUsuario(statusUsuarioDb.Id, usuarioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o histórico do usuário."));
}
_historicoStatusUsuarioRepository.Create(historicoUsuario);
// Cria o usuário administrador
UsuarioAdministrador usuarioAdm = null;
try
{
usuarioAdm = new UsuarioAdministrador(input.Nif, usuarioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao vincular o usuário à um perfil de Administrador."));
}
_usuarioAdministradorRepository.Create(usuarioAdm);
await _usuarioAdministradorRepository.UnitOfWork.SaveDbChanges();
return(StatusCode(200, $"Usuário [{usuarioDb.Email}] com perfil de {tipoAdmDb.Descricao} criado com sucesso!"));
}
public async Task <IActionResult> CriarUsuarioCandidato(string token, CriarUsuarioCandidatoAlunoInput input)
{
// Busca validacao de usuario por token
var validacaoUsuario = _validacaoUsuarioCandidatoRepository.GetValidacaoUsuarioCandidatoByToken(token);
// Caso não existir
if (validacaoUsuario == null)
{
return(StatusCode(404, "Este Token expirou ou não existe no banco de dados."));
}
// Caso não seja mais válido
if (DateTime.Now.ToUniversalTime() > validacaoUsuario.DataValida.ToUniversalTime())
{
// Altera para inativo caso não seja mais válido
validacaoUsuario.AlterarParaInativo();
_validacaoUsuarioCandidatoRepository.UpdateValidacaoUsuarioCandidato(validacaoUsuario);
// Salva alterações no BD
await _validacaoUsuarioCandidatoRepository.UnitOfWork.SaveDbChanges();
return(StatusCode(400, "Este Token para validação de usuário expirou."));
}
// Busca aluno pelo Id
var alunoDb = _alunoRepository.GetById(validacaoUsuario.AlunoId);
// Caso aluno não exista mais
if (alunoDb == null)
{
return(StatusCode(400, "O aluno não existe mais no banco de dados, não será permitido criar um usuário."));
}
var tipoCandidatoDb = _tipoUsuarioRepository.GetByDescricao(TipoUsuarioDefaultValuesAccess.GetValue(TipoUsuarioDefaultValues.Candidato));
var statusUsuarioDb = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaAtiva));
// Cria o usuário
Usuario usuario = null;
try
{
// Gera Hash da senha
var senhaHash = new PasswordHasher <Usuario>().HashPassword(usuario, input.Senha);
usuario = new Usuario(alunoDb.NomeCompleto, alunoDb.Email, senhaHash, tipoCandidatoDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o usuário."));
}
var usuarioDb = _usuarioRepository.Create(usuario);
// Cria o 1° histórico do usuário
HistoricoStatusUsuario historicoUsuario = null;
try
{
historicoUsuario = new HistoricoStatusUsuario(statusUsuarioDb.Id, usuarioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o histórico do usuário."));
}
_historicoStatusUsuarioRepository.Create(historicoUsuario);
// Cria o usuarioCandidato
UsuarioCandidatoAluno usuarioCandidato = null;
try
{
usuarioCandidato = new UsuarioCandidatoAluno(alunoDb.Id, usuarioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao vincular o perfil de candidato ao usuário."));
}
var usuarioCandidatoDb = _usuarioCandidatoAlunoRepository.Create(usuarioCandidato);
// Cria o perfil do usuarioCandidato (linkExterno e SobreOCandidato vazios)
PerfilUsuarioCandidatoAluno perfilCandidato = null;
try
{
perfilCandidato = new PerfilUsuarioCandidatoAluno("", "", usuarioCandidatoDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o perfil padrão do candidato."));
}
_usuarioCandidatoAlunoRepository.CreatePerfilUsuarioCandidatoAluno(perfilCandidato);
// Altera para validação Inativa (para não registrar dois usuários candidatos iguais)
validacaoUsuario.AlterarParaInativo();
_validacaoUsuarioCandidatoRepository.UpdateValidacaoUsuarioCandidato(validacaoUsuario);
await _usuarioCandidatoAlunoRepository.UnitOfWork.SaveDbChanges();
return(StatusCode(200, $"Usuário [{alunoDb.Email}] com perfil de {tipoCandidatoDb.Descricao} criado com sucesso!"));
}
public async Task <IActionResult> CriarUsuarioEmpresa(CriarUsuarioEmpresaInput input)
{
if (!ValidatorUtil.CnpjIsValid(input.Cnpj))
{
return(StatusCode(400, "CNPJ Inválido."));
}
var usuarioDb = _usuarioRepository.GetUsuarioByEmail(input.Email);
// Verifica se já existe um usuário com mesmo email cadastrado no sistema
if (usuarioDb != null)
{
return(StatusCode(400, $"Já existe um usuário com email [{input.Email}] no sistema."));
}
// Verifica se existe um aluno cadastrado com mesmo email
var alunoDb = _alunoRepository.BuscarPorEmail(input.Email);
if (alunoDb != null)
{
return(StatusCode(400, $"Já existe um aluno cadastrado com email [{input.Email}] no sistema."));
}
var empresaDb = _empresaRepository.GetByCNPJ(input.Cnpj);
if (empresaDb == null)
{
#region Verifica se já existe uma empresa com o mesmo CNPJ cadastrada no sistema
var responseReceita = await apiRequestService.ReceitaWS(input.Cnpj);
if (responseReceita == null)
{
return(StatusCode(400, "Ocorreu um erro na busca do CNPJ da Empresa, tente novamente mais tarde."));
}
if (responseReceita.Status.Equals("ERROR") || responseReceita.Status.Equals("CNPJ inválido") || !responseReceita.Status.Equals("OK"))
{
return(StatusCode(400, $"{responseReceita.Message}"));
}
#region Cadastra/Busca endereços e vincula-os
TipoEmpresa tipoEmpresa = null;
if (responseReceita.TipoEmpresa.ToUpper() == TipoEmpresaDefaultValuesAccess.GetValue(TipoEmpresaDefaultValues.FILIAL))
{
tipoEmpresa = _tipoEmpresaRepository.GetByDescricao(TipoEmpresaDefaultValuesAccess.GetValue(TipoEmpresaDefaultValues.FILIAL));
}
if (responseReceita.TipoEmpresa.ToUpper() == TipoEmpresaDefaultValuesAccess.GetValue(TipoEmpresaDefaultValues.MATRIZ))
{
tipoEmpresa = _tipoEmpresaRepository.GetByDescricao(TipoEmpresaDefaultValuesAccess.GetValue(TipoEmpresaDefaultValues.MATRIZ));
}
if (tipoEmpresa == null)
{
return(StatusCode(400, "Houve um erro ao adquirir o tipo da empresa."));
}
var responseViaCep = await apiRequestService.ViaCEP(FormatStringUtil.CaracterClear(responseReceita.CEP));
if (responseViaCep == null)
{
return(StatusCode(400, "Ocorreu um erro na busca do endereço da Empresa, tente novamente mais tarde."));
}
var UfSiglaDb = _enderecoRepository.GetUfSiglaBySigla(responseViaCep.UfSigla);
if (UfSiglaDb == null)
{
return(StatusCode(400, "Não existe UF's necessárias cadastradas no banco de dados, não é possível prosseguir com o cadastro da empresa."));
}
var municipioDb = _enderecoRepository.GetMunicipioByDescricao(responseViaCep.Localidade);
// Cria um novo município caso não encontre já criado no banco de dados.
if (municipioDb == null)
{
try
{
municipioDb = new Municipio(responseViaCep.Localidade, UfSiglaDb.Id);
municipioDb = _enderecoRepository.CreateMunicipio(municipioDb);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar um novo município no banco de dados para a Empresa."));
}
}
// Verifica quais campos que não estão vazios para criar o endereço
string logradouroPreenchido = string.IsNullOrEmpty(responseViaCep.Logradouro) == false ? responseViaCep.Logradouro : responseReceita.Logradouro;
string bairroPreenchido = string.IsNullOrEmpty(responseViaCep.Bairro) == false ? responseViaCep.Bairro : responseReceita.Bairro;
// Cria novo endereço para a Empresa
Endereco endereco = null;
try
{
endereco = new Endereco(responseViaCep.Cep, bairroPreenchido, logradouroPreenchido, responseReceita.Numero, municipioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno criar um endereço para a Empresa."));
}
var enderecoDb = _enderecoRepository.Create(endereco);
#endregion
// Verifica se fantasia esta nula e substitui por nome, caso contrário, mantem fantasia
string nomeEmpresa = string.IsNullOrEmpty(responseReceita.Fantasia) ? responseReceita.Nome : responseReceita.Fantasia;
// Cria Empresa
empresaDb = null;
try
{
empresaDb = new Empresa(input.Cnpj, nomeEmpresa, enderecoDb.Id, tipoEmpresa.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar uma Empresa."));
}
// Cria Empresa no BD
empresaDb = _empresaRepository.Create(empresaDb);
#region Registra todos os TiposCnaes (Atividade Principal e Atividade Secundária)
// Default Values Atividade principal e secundária
var AtividadePrincipalDb = _tipoAtividadeCnaeRepository.GetByDescricao(TipoAtividadeCnaeDefaultValuesAccess.GetValue(TipoAtividadeCnaeDefaultValues.AtividadePrincipal));
var AtividadeSecundariaDb = _tipoAtividadeCnaeRepository.GetByDescricao(TipoAtividadeCnaeDefaultValuesAccess.GetValue(TipoAtividadeCnaeDefaultValues.AtividadeSecundaria));
// Atividade Principal
TipoCnae tipoCnaeDb = null;
if (responseReceita.AtividadePrincipal.Any())
{
foreach (var ap in responseReceita.AtividadePrincipal)
{
tipoCnaeDb = _empresaRepository.GetTipoCnaeByCodigo(ap.Code);
if (tipoCnaeDb == null)
{
try
{
tipoCnaeDb = new TipoCnae(ap.Text, ap.Code);
tipoCnaeDb = _empresaRepository.CreateTipoCnae(tipoCnaeDb);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar a Atividade Principal da Empresa, tente novamente mais tarde."));
}
}
AtividadeCnae atividadeCnae = null;
try
{
atividadeCnae = new AtividadeCnae(tipoCnaeDb.Id, AtividadePrincipalDb.Id, empresaDb.Id);
_empresaRepository.CreateAtividadeCnae(atividadeCnae);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao vincular o CNAE à Empresa, tente novamente mais tarde."));
}
}
}
// Atividades Secundárias
if (responseReceita.AtividadeSecundaria.Any())
{
foreach (var ats in responseReceita.AtividadeSecundaria)
{
tipoCnaeDb = _empresaRepository.GetTipoCnaeByCodigo(ats.Code);
if (tipoCnaeDb == null)
{
try
{
tipoCnaeDb = new TipoCnae(ats.Text, ats.Code);
tipoCnaeDb = _empresaRepository.CreateTipoCnae(tipoCnaeDb);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar alguma Atividade Secundária da Empresa, tente novamente mais tarde."));
}
}
AtividadeCnae atividadeCnae = null;
try
{
atividadeCnae = new AtividadeCnae(tipoCnaeDb.Id, AtividadeSecundariaDb.Id, empresaDb.Id);
_empresaRepository.CreateAtividadeCnae(atividadeCnae);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao vincular o CNAE à Empresa, tente novamente mais tarde."));
}
}
}
#endregion
// Registra todos da lista de QSA
if (responseReceita.QSA.Any())
{
foreach (var qsa in responseReceita.QSA)
{
QSA qsaDb = null;
try
{
qsaDb = new QSA(qsa.Nome, qsa.Qual, empresaDb.Id);
_empresaRepository.CreateQSA(qsaDb);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o QSA da Empresa."));
}
}
}
#endregion
}
else
{
#region Caso empresa já exista
var usuarioEmpresaDb = _usuarioEmpresaRepository.GetByEmpresaId(empresaDb.Id);
// Verifica se já existe um usuário vinculado à empresa
if (usuarioEmpresaDb != null)
{
return(StatusCode(400, $"A Empresa de CNPJ [{input.Cnpj}] já está vinculada à um usuário."));
}
#endregion
}
var tipoEmpresaDb = _tipoUsuarioRepository.GetByDescricao(TipoUsuarioDefaultValuesAccess.GetValue(TipoUsuarioDefaultValues.Empresa));
var statusUsuarioDb = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaAtiva));
// Criação do usuário
usuarioDb = null;
try
{
// Gera Hash da senha
var senhaHash = new PasswordHasher <Usuario>().HashPassword(usuarioDb, input.Senha);
usuarioDb = new Usuario(input.Nome, input.Email, senhaHash, tipoEmpresaDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o Usuário."));
}
usuarioDb = _usuarioRepository.Create(usuarioDb);
// Cria o 1° histórico do usuário
HistoricoStatusUsuario historicoUsuario = null;
try
{
historicoUsuario = new HistoricoStatusUsuario(statusUsuarioDb.Id, usuarioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o histórico do usuário."));
}
_historicoStatusUsuarioRepository.Create(historicoUsuario);
// Criação do UsuarioEmpresa, vincula o usuário à empresa criada
UsuarioEmpresa usuarioEmpresa = null;
try
{
usuarioEmpresa = new UsuarioEmpresa(empresaDb.Id, usuarioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o UsuarioEmpresa (vincular o usuário à empresa)."));
}
_usuarioEmpresaRepository.Create(usuarioEmpresa);
await _usuarioRepository.UnitOfWork.SaveDbChanges();
return(StatusCode(200, $"Usuário {usuarioDb.Email} com perfil de Empresa com CNPJ {empresaDb.CNPJ} criado com sucesso!"));
}
public async Task <IActionResult> PutDesativarUsuario(string email, long usuarioId)
{
// Busca o adm pelo usuarioId
var admDb = _usuarioRepository.GetById(usuarioId);
// Caso não encontre
if (admDb == null)
{
return(StatusCode(404, $"Este usuário de id [{usuarioId}] não existe."));
}
// Busca o vinculo entre Usuario X Administrador
var usuarioAdm = _usuarioAdministradorRepository.GetByUsuarioId(admDb.Id);
// Caso não encontre, não é um perfil de administrador
if (usuarioAdm == null)
{
return(StatusCode(401, "Este usuário não tem um perfil de administrador para desativar um usuário."));
}
// Busca um usuário por email
var usuarioBuscado = _usuarioRepository.GetUsuarioByEmail(email);
// Caso não encontre
if (usuarioBuscado == null)
{
return(StatusCode(404, "Usuário não encontrado!"));
}
// Caso o administrador tente desativar seu próprio usuário
if (usuarioBuscado.Email == admDb.Email)
{
return(StatusCode(403, "Você não pode excluir seu próprio usuário."));
}
// Caso o adminisrador tente desativar o usuário padrão da plataforma
if (usuarioBuscado.Email == "*****@*****.**")
{
return(StatusCode(403, "Você não pode excluir o administrador padrão."));
}
// Busca o historico do usuário
var historicoBuscado = _historicoStatusUsuarioRepository.GetHistoricoAtualByUsuarioId(usuarioBuscado.Id);
// Caso não encontre
if (historicoBuscado == null)
{
return(StatusCode(404, "Histórico de Status do usuário não encontrado!"));
}
// Pega o status padrão "Conta Desativado"
var StatusUsuario = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaDesativada));
// Pega o status padrão "Conta ativa"
var StatusUsuarioAtivo = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaAtiva));
// Caso a conta não estja ativa
if (historicoBuscado.StatusUsuarioId != StatusUsuarioAtivo.Id)
{
return(StatusCode(404, "Este usuário ja está desativado!"));
}
// Altera o atual para antigo e cria o novo historico
HistoricoStatusUsuario historicoStatusUsuario = null;
try
{
historicoBuscado.AlterarParaAntigo();
_historicoStatusUsuarioRepository.PutAlterarHistorico(historicoBuscado);
historicoStatusUsuario = new HistoricoStatusUsuario(StatusUsuario.Id, usuarioBuscado.Id);
_historicoStatusUsuarioRepository.Create(historicoStatusUsuario);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o histórico"));
}
// Salva alterações no BD
await _historicoStatusUsuarioRepository.UnitOfWork.SaveDbChanges();
return(StatusCode(200, "Usuário desativado!"));
}
public IActionResult AdminGetAllEmpresas()
{
List <EmpresaViewModel> empresas = new List <EmpresaViewModel>();
try
{
empresas = _empresasQueries.GetAllEmpresas();
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao buscar todas as empresas cadastradas na plataforma."));
}
// Itera entre todas as empresas
foreach (var empresa in empresas.ToList())
{
try
{
// Busca o usuarioEmpresa por ID
var usuarioEmpresa = _usuarioEmpresaRepository.GetByEmpresaId(empresa.Id);
// Busca usuário por Id
var usuarioDb = _usuarioRepository.GetById(usuarioEmpresa.UsuarioId);
// Caso não existir
if (usuarioDb == null)
{
return(StatusCode(404, $"Este Id de usuário [{usuarioEmpresa.UsuarioId}] não existe."));
}
// Busca o histórico do usuário por ID
var historicoUsuario = _historicoStatusUsuarioRepository.GetHistoricoAtualByUsuarioId(usuarioDb.Id);
// Caso historico do usuário não exista
if (historicoUsuario == null)
{
return(StatusCode(404, $"Não foi encontrado um histórico de usuário da empresa [{empresa.Id}]"));
}
// Busca o statusUsuario "Conta Excluída"
var statusUsuarioExcluidoDb = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaExcluida));
// Caso a conta da empresa esteja com status EXCLUÍDA, remove a empresa específica da lista
if (historicoUsuario.StatusUsuarioId == statusUsuarioExcluidoDb.Id)
{
empresas.Remove(empresa);
}
else
{
// Caso estiver ATIVA ou DESATIVADA, pode ser visualizada e vincula email do usuário com a empresa
empresa.AcrescentarEmailUsuario(usuarioDb.Email);
}
}
catch (Exception)
{
return(StatusCode(500, "Houve algum erro interno ao verificar o histórico de status usuários das empresas."));
}
}
return(StatusCode(200, empresas));
}
public IActionResult AdminGetAllInformacoesCandidatoByCandidatoId(long usuarioCandidatoId)
{
try
{
// Busca usuarioCandidato por Id
var usuarioCandidatoDb = _usuarioCandidatoAlunoRepository.GetById(usuarioCandidatoId);
// Caso não encontrar
if (usuarioCandidatoDb == null)
{
return(StatusCode(400, "Este usuário não é um candidato."));
}
// Busca aluno específico
var aluno = _usuarioQueries.GetInformacoesPerfilAlunoByAlunoId(usuarioCandidatoDb.AlunoId);
// Caso não encontre
if (aluno == null)
{
return(StatusCode(404, "Este aluno não existe."));
}
// Verifica se usuário ainda não foi cadastrado (só mostra infos do aluno), ou se usuário foi excluído
if (usuarioCandidatoDb != null)
{
var historicoUsuario = _historicoStatusUsuarioRepository.GetHistoricoAtualByUsuarioId(usuarioCandidatoDb.UsuarioId);
var statusUsuarioExcluidoDb = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaExcluida));
if (historicoUsuario.StatusUsuarioId == statusUsuarioExcluidoDb.Id)
{
aluno.PerfilCandidato.SobreOCandidato = "USUÁRIO EXCLUÍDO.";
}
}
else
{
aluno.PerfilCandidato.SobreOCandidato = "USUÁRIO NÃO CADASTRADO.";
}
return(StatusCode(200, aluno));
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao tentar retornar as informações de um candidato específico."));
}
}
public IActionResult Post(LoginInput login)
{
try
{
Usuario usuarioBuscado = _usuarioRepository.GetUsuarioByEmail(login.Email);
PasswordVerificationResult validacaoSenha = PasswordVerificationResult.Failed;
if (usuarioBuscado != null)
{
validacaoSenha = new PasswordHasher <Usuario>().VerifyHashedPassword(usuarioBuscado, usuarioBuscado.Senha, login.Senha);
}
if (usuarioBuscado == null || validacaoSenha == PasswordVerificationResult.Failed)
{
return(NotFound("Email e/ou senha inválidos."));
}
// Busca o historicoStatusUsuario pelo ID do usuário
HistoricoStatusUsuario historicoStatus = _historicoStatusUsuarioRepository.GetHistoricoAtualByUsuarioId(usuarioBuscado.Id);
if (historicoStatus == null)
{
return(StatusCode(404, "Não foi encontrado um histórico de status desse usuário."));
}
// Busca o status "Conta Ativa"
var statusUsuarioAtivoDb = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaAtiva));
// Busca o status do usuário buscado
var statusUsuarioBuscado = _statusUsuarioRepository.GetById(historicoStatus.StatusUsuarioId);
// O historicoStatus do usuário buscado é igual à conta ATIVA? Caso NÃO, retorna erro que o usuário não é mais autorizado a logar no site.
if (historicoStatus.StatusUsuarioId != statusUsuarioAtivoDb.Id)
{
return(Unauthorized($"O usuário [{usuarioBuscado.Email}] está com a {statusUsuarioBuscado.Descricao}."));
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, usuarioBuscado.Email),
new Claim(JwtRegisteredClaimNames.Jti, usuarioBuscado.Id.ToString()),
new Claim(ClaimTypes.Role, usuarioBuscado.TipoUsuarioId.ToString()),
new Claim("role", usuarioBuscado.TipoUsuarioId.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, usuarioBuscado.Nome)
};
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("senaivagas-chave-autenticacao"));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "Senai.Vagas.Backend",
audience: "Senai.Vagas.Backend",
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds
);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
catch (Exception error)
{
// Retorna a resposta da requisição 400 - Bad Request e o erro ocorrido com uma mensagem
return(StatusCode(500, $"Houve um erro interno ao gerar o Token de usuário | [{error.Message}]"));
}
}