Ejemplo n.º 1
0
        private async Task <PeriodoEscolarDto> BuscaPeriodo(Turma turma, int bimestre)
        {
            var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, turma.ModalidadeCodigo == Modalidade.EJA?ModalidadeTipoCalendario.EJA : ModalidadeTipoCalendario.FundamentalMedio);

            PeriodoEscolarDto periodo = null;

            // Eja possui 2 calendarios por ano
            if (turma.ModalidadeCodigo == Modalidade.EJA)
            {
                if (turma.Semestre == 1)
                {
                    periodo = (await consultasPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id)).Periodos
                              .FirstOrDefault(p => p.Bimestre == bimestre && p.PeriodoInicio < new DateTime(turma.AnoLetivo, 6, 1));
                }
                else
                {
                    periodo = (await consultasPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id)).Periodos
                              .FirstOrDefault(p => p.Bimestre == bimestre && p.PeriodoFim > new DateTime(turma.AnoLetivo, 6, 1));
                }
            }
            else
            {
                periodo = (await consultasPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id)).Periodos
                          .FirstOrDefault(p => p.Bimestre == bimestre);
            }

            if (!await consultasTurma.TurmaEmPeriodoAberto(turma, DateTime.Today, bimestre, tipoCalendario: tipoCalendario))
            {
                throw new NegocioException($"Período do {bimestre}º Bimestre não está aberto.");
            }

            return(periodo);
        }
        private PeriodoEscolarDto BuscaPeriodo(int anoLetivo, Modalidade modalidadeCodigo, int bimestre, int semestre)
        {
            var tipoCalendario = repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(anoLetivo, modalidadeCodigo == Modalidade.EJA ? ModalidadeTipoCalendario.EJA : ModalidadeTipoCalendario.FundamentalMedio);

            PeriodoEscolarDto periodo = null;

            // Eja possui 2 calendarios por ano
            if (modalidadeCodigo == Modalidade.EJA)
            {
                if (semestre == 1)
                {
                    periodo = consultasPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id).Periodos
                              .FirstOrDefault(p => p.Bimestre == bimestre && p.PeriodoInicio < new DateTime(anoLetivo, 6, 1));
                }
                else
                {
                    periodo = consultasPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id).Periodos
                              .FirstOrDefault(p => p.Bimestre == bimestre && p.PeriodoFim > new DateTime(anoLetivo, 6, 1));
                }
            }
            else
            {
                periodo = consultasPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id).Periodos
                          .FirstOrDefault(p => p.Bimestre == bimestre);
            }

            // TODO alterar verificação para checagem de periodo de fechamento e reabertura do fechamento depois de implementado
            if (DateTime.Now < periodo.PeriodoInicio || DateTime.Now > periodo.PeriodoFim)
            {
                throw new NegocioException($"Período do {bimestre}º Bimestre não está aberto.");
            }

            return(periodo);
        }
Ejemplo n.º 3
0
        public async Task <IActionResult> Get(long codigoTipoCalendario, [FromServices] IConsultasPeriodoEscolar consultas)
        {
            var periodoEscolar = await consultas.ObterPorTipoCalendario(codigoTipoCalendario);

            if (periodoEscolar == null)
            {
                return(NoContent());
            }

            return(Ok(periodoEscolar));
        }
        public async Task <PlanoAulaRetornoDto> ObterPlanoAulaPorAula(long aulaId)
        {
            if (!await VerificarPlanoAnualExistente(aulaId))
            {
                throw new NegocioException("Não foi possível carregar o plano de aula porque não há plano anual cadastrado");
            }
            PlanoAulaRetornoDto planoAulaDto = new PlanoAulaRetornoDto();
            // Busca plano de aula por data e disciplina da aula
            var plano = await repositorio.ObterPlanoAulaPorAula(aulaId);

            var aulaDto = await consultasAula.BuscarPorId(aulaId);

            var atividadeAvaliativa = await repositorioAtividadeAvaliativa.ObterAtividadeAvaliativa(aulaDto.DataAula.Date, aulaDto.DisciplinaId, aulaDto.TurmaId, aulaDto.UeId);

            if (plano != null)
            {
                planoAulaDto = MapearParaDto(plano) ?? new PlanoAulaRetornoDto();

                // Carrega objetivos aprendizagem Jurema
                var planoAnual = await consultasPlanoAnual.ObterPorEscolaTurmaAnoEBimestre(new FiltroPlanoAnualDto()
                {
                    AnoLetivo = aulaDto.DataAula.Year,
                    Bimestre  = (aulaDto.DataAula.Month + 2) / 3,
                    ComponenteCurricularEolId = long.Parse(aulaDto.DisciplinaId),
                    EscolaId = aulaDto.UeId,
                    TurmaId  = aulaDto.TurmaId
                }, seNaoExistirRetornaNovo : false);

                // Carrega objetivos já cadastrados no plano de aula
                var objetivosAula = await consultasObjetivosAula.ObterObjetivosPlanoAula(plano.Id);

                if (planoAnual != null)
                {
                    // Filtra objetivos anual com os objetivos da aula
                    planoAulaDto.ObjetivosAprendizagemAula = planoAnual.ObjetivosAprendizagem
                                                             .Where(c => objetivosAula.Any(a => a.ObjetivoAprendizagemPlano.ObjetivoAprendizagemJuremaId == c.Id))
                                                             .ToList();
                }
            }
            var periodoEscolar = consultasPeriodoEscolar.ObterPorTipoCalendario(aulaDto.TipoCalendarioId);
            var periodo        = periodoEscolar.Periodos.FirstOrDefault(p => p.PeriodoInicio <= aulaDto.DataAula && p.PeriodoFim >= aulaDto.DataAula);
            var planoAnualId   = await consultasPlanoAnual.ObterIdPlanoAnualPorAnoEscolaBimestreETurma(
                aulaDto.DataAula.Year, aulaDto.UeId, long.Parse(aulaDto.TurmaId), periodo.Bimestre, long.Parse(aulaDto.DisciplinaId));

            // Carrega informações da aula para o retorno
            planoAulaDto.PossuiPlanoAnual      = planoAnualId > 0;
            planoAulaDto.AulaId                = aulaDto.Id;
            planoAulaDto.QtdAulas              = aulaDto.Quantidade;
            planoAulaDto.IdAtividadeAvaliativa = atividadeAvaliativa?.Id;
            planoAulaDto.PodeLancarNota        = planoAulaDto.IdAtividadeAvaliativa.HasValue && aulaDto.DataAula.Date <= DateTime.Now.Date;
            return(planoAulaDto);
        }
        private PeriodoEscolarDto BuscaPeriodo(int anoLetivo, Modalidade modalidadeCodigo, int bimestre, int semestre)
        {
            var tipoCalendario = consultasTipoCalendario.BuscarPorAnoLetivoEModalidade(anoLetivo, modalidadeCodigo == Modalidade.EJA ? ModalidadeTipoCalendario.EJA : ModalidadeTipoCalendario.FundamentalMedio);
            var periodo        = consultasPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id).Periodos.FirstOrDefault(p => p.Bimestre == bimestre);

            // TODO alterar verificação para checagem de periodo de fechamento e reabertura do fechamento depois de implementado
            if (DateTime.Now < periodo.PeriodoInicio || DateTime.Now > periodo.PeriodoFim)
            {
                throw new NegocioException($"Período do {bimestre}º Bimestre não está aberto");
            }

            return(periodo);
        }
Ejemplo n.º 6
0
        public async Task <IEnumerable <PeriodoEscolarAbertoDto> > PeriodosEmAbertoTurma(string turmaCodigo, DateTime dataReferencia, bool ehAnoLetivo = false)
        {
            var turma = await ObterComUeDrePorCodigo(turmaCodigo);

            if (turma == null)
            {
                throw new NegocioException($"Turma de código {turmaCodigo} não localizada!");
            }

            var tipoCalendario = await consultasTipoCalendario.ObterPorTurma(turma);

            var listaPeriodos = await consultasPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id);

            return(await ObterPeriodosEmAberto(turma, dataReferencia, listaPeriodos.Periodos, ehAnoLetivo));
        }
Ejemplo n.º 7
0
        public async Task <IEnumerable <DataAulasProfessorDto> > ObterDatasDeAulasPorCalendarioTurmaEDisciplina(int anoLetivo, string turmaCodigo, string disciplinaCodigo)
        {
            var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();

            var usuarioRF = usuarioLogado.EhProfessor() && !usuarioLogado.EhProfessorInfantil() ? usuarioLogado.CodigoRf : string.Empty;

            var turma = await repositorioTurma.ObterPorCodigo(turmaCodigo);

            if (turma == null)
            {
                throw new NegocioException("Turma não encontrada");
            }

            var tipoCalendario = await consultasTipoCalendario.BuscarPorAnoLetivoEModalidade(anoLetivo, turma.ModalidadeTipoCalendario, turma.Semestre);

            if (tipoCalendario == null)
            {
                throw new NegocioException("Tipo de calendário não existe para turma selecionada");
            }

            var periodosEscolares = await consultasPeriodoEscolar.ObterPorTipoCalendario(tipoCalendario.Id);

            return(await ObterAulasNosPeriodos(periodosEscolares, anoLetivo, turmaCodigo, disciplinaCodigo, usuarioLogado, usuarioRF));
        }
Ejemplo n.º 8
0
        public void Deve_Consultar_Periodo_Escolar()
        {
            repositorio.Setup(r => r.ObterPorTipoCalendario(It.IsAny <long>())).Returns(new List <PeriodoEscolar>());

            consultas.ObterPorTipoCalendario(1);
        }
Ejemplo n.º 9
0
        public async Task Deve_Consultar_Periodo_Escolar()
        {
            repositorio.Setup(r => r.ObterPorTipoCalendario(It.IsAny <long>())).ReturnsAsync(new List <PeriodoEscolar>());

            await consultas.ObterPorTipoCalendario(1);
        }