Пример #1
0
    /// <summary>
    /// Carrega os grids de disciplinas da turma
    /// </summary>
    /// <param name="cur_id">id do curso</param>
    /// <param name="crr_id">id do currículo</param>
    /// <param name="crp_id">id do currículo período</param>
    /// <param name="tipo">tipo de disciplina (ex: 1–Obrigatória,3–Optativa...)</param>
    /// <param name="tur_id">id da turma</param>
    /// <param name="esc_id">Id da escola</param>
    /// <param name="uni_id">Id da unidade da escola</param>
    /// <param name="ProfessorEspecialista">Professor especialista</param>
    /// <param name="dtDocentes">Tabela de docentes da escola</param>
    /// <param name="dtAvaliacoesFormato">Tabela com avaliações periódicas do formato - será mostrada na coluna controle semestral</param>
    /// <param name="dtDisciplinaNaoAvaliado">Tabela de disciplinas não avaliadas - todas as disciplinas da turma</param>
    /// <param name="bloqueioAtribuicaoDocente">Flag que indica se é pra bloquear a atribuição de docente para a escola</param>
    public void CarregaGridDisciplinas
    (
        int cur_id
        , int crr_id
        , int crp_id
        , ACA_CurriculoDisciplinaTipo tipo
        , long tur_id
        , int esc_id
        , int uni_id
        , bool ProfessorEspecialista
        , ref DataTable dtDocentes
        , DataTable dtAvaliacoesFormato
        , ref DataTable dtDisciplinaNaoAvaliado
        , bool bloqueioAtribuicaoDocente
        , ref DataTable dtVigenciasDocentes
        , bool aplicarNovaRegraDocenciaCompartilhada
    )
    {
        dtDocentesEscola        = dtDocentes;
        DtAvaliacoesFormato     = dtAvaliacoesFormato;
        DtDisciplinaNaoAvaliado = dtDisciplinaNaoAvaliado;
        DtVigenciasDocentes     = dtVigenciasDocentes;

        if ((DtDisciplinaNaoAvaliado == null) && (tur_id > 0))
        {
            // Carregar avaliações que devem ser desconsideradas para a disciplina.
            DtDisciplinaNaoAvaliado = TUR_TurmaDisciplinaNaoAvaliadoBO.GetSelectBy_Turma(tur_id);
        }

        bool mostraAvaliacoes = (DtAvaliacoesFormato != null) && (DtAvaliacoesFormato.Rows.Count > 0) && TUR_TurmaBO.VerificaAcessoControleSemestral(tur_id);

        gvDisciplina.Columns[indiceColunaAvaliacoesPeriodicas].Visible = mostraAvaliacoes;

        // Variáveis que carregam o combo de professor.
        escola_esc_id = esc_id;
        escola_uni_id = uni_id;
        escola_bloqueioAtribuicaoDocente = bloqueioAtribuicaoDocente;
        professorEspecialista            = ProfessorEspecialista;

        gvDisciplina.Columns[indiceColunaQtAulasSemanais].Visible =

            tipo != ACA_CurriculoDisciplinaTipo.DisciplinaPrincipal;

        // Carregando as disciplinas de acordo como o tipo dado.
        DataTable dtDisciplina = ACA_CurriculoDisciplinaBO.GetSelectBy_Curso_Tipo(cur_id, crr_id, crp_id, tipo, tur_id);

        lblMensagemControleSemestral.Visible = mostraAvaliacoes && dtDisciplina.Rows.Count > 0;
        lblMensagemControleSemestral.Text    = TextoControleSemestral;

        // Guarda todas as disciplinas da turma
        string tud_ids = string.Join(",", (from DataRow dr in dtDisciplina.Rows

                                           select dr["tud_id"].ToString()).ToArray());

        listTurmaDocentes = TUR_TurmaDocenteBO.SelecionaDocentesDisciplina(tud_ids);

        // Caso o não tenho o tipo de disciplina aparece seguinte mensagem.
        gvDisciplina.EmptyDataText = (dtDisciplina == null)
                                        ? string.Format("É necessário selecionar o(a) {0} e o(a) {1}.",
                                                        GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower(),
                                                        GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower())
                                        : string.Format("Não foram encontrados(as) " + GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA_PLURAL_MIN") + " para o(a) {0} e o(a) {1} selecionado(a).",
                                                        GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower(),
                                                        GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower());

        this.aplicarNovaRegraDocenciaCompartilhada = aplicarNovaRegraDocenciaCompartilhada;
        gvDisciplina.DataSource = dtDisciplina;
        gvDisciplina.DataBind();

        // Volta o valor das tabelas (caso tenham sido carregados no DataBind do grid).
        dtDocentes = dtDocentesEscola;
        dtDisciplinaNaoAvaliado = DtDisciplinaNaoAvaliado;
    }
Пример #2
0
        /// <summary>
        /// Carrega dados da turma na tela para alteração.
        /// </summary>
        /// <param name="tur_id">ID da turma</param>
        private void CarregarDadosAlteracao(long tur_id)
        {
            try
            {
                VS_tur_id = tur_id;
                // Carregar entidades.
                TUR_Turma entTurma = new TUR_Turma {
                    tur_id = tur_id
                };
                TUR_TurmaBO.GetEntity(entTurma);

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

                if (!ValidaDadosTurma(entTurma, entEscola))
                {
                    return;
                }

                uccFiltroEscola.Uad_ID = entEscola.uad_idSuperiorGestao;
                uccFiltroEscola_IndexChangedUA();
                uccFiltroEscola.SelectedValueEscolas = new[] { entTurma.esc_id, entTurma.uni_id };
                uccFiltroEscola_IndexChangedUnidadeEscola();
                uccCalendario.Valor = entTurma.cal_id;

                DtVigenciasDocentes = TUR_TurmaDocenteBO.SelecionaVigenciasDocentesPorDisciplina(tur_id);

                VS_ListaCurriculoDisciplina = new List <ACA_CurriculoDisciplina>();
                DataTable dt = TUR_TurmaDisciplinaBO.SelecionarTurmaDisciplina_CurriculoDisciplina_By_Turma(tur_id);
                for (int row = 0; row < dt.Rows.Count; row++)
                {
                    ACA_CurriculoDisciplina obj = new ACA_CurriculoDisciplina();
                    obj.dis_nome      = dt.Rows[row]["dis_nome"].ToString();
                    obj.cur_nome      = dt.Rows[row]["cur_nome"].ToString();
                    obj.crp_descricao = dt.Rows[row]["crp_descricao"].ToString();
                    obj.crp_id        = (int)dt.Rows[row]["crp_id"];
                    obj.crr_id        = (int)dt.Rows[row]["crr_id"];
                    obj.cur_id        = (int)dt.Rows[row]["cur_id"];
                    obj.dis_id        = (int)dt.Rows[row]["dis_id"];
                    obj.tds_id        = (int)dt.Rows[row]["tds_id"];
                    obj.IsNew         = false;
                    VS_ListaCurriculoDisciplina.Add(obj);
                }

                divDiciplinas.Visible = true;
                AdicionaVazio();
                grvDiciplinas.DataSource = VS_ListaCurriculoDisciplina;
                grvDiciplinas.DataBind();

                uccFormatoAvaliacao.CarregarFormatoPorFormatoPadraoAtivo(entTurma.fav_id);
                uccFormatoAvaliacao.Valor = entTurma.fav_id;

                txtCodigoTurma.Text = entTurma.tur_codigo;
                txtCodigoInep.Text  = entTurma.tur_codigoInep;
                txtCapacidade.Text  = entTurma.tur_vagas.ToString();

                if (dt.Rows.Count > 0)
                {
                    // Carga horária semanal da disciplina.
                    txtAulasSemanais.Text = dt.Rows[0]["tud_cargaHorariaSemanal"].ToString();

                    string nomeDocente = string.Empty;
                    if (!string.IsNullOrEmpty(dt.Rows[0]["doc_id"].ToString()))
                    {
                        DataTable informacoesDocente =
                            ACA_DocenteBO.SelecionaPorColaboradorDocente(
                                Convert.ToInt64(dt.Rows[0]["col_id"]),
                                Convert.ToInt64(dt.Rows[0]["doc_id"]));
                        nomeDocente = informacoesDocente.Rows[0]["pes_nome"].ToString();
                    }

                    VS_tud_id = Convert.ToInt64(dt.Rows[0]["tud_id"]);
                    //VS_tdt_id = (int)dt.Rows[0]["tdt_id"];
                    divDocente.Visible = true;

                    dtDocentes = new DataTable();
                    dtDocentes.Columns.Add("posicao");
                    dtDocentes.Columns.Add("tud_id");
                    dtDocentes.Columns.Add("qtdedocentes");
                    dtDocentes.Columns.Add("tds_id");

                    for (int i = 1; i <= QtdeDocentes; i++)
                    {
                        DataRow dr = dtDocentes.NewRow();
                        dr["posicao"]      = i;
                        dr["tud_id"]       = VS_tud_id;
                        dr["qtdedocentes"] = QtdeDocentes;
                        dr["tds_id"]       = Convert.ToInt32(dt.Rows[0]["tds_id"]);
                        dtDocentes.Rows.Add(dr);
                    }

                    bloqueioAtribuicao      = false;
                    esc_id                  = entTurma.esc_id;
                    uni_id                  = entTurma.uni_id;
                    tds_id                  = Convert.ToInt32(dt.Rows[0]["tds_id"]);
                    buscaDocente            = true;
                    tur_docenteEspecialista = entTurma.tur_docenteEspecialista;

                    rptDocentes.DataSource = dtDocentes;
                    rptDocentes.DataBind();
                }

                uccTurno.Valor = entTurma.trn_id;

                if (entTurma.tur_participaRodizio)
                {
                    chkRodizio.Checked = true;
                }

                ddlSituacao.SelectedValue = entTurma.tur_situacao.ToString();

                DesabilitaDadosAlteracao();

                RegistraScriptConfirmacao(entTurma);
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar a turma multisseriada.", UtilBO.TipoMensagem.Erro);
            }
        }
Пример #3
0
        /// <summary>
        /// Carrega todas as posições de docente permitidas pelo parâmetro.
        /// </summary>
        /// <param name="tud_id">Id da disciplina.</param>
        /// <param name="doc_id">Id do docente.</param>
        /// <param name="carregarDocentesComAtrib">Verifica se é pra carregar somente os docentes com atribuição.</param>
        public void CarregarPorParametro(long tud_id = -1, long doc_id = -1)
        {
            try
            {
                int qtdPosicoes = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_DOCENTES_VIGENTES_DISCIPLINA, __SessionWEB.__UsuarioWEB.Usuario.ent_id);

                bool carregarDocentesComAtrib = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.NAO_MOSTRAR_POSICAO_DOCENTES_PLANEJAMENTO, __SessionWEB.__UsuarioWEB.Usuario.ent_id);

                ddlCombo.Items.Clear();

                if (tud_id > 0)
                {
                    if (doc_id > 0)
                    {
                        List <KeyValuePair <int, string> > docentePosicao = TUR_TurmaDocenteBO.SelecionaDocentesPosicaoPorDisciplina(tud_id)
                                                                            .Where(p => VS_ltPermissao.Any(q => q.tdt_posicaoPermissao == (byte)p.Key && q.pdc_permissaoConsulta)).ToList();
                        string nomeDocente;
                        foreach (int i in docentePosicao.Select(p => p.Key))
                        {
                            nomeDocente = docentePosicao.Find(p => p.Key == i).Value;

                            if (carregarDocentesComAtrib && (!string.IsNullOrEmpty(nomeDocente)))
                            {
                                ddlCombo.Items.Insert(0, new ListItem(nomeDocente, i.ToString(), true));
                            }
                            else if (!carregarDocentesComAtrib)
                            {
                                ddlCombo.Items.Insert(0, new ListItem(
                                                          string.IsNullOrEmpty(nomeDocente) ? string.Format("Docente {0}", i.ToString()) : nomeDocente,
                                                          i.ToString(),
                                                          true));
                            }
                        }
                    }
                    else
                    {
                        List <KeyValuePair <int, string> > docentePosicao = TUR_TurmaDocenteBO.SelecionaDocentesPosicaoPorDisciplina(tud_id);;
                        string nomeDocente;

                        for (int i = qtdPosicoes; i > 0; i--)
                        {
                            nomeDocente = docentePosicao.Find(p => p.Key == i).Value;

                            if (carregarDocentesComAtrib && (!string.IsNullOrEmpty(nomeDocente)))
                            {
                                ddlCombo.Items.Insert(0, new ListItem(nomeDocente, i.ToString(), true));
                            }
                            else if (!carregarDocentesComAtrib)
                            {
                                ddlCombo.Items.Insert(0, new ListItem(
                                                          string.IsNullOrEmpty(nomeDocente) ? string.Format("Docente {0}", i.ToString()) : nomeDocente,
                                                          i.ToString(),
                                                          true));
                            }
                        }
                    }
                }
                else
                {
                    for (int i = qtdPosicoes; i > 0; i--)
                    {
                        ddlCombo.Items.Insert(0, new ListItem(
                                                  string.Format("Docente {0}", i.ToString()),
                                                  i.ToString(),
                                                  true));
                    }
                }

                IncluirOpcaoTodos();
                CarregarMensagemSelecione();
                ddlCombo.AppendDataBoundItems = true;
            }
            catch (Exception)
            {
                lblMessage.Text    = "Erro ao tentar carregar " + lblTitulo.Text.Replace('*', ' ').ToLower() + ".";
                lblMessage.Visible = true;
            }
        }
Пример #4
0
        /// <summary>
        /// Carrega dados da turma na tela para alteração.
        /// </summary>
        /// <param name="tur_id">ID da turma</param>
        private void CarregarDadosAlteracao(long tur_id)
        {
            try
            {
                VS_tur_id = tur_id;

                // Carregar entidades.
                TUR_Turma entTurma = new TUR_Turma {
                    tur_id = tur_id
                };
                TUR_TurmaBO.GetEntity(entTurma);

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

                DtVigenciasDocentes = TUR_TurmaDocenteBO.SelecionaVigenciasDocentesPorDisciplina(entTurma.tur_id);

                List <TUR_TurmaCurriculo>      listaCurriculos  = TUR_TurmaCurriculoBO.GetSelectBy_Turma(entTurma.tur_id, ApplicationWEB.AppMinutosCacheLongo);
                List <CadastroTurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectCadastradosBy_Turma(tur_id);

                if (!ValidaDadosTurma(entTurma, entEscola, listaCurriculos, listaDisciplinas))
                {
                    return;
                }

                uccFiltroEscola.Uad_ID = entEscola.uad_idSuperior;
                uccFiltroEscola_IndexChangedUA();

                uccFiltroEscola.SelectedValueEscolas = new[] { entTurma.esc_id, entTurma.uni_id };

                uccFiltroEscola_IndexChangedUnidadeEscola();

                int cur_id = listaCurriculos[0].cur_id;
                int crr_id = listaCurriculos[0].crr_id;

                uccCursoCurriculo.Valor = new[] { cur_id, crr_id };
                UCComboCursoCurriculo1_IndexChanged();

                uccCalendario.Valor = entTurma.cal_id;
                UCComboCalendario1_IndexChanged();

                VS_tud_id = listaDisciplinas[0].entTurmaDisciplina.tud_id;
                VS_tdt_id = listaDisciplinas[0].entTurmaDocente.tdt_id;

                uccDisciplina.Valor = listaDisciplinas[0].entTurmaDiscRelDisciplina.dis_id;

                UCComboDisciplina1_OnSelectedIndexChanged();

                uccFormatoAvaliacao.CarregarFormatoPorFormatoPadraoAtivo(entTurma.fav_id);
                uccFormatoAvaliacao.Valor = entTurma.fav_id;
                UCComboFormatoAvaliacao1_IndexChanged();

                txtCodigoTurma.Text        = entTurma.tur_codigo;
                txtCodigoInep.Text         = entTurma.tur_codigoInep;
                txtCapacidade.Text         = entTurma.tur_vagas.ToString();
                txtMinimoMatriculados.Text = entTurma.tur_minimoMatriculados.ToString();

                // Carga horária semanal da disciplina.
                txtAulasSemanais.Text = listaDisciplinas[0].entTurmaDisciplina.tud_cargaHorariaSemanal.ToString();

                foreach (ListItem item in chkPeriodosCurso.Items)
                {
                    int crp_id = Convert.ToInt32(item.Value);

                    item.Selected = listaCurriculos.Exists(p => p.crp_id == crp_id);
                }

                foreach (ListItem item in chkPeriodosCalendario.Items)
                {
                    int tpc_id = Convert.ToInt32(item.Value);

                    item.Selected = listaDisciplinas[0].entTurmaCalendario.Exists(p => p.tpc_id == tpc_id);
                }

                ACA_Disciplina entDis = new ACA_Disciplina
                {
                    dis_id = listaDisciplinas[0].entTurmaDiscRelDisciplina.dis_id
                };
                ACA_DisciplinaBO.GetEntity(entDis);

                DataTable informacoesDocente =
                    ACA_DocenteBO.SelecionaPorColaboradorDocente(
                        listaDisciplinas[0].entTurmaDocente.col_id,
                        listaDisciplinas[0].entTurmaDocente.doc_id);

                bool bloqueioAtribuicao = false;

                divDocente.Visible = true;
                if (informacoesDocente.Rows.Count > 0)
                {
                    UCControleVigenciaDocentes.CarregarDocente(
                        informacoesDocente.Rows[0]["pes_nome"].ToString(),
                        1,
                        1,
                        VS_tud_id,
                        ref dtDocentes,
                        entDis.tds_id,
                        entTurma.esc_id,
                        entTurma.uni_id,
                        entTurma.tur_docenteEspecialista
                        , bloqueioAtribuicao
                        , ref DtVigenciasDocentes);
                }

                // Verifica se possui parametros de formacao
                MTR_ParametroFormacaoTurma entityFormacao = MTR_ParametroFormacaoTurmaBO.SelecionaParametroPorAnoCurso(cur_id, crr_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
                if (entityFormacao != null)
                {
                    uccTurno.CarregarTurnoPorParametroPeriodo(entityFormacao);
                }
                else
                {
                    uccTurno.CarregarTurnoPorTurnoAtivo(entTurma.trn_id);
                }

                uccTurno.Valor = entTurma.trn_id;

                if (entTurma.tur_participaRodizio)
                {
                    chkRodizio.Checked = true;
                }

                if (entTurma.tur_situacao == (byte)TUR_TurmaSituacao.Aguardando)
                {
                    ddlSituacao.Items.Add(new ListItem("Aguardando", ((byte)TUR_TurmaSituacao.Aguardando).ToString()));
                }
                ddlSituacao.SelectedValue = entTurma.tur_situacao.ToString();

                DesabilitaDadosAlteracao(entityFormacao);

                RegistraScriptConfirmacao(entTurma);
            }
            catch (ValidationException ex)
            {
                lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar a turma de eletiva.", UtilBO.TipoMensagem.Erro);
            }
        }
Пример #5
0
    /// <summary>
    /// Carrega no repeater de disciplinas eletivas da turma
    /// </summary>
    /// <param name="cur_id">id do curso</param>
    /// <param name="crr_id">id do currículo</param>
    /// <param name="crp_id">id do currículo período</param>
    /// <param name="tipo">tipo de disciplina (ex: 1–Obrigatória,3–Optativa...)</param>
    /// <param name="tur_id">id da turma</param>
    /// <param name="cal_id">Calendário</param>
    /// <param name="esc_id">Id da escola</param>
    /// <param name="uni_id">Unidade da escola</param>
    /// <param name="ProfessorEspecialista">Flag que indica se turma é para professor especialista</param>
    /// <param name="dtDocentes">Tabela de docentes da escola</param>
    /// <param name="dtAvaliacoesFormato">Tabela com avaliações periódicas do formato - será mostrada na coluna controle semestral</param>
    /// <param name="dtDisciplinaNaoAvaliado">Tabela de disciplinas não avaliadas - todas as disciplinas da turma</param>
    /// <param name="bloqueioAtribuicaoDocente">Flag que indica se é pra bloquear a atribuição de docente para a escola</param>
    /// <param name="tabelaPeriodosCalendario">Tabela com períodos do calendário da turma</param>
    public bool CarregaRepeaterDisciplinas
    (
        Int32 cur_id
        , Int32 crr_id
        , Int32 crp_id
        , ACA_CurriculoDisciplinaTipo tipo
        , Int64 tur_id
        , Int32 cal_id
        , Int32 esc_id
        , Int32 uni_id
        , bool ProfessorEspecialista
        , ref DataTable dtDocentes
        , DataTable dtAvaliacoesFormato
        , ref DataTable dtDisciplinaNaoAvaliado
        , bool bloqueioAtribuicaoDocente
        , DataTable tabelaPeriodosCalendario
        , ref DataTable dtVigenciasDocentes
        , bool aplicarNovaRegraDocenciaCompartilhada
    )
    {
        dtDocentesEscola        = dtDocentes;
        DtAvaliacoesFormato     = dtAvaliacoesFormato;
        DtDisciplinaNaoAvaliado = dtDisciplinaNaoAvaliado;
        dtPeriodosCalendario    = tabelaPeriodosCalendario;
        DtVigenciasDocentes     = dtVigenciasDocentes;

        if ((DtDisciplinaNaoAvaliado == null) && (tur_id > 0))
        {
            // Carregar avaliações que devem ser desconsideradas para a disciplina.
            DtDisciplinaNaoAvaliado = TUR_TurmaDisciplinaNaoAvaliadoBO.GetSelectBy_Turma(tur_id);
        }

        // Variáveis que carregam o combo de professor.
        escola_esc_id = esc_id;
        escola_uni_id = uni_id;
        escola_bloqueioAtribuicaoDocente = bloqueioAtribuicaoDocente;
        professorEspecialista            = ProfessorEspecialista;

        VS_AcessoControleSemestral = TUR_TurmaBO.VerificaAcessoControleSemestral(tur_id);

        bool mostraAvaliacoes = (DtAvaliacoesFormato != null && DtAvaliacoesFormato.Rows.Count > 0) && VS_AcessoControleSemestral;

        // Carregando as disciplinas de acordo como o tipo dado.
        DataTable dtDisciplina = ACA_CurriculoDisciplinaBO.GetSelectBy_Curso_Tipo
                                 (
            cur_id
            , crr_id
            , crp_id
            , tipo
            , tur_id
                                 );

        lblMensagemControleSemestral.Visible = mostraAvaliacoes && dtDisciplina.Rows.Count > 0;
        lblMensagemControleSemestral.Text    = TextoControleSemestral;

        // Guarda todas as disciplinas da turma
        string tud_ids = string.Join(",", (from DataRow dr in dtDisciplina.Rows
                                           select dr["tud_id"].ToString()).ToArray());

        listTurmaDocentes = TUR_TurmaDocenteBO.SelecionaDocentesDisciplina(tud_ids);

        // Se existir disciplina eletiva
        if (dtDisciplina.Rows.Count > 0)
        {
            lblSemDisciplinasEletivas.Visible = false;
            rptDisciplinasEletivas.Visible    = true;

            this.aplicarNovaRegraDocenciaCompartilhada = aplicarNovaRegraDocenciaCompartilhada;
            rptDisciplinasEletivas.DataSource          = dtDisciplina;
            rptDisciplinasEletivas.DataBind();

            foreach (string id in periodosIds)
            {
                Script += "setaCheckBoxPeriodo('." + id + "');";
            }

            return(true);
        }

        lblSemDisciplinasEletivas.Visible = true;
        rptDisciplinasEletivas.Visible    = false;

        // Volta o valor das tabelas (caso tenham sido carregados no DataBind do grid).
        dtDocentes = dtDocentesEscola;
        dtDisciplinaNaoAvaliado = DtDisciplinaNaoAvaliado;

        return(false);
    }
Пример #6
0
        private void UCComboTurmaDisciplina_IndexChanged()
        {
            try
            {
                UCCPeriodoCalendario.Valor         = new[] { -1, -1 };
                UCCPeriodoCalendario.PermiteEditar = false;
                // utilizado para evitar chamar o evento de alteracao do calendario periodo duas vezes seguidas.
                bool selecionouComboPeriodos = false;

                if (UCCTurmaDisciplina1.Valor > -1)
                {
                    long tur_id = Convert.ToInt64(ddlTurma.SelectedValue);

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

                    ACA_CalendarioAnual entCalendario = new ACA_CalendarioAnual {
                        cal_id = entTurma.cal_id
                    };
                    ACA_CalendarioAnualBO.GetEntity(entCalendario);

                    ACA_FormatoAvaliacao entFormatoAvaliacao = new ACA_FormatoAvaliacao {
                        fav_id = entTurma.fav_id
                    };
                    ACA_FormatoAvaliacaoBO.GetEntity(entFormatoAvaliacao);

                    VS_FechamentoAutomatico = entFormatoAvaliacao.fav_fechamentoAutomatico;

                    TUR_TurmaDisciplina entityTurmaDisciplina = new TUR_TurmaDisciplina {
                        tud_id = UCCTurmaDisciplina1.Valor
                    };
                    TUR_TurmaDisciplinaBO.GetEntity(entityTurmaDisciplina);

                    if (entityTurmaDisciplina.tud_naoLancarFrequencia)
                    {
                        lblMessage.Text           = UtilBO.GetErroMessage(GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + " não pode lançar frequência na turma.", UtilBO.TipoMensagem.Alerta);
                        UCCTurmaDisciplina1.Valor = -1;
                    }
                    else
                    {
                        bool sucessoProcessarPendenciaFechamento = true;
                        if (VS_FechamentoAutomatico)
                        {
                            var pendencias = CLS_AlunoFechamentoPendenciaBO.SelecionarAguardandoProcessamento(tur_id, entityTurmaDisciplina.tud_id, entityTurmaDisciplina.tud_tipo, 0);

                            if ((pendencias != null) && (pendencias.Rows.Count > 0))
                            {
                                try
                                {
                                    // limpa cache desta turma
                                    string pattern;
                                    pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_BIMESTRE_PATTERN_KEY, entityTurmaDisciplina.tud_id);
                                    CacheManager.Factory.RemoveByPattern(pattern);
                                    pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY, entityTurmaDisciplina.tud_id);
                                    CacheManager.Factory.RemoveByPattern(pattern);
                                    pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_PATTERN_KEY, tur_id);
                                    CacheManager.Factory.RemoveByPattern(pattern);
                                    pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_FINAL_PATTERN_KEY, entityTurmaDisciplina.tud_id);
                                    CacheManager.Factory.RemoveByPattern(pattern);
                                    pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_PATTERN_KEY, entityTurmaDisciplina.tud_id);
                                    CacheManager.Factory.RemoveByPattern(pattern);
                                    pattern = String.Format("{0}_{1}", ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_PATTERN_KEY, tur_id);
                                    CacheManager.Factory.RemoveByPattern(pattern);
                                    pattern = String.Format(ModelCache.PENDENCIAS_DISCIPLINA_MODEL_KEY, entTurma.esc_id, entTurma.uni_id, entCalendario.cal_ano, entityTurmaDisciplina.tud_id);
                                    CacheManager.Factory.Remove(pattern);
                                    CLS_AlunoFechamentoPendenciaBO.Processar(entityTurmaDisciplina.tud_id, (byte)AvaliacaoTipo.Final, pendencias);
                                }
                                catch (Exception ex)
                                {
                                    sucessoProcessarPendenciaFechamento = false;
                                    ApplicationWEB._GravaErro(ex);
                                    lblMessage.Text = UtilBO.GetErroMessage(GetGlobalResourceObject("Classe", "CompensacaoAusencia.Cadastro.MensagemErroProcessarPendenciaFechamento").ToString(), UtilBO.TipoMensagem.Erro);
                                }
                            }
                        }
                        if (sucessoProcessarPendenciaFechamento)
                        {
                            UCCPeriodoCalendario.CarregarPorPeriodoEventoEfetivacaoVigentes(entTurma.cal_id, UCCTurmaDisciplina1.Valor, entTurma.tur_id, true);
                            selecionouComboPeriodos = UCCPeriodoCalendario.Valor[0] != -1 && UCCPeriodoCalendario.Valor[1] != -1;

                            UCCPeriodoCalendario.SetarFoco();
                            UCCPeriodoCalendario.PermiteEditar = true;
                        }

                        VS_DisciplinaEspecial = entityTurmaDisciplina.tud_disciplinaEspecial;

                        VS_posicao = TUR_TurmaDocenteBO.SelecionaPosicaoPorDocenteTurma(_VS_doc_id, UCCTurmaDisciplina1.Valor, ApplicationWEB.AppMinutosCacheLongo);

                        VS_tipoDocente = ACA_TipoDocenteBO.SelecionaTipoDocentePorPosicao(VS_posicao, ApplicationWEB.AppMinutosCacheLongo);
                    }
                }

                if (!selecionouComboPeriodos)
                {
                    UCCPeriodoCalendario_IndexChanged();
                }
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar os dados.", UtilBO.TipoMensagem.Erro);
            }
        }
Пример #7
0
        /// <summary>
        /// Método para salvar um informativo.
        /// </summary>
        private void Salvar()
        {
            try
            {
                bool permiteEditar = true;

                if (__SessionWEB.__UsuarioWEB.Docente.doc_id > 0)
                {
                    long tud_id      = UCCTurmaDisciplina1.Valor;
                    byte tdt_posicao = TUR_TurmaDocenteBO.SelecionaPosicaoPorDocenteTurma(__SessionWEB.__UsuarioWEB.Docente.doc_id, tud_id, ApplicationWEB.AppMinutosCacheLongo);
                    permiteEditar = CFG_PermissaoDocenteBO.SelecionaPermissaoModulo(tdt_posicao, (byte)EnumModuloPermissao.Compensacoes)
                                    .Any(p => p.pdc_permissaoEdicao);
                }

                if (permiteEditar)
                {
                    if (Convert.ToInt32(txtQtAulas.Text) == 0)
                    {
                        throw new ValidationException("Quantidade de aulas compensadas deve ser um número maior do que zero.");
                    }

                    CLS_CompensacaoAusencia entCompensacao = new CLS_CompensacaoAusencia();
                    entCompensacao.cpa_id = VS_cpa_id;
                    entCompensacao.tud_id = UCCTurmaDisciplina1.Valor;
                    entCompensacao.tpc_id = UCCPeriodoCalendario.Valor[0];
                    entCompensacao.cpa_atividadesDesenvolvidas    = txtAtividades.Text;
                    entCompensacao.cpa_quantidadeAulasCompensadas = Convert.ToInt32(txtQtAulas.Text);
                    entCompensacao.pro_id       = VS_pro_id;
                    entCompensacao.cpa_situacao = 1;
                    entCompensacao.IsNew        = VS_cpa_id < 0;

                    List <CLS_CompensacaoAusenciaAluno> listCompensacaoAluno = new List <CLS_CompensacaoAusenciaAluno>();

                    foreach (RepeaterItem item in rptAlunos.Items)
                    {
                        CheckBox ckbAluno = (CheckBox)item.FindControl("ckbAluno");
                        if (ckbAluno != null && ckbAluno.Checked)
                        {
                            HiddenField hdnId = (HiddenField)item.FindControl("hdnId");
                            if (hdnId != null)
                            {
                                string[] valor = hdnId.Value.Split(';');
                                CLS_CompensacaoAusenciaAluno compAluno = new CLS_CompensacaoAusenciaAluno
                                {
                                    tud_id = Convert.ToInt64(valor[0]),
                                    cpa_id = Convert.ToInt32(entCompensacao.cpa_id),
                                    alu_id = Convert.ToInt64(valor[1]),
                                    mtu_id = Convert.ToInt32(valor[2]),
                                    mtd_id = Convert.ToInt32(valor[3])
                                };

                                listCompensacaoAluno.Add(compAluno);
                            }
                        }
                    }

                    if (listCompensacaoAluno.Count == 0)
                    {
                        throw new ValidationException("É necessário selecionar pelo menos um aluno para realizar a compensação.");
                    }

                    if (CLS_CompensacaoAusenciaBO.Save(entCompensacao, listCompensacaoAluno, VS_FechamentoAutomatico, UCComboCalendario.Valor))
                    {
                        ApplicationWEB._GravaLogSistema(VS_cpa_id > 0 ? LOG_SistemaTipo.Update : LOG_SistemaTipo.Insert, "cpa_id: " + entCompensacao.cpa_id + " tud_id: " + entCompensacao.tud_id);
                        __SessionWEB.PostMessages = UtilBO.GetErroMessage("Compensação de ausência " + (VS_cpa_id > 0 ? "alterada" : "incluída") + " com sucesso.", UtilBO.TipoMensagem.Sucesso);

                        VS_QtAulasComp = 0;

                        VerificaPaginaRedirecionar();
                    }
                }
                else
                {
                    string msg = String.Format("O docente não possui permissão para incluir compensações de ausência para o(a) {0} selecionado(a).", GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA_MIN"));
                    lblMessage.Text = UtilBO.GetErroMessage(msg, UtilBO.TipoMensagem.Alerta);
                }
            }
            catch (ValidationException e)
            {
                lblMessage.Text = UtilBO.GetErroMessage(e.Message, UtilBO.TipoMensagem.Alerta);
            }
            catch (ArgumentException e)
            {
                lblMessage.Text = UtilBO.GetErroMessage(e.Message, UtilBO.TipoMensagem.Alerta);
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar compensação de ausência.", UtilBO.TipoMensagem.Erro);
            }
        }
Пример #8
0
        /// <summary>
        /// Realiza a consulta pelos filtros informados.
        /// </summary>
        private void Pesquisar()
        {
            try
            {
                Dictionary <string, string> filtros = new Dictionary <string, string>();

                bool permiteConsultar = true;
                List <sPermissaoDocente> ltPermissao = new List <sPermissaoDocente>();
                EnumTipoDocente          tipoDocente = EnumTipoDocente.Titular;
                if (_VS_doc_id > 0)
                {
                    long tud_id = UCCTurmaDisciplina1.Valor;
                    bool AtribuicaoAtiva;
                    // Traz a última atribuição que o docente teve naquela disciplina, sendo ativa ou inativa.
                    byte tdt_posicao = TUR_TurmaDocenteBO.SelecionaPosicaoPorDocenteTurma_ComInativos
                                           (_VS_doc_id, tud_id, out AtribuicaoAtiva, ApplicationWEB.AppMinutosCacheLongo);
                    VS_AtribuicaoAtiva = AtribuicaoAtiva;
                    ltPermissao        = CFG_PermissaoDocenteBO.SelecionaPermissaoModulo(tdt_posicao, (byte)EnumModuloPermissao.Compensacoes);
                    permiteConsultar   = ltPermissao.Any(p => p.pdc_permissaoConsulta);

                    TUR_TurmaDisciplina entityTurmaDisciplina = new TUR_TurmaDisciplina {
                        tud_id = tud_id
                    };
                    TUR_TurmaDisciplinaBO.GetEntity(entityTurmaDisciplina);
                    VS_DisciplinaEspecial = entityTurmaDisciplina.tud_disciplinaEspecial;

                    tipoDocente = ACA_TipoDocenteBO.SelecionaTipoDocentePorPosicao(tdt_posicao, ApplicationWEB.AppMinutosCacheLongo);
                }
                else
                {
                    VS_AtribuicaoAtiva = true;
                }

                if (permiteConsultar)
                {
                    gvCompAusencia.EmptyDataText = GetGlobalResourceObject("Classe", "CompensacaoAusencia.Busca.SemCompensacaoAusencia").ToString();
                    gvCompAusencia.PageIndex     = 0;
                    odsCompAusencia.SelectMethod = _VS_doc_id > 0 && VS_DisciplinaEspecial ? "SelectByPesquisaFiltroDeficiencia" : "SelectByPesquisa";
                    odsCompAusencia.SelectParameters.Clear();
                    odsCompAusencia.SelectParameters.Add("uad_idSuperior", DbType.Guid, UCComboUAEscola.Uad_ID.ToString());
                    odsCompAusencia.SelectParameters.Add("esc_id", DbType.Int32, UCComboUAEscola.Esc_ID.ToString());
                    odsCompAusencia.SelectParameters.Add("uni_id", DbType.Int32, UCComboUAEscola.Uni_ID.ToString());
                    odsCompAusencia.SelectParameters.Add("cur_id", DbType.Int32, UCCCursoCurriculo.Valor[0].ToString());
                    odsCompAusencia.SelectParameters.Add("crr_id", DbType.Int32, UCCCursoCurriculo.Valor[1].ToString());
                    odsCompAusencia.SelectParameters.Add("cap_id", DbType.Int32, UCCPeriodoCalendario.Valor[1].ToString());
                    odsCompAusencia.SelectParameters.Add("tud_id", DbType.Int64, UCCTurmaDisciplina1.Valor.ToString());
                    odsCompAusencia.SelectParameters.Add("tur_id", DbType.Int64, ddlTurma.SelectedValue);

                    // Filtra pela visão do usuário.
                    odsCompAusencia.SelectParameters.Add("gru_id", __SessionWEB.__UsuarioWEB.Grupo.gru_id.ToString());
                    odsCompAusencia.SelectParameters.Add("usu_id", __SessionWEB.__UsuarioWEB.Usuario.usu_id.ToString());
                    odsCompAusencia.SelectParameters.Add("adm", (__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Administracao || __SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Individual).ToString());
                    odsCompAusencia.SelectParameters.Add("ent_id", __SessionWEB.__UsuarioWEB.Usuario.ent_id.ToString());

                    if (_VS_doc_id > 0 && VS_DisciplinaEspecial)
                    {
                        odsCompAusencia.SelectParameters.Add("tipoDocente", tipoDocente.ToString());
                    }

                    odsCompAusencia.DataBind();

                    // quantidade de itens por página
                    string qtItensPagina = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.QT_ITENS_PAGINACAO);
                    int    itensPagina   = string.IsNullOrEmpty(qtItensPagina) ? ApplicationWEB._Paginacao : Convert.ToInt32(qtItensPagina);

                    gvCompAusencia.Sort(VS_Ordenacao, VS_SortDirection);

                    #region Salvar busca realizada com os parâmetros do ODS.

                    foreach (Parameter param in odsCompAusencia.SelectParameters)
                    {
                        filtros.Add(param.Name, param.DefaultValue);
                    }

                    filtros.Add("tpc_id", UCCPeriodoCalendario.Valor[0].ToString());
                    filtros.Add("cal_id", UCComboCalendario.Valor.ToString());

                    __SessionWEB.BuscaRealizada = new BuscaGestao
                    {
                        PaginaBusca = PaginaGestao.CompensacaoAusencia
                        ,
                        Filtros = filtros
                    };

                    #endregion

                    // mostra essa quantidade no combobox
                    UCComboQtdePaginacao1.Valor = itensPagina;
                    // atribui essa quantidade para o grid
                    gvCompAusencia.PageSize = itensPagina;
                    // atualiza o grid
                    gvCompAusencia.DataBind();

                    fdsResultados.Visible = true;

                    if (_VS_doc_id > 0)
                    {
                        gvCompAusencia.Columns[gvCompAusenciaIndiceAlterar].Visible     =
                            gvCompAusencia.Columns[gvCompAusenciaIndiceExcluir].Visible = ltPermissao.Any(p => p.pdc_permissaoEdicao);
                    }
                    else
                    {
                        gvCompAusencia.Columns[gvCompAusenciaIndiceAlterar].Visible = __SessionWEB.__UsuarioWEB.GrupoPermissao.grp_alterar;
                        gvCompAusencia.Columns[gvCompAusenciaIndiceExcluir].Visible = __SessionWEB.__UsuarioWEB.GrupoPermissao.grp_excluir;
                    }
                }
                else
                {
                    string msg = String.Format("O docente não possui permissão para consultar compensações de ausência do(a) {0} selecionado(a).", GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA_MIN"));
                    lblMessage.Text = UtilBO.GetErroMessage(msg, UtilBO.TipoMensagem.Alerta);
                }
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar as compensações de ausências.", UtilBO.TipoMensagem.Erro);
            }
        }