public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
if (mensagemRabbit?.Mensagem is null)
{
throw new NegocioException("Não foi possível processar o curso do usuário GSA. A mensagem enviada é inválida.");
}
var usuarioCursoGsaDto = JsonConvert.DeserializeObject <UsuarioCursoGsaDto>(mensagemRabbit.Mensagem.ToString());
if (usuarioCursoGsaDto is null)
{
throw new NegocioException("Não foi possível processar o curso do usuário GSA. A mensagem enviada é inválida.");
}
var usuarioCursoExiste = await mediator.Send(new ExisteCursoDoUsuarioGsaPorUsuarioIdCursoIdQuery(usuarioCursoGsaDto.UsuarioId, usuarioCursoGsaDto.CursoId.ToString()));
if (usuarioCursoExiste)
{
return(true);
}
var usuarioCursoTipo = Enum.Parse <UsuarioCursoGsaTipo>(usuarioCursoGsaDto.UsuarioCursoTipo.ToString());
var usuarioGsa = new UsuarioCursoGsa(usuarioCursoGsaDto.UsuarioId, usuarioCursoGsaDto.CursoId.ToString(), usuarioCursoTipo);
var retorno = await mediator.Send(new IncluirUsuarioCursoGsaCommand(usuarioGsa));
return(retorno);
}
public async Task <bool> Executar(MensagemRabbit mensagem)
{
var filtro = ObterParametrosFiltro(mensagem);
var ultimaAtualizacao = filtro != null ? new DateTime(filtro.AnoLetivo, 1, 1) : await mediator.Send(new ObterDataUltimaExecucaoPorTipoQuery(ExecucaoTipo.ProfessorAdicionar));
var paginacao = new Paginacao(0, 0);
var parametrosCargaInicialDto = filtro != null ? new ParametrosCargaInicialDto(filtro.TiposUes, filtro.Ues, filtro.Turmas, filtro.AnoLetivo) :
await mediator.Send(new ObterParametrosCargaIncialPorAnoQuery(DateTime.Today.Year));
var professoresParaIncluirGoogle = await mediator.Send(new ObterProfessoresParaIncluirGoogleQuery(ultimaAtualizacao, paginacao, string.Empty, parametrosCargaInicialDto));
foreach (var professorParaIncluirGoogle in professoresParaIncluirGoogle.Items)
{
try
{
var publicarProfessor = await mediator.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaProfessorIncluir, RotasRabbit.FilaProfessorIncluir, professorParaIncluirGoogle));
if (!publicarProfessor)
{
await IncluirProfessorComErroAsync(professorParaIncluirGoogle, ObterMensagemDeErro(professorParaIncluirGoogle.Rf));
}
}
catch (Exception ex)
{
await IncluirProfessorComErroAsync(professorParaIncluirGoogle, ObterMensagemDeErro(professorParaIncluirGoogle.Rf, ex));
}
}
if (professoresParaIncluirGoogle.TotalRegistros > 1)
{
await mediator.Send(new AtualizaExecucaoControleCommand(ExecucaoTipo.ProfessorAdicionar, DateTime.Today));
}
return(true);
}
private async Task Valida_Inclusao_De_Curso_Valido_Deve_Retornar_True()
{
// Arrange
var curso = new CursoEol("Curso teste", "Secao", 10, 10, "01010", "*****@*****.**");
mediator.Setup(a => a.Send(It.IsAny <ExisteCursoPorTurmaComponenteCurricularQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
mediator.Setup(a => a.Send(It.IsAny <InserirCursoGoogleCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
mediator.Setup(a => a.Send(It.IsAny <InserirCursoCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(10);
mediator.Setup(a => a.Send(It.IsAny <PublicaFilaRabbitCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var cursoJson = JsonConvert.SerializeObject(curso);
var mensagem = new MensagemRabbit(cursoJson);
// Act
var retorno = await incluirCursoUseCase.Executar(mensagem);
// Assert
Assert.True(retorno);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
var filtro = ObterFiltro(mensagemRabbit);
var ultimaAtualizacao = filtro != null ? new DateTime(filtro.AnoLetivo, 1, 1) : await mediator.Send(new ObterDataUltimaExecucaoPorTipoQuery(ExecucaoTipo.CursoGradesAdicionar));
var parametrosCargaInicial = filtro != null ? new ParametrosCargaInicialDto(filtro.TiposUes, filtro.Ues, filtro.Turmas, filtro.AnoLetivo) : null;
var paginacao = new Paginacao(0, 0);
var gradesDeCursosAlunos = await mediator.Send(new ObterGradesDeCursosQuery(ultimaAtualizacao, paginacao, parametrosCargaInicial));
foreach (var gradeDeCurso in gradesDeCursosAlunos.Items)
{
var cursoDoAlunoParaIncluir = new CursoEol(gradeDeCurso.Nome, gradeDeCurso.Secao, gradeDeCurso.TurmaId, gradeDeCurso.ComponenteCurricularId, gradeDeCurso.UeCodigo, gradeDeCurso.Email);
try
{
var publicarGradeAlunoCurso = await mediator.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaCursoIncluir, RotasRabbit.FilaCursoIncluir, cursoDoAlunoParaIncluir));
if (!publicarGradeAlunoCurso)
{
await IncluirGradeDeCursoComErroAsync(gradeDeCurso, ObterMensagemDeErro(gradeDeCurso));
}
}
catch (Exception ex)
{
await IncluirGradeDeCursoComErroAsync(gradeDeCurso, ObterMensagemDeErro(gradeDeCurso, ex));
}
}
await mediator.Send(new AtualizaExecucaoControleCommand(ExecucaoTipo.CursoGradesAdicionar, DateTime.Today));
return(true);
}
private async Task Valida_Tratamento_De_Duplicidade_No_Google_Deve_Retornar_True()
{
// Arrange
var funcionario = new FuncionarioEol(123456, "José da Silva", string.Empty, string.Empty);
mediator.Setup(a => a.Send(It.IsAny <ExisteFuncionarioPorRfQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
var googleDuplicidadeException = new GoogleApiException(string.Empty, GoogleApiExceptionMensagens.Erro409EntityAlreadyExists);
googleDuplicidadeException.HttpStatusCode = HttpStatusCode.Conflict;
googleDuplicidadeException.Error = new Google.Apis.Requests.RequestError
{
Code = (int)HttpStatusCode.Conflict,
Message = GoogleApiExceptionMensagens.Erro409EntityAlreadyExists
};
mediator.Setup(a => a.Send(It.IsAny <InserirFuncionarioGoogleCommand>(), It.IsAny <CancellationToken>()))
.Throws(googleDuplicidadeException);
mediator.Setup(a => a.Send(It.IsAny <IncluirUsuarioCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(10);
mediator.Setup(a => a.Send(It.IsAny <PublicaFilaRabbitCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var funcionarioJson = JsonConvert.SerializeObject(funcionario);
var mensagem = new MensagemRabbit(funcionarioJson);
// Act
var retorno = await inserirFuncionarioGoogleUseCase.Executar(mensagem);
// Assert
Assert.True(retorno);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
if (mensagemRabbit?.Mensagem is null)
{
throw new NegocioException("Não foi possível gerar a carga de dados para a inativação usuário GSA.");
}
var filtro = mensagemRabbit?.ObterObjetoMensagem <AlunoUsuarioInativarDto>();
if (filtro is null)
{
throw new NegocioException("A mensagem enviada é inválida.");
}
try
{
var usuarioInativado = await mediator.Send(new IncluirUsuarioInativoCommand(new UsuarioInativo(filtro.UsuarioId, UsuarioTipo.Aluno)));
var unidadeOrganizacionalAtualizada = await mediator.Send(new AtualizarUnidadeOrganizacionalUsuarioCommand(filtro.UsuarioId, "Alunos/Inativos"));
var alunoRemovidoGoogle = await mediator.Send(new InativarAlunoGoogleCommand(filtro.EmailUsuario));
if (usuarioInativado == false || unidadeOrganizacionalAtualizada == false || alunoRemovidoGoogle == false)
{
await InserirMensagemErroIntegracaoAsync(filtro, "Não foi possível Inativar o Usuário!");
}
}
catch (Exception ex)
{
SentrySdk.CaptureException(ex);
await InserirMensagemErroIntegracaoAsync(filtro, ex.Message);
}
return(true);
}
private async Task Valida_Tratamento_De_Excecoes_Ao_Comunicar_Com_Google_Deve_Devolver_A_Excecao_Disparada()
{
// Arrange
var funcionarioCurso = new FuncionarioCursoEol(1234567, 1010, 6);
var funcionarioGoogle = new FuncionarioGoogle(1234567, "José da Silva", "*****@*****.**", string.Empty);
var cursoGoogle = new CursoGoogle("Curso Google", "Seção", 1010, 6, "*****@*****.**");
mediator.Setup(a => a.Send(It.IsAny <ObterFuncionariosGooglePorRfsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <FuncionarioGoogle> {
funcionarioGoogle
});
mediator.Setup(a => a.Send(It.IsAny <ObterCursoPorTurmaComponenteCurricularQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cursoGoogle);
mediator.Setup(a => a.Send(It.IsAny <ExisteFuncionarioCursoGoogleQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
var excecao = new NullReferenceException("Erro ao se comunicar Google Classroom.");
mediator.Setup(a => a.Send(It.IsAny <InserirFuncionarioCursoGoogleCommand>(), It.IsAny <CancellationToken>()))
.Throws(excecao);
mediator.Setup(a => a.Send(It.IsAny <IncluirCursoUsuarioCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(10);
var funcionarioCursoJson = JsonConvert.SerializeObject(funcionarioCurso);
var mensagem = new MensagemRabbit(funcionarioCursoJson);
// Assert
await Assert.ThrowsAsync <NullReferenceException>(() => inserirFuncionarioCursoGoogleUseCase.Executar(mensagem));
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
try
{
var errosParaTratar = await mediator.Send(new ObterAlunoInativoErroQuery());
if (errosParaTratar != null && errosParaTratar.Any())
{
foreach (var erroParaTratar in errosParaTratar)
{
try
{
await mediator.Send(new PublicaFilaRabbitCommand(
RotasRabbit.FilaGsaInativarUsuarioIniciar,
RotasRabbit.FilaGsaInativarUsuarioIniciar, erroParaTratar));
await ExcluirCursoErroAsync(erroParaTratar);
}
catch (Exception ex)
{
SentrySdk.CaptureException(ex);
}
}
}
return(true);
}
catch (Exception ex)
{
SentrySdk.CaptureException(ex);
}
return(false);
}
private async Task Valida_Inclusao_De_Aluno_Valido_Deve_Retornar_True()
{
// Arrange
var aluno = new AlunoEol(1, "José da Silva", string.Empty, string.Empty, new DateTime(1990, 9, 10));
var alunoComEmailTratado = new AlunoEol(1, "José da Silva", string.Empty, string.Empty, new DateTime(1990, 9, 10));
mediator.Setup(a => a.Send(It.IsAny <VerificarEmailExistenteAlunoQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(alunoComEmailTratado);
mediator.Setup(a => a.Send(It.IsAny <ExisteAlunoPorCodigoQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
mediator.Setup(a => a.Send(It.IsAny <InserirAlunoGoogleCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
mediator.Setup(a => a.Send(It.IsAny <IncluirUsuarioCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(10);
mediator.Setup(a => a.Send(It.IsAny <PublicaFilaRabbitCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var alunoJson = JsonConvert.SerializeObject(aluno);
var mensagem = new MensagemRabbit(alunoJson);
// Act
var retorno = await incluirAlunoUseCase.Executar(mensagem);
// Assert
Assert.True(retorno);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
var dto = mensagemRabbit.ObterObjetoMensagem <FiltroProfessoresEFuncionarioInativosDto>();
if (dto.ProcessarFuncionariosIndiretos)
{
var funcionariosIndiretosGoogle = await mediator.Send(new ObterFuncionariosIndiretosPorCpfQuery(dto.Cpfs.ToArray()));
if (funcionariosIndiretosGoogle != null && funcionariosIndiretosGoogle.Any())
{
await TratarFuncionariosIndiretos(funcionariosIndiretosGoogle);
}
}
if (dto.ProcessarProfessoresEFuncionarios)
{
var professoresEFuncionariosGoogle = await mediator.Send(new ObterProfessoresEFuncionariosPorCodigosQuery(dto.Rfs.ToArray()));
if (professoresEFuncionariosGoogle != null && professoresEFuncionariosGoogle.Any())
{
await TratarProfessoresEFuncionarios(professoresEFuncionariosGoogle);
}
}
return(true);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
try
{
var filtroCargaInicial = UtilsDto.ObterFiltroParametrosIniciais(mensagemRabbit);
var usuarioErros = await mediator.Send(new ObtemUsuariosErrosPorTipoQuery(UsuarioTipo.Funcionario));
if (!usuarioErros?.Any() ?? true)
{
return(true);
}
foreach (var usuarioErro in usuarioErros)
{
var filtroFuncionarioErro = new FiltroUsuarioErroDto(usuarioErro, filtroCargaInicial);
var publicarFuncionario = await mediator.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaFuncionarioErroTratar, RotasRabbit.FilaFuncionarioErroTratar, filtroFuncionarioErro));
if (!publicarFuncionario)
{
SentrySdk.CaptureMessage($"Não foi possível inserir o tratamento de erro do funcionário RF{usuarioErro.UsuarioId} na fila.");
continue;
}
await ExcluirUsuarioErroAsync(usuarioErro);
}
return(true);
}
catch (Exception ex)
{
SentrySdk.CaptureException(ex);
}
return(false);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
try
{
var filtro = ObterFiltro(mensagemRabbit);
var usuarioErros = await mediator.Send(new ObtemUsuariosErrosPorTipoQuery(UsuarioTipo.Aluno));
if (!usuarioErros?.Any() ?? true)
{
return(true);
}
foreach (var usuarioErro in usuarioErros)
{
var filtroAluno = new FiltroAlunoErroDto(usuarioErro, filtro.AnoLetivo, filtro.TiposUes, filtro.Ues, filtro.Turmas);
var publicarFuncionario = await mediator.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaAlunoErroTratar, RotasRabbit.FilaAlunoErroTratar, filtroAluno));
if (!publicarFuncionario)
{
SentrySdk.CaptureMessage($"Não foi possível inserir o tratamento de erro do aluno RA{usuarioErro.UsuarioId} na fila.");
continue;
}
await ExcluirUsuarioErroAsync(usuarioErro);
}
return(true);
}
catch (Exception ex)
{
SentrySdk.CaptureException(ex);
}
return(false);
}
private async Task Valida_Tratamento_De_Aluno_Ja_Incluso_No_Curso_Deve_Retornar_True()
{
// Arrange
var alunoCurso = new AlunoCursoEol(1234567, 1010, 6);
var alunoGoogle = new AlunoGoogle(1234567, "José da Silva", "*****@*****.**", string.Empty);
var cursoGoogle = new CursoGoogle("Curso Google", "Seção", 1010, 6, "*****@*****.**");
mediator.Setup(a => a.Send(It.IsAny <ObterAlunosPorCodigosQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <AlunoGoogle> {
alunoGoogle
});
mediator.Setup(a => a.Send(It.IsAny <ObterCursoPorEmailNomeQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cursoGoogle);
mediator.Setup(a => a.Send(It.IsAny <ExisteAlunoCursoGoogleQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var alunoCursoJson = JsonConvert.SerializeObject(alunoCurso);
var mensagem = new MensagemRabbit(alunoCursoJson);
// Act
var retorno = await inserirAlunoCursoGoogleUseCase.Executar(mensagem);
// Assert
Assert.True(retorno);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
var filtroDadosUsuario = mensagemRabbit.ObterObjetoMensagem <AtualizarDadosUsuarioDto>();
if (filtroDadosUsuario == null)
{
SentrySdk.CaptureMessage($"Não foi possível realizar a atualização dos dados do responsável do aluno no eol", Sentry.Protocol.SentryLevel.Error);
return(false);
}
var usuarioApp = await mediator.Send(new ObterUsuarioQuery(filtroDadosUsuario.Id));
if (usuarioApp == null)
{
return(false);
}
var usuariosEol = await mediator.Send(new ObterDadosReponsavelPorCpfQuery(usuarioApp.Cpf));
if (usuariosEol == null || !usuariosEol.Any())
{
return(false);
}
MapearAlteracoes(usuariosEol, filtroDadosUsuario);
foreach (var usuarioEol in usuariosEol)
{
await mediator.Send(new AtualizarDadosResponsavelEolCommand(usuarioEol.CodigoAluno, long.Parse(usuarioEol.CPF), usuarioEol.Email, filtroDadosUsuario.DataNascimentoResponsavel, usuarioEol.NomeMae, usuarioEol.NumeroCelular, usuarioEol.DDDCelular));
}
return(true);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
SentrySdk.AddBreadcrumb($"Mensagem InserirAulaRecorrenteUseCase", "Rabbit - InserirAulaRecorrenteUseCase");
InserirAulaRecorrenteCommand command = mensagemRabbit.ObterObjetoMensagem <InserirAulaRecorrenteCommand>();
return(await mediator.Send(command));
}
private async Task Valida_Tratamento_De_Duplicidade_No_Google_Deve_Retornar_True()
{
// Arrange
var professorCurso = new ProfessorCursoEol(1234567, 1010, 6);
var professorGoogle = new ProfessorGoogle(1234567, "José da Silva", "*****@*****.**", string.Empty);
var cursoGoogle = new CursoGoogle("Curso Google", "Seção", 1010, 6, "*****@*****.**");
mediator.Setup(a => a.Send(It.IsAny <ObterProfessoresPorRfsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <ProfessorGoogle> {
professorGoogle
});
mediator.Setup(a => a.Send(It.IsAny <ObterCursoPorTurmaComponenteCurricularQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cursoGoogle);
mediator.Setup(a => a.Send(It.IsAny <ExisteProfessorCursoGoogleQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
var googleDuplicidadeException = GerarExcecaoDeDuplicidadeDoGoogle();
mediator.Setup(a => a.Send(It.IsAny <InserirProfessorCursoGoogleCommand>(), It.IsAny <CancellationToken>()))
.Throws(googleDuplicidadeException);
mediator.Setup(a => a.Send(It.IsAny <IncluirCursoUsuarioCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(10);
var professorCursoJson = JsonConvert.SerializeObject(professorCurso);
var mensagem = new MensagemRabbit(professorCursoJson);
// Act
var retorno = await inserirProfessorCursoGoogleUseCase.Executar(mensagem);
// Assert
Assert.True(retorno);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
var filtro = mensagemRabbit.Mensagem.ToString() != null?mensagemRabbit.ObterObjetoMensagem <FiltroCargaInicialDto>() : null;
var ultimaAtualizacao = await mediator.Send(new ObterDataUltimaExecucaoPorTipoQuery(ExecucaoTipo.AtribuicaoProfessorCursoAdicionar));
var paginacao = new Paginacao(0, 0);
var parametrosCargaInicialDto = filtro != null ? new ParametrosCargaInicialDto(filtro.TiposUes, filtro.Ues, filtro.Turmas, DateTime.Today.Year) :
await mediator.Send(new ObterParametrosCargaIncialPorAnoQuery(DateTime.Today.Year));
var atribuicoesDeCursosProfessores = await mediator.Send(new ObterAtribuicoesDeCursosDosProfessoresQuery(ultimaAtualizacao, paginacao, parametrosCargaInicialDto));
foreach (var atribuicaoDeCursoDoProfessor in atribuicoesDeCursosProfessores.Items)
{
var cursoDoProfessorParaIncluir = new ProfessorCursoEol(atribuicaoDeCursoDoProfessor.Rf, atribuicaoDeCursoDoProfessor.TurmaId, atribuicaoDeCursoDoProfessor.ComponenteCurricularId, atribuicaoDeCursoDoProfessor.Modalidade);
try
{
var publicarProfessor = await mediator.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaProfessorCursoIncluir, RotasRabbit.FilaProfessorCursoIncluir, cursoDoProfessorParaIncluir));
if (!publicarProfessor)
{
await IncluirCursoDoProfessorComErroAsync(cursoDoProfessorParaIncluir, ObterMensagemDeErro(cursoDoProfessorParaIncluir));
}
}
catch (Exception ex)
{
await IncluirCursoDoProfessorComErroAsync(cursoDoProfessorParaIncluir, ObterMensagemDeErro(cursoDoProfessorParaIncluir, ex));
}
}
await mediator.Send(new AtualizaExecucaoControleCommand(ExecucaoTipo.AtribuicaoProfessorCursoAdicionar, DateTime.Today));
return(true);
}
private async Task Valida_Tratamento_De_Excecoes_Do_Google_Deve_Devolver_A_GoogleApiExption_Disparada()
{
// Arrange
var professorCurso = new ProfessorCursoEol(1234567, 1010, 6);
var professorGoogle = new ProfessorGoogle(1234567, "José da Silva", "*****@*****.**", string.Empty);
var cursoGoogle = new CursoGoogle("Curso Google", "Seção", 1010, 6, "*****@*****.**");
mediator.Setup(a => a.Send(It.IsAny <ObterProfessoresPorRfsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <ProfessorGoogle> {
professorGoogle
});
mediator.Setup(a => a.Send(It.IsAny <ObterCursoPorTurmaComponenteCurricularQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cursoGoogle);
mediator.Setup(a => a.Send(It.IsAny <ExisteProfessorCursoGoogleQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
var googleException = new GoogleApiException(string.Empty, "Erro no Google Classroom.");
mediator.Setup(a => a.Send(It.IsAny <InserirProfessorCursoGoogleCommand>(), It.IsAny <CancellationToken>()))
.Throws(googleException);
mediator.Setup(a => a.Send(It.IsAny <IncluirCursoUsuarioCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(10);
var professorCursoJson = JsonConvert.SerializeObject(professorCurso);
var mensagem = new MensagemRabbit(professorCursoJson);
// Assert
await Assert.ThrowsAsync <GoogleApiException>(() => inserirProfessorCursoGoogleUseCase.Executar(mensagem));
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
var filtroDadosUsuario = mensagemRabbit.ObterObjetoMensagem <AtualizarDadosUsuarioDto>();
var usuarioApp = await mediator.Send(new ObterUsuarioQuery(filtroDadosUsuario.Id));
if (usuarioApp == null)
{
return(false);
}
var usuariosEol = await mediator.Send(new ObterDadosReponsavelPorCpfQuery(usuarioApp.Cpf));
if (usuariosEol == null || !usuariosEol.Any())
{
return(false);
}
MapearAlteracoes(usuariosEol, filtroDadosUsuario);
foreach (var usuarioEol in usuariosEol)
{
await mediator.Send(new EnviarAtualizacaoCadastralProdamCommand(usuarioEol));
}
return(true);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
var codigoCurso = long.Parse(mensagemRabbit.Mensagem.ToString());
try
{
var excluido = await mediator.Send(new ExcluirCursoGoogleCommand(codigoCurso));
if (excluido)
{
return(await mediator.Send(new ExcluirCursoCommand(codigoCurso)));
}
return(false);
}
catch (GoogleApiException exception)
{
if (exception.HttpStatusCode == HttpStatusCode.NotFound)
{
return(await mediator.Send(new ExcluirCursoCommand(codigoCurso)));
}
throw new NegocioException("Ocorreu um erro interno de comunicação comm google. Favor contatar o suporte.");
}
catch (Exception e)
{
throw new NegocioException("Ocorreu um erro interno. Favor contatar o suporte.");
}
}
private async Task Valida_Tratamento_De_Funcionario_Ja_Incluso_No_Curso_Deve_Retornar_True()
{
// Arrange
var funcionarioCurso = new FuncionarioCursoEol(1234567, 1010, 6);
var funcionarioGoogle = new FuncionarioGoogle(1234567, "José da Silva", "*****@*****.**", string.Empty);
var cursoGoogle = new CursoGoogle("Curso Google", "Seção", 1010, 6, "*****@*****.**");
mediator.Setup(a => a.Send(It.IsAny <ObterFuncionariosGooglePorRfsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <FuncionarioGoogle> {
funcionarioGoogle
});
mediator.Setup(a => a.Send(It.IsAny <ObterCursoPorTurmaComponenteCurricularQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cursoGoogle);
mediator.Setup(a => a.Send(It.IsAny <ExisteFuncionarioCursoGoogleQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var funcionarioCursoJson = JsonConvert.SerializeObject(funcionarioCurso);
var mensagem = new MensagemRabbit(funcionarioCursoJson);
// Act
var retorno = await inserirFuncionarioCursoGoogleUseCase.Executar(mensagem);
// Assert
Assert.True(retorno);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
var filtro = JsonConvert.DeserializeObject <FiltroFormacaoCidadeTurmaComponenteDto>(mensagemRabbit.Mensagem.ToString());
try
{
foreach (var salaVirtual in filtro.SalasVirtuais)
{
await mediator.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaGsaFormacaoCidadeTurmasTratarCurso,
new FiltroFormacaoCidadeTurmaCursoDto($"{filtro.SalaVirtual} - {salaVirtual.SalaVirtual}",
filtro.CodigoDre,
filtro.AnoLetivo,
salaVirtual.ComponentesCurricularesIds,
salaVirtual.ModalidadesIds,
salaVirtual.TipoEscola,
salaVirtual.TipoConsulta,
salaVirtual.AnoTurma,
salaVirtual.IncluirAlunoCurso,
salaVirtual.AgruparPorDres ?? (new string[] { filtro.CodigoDre }))));
}
}
catch (Exception ex)
{
filtro.MensagemErro = $"{ex.Message}";
await mediator.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaGsaFormacaoCidadeTurmasTratarComponenteErro, filtro));
await mediator.Send(new SalvarLogViaRabbitCommand($"{RotasRabbit.FilaGsaFormacaoCidadeTurmasTratarComponente} - {ex.Message}", LogNivel.Critico, LogContexto.FormacaoCidade, mensagemRabbit.Mensagem.ToString()));
}
return(true);
}
private async Task Valida_Inclusao_De_Funcionario_Valido_Deve_Retornar_True()
{
// Arrange
var funcionario = new FuncionarioEol(123456, "José da Silva", string.Empty, string.Empty);
mediator.Setup(a => a.Send(It.IsAny <ExisteFuncionarioPorRfQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(false);
mediator.Setup(a => a.Send(It.IsAny <InserirFuncionarioGoogleCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
mediator.Setup(a => a.Send(It.IsAny <IncluirUsuarioCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(10);
mediator.Setup(a => a.Send(It.IsAny <PublicaFilaRabbitCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
var funcionarioJson = JsonConvert.SerializeObject(funcionario);
var mensagem = new MensagemRabbit(funcionarioJson);
// Act
var retorno = await inserirFuncionarioGoogleUseCase.Executar(mensagem);
// Assert
Assert.True(retorno);
}
public async Task <bool> Executar(MensagemRabbit mensagem)
{
var filtro = ObterFiltro(mensagem);
var ultimaAtualizacao = filtro != null ? new DateTime(filtro.AnoLetivo, 1, 1) : await mediator.Send(new ObterDataUltimaExecucaoPorTipoQuery(ExecucaoTipo.FuncionarioIndiretoAdicionar));
var paginacao = new Paginacao(0, 0);
var funcionariosIndiretosParaIncluirGoogle = await mediator.Send(new ObterFuncionariosIndiretosParaIncluirGoogleQuery(ultimaAtualizacao, paginacao));
foreach (var funcionarioIndiretosParaIncluirGoogle in funcionariosIndiretosParaIncluirGoogle.Items)
{
try
{
var publicarFuncionario = await mediator.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaFuncionarioIndiretoIncluir, RotasRabbit.FilaFuncionarioIndiretoIncluir, funcionarioIndiretosParaIncluirGoogle));
if (!publicarFuncionario)
{
await IncluirFuncionarioIndiretoComErroAsync(funcionarioIndiretosParaIncluirGoogle, ObterMensagemDeErro(funcionarioIndiretosParaIncluirGoogle.Cpf));
}
}
catch (Exception ex)
{
await IncluirFuncionarioIndiretoComErroAsync(funcionarioIndiretosParaIncluirGoogle, ObterMensagemDeErro(funcionarioIndiretosParaIncluirGoogle.Cpf, ex));
}
}
await mediator.Send(new AtualizaExecucaoControleCommand(ExecucaoTipo.FuncionarioIndiretoAdicionar, DateTime.Today));
return(true);
}
public async Task <bool> Executar(MensagemRabbit mensagem)
{
var filtro = UtilsDto.ObterFiltroParametrosIniciais(mensagem);
var ultimaAtualizacao = filtro != null ? await mediator.Send(new ObterDataUltimaExecucaoPorTipoQuery(ExecucaoTipo.FuncionarioAdicionar)) : new DateTime(filtro.AnoLetivo, 1, 1);
var paginacao = new Paginacao(0, 0);
var parametrosCargaInicialDto = filtro != null ? new ParametrosCargaInicialDto(filtro.TiposUes, filtro.Ues, filtro.Turmas, filtro.AnoLetivo) :
await mediator.Send(new ObterParametrosCargaIncialPorAnoQuery(DateTime.Today.Year));
var funcionariosParaIncluirGoogle = await mediator.Send(new ObterFuncionariosParaIncluirGoogleQuery(ultimaAtualizacao, paginacao, string.Empty, parametrosCargaInicialDto));
foreach (var funcionarioParaIncluirGoogle in funcionariosParaIncluirGoogle.Items)
{
try
{
var publicarFuncionario = await mediator.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaFuncionarioIncluir, RotasRabbit.FilaFuncionarioIncluir, funcionarioParaIncluirGoogle));
if (!publicarFuncionario)
{
await IncluirFuncionarioComErroAsync(funcionarioParaIncluirGoogle, ObterMensagemDeErro(funcionarioParaIncluirGoogle.Rf));
}
}
catch (Exception ex)
{
await IncluirFuncionarioComErroAsync(funcionarioParaIncluirGoogle, ObterMensagemDeErro(funcionarioParaIncluirGoogle.Rf, ex));
}
}
await mediator.Send(new AtualizaExecucaoControleCommand(ExecucaoTipo.FuncionarioAdicionar, DateTime.Today));
return(true);
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
var dto = mensagemRabbit.ObterObjetoMensagem <AlterarNotificacaoDiarioBordoDto>();
await mediator.Send(new AlterarNotificacaoDiarioBordoCommand(dto.ObservacaoId, dto.UsuarioId));
return(true);
}
public async Task <bool> Executar(MensagemRabbit param)
{
try
{
var turmasDoEnsinoInfantil = await mediator.Send(new ObterTurmasPorAnoModalidadeQuery(DateTime.Now.Year, Modalidade.Infantil));
if (!turmasDoEnsinoInfantil?.Any() ?? true)
{
SentrySdk.AddBreadcrumb($"Não foram encontradas turmas para geração de pendências de ausência de registro individual .", $"Rabbit - {nameof(GerarPendenciaAusenciaRegistroIndividualUseCase)}");
return(false);
}
foreach (var turma in turmasDoEnsinoInfantil)
{
await GerarPendenciaAusenciaRegistroIndividualTurmaAsync(turma);
}
return(true);
}
catch (Exception ex)
{
SentrySdk.CaptureException(ex);
return(false);
}
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
if (mensagemRabbit?.Mensagem is null)
{
throw new NegocioException("Não foi possível processaor o curso GSA. A mensagem enviada é inválida.");
}
var cursoGsaDto = JsonConvert.DeserializeObject <CursoGsaDto>(mensagemRabbit.Mensagem.ToString());
if (cursoGsaDto is null)
{
throw new NegocioException("Não foi possível processaor o curso GSA. A mensagem enviada é inválida.");
}
var cursoGoogle = await mediator.Send(new ObterCursoGooglePorIdQuery(cursoGsaDto.Id));
var cursoInseridoManualmente = cursoGoogle is null;
var cursoGsa = new CursoGsa(cursoGsaDto.Id, cursoGsaDto.Nome, cursoGsaDto.Secao, cursoGsaDto.CriadorId, cursoGsaDto.Descricao, cursoInseridoManualmente, cursoGsaDto.DataInclusao);
var retorno = await mediator.Send(new InserirCursoGsaCommand(cursoGsa));
if (cursoGsaDto.UltimoItemDaFila)
{
await IniciarValidacaoAsync();
}
await InicarCargaUsuariosDoCursoAsync(cursoGsaDto);
return(retorno);
}
public async Task<bool> Executar(MensagemRabbit mensagemRabbit)
{
SentrySdk.AddBreadcrumb($"Mensagem {nameof(AtualizarPendenciaRegistroIndividualUseCase)}", $"Rabbit - {nameof(AtualizarPendenciaRegistroIndividualUseCase)}");
var command = mensagemRabbit.ObterObjetoMensagem<AtualizarPendenciaRegistroIndividualCommand>();
await mediator.Send(command);
return true;
}
public async Task <bool> Executar(MensagemRabbit mensagem)
{
if (mensagem.Mensagem is null)
{
throw new NegocioException("O objeto da atividade avaliativa deve ser informado na mensagem");
}
var atividades = mensagem
.ObterObjetoMensagem <TratarImportacaoNotasAvalidacaoDto[]>();
foreach (var atividade in atividades)
{
var consultaNotas = await mediator
.Send(new ObterNotasGooglePorAtividadeQuery(atividade.DadosAvaliacao));
await ProximaPagina(atividade, consultaNotas.TokenProximaPagina);
foreach (var nota in consultaNotas.Notas)
{
await mediator
.Send(new PublicaFilaRabbitCommand(RotasRabbit.FilaGsaNotasAtividadesSync, new SincronizarImportacaoNotasDto(atividade.DadosAvaliacao, nota)));
}
}
return(true);
}