public async Task <bool> Executar(PlanoAulaDto planoAulaDto)
{
unitOfWork.IniciarTransacao();
await mediator.Send(new SalvarPlanoAulaCommand(planoAulaDto));
unitOfWork.PersistirTransacao();
return(true);
}
private void Setup()
{
// Aula
aula = new Aula()
{
DataAula = new DateTime(2019, 11, 18),
TurmaId = "123",
DisciplinaId = "7",
Quantidade = 3,
TipoAula = TipoAula.Normal
};
repositorioAula.Setup(a => a.ObterPorId(It.IsAny <long>()))
.Returns(aula);
// Plano Aula
planoAulaDto = new PlanoAulaDto()
{
AulaId = 1,
Descricao = "Teste de inclusão",
DesenvolvimentoAula = "Desenvolvimento da aula",
};
repositorioPlanoAula.Setup(a => a.ObterPlanoAulaPorAula(It.IsAny <long>()))
.Returns(Task.FromResult(new PlanoAula()));
// Usuario
usuario = new Usuario()
{
CodigoRf = "ABC",
};
usuario.DefinirPerfis(new List <PrioridadePerfil>()
{
new PrioridadePerfil()
{
CodigoPerfil = PERFIL_PROFESSOR
}
});
servicoUsuario.Setup(a => a.ObterLoginAtual()).Returns("teste");
servicoUsuario.Setup(a => a.ObterPerfilAtual()).Returns(new Guid());
servicoUsuario.Setup(a => a.ObterUsuarioLogado()).Returns(Task.FromResult(usuario));
// Abrangencia
abrangencia = new AbrangenciaFiltroRetorno()
{
Ano = "2019",
CodigoTurma = "123",
QtDuracaoAula = 3,
Modalidade = Modalidade.Fundamental
};
repositorioAbrangencia.Setup(a => a.ObterAbrangenciaTurma(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <bool>()))
.Returns(Task.FromResult(abrangencia));
}
private PlanoAula MapearParaDominio(PlanoAulaDto planoDto, PlanoAula planoAula = null)
{
if (planoAula == null)
{
planoAula = new PlanoAula();
}
planoAula.AulaId = planoDto.AulaId;
planoAula.Descricao = planoDto.Descricao;
planoAula.DesenvolvimentoAula = planoDto.DesenvolvimentoAula;
planoAula.RecuperacaoAula = planoDto.RecuperacaoAula;
planoAula.LicaoCasa = planoDto.LicaoCasa;
return(planoAula);
}
public async Task Migrar(MigrarPlanoAulaDto migrarPlanoAulaDto)
{
var usuario = await servicoUsuario.ObterUsuarioLogado();
var planoAulaDto = repositorio.ObterPorId(migrarPlanoAulaDto.PlanoAulaId);
var aula = repositorioAula.ObterPorId(planoAulaDto.AulaId);
await ValidarMigracao(migrarPlanoAulaDto, usuario.CodigoRf, usuario.EhProfessorCj(), aula.UeId);
var objetivosPlanoAulaDto = await repositorioObjetivosAula.ObterObjetivosPlanoAula(migrarPlanoAulaDto.PlanoAulaId);
unitOfWork.IniciarTransacao();
foreach (var planoTurma in migrarPlanoAulaDto.IdsPlanoTurmasDestino)
{
AulaConsultaDto aulaConsultaDto = await
repositorioAula.ObterAulaDataTurmaDisciplina(
planoTurma.Data,
planoTurma.TurmaId,
migrarPlanoAulaDto.DisciplinaId
);
if (aulaConsultaDto == null)
{
throw new NegocioException($"Não há aula cadastrada para a turma {planoTurma.TurmaId} para a data {planoTurma.Data.ToString("dd/MM/yyyy")} nesta disciplina!");
}
var planoCopia = new PlanoAulaDto()
{
Id = planoTurma.Sobreescrever ? migrarPlanoAulaDto.PlanoAulaId : 0,
AulaId = aulaConsultaDto.Id,
Descricao = planoAulaDto.Descricao,
DesenvolvimentoAula = planoAulaDto.DesenvolvimentoAula,
LicaoCasa = migrarPlanoAulaDto.MigrarLicaoCasa ? planoAulaDto.LicaoCasa : string.Empty,
ObjetivosAprendizagemJurema = !usuario.EhProfessorCj() ||
migrarPlanoAulaDto.MigrarObjetivos ?
objetivosPlanoAulaDto.Select(o => o.ObjetivoAprendizagemPlano.ObjetivoAprendizagemJuremaId).ToList() : null,
RecuperacaoAula = migrarPlanoAulaDto.MigrarRecuperacaoAula ?
planoAulaDto.RecuperacaoAula : string.Empty
};
await Salvar(planoCopia, false);
}
unitOfWork.PersistirTransacao();
}
public async Task Deve_Adicionar_Novo_Plano_Aula()
{
//Arrange
mediator.Setup(a => a.Send(It.IsAny <SalvarPlanoAulaCommand>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
//Act
var dto = new PlanoAulaDto();
dto.AulaId = 1;
dto.Descricao = "Descrição do plano de aula";
mediator.Setup(a => a.Send(It.IsAny <ObterAulaPorIdQuery>(), It.IsAny <CancellationToken>())).ReturnsAsync(new Aula()
{
Id = 1,
TurmaId = "1"
});
mediator.Setup(a => a.Send(It.IsAny <ObterTurmaPorCodigoQuery>(), It.IsAny <CancellationToken>())).ReturnsAsync(new Turma()
{
Id = 1,
Nome = "1A"
});
mediator.Setup(a => a.Send(It.IsAny <ObterUsuarioLogadoQuery>(), It.IsAny <CancellationToken>())).ReturnsAsync(new Usuario()
{
Id = 1,
CodigoRf = "1111111"
});
mediator.Setup(a => a.Send(It.IsAny <ObterPlanoAulaPorAulaIdQuery>(), It.IsAny <CancellationToken>())).ReturnsAsync(new PlanoAula()
{
Id = 1,
});
mediator.Setup(a => a.Send(It.IsAny <ObterPlanejamentoAnualPorAnoEscolaBimestreETurmaQuery>(), It.IsAny <CancellationToken>())).ReturnsAsync(new PlanejamentoAnual()
{
Id = 1,
});
var auditoriaDto = await useCase.Executar(dto);
//Asert
mediator.Verify(x => x.Send(It.IsAny <SalvarPlanoAulaCommand>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.True(true);
}
public async Task <bool> Handle(MigrarPlanoAulaCommand request, CancellationToken cancellationToken)
{
var usuario = request.Usuario;
var planoAulaDto = repositorioPlanoAula.ObterPorId(request.PlanoAulaMigrar.PlanoAulaId);
var aula = await mediator.Send(new ObterAulaPorIdQuery(planoAulaDto.AulaId));
await ValidarMigracao(request.PlanoAulaMigrar, usuario.CodigoRf, usuario.EhProfessorCj(), aula.UeId);
unitOfWork.IniciarTransacao();
foreach (var planoTurma in request.PlanoAulaMigrar.IdsPlanoTurmasDestino)
{
AulaConsultaDto aulaConsultaDto = await
mediator.Send(new ObterAulaDataTurmaDisciplinaQuery(
planoTurma.Data,
planoTurma.TurmaId,
request.PlanoAulaMigrar.DisciplinaId
));
if (aulaConsultaDto == null)
{
throw new NegocioException($"Não há aula cadastrada para a turma {planoTurma.TurmaId} para a data {planoTurma.Data.ToString("dd/MM/yyyy")} nesta disciplina!");
}
var planoCopia = new PlanoAulaDto()
{
Id = planoTurma.Sobreescrever ? request.PlanoAulaMigrar.PlanoAulaId : 0,
AulaId = aulaConsultaDto.Id,
Descricao = planoAulaDto.Descricao,
DesenvolvimentoAula = planoAulaDto.DesenvolvimentoAula,
LicaoCasa = request.PlanoAulaMigrar.MigrarLicaoCasa ? planoAulaDto.LicaoCasa : string.Empty,
ObjetivosAprendizagemComponente = !usuario.EhProfessorCj() ||
request.PlanoAulaMigrar.MigrarObjetivos ?
(await mediator.Send(new ObterObjetivosComComponentePorPlanoAulaIdQuery(request.PlanoAulaMigrar.PlanoAulaId)))?.ToList() : null,
RecuperacaoAula = request.PlanoAulaMigrar.MigrarRecuperacaoAula ?
planoAulaDto.RecuperacaoAula : string.Empty
};
await mediator.Send(new SalvarPlanoAulaCommand(planoCopia));
}
unitOfWork.PersistirTransacao();
return(true);
}
private async Task SalvarPlanoAula(PlanoAula planoAula, PlanoAulaDto planoAulaDto, long planoAnualId)
{
repositorio.Salvar(planoAula);
// Salvar Objetivos
await repositorioObjetivosAula.LimparObjetivosAula(planoAula.Id);
if (planoAulaDto.ObjetivosAprendizagemJurema != null)
{
foreach (var objetivoJuremaId in planoAulaDto.ObjetivosAprendizagemJurema)
{
var objetivoPlanoAnualId = await consultasObjetivoAprendizagem
.ObterIdPorObjetivoAprendizagemJurema(planoAnualId, objetivoJuremaId);
if (objetivoPlanoAnualId <= 0)
{
objetivoPlanoAnualId = await SalvarObjetivoPlanoAnual(objetivoJuremaId, planoAnualId);
}
repositorioObjetivosAula.Salvar(new ObjetivoAprendizagemAula(planoAula.Id, objetivoPlanoAnualId));
}
}
}
public async Task <IActionResult> Post(PlanoAulaDto planoAulaDto, [FromServices] ISalvarPlanoAulaUseCase useCase)
{
return(Ok(await useCase.Executar(planoAulaDto)));
}
public async Task Salvar(PlanoAulaDto planoAulaDto, bool controlarTransacao = true)
{
var aula = repositorioAula.ObterPorId(planoAulaDto.AulaId);
var abrangenciaTurma = await consultasAbrangencia.ObterAbrangenciaTurma(aula.TurmaId);
if (abrangenciaTurma == null)
{
throw new NegocioException("Usuario sem acesso a turma da respectiva aula");
}
var usuario = await servicoUsuario.ObterUsuarioLogado();
await VerificaSeProfessorPodePersistirTurmaDisciplina(usuario.CodigoRf, aula.TurmaId, aula.DisciplinaId, aula.DataAula, usuario);
PlanoAula planoAula = await repositorio.ObterPlanoAulaPorAula(planoAulaDto.AulaId);
planoAula = MapearParaDominio(planoAulaDto, planoAula);
if (planoAulaDto.ObjetivosAprendizagemJurema == null || !planoAulaDto.ObjetivosAprendizagemJurema.Any() && !planoAula.Migrado)
{
var permitePlanoSemObjetivos = false;
// Os seguintes componentes curriculares (disciplinas) não tem seleção de objetivos de aprendizagem
// Libras, Sala de Leitura
permitePlanoSemObjetivos = new string[] { "218", "1061" }.Contains(aula.DisciplinaId);
// EJA e Médio não obrigam seleção
if (!permitePlanoSemObjetivos)
{
permitePlanoSemObjetivos = new[] { Modalidade.EJA, Modalidade.Medio }.Contains(abrangenciaTurma.Modalidade);
}
// Para professores substitutos (CJ) a seleção dos objetivos deve ser opcional
if (!permitePlanoSemObjetivos)
{
permitePlanoSemObjetivos = usuario.EhProfessorCj();
}
// Caso a disciplina não possui vinculo com Jurema, os objetivos não devem ser exigidos
if (!permitePlanoSemObjetivos)
{
permitePlanoSemObjetivos = !(consultasObjetivoAprendizagem.DisciplinaPossuiObjetivosDeAprendizagem(Convert.ToInt64(aula.DisciplinaId)));
}
if (!permitePlanoSemObjetivos)
{
throw new NegocioException("A seleção de objetivos de aprendizagem é obrigatória para criação do plano de aula");
}
}
var bimestre = (aula.DataAula.Month + 2) / 3;
var planoAnualId = await consultasPlanoAnual.ObterIdPlanoAnualPorAnoEscolaBimestreETurma(
aula.DataAula.Year, aula.UeId, long.Parse(aula.TurmaId), bimestre, long.Parse(aula.DisciplinaId));
if (planoAnualId <= 0 && !usuario.PerfilAtual.Equals(Perfis.PERFIL_CJ))
{
throw new NegocioException("Não foi possível concluir o cadastro, pois não existe plano anual cadastrado");
}
if (controlarTransacao)
{
using (var transacao = unitOfWork.IniciarTransacao())
{
await SalvarPlanoAula(planoAula, planoAulaDto, planoAnualId);
unitOfWork.PersistirTransacao();
}
}
else
{
await SalvarPlanoAula(planoAula, planoAulaDto, planoAnualId);
}
}
public SalvarPlanoAulaCommand(PlanoAulaDto dto)
{
PlanoAula = dto;
}
public async Task <IActionResult> Post(PlanoAulaDto planoAulaDto, [FromServices] IComandosPlanoAula comandos)
{
await comandos.Salvar(planoAulaDto);
return(Ok());
}
