Exemple #1
0
        private async Task <string> ValidaMinimoAvaliacoesBimestre(long tipoCalendarioId, string turmaId, long disciplinaId, int bimestre)
        {
            var validacoes             = new StringBuilder();
            var tipoAvaliacaoBimestral = await repositorioTipoAvaliacao.ObterTipoAvaliacaoBimestral();

            var disciplinasEOL = servicoEOL.ObterDisciplinasPorIds(new long[] { disciplinaId });

            if (disciplinasEOL.First().Regencia)
            {
                // Disciplinas Regencia de Classe
                disciplinasEOL = await consultasDisciplina.ObterDisciplinasParaPlanejamento(new FiltroDisciplinaPlanejamentoDto()
                {
                    CodigoTurma      = long.Parse(turmaId),
                    CodigoDisciplina = disciplinaId,
                    Regencia         = true
                });

                foreach (var disciplina in disciplinasEOL)
                {
                    var avaliacoes = await repositorioAtividadeAvaliativaRegencia.ObterAvaliacoesBimestrais(tipoCalendarioId, turmaId, disciplina.CodigoComponenteCurricular.ToString(), bimestre);

                    if ((avaliacoes == null) || (avaliacoes.Count() < tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre))
                    {
                        validacoes.AppendLine($"A disciplina [{disciplina.Nome}] não tem o número mínimo de avaliações bimestrais: Necessário {tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre}");
                    }
                }
            }
            else
            {
                var disciplinaEOL = disciplinasEOL.First();
                var avaliacoes    = await repositorioAtividadeAvaliativaDisciplina.ObterAvaliacoesBimestrais(tipoCalendarioId, turmaId, disciplinaEOL.CodigoComponenteCurricular.ToString(), bimestre);

                if ((avaliacoes == null) || (avaliacoes.Count() < tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre))
                {
                    validacoes.AppendLine($"A disciplina [{disciplinaEOL.Nome}] não tem o número mínimo de avaliações bimestrais: Necessário {tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre}");
                }
            }

            return(validacoes.ToString());
        }
Exemple #2
0
 public async Task <TipoAvaliacaoCompletaDto> ObterTipoAvaliacaoBimestral()
 => MapearParaDto(await repositorioTipoAvaliacao.ObterTipoAvaliacaoBimestral(), false);
        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);
        }