コード例 #1
0
        public void NotificarCompensacaoAusencia(long compensacaoId)
        {
            // Verifica se compensação possui alunos vinculados
            var alunos = repositorioCompensacaoAusenciaAluno.ObterPorCompensacao(compensacaoId).Result;

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

            // Verifica se possui aluno não notificado na compensação
            alunos = alunos.Where(a => !a.Notificado);
            if (!alunos.Any())
            {
                return;
            }

            // Carrega dados da compensacao a notificar
            var          compensacao   = repositorioCompensacaoAusencia.ObterPorId(compensacaoId);
            var          turma         = repositorioTurma.ObterPorId(compensacao.TurmaId);
            var          ue            = repositorioUe.ObterUEPorTurma(turma.CodigoTurma);
            var          dre           = repositorioDre.ObterPorId(ue.DreId);
            var          disciplinaEOL = ObterNomeDisciplina(compensacao.DisciplinaId);
            MeusDadosDto professor     = servicoEOL.ObterMeusDados(compensacao.CriadoRF).Result;

            // Carrega dados dos alunos não notificados
            var alunosTurma = servicoEOL.ObterAlunosPorTurma(turma.CodigoTurma).Result;
            var alunosDto   = new List <CompensacaoAusenciaAlunoQtdDto>();

            foreach (var aluno in alunos)
            {
                var alunoEol = alunosTurma.FirstOrDefault(a => a.CodigoAluno == aluno.CodigoAluno);
                alunosDto.Add(new CompensacaoAusenciaAlunoQtdDto()
                {
                    NumeroAluno            = alunoEol.NumeroAlunoChamada,
                    CodigoAluno            = aluno.CodigoAluno,
                    NomeAluno              = alunoEol.NomeAluno,
                    QuantidadeCompensacoes = aluno.QuantidadeFaltasCompensadas
                });
            }

            var gestores = BuscaGestoresUe(ue.CodigoUe);

            if (gestores != null && gestores.Any())
            {
                foreach (var gestor in gestores)
                {
                    var notificacaoId = NotificarCompensacaoAusencia(compensacaoId
                                                                     , gestor.Usuario
                                                                     , professor.Nome
                                                                     , professor.CodigoRf
                                                                     , disciplinaEOL
                                                                     , turma.CodigoTurma
                                                                     , turma.Nome
                                                                     , turma.ModalidadeCodigo.GetAttribute <DisplayAttribute>().ShortName
                                                                     , ue.CodigoUe
                                                                     , ue.Nome
                                                                     , ue.TipoEscola.GetAttribute <DisplayAttribute>().ShortName
                                                                     , dre.CodigoDre
                                                                     , dre.Nome
                                                                     , compensacao.Bimestre
                                                                     , compensacao.Nome
                                                                     , alunosDto);

                    // Grava vinculo de notificação x compensação
                    repositorioNotificacaoCompensacaoAusencia.Inserir(notificacaoId, compensacaoId);
                }

                // Marca aluno como notificado
                alunosDto.ForEach(alunoDto =>
                {
                    var aluno        = alunos.FirstOrDefault(a => a.CodigoAluno == alunoDto.CodigoAluno);
                    aluno.Notificado = true;
                    repositorioCompensacaoAusenciaAluno.Salvar(aluno);
                });
            }
        }
コード例 #2
0
        private async Task <List <string> > GravarCompensacaoAlunos(bool alteracao, long compensacaoId, string turmaId, string disciplinaId, IEnumerable <CompensacaoAusenciaAlunoDto> alunosDto, PeriodoEscolarDto periodo)
        {
            var mensagensExcessao = new StringBuilder();

            List <CompensacaoAusenciaAluno>        listaPersistencia = new List <CompensacaoAusenciaAluno>();
            IEnumerable <CompensacaoAusenciaAluno> alunos            = new List <CompensacaoAusenciaAluno>();

            if (alteracao)
            {
                alunos = await repositorioCompensacaoAusenciaAluno.ObterPorCompensacao(compensacaoId);
            }

            // excluir os removidos da lista
            foreach (var alunoRemovido in alunos.Where(a => !alunosDto.Any(d => d.Id == a.CodigoAluno)))
            {
                alunoRemovido.Excluir();
                listaPersistencia.Add(alunoRemovido);
            }

            // altera as faltas compensadas
            foreach (var aluno in alunos.Where(a => !a.Excluido))
            {
                var frequenciaAluno = repositorioFrequencia.ObterPorAlunoDisciplinaData(aluno.CodigoAluno, disciplinaId, periodo.PeriodoFim);
                if (frequenciaAluno == null)
                {
                    mensagensExcessao.Append($"O aluno(a) [{aluno.CodigoAluno}] não possui ausência para compensar. ");
                    continue;
                }

                var faltasNaoCompensadas = frequenciaAluno.NumeroFaltasNaoCompensadas + aluno.QuantidadeFaltasCompensadas;

                var alunoDto = alunosDto.FirstOrDefault(a => a.Id == aluno.CodigoAluno);
                if (alunoDto.QtdFaltasCompensadas > faltasNaoCompensadas)
                {
                    mensagensExcessao.Append($"O aluno(a) [{alunoDto.Id}] possui apenas {frequenciaAluno.NumeroFaltasNaoCompensadas} faltas não compensadas. ");
                    continue;
                }

                aluno.QuantidadeFaltasCompensadas = alunoDto.QtdFaltasCompensadas;
                listaPersistencia.Add(aluno);
            }

            // adiciona os alunos novos
            foreach (var alunoDto in alunosDto.Where(d => !alunos.Any(a => a.CodigoAluno == d.Id)))
            {
                var frequenciaAluno = repositorioFrequencia.ObterPorAlunoDisciplinaData(alunoDto.Id, disciplinaId, periodo.PeriodoFim);
                if (frequenciaAluno == null)
                {
                    mensagensExcessao.Append($"O aluno(a) [{alunoDto.Id}] não possui ausência para compensar. ");
                    continue;
                }

                if (alunoDto.QtdFaltasCompensadas > frequenciaAluno.NumeroFaltasNaoCompensadas)
                {
                    mensagensExcessao.Append($"O aluno(a) [{alunoDto.Id}] possui apenas {frequenciaAluno.NumeroFaltasNaoCompensadas} faltas não compensadas. ");
                    continue;
                }

                listaPersistencia.Add(MapearCompensacaoAlunoEntidade(compensacaoId, alunoDto));
            }

            if (!string.IsNullOrEmpty(mensagensExcessao.ToString()))
            {
                throw new NegocioException(mensagensExcessao.ToString());
            }

            listaPersistencia.ForEach(aluno => repositorioCompensacaoAusenciaAluno.Salvar(aluno));

            // Recalcula Frequencia dos alunos envolvidos na Persistencia
            return(listaPersistencia.Select(a => a.CodigoAluno).ToList());
        }