public async Task <RespostaApi> Executar(SolicitarReiniciarSenhaDto solicitarReiniciarSenhaDto)
{
if (ValidacaoCpf.Valida(solicitarReiniciarSenhaDto.Cpf) == false)
{
throw new NegocioException($"CPF inválido!");
}
var usuarioCoreSSO = await mediator.Send(new ObterUsuarioCoreSSOQuery(solicitarReiniciarSenhaDto.Cpf));
await mediator.Send(new ObterDadosAlunosQuery(solicitarReiniciarSenhaDto.Cpf));
var usuario = await mediator.Send(new ObterUsuarioPorCpfQuery(solicitarReiniciarSenhaDto.Cpf));
if (usuario == null && usuarioCoreSSO != null)
{
throw new NegocioException($"O usuário {Formatacao.FormatarCpf(solicitarReiniciarSenhaDto.Cpf)} deverá informar a data de nascimento de um dos estudantes que é responsável no campo de senha!");
}
var usuarioEol = await mediator.Send(new ObterDadosResumidosReponsavelPorCpfQuery(solicitarReiniciarSenhaDto.Cpf));
if (usuario.PrimeiroAcesso == true)
{
throw new NegocioException($"O usuário {Formatacao.FormatarCpf(solicitarReiniciarSenhaDto.Cpf)} - {usuarioEol.Nome} deverá informar a data de nascimento de um dos estudantes que é responsável no campo de senha!");
}
await mediator.Send(new ReiniciarSenhaCommand()
{
Id = usuario.Id, PrimeiroAcesso = true
});
var mensagemSucesso = $"A senha do usuário {Formatacao.FormatarCpf(usuario.Cpf)} - {usuarioEol.Nome} foi reiniciada com sucesso. No próximo acesso ao aplicativo o usuário deverá informar a data de nascimento de um dos estudantes que é responsável!";
return(RespostaApi.Sucesso(mensagemSucesso));
}
public async Task <UsuarioDto> Executar(string codigoDre, long codigoUe, string cpf)
{
if (ValidacaoCpf.Valida(cpf) == false)
{
throw new NegocioException($"CPF inválido!");
}
var usuarioCoreSSO = await mediator.Send(new ObterUsuarioCoreSSOQuery(cpf));
await mediator.Send(new ObterDadosAlunosPorDreUeCpfResponsavelQuery(codigoDre, codigoUe, cpf));
var usuarioApp = await mediator.Send(new ObterUsuarioNaoExcluidoPorCpfQuery(cpf));
var usuarioEol = await mediator.Send(new ObterDadosResumidosReponsavelPorCpfQuery(cpf));
if (usuarioCoreSSO == null)
{
throw new NegocioException($"Este CPF não consta como responsável de um estudante ativo nesta Unidade Escolar.");
}
if (usuarioApp == null && usuarioCoreSSO != null)
{
throw new NegocioException($"O usuário {Formatacao.FormatarCpf(cpf)} deverá informar a data de nascimento de um dos estudantes que é responsável no campo de senha!");
}
return(new UsuarioDto(usuarioApp.Cpf, usuarioEol.Nome));
}
private async Task <IEnumerable <ResponsavelAlunoEOLDto> > ObterUsuariosAlunos()
{
var usuariosComApp =
(await ObterUsuariosAlunosNotificacoesApp())
.Select(usuario => usuario.CpfResponsavel)
.Distinct()
.OrderBy(u => u)
.ToArray();
var responsaveisEOL =
(await responsavelEOLRepositorio.ListarCpfResponsavelAlunoDaDreUeTurma())
.AsParallel()
.Where(resp => ValidacaoCpf.Valida(resp.CpfResponsavel.ToString("00000000000")))
.Select(usuarioAluno =>
{
usuarioAluno
.TemAppInstalado =
Array
.BinarySearch(usuariosComApp, usuarioAluno.CpfResponsavel) >= 0;
return(usuarioAluno);
})
.ToArray();
return(responsaveisEOL);
}
private DashboardAdesaoDto ProcessaResponsavel(ResponsavelEOLDto responsavel, IEnumerable <Dominio.Entidades.Usuario> usuariosDoSistema, List <DashboardAdesaoUnificacaoDto> listaCpfsUnificados)
{
if (responsavel.CpfResponsavel == 0 || !listaCpfsUnificados.Any(a => a.CPF == responsavel.CpfResponsavel))
{
var cpf = responsavel.CpfResponsavel.ToString("00000000000");
var cpfValido = ValidacaoCpf.Valida(cpf);
var usuarios_primeiro_acesso_incompleto = 0;
var usuarios_validos = 0;
var usuarios_cpf_invalidos = 0;
var usuarios_sem_app_instalado = 0;
if (cpfValido)
{
var usuarioDoSistema = usuariosDoSistema.FirstOrDefault(a => a.Cpf == cpf);
if (usuarioDoSistema == null)
{
usuarios_sem_app_instalado = 1;
}
else
{
usuarios_primeiro_acesso_incompleto = usuarioDoSistema.PrimeiroAcesso ? 1 : 0;
usuarios_validos = !usuarioDoSistema.PrimeiroAcesso ? 1 : 0;
}
}
else
{
usuarios_cpf_invalidos = 1;
}
var dashboard_adesao = new DashboardAdesaoDto
{
dre_codigo = responsavel.CodigoDre,
dre_nome = responsavel.Dre,
ue_codigo = responsavel.CodigoUe,
ue_nome = responsavel.Ue,
codigo_turma = responsavel.CodigoTurma,
usuarios_primeiro_acesso_incompleto = usuarios_primeiro_acesso_incompleto,
usuarios_validos = usuarios_validos,
usuarios_cpf_invalidos = usuarios_cpf_invalidos,
usuarios_sem_app_instalado = usuarios_sem_app_instalado
};
listaDeCpfsUtilizados.Add(new DashboardAdesaoUnificacaoDto()
{
CPF = long.Parse(cpf),
DreCodigo = responsavel.CodigoDre,
PrimeiroAcessoIncompleto = usuarios_primeiro_acesso_incompleto,
TurmaCodigo = responsavel.CodigoTurma,
UeCodigo = responsavel.CodigoUe,
UsuarioCpfInvalido = usuarios_cpf_invalidos,
UsuarioSemAppInstalado = usuarios_sem_app_instalado,
UsuarioValido = usuarios_validos
});
return(dashboard_adesao);
}
return(null);
}
public void FuncaoValidaCpf_Erro(string cpf)
{
//Arrange
//Act
//Assert
Assert.False(ValidacaoCpf.ValidaCPF(cpf));
}
public void FuncaoValidaCpf_ok(string cpf)
{
//Arrange
//Act
//Assert
Assert.True(ValidacaoCpf.ValidaCPF(cpf));
}
/// <summary>
/// Validação server
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public override bool IsValid(object value)
{
if (value == null || string.IsNullOrEmpty(value.ToString()))
{
return(true);
}
bool valido = ValidacaoCpf.ValidaCPF(value.ToString());
return(valido);
}
public FornecedorValidation()
{
RuleFor(f => f.Nome)
.NotEmpty().WithMessage("O campo {PropertyName} precisa ser fornecido")
.Length(2, 100).WithMessage(("O campo {PropertyName} precisa ter entre {MinLength} e {MaxLength} caracteres"));
When(f => f.TipoFornecedor == TipoFornecedor.PessoaFisica, () =>
{
RuleFor(f => f.Documento.Length).Equal(ValidacaoCpf.TamanhoCpf)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => ValidacaoCpf.Validar(f.Documento)).Equal(true)
.WithMessage("O campo Documento fornecido é inválido.");
});
When(f => f.TipoFornecedor == TipoFornecedor.PessoaJuridica, () =>
{
RuleFor(f => f.Documento.Length).Equal(ValidacaoCnpf.TamanhoCNPJ)
.WithMessage("O campo Documento precisa ter {ComparisonValue} caracteres e foi fornecido {PropertyValue}.");
RuleFor(f => ValidacaoCnpf.Validar(f.Documento)).Equal(true)
.WithMessage("O campo Documento fornecido é inválido.");
});
}
/// <summary>
/// Verifica se o CPF, o CRM e o email já não estão cadastrados, se o CPF é válido, se existem campos obrigatórios
/// que não estão preenchidos, se os campos respeitam os limites de caracteres especificados no Database e se o
/// médico é maior de idade. Antes de alterar os dados sobre um médico.
/// </summary>
/// <param name="id">Usado para buscar o médico no Database.</param>
/// <param name="entity">Objeto com as informações a serem alteradas.</param>
/// <returns>Seleciona um médico do Database ou gera alguma exceção.</returns>
public Medico Alterar(int id, Medico entity)
{
Medico obj;
//Verifica se existem campos vazios.
if (CamposVazios.Verificar(entity))
{
throw new DadoInvalidoException("Existem campos obrigatórios que não foram preenchidos!");
}
//Verifica se nenhum campo do objeto entity excede o limite de caracteres estipulado no Database.
if (ExcedeLimiteDeCaracteres.Verificar(entity))
{
throw new DadoInvalidoException("Existem campos que excedem o limite de caracteres permitidos!");
}
//Converte o gênero para caixa alta e verifica se o gênero é válido.
if (GeneroValido.Verificar(GeneroValido.CaixaAlta(entity.Genero)) == false)
{
throw new DadoInvalidoException($"O gênero: \"{entity.Genero}\", é inválido!");
}
//Verifica se o formato e a quantidade de caracteres do celular são válidos.
if (TelefoneValido.Verificar(TelefoneValido.LimparFormatacao(entity.Celular)) == false)
{
throw new DadoInvalidoException($"O número de celular:\"{entity.Celular}\" é inválido!");
}
//Verifica se o CRM já não foi cadastrado.
obj = _medicoRepositorio.SelecionarPorCrm(entity.Crm);
if (obj != null && obj.Id != id)
{
throw new ConflitoException($"O CRM: \"{entity.Crm}\", já foi cadastrado!");
}
//Verifica se o CPF é válido e se ele já foi cadastrado.
if (ValidacaoCpf.Verificar(entity.Cpf) == false)
{
throw new DadoInvalidoException($"O CPF: \"{entity.Cpf}\" é invalido!");
}
else
{
obj = _medicoRepositorio.SelecionarPorCpf(entity.Cpf);
if (obj != null && obj.Id != id)
{
throw new ConflitoException($"O CPF: \"{entity.Cpf}\", já foi cadastrado!");
}
else if (_pacienteRepositorio.SelecionarPorCpf(entity.Cpf) != null)
{
throw new ConflitoException($"O CPF: \"{entity.Cpf}\", já foi cadastrado!");
}
}
//Verifica se o email já foi casatrado.
obj = _medicoRepositorio.SelecionarPorEmail(entity.Email);
if (obj != null && id != obj.Id)
{
throw new ConflitoException($"O email: \"{entity.Email}\", já foi cadastrado!");
}
//Verifica se o médico é maior de idade.
if (Maioridade.Verificar(entity.DataNasc) == false)
{
throw new DadoInvalidoException("Idade inválida - Apenas maiores de 18 anos podem se cadastrar");
}
entity.Id = id;
_medicoRepositorio.Alterar(entity);
return(_medicoRepositorio.SelecionarPorId(id));
}
