private async Task <bool> VerificarPlanoAnualExistente(long aulaId)
        {
            var usuario = await servicoUsuario.ObterUsuarioLogado();

            var aula = repositorioAula.ObterPorId(aulaId);

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

            var periodoEscolar = consultasPeriodoEscolar.ObterPeriodoEscolarPorData(aula.TipoCalendarioId, aula.DataAula);

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

            var planoAnualId = await consultasPlanoAnual.ObterIdPlanoAnualPorAnoEscolaBimestreETurma(
                aula.DataAula.Year, aula.UeId, long.Parse(aula.TurmaId), periodoEscolar.Bimestre, long.Parse(aula.DisciplinaId));

            if (planoAnualId <= 0 && !usuario.EhProfessorCj())
            {
                return(false);
            }
            return(true);
        }
        public async Task <FrequenciaDto> ObterListaFrequenciaPorAula(long aulaId)
        {
            var aula = repositorioAula.ObterPorId(aulaId);

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

            var alunosDaTurma = await servicoEOL.ObterAlunosPorTurma(aula.TurmaId, aula.DataAula.Year);

            if (alunosDaTurma == null || !alunosDaTurma.Any())
            {
                throw new NegocioException("Não foram encontrados alunos para a aula/turma informada.");
            }
            var turma = repositorioTurma.ObterPorId(aula.TurmaId);

            if (turma == null)
            {
                throw new NegocioException("Não foi encontrada uma turma com o id informado. Verifique se você possui abrangência para essa turma.");
            }
            FrequenciaDto registroFrequenciaDto = ObterRegistroFrequencia(aulaId, aula, turma);

            var ausencias = servicoFrequencia.ObterListaAusenciasPorAula(aulaId);

            if (ausencias == null)
            {
                ausencias = new List <RegistroAusenciaAluno>();
            }

            var bimestre = consultasPeriodoEscolar.ObterPeriodoEscolarPorData(aula.TipoCalendarioId, aula.DataAula);

            if (bimestre == null)
            {
                throw new NegocioException("Ocorreu um erro, esta aula está fora do período escolar.");
            }
            var parametroPercentualCritico = repositorioParametrosSistema.ObterValorPorTipoEAno(
                TipoParametroSistema.PercentualFrequenciaCritico,
                bimestre.PeriodoInicio.Year);

            if (parametroPercentualCritico == null)
            {
                throw new NegocioException("Parâmetro de percentual de frequência em nível crítico não encontrado contate a SME.");
            }
            var percentualCritico = int.Parse(parametroPercentualCritico);
            var percentualAlerta  = int.Parse(repositorioParametrosSistema.ObterValorPorTipoEAno(
                                                  TipoParametroSistema.PercentualFrequenciaAlerta,
                                                  bimestre.PeriodoInicio.Year));

            var disciplinaAula = servicoEOL.ObterDisciplinasPorIds(new long[] { Convert.ToInt64(aula.DisciplinaId) });

            if (disciplinaAula == null || disciplinaAula.ToList().Count <= 0)
            {
                throw new NegocioException("Disciplina da aula não encontrada");
            }

            foreach (var aluno in alunosDaTurma.Where(a => a.DeveMostrarNaChamada()))
            {
                // Apos o bimestre da inatividade o aluno não aparece mais na lista de frequencia
                if (aluno.EstaInativo() && (aluno.DataSituacao < bimestre.PeriodoInicio))
                {
                    continue;
                }

                var registroFrequenciaAluno = new RegistroFrequenciaAlunoDto
                {
                    CodigoAluno             = aluno.CodigoAluno,
                    NomeAluno               = aluno.NomeAluno,
                    NumeroAlunoChamada      = aluno.NumeroAlunoChamada,
                    CodigoSituacaoMatricula = aluno.CodigoSituacaoMatricula,
                    SituacaoMatricula       = aluno.SituacaoMatricula,
                    Desabilitado            = (aluno.EstaInativo() && (aula.DataAula.Date >= aluno.DataSituacao.Date)) || aula.EhDataSelecionadaFutura,
                };

                // Marcador visual da situação
                registroFrequenciaAluno.Marcador = servicoAluno.ObterMarcadorAluno(aluno, bimestre);

                // Indicativo de frequencia do aluno
                registroFrequenciaAluno.IndicativoFrequencia = ObterIndicativoFrequencia(aluno, aula.DisciplinaId, bimestre, percentualAlerta, percentualCritico);

                if (!disciplinaAula.FirstOrDefault().RegistraFrequencia)
                {
                    registroFrequenciaDto.ListaFrequencia.Add(registroFrequenciaAluno);
                    continue;
                }

                var ausenciasAluno = ausencias.Where(c => c.CodigoAluno == aluno.CodigoAluno);

                for (int numeroAula = 1; numeroAula <= aula.Quantidade; numeroAula++)
                {
                    registroFrequenciaAluno.Aulas.Add(new FrequenciaAulaDto
                    {
                        NumeroAula = numeroAula,
                        Compareceu = !ausenciasAluno.Any(c => c.NumeroAula == numeroAula)
                    });
                }

                registroFrequenciaDto.ListaFrequencia.Add(registroFrequenciaAluno);
            }

            registroFrequenciaDto.Desabilitado = registroFrequenciaDto.ListaFrequencia.All(c => c.Desabilitado) || aula.EhDataSelecionadaFutura;

            return(registroFrequenciaDto);
        }
        public async Task <FechamentoTurmaDisciplinaBimestreDto> ObterNotasFechamentoTurmaDisciplina(string turmaId, long disciplinaId, int?bimestre)
        {
            var turma          = repositorioTurma.ObterPorId(turmaId);
            var tipoCalendario = repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, ModalidadeParaModalidadeTipoCalendario(turma.ModalidadeCodigo));

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

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

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

            var bimestreAtual = bimestre;

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

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

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

            // Carrega alunos
            var alunos = await servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma, turma.AnoLetivo);

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

            // DTO de retorno
            var fechamentoBimestre = new FechamentoTurmaDisciplinaBimestreDto()
            {
                Bimestre            = bimestreAtual.Value,
                TotalAulasDadas     = 0, // Carregar
                TotalAulasPrevistas = 0, // Carregar
                Alunos = new List <NotaConceitoAlunoBimestreDto>()
            };


            // Carrega fechamento da Turma x Disciplina x Bimestre
            var fechamentoTurma = await ObterFechamentoTurmaDisciplina(turmaId, disciplinaId, bimestreAtual.Value);

            if (fechamentoTurma != null)
            {
                var disciplinasId = new long[] { disciplinaId };

                var disciplinaEOL = servicoEOL.ObterDisciplinasPorIds(disciplinasId).FirstOrDefault();
                IEnumerable <DisciplinaResposta> disciplinasRegencia = null;

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

                fechamentoBimestre.Alunos = new List <NotaConceitoAlunoBimestreDto>();

                var bimestreDoPeriodo = consultasPeriodoEscolar.ObterPeriodoEscolarPorData(tipoCalendario.Id, periodoAtual.PeriodoFim);

                foreach (var aluno in alunos)
                {
                    var alunoDto = new NotaConceitoAlunoBimestreDto();
                    alunoDto.NumeroChamada = aluno.NumeroAlunoChamada;
                    alunoDto.Nome          = aluno.NomeAluno;
                    alunoDto.Ativo         = aluno.CodigoSituacaoMatricula.Equals(SituacaoMatriculaAluno.Ativo);

                    var marcador = servicoAluno.ObterMarcadorAluno(aluno, bimestreDoPeriodo);
                    if (marcador != null)
                    {
                        alunoDto.Informacao = marcador.Descricao;
                    }

                    // Carrega Frequencia do aluno
                    if (aluno.CodigoAluno != null)
                    {
                        // Carrega notas do bimestre
                        var notasConceitoBimestre = await ObterNotasBimestre(aluno.CodigoAluno, fechamentoTurma.Id);

                        foreach (var notaConceitoBimestre in notasConceitoBimestre)
                        {
                            alunoDto.Notas = new List <NotaConceitoBimestreRetornoDto>();
                            ((List <NotaConceitoBimestreRetornoDto>)alunoDto.Notas).Add(new NotaConceitoBimestreRetornoDto()
                            {
                                DisciplinaId = notaConceitoBimestre.DisciplinaId,
                                Disciplina   = disciplinaEOL.Regencia ?
                                               disciplinasRegencia.FirstOrDefault(a => a.CodigoComponenteCurricular == notaConceitoBimestre.DisciplinaId).Nome :
                                               disciplinaEOL.Nome,
                                NotaConceito = notaConceitoBimestre.Nota > 0 ? notaConceitoBimestre.Nota.ToString() : ObterConceito(notaConceitoBimestre.ConceitoId)
                            });
                        }

                        var frequenciaAluno = repositorioFrequenciaAlunoDisciplinaPeriodo.ObterPorAlunoData(aluno.CodigoAluno, periodoAtual.PeriodoFim, TipoFrequenciaAluno.PorDisciplina, disciplinaId.ToString());
                        if (frequenciaAluno != null)
                        {
                            alunoDto.QuantidadeFaltas       = frequenciaAluno.TotalAusencias;
                            alunoDto.QuantidadeCompensacoes = frequenciaAluno.TotalCompensacoes;
                            alunoDto.PercentualFrequencia   = frequenciaAluno.PercentualFrequencia;
                        }
                        fechamentoBimestre.Alunos.Add(alunoDto);
                    }
                }
            }

            var aulaPrevisa = await consultasAulaPrevista.ObterAulaPrevistaDada(turma.ModalidadeCodigo, turma.CodigoTurma, disciplinaId.ToString());

            var aulaPrevistaBimestreAtual = new AulasPrevistasDadasDto();

            if (aulaPrevisa != null)
            {
                aulaPrevistaBimestreAtual = aulaPrevisa.AulasPrevistasPorBimestre.FirstOrDefault(a => a.Bimestre == bimestreAtual);
            }

            fechamentoBimestre.Bimestre            = bimestreAtual.Value;
            fechamentoBimestre.TotalAulasDadas     = aulaPrevistaBimestreAtual.Cumpridas;
            fechamentoBimestre.TotalAulasPrevistas = aulaPrevistaBimestreAtual.Previstas.Quantidade;

            return(fechamentoBimestre);
        }
Ejemplo n.º 4
0
        public async Task <FrequenciaDto> ObterListaFrequenciaPorAula(long aulaId, long?disciplinaId = null)
        {
            var aula = repositorioAula.ObterPorId(aulaId);

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



            var alunosDaTurma = await servicoEOL.ObterAlunosPorTurma(aula.TurmaId);

            if (alunosDaTurma == null || !alunosDaTurma.Any())
            {
                throw new NegocioException("Não foram encontrados alunos para a aula/turma informada.");
            }

            var turma = await repositorioTurma.ObterPorCodigo(aula.TurmaId);

            if (turma == null)
            {
                throw new NegocioException("Não foi encontrada uma turma com o id informado. Verifique se você possui abrangência para essa turma.");
            }

            FrequenciaDto registroFrequenciaDto = ObterRegistroFrequencia(aulaId, aula, turma);

            var ausencias = servicoFrequencia.ObterListaAusenciasPorAula(aulaId);

            if (ausencias == null)
            {
                ausencias = new List <RegistroAusenciaAluno>();
            }

            var bimestre = await consultasPeriodoEscolar.ObterPeriodoEscolarPorData(aula.TipoCalendarioId, aula.DataAula);

            if (bimestre == null)
            {
                throw new NegocioException("Ocorreu um erro, esta aula está fora do período escolar.");
            }


            registroFrequenciaDto.TemPeriodoAberto = await consultasTurma.TurmaEmPeriodoAberto(aula.TurmaId, DateTime.Today, bimestre.Bimestre);

            var parametroPercentualCritico = await repositorioParametrosSistema.ObterValorPorTipoEAno(
                TipoParametroSistema.PercentualFrequenciaCritico,
                bimestre.PeriodoInicio.Year);

            if (parametroPercentualCritico == null)
            {
                throw new NegocioException("Parâmetro de percentual de frequência em nível crítico não encontrado contate a SME.");
            }

            var percentualCritico = int.Parse(parametroPercentualCritico);
            var percentualAlerta  = int.Parse(await repositorioParametrosSistema.ObterValorPorTipoEAno(
                                                  TipoParametroSistema.PercentualFrequenciaAlerta,
                                                  bimestre.PeriodoInicio.Year));

            var disciplinaAula = await repositorioComponenteCurricular.ObterDisciplinasPorIds(new long[] { disciplinaId.HasValue?disciplinaId.Value : Convert.ToInt64(aula.DisciplinaId) });

            if (disciplinaAula == null || disciplinaAula.ToList().Count <= 0)
            {
                throw new NegocioException("Disciplina da aula não encontrada");
            }

            var anotacoesTurma = await mediator.Send(new ObterAlunosComAnotacaoNaAulaQuery(aulaId));

            foreach (var aluno in alunosDaTurma.Where(a => a.DeveMostrarNaChamada(aula.DataAula)).OrderBy(c => c.NomeAluno))
            {
                // Apos o bimestre da inatividade o aluno não aparece mais na lista de frequencia ou
                // se a matrícula foi ativada após a data da aula
                if ((aluno.EstaInativo(aula.DataAula) && aluno.DataSituacao < bimestre.PeriodoInicio) ||
                    (aluno.CodigoSituacaoMatricula == SituacaoMatriculaAluno.Ativo && aluno.DataSituacao > aula.DataAula))
                {
                    continue;
                }

                if (aula.DataAula < aluno.DataMatricula.Date)
                {
                    continue;
                }

                var registroFrequenciaAluno = new RegistroFrequenciaAlunoDto
                {
                    CodigoAluno             = aluno.CodigoAluno,
                    NomeAluno               = aluno.NomeAluno,
                    NumeroAlunoChamada      = aluno.NumeroAlunoChamada,
                    CodigoSituacaoMatricula = aluno.CodigoSituacaoMatricula,
                    SituacaoMatricula       = aluno.SituacaoMatricula,
                    DataSituacao            = aluno.DataSituacao,
                    DataNascimento          = aluno.DataNascimento,
                    Desabilitado            = aluno.EstaInativo(aula.DataAula) || aula.EhDataSelecionadaFutura,
                    PermiteAnotacao         = aluno.EstaAtivo(aula.DataAula),
                    PossuiAnotacao          = anotacoesTurma.Any(a => a == aluno.CodigoAluno),
                    NomeResponsavel         = aluno.NomeResponsavel,
                    TipoResponsavel         = ObterTipoResponsavel(aluno.TipoResponsavel),
                    CelularResponsavel      = aluno.CelularResponsavel,
                    DataAtualizacaoContato  = aluno.DataAtualizacaoContato
                };

                // Marcador visual da situação
                registroFrequenciaAluno.Marcador = servicoAluno.ObterMarcadorAluno(aluno, bimestre, turma.EhTurmaInfantil);

                // Indicativo de frequencia do aluno
                aluno.CodigoTurma = long.Parse(turma.CodigoTurma);
                registroFrequenciaAluno.IndicativoFrequencia = ObterIndicativoFrequencia(aluno, aula.DisciplinaId, bimestre, percentualAlerta, percentualCritico);

                if (!disciplinaAula.FirstOrDefault().RegistraFrequencia)
                {
                    registroFrequenciaDto.ListaFrequencia.Add(registroFrequenciaAluno);
                    continue;
                }

                var ausenciasAluno = ausencias.Where(c => c.CodigoAluno == aluno.CodigoAluno);

                for (int numeroAula = 1; numeroAula <= aula.Quantidade; numeroAula++)
                {
                    registroFrequenciaAluno.Aulas.Add(new FrequenciaAulaDto
                    {
                        NumeroAula = numeroAula,
                        Compareceu = !ausenciasAluno.Any(c => c.NumeroAula == numeroAula)
                    });
                }

                registroFrequenciaDto.ListaFrequencia.Add(registroFrequenciaAluno);
            }

            registroFrequenciaDto.Desabilitado = registroFrequenciaDto.ListaFrequencia.All(c => c.Desabilitado) || aula.EhDataSelecionadaFutura;

            return(registroFrequenciaDto);
        }
        public async Task <FechamentoTurmaDisciplinaBimestreDto> ObterNotasFechamentoTurmaDisciplina(string turmaId, long disciplinaId, int?bimestre, int semestre)
        {
            var turma = await repositorioTurma.ObterPorCodigo(turmaId);

            var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, ModalidadeParaModalidadeTipoCalendario(turma.ModalidadeCodigo), 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 bimestreAtual = bimestre;

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

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

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

            // Carrega alunos
            var alunos = await servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma, turma.AnoLetivo);

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

            // DTO de retorno
            var fechamentoBimestre = new FechamentoTurmaDisciplinaBimestreDto()
            {
                Bimestre            = bimestreAtual.Value,
                Periodo             = tipoCalendario.Periodo,
                TotalAulasDadas     = 0, // Carregar
                TotalAulasPrevistas = 0, // Carregar
                Alunos = new List <NotaConceitoAlunoBimestreDto>()
            };

            var disciplinaEOL = await consultasDisciplina.ObterDisciplina(disciplinaId);

            IEnumerable <DisciplinaResposta> disciplinasRegencia = null;

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

            fechamentoBimestre.EhSintese = !disciplinaEOL.LancaNota;

            // Carrega fechamento da Turma x Disciplina x Bimestre
            var fechamentosTurma = await ObterFechamentosTurmaDisciplina(turmaId, disciplinaId.ToString(), bimestreAtual.Value);

            if ((fechamentosTurma != null && fechamentosTurma.Any()) || fechamentoBimestre.EhSintese)
            {
                if (fechamentosTurma != null && fechamentosTurma.Any())
                {
                    fechamentoBimestre.Situacao       = fechamentosTurma.First().Situacao;
                    fechamentoBimestre.SituacaoNome   = fechamentosTurma.First().Situacao.Name();
                    fechamentoBimestre.FechamentoId   = fechamentosTurma.First().Id;
                    fechamentoBimestre.DataFechamento = fechamentosTurma.First().AlteradoEm.HasValue ? fechamentosTurma.First().AlteradoEm.Value : fechamentosTurma.First().CriadoEm;
                }

                fechamentoBimestre.Alunos = new List <NotaConceitoAlunoBimestreDto>();

                var bimestreDoPeriodo = await consultasPeriodoEscolar.ObterPeriodoEscolarPorData(tipoCalendario.Id, periodoAtual.PeriodoFim);

                foreach (var aluno in alunos.Where(a => a.NumeroAlunoChamada > 0 || a.CodigoSituacaoMatricula.Equals(SituacaoMatriculaAluno.Ativo)).OrderBy(a => a.NumeroAlunoChamada).ThenBy(a => a.NomeValido()))
                {
                    var fechamentoTurma = (from ft in fechamentosTurma
                                           from fa in ft.FechamentoAlunos
                                           where fa.AlunoCodigo.Equals(aluno.CodigoAluno)
                                           select ft).FirstOrDefault();

                    var alunoDto = new NotaConceitoAlunoBimestreDto();
                    alunoDto.CodigoAluno   = aluno.CodigoAluno;
                    alunoDto.NumeroChamada = aluno.NumeroAlunoChamada;
                    alunoDto.Nome          = aluno.NomeAluno;
                    alunoDto.Ativo         = aluno.CodigoSituacaoMatricula.Equals(SituacaoMatriculaAluno.Ativo);

                    var anotacaoAluno = await consultasFehcamentoAluno.ObterAnotacaoPorAlunoEFechamento(fechamentoTurma?.Id ?? 0, aluno.CodigoAluno);

                    alunoDto.TemAnotacao = anotacaoAluno != null && anotacaoAluno.Anotacao != null &&
                                           !string.IsNullOrEmpty(anotacaoAluno.Anotacao.Trim());

                    var marcador = servicoAluno.ObterMarcadorAluno(aluno, bimestreDoPeriodo);
                    if (marcador != null)
                    {
                        alunoDto.Informacao = marcador.Descricao;
                    }

                    var frequenciaAluno = consultasFrequencia.ObterPorAlunoDisciplinaData(aluno.CodigoAluno, disciplinaId.ToString(), periodoAtual.PeriodoFim);
                    if (frequenciaAluno != null)
                    {
                        alunoDto.QuantidadeFaltas       = frequenciaAluno.TotalAusencias;
                        alunoDto.QuantidadeCompensacoes = frequenciaAluno.TotalCompensacoes;
                        alunoDto.PercentualFrequencia   = frequenciaAluno.PercentualFrequencia;
                    }
                    else
                    {
                        // Quando não tem registro de frequencia assume 100%
                        alunoDto.QuantidadeFaltas       = 0;
                        alunoDto.QuantidadeCompensacoes = 0;
                        alunoDto.PercentualFrequencia   = 100;
                    }

                    // Carrega Frequencia do aluno
                    if (aluno.CodigoAluno != null)
                    {
                        if (fechamentoBimestre.EhSintese && fechamentoTurma == null)
                        {
                            var sinteseDto = await consultasFrequencia.ObterSinteseAluno(alunoDto.PercentualFrequencia, disciplinaEOL);

                            alunoDto.SinteseId = sinteseDto.Id;
                            alunoDto.Sintese   = sinteseDto.Valor;
                        }
                        else
                        {
                            // Carrega notas do bimestre
                            var notasConceitoBimestre = await ObterNotasBimestre(aluno.CodigoAluno, fechamentoTurma != null?fechamentoTurma.Id : 0);

                            if (notasConceitoBimestre.Any())
                            {
                                alunoDto.Notas = new List <FechamentoNotaRetornoDto>();
                            }

                            if (fechamentoBimestre.EhSintese)
                            {
                                var notaConceitoBimestre = notasConceitoBimestre.FirstOrDefault();
                                if (notaConceitoBimestre != null && notaConceitoBimestre.SinteseId.HasValue)
                                {
                                    alunoDto.SinteseId = (SinteseEnum)notaConceitoBimestre.SinteseId.Value;
                                    alunoDto.Sintese   = ObterSintese(notaConceitoBimestre.SinteseId.Value);
                                }
                            }
                            else
                            {
                                foreach (var notaConceitoBimestre in notasConceitoBimestre)
                                {
                                    string nomeDisciplina;
                                    if (disciplinaEOL.Regencia)
                                    {
                                        nomeDisciplina = disciplinasRegencia.FirstOrDefault(a => a.CodigoComponenteCurricular == notaConceitoBimestre.DisciplinaId)?.Nome;
                                    }
                                    else
                                    {
                                        nomeDisciplina = disciplinaEOL.Nome;
                                    }

                                    ((List <FechamentoNotaRetornoDto>)alunoDto.Notas).Add(new FechamentoNotaRetornoDto()
                                    {
                                        DisciplinaId      = notaConceitoBimestre.DisciplinaId,
                                        Disciplina        = nomeDisciplina,
                                        NotaConceito      = notaConceitoBimestre.ConceitoId.HasValue ? ObterConceito(notaConceitoBimestre.ConceitoId.Value) : notaConceitoBimestre.Nota,
                                        EhConceito        = notaConceitoBimestre.ConceitoId.HasValue,
                                        ConceitoDescricao = notaConceitoBimestre.ConceitoId.HasValue ? ObterConceitoDescricao(notaConceitoBimestre.ConceitoId.Value) : string.Empty
                                    });
                                }
                            }
                        }

                        fechamentoBimestre.Alunos.Add(alunoDto);
                    }
                }
            }

            var aulaPrevisa = await consultasAulaPrevista.ObterAulaPrevistaDada(turma.ModalidadeCodigo, turma.CodigoTurma, disciplinaId.ToString(), semestre);

            var aulaPrevistaBimestreAtual = new AulasPrevistasDadasDto();

            if (aulaPrevisa != null)
            {
                aulaPrevistaBimestreAtual = aulaPrevisa.AulasPrevistasPorBimestre.FirstOrDefault(a => a.Bimestre == bimestreAtual);
            }

            fechamentoBimestre.Bimestre            = bimestreAtual.Value;
            fechamentoBimestre.TotalAulasDadas     = aulaPrevistaBimestreAtual.Cumpridas;
            fechamentoBimestre.TotalAulasPrevistas = aulaPrevistaBimestreAtual.Previstas.Quantidade;

            fechamentoBimestre.PodeProcessarReprocessar = await consultasFechamento.TurmaEmPeriodoDeFechamento(turma.CodigoTurma, DateTime.Today, bimestreAtual.Value);

            return(fechamentoBimestre);
        }