Example #1
0
 /// <summary>
 /// Remove do cache a entidade.
 /// </summary>
 /// <param name="entity"></param>
 public static void LimpaCache_PeloCurso(ACA_Curso entity)
 {
     if (HttpContext.Current != null)
     {
         GestaoEscolarUtilBO.LimpaCache(string.Format("ACA_Curriculo_GetEntity_{0}_", entity.cur_id));
     }
 }
Example #2
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()));
                }
            }
        }
Example #3
0
        /// <summary>
        /// Valida dados necessários para salvar a entidade. Dispara um ValidationException caso não
        /// esteja válida.
        /// </summary>
        /// <param name="entity">Entidade a validar</param>
        /// <param name="banco">Transação com banco do Gestão - obrigatório</param>
        /// <param name="ent_id">Id da entidade do usuário logado.</param>
        private static void ValidaDados(ACA_AlunoCurriculo entity, TalkDBTransaction banco, Guid ent_id)
        {
            //Validação feita no BO devido a alteração de nome dos campos para os diferentes clientes
            if (entity.cur_id <= 0)
            {
                throw new ACA_AlunoCurriculo_ValidationException(GestaoEscolarUtilBO.nomePadraoCurso(ent_id) + " é obrigatório.");
            }

            if (entity.crr_id <= 0)
            {
                throw new ACA_AlunoCurriculo_ValidationException(GestaoEscolarUtilBO.nomePadraoCurso(ent_id) + " é obrigatório.");
            }

            if (entity.crp_id <= 0)
            {
                throw new ACA_AlunoCurriculo_ValidationException(GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id) + " é obrigatório.");
            }

            if (!string.IsNullOrEmpty(entity.alc_matriculaEstadual) && entity.alc_matriculaEstadual.Length > 50)
            {
                throw new ACA_AlunoCurriculo_ValidationException(GestaoEscolarUtilBO.nomePadraoMatriculaEstadual(ent_id) + " pode conter até 50 caracteres.");
            }

            //Se for uma nova matrícula e se a situação dela for 'Ativa' ou 'Em matrícula'
            //Verifica se já existe uma matrícula cadastrada com os mesmos dados
            if (entity.IsNew &&
                (entity.alc_situacao == Convert.ToByte(ACA_AlunoCurriculoSituacao.Ativo) ||
                 entity.alc_situacao == Convert.ToByte(ACA_AlunoCurriculoSituacao.EmMatricula)))
            {
                if (Existe_AlunoCurriculo(entity.alu_id, entity.cur_id, entity.crr_id, entity.crp_id, banco))
                {
                    ESC_Escola esc = new ESC_Escola {
                        esc_id = entity.esc_id
                    };
                    ESC_EscolaBO.GetEntity(esc, banco);

                    ACA_Curso cur = new ACA_Curso {
                        cur_id = entity.cur_id
                    };
                    ACA_CursoBO.GetEntity(cur, banco);

                    ACA_CurriculoPeriodo crp = new ACA_CurriculoPeriodo {
                        cur_id = entity.cur_id, crr_id = entity.crr_id, crp_id = entity.crp_id
                    };
                    ACA_CurriculoPeriodoBO.GetEntity(crp, banco);

                    throw new ACA_AlunoCurriculo_ValidationException("Já existe uma matrícula 'Ativa' ou 'Em matrícula' cadastrada com os mesmos dados: <BR/>" +
                                                                     "Escola: " + esc.esc_nome + "<BR/>" +
                                                                     GestaoEscolarUtilBO.nomePadraoCurso(ent_id) + ": " + cur.cur_nome + "<BR/>" +
                                                                     GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id) + ": " + crp.crp_descricao);
                }
            }
        }
Example #4
0
        public static bool DeletarPorCalendario
        (
            int cal_id
            , Guid ent_id
            , List <ACA_CalendarioCurso> ltCalendarioCurso
            , Data.Common.TalkDBTransaction banco
        )
        {
            DataTable dt = SelecionaCursosAssociados(cal_id, ent_id);

            for (int i = 0; i < dt.Rows.Count; i++)
            {
                int cur_id = Convert.ToInt32(dt.Rows[i]["cur_id"].ToString());

                // Exclui cache de calendário guardado para o curso.
                if (HttpContext.Current != null)
                {
                    string chave = string.Format("CalendarioAnual_{0}", cur_id);
                    HttpContext.Current.Cache.Remove(chave);
                }

                if (!ltCalendarioCurso.Exists(p => p.cur_id == cur_id))
                {
                    if (VerificaTurmaExistente(cal_id, cur_id, ent_id))
                    {
                        ACA_Curso entityCurso = new ACA_Curso {
                            cur_id = cur_id
                        };
                        ACA_CursoBO.GetEntity(entityCurso, banco);

                        throw new ValidationException("Não é possível excluir o(a) " + GestaoEscolarUtilBO.nomePadraoCurso(ent_id) + " " + entityCurso.cur_nome + " pois possui outros registros ligados a ele(a).");
                    }
                }
            }

            ACA_CalendarioCursoDAO dao = new ACA_CalendarioCursoDAO {
                _Banco = banco
            };

            dao.DeleteBy_Calendario(cal_id);

            return(true);
        }
        /// <summary>
        /// Retorna a matriz curricular das disciplinas da turma
        /// </summary>
        /// <param name="tur_id">ID da turma</param>
        /// <param name="cur_efetivacaoSemestral">flag que indica se o curso permite efetivação semestral</param>
        /// <returns></returns>
        public static List <MatrizCurricular> SelecionaMatrizCurricularTurma
        (
            long tur_id
            , out bool efetivacaoSemestral
        )
        {
            List <TUR_TurmaCurriculo> listaCurriculo = TUR_TurmaCurriculoBO.GetSelectBy_Turma(tur_id, GestaoEscolarUtilBO.MinutosCacheLongo);

            ACA_Curso entityCurso = new ACA_Curso {
                cur_id = listaCurriculo[0].cur_id
            };

            ACA_CursoBO.GetEntity(entityCurso);

            List <MatrizCurricular> lista = new List <MatrizCurricular>();

            if (entityCurso.cur_efetivacaoSemestral)
            {
                efetivacaoSemestral = true;

                ACA_CurriculoControleSemestralDisciplinaPeriodoDAO dao = new ACA_CurriculoControleSemestralDisciplinaPeriodoDAO();
                DataTable dt = dao.SelecionaMatrizCurricularTurma(tur_id);

                foreach (DataRow dr in dt.Rows)
                {
                    MatrizCurricular ent = new MatrizCurricular();

                    ent.tud_id         = Convert.ToInt64(dr["tud_id"]);
                    ent.tpc_id         = Convert.ToInt32(dr["tpc_id"]);
                    ent.csp_nota       = Convert.ToBoolean(dr["csp_nota"]);
                    ent.csp_frequencia = Convert.ToBoolean(dr["csp_frequencia"]);

                    lista.Add(ent);
                }
            }
            else
            {
                efetivacaoSemestral = false;
            }

            return(lista);
        }
Example #6
0
        /// <summary>
        /// Carrega os documentos ativos
        /// </summary>
        private void CarregarDocumentos(long alu_id, int mtu_id)
        {
            string mtuId = "";

            if (mtu_id > 0)
            {
                mtuId = Convert.ToString(mtu_id);
            }
            MTR_MatriculaTurma matriculaTurma = MTR_MatriculaTurmaBO.GetEntity(new MTR_MatriculaTurma {
                alu_id = __SessionWEB.__UsuarioWEB.alu_id, mtu_id = mtu_id
            });
            //TUR_Turma turma = TUR_TurmaBO.GetEntity(new TUR_Turma { tur_id = matriculaTurma.tur_id });
            TUR_TurmaCurriculo curriculo = TUR_TurmaCurriculoBO.GetSelectBy_Turma(matriculaTurma.tur_id).FirstOrDefault();
            ACA_Curso          curso     = ACA_CursoBO.GetEntity(new ACA_Curso {
                cur_id = curriculo.cur_id
            });

            this.tne_id = curso.tne_id;


            DataTable dtArea = ACA_TipoAreaDocumentoBO.SelecionarAtivos();

            dtArea.Columns.Add("PPP");

            // Adiciona PPP
            DataRow drPPP = dtArea.NewRow();

            drPPP["tad_id"]   = -1;
            drPPP["tad_nome"] = GetGlobalResourceObject("Mensagens", "MSG_PLANO_POLITICO_PEDAGOGICO").ToString();
            drPPP["PPP"]      = true;
            drPPP["tad_cadastroEscolaBoolean"] = true;
            dtArea.Rows.Add(drPPP);

            rptAreas.DataSource = dtArea;
            rptAreas.DataBind();

            lblSemAreas.Text = UtilBO.GetErroMessage((string)GetGlobalResourceObject("UserControl", "UCPlanejamentoProjetos.lblSemAreas.Text"),
                                                     UtilBO.TipoMensagem.Informacao);
            lblSemAreas.Visible = rptAreas.Items.Count <= 0;
        }
Example #7
0
        /// <summary>
        /// Carrega os dados de lançamento de frequência externa do aluno
        /// </summary>
        private void CarregarLancamento()
        {
            List <DadosLancamentoFreqExterna> lDadosAluno = CLS_AlunoFrequenciaExternaBO.SelecionaDadosAlunoLancamentoFrequenciaExterna(VS_alu_id, VS_mtu_id);

            if (lDadosAluno.Any())
            {
                int       cur_id = lDadosAluno.First().cur_id;
                ACA_Curso cur    = new ACA_Curso {
                    cur_id = cur_id
                };
                ACA_CursoBO.GetEntity(cur);

                //Verifica se o nível de ensino do curso é do ensino infantil.
                bool ensinoInfantil = cur.tne_id == ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_NIVEL_ENSINO_EDUCACAO_INFANTIL, __SessionWEB.__UsuarioWEB.Usuario.ent_id);

                #region Períodos

                var periodos = from DadosAlunoEntradaRede item in VS_ListaDadosPeriodo
                               orderby item.tpc_ordem
                               group item by item.tpc_id
                               into g
                               select
                               new
                {
                    tpc_id = g.Key
                    ,
                    tpc_nome = g.First().cap_descricao
                    ,
                    g.First().tpc_ordem
                };

                rptPeriodosNomes.DataSource                      = periodos;
                rptPeriodosColunasFixas.DataSource               = periodos;
                rptPeriodosNomesEnriquecimento.DataSource        = periodos;
                rptPeriodosNomesEI.DataSource                    = periodos;
                rptPeriodosColunasFixasEnriquecimento.DataSource = periodos;
                rptPeriodosColunasFixasEI.DataSource             = periodos;
                rptPeriodosNomes.DataBind();
                rptPeriodosColunasFixas.DataBind();
                rptPeriodosNomesEnriquecimento.DataBind();
                rptPeriodosNomesEI.DataBind();
                rptPeriodosColunasFixasEnriquecimento.DataBind();
                rptPeriodosColunasFixasEI.DataBind();

                #endregion Períodos

                #region Disciplinas

                bool controleOrdemDisciplinas = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.CONTROLAR_ORDEM_DISCIPLINAS,
                                                                                                           __SessionWEB.__UsuarioWEB.Usuario.ent_id);

                var todasDisciplinas = (from DadosLancamentoFreqExterna item in lDadosAluno
                                        where item.tur_id > 0 && item.tud_tipo != (byte)TurmaDisciplinaTipo.Experiencia
                                        orderby item.tud_tipo, item.Disciplina
                                        group item by item.Disciplina into g
                                        select new
                {
                    tud_id = g.First().tud_id
                    ,
                    Disciplina = g.Key
                    ,
                    tds_ordem = g.First().tds_ordem
                    ,
                    tud_tipo = g.First().tud_tipo
                    ,
                    regencia = g.First().tud_tipo == (byte)TurmaDisciplinaTipo.Regencia ||
                               g.First().tud_tipo == (byte)TurmaDisciplinaTipo.ComponenteRegencia ||
                               (g.First().tud_tipo == (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia &&
                                controleOrdemDisciplinas) ? 1 : 2
                    ,
                    enriquecimentoCurricular = g.First().EnriquecimentoCurricular
                    ,
                    frequencias = (from per in periodos.ToList()
                                   orderby per.tpc_ordem
                                   select new
                    {
                        per.tpc_id
                        ,
                        frequencia = (from DadosLancamentoFreqExterna bFrequencia in lDadosAluno
                                      where bFrequencia.Disciplina == g.Key &&
                                      bFrequencia.tpc_id == per.tpc_id
                                      select new
                        {
                            bFrequencia.numeroAulas
                            ,
                            bFrequencia.numeroFaltas
                            ,
                            numeroAulasPrevistas = bFrequencia.possuiLancamentoAulasPrevistas ?
                                                   bFrequencia.numeroAulasPrevistas.ToString() : "-"
                            ,
                            bFrequencia.possuiLancamentoAulasPrevistas
                            ,
                            tud_Tipo = g.First().tud_tipo
                            ,
                            bFrequencia.tud_id
                            ,
                            bFrequencia.mtu_id
                            ,
                            bFrequencia.mtd_id
                            ,
                            bFrequencia.tud_idRegencia
                            ,
                            bFrequencia.mtd_idRegencia
                            ,
                            afx_id = bFrequencia.ID
                            ,
                            enriquecimentoCurricular = bFrequencia.EnriquecimentoCurricular
                        }).FirstOrDefault()
                    })
                });

                var experiencias = (from DadosLancamentoFreqExterna item in lDadosAluno
                                    where item.tur_id > 0 && item.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia
                                    orderby item.tud_tipo, item.Disciplina
                                    group item by item.Disciplina into g
                                    select new
                {
                    tud_id = g.First().tud_id
                    ,
                    Disciplina = g.Key
                    ,
                    tds_ordem = g.First().tds_ordem
                    ,
                    tud_tipo = g.First().tud_tipo
                    ,
                    regencia = g.First().tud_tipo == (byte)TurmaDisciplinaTipo.Regencia ||
                               g.First().tud_tipo == (byte)TurmaDisciplinaTipo.ComponenteRegencia ||
                               (g.First().tud_tipo == (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia &&
                                controleOrdemDisciplinas) ? 1 : 2
                    ,
                    enriquecimentoCurricular = g.First().EnriquecimentoCurricular
                    ,
                    frequencias = (from per in periodos.ToList()
                                   orderby per.tpc_ordem
                                   select new
                    {
                        per.tpc_id
                        ,
                        frequencia = (from DadosLancamentoFreqExterna bFrequencia in lDadosAluno
                                      where bFrequencia.Disciplina == g.Key &&
                                      bFrequencia.tpc_id == per.tpc_id
                                      select new
                        {
                            bFrequencia.numeroAulas
                            ,
                            bFrequencia.numeroFaltas
                            ,
                            numeroAulasPrevistas = bFrequencia.possuiLancamentoAulasPrevistas ?
                                                   bFrequencia.numeroAulasPrevistas.ToString() : "-"
                            ,
                            bFrequencia.possuiLancamentoAulasPrevistas
                            ,
                            tud_Tipo = g.First().tud_tipo
                            ,
                            bFrequencia.tud_id
                            ,
                            bFrequencia.mtu_id
                            ,
                            bFrequencia.mtd_id
                            ,
                            bFrequencia.tud_idRegencia
                            ,
                            bFrequencia.mtd_idRegencia
                            ,
                            afx_id = bFrequencia.ID
                            ,
                            enriquecimentoCurricular = bFrequencia.EnriquecimentoCurricular
                        }).FirstOrDefault()
                    })
                });

                var disciplinas = (from item in todasDisciplinas
                                   where !item.enriquecimentoCurricular //Retira as que são de enriquecimento curricular
                                   select item
                                   );

                // Realiza uma ordenação posterior em que so importa se a disciplina é ou nao regencia/componente da regencia para manter o agrupamento
                var dispOrdenadas = from item in disciplinas
                                    orderby item.regencia, controleOrdemDisciplinas ? item.tds_ordem.ToString() : item.Disciplina
                select item;

                // "Agrupa" a frequência das disciplinas componentes e complementares à regência.
                QtComponenteRegencia = dispOrdenadas.Count(p => ((byte)TurmaDisciplinaTipo.ComponenteRegencia == p.tud_tipo || (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia == p.tud_tipo));

                // "Agrupa" a frequência das disciplinas
                QtComponentes = dispOrdenadas.Count();

                if (!ensinoInfantil)
                {
                    divDisciplinas.Visible    = true;
                    rptDisciplinas.DataSource = dispOrdenadas;
                    rptDisciplinas.DataBind();
                }
                else
                {
                    divDisciplinas.Visible = false;
                }

                #endregion Disciplinas

                #region Disciplinas de enriquecimento curricular e experiências

                var disciplinasEnriquecimentoCurricular = (from item in todasDisciplinas
                                                           where item.enriquecimentoCurricular //Verifica se são de enriquecimento curricular
                                                           select item
                                                           );

                if (disciplinasEnriquecimentoCurricular.Count() > 0 || experiencias.Count() > 0)
                {
                    divEnriquecimentoCurricular.Visible = true;

                    // Realiza uma ordenação posterior em que so importa se a disciplina é ou nao regencia/componente da regencia para manter o agrupamento
                    var dispOrdenadasEnriquecimento = from item in disciplinasEnriquecimentoCurricular
                                                      orderby item.regencia, controleOrdemDisciplinas ? item.tds_ordem.ToString() : item.Disciplina
                    select item;


                    rptDisciplinasEnriquecimentoCurricular.DataSource = dispOrdenadasEnriquecimento;
                    rptDisciplinasEnriquecimentoCurricular.DataBind();

                    rptDisciplinasExperiencias.DataSource = experiencias.OrderBy(p => controleOrdemDisciplinas ? p.tds_ordem.ToString() : p.Disciplina);
                    rptDisciplinasExperiencias.DataBind();
                }
                else
                {
                    divEnriquecimentoCurricular.Visible = false;
                }

                #endregion Disciplinas de enriquecimento curricular

                #region Ensino Infantil

                if (ensinoInfantil)
                {
                    divEnsinoInfantil.Visible = true;

                    rptDisciplinasEnsinoInfantil.DataSource = dispOrdenadas;
                    rptDisciplinasEnsinoInfantil.DataBind();
                }
                else
                {
                    divEnsinoInfantil.Visible = false;
                }

                #endregion
            }
        }
Example #8
0
        public new static bool Delete
        (
            MTR_ParametroTipoMovimentacaoCurriculoPeriodo entity
            , Data.Common.TalkDBTransaction banco
            , Guid ent_id
        )
        {
            MTR_ParametroTipoMovimentacaoCurriculoPeriodoDAO dao = new MTR_ParametroTipoMovimentacaoCurriculoPeriodoDAO();

            if (banco == null)
            {
                dao._Banco.Open(IsolationLevel.ReadCommitted);
            }
            else
            {
                dao._Banco = banco;
            }

            try
            {
                // Verifica se o curso período do parâmetro de movimentação pode ser deletado
                if (GestaoEscolarUtilBO.VerificaIntegridadaChaveDupla("tmo_id", "tmp_id", entity.tmo_id.ToString(), entity.tmp_id.ToString(), "MTR_TipoMovimentacaoCurriculoPeriodo,MTR_ParametroTipoMovimentacaoCurriculoPeriodo", dao._Banco))
                {
                    MTR_TipoMovimentacaoCurriculoPeriodo tmp = new MTR_TipoMovimentacaoCurriculoPeriodo {
                        tmo_id = entity.tmo_id, tmp_id = entity.tmp_id
                    };
                    MTR_TipoMovimentacaoCurriculoPeriodoBO.GetEntity(tmp, dao._Banco);

                    ACA_Curso cur = new ACA_Curso {
                        cur_id = tmp.cur_id
                    };
                    ACA_CursoBO.GetEntity(cur, dao._Banco);

                    ACA_CurriculoPeriodo crp = new ACA_CurriculoPeriodo {
                        cur_id = tmp.cur_id, crr_id = tmp.crr_id, crp_id = tmp.crp_id
                    };
                    ACA_CurriculoPeriodoBO.GetEntity(crp, dao._Banco);

                    throw new ValidationException("Não é possível excluir o(a) " + GestaoEscolarUtilBO.nomePadraoCurso(ent_id).ToLower() + " " + cur.cur_nome + " e " + GestaoEscolarUtilBO.nomePadraoPeriodo(ent_id).ToLower() + " " + crp.crp_descricao + " pois possui outros registros ligados a ele(a).");
                }

                // Deleta logicamente o parâmetro do curso período para parâmetro de movimentação
                dao.Delete(entity);

                return(true);
            }
            catch (Exception err)
            {
                if (banco == null)
                {
                    dao._Banco.Close(err);
                }

                throw;
            }
            finally
            {
                if (banco == null)
                {
                    dao._Banco.Close();
                }
            }
        }
Example #9
0
    protected void Page_Load(object sender, EventArgs e)
    {
        lblMsgParecer.Text = "Marque apenas as reuniões em que o responsável esteve presente.<br>";

        //"Marque a opção Efetivado para indicar que o lançamento de frequência do " +
        //"dia foi finalizado e todas as ausências foram apontadas.";
        lblMsgParecer.Text = UtilBO.GetErroMessage(lblMsgParecer.Text, UtilBO.TipoMensagem.Informacao);
        ScriptManager sm = ScriptManager.GetCurrent(this);

        if (sm != null)
        {
            sm.Scripts.Add(new ScriptReference(ArquivoJS.JqueryFixer));
            RegistrarParametrosMensagemSair(true, (__SessionWEB.__UsuarioWEB.Docente.doc_id > 0));
            sm.Scripts.Add(new ScriptReference(ArquivoJS.ExitPageConfirm));
            sm.Scripts.Add(new ScriptReference("~/Includes/jsSetExitPageConfirmer.js"));
            sm.Scripts.Add(new ScriptReference(ArquivoJS.MsgConfirmBtn));

            // A ordem dos 2 scripts abaixo não deve ser alterada - se for, as máscaras
            // dos campos não vai funcionar, pois no primeiro script ele "refaz" as tabelas
            // com o JQuery.Fixer, e por isso não adianta setar as máscaras antes.
            sm.Scripts.Add(new ScriptReference(ArquivoJS.JQueryValidation));
            sm.Scripts.Add(new ScriptReference(ArquivoJS.JqueryMask));
            sm.Scripts.Add(new ScriptReference(ArquivoJS.MascarasCampos));
            sm.Scripts.Add(new ScriptReference(ArquivoJS.CamposData));
            sm.Scripts.Add(new ScriptReference("~/Includes/jsCadastroFrequenciaReuniaoResponsaveis.js"));

            if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.BOTAO_SALVAR_PERMANECE_TELA, __SessionWEB.__UsuarioWEB.Usuario.ent_id))
            {
                if (!Convert.ToString(_btnCancelar.CssClass).Contains("btnMensagemUnload"))
                {
                    _btnCancelar.CssClass += " btnMensagemUnload";
                }

                if (!Convert.ToString(_btnCancelar2.CssClass).Contains("btnMensagemUnload"))
                {
                    _btnCancelar2.CssClass += " btnMensagemUnload";
                }
            }
        }

        HabilitarControlesTela(__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_alterar);

        if (!IsPostBack)
        {
            string message = __SessionWEB.PostMessages;
            if (!string.IsNullOrEmpty(message))
            {
                _lblMessage.Text = message;
            }

            _carregaComboHora();
            _carregaComboMinuto();
            if (Session["tur_idFrequencia"] != null)
            {
                VS_tur_id = Convert.ToInt32(Session["tur_idFrequencia"]);

                Session.Remove("tur_idFrequencia");

                TUR_Turma tur = new TUR_Turma
                {
                    tur_id = VS_tur_id
                };
                TUR_TurmaBO.GetEntity(tur);

                ACA_FormatoAvaliacao fav = new ACA_FormatoAvaliacao
                {
                    fav_id = tur.fav_id
                };
                ACA_FormatoAvaliacaoBO.GetEntity(fav);

                ESC_Escola entEscola = ESC_EscolaBO.GetEntity(
                    new ESC_Escola {
                    esc_id = tur.esc_id
                });

                List <TUR_TurmaCurriculo> crrTur = TUR_TurmaCurriculoBO.GetSelectBy_Turma(VS_tur_id, ApplicationWEB.AppMinutosCacheLongo);

                ACA_Curso cur = new ACA_Curso
                {
                    cur_id = crrTur[0].cur_id
                };
                ACA_CursoBO.GetEntity(cur);

                VS_cal_id = tur.cal_id;

                if (Session["cap_idFrequencia"] != null && cadastroReunioesPorPeriodo)
                {
                    VS_cap_id = Convert.ToInt32(Session["cap_idFrequencia"]);
                    Session.Remove("tur_idFrequencia");
                }

                ACA_CursoReunioes crn = ACA_CursoReunioesBO.SelecionaPorCursoCalendarioPeriodo
                                        (
                    cur.cur_id
                    ,
                    crrTur[0].crr_id
                    ,
                    VS_cal_id
                    ,
                    cadastroReunioesPorPeriodo ? VS_cap_id : -1
                                        );

                VS_qtd_reunioes = crn.crn_qtde;

                string esc_nome = entEscola.esc_nome;

                if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.ORDENAR_ESCOLAS_POR_CODIGO, __SessionWEB.__UsuarioWEB.Usuario.ent_id))
                {
                    esc_nome = entEscola.esc_codigo + " - " + esc_nome;
                }

                lblTurma.Text  = "Escola: <b>" + esc_nome + "</b><br />";
                lblTurma.Text += "Turma: <b>" + tur.tur_codigo + "</b>";
                lblCurso.Text  = GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id) + ": <b>" + cur.cur_nome + "</b>";

                if (cadastroReunioesPorPeriodo)
                {
                    ACA_CalendarioPeriodo cap = new ACA_CalendarioPeriodo {
                        cal_id = VS_cal_id, cap_id = VS_cap_id
                    };
                    ACA_CalendarioPeriodoBO.GetEntity(cap);
                    lblPeriodoCalendario.Text = GestaoEscolarUtilBO.nomePadraoPeriodo_Calendario(__SessionWEB.__UsuarioWEB.Usuario.ent_id) + ": <b>" + cap.cap_descricao + (periodoAberto ? " (aberto)" : string.Empty) + "</b>";

                    UCComboPeriodoCalendario1.Visible = false;
                    lblPeriodoCalendario.Visible      = true;
                }
                else
                {
                    lblPeriodoCalendario.Visible      = false;
                    UCComboPeriodoCalendario1.Visible = true;

                    // Carregar combo de período do calendário.
                    UCComboPeriodoCalendario1.CarregarTodosPor_EventoEfetivacao(VS_cal_id, -1, VS_tur_id, __SessionWEB.__UsuarioWEB.Docente.doc_id);
                }

                VerificaRegrasCurso(tur, fav);
                CarregarTelaLancametoFrequencia();
            }
            else
            {
                Response.Redirect("~/Classe/ReunioesResponsaveisFrequencia/Busca.aspx", false);
                HttpContext.Current.ApplicationInstance.CompleteRequest();
            }
        }

        _UCComboOrdenacao1._OnSelectedIndexChange += CarregarTelaLancametoFrequencia;
        UCComboPeriodoCalendario1.IndexChanged    += UCComboPeriodoCalendario1_IndexChanged;
    }