Exemplo n.º 1
0
        /// <summary>
        /// Verifica se o turno da nova turma não entra em conflito com o turno da SAAI – Sala de apoio e acompanhamento a inclusão.
        /// </summary>
        /// <param name="alunoDeficiente">Aluno é deficiente</param>
        /// <param name="cadMov">Estrutura de cadastro de movimentação</param>
        /// <param name="bancoGestao">Transação com banco - obrigatório</param>
        /// <param name="ent_id">Id da entidade do usuário logado.</param>
        private static void VerificarCursoExclusivoDeficiente(bool alunoDeficiente, MTR_Movimentacao_Cadastro cadMov, TalkDBTransaction bancoGestao, Guid ent_id)
        {
            if (!alunoDeficiente)
            {
                int cur_id = cadMov.entAluCurNovo.cur_id;

                ACA_Curso curso = null;

                if (cadMov.listasFechamentoMatricula.listCursos != null)
                {
                    // Se a lista de fechamento foi alimentada, buscar entidade da lista.
                    curso = cadMov.listasFechamentoMatricula.listCursos.Find(p => p.cur_id == cur_id);
                }

                if (curso == null)
                {
                    curso = ACA_CursoBO.GetEntity(new ACA_Curso {
                        cur_id = cur_id
                    }, bancoGestao);
                }

                if (curso.cur_exclusivoDeficiente)
                {
                    throw new ValidationException(String.Format("Este(a) {0} é exclusivo(a) para aluno(s) {1}. Favor verificar.",
                                                                GestaoEscolarUtilBO.nomePadraoCurso(ent_id).ToLower(),
                                                                ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.TERMO_ALUNOS_DEFICIENCIA_TURMAS_NORMAIS, ent_id).ToLower()));
                }
            }
        }
Exemplo n.º 2
0
 /// <summary>
 /// Validação da data de movimentação, pois a data atual não pode ser anterior a última.
 /// </summary>
 /// <param name="cadMov">Estrutura de movimentação</param>
 /// <param name="tmo">Entidade tipo de movimentação</param>
 /// <param name="alu">Entidade do aluno</param>
 /// <param name="bancoGestao">Conexão aberta com o banco de dados do gestão</param>
 /// <param name="listasFechamentoMatricula">Listas carregadas com dados do fechamento de matrícula</param>
 private static void ValidaDataMovimentacao
 (
     MTR_Movimentacao_Cadastro cadMov
     , MTR_TipoMovimentacao tmo
     , ACA_Aluno alu
     , TalkDBTransaction bancoGestao
     , FormacaoTurmaBO.ListasFechamentoMatricula listasFechamentoMatricula = null
 )
 {
     // Chama o método padrão para validar data da movimetação
     ValidaDataMovimentacao(cadMov.dataMovimentacao, alu.alu_id, alu.ent_id, tmo.tmo_id, bancoGestao, listasFechamentoMatricula);
 }
Exemplo n.º 3
0
        /// <summary>
        /// Valida os dados necessários para realizar qualquer movimentação.
        /// Dispara uma ValidationException caso haja algum problema.
        /// </summary>
        /// <param name="cadMov">Entidade de cadastro de movimentação</param>
        /// <param name="alu">Entidade do aluno</param>
        /// <param name="tmo">Entidade tipo de movimentação</param>
        /// <param name="bancoGestao">Transação com banco - obrigatório</param>
        private static void ValidaDadosMovimentacao(MTR_Movimentacao_Cadastro cadMov, MTR_TipoMovimentacao tmo, ACA_Aluno alu, TalkDBTransaction bancoGestao)
        {
            bool isValidInicioMovimentacao;
            bool isValidFechamentoMovimentacao;

            // Valida se está no momento configurado na movimentação.
            MTR_TipoMovimentacaoBO.VerificaPeriodoValidoMovimentacao(cadMov.entMatTurAnterior,
                                                                     cadMov.entAluCurAnterior,
                                                                     cadMov.entMovimentacao.tmo_id,
                                                                     bancoGestao,
                                                                     cadMov.entMovimentacao.mov_dataRealizacao,
                                                                     out isValidInicioMovimentacao,
                                                                     out isValidFechamentoMovimentacao,
                                                                     cadMov.listasFechamentoMatricula);

            if (!isValidInicioMovimentacao)
            {
                throw new ValidationException("Não é possível realizar esse tipo de movimentação nesse momento do calendário escolar.");
            }

            if ((cadMov.entMatTurNovo != null) && (cadMov.entMatTurNovo.tur_id > 0))
            {
                // Verificar se a turma que o aluno vai entrar é do tipo 1-Normal.
                TUR_Turma entTurmaDestino = null;
                if (cadMov.listasFechamentoMatricula.listTurma != null)
                {
                    // Se a lista de fechamento foi alimentada, buscar entidade da lista.
                    entTurmaDestino = cadMov.listasFechamentoMatricula.listTurma.Find(p => p.tur_id == cadMov.entMatTurNovo.tur_id);
                }

                if (entTurmaDestino == null)
                {
                    entTurmaDestino = new TUR_Turma
                    {
                        tur_id = cadMov.entMatTurNovo.tur_id
                    };
                    TUR_TurmaBO.GetEntity(entTurmaDestino, bancoGestao);
                }

                if (entTurmaDestino.tur_tipo != (byte)TUR_TurmaTipo.Normal)
                {
                    throw new ValidationException("Não é possível movimentar o aluno para a turma " +
                                                  entTurmaDestino.tur_codigo + ".");
                }
            }
        }
Exemplo n.º 4
0
 /// <summary>
 /// Calcula o percentual de frequência acumulada do aluno
 /// </summary>
 /// <param name="cadMov">Referência a estrutura de cadastro de movimentação</param>
 /// <param name="tmo_tipoMovimento">Tipo de movimentação</param>
 private static void CalcularFrequenciaAnterior(ref MTR_Movimentacao_Cadastro cadMov, int tmo_tipoMovimento)
 {
     if (MTR_TipoMovimentacaoBO.VerificarMovimentacaoInclusao(tmo_tipoMovimento))
     {
         if ((MTR_TipoMovimentacaoTipoMovimento)tmo_tipoMovimento == MTR_TipoMovimentacaoTipoMovimento.MatriculaInicial)
         {
             cadMov.entMovimentacao.mov_frequencia = 0;
         }
         else if ((MTR_TipoMovimentacaoTipoMovimento)tmo_tipoMovimento == MTR_TipoMovimentacaoTipoMovimento.TransferenciaDaRedeParticular ||
                  (MTR_TipoMovimentacaoTipoMovimento)tmo_tipoMovimento == MTR_TipoMovimentacaoTipoMovimento.TransferenciaDaRedePublicaOutrosEstadosFederal ||
                  (MTR_TipoMovimentacaoTipoMovimento)tmo_tipoMovimento == MTR_TipoMovimentacaoTipoMovimento.TransferenciaDaRedePublicaOutrosMunicipios)
         {
             if (cadMov.entMovimentacao.mov_frequencia <= 0)
             {
                 cadMov.entMovimentacao.mov_frequencia = 100;
             }
         }
         else if ((MTR_TipoMovimentacaoTipoMovimento)tmo_tipoMovimento == MTR_TipoMovimentacaoTipoMovimento.Reconducao)
         {
             cadMov.entMovimentacao.mov_frequencia = 0;
         }
     }
 }
Exemplo n.º 5
0
        /// <summary>
        /// Verifica se o tipo de movimentação gera transferencia de matricula do aluno.
        /// </summary>
        /// <param name="tipoMovimento">Tipo do movimento</param>
        /// <returns></returns>
        public static bool VerificarMovimentacaoTransferenciaMatriculaAluno(MTR_Movimentacao_Cadastro cadMov)
        {
            MTR_MovimentacaoDAO daoMov      = new MTR_MovimentacaoDAO();
            TalkDBTransaction   bancoGestao = daoMov._Banco;

            MTR_TipoMovimentacao tmo;

            if (cadMov.listasFechamentoMatricula.listTipoMovimentacao != null)
            {
                // Se os dados do fechamento de matrícula forem alimentados, pegar dados do fechamento.
                tmo = cadMov.listasFechamentoMatricula.listTipoMovimentacao.
                      Find(p => p.tmo_id == cadMov.entMovimentacao.tmo_id) ?? new MTR_TipoMovimentacao();
            }
            else
            {
                tmo = new MTR_TipoMovimentacao {
                    tmo_id = cadMov.entMovimentacao.tmo_id
                };
                MTR_TipoMovimentacaoBO.GetEntity(tmo, daoMov._Banco);
            }

            switch ((MTR_TipoMovimentacaoTipoMovimento)tmo.tmo_tipoMovimento)
            {
            case MTR_TipoMovimentacaoTipoMovimento.MudancaTurma:
            case MTR_TipoMovimentacaoTipoMovimento.MudancaBlocoPEJA:
            case MTR_TipoMovimentacaoTipoMovimento.RenovacaoMatricula:
                return(true);

            case MTR_TipoMovimentacaoTipoMovimento.Adequacao:
                bool isCurriculoPeriodoEJA = ACA_CurriculoPeriodoBO.VerificaCurriculoPeriodoEJA(new ACA_CurriculoPeriodo {
                    cur_id = cadMov.entAluCurNovo.cur_id, crr_id = cadMov.entAluCurNovo.crr_id, crp_id = cadMov.entAluCurNovo.crp_id
                }, bancoGestao);
                return(!(cadMov.entAluCurAnterior.cur_id == cadMov.entAluCurNovo.cur_id &&
                         cadMov.entAluCurAnterior.crr_id == cadMov.entAluCurNovo.crr_id &&
                         cadMov.entAluCurAnterior.crp_id == cadMov.entAluCurNovo.crp_id &&
                         isCurriculoPeriodoEJA) &&
                       cadMov.entAluCurAnterior.esc_id == cadMov.entAluCurNovo.esc_id &&
                       cadMov.entAluCurAnterior.uni_id == cadMov.entAluCurNovo.uni_id);

            case MTR_TipoMovimentacaoTipoMovimento.MudancaModalidaeEnsino:
                return(cadMov.entAluCurAnterior.esc_id == cadMov.entAluCurNovo.esc_id &&
                       cadMov.entAluCurAnterior.uni_id == cadMov.entAluCurNovo.uni_id);

            case MTR_TipoMovimentacaoTipoMovimento.Reclassificacao:
                ACA_CurriculoPeriodo entCurPerAnterior = new ACA_CurriculoPeriodo
                {
                    cur_id = cadMov.entAluCurAnterior.cur_id,
                    crr_id = cadMov.entAluCurAnterior.crr_id,
                    crp_id = cadMov.entAluCurAnterior.crp_id
                };
                ACA_CurriculoPeriodoBO.GetEntity(entCurPerAnterior, bancoGestao);

                ACA_CurriculoPeriodo entCurPerNovo = new ACA_CurriculoPeriodo
                {
                    cur_id = cadMov.entAluCurNovo.cur_id,
                    crr_id = cadMov.entAluCurNovo.crr_id,
                    crp_id = cadMov.entAluCurNovo.crp_id
                };
                ACA_CurriculoPeriodoBO.GetEntity(entCurPerNovo, bancoGestao);

                // Alterado para pegar os cursos/períodos equivalentes com o curso de destino.
                List <ACA_CurriculoPeriodo> listPeriodosEquivalentes = ACA_CurriculoPeriodoBO.Seleciona_PeriodosRelacionados_Equivalentes(cadMov.entAluCurNovo.cur_id, cadMov.entAluCurNovo.crr_id, cadMov.entAluCurNovo.crp_id);

                return(((entCurPerAnterior.cur_id == entCurPerNovo.cur_id && entCurPerAnterior.crr_id == entCurPerNovo.crr_id) ||
                        (listPeriodosEquivalentes.Count > 0 && listPeriodosEquivalentes.Exists(p => p.cur_id == entCurPerNovo.cur_id && p.crr_id == entCurPerNovo.crr_id))) &&
                       !(entCurPerAnterior.crp_ordem == entCurPerNovo.crp_ordem &&
                         ACA_CurriculoPeriodoBO.VerificaCurriculoPeriodoEJA(entCurPerNovo, bancoGestao) &&
                         entCurPerNovo.crp_turmaAvaliacao) &&
                       entCurPerAnterior.crp_ordem == entCurPerNovo.crp_ordem - 1 &&
                       cadMov.entAluCurAnterior.esc_id == cadMov.entAluCurNovo.esc_id &&
                       cadMov.entAluCurAnterior.uni_id == cadMov.entAluCurNovo.uni_id);

            default:
                return(false);
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// Valida e configura se a turma destino possui a mesma avaliação turma atual do aluno.
        /// </summary>
        /// <param name="cadMov">Estrutura de movimentação</param>
        /// <param name="progressaoPEJA">Verifica se o método é chamado pela tela de progressão</param>
        /// <param name="bancoGestao">Transação com banco Gestão - obrigatório</param>
        public static void ConfiguraTurmaAvaliacao(MTR_Movimentacao_Cadastro cadMov, bool progressaoPEJA, TalkDBTransaction bancoGestao)
        {
            List <ACA_CurriculoPeriodo> listPeriodosEquivalentes = ACA_CurriculoPeriodoBO.
                                                                   Seleciona_PeriodosRelacionados_Equivalentes(cadMov.entAluCurAnterior.cur_id, cadMov.entAluCurAnterior.crr_id, cadMov.entAluCurAnterior.crp_id);

            // Apenas valida a avaliação da turma caso seja o mesmo Curso/Período.
            // Também verifica se os cursos são equivalentes
            if (
                ((cadMov.entAluCurAnterior.cur_id == cadMov.entAluCurNovo.cur_id) &&
                 (cadMov.entAluCurAnterior.crr_id == cadMov.entAluCurNovo.crr_id) &&
                 (cadMov.entAluCurAnterior.crp_id == cadMov.entAluCurNovo.crp_id)) ||
                (listPeriodosEquivalentes.Count > 0 && listPeriodosEquivalentes.Exists(p => p.cur_id == cadMov.entAluCurNovo.cur_id &&
                                                                                       p.crr_id == cadMov.entAluCurNovo.crr_id &&
                                                                                       p.crp_id == cadMov.entAluCurNovo.crp_id)))
            {
                // Apenas valida a avaliação da turma caso definido a turma destino.
                if (cadMov.entMatTurNovo.tur_id > 0)
                {
                    ACA_CurriculoPeriodo entityCurriculoPeriodo = new ACA_CurriculoPeriodo {
                        cur_id = cadMov.entAluCurAnterior.cur_id, crr_id = cadMov.entAluCurAnterior.crr_id, crp_id = cadMov.entAluCurAnterior.crp_id
                    };
                    ACA_CurriculoPeriodoBO.GetEntity(entityCurriculoPeriodo, bancoGestao);

                    TUR_TurmaCurriculoAvaliacao entityTurmaCurriculoAvaliacaoAtual = new TUR_TurmaCurriculoAvaliacao {
                        tur_id = cadMov.entAluCurAvaAnterior.tur_id, cur_id = cadMov.entAluCurAvaAnterior.cur_id, crr_id = cadMov.entAluCurAvaAnterior.crr_id, crp_id = cadMov.entAluCurAvaAnterior.crp_id, tca_id = cadMov.entAluCurAvaAnterior.tca_id
                    };
                    TUR_TurmaCurriculoAvaliacaoBO.GetEntity(entityTurmaCurriculoAvaliacaoAtual, bancoGestao);
                    if (entityTurmaCurriculoAvaliacaoAtual.tca_id > 0)
                    {
                        TUR_TurmaCurriculoAvaliacao entityTurmaCurriculoAvaliacaoDestino;
                        string msg;

                        if (!progressaoPEJA)
                        {
                            // Verifica se a turma destino possui a avaliação da turma origem.
                            entityTurmaCurriculoAvaliacaoDestino =
                                TUR_TurmaCurriculoAvaliacaoBO.SelecionaAvaliacaoExistenteParaTurma(cadMov.entMatTurNovo.tur_id,
                                                                                                   cadMov.entAluCurNovo.cur_id,
                                                                                                   cadMov.entAluCurNovo.crr_id,
                                                                                                   cadMov.entAluCurNovo.crp_id,
                                                                                                   entityTurmaCurriculoAvaliacaoAtual.tca_numeroAvaliacao);
                            msg = "A turma destino do aluno deve possuir o(a) mesmo(a) " +
                                  GestaoEscolarUtilBO.nomePadraoPeriodoAvaliacao(entityCurriculoPeriodo.crp_nomeAvaliacao) + " atual do aluno.";
                        }
                        else
                        {
                            entityTurmaCurriculoAvaliacaoDestino = new TUR_TurmaCurriculoAvaliacao
                            {
                                tur_id = cadMov.entMatTurNovo.tur_id
                                ,
                                cur_id = cadMov.entAluCurAvaNovo.cur_id
                                ,
                                crr_id = cadMov.entAluCurAvaNovo.crr_id
                                ,
                                crp_id = cadMov.entAluCurAvaNovo.crp_id
                                ,
                                tca_id = cadMov.entAluCurAvaNovo.tca_id
                            };
                            TUR_TurmaCurriculoAvaliacaoBO.GetEntity(entityTurmaCurriculoAvaliacaoDestino, bancoGestao);
                            msg = "A turma destino do aluno não possui o(a) " +
                                  GestaoEscolarUtilBO.nomePadraoPeriodoAvaliacao(entityCurriculoPeriodo.crp_nomeAvaliacao) + " configurada para o aluno.";
                        }

                        if ((entityTurmaCurriculoAvaliacaoDestino != null) && (entityTurmaCurriculoAvaliacaoDestino.tca_id > 0))
                        {
                            // Configura o currículo avaliação novo com mesma avaliação, caso necessário.
                            if (cadMov.entAluCurAvaNovo.tca_id <= 0)
                            {
                                cadMov.entAluCurAvaNovo.alu_id = cadMov.entAluCurNovo.alu_id;
                                cadMov.entAluCurAvaNovo.tur_id = entityTurmaCurriculoAvaliacaoDestino.tur_id;
                                cadMov.entAluCurAvaNovo.cur_id = entityTurmaCurriculoAvaliacaoDestino.cur_id;
                                cadMov.entAluCurAvaNovo.crr_id = entityTurmaCurriculoAvaliacaoDestino.crr_id;
                                cadMov.entAluCurAvaNovo.crp_id = entityTurmaCurriculoAvaliacaoDestino.crp_id;
                                cadMov.entAluCurAvaNovo.tca_id = entityTurmaCurriculoAvaliacaoDestino.tca_id;
                            }
                        }
                        else
                        {
                            throw new ValidationException(msg);
                        }
                    }
                    else
                    {
                        throw new ValidationException("Não é possível realizar essa movimentação, pois o aluno não possui " +
                                                      GestaoEscolarUtilBO.nomePadraoPeriodoAvaliacao(entityCurriculoPeriodo.crp_nomeAvaliacao) + " ativo(a) na turma.");
                    }
                }
            }
        }