private async Task InserirAlunoCursoGoogleAsync(AlunoGoogle alunoGoogle, CursoGoogle cursoGoogle)
{
var alunoCursoGoogle = new AlunoCursoGoogle(alunoGoogle.Indice, cursoGoogle.Id);
try
{
var professorCursoSincronizado = await mediator.Send(new InserirAlunoCursoGoogleCommand(alunoCursoGoogle, alunoGoogle.Email));
if (professorCursoSincronizado)
{
await InserirAlunoCursoAsync(alunoCursoGoogle);
}
}
catch (GoogleApiException gEx)
{
if (gEx.EhErroDeDuplicidade())
{
await InserirAlunoCursoAsync(alunoCursoGoogle);
}
else
{
throw;
}
}
}
private async Task Valida_Tratamento_De_Excecoes_Ao_Comunicar_Com_Google_Deve_Devolver_A_Excecao_Disparada()
{
// 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(false);
var excecao = new NullReferenceException("Erro ao se comunicar Google Classroom.");
mediator.Setup(a => a.Send(It.IsAny <InserirAlunoCursoGoogleCommand>(), It.IsAny <CancellationToken>()))
.Throws(excecao);
mediator.Setup(a => a.Send(It.IsAny <IncluirCursoUsuarioCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(10);
var alunoCursoJson = JsonConvert.SerializeObject(alunoCurso);
var mensagem = new MensagemRabbit(alunoCursoJson);
// Assert
await Assert.ThrowsAsync <NullReferenceException>(() => inserirAlunoCursoGoogleUseCase.Executar(mensagem));
}
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 FiltroAlunoCursoDto(AlunoGoogle alunoGoogle, int?anoLetivo, List <int> tiposUes, List <long> ues, List <long> turmas)
{
AlunoGoogle = alunoGoogle;
AnoLetivo = anoLetivo;
TiposUes = tiposUes;
Ues = ues;
Turmas = turmas;
}
private async Task InserirAlunoAsync(AlunoGoogle alunoGoogle, FiltroAlunoDto filtro)
{
alunoGoogle.Indice = await mediator.Send(new IncluirUsuarioCommand(alunoGoogle));
var filtroAlunoCurso = new FiltroAlunoCursoDto(alunoGoogle, filtro.AnoLetivo, filtro.TiposUes, filtro.Ues, filtro.Turmas);
await IniciarSyncGoogleCursosDoAlunoAsync(filtroAlunoCurso);
}
private void Valida_Tratamento_Da_Formatacao_De_Nomes_Passandos_Os_Resultados_Esperados(string nome, string sobrenomeEsperado, string nomeEsperado)
{
// Arrange
var aluno = new AlunoGoogle(1, nome, "email", "organizationPath");
// Assert
Assert.NotNull(aluno);
Assert.Equal(sobrenomeEsperado, aluno.Sobrenome);
Assert.Equal(nomeEsperado, aluno.Nome);
}
private async Task IncluirCursoDoAlunoComErroAsync(AlunoGoogle alunoGoogle, string mensagem)
{
var command = new IncluirCursoUsuarioErroCommand(
alunoGoogle.Codigo,
ExecucaoTipo.ProfessorCursoAdicionar,
ErroTipo.Negocio,
mensagem);
await mediator.Send(command);
}
private async Task AtualizarAlunoNoGoogleAsync(AlunoGoogle alunoGoogle, DirectoryService diretorioClassroom)
{
var usuarioParaIncluirNoGoogle = new User
{
Name = new UserName {
FamilyName = alunoGoogle.Sobrenome, GivenName = alunoGoogle.PrimeiroNome, FullName = alunoGoogle.Nome
},
PrimaryEmail = alunoGoogle.Email,
OrgUnitPath = alunoGoogle.OrganizationPath,
Suspended = false
};
var requestUpdate = diretorioClassroom.Users.Patch(usuarioParaIncluirNoGoogle, alunoGoogle.GoogleClassroomId ?? alunoGoogle.Email);
await requestUpdate.ExecuteAsync();
}
public async Task <bool> Executar(MensagemRabbit mensagemRabbit)
{
if (mensagemRabbit.Mensagem is null)
{
throw new NegocioException("Não foi possível incluir o aluno. A mensagem enviada é inválida.");
}
var filtro = mensagemRabbit.ObterObjetoMensagem <FiltroAlunoDto>();
var alunoParaIncluir = filtro.AlunoEol;
if (alunoParaIncluir is null)
{
throw new NegocioException("Não foi possível incluir o aluno. A mensagem enviada é inválida.");
}
try
{
var alunoJaIncluido = await mediator.Send(new ObterAlunosPorCodigosQuery(alunoParaIncluir.Codigo));
var googleClassroomId = alunoJaIncluido.Any() ? alunoJaIncluido.First().GoogleClassroomId : null;
if (alunoJaIncluido != null && alunoJaIncluido.Any() && googleClassroomId != null && !googleClassroomId.Equals(alunoParaIncluir.Codigo.ToString()))
{
await AtualizarAlunoGoogleSync(filtro, alunoJaIncluido.First());
return(true);
}
alunoParaIncluir = await mediator.Send(new VerificarEmailExistenteAlunoQuery(alunoParaIncluir));
var alunoGoogle = new AlunoGoogle(alunoParaIncluir.Codigo, alunoParaIncluir.Nome, alunoParaIncluir.Email, alunoParaIncluir.OrganizationPath);
await InserirAlunoGoogleAsync(alunoGoogle, alunoJaIncluido?.FirstOrDefault(), filtro);
return(true);
}
catch (Exception ex)
{
await mediator.Send(new IncluirUsuarioErroCommand(alunoParaIncluir?.Codigo, alunoParaIncluir?.Email,
$"ex.: {ex.Message} <-> msg rabbit: {mensagemRabbit}. StackTrace:{ex.StackTrace}.", UsuarioTipo.Aluno, ExecucaoTipo.AlunoAdicionar));
throw;
}
}
private async Task AtualizarAlunoGoogleSync(FiltroAlunoDto filtro, AlunoGoogle alunoGoogle)
{
var alunoEol = filtro.AlunoEol;
alunoGoogle.Nome = alunoEol.Nome;
alunoGoogle.OrganizationPath = alunoEol.OrganizationPath;
var incluiuAlunoGoogle = await mediator.Send(new AtualizarAlunoGoogleCommand(alunoGoogle));
if (!incluiuAlunoGoogle)
{
await mediator.Send(new IncluirUsuarioErroCommand(alunoGoogle?.Codigo, alunoGoogle?.Email,
$"Não foi possível atualizar o aluno no Google Classroom. {alunoGoogle}", UsuarioTipo.Aluno, ExecucaoTipo.AlunoAdicionar));
return;
}
var usuarioAlterado = await mediator.Send(new AtualizarUsuarioCommand(alunoGoogle.Indice, alunoGoogle.Nome, alunoGoogle.OrganizationPath));
if (!usuarioAlterado)
{
await mediator.Send(new IncluirUsuarioErroCommand(alunoGoogle?.Codigo, alunoGoogle?.Email,
$"Não foi possível atualizar o aluno {alunoGoogle} no Google Classroom. O aluno não foi encontrado na base.", UsuarioTipo.Aluno, ExecucaoTipo.AlunoAdicionar));
return;
}
var idAlterado = await mediator.Send(new AtualizarUsuarioGoogleClassroomIdCommand(alunoGoogle.Indice, alunoGoogle.GoogleClassroomId));
if (!idAlterado)
{
await mediator.Send(new IncluirUsuarioErroCommand(alunoGoogle?.Codigo, alunoGoogle?.Email,
$"Não foi possível atualizar o Id do aluno {alunoGoogle} no Google Classroom.", UsuarioTipo.Aluno, ExecucaoTipo.AlunoAdicionar));
return;
}
var filtroAlunoCurso = new FiltroAlunoCursoDto(alunoGoogle, filtro.AnoLetivo, filtro.TiposUes, filtro.Ues, filtro.Turmas);
await IniciarSyncGoogleCursosDoAlunoAsync(filtroAlunoCurso);
}
private async Task InserirAlunoGoogleAsync(AlunoGoogle alunoGoogle, AlunoGoogle alunoJaIncluido, FiltroAlunoDto filtro)
{
var alunoEol = filtro.AlunoEol;
try
{
var incluiuAlunoGoogle = await mediator.Send(new InserirAlunoGoogleCommand(alunoGoogle));
if (!incluiuAlunoGoogle)
{
await mediator.Send(new IncluirUsuarioErroCommand(alunoGoogle?.Codigo, alunoGoogle?.Email,
$"Não foi possível incluir o aluno no Google Classroom. {alunoGoogle}", UsuarioTipo.Aluno, ExecucaoTipo.AlunoAdicionar));
return;
}
if (alunoJaIncluido != null)
{
alunoJaIncluido.GoogleClassroomId = alunoGoogle.GoogleClassroomId;
await AtualizarAlunoGoogleSync(filtro, alunoJaIncluido);
}
else
{
await InserirAlunoAsync(alunoGoogle, filtro);
}
}
catch (GoogleApiException gEx)
{
if (gEx.EhErroDeDuplicidade())
{
await InserirAlunoAsync(alunoGoogle, filtro);
}
else
{
throw;
}
}
}
private async Task IncluirAlunoNoGoogle(AlunoGoogle alunoGoogle, DirectoryService diretorioClassroom)
{
var usuarioParaIncluirNoGoogle = new User
{
Name = new UserName {
FamilyName = alunoGoogle.Sobrenome, GivenName = alunoGoogle.PrimeiroNome, FullName = alunoGoogle.Nome
},
PrimaryEmail = alunoGoogle.Email,
OrgUnitPath = alunoGoogle.OrganizationPath,
Password = configuration["GoogleClassroomConfig:PasswordPadraoParaUsuarioNovo"],
ChangePasswordAtNextLogin = true
};
var requestCreate = diretorioClassroom.Users.Insert(usuarioParaIncluirNoGoogle);
var usuarioIncluido = await requestCreate.ExecuteAsync();
if (usuarioIncluido is null)
{
throw new NegocioException("Não foi possível obter o aluno incluído no Google Classroom.");
}
alunoGoogle.GoogleClassroomId = usuarioIncluido.Id;
}
public InserirAlunoGoogleCommand(AlunoGoogle alunoGoogle)
{
AlunoGoogle = alunoGoogle;
}
public AtualizarAlunoGoogleCommand(AlunoGoogle alunoGoogle)
{
AlunoGoogle = alunoGoogle;
}
public IncluirUsuarioCommand(AlunoGoogle alunoGoogle)
: this(usuarioGoogle : alunoGoogle)
{
Id = alunoGoogle.Codigo;
}
