예제 #1
0
        public async Task <ConselhoClasseNotaRetornoDto> SalvarConselhoClasseAlunoNotaAsync(ConselhoClasseNotaDto conselhoClasseNotaDto, string alunoCodigo, long conselhoClasseId, long fechamentoTurmaId, string codigoTurma, int bimestre)
        {
            var conselhoClasseNota = new ConselhoClasseNota();

            var fechamentoTurma = await repositorioFechamentoTurma.ObterCompletoPorIdAsync(fechamentoTurmaId);

            var fechamentoTurmaDisciplina = new FechamentoTurmaDisciplina();

            if (fechamentoTurma == null)
            {
                var turma = await consultasTurma.ObterPorCodigo(codigoTurma);

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

                var ue = repositorioUe.ObterPorId(turma.UeId);
                ue.AdicionarDre(repositorioDre.ObterPorId(ue.DreId));
                turma.AdicionarUe(ue);

                if (turma.AnoLetivo == DateTime.Today.Year)
                {
                    throw new NegocioException("Não existe fechamento de turma para o conselho de classe");
                }

                var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, turma.ModalidadeTipoCalendario, turma.Semestre);

                if (tipoCalendario == null)
                {
                    throw new NegocioException("Tipo calendário não encontrado");
                }

                var periodoEscolar = await consultasPeriodoEscolar.ObterPeriodoEscolarPorTipoCalendarioBimestre(tipoCalendario.Id, bimestre);

                fechamentoTurma = new FechamentoTurma()
                {
                    TurmaId          = turma.Id,
                    Migrado          = false,
                    PeriodoEscolarId = periodoEscolar?.Id,
                    Turma            = turma,
                    PeriodoEscolar   = periodoEscolar
                };

                fechamentoTurmaDisciplina = new FechamentoTurmaDisciplina()
                {
                    DisciplinaId = conselhoClasseNotaDto.CodigoComponenteCurricular
                };
            }
            try
            {
                unitOfWork.IniciarTransacao();
                if (fechamentoTurmaDisciplina.DisciplinaId > 0)
                {
                    await repositorioFechamentoTurma.SalvarAsync(fechamentoTurma);

                    fechamentoTurmaDisciplina.FechamentoTurmaId = fechamentoTurma.Id;
                    await repositorioFechamentoTurmaDisciplina.SalvarAsync(fechamentoTurmaDisciplina);
                }
                if (fechamentoTurma.PeriodoEscolarId.HasValue)
                {
                    // Fechamento Bimestral
                    if (!await consultasPeriodoFechamento.TurmaEmPeriodoDeFechamento(fechamentoTurma.Turma, DateTime.Today, fechamentoTurma.PeriodoEscolar.Bimestre))
                    {
                        throw new NegocioException($"Turma {fechamentoTurma.Turma.Nome} não esta em período de fechamento para o {fechamentoTurma.PeriodoEscolar.Bimestre}º Bimestre!");
                    }
                }
                else
                {
                    // Fechamento Final
                    if (fechamentoTurma.Turma.AnoLetivo != 2020)
                    {
                        var validacaoConselhoFinal = await consultasConselhoClasse.ValidaConselhoClasseUltimoBimestre(fechamentoTurma.Turma);

                        if (!validacaoConselhoFinal.Item2 && fechamentoTurma.Turma.AnoLetivo == DateTime.Today.Year)
                        {
                            throw new NegocioException($"Para acessar este aba você precisa registrar o conselho de classe do {validacaoConselhoFinal.Item1}º bimestre");
                        }
                    }
                }
                unitOfWork.PersistirTransacao();
            }
            catch (Exception e)
            {
                unitOfWork.Rollback();
                throw e;
            }

            long conselhoClasseAlunoId = 0;

            try
            {
                if (conselhoClasseId == 0)
                {
                    var conselhoClasse = new ConselhoClasse();
                    conselhoClasse.FechamentoTurmaId = fechamentoTurma.Id;

                    unitOfWork.IniciarTransacao();
                    await repositorioConselhoClasse.SalvarAsync(conselhoClasse);

                    conselhoClasseId = conselhoClasse.Id;

                    conselhoClasseAlunoId = await SalvarConselhoClasseAlunoResumido(conselhoClasse.Id, alunoCodigo);

                    conselhoClasseNota = ObterConselhoClasseNota(conselhoClasseNotaDto, conselhoClasseAlunoId);

                    if (fechamentoTurma.Turma.AnoLetivo == 2020)
                    {
                        ValidarNotasFechamentoConselhoClasse2020(conselhoClasseNota);
                    }

                    await repositorioConselhoClasseNota.SalvarAsync(conselhoClasseNota);

                    unitOfWork.PersistirTransacao();
                }
                else
                {
                    var conselhoClasseAluno = await repositorioConselhoClasseAluno.ObterPorConselhoClasseAlunoCodigoAsync(conselhoClasseId, alunoCodigo);

                    unitOfWork.IniciarTransacao();

                    conselhoClasseAlunoId = conselhoClasseAluno != null ? conselhoClasseAluno.Id : await SalvarConselhoClasseAlunoResumido(conselhoClasseId, alunoCodigo);

                    conselhoClasseNota = await repositorioConselhoClasseNota.ObterPorConselhoClasseAlunoComponenteCurricularAsync(conselhoClasseAlunoId, conselhoClasseNotaDto.CodigoComponenteCurricular);

                    if (conselhoClasseNota == null)
                    {
                        conselhoClasseNota = ObterConselhoClasseNota(conselhoClasseNotaDto, conselhoClasseAlunoId);
                    }
                    else
                    {
                        conselhoClasseNota.Justificativa = conselhoClasseNotaDto.Justificativa;
                        if (conselhoClasseNotaDto.Nota.HasValue)
                        {
                            // Gera histórico de alteração
                            if (conselhoClasseNota.Nota != conselhoClasseNotaDto.Nota.Value)
                            {
                                await mediator.Send(new SalvarHistoricoNotaConselhoClasseCommand(conselhoClasseNota.Id, conselhoClasseNota.Nota.Value, conselhoClasseNotaDto.Nota.Value));
                            }

                            conselhoClasseNota.Nota = conselhoClasseNotaDto.Nota.Value;
                        }
                        else
                        {
                            conselhoClasseNota.Nota = null;
                        }

                        if (conselhoClasseNotaDto.Conceito.HasValue)
                        {
                            // Gera histórico de alteração
                            if (conselhoClasseNota.ConceitoId != conselhoClasseNotaDto.Conceito.Value)
                            {
                                await mediator.Send(new SalvarHistoricoConceitoConselhoClasseCommand(conselhoClasseNota.Id, conselhoClasseNota.ConceitoId.Value, conselhoClasseNotaDto.Conceito.Value));
                            }

                            conselhoClasseNota.ConceitoId = conselhoClasseNotaDto.Conceito.Value;
                        }
                    }

                    if (fechamentoTurma.Turma.AnoLetivo == 2020)
                    {
                        ValidarNotasFechamentoConselhoClasse2020(conselhoClasseNota);
                    }

                    await repositorioConselhoClasseNota.SalvarAsync(conselhoClasseNota);

                    unitOfWork.PersistirTransacao();
                }
            }
            catch (Exception e)
            {
                unitOfWork.Rollback();
                throw e;
            }

            // TODO Verificar se o fechamentoTurma.Turma carregou UE
            if (await VerificaNotasTodosComponentesCurriculares(alunoCodigo, fechamentoTurma.Turma, fechamentoTurma.PeriodoEscolarId))
            {
                await VerificaRecomendacoesAluno(conselhoClasseAlunoId);
            }

            var usuarioLogado = await mediator.Send(new ObterUsuarioLogadoQuery());

            await mediator.Send(new PublicaFilaAtualizacaoSituacaoConselhoClasseCommand(conselhoClasseId, usuarioLogado));

            var auditoria = (AuditoriaDto)conselhoClasseNota;
            var conselhoClasseNotaRetorno = new ConselhoClasseNotaRetornoDto()
            {
                ConselhoClasseId  = conselhoClasseId,
                FechamentoTurmaId = fechamentoTurma.Id,
                Auditoria         = auditoria
            };

            return(conselhoClasseNotaRetorno);
        }
예제 #2
0
        public async Task <ConsultasConselhoClasseRecomendacaoConsultaDto> ObterRecomendacoesAlunoFamilia(long conselhoClasseId, long fechamentoTurmaId, string alunoCodigo, string codigoTurma, int?bimestre)
        {
            var fechamentoTurma = await consultasFechamentoTurma.ObterCompletoPorIdAsync(fechamentoTurmaId);

            var turma          = fechamentoTurma?.Turma;
            var periodoEscolar = fechamentoTurma?.PeriodoEscolar;

            var emFechamento = true;

            if (fechamentoTurma == null)
            {
                turma = await consultasTurma.ObterPorCodigo(codigoTurma);

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

                var tipoCalendario = await repositorioTipoCalendario.BuscarPorAnoLetivoEModalidade(turma.AnoLetivo, turma.ModalidadeTipoCalendario, turma.Semestre);

                if (tipoCalendario == null)
                {
                    throw new NegocioException("Tipo calendário não encontrado");
                }

                periodoEscolar = await consultasPeriodoEscolar.ObterPeriodoEscolarPorTipoCalendarioBimestre(tipoCalendario.Id, bimestre.Value);
            }

            if (!bimestre.HasValue)
            {
                if (fechamentoTurma.Turma.AnoLetivo != 2020)
                {
                    var validacaoConselhoFinal = await consultasConselhoClasse.ValidaConselhoClasseUltimoBimestre(turma);

                    if (!validacaoConselhoFinal.Item2)
                    {
                        throw new NegocioException($"Para acessar este aba você precisa registrar o conselho de classe do {validacaoConselhoFinal.Item1}º bimestre");
                    }
                }
                emFechamento = await consultasPeriodoFechamento.TurmaEmPeriodoDeFechamento(turma.CodigoTurma, DateTime.Today);
            }
            else
            {
                emFechamento = await consultasPeriodoFechamento.TurmaEmPeriodoDeFechamento(turma.CodigoTurma, DateTime.Today, bimestre.Value);
            }

            var anotacoesDoAluno = await consultasFechamentoAluno.ObterAnotacaoAlunoParaConselhoAsync(alunoCodigo, fechamentoTurmaId);

            if (anotacoesDoAluno == null)
            {
                anotacoesDoAluno = new List <FechamentoAlunoAnotacaoConselhoDto>();
            }

            var conselhoClasseAluno = fechamentoTurma != null ? await repositorioConselhoClasseAluno.ObterPorFechamentoAsync(fechamentoTurma.Id, alunoCodigo): null;

            if (conselhoClasseAluno == null || string.IsNullOrEmpty(conselhoClasseAluno.RecomendacoesAluno) || string.IsNullOrEmpty(conselhoClasseAluno.RecomendacoesFamilia))
            {
                return(await ObterRecomendacoesIniciais(conselhoClasseAluno, anotacoesDoAluno, emFechamento));
            }

            return(TransformaEntidadeEmConsultaDto(conselhoClasseAluno, anotacoesDoAluno, emFechamento));
        }