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 <RespostaApi> Executar(NovaSenhaDto novaSenhaDto)
{
var usuario = await mediator.Send(new ObterUsuarioQuery()
{
Id = novaSenhaDto.Id
});
if (usuario == null)
{
throw new NegocioException("Usuário não encontrado");
}
if (!usuario.PrimeiroAcesso)
{
throw new NegocioException("Somente é possivel utilizar essa função quando for o primeiro acesso do usuário");
}
var usuarioCoreSSO = await mediator.Send(new ObterUsuarioCoreSSOQuery(usuario.Cpf));
await CriarUsuarioOuAssociarGrupo(mediator, novaSenhaDto, usuario, usuarioCoreSSO);
var atualizarPrimeiroAcesso = MapearAtualizarPrimeiroAcessoCommand(usuario);
await mediator.Send(atualizarPrimeiroAcesso);
await IncluirSenhaHistorico(usuario.Cpf);
return(RespostaApi.Sucesso());
}
public static async Task <RespostaApi> Executar(IMediator mediator, string cpf, string dispositivoId)
{
var respostaApi = new RespostaApi();
respostaApi.Ok = await mediator.Send(new RemoveUsuarioDispositivoCommand(cpf, dispositivoId));
return(respostaApi);
}
public static RespostaApi RetornaBaseModel(ModelStateDictionary modelState)
{
return(RespostaApi.Falha(modelState.Keys
.SelectMany(key => modelState[key].Errors.Select(x => new string(x.ErrorMessage)))
.ToArray()));
;
}
public async Task <RespostaApi> Executar(ValidarTokenDto validarTokenDto)
{
var usuario = await mediator.Send(new ObterUsuarioPorTokenRedefinicaoQuery(validarTokenDto.Token.ToUpper()));
usuario.ValidarTokenRedefinicao(validarTokenDto.Token.ToUpper());
return(RespostaApi.Sucesso());
}
public async Task <NotificacaoResposta> Executar(IMediator mediator, UsuarioNotificacaoDto usuarioMensagem, string cpfUsuario)
{
RespostaApi resposta = await mediator.Send(new DadosAlunoCommand(cpfUsuario));
if (resposta.Data == null)
{
throw new NegocioException("Não foi possivel obter os alunos por escola");
}
var listaEscolas = (IEnumerable <ListaEscola>)resposta.Data;
var notificacao = await mediator.Send(new ObterNotificacaoPorIdQuery(usuarioMensagem.NotificacaoId));
if (notificacao == null)
{
throw new NegocioException("Não foi possivel localizar a notificação.");
}
switch (notificacao.TipoComunicado)
{
case TipoComunicado.SME:
await ConfirmarLeituraSME(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);
break;
case TipoComunicado.DRE:
await ConfirmarLeituraDRE(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);
break;
case TipoComunicado.UE:
await ConfirmarLeituraUE(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);
break;
case TipoComunicado.UEMOD:
await ConfirmarLeituraUEMOD(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);
break;
case TipoComunicado.TURMA:
await ConfirmarLeituraTurma(mediator, usuarioMensagem, cpfUsuario, listaEscolas, notificacao);
break;
case TipoComunicado.ALUNO:
await ConfirmarLeituraAlunoEspecifico(mediator, usuarioMensagem, cpfUsuario, listaEscolas);
break;
default:
throw new NegocioException("Não identificado o Tipo desta notificação");
}
;
notificacao.MensagemVisualizada = usuarioMensagem.MensagemVisualizada;
return(notificacao);
}
private static ResultadoBaseResult TratarValidacaoException(ValidacaoException validacaoException)
{
if (!validacaoException.Errors.Any())
{
return(new ResultadoBaseResult(validacaoException.Message));
}
return(new ResultadoBaseResult(RespostaApi.Falha(validacaoException.Errors)));
}
private RespostaApi MapearResposta(Usuario usuarioApp)
{
RespostaAutenticar usuario = new RespostaAutenticar
{
Cpf = usuarioApp.Cpf,
Id = usuarioApp.Id,
UltimaAtualizacao = usuarioApp.AlteradoEm
};
return(RespostaApi.Sucesso(usuario));
}
public async Task <RespostaApi> Executar(string cpf)
{
RespostaApi resposta = await mediator.Send(new DadosAlunoCommand(cpf));
if (!resposta.Ok)
{
throw new NegocioException(string.Join(',', resposta.Erros));
}
return(resposta);
}
public async Task <RespostaApi> Executar(AlterarSenhaDto alterarSenhaDto, string senhaAntiga)
{
await ValidarDto(alterarSenhaDto);
var usuario = await ObterUsuarioCoreSSO(alterarSenhaDto);
usuario.ValidarSenhaAlterarSenha(usuario.ObterSenhaCriptografada(senhaAntiga));
usuario.AlterarSenha(alterarSenhaDto.Senha);
await Validar5UltimasSenhas(usuario);
await AlterarSenhaUsuarioCoreSSO(usuario);
await IncluirSenhaHistorico(usuario);
return(RespostaApi.Sucesso());
}
public async Task <RespostaApi> Executar(long[] id)
{
RespostaApi resposta = new RespostaApi();
var removeuNotificaoUsuarios = await mediator.Send(new RemoverNotificacaoUsuarioCommand(id));
if (!removeuNotificaoUsuarios)
{
resposta.Erros.SetValue($"Erro ao excluir Registros de leitura", 0);
return(resposta);
}
resposta.Erros = await mediator.Send(new RemoverNotificacaoCommand(id));
resposta.Ok = resposta.Erros?[0] == null;
return(resposta);
}
public async Task <RespostaApi> Executar(AlterarSenhaDto alterarSenhaDto, string senhaAntiga)
{
await ValidarDto(alterarSenhaDto);
var usuario = await ObterUsuarioCoreSSO(alterarSenhaDto);
usuario.ValidarSenhaAlterarSenha(usuario.ObterSenhaCriptografada(senhaAntiga));
usuario.AlterarSenha(alterarSenhaDto.Senha);
await Validar5UltimasSenhas(usuario);
await AlterarSenhaUsuarioCoreSSO(usuario);
await IncluirSenhaHistorico(usuario);
var token = await mediator.Send(new CriarTokenCommand(usuario.Cpf));
return(RespostaApi.Sucesso(new RetornoToken(token)));
}
public async Task <RespostaApi> Executar(GerarTokenDto gerarTokenDto)
{
var usuario = await ObterUsuario(gerarTokenDto);
var usuarioCoreSSO = await ObterUsuarioCoreSSO(gerarTokenDto);
await mediator.Send(new ValidarAlunoInativoRestritoCommand(usuarioCoreSSO));
usuario.IniciarRedefinicaoSenha();
if (string.IsNullOrEmpty(usuario.Email))
{
throw new NegocioException("Usuário não possui e-mail cadastrado");
}
await EnvioEmail(usuario);
await mediator.Send(new SalvarUsuarioCommand(usuario));
return(RespostaApi.Sucesso(usuario.Email));
}
public async Task <IEnumerable <NotificacaoResposta> > Executar(string cpf, long codigoAluno, DateTime dataUltimaConsulta)
{
var usuario = await mediator.Send(new ObterUsuarioQuery(cpf));
if (usuario == null)
{
throw new NegocioException($"Não encontrado usuário com o CPF {cpf}");
}
RespostaApi resposta = await mediator.Send(new DadosAlunoCommand(cpf));
if (resposta.Data == null)
{
throw new NegocioException("Não foi possivel obter os alunos por escola");
}
var listaEscolas = (IEnumerable <ListaEscola>)resposta.Data;
var aluno = listaEscolas.FirstOrDefault(
x => x.Alunos.Any(z => z.CodigoEol == codigoAluno)).Alunos.FirstOrDefault(x => x.CodigoEol == codigoAluno);
if (aluno == null)
{
throw new NegocioException($"Não encontrado usuário com o codigo {codigoAluno}");
}
var modalidades = listaEscolas.Where(x => x.Alunos.Any(z => z.CodigoEol == aluno.CodigoEol)).Select(x => x.ModalidadeCodigo);
return(await mediator.Send(new MensagensUsuarioLogadoAlunoQuery
{
CodigoAluno = aluno.CodigoEol.ToString(),
CodigoDRE = aluno.CodigoDre,
CodigoTurma = aluno.CodigoTurma.ToString(),
CodigoUE = aluno.CodigoEscola,
CodigoUsuario = usuario.Id,
ModalidadesId = string.Join(',', modalidades),
DataUltimaConsulta = dataUltimaConsulta,
SerieResumida = aluno.SerieResumida
}));
}
public async Task <RespostaApi> Executar(AtualizarDadosUsuarioDto usuarioDto)
{
var usuarioApp = await mediator.Send(new ObterUsuarioQuery(usuarioDto.Id));
bool podePersistirTexto = await PodePersistirTexto(usuarioDto);
if (!podePersistirTexto)
{
return(RespostaApi.Falha("Conteúdo inadequado nos campos de cadastro, por favor revise e tente novamente."));
}
var usuarioEol = await mediator.Send(new ObterDadosResumidosReponsavelPorCpfQuery(usuarioApp.Cpf));
if (usuarioEol == null)
{
return(RespostaApi.Falha("Usuário não encontrado!"));
}
await AtualizaUsuario(usuarioApp, usuarioDto);
return(MapearResposta(usuarioApp));
}
// Função responsável por cadastrar um novo Cliente
public RespostaApi CadastraCliente(
string nome,
string cpf,
string telefone,
string email,
string senha
)
{
// Envia a requisição para cadastraCliente
var json = EnviaRequisicao("/cadastraCliente",
"nome=" + nome +
"&cpf=" + cpf +
"&telefone=" + telefone +
"&email=" + email +
"&senha=" + senha
);
// Formata o Json
RespostaApi result = JsonConvert.DeserializeObject <RespostaApi>(json);
return(result);
}
public static RespostaApi RetornaBaseModel(string mensagem)
{
return(RespostaApi.Falha(mensagem));
}
public async Task <RespostaApi> Executar(IMediator mediator, AlterarEmailCelularDto alterarEmailCelularDto)
{
await mediator.Send(new AlterarEmailCelularCommand(alterarEmailCelularDto));
return(RespostaApi.Sucesso());
}
public static RespostaApi ParaRespostaApi(this IdentityResult resultado)
{
return(resultado.Succeeded
? RespostaApi.Sucesso()
: RespostaApi.Falha(resultado.Errors.Select(e => e.Description)));
}
public async Task Deve_Autenticar_Usuario()
{
mediator.Setup(a => a.Send(It.IsAny <AutenticarUsuarioCommand>(), It.IsAny <CancellationToken>())).ReturnsAsync(RespostaApi.Sucesso(new RespostaAutenticar()));
mediator.Setup(a => a.Send(It.IsAny <CriarTokenCommand>(), It.IsAny <CancellationToken>())).ReturnsAsync("");
mediator.Setup(a => a.Send(It.IsAny <UsuarioDispositivoCommand>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
var autenticacao = await autenticarUsuarioUseCase.Executar("000.000.000-00", "Ab#123456", "Teste");
Assert.True(autenticacao.Ok);
}
public async Task <RespostaApi> Executar(IMediator mediator)
{
await mediator.Send(new TesteArquiteturaCommand());
return(RespostaApi.Sucesso());
}
public ResultadoBaseResult(RespostaApi retornoBaseDto) : base(retornoBaseDto)
{
StatusCode = 400;
}
