Ejemplo n.º 1
0
    /// <summary>
    /// Carrega os dados do tipo de atividade avaliativa nos controles caso seja alteração.
    /// </summary>
    /// <param name="tav_id"></param>
    private void Carregar(int tav_id)
    {
        try
        {
            CLS_TipoAtividadeAvaliativa entity = new CLS_TipoAtividadeAvaliativa {
                tav_id = tav_id
            };
            entity = CLS_TipoAtividadeAvaliativaBO.CarregaDados(entity.tav_id);

            _VS_tav_id = entity.tav_id;
            txtTipoAtividadeAvaliativa.Text = entity.tav_nome;
            ddlQualificador.SelectedValue   = entity.qat_id.ToString();
        }
        catch (Exception e)
        {
            ApplicationWEB._GravaErro(e);
            lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar o tipo de atividade avaliativa.", UtilBO.TipoMensagem.Erro);
        }
    }
Ejemplo n.º 2
0
    /// <summary>
    /// Mostra os tipos de atividades não excluídos logicamente no dropdownlist
    /// </summary>
    /// <param name="apenasAtivos">Apenas os ativos ou não</param>
    /// <param name="tav_id">Id de um tipo para ser retornado</param>
    public void CarregaTipoAtividadeAvaliativaAtivosMaisInativo(bool apenasAtivos, int tav_id, long tud_id = -1)
    {
        List <CLS_TipoAtividadeAvaliativa> list;

        if (tud_id <= 0)
        {
            list = CLS_TipoAtividadeAvaliativaBO.SelecionaTipoAtividadeAvaliativa(apenasAtivos, ApplicationWEB.AppMinutosCacheLongo);
        }
        else
        {
            list = CLS_TipoAtividadeAvaliativaBO.SelecionaTiposAtividadesAvaliativasAtivosBy_TurmaDisciplina(tud_id, ApplicationWEB.AppMinutosCacheLongo);
        }

        //Ve se o id não esta na lista, se nao estiver, adiciona ele
        if (!list.Any(p => p.tav_id == tav_id))
        {
            CLS_TipoAtividadeAvaliativa entity = new CLS_TipoAtividadeAvaliativa {
                tav_id = tav_id
            };
            CLS_TipoAtividadeAvaliativaBO.GetEntity(entity);

            if (entity.tav_id > 0 && entity.tav_situacao != (byte)CLS_TipoAtividadeAvaliativaSituacao.Excluido)
            {
                list.Add(new CLS_TipoAtividadeAvaliativa
                {
                    tav_id   = entity.tav_id,
                    tav_nome = entity.tav_nome
                });
            }
        }

        ddlCombo.Items.Clear();
        ddlCombo.DataSource = list;
        ddlCombo.Items.Insert(0, new ListItem(string.Format("-- Selecione um tipo de {0} --", GestaoEscolarUtilBO.nomePadraoAtividadeAvaliativa(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower()), "-1", true));
        if (MostrarMessageOutros)
        {
            ddlCombo.Items.Insert(ddlCombo.Items.Count, new ListItem(string.Format("Outro tipo de {0}...", GestaoEscolarUtilBO.nomePadraoAtividadeAvaliativa(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower()), "0", true));
        }
        ddlCombo.DataBind();
    }
        /// <summary>
        /// Retorna os dados da atividade avaliativa pelo parâmetro
        /// </summary>
        /// <param name="tav_id"></param>
        /// <returns></returns>
        public CLS_TipoAtividadeAvaliativa CarregaDados(int tav_id)
        {
            QuerySelectStoredProcedure qs = new QuerySelectStoredProcedure("NEW_CLS_TipoAtividadeAvaliativa_SelecionaAtivos_Qualificador", _Banco);

            try
            {
                #region PARAMETROS

                Param               = qs.NewParameter();
                Param.DbType        = DbType.Int32;
                Param.ParameterName = "@tav_id";
                Param.Size          = 4;
                if (tav_id > 0)
                {
                    Param.Value = tav_id;
                }
                else
                {
                    Param.Value = DBNull.Value;
                }
                qs.Parameters.Add(Param);

                #endregion

                qs.Execute();

                CLS_TipoAtividadeAvaliativa entity = new CLS_TipoAtividadeAvaliativa();

                return(qs.Return.Rows.Count > 0 ? DataRowToEntity(qs.Return.Rows[0], entity) : new CLS_TipoAtividadeAvaliativa());
            }
            catch
            {
                throw;
            }
            finally
            {
                qs.Parameters.Clear();
            }
        }
Ejemplo n.º 4
0
    protected void grvTipoAtividadeAvaliativa_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        if (e.CommandName == "InativarAtividade")
        {
            int index  = Convert.ToInt32(e.CommandArgument);
            int tav_id = Convert.ToInt32(grvTipoAtividadeAvaliativa.DataKeys[index].Value.ToString());

            CLS_TipoAtividadeAvaliativa entity = new CLS_TipoAtividadeAvaliativa {
                tav_id = tav_id
            };
            CLS_TipoAtividadeAvaliativaBO.GetEntity(entity);

            entity.tav_situacao = (byte)CLS_TipoAtividadeAvaliativaSituacao.Inativo;

            if (CLS_TipoAtividadeAvaliativaBO.Save(entity))
            {
                grvTipoAtividadeAvaliativa.PageIndex = 0;
                grvTipoAtividadeAvaliativa.DataBind();
                ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, "tav_id: " + tav_id);
                lblMessage.Text = UtilBO.GetErroMessage("Tipo de atividade avaliativa inativado com sucesso.", UtilBO.TipoMensagem.Sucesso);
            }
        }

        if (e.CommandName == "AtivarAtividade")
        {
            int index  = Convert.ToInt32(e.CommandArgument);
            int tav_id = Convert.ToInt32(grvTipoAtividadeAvaliativa.DataKeys[index].Value.ToString());

            CLS_TipoAtividadeAvaliativa entity = new CLS_TipoAtividadeAvaliativa {
                tav_id = tav_id
            };
            CLS_TipoAtividadeAvaliativaBO.GetEntity(entity);

            entity.tav_situacao = (byte)CLS_TipoAtividadeAvaliativaSituacao.Ativo;

            if (CLS_TipoAtividadeAvaliativaBO.Save(entity))
            {
                grvTipoAtividadeAvaliativa.PageIndex = 0;
                grvTipoAtividadeAvaliativa.DataBind();
                ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, "tav_id: " + tav_id);
                lblMessage.Text = UtilBO.GetErroMessage("Tipo de atividade avaliativa ativado com sucesso.", UtilBO.TipoMensagem.Sucesso);
            }
        }

        if (e.CommandName == "Deletar")
        {
            try
            {
                int index  = int.Parse(e.CommandArgument.ToString());
                int tav_id = Convert.ToInt32(grvTipoAtividadeAvaliativa.DataKeys[index].Value.ToString());

                CLS_TipoAtividadeAvaliativa entity = new CLS_TipoAtividadeAvaliativa {
                    tav_id = tav_id
                };
                CLS_TipoAtividadeAvaliativaBO.GetEntity(entity);

                if (CLS_TipoAtividadeAvaliativaBO.Delete(entity))
                {
                    grvTipoAtividadeAvaliativa.PageIndex = 0;
                    grvTipoAtividadeAvaliativa.DataBind();
                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Delete, "tav_id: " + tav_id);
                    lblMessage.Text = UtilBO.GetErroMessage("Tipo de atividade avaliativa excluído com sucesso.", UtilBO.TipoMensagem.Sucesso);
                }
            }
            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 excluir o tipo de atividade avaliativa.", UtilBO.TipoMensagem.Erro);
            }
        }
    }
Ejemplo n.º 5
0
        public static bool Save
        (
            CLS_TurmaNota entity,
            TUR_Turma entTurma,
            DateTime cal_dataInicio,
            DateTime cal_dataFim,
            DateTime cap_dataInicio,
            DateTime cap_dataFim,
            Guid ent_id,
            List <CLS_TurmaNotaOrientacaoCurricular> lstHabilidades,
            bool fav_permiteRecuperacaoForaPeriodo,
            CLS_TurmaAula entityTurmaAula = null,
            CLS_TurmaNotaRegencia entityTurmaNotaRegencia = null,
            bool validarDataAula = true,
            Guid usu_id          = new Guid(),
            byte origemLogNota   = 0,
            byte tipoLogNota     = 0
        )
        {
            TalkDBTransaction banco = new CLS_TurmaNotaDAO()._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);

            try
            {
                bool bRetorno = false;

                // Caso tenha selecionado uma aula para vincular à atividade.
                if (validarDataAula && entity.tnt_data == new DateTime())
                {
                    CLS_TurmaAula entityAula = new CLS_TurmaAula
                    {
                        tud_id = entity.tud_id,
                        tau_id = entity.tau_id
                    };
                    CLS_TurmaAulaBO.GetEntity(entityAula, banco);

                    // Verifica se o usuário logado tem uma posição compatível à da aula.
                    if ((entity.tdt_posicao > 0) && (entity.tdt_posicao != entityAula.tdt_posicao))
                    {
                        throw new ValidationException("Você não tem permissão para vincular a nova atividade à esta data da aula.");
                    }

                    // Caso o usuário logado tenha selecionado uma aula para vincular e
                    // não seja um docente, copia a posição da aula.
                    entity.tdt_posicao = entityAula.tdt_posicao;
                    entity.usu_id      = entityAula.usu_id;
                }

                // Caso o usuário logado não seja um docente, grava como posição 1.
                if (entity.tdt_posicao < 1)
                {
                    entity.tdt_posicao = 1;
                }

                if (entity.Validate())
                {
                    // Verifica se a atividade foi alterada/excluída por outra pessoa enquanto o usuário tentava alterar a mesma.
                    CLS_TurmaNota entityAtividadeAuxiliar = new CLS_TurmaNota
                    {
                        tud_id = entity.tud_id,
                        tnt_id = entity.tnt_id
                    };
                    GetEntity(entityAtividadeAuxiliar, banco);

                    if (!entityAtividadeAuxiliar.IsNew)
                    {
                        entity.tdt_posicao = entityAtividadeAuxiliar.tdt_posicao;
                        entity.usu_id      = entityAtividadeAuxiliar.usu_id;
                    }

                    if (entityAtividadeAuxiliar.tnt_dataAlteracao != entity.tnt_dataAlteracao)
                    {
                        throw new EditarAtividade_ValidationException("Esta atividade já foi alterada recentemente.");
                    }

                    string nomeAtividade = GestaoEscolarUtilBO.nomePadraoAtividadeAvaliativa(ent_id);

                    if (entity.tav_id <= 0 && string.IsNullOrEmpty(entity.tnt_nome) && ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.NOME_TODAS_ATIVIDADES_AVALIATIVAS, ent_id) == "False")
                    {
                        throw new ArgumentException(string.Format("Outro tipo de {0} é obrigatório.", nomeAtividade.ToLower()));
                    }

                    CLS_TipoAtividadeAvaliativa entityAtividade = new CLS_TipoAtividadeAvaliativa();
                    if (entity.tav_id <= 0)
                    {
                        if (entity.tnt_nome.Length > 100)
                        {
                            throw new ArgumentException(nomeAtividade + " pode conter até 100 caracteres.");
                        }
                    }
                    else
                    {
                        entityAtividade.tav_id = entity.tav_id;
                        CLS_TipoAtividadeAvaliativaBO.GetEntity(entityAtividade, banco);
                    }

                    if (entity.tnt_situacao != Convert.ToByte(CLS_TurmaNotaSituacao.AtividadeCancelada) || (entityAtividadeAuxiliar.tnt_situacao == entity.tnt_situacao))
                    {
                        if ((entityAtividade.tav_situacao == Convert.ToByte(CLS_TipoAtividadeAvaliativaSituacao.Inativo)) && (entityAtividade.tav_id != entityAtividadeAuxiliar.tav_id))
                        {
                            throw new ArgumentException(string.Format("Tipo de {0} está inativo.", nomeAtividade.ToLower()));
                        }
                    }

                    CLS_TurmaNota avaRecuperacao = CLS_TurmaNotaBO.GetSelectRelacionadaFilho(entity.tud_id, entity.tnt_id, banco);
                    if (entity.tnt_data != new DateTime())
                    {
                        if (entTurma.tur_id <= 0)
                        {
                            entTurma = new TUR_Turma {
                                tur_id = entity.tur_id
                            };
                            TUR_TurmaBO.GetEntity(entTurma, banco);
                        }

                        // Compara as datas das avaliacoes relacionadas
                        bool          relacionadaPai = false;
                        CLS_TurmaNota avaRelacionada = CLS_TurmaNotaBO.GetSelectRelacionadaFilho(entity.tud_id, entity.tnt_id, banco);
                        if (avaRelacionada.tnt_id > 0)
                        {
                            // se a data da recuperacao filho eh menor que a data da avaliacao pai...
                            if (avaRecuperacao.tnt_data != new DateTime() && avaRecuperacao.tnt_data < entity.tnt_data)
                            {
                                throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidacaoDataFilho").ToString());
                            }
                        }
                        else
                        {
                            avaRelacionada = CLS_TurmaNotaBO.GetSelectRelacionadaPai(entity.tud_id, entity.tnt_id);
                            relacionadaPai = avaRelacionada.tnt_id > 0;
                            avaRelacionada = CLS_TurmaNotaBO.GetSelectRelacionadaPai(entity.tud_id, entity.tnt_id, banco);
                            // se a data da avaliacao pai eh maior que a data da recuperacao filho...
                            if (avaRelacionada.tnt_id > 0 && avaRelacionada.tnt_data != new DateTime() && avaRelacionada.tnt_data > entity.tnt_data)
                            {
                                throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidacaoDataPai").ToString());
                            }
                        }

                        if (!(fav_permiteRecuperacaoForaPeriodo && relacionadaPai) &&
                            (entity.tnt_data > cal_dataFim || entity.tnt_data < cal_dataInicio))
                        {
                            throw new ArgumentException("A data da atividade deve estar dentro do período do calendário escolar (" + cal_dataInicio.ToString("dd/MM/yyyy") + " - " + cal_dataFim.ToString("dd/MM/yyyy") + ").");
                        }

                        if (!(fav_permiteRecuperacaoForaPeriodo && relacionadaPai) &&
                            (entity.tnt_data > cap_dataFim || entity.tnt_data < cap_dataInicio))
                        {
                            throw new ArgumentException("A data da atividade deve estar dentro do período do calendário (" + cap_dataInicio.ToString("dd/MM/yyyy") + " - " + cap_dataFim.ToString("dd/MM/yyyy") + ").");
                        }
                    }

                    // Valida se existe aluno com habilidade nao selecionada na avaliacao
                    if (entity.tnt_id > 0 && !CLS_TurmaNotaAlunoOrientacaoCurricularBO.ValidarHabilidadesAvaliacao(lstHabilidades, banco))
                    {
                        throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidaHabilidadesAluno").ToString());
                    }

                    // Valida se existe aluno na avaliacao de recuperacao, com habilidade
                    // que nao esta mais selecionada na avaliacao normal
                    if (avaRecuperacao.tnt_id > 0 && !CLS_TurmaNotaAlunoOrientacaoCurricularBO.ValidarHabilidadesAvaliacao(lstHabilidades, banco, avaRecuperacao.tnt_id))
                    {
                        throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidaHabilidadesAlunoRecuperacao").ToString());
                    }

                    CLS_ConfiguracaoAtividadeQualificador configQualificador = new CLS_ConfiguracaoAtividadeQualificador();
                    CLS_TurmaNotaDAO dao = new CLS_TurmaNotaDAO {
                        _Banco = banco
                    };
                    if (entity.IsNew && entity.tav_id > 0 && entityAtividade.qat_id > 0)
                    {
                        CLS_ConfiguracaoAtividadeQualificadorDAO configQualificadorDao = new CLS_ConfiguracaoAtividadeQualificadorDAO();
                        configQualificadorDao._Banco = banco;
                        configQualificador           = configQualificadorDao.GetSelectByTudQualificador(entity.tud_id, entityAtividade.qat_id);

                        // Valida a quantidade configurada para o qualificador
                        if (configQualificador.caa_id > 0 && configQualificador.caq_quantidade >= 0)
                        {
                            if (dao.ValidaQuantidadeMaxima(entity.tud_id, entityAtividade.qat_id, entity.tpc_id, configQualificador.caq_quantidade))
                            {
                                throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidacaoQuantidade").ToString());
                            }
                        }
                    }

                    bRetorno = dao.Salvar(entity);

                    if (entity.IsNew &&
                        configQualificador.caa_id > 0 &&
                        configQualificador.caq_possuiRecuperacao)
                    {
                        int tavIdRelacionado = CLS_TipoAtividadeAvaliativaBO.SelecionaTipoAtividadeAvaliativaRelacionado(configQualificador.caa_id, configQualificador.qat_id, banco);
                        if (tavIdRelacionado > 0)
                        {
                            CLS_TurmaNota entityRelacionada = new CLS_TurmaNota();
                            entityRelacionada.tud_id                 = entity.tud_id;
                            entityRelacionada.IsNew                  = true;
                            entityRelacionada.tpc_id                 = entity.tpc_id;
                            entityRelacionada.tnt_situacao           = 1;
                            entityRelacionada.tav_id                 = tavIdRelacionado;
                            entityRelacionada.tdt_posicao            = entity.tdt_posicao;
                            entityRelacionada.tnt_exclusiva          = false;
                            entityRelacionada.usu_id                 = entity.usu_id;
                            entityRelacionada.usu_idDocenteAlteracao = entity.usu_idDocenteAlteracao;
                            dao.Salvar(entityRelacionada);

                            CLS_TurmaNotaRelacionada entityRelacionamento = new CLS_TurmaNotaRelacionada();
                            entityRelacionamento.IsNew             = true;
                            entityRelacionamento.tud_id            = entity.tud_id;
                            entityRelacionamento.tnt_id            = entity.tnt_id;
                            entityRelacionamento.tud_idRelacionada = entityRelacionada.tud_id;
                            entityRelacionamento.tnt_idRelacionada = entityRelacionada.tnt_id;
                            CLS_TurmaNotaRelacionadaBO.Save(entityRelacionamento, banco);

                            avaRecuperacao = entityRelacionada;
                        }
                    }

                    #region Salva as Orientacoes curriculares ligadas a avaliacao

                    if (bRetorno && lstHabilidades.Any())
                    {
                        lstHabilidades.ForEach(x => x.tnt_id = entity.tnt_id);
                        bRetorno = CLS_TurmaNotaOrientacaoCurricularBO.SalvarEmLote(lstHabilidades, banco);

                        // Copia as habilidades na avaliacao de recuperacao
                        if (avaRecuperacao.tnt_id > 0)
                        {
                            // Salva as Orientacoes curriculares ligadas a avaliacao - específico para recuperação.
                            lstHabilidades.ForEach(x => x.tnt_id = avaRecuperacao.tnt_id);
                            CLS_TurmaNotaOrientacaoCurricularBO.SalvarEmLote(lstHabilidades, banco);
                        }
                    }

                    #endregion Salva as Orientacoes curriculares ligadas a avaliacao

                    #region Salva a turma Aula

                    if (entityTurmaAula != null)
                    {
                        bRetorno = CLS_TurmaAulaBO.Save(entityTurmaAula, banco);
                    }

                    #endregion Salva a turma Aula

                    // Salva o vinculo com a aula, caso seja regência
                    if (entityTurmaNotaRegencia != null)
                    {
                        entityTurmaNotaRegencia.tnt_id = entity.tnt_id;
                        bRetorno = CLS_TurmaNotaRegenciaBO.Save(entityTurmaNotaRegencia, banco);
                    }

                    if (origemLogNota > 0 && tipoLogNota > 0)
                    {
                        DateTime dataLogNota = DateTime.Now;
                        LOG_TurmaNota_Alteracao entLogNota = new LOG_TurmaNota_Alteracao
                        {
                            tud_id     = entity.tud_id,
                            tnt_id     = entity.tnt_id,
                            usu_id     = usu_id,
                            ltn_origem = origemLogNota,
                            ltn_tipo   = tipoLogNota,
                            ltn_data   = dataLogNota
                        };

                        LOG_TurmaNota_AlteracaoBO.Save(entLogNota, banco);
                    }

                    return(bRetorno);
                }

                throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
            }
            catch (Exception err)
            {
                banco.Close(err);
                throw;
            }
            finally
            {
                banco.Close();
            }
        }
Ejemplo n.º 6
0
    /// <summary>
    /// Insere ou altera um tipo de atividade avaliativa
    /// </summary>
    private void Salvar()
    {
        try
        {
            CLS_TipoAtividadeAvaliativa entity = new CLS_TipoAtividadeAvaliativa();
            entity.tav_id   = _VS_tav_id;
            entity          = CLS_TipoAtividadeAvaliativaBO.GetEntity(entity);
            entity.tav_nome = txtTipoAtividadeAvaliativa.Text;
            entity.qat_id   = Int32.Parse(ddlQualificador.SelectedValue);

            if (_VS_tav_id > 0)
            {
                entity.IsNew             = false;
                entity.tav_dataAlteracao = DateTime.Now;
            }
            else
            {
                entity.IsNew             = true;
                entity.tav_situacao      = 1;
                entity.tav_dataAlteracao = DateTime.Now;
                entity.tav_dataCriacao   = DateTime.Now;
            }

            if (CLS_TipoAtividadeAvaliativaBO.Save(entity))
            {
                if (_VS_tav_id <= 0)
                {
                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Insert, "tav_id: " + entity.tav_id);
                    __SessionWEB.PostMessages = UtilBO.GetErroMessage("Tipo de atividade avaliativa incluído com sucesso.", UtilBO.TipoMensagem.Sucesso);
                }
                else
                {
                    ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, "tav_id: " + entity.tav_id);
                    __SessionWEB.PostMessages = UtilBO.GetErroMessage("Tipo de atividade avaliativa alterado com sucesso.", UtilBO.TipoMensagem.Sucesso);
                }

                Response.Redirect(__SessionWEB._AreaAtual._Diretorio + "Configuracao/TipoAtividadeAvaliativa/Busca.aspx", false);
                HttpContext.Current.ApplicationInstance.CompleteRequest();
            }
            else
            {
                lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o tipo de atividade avaliativa.", UtilBO.TipoMensagem.Erro);
            }
        }
        catch (MSTech.Validation.Exceptions.ValidationException e)
        {
            lblMessage.Text = UtilBO.GetErroMessage(e.Message, UtilBO.TipoMensagem.Alerta);
        }
        catch (DuplicateNameException e)
        {
            lblMessage.Text = UtilBO.GetErroMessage(e.Message, UtilBO.TipoMensagem.Alerta);
        }
        catch (ArgumentException e)
        {
            lblMessage.Text = UtilBO.GetErroMessage(e.Message, UtilBO.TipoMensagem.Alerta);
        }
        catch (Exception e)
        {
            ApplicationWEB._GravaErro(e);
            lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o tipo de atividade avaliativa.", UtilBO.TipoMensagem.Erro);
        }
    }