public async Task <int> ValidarAulasReposicaoPendente(long fechamentoId, Turma turma, long disciplinaId, DateTime inicioPeriodo, DateTime fimPeriodo)
        {
            var aulasPendentes = repositorioAula.ObterAulasReposicaoPendentes(turma.CodigoTurma, disciplinaId.ToString(), inicioPeriodo, fimPeriodo);

            if (aulasPendentes != null && aulasPendentes.Any())
            {
                var componenteCurricular = (await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { disciplinaId })).ToList()?.FirstOrDefault();
                if (componenteCurricular == null)
                {
                    throw new NegocioException("Componente curricular não encontrado.");
                }
                var mensagem = new StringBuilder($"A aulas de reposição de {componenteCurricular.Nome} da turma {turma.Nome} a seguir estão pendentes de aprovação:<br>");
                foreach (var aula in aulasPendentes.OrderBy(a => a.DataAula))
                {
                    var professor = servicoUsuario.ObterUsuarioPorCodigoRfLoginOuAdiciona(aula.ProfessorRf);
                    if (professor == null)
                    {
                        throw new NegocioException($"Professor com RF {aula.ProfessorRf} não encontrado.");
                    }
                    mensagem.AppendLine($"Professor { aula.ProfessorRf} - { professor.Nome}, dia {aula.DataAula.ToString("dd/MM/yyyy")}.<br>");
                }

                var professorRf = aulasPendentes.First().ProfessorRf;
                await GerarPendencia(fechamentoId, TipoPendencia.AulasReposicaoPendenteAprovacao, mensagem.ToString(), professorRf);
            }
            else
            {
                repositorioPendencia.AtualizarPendencias(fechamentoId, SituacaoPendencia.Resolvida, TipoPendencia.AulasReposicaoPendenteAprovacao);
            }

            aulasReposicaoPendentes = aulasPendentes.Count();
            return(aulasReposicaoPendentes);
        }
Esempio n. 2
0
        public async Task <IEnumerable <DisciplinaResposta> > ObterComponentesCJ(Modalidade?modalidade, string codigoTurma, string ueId, long codigoDisciplina, string rf, bool ignorarDeParaRegencia = false)
        {
            IEnumerable <DisciplinaResposta> componentes = null;
            var atribuicoes = await repositorioAtribuicaoCJ.ObterPorFiltros(modalidade,
                                                                            codigoTurma,
                                                                            ueId,
                                                                            codigoDisciplina,
                                                                            rf,
                                                                            string.Empty,
                                                                            true);

            if (atribuicoes == null || !atribuicoes.Any())
            {
                return(null);
            }

            var disciplinasEol = await repositorioComponenteCurricular.ObterDisciplinasPorIds(atribuicoes.Select(a => a.DisciplinaId).Distinct().ToArray());

            var componenteRegencia = disciplinasEol?.FirstOrDefault(c => c.Regencia);

            if (componenteRegencia == null || ignorarDeParaRegencia)
            {
                return(TransformarListaDisciplinaEolParaRetornoDto(disciplinasEol));
            }

            var componentesRegencia = await repositorioComponenteCurricular.ObterDisciplinasPorIds(IDS_COMPONENTES_REGENCIA);

            if (componentesRegencia != null)
            {
                return(TransformarListaDisciplinaEolParaRetornoDto(componentesRegencia));
            }

            return(componentes);
        }
Esempio n. 3
0
        public async Task <IEnumerable <AlunoAusenteDto> > ObterListaAlunosComAusencia(string turmaId, string disciplinaId, int bimestre)
        {
            var alunosAusentesDto = new List <AlunoAusenteDto>();
            // Busca dados da turma
            var turma = await BuscaTurma(turmaId);

            // Busca periodo
            var periodo = await BuscaPeriodo(turma, bimestre);

            var alunosEOL = await servicoEOL.ObterAlunosPorTurma(turmaId);

            if (alunosEOL == null || !alunosEOL.Any())
            {
                throw new NegocioException("Não foram localizados alunos para a turma selecionada.");
            }

            var disciplinasEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { long.Parse(disciplinaId) });

            if (disciplinasEOL == null || !disciplinasEOL.Any())
            {
                throw new NegocioException("Disciplina informada não localizada no EOL.");
            }

            var quantidadeMaximaCompensacoes = int.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(TipoParametroSistema.QuantidadeMaximaCompensacaoAusencia, DateTime.Today.Year)));
            var percentualFrequenciaAlerta   = int.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(disciplinasEOL.First().Regencia ? TipoParametroSistema.CompensacaoAusenciaPercentualRegenciaClasse : TipoParametroSistema.CompensacaoAusenciaPercentualFund2, DateTime.Today.Year)));

            foreach (var alunoEOL in alunosEOL)
            {
                var frequenciaAluno = repositorioFrequenciaAlunoDisciplinaPeriodo.ObterPorAlunoDisciplinaData(alunoEOL.CodigoAluno, disciplinaId, periodo.PeriodoFim);
                if (frequenciaAluno == null || frequenciaAluno.NumeroFaltasNaoCompensadas == 0)
                {
                    continue;
                }

                var faltasNaoCompensadas = int.Parse(frequenciaAluno.NumeroFaltasNaoCompensadas.ToString());

                alunosAusentesDto.Add(new AlunoAusenteDto()
                {
                    Id   = alunoEOL.CodigoAluno,
                    Nome = alunoEOL.NomeAluno,
                    QuantidadeFaltasTotais       = faltasNaoCompensadas,
                    MaximoCompensacoesPermitidas = quantidadeMaximaCompensacoes > faltasNaoCompensadas ? faltasNaoCompensadas : quantidadeMaximaCompensacoes,
                    PercentualFrequencia         = frequenciaAluno.PercentualFrequencia,
                    Alerta = frequenciaAluno.PercentualFrequencia <= percentualFrequenciaAlerta
                });
            }

            return(alunosAusentesDto);
        }
Esempio n. 4
0
        private async Task <DisciplinaDto> ObterDisciplina(long idDisciplina)
        {
            long[] disciplinaId = { idDisciplina };
            var    disciplina   = await repositorioComponenteCurricular.ObterDisciplinasPorIds(disciplinaId);

            if (!disciplina.Any())
            {
                throw new NegocioException("Disciplina não encontrada no EOL.");
            }
            return(disciplina.FirstOrDefault());
        }
 public async Task <IEnumerable <DisciplinaDto> > Handle(ObterComponentesCurricularesPorIdsQuery request, CancellationToken cancellationToken)
 {
     if (request.PossuiTerritorio.HasValue && request.PossuiTerritorio.Value)
     {
         return(await servicoEol.ObterDisciplinasPorIdsAgrupadas(request.Ids));
     }
     else
     {
         return(await repositorioComponenteCurricular.ObterDisciplinasPorIds(request.Ids));
     }
 }
Esempio n. 6
0
        public async Task <PaginacaoResultadoDto <PendenciaFechamentoResumoDto> > Listar(FiltroPendenciasFechamentosDto filtro)
        {
            var retornoConsultaPaginada = await repositorioPendenciaFechamento.ListarPaginada(Paginacao, filtro.TurmaCodigo, filtro.Bimestre, filtro.ComponenteCurricularId);

            if (retornoConsultaPaginada.Items != null && retornoConsultaPaginada.Items.Any())
            {
                // Atualiza nome da situacao
                retornoConsultaPaginada.Items.ToList()
                .ForEach(i => i.SituacaoNome = Enum.GetName(typeof(SituacaoPendencia), i.Situacao));

                // Carrega nomes das disciplinas para o DTO de retorno
                var disciplinasEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(retornoConsultaPaginada.Items.Select(a => a.DisciplinaId).Distinct().ToArray());

                foreach (var disciplinaEOL in disciplinasEOL)
                {
                    retornoConsultaPaginada.Items.Where(c => c.DisciplinaId == disciplinaEOL.CodigoComponenteCurricular).ToList()
                    .ForEach(d => d.ComponenteCurricular = disciplinaEOL.Nome);
                }
            }

            return(retornoConsultaPaginada);
        }
Esempio n. 7
0
        public async Task Reprocessar(long fechamentoTurmaDisciplinaId)
        {
            var fechamentoTurmaDisciplina = repositorioFechamentoTurmaDisciplina.ObterPorId(fechamentoTurmaDisciplinaId);

            if (fechamentoTurmaDisciplina == null)
            {
                throw new NegocioException("Fechamento ainda não realizado para essa turma.");
            }

            var turma = await repositorioTurma.ObterTurmaComUeEDrePorId(fechamentoTurmaDisciplina.FechamentoTurma.TurmaId);

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

            var disciplinaEOL = (await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { fechamentoTurmaDisciplina.DisciplinaId })).ToList().FirstOrDefault();

            if (disciplinaEOL == null)
            {
                throw new NegocioException("Componente Curricular não localizado.");
            }

            var periodoEscolar = repositorioPeriodoEscolar.ObterPorId(fechamentoTurmaDisciplina.FechamentoTurma.PeriodoEscolarId.Value);

            if (periodoEscolar == null)
            {
                throw new NegocioException("Período escolar não encontrado.");
            }

            fechamentoTurmaDisciplina.AdicionarPeriodoEscolar(periodoEscolar);
            fechamentoTurmaDisciplina.AtualizarSituacao(SituacaoFechamento.EmProcessamento);
            repositorioFechamentoTurmaDisciplina.Salvar(fechamentoTurmaDisciplina);

            var usuarioLogado = await servicoUsuario.ObterUsuarioLogado();

            Cliente.Executar <IServicoFechamentoTurmaDisciplina>(c => c.GerarPendenciasFechamento(fechamentoTurmaDisciplina.DisciplinaId, turma, periodoEscolar, fechamentoTurmaDisciplina, usuarioLogado, !disciplinaEOL.LancaNota, disciplinaEOL.RegistraFrequencia));
        }
        public async Task <IEnumerable <ComponenteCurricularEol> > Handle(ObterComponentesCJQuery request, CancellationToken cancellationToken)
        {
            var atribuicoes = await repositorioAtribuicaoCJ.ObterPorFiltros(request.Modalidade,
                                                                            request.TurmaCodigo,
                                                                            request.UeCodigo,
                                                                            request.ComponenteCurricular,
                                                                            request.ProfessorRf,
                                                                            string.Empty,
                                                                            true);

            if (atribuicoes == null || !atribuicoes.Any())
            {
                return(null);
            }

            var disciplinasEol = await repositorioComponenteCurricular.ObterDisciplinasPorIds(atribuicoes.Select(a => a.DisciplinaId).Distinct().ToArray());

            IEnumerable <ComponenteCurricularEol> componentes = null;

            var componenteRegencia = disciplinasEol?.FirstOrDefault(c => c.Regencia);

            if (request.ListarComponentesPlanejamento && componenteRegencia != null)
            {
                var componentesRegencia = await repositorioComponenteCurricular.ObterDisciplinasPorIds(IDS_COMPONENTES_REGENCIA);

                if (componentesRegencia != null)
                {
                    componentes = TransformarListaDisciplinaEolParaRetornoDto(componentesRegencia);
                }
            }
            else
            {
                componentes = TransformarListaDisciplinaEolParaRetornoDto(disciplinasEol);
            }
            return(componentes);
        }
Esempio n. 9
0
        private async Task ValidaComponentesCurricularesQueNaoPodemSerSubstituidos(AtribuicaoCJ atribuicaoCJ)
        {
            if (componentesQueNaoPodemSerSubstituidos.Any(a => a == atribuicaoCJ.DisciplinaId))
            {
                var nomeComponenteCurricular = await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { atribuicaoCJ.DisciplinaId });

                if (nomeComponenteCurricular != null && nomeComponenteCurricular.Any())
                {
                    throw new NegocioException($"O componente curricular {nomeComponenteCurricular.FirstOrDefault().Nome} não pode ser substituido.");
                }
                else
                {
                    throw new NegocioException($"Não foi possível localizar o nome do componente curricular de identificador {atribuicaoCJ.DisciplinaId} no EOL.");
                }
            }
        }
Esempio n. 10
0
        private async Task ConsisteDisciplina(long disciplinaId, IEnumerable <string> disciplinasRegenciaIds, bool registroMigrado)
        {
            var disciplinasEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { disciplinaId });

            if (!disciplinasEOL.Any())
            {
                throw new NegocioException("Disciplina não encontrada no EOL.");
            }

            var disciplina = disciplinasEOL.FirstOrDefault();

            if (!registroMigrado && disciplina.Regencia && ((disciplinasRegenciaIds == null) || !disciplinasRegenciaIds.Any()))
            {
                throw new NegocioException("Regência de classe deve informar a(s) disciplina(s) relacionadas a esta atividade.");
            }
        }
        private async Task <IEnumerable <AtribuicaoCJListaRetornoDto> > TransformaEntidadesEmDtosListaRetorno(IEnumerable <AtribuicaoCJ> listaDto)
        {
            var idsDisciplinas = listaDto
                                 .Select(a => a.DisciplinaId)
                                 .Distinct <long>()
                                 .ToArray();

            var disciplinasEol = await repositorioComponenteCurricular.ObterDisciplinasPorIds(idsDisciplinas);

            if (!disciplinasEol.Any())
            {
                throw new NegocioException("Não foi possível obter as descrições das disciplinas no Eol.");
            }

            var professoresDisciplinas = listaDto
                                         .GroupBy(a => new { a.ProfessorRf, a.Modalidade, a.TurmaId, a.UeId }).ToList();

            var listRetorno = new List <AtribuicaoCJListaRetornoDto>();

            professoresDisciplinas.ForEach(a =>
            {
                var disciplinasIds = a.Select(b => b.DisciplinaId);

                var disciplinasDescricoes = disciplinasEol
                                            .Where(c => disciplinasIds.Contains(c.CodigoComponenteCurricular))
                                            .ToList();

                var professorDisciplina = a.FirstOrDefault();

                var atribuicaoDto = new AtribuicaoCJListaRetornoDto()
                {
                    Modalidade   = a.Key.Modalidade.GetAttribute <DisplayAttribute>().Name,
                    ModalidadeId = (int)a.Key.Modalidade,
                    Turma        = professorDisciplina.Turma.Nome,
                    TurmaId      = professorDisciplina.TurmaId,
                    Disciplinas  = disciplinasDescricoes.Select(d => d.Nome).ToArray()
                };

                listRetorno.Add(atribuicaoDto);
            });

            return(listRetorno);
        }
Esempio n. 12
0
        public async Task <CompensacaoAusenciaCompletoDto> ObterPorId(long id)
        {
            var compensacao = repositorioCompensacaoAusencia.ObterPorId(id);

            if (compensacao == null)
            {
                throw new NegocioException("Compensação de ausencia não localizada.");
            }

            var compensacaoDto = MapearParaDtoCompleto(compensacao);

            compensacao.Alunos = await consultasCompensacaoAusenciaAluno.ObterPorCompensacao(compensacao.Id);

            // Busca os nomes de alunos do EOL por turma
            var turma = await repositorioTurma.ObterPorId(compensacao.TurmaId);

            compensacaoDto.TurmaId = turma.CodigoTurma;

            var alunos = await servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma);

            if (alunos == null)
            {
                throw new NegocioException("Alunos não localizados para a turma.");
            }

            var disciplinasEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { long.Parse(compensacao.DisciplinaId) });

            if (disciplinasEOL == null || !disciplinasEOL.Any())
            {
                throw new NegocioException("Disciplina informada na compensação não localizada no EOL.");
            }

            var quantidadeMaximaCompensacoes = int.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(TipoParametroSistema.QuantidadeMaximaCompensacaoAusencia, DateTime.Today.Year)));
            var percentualFrequenciaAlerta   = int.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(disciplinasEOL.First().Regencia ? TipoParametroSistema.CompensacaoAusenciaPercentualRegenciaClasse : TipoParametroSistema.CompensacaoAusenciaPercentualFund2, DateTime.Today.Year)));

            foreach (var aluno in compensacao.Alunos)
            {
                // Adiciona nome do aluno no Dto de retorno
                var alunoEol = alunos.FirstOrDefault(a => a.CodigoAluno == aluno.CodigoAluno);
                if (alunoEol != null)
                {
                    var alunoDto = MapearParaDtoAlunos(aluno);
                    alunoDto.Nome = alunoEol.NomeAluno;

                    var frequenciaAluno = consultasFrequencia.ObterPorAlunoDisciplinaData(aluno.CodigoAluno, compensacao.DisciplinaId, DateTime.Now);
                    if (frequenciaAluno != null)
                    {
                        alunoDto.QuantidadeFaltasTotais       = int.Parse((frequenciaAluno.NumeroFaltasNaoCompensadas + alunoDto.QuantidadeFaltasCompensadas).ToString());
                        alunoDto.PercentualFrequencia         = frequenciaAluno.PercentualFrequencia;
                        alunoDto.MaximoCompensacoesPermitidas = quantidadeMaximaCompensacoes > alunoDto.QuantidadeFaltasTotais ? alunoDto.QuantidadeFaltasTotais : quantidadeMaximaCompensacoes;
                        alunoDto.Alerta = frequenciaAluno.PercentualFrequencia <= percentualFrequenciaAlerta;
                    }
                    else
                    {
                        alunoDto.PercentualFrequencia = 100;
                    }

                    compensacaoDto.Alunos.Add(alunoDto);
                }
            }

            if (disciplinasEOL.First().Regencia)
            {
                var disciplinasRegencia = await consultasCompensacaoAusenciaDisciplinaRegencia.ObterPorCompensacao(compensacao.Id);

                var disciplinasIds = disciplinasRegencia.Select(x => long.Parse(x.DisciplinaId));

                if (!disciplinasIds.Any())
                {
                    return(compensacaoDto);
                }

                disciplinasEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(disciplinasIds.ToArray());

                foreach (var disciplinaEOL in disciplinasEOL)
                {
                    compensacaoDto.DisciplinasRegencia.Add(new DisciplinaNomeDto()
                    {
                        Codigo = disciplinaEOL.CodigoComponenteCurricular.ToString(),
                        Nome   = disciplinaEOL.Nome
                    });
                }
            }

            return(compensacaoDto);
        }
        public async Task <DiaEventoAula> ObterEventoAulasDia(FiltroEventosAulasCalendarioDiaDto filtro)
        {
            List <EventosAulasTipoDiaDto> eventosAulas = new List <EventosAulasTipoDiaDto>();

            if (!filtro.TodasTurmas && string.IsNullOrWhiteSpace(filtro.TurmaId))
            {
                throw new NegocioException("É necessario informar uma turma para pesquisa");
            }

            var temTurmaInformada = !string.IsNullOrEmpty(filtro.TurmaId);
            var data = filtro.Data.Date;

            var perfil = servicoUsuario.ObterPerfilAtual();

            var usuario = await servicoUsuario.ObterUsuarioLogado();

            string rf = usuario.TemPerfilGestaoUes() ? string.Empty : usuario.CodigoRf;

            var disciplinasUsuario = usuario.EhProfessorCj() ?
                                     await consultasDisciplina.ObterDisciplinasPerfilCJ(filtro.TurmaId, usuario.CodigoRf) :
                                     await servicoEOL.ObterDisciplinasPorCodigoTurmaLoginEPerfil(filtro.TurmaId, usuario.CodigoRf, usuario.PerfilAtual);

            var eventos = await repositorioEvento.ObterEventosPorTipoDeCalendarioDreUeDia(filtro.TipoCalendarioId, filtro.DreId, filtro.UeId, data, filtro.EhEventoSme, usuario.PodeVisualizarEventosLibExcepRepoRecessoGestoresUeDreSme());

            var aulas = await ObterAulasDia(filtro, data, perfil, rf, disciplinasUsuario);

            var atividades = await repositorioAtividadeAvaliativa.ObterAtividadesPorDia(filtro.DreId, filtro.UeId, data, rf, filtro.TurmaId);

            ObterEventosParaEventosAulasDia(eventosAulas, eventos);

            var turmasAulas = aulas.GroupBy(x => x.TurmaId).Select(x => x.Key);

            var turmasAbrangencia = await ObterTurmasAbrangencia(turmasAulas, filtro.TurmaHistorico);

            var idsDisciplinasAulas = aulas.Select(a => long.Parse(a.DisciplinaId)).Distinct().ToList();

            var idsDisciplinasCompartilhadas = aulas.Where(a => !String.IsNullOrEmpty(a.DisciplinaCompartilhadaId) && !a.DisciplinaCompartilhadaId.Equals("null"))
                                               .Select(a => long.Parse(a.DisciplinaCompartilhadaId)).Distinct();

            if (idsDisciplinasCompartilhadas != null && idsDisciplinasCompartilhadas.Any())
            {
                idsDisciplinasAulas.AddRange(idsDisciplinasCompartilhadas);
            }

            IEnumerable <DisciplinaDto> disciplinasEol = new List <DisciplinaDto>();

            if (idsDisciplinasAulas != null && idsDisciplinasAulas.Any())
            {
                disciplinasEol = await repositorioComponenteCurricular.ObterDisciplinasPorIds(idsDisciplinasAulas.ToArray());
            }

            aulas
            .ToList()
            .ForEach(x =>
            {
                bool podeCriarAtividade = true;
                var listaAtividades     = atividades.Where(w => w.DataAvaliacao.Date == x.DataAula.Date && w.TurmaId == x.TurmaId &&
                                                           PossuiDisciplinas(w.Id, x.DisciplinaId)).ToList();
                var disciplina = disciplinasEol?.FirstOrDefault(d => d.CodigoComponenteCurricular.ToString().Equals(x.DisciplinaId));
                var disciplinaCompartilhada = disciplinasEol?.FirstOrDefault(d => d.CodigoComponenteCurricular.ToString().Equals(x.DisciplinaCompartilhadaId));
                if (atividades != null && disciplina != null)
                {
                    foreach (var item in listaAtividades)
                    {
                        if (disciplina.Regencia)
                        {
                            var disciplinasRegenciasComAtividades = repositorioAtividadeAvaliativaRegencia.Listar(item.Id).Result;

                            disciplinasRegenciasComAtividades.ToList().ForEach(async r => r.DisciplinaContidaRegenciaNome = (await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { Convert.ToInt64(r.DisciplinaContidaRegenciaId) })).ToList().FirstOrDefault().Nome);

                            item.AtividadeAvaliativaRegencia = new List <AtividadeAvaliativaRegencia>();
                            item.AtividadeAvaliativaRegencia.AddRange(disciplinasRegenciasComAtividades);
                            podeCriarAtividade = true;
                        }
                        else
                        {
                            podeCriarAtividade = false;
                        }
                    }
                }

                var turma = turmasAbrangencia.FirstOrDefault(t => t.CodigoTurma.Equals(x.TurmaId));

                eventosAulas.Add(new EventosAulasTipoDiaDto
                {
                    Id         = x.Id,
                    TipoEvento = x.AulaCJ ? "CJ" : "Aula",
                    DadosAula  = new DadosAulaDto
                    {
                        DisciplinaId = disciplina?.CodigoComponenteCurricular ?? null,
                        Disciplina   = $"{(disciplina?.Nome ?? "Disciplina não encontrada")} {(x.TipoAula == TipoAula.Reposicao ? "(Reposição)" : "")} {(x.Status == EntidadeStatus.AguardandoAprovacao ? "- Aguardando aprovação" : "")}",
                        DisciplinaCompartilhadaId = disciplinaCompartilhada?.CodigoComponenteCurricular ?? null,
                        DisciplinaCompartilhada   = $"{(disciplinaCompartilhada?.Nome ?? "Disciplina não encontrada")} ",
                        EhRegencia                = disciplina.Regencia,
                        EhCompartilhada           = disciplina.Compartilhada,
                        PermiteRegistroFrequencia = disciplina.RegistraFrequencia && !x.SomenteConsulta,
                        PodeCadastrarAvaliacao    = podeCriarAtividade,
                        Horario        = x.DataAula.ToString("hh:mm tt", CultureInfo.InvariantCulture),
                        Modalidade     = turma?.Modalidade.GetAttribute <DisplayAttribute>().Name ?? "Modalidade",
                        Tipo           = turma?.TipoEscola.GetAttribute <DisplayAttribute>().ShortName ?? "Escola",
                        Turma          = x.TurmaNome,
                        DentroPeriodo  = x.DentroPeriodo,
                        UnidadeEscolar = x.UeNome,
                        Atividade      = listaAtividades
                    }
                });
            });

            var dentroDoPeriodo = await consultasAula.AulaDentroPeriodo(filtro.TurmaId, filtro.Data) || await PodeCriarAulaNoPeriodo(filtro.Data, filtro.TipoCalendarioId, filtro.UeId, filtro.DreId);

            return(new DiaEventoAula
            {
                EventosAulas = eventosAulas,
                Letivo = comandosDiasLetivos.VerificarSeDataLetiva(eventos, data),
                DentroPeriodo = dentroDoPeriodo
            });
        }
        public async Task <NotasConceitosRetornoDto> ListarNotasConceitos(ListaNotasConceitosConsultaDto filtro)
        {
            var modalidadeTipoCalendario = ObterModalidadeCalendario(filtro.Modalidade);

            var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(filtro.AnoLetivo, modalidadeTipoCalendario, filtro.Semestre);

            if (tipoCalendario == null)
            {
                throw new NegocioException("Não foi encontrado tipo de calendário escolar, para a modalidade informada.");
            }

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

            if (periodosEscolares == null || !periodosEscolares.Any())
            {
                throw new NegocioException("Não foi encontrado período Escolar para a modalidade informada.");
            }

            var bimestre = filtro.Bimestre;

            if (!bimestre.HasValue || bimestre == 0)
            {
                bimestre = ObterBimestreAtual(periodosEscolares);
            }

            var periodoAtual = periodosEscolares.FirstOrDefault(x => x.Bimestre == bimestre);

            if (periodoAtual == null)
            {
                throw new NegocioException("Não foi encontrado período escolar para o bimestre solicitado.");
            }

            List <AtividadeAvaliativa> atividadesAvaliativaEBimestres = new List <AtividadeAvaliativa>();
            // Carrega disciplinas filhas da disciplina passada como parametro
            var disciplinasProfessor = await consultasDisciplina.ObterComponentesCurricularesPorProfessorETurma(filtro.TurmaCodigo, true);

            var disciplinasFilha = disciplinasProfessor.Where(d => d.CdComponenteCurricularPai == long.Parse(filtro.DisciplinaCodigo));

            if (disciplinasFilha.Any())
            {
                foreach (var disciplinaFilha in disciplinasFilha)
                {
                    atividadesAvaliativaEBimestres.AddRange(await consultasAtividadeAvaliativa.ObterAvaliacoesNoBimestre(filtro.TurmaCodigo, disciplinaFilha.CodigoComponenteCurricular.ToString(), periodoAtual.PeriodoInicio, periodoAtual.PeriodoFim));
                }
            }
            else
            {
                // Disciplina não tem disciplinas filhas então carrega avaliações da propria
                atividadesAvaliativaEBimestres.AddRange(await consultasAtividadeAvaliativa.ObterAvaliacoesNoBimestre(filtro.TurmaCodigo, filtro.DisciplinaCodigo, periodoAtual.PeriodoInicio, periodoAtual.PeriodoFim));
            }

            if (atividadesAvaliativaEBimestres is null || !atividadesAvaliativaEBimestres.Any())
            {
                return(ObterRetornoGenericoBimestreAtualVazio(periodosEscolares, bimestre.Value));
            }

            var alunos = await servicoEOL.ObterAlunosPorTurma(filtro.TurmaCodigo);

            if (alunos == null || !alunos.Any())
            {
                throw new NegocioException("Não foi encontrado alunos para a turma informada");
            }

            var retorno = new NotasConceitosRetornoDto();

            var tipoAvaliacaoBimestral = await repositorioTipoAvaliacao.ObterTipoAvaliacaoBimestral();

            retorno.BimestreAtual                 = bimestre.Value;
            retorno.MediaAprovacaoBimestre        = double.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(TipoParametroSistema.MediaBimestre, DateTime.Today.Year)));
            retorno.MinimoAvaliacoesBimestrais    = tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre;
            retorno.PercentualAlunosInsuficientes = double.Parse(await mediator.Send(new ObterValorParametroSistemaTipoEAnoQuery(TipoParametroSistema.PercentualAlunosInsuficientes, DateTime.Today.Year)));

            DateTime?dataUltimaNotaConceitoInserida      = null;
            DateTime?dataUltimaNotaConceitoAlterada      = null;
            var      usuarioRfUltimaNotaConceitoInserida = string.Empty;
            var      usuarioRfUltimaNotaConceitoAlterada = string.Empty;
            var      nomeAvaliacaoAuditoriaInclusao      = string.Empty;
            var      nomeAvaliacaoAuditoriaAlteracao     = string.Empty;

            foreach (var periodoEscolar in periodosEscolares)
            {
                AtividadeAvaliativa atividadeAvaliativaParaObterTipoNota = null;
                var valorBimestreAtual    = periodoEscolar.Bimestre;
                var bimestreParaAdicionar = new NotasConceitosBimestreRetornoDto()
                {
                    Descricao     = $"{valorBimestreAtual}º Bimestre",
                    Numero        = valorBimestreAtual,
                    PeriodoInicio = periodoEscolar.PeriodoInicio,
                    PeriodoFim    = periodoEscolar.PeriodoFim
                };

                if (valorBimestreAtual == periodoAtual.Bimestre)
                {
                    var listaAlunosDoBimestre = new List <NotasConceitosAlunoRetornoDto>();

                    var atividadesAvaliativasdoBimestre = atividadesAvaliativaEBimestres
                                                          .Where(a => a.DataAvaliacao.Date >= periodoAtual.PeriodoInicio.Date && periodoAtual.PeriodoFim.Date >= a.DataAvaliacao.Date)
                                                          .OrderBy(a => a.DataAvaliacao)
                                                          .ToList();

                    var alunosIds = alunos.Select(a => a.CodigoAluno).Distinct();
                    var notas     = repositorioNotasConceitos
                                    .ObterNotasPorAlunosAtividadesAvaliativas(atividadesAvaliativasdoBimestre.Select(a => a.Id).Distinct(), alunosIds, filtro.DisciplinaCodigo);

                    var ausenciasAtividadesAvaliativas = await repositorioFrequencia
                                                         .ObterAusencias(filtro.TurmaCodigo, filtro.DisciplinaCodigo, atividadesAvaliativasdoBimestre.Select(a => a.DataAvaliacao).Distinct().ToArray(), alunosIds.ToArray());

                    var consultaEOL = await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { long.Parse(filtro.DisciplinaCodigo) });

                    if (consultaEOL == null || !consultaEOL.Any())
                    {
                        throw new NegocioException("Disciplina informada não encontrada no EOL");
                    }
                    var disciplinaEOL = consultaEOL.First();

                    IEnumerable <DisciplinaResposta> disciplinasRegencia = null;

                    if (disciplinaEOL.Regencia)
                    {
                        disciplinasRegencia = await servicoEOL.ObterDisciplinasParaPlanejamento(long.Parse(filtro.TurmaCodigo), servicoUsuario.ObterLoginAtual(), servicoUsuario.ObterPerfilAtual());
                    }

                    var fechamentosTurma = await consultasFechamentoTurmaDisciplina.ObterFechamentosTurmaDisciplina(filtro.TurmaCodigo, filtro.DisciplinaCodigo, valorBimestreAtual);

                    var alunosForeach = from a in alunos
                                        where (a.EstaAtivo(periodoAtual.PeriodoFim)) ||
                                        (a.EstaInativo(periodoAtual.PeriodoFim) && a.DataSituacao.Date >= periodoAtual.PeriodoInicio.Date)
                                        orderby a.NomeValido(), a.NumeroAlunoChamada

                    select a;

                    foreach (var aluno in alunosForeach)
                    {
                        var notaConceitoAluno = new NotasConceitosAlunoRetornoDto()
                        {
                            Id            = aluno.CodigoAluno,
                            Nome          = aluno.NomeValido(),
                            NumeroChamada = aluno.NumeroAlunoChamada
                        };
                        var notasAvaliacoes = new List <NotasConceitosNotaAvaliacaoRetornoDto>();

                        foreach (var atividadeAvaliativa in atividadesAvaliativasdoBimestre)
                        {
                            var notaDoAluno        = ObterNotaParaVisualizacao(notas, aluno, atividadeAvaliativa);
                            var notaParaVisualizar = string.Empty;

                            if (notaDoAluno != null)
                            {
                                notaParaVisualizar = notaDoAluno.ObterNota();

                                if (!dataUltimaNotaConceitoInserida.HasValue || notaDoAluno.CriadoEm > dataUltimaNotaConceitoInserida.Value)
                                {
                                    usuarioRfUltimaNotaConceitoInserida = $"{notaDoAluno.CriadoPor}({notaDoAluno.CriadoRF})";
                                    dataUltimaNotaConceitoInserida      = notaDoAluno.CriadoEm;
                                    nomeAvaliacaoAuditoriaInclusao      = atividadeAvaliativa.NomeAvaliacao;
                                }

                                if (notaDoAluno.AlteradoEm.HasValue && (!dataUltimaNotaConceitoAlterada.HasValue || notaDoAluno.AlteradoEm.Value > dataUltimaNotaConceitoAlterada.Value))
                                {
                                    usuarioRfUltimaNotaConceitoAlterada = $"{notaDoAluno.AlteradoPor}({notaDoAluno.AlteradoRF})";
                                    dataUltimaNotaConceitoAlterada      = notaDoAluno.AlteradoEm;
                                    nomeAvaliacaoAuditoriaAlteracao     = atividadeAvaliativa.NomeAvaliacao;
                                }
                            }

                            var ausente       = ausenciasAtividadesAvaliativas.Any(a => a.AlunoCodigo == aluno.CodigoAluno && a.AulaData.Date == atividadeAvaliativa.DataAvaliacao.Date);
                            var notaAvaliacao = new NotasConceitosNotaAvaliacaoRetornoDto()
                            {
                                AtividadeAvaliativaId = atividadeAvaliativa.Id,
                                NotaConceito          = notaParaVisualizar,
                                Ausente    = ausente,
                                PodeEditar = aluno.EstaAtivo(atividadeAvaliativa.DataAvaliacao) ||
                                             (aluno.EstaInativo(atividadeAvaliativa.DataAvaliacao) && atividadeAvaliativa.DataAvaliacao.Date <= aluno.DataSituacao.Date)
                            };
                            notasAvaliacoes.Add(notaAvaliacao);
                        }

                        notaConceitoAluno.PodeEditar = notasAvaliacoes.Any(na => na.PodeEditar);

                        notaConceitoAluno.Marcador = servicoAluno.ObterMarcadorAluno(aluno, new PeriodoEscolar()
                        {
                            Bimestre      = valorBimestreAtual,
                            PeriodoInicio = periodoAtual.PeriodoInicio,
                            PeriodoFim    = periodoAtual.PeriodoFim
                        });

                        notaConceitoAluno.NotasAvaliacoes = notasAvaliacoes;

                        var fechamentoTurma = (from ft in fechamentosTurma
                                               from fa in ft.FechamentoAlunos
                                               where fa.AlunoCodigo.Equals(aluno.CodigoAluno)
                                               select ft).FirstOrDefault();

                        // Carrega Notas do Bimestre
                        if (fechamentoTurma != null)
                        {
                            bimestreParaAdicionar.FechamentoTurmaId = fechamentoTurma.Id;
                            bimestreParaAdicionar.Situacao          = fechamentoTurma.Situacao;

                            retorno.AuditoriaBimestreInserido = $"Nota final do bimestre inserida por {fechamentoTurma.CriadoPor}({fechamentoTurma.CriadoRF}) em {fechamentoTurma.CriadoEm.ToString("dd/MM/yyyy")}, às {fechamentoTurma.CriadoEm.ToString("HH:mm")}.";
                            if (fechamentoTurma.AlteradoEm.HasValue)
                            {
                                retorno.AuditoriaBimestreAlterado = $"Nota final do bimestre alterada por {fechamentoTurma.AlteradoPor}({fechamentoTurma.CriadoRF}) em {fechamentoTurma.AlteradoEm.Value.ToString("dd/MM/yyyy")}, às {fechamentoTurma.AlteradoEm.Value.ToString("HH:mm")}.";
                            }

                            var notasConceitoBimestre = await consultasFechamentoTurmaDisciplina.ObterNotasBimestre(aluno.CodigoAluno, fechamentoTurma.Id);

                            if (disciplinaEOL.Regencia)
                            {
                                // Regencia carrega disciplinas mesmo sem nota de fechamento
                                foreach (var disciplinaRegencia in disciplinasRegencia)
                                {
                                    var nota = new FechamentoNotaRetornoDto()
                                    {
                                        DisciplinaId = disciplinaRegencia.CodigoComponenteCurricular,
                                        Disciplina   = disciplinaRegencia.Nome,
                                    };
                                    var notaRegencia = notasConceitoBimestre?.FirstOrDefault(c => c.DisciplinaId == disciplinaRegencia.CodigoComponenteCurricular);
                                    if (notaRegencia != null)
                                    {
                                        nota.NotaConceito = (notaRegencia.ConceitoId.HasValue ? notaRegencia.ConceitoId.Value : notaRegencia.Nota);
                                        nota.EhConceito   = notaRegencia.ConceitoId.HasValue;
                                    }

                                    notaConceitoAluno.NotasBimestre.Add(nota);
                                }
                            }
                            else
                            {
                                foreach (var notaConceitoBimestre in notasConceitoBimestre)
                                {
                                    notaConceitoAluno.NotasBimestre.Add(new FechamentoNotaRetornoDto()
                                    {
                                        DisciplinaId = notaConceitoBimestre.DisciplinaId,
                                        Disciplina   = disciplinaEOL.Nome,
                                        NotaConceito = notaConceitoBimestre.ConceitoId.HasValue ?
                                                       notaConceitoBimestre.ConceitoId.Value :
                                                       notaConceitoBimestre.Nota,
                                        EhConceito = notaConceitoBimestre.ConceitoId.HasValue
                                    });
                                }
                            }
                        }
                        else
                        if (disciplinaEOL.Regencia)
                        {
                            // Regencia carrega disciplinas mesmo sem nota de fechamento
                            foreach (var disciplinaRegencia in disciplinasRegencia)
                            {
                                notaConceitoAluno.NotasBimestre.Add(new FechamentoNotaRetornoDto()
                                {
                                    DisciplinaId = disciplinaRegencia.CodigoComponenteCurricular,
                                    Disciplina   = disciplinaRegencia.Nome,
                                });
                            }
                        }

                        // Carrega Frequencia Aluno
                        var frequenciaAluno = repositorioFrequenciaAluno.ObterPorAlunoData(aluno.CodigoAluno, periodoAtual.PeriodoFim, TipoFrequenciaAluno.PorDisciplina, filtro.DisciplinaCodigo);
                        notaConceitoAluno.PercentualFrequencia = frequenciaAluno != null ?
                                                                 (int)Math.Round(frequenciaAluno.PercentualFrequencia, 0) :
                                                                 100;

                        listaAlunosDoBimestre.Add(notaConceitoAluno);
                    }

                    foreach (var avaliacao in atividadesAvaliativasdoBimestre)
                    {
                        var avaliacaoDoBimestre = new NotasConceitosAvaliacaoRetornoDto()
                        {
                            Id        = avaliacao.Id,
                            Data      = avaliacao.DataAvaliacao,
                            Descricao = avaliacao.DescricaoAvaliacao,
                            Nome      = avaliacao.NomeAvaliacao
                        };
                        if (avaliacao.Categoria.Equals(CategoriaAtividadeAvaliativa.Interdisciplinar))
                        {
                            avaliacaoDoBimestre.EhInterdisciplinar = true;
                            var atividadeDisciplinas = await repositorioAtividadeAvaliativaDisciplina.ListarPorIdAtividade(avaliacao.Id);

                            var idsDisciplinas = atividadeDisciplinas.Select(a => long.Parse(a.DisciplinaId)).ToArray();
                            var disciplinas    = await repositorioComponenteCurricular.ObterDisciplinasPorIds(idsDisciplinas);

                            var nomesDisciplinas = disciplinas.Select(d => d.Nome).ToArray();
                            avaliacaoDoBimestre.Disciplinas = nomesDisciplinas;
                        }
                        bimestreParaAdicionar.Avaliacoes.Add(avaliacaoDoBimestre);

                        if (atividadeAvaliativaParaObterTipoNota == null)
                        {
                            atividadeAvaliativaParaObterTipoNota = avaliacao;
                        }
                    }
                    bimestreParaAdicionar.Alunos = listaAlunosDoBimestre;
                    bimestreParaAdicionar.QtdAvaliacoesBimestrais = atividadesAvaliativasdoBimestre.Where(x => x.TipoAvaliacaoId == tipoAvaliacaoBimestral.Id).Count();
                    bimestreParaAdicionar.PodeLancarNotaFinal     = await VerificaPeriodoFechamentoEmAberto(filtro.TurmaCodigo, periodoAtual.Bimestre);

                    // Valida Avaliações Bimestrais
                    await ValidaMinimoAvaliacoesBimestrais(disciplinaEOL, disciplinasRegencia, tipoCalendario.Id, filtro.TurmaCodigo, valorBimestreAtual, tipoAvaliacaoBimestral, bimestreParaAdicionar);

                    if (atividadeAvaliativaParaObterTipoNota != null)
                    {
                        var notaTipo = await servicoDeNotasConceitos.TipoNotaPorAvaliacao(atividadeAvaliativaParaObterTipoNota, filtro.TurmaHistorico);

                        if (notaTipo == null)
                        {
                            throw new NegocioException("Não foi possível obter o tipo de nota desta avaliação.");
                        }

                        retorno.NotaTipo = notaTipo.TipoNota;
                        ObterValoresDeAuditoria(dataUltimaNotaConceitoInserida, dataUltimaNotaConceitoAlterada, usuarioRfUltimaNotaConceitoInserida, usuarioRfUltimaNotaConceitoAlterada, notaTipo.TipoNota, retorno, nomeAvaliacaoAuditoriaInclusao, nomeAvaliacaoAuditoriaAlteracao);
                    }
                }

                retorno.Bimestres.Add(bimestreParaAdicionar);
            }

            return(retorno);
        }