コード例 #1
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);
            }
        }
コード例 #2
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);
            }
        }