/// <summary> /// Seleciona o formato de avaliação de acordo com a disciplina da turma. /// </summary> /// <param name="tud_id">Id da disciplina da turma.</param> /// <returns>Formato de avaliação.</returns> public ACA_FormatoAvaliacao SelecionarPorTur(long tur_id) { QuerySelectStoredProcedure qs = new QuerySelectStoredProcedure("NEW_ACA_FormatoAvaliacao_SelecionaPorTur", _Banco); try { #region PARAMETROS Param = qs.NewParameter(); Param.DbType = DbType.Int64; Param.Size = 8; Param.ParameterName = "@tur_id"; Param.Value = tur_id; qs.Parameters.Add(Param); #endregion qs.Execute(); ACA_FormatoAvaliacao entity = new ACA_FormatoAvaliacao(); if (qs.Return.Rows.Count > 0) { entity = DataRowToEntity(qs.Return.Rows[0], entity); } return(entity); } finally { qs.Parameters.Clear(); } }
/// <summary> /// Inicializa o user control, setando a visibilidade os botões /// conforme a página inicial. /// </summary> /// <param name="TelaInicial">Tela inicial a ser carregada.</param> /// <param name="fav">Formato de avaliação</param> /// <param name="tipo">Tipo de turma</param> public void Inicializar ( PaginaGestao TelaInicial , ACA_FormatoAvaliacao fav , TUR_TurmaTipo tipo , TUR_TurmaDisciplina entTurmaDisciplina ) { lblInfoLancamentoFrequenciaMensal.Text = UtilBO.GetErroMessage("Para lançar a frequência mensal dessa turma, acessar a frequência mensal das turmas regulares dos alunos.", UtilBO.TipoMensagem.Informacao); divInfoLancamentoFrequenciaMensal.Visible = (tipo == TUR_TurmaTipo.EletivaAluno); btnEfetivacao.Visible = (TelaInicial != PaginaGestao.EfetivacaoNotas); btnLancamentoFrequencia.Visible = (TelaInicial != PaginaGestao.Lancamento_Frequencia) && (fav.fav_tipoLancamentoFrequencia != Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.Mensal)) // Se a disciplina for do tipo Complementação de regência, não exibe o botão frequência. && (entTurmaDisciplina == null || entTurmaDisciplina.tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia); btnLancamentoAvaliacao.Visible = (TelaInicial != PaginaGestao.Lancamento_Avaliacoes); btnLancamentoFrequenciaMensal.Visible = (TelaInicial != PaginaGestao.Lancamento_FrequenciaMensal) && (tipo != TUR_TurmaTipo.EletivaAluno) && ((fav.fav_tipoLancamentoFrequencia == Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.Mensal) || fav.fav_tipoLancamentoFrequencia == Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.AulasPlanejadasMensal)) && __SessionWEB.__UsuarioWEB.Grupo.vis_id != SysVisaoID.Individual); }
/// <summary> /// Salva as entidades turmaAula e TurmaAulaAluno nas listas. /// </summary> /// <param name="listTurmaAulaAluno">Lista de entidades CLS_TurmaAulaAluno</param> /// <param name="listTurmaAula">LIsta de entidades CLS_TurmaAula</param> /// <param name="tur_id">ID da turma</param> /// <param name="tud_id">ID da disciplina que está sendo salva as frequências</param> /// <param name="tdt_posicao">Posição do docente logado no sistema</param> /// <param name="entityTurma">Turma.</param> /// <param name="entityFormatoAvaliacao">Formato de avaliação.</param> /// <param name="entityCurriculoPeriodo">CurriculoPeriodo.</param> /// <returns></returns> public static bool Save ( List <CLS_TurmaAulaAluno> listTurmaAulaAluno , List <CLS_TurmaAula> listTurmaAula , long tur_id , long tud_id , byte tdt_posicao , TUR_Turma entityTurma = null , ACA_FormatoAvaliacao entityFormatoAvaliacao = null , ACA_CurriculoPeriodo entityCurriculoPeriodo = null , Guid usu_id = new Guid() , byte origemLogAula = 0 , byte tipoLogAula = 0 , Guid ent_id = new Guid() ) { TalkDBTransaction banco = new CLS_TurmaAulaAlunoDAO()._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); try { return(Save(listTurmaAulaAluno, listTurmaAula, tur_id, tud_id, tdt_posicao, entityTurma, entityFormatoAvaliacao, entityCurriculoPeriodo, banco, usu_id, origemLogAula, tipoLogAula, ent_id)); } catch (Exception err) { banco.Close(err); throw; } finally { banco.Close(); } }
protected void btnLancamentoFrequenciaMensal_Click(object sender, EventArgs e) { try { SetaPeriodoSelecionado(); ACA_FormatoAvaliacao fav = new ACA_FormatoAvaliacao { fav_id = _VS_fav_id }; ACA_FormatoAvaliacaoBO.GetEntity(fav); if (fav.fav_tipoLancamentoFrequencia == Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.Mensal) || fav.fav_tipoLancamentoFrequencia == Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.AulasPlanejadasMensal)) { Session["tur_idFrequencia"] = _VS_tur_id.ToString(); RedirecionaPagina("~/Classe/LancamentoFrequencia/LancamentoMensal.aspx"); } } catch (Exception ex) { ApplicationWEB._GravaErro(ex); __SessionWEB.PostMessages = UtilBO.GetErroMessage("Erro ao tentar carregar o sistema.", UtilBO.TipoMensagem.Erro); Response.Redirect("~/Classe/LancamentoFrequencia/Busca.aspx", false); HttpContext.Current.ApplicationInstance.CompleteRequest(); } }
/// <summary> /// Pesquisa os dados da turma. /// </summary> private void Pesquisar() { fdsSemAlunos.Visible = false; divResultados.Visible = false; UCAlunoEfetivacaoObservacaoGeral1.Mensagem = string.Empty; UCAlunoEfetivacaoObservacaoGeral1.ObservacaoVisible = false; spanMensagemSelecionarAluno.Visible = false; #region Salvar busca realizada com os parâmetros Dictionary <string, string> filtros = new Dictionary <string, string>(); filtros.Add("uad_idSuperior", UCComboUAEscola1.Uad_ID.ToString()); filtros.Add("esc_id", UCComboUAEscola1.Esc_ID.ToString()); filtros.Add("uni_id", UCComboUAEscola1.Uni_ID.ToString()); filtros.Add("cal_id", UCComboCalendario1.Valor.ToString()); filtros.Add("tur_id", UCComboTurma1.Valor[0].ToString()); filtros.Add("crp_idTurma", UCComboTurma1.Valor[1].ToString()); filtros.Add("ttn_id", UCComboTurma1.Valor[2].ToString()); filtros.Add("turmaExtinta", chkTurmaExtinta.Checked.ToString()); __SessionWEB.BuscaRealizada = new BuscaGestao { PaginaBusca = PaginaGestao.EfetivacaoGestor , Filtros = filtros }; #endregion Salvar busca realizada com os parâmetros VS_esc_id = UCComboUAEscola1.Esc_ID; VS_tur_id = UCComboTurma1.Valor[0]; CarregarAlunosTurma(VS_tur_id); if (rptAlunos.Items.Count > 0) { divResultados.Visible = true; spanMensagemSelecionarAluno.Visible = true; fdsSemAlunos.Visible = false; } else { divResultados.Visible = false; fdsSemAlunos.Visible = true; lblMensagemSemAlunos.Text = UtilBO.GetErroMessage(RetornaValorResource("lblMensagemSemAlunos.Text"), UtilBO.TipoMensagem.Informacao); } // Formatacao da nota numerica string arredondamento = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.ARREDONDAMENTO_NOTA_AVALIACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id).ToString(); ACA_FormatoAvaliacao formatoAvaliacao = TUR_TurmaBO.SelecionaFormatoAvaliacao(VS_tur_id); ACA_EscalaAvaliacaoNumerica escalaNum = new ACA_EscalaAvaliacaoNumerica { esa_id = formatoAvaliacao.esa_idPorDisciplina }; ACA_EscalaAvaliacaoNumericaBO.GetEntity(escalaNum); hdnFormatacaoNota.Value = RetornaNumeroCasasDecimais(escalaNum) + ";" + arredondamento.ToString().ToLower() + ";" + escalaNum.ean_variacao.ToString().Replace(',', '.'); // }
public void Carregar(int anoLetivo, int tcp_id, int tne_id) { try { dtDados = ACA_AlunoHistoricoBO.Seleciona_TipoCurriculoPeriodoAnoLetivo(tcp_id, anoLetivo, tne_id); dtDados.Columns.Add("ahd_id"); dtDados.Columns.Add("grade", typeof(bool)); dtDados.Columns.Add("alu_id", typeof(int)); dtDados.Columns.Add("ahd_avaliacao", typeof(string)); dtDados.Columns.Add("ahd_frequencia", typeof(int)); foreach (DataRow row in dtDados.Rows) { if (Convert.ToInt32(row["tds_id"]) > 0) { row["grade"] = true; } else { row["grade"] = false; } } if (dtDados.Rows.Count == 0) { lblMessage.Text = UtilBO.GetErroMessage((string)GetGlobalResourceObject("UserControl", "UCAddResultadoFinal.NenhumDadoParaInserir"), UtilBO.TipoMensagem.Informacao); } else { ACA_FormatoAvaliacao fav = new ACA_FormatoAvaliacao { fav_id = Convert.ToInt32(dtDados.Rows[0]["fav_id"]) }; ACA_FormatoAvaliacaoBO.GetEntity(fav); VS_fav_tipo = fav.fav_tipo; esa_id = fav.esa_idPorDisciplina > 0 ? fav.esa_idPorDisciplina : fav.esa_idConceitoGlobal; ACA_EscalaAvaliacao esa = new ACA_EscalaAvaliacao { esa_id = esa_id }; ACA_EscalaAvaliacaoBO.GetEntity(esa); tipo = esa.esa_tipo; } } catch (Exception ex) { ApplicationWEB._GravaErro(ex); lblMessage.Text = UtilBO.GetErroMessage((string)GetGlobalResourceObject("UserControl", "UCAddResultadoFinal.ErroCarregar"), UtilBO.TipoMensagem.Erro); } }
/// <summary> /// Verifica se as regras do curso estão sendo cumpridas. /// Quando o regime de matrícula é Seriado por avaliações, o formato tem que /// ser do tipo Conceito Global e a avaliação selecionada tem que ser do tipo /// Periódica ou Periódica + Final. /// </summary> private void VerificaRegrasCurso(TUR_Turma entityTurma, ACA_FormatoAvaliacao entityFormatoAvaliacao) { ACA_CurriculoPeriodo entCurPeriodo; bool Seriado; if (TUR_TurmaCurriculoBO.ValidaCursoSeriadoAvaliacao(entityTurma, entityFormatoAvaliacao, out entCurPeriodo, out Seriado) && Seriado) { VS_crp_nomeAvaliacao = GestaoEscolarUtilBO.nomePadraoPeriodoAvaliacao(entCurPeriodo.crp_nomeAvaliacao); } VS_CursoSeriadoAvaliacoes = Seriado && entCurPeriodo.crp_turmaAvaliacao; }
/// <summary> /// Verifica se o curso da turma possui avaliação do tipo seriado. /// </summary> /// <param name="entTurma">Entidade da turma.</param> /// <param name="EntFormatoAvaliacao">Entidade do formato de avaliação da turma.</param> /// <param name="banco">Transação.</param> /// <param name="entCurriculoPeriodo">Entidade do grupamento da turma (parâmatro de sáida)</param> /// <param name="Seriado">Flag que indica se o curso ~possui avaliação do tipo seriado (parâmatro de sáida)</param> /// <returns></returns> public static bool ValidaCursoSeriadoAvaliacao(TUR_Turma entTurma, ACA_FormatoAvaliacao EntFormatoAvaliacao, TalkDBTransaction banco, out ACA_CurriculoPeriodo entCurriculoPeriodo, out bool Seriado) { Seriado = false; List <TUR_TurmaCurriculo> listCurriculos = TUR_TurmaCurriculoBO.GetSelectBy_Turma(entTurma.tur_id, banco, GestaoEscolarUtilBO.MinutosCacheLongo); if (listCurriculos.Count == 0) { throw new Exception("A turma (tur_id: " + entTurma.tur_id + ") não possui nenhum curriculoPeriodo cadastrado."); } ACA_Curriculo entCurriculo = new ACA_Curriculo { cur_id = listCurriculos[0].cur_id , crr_id = listCurriculos[0].crr_id }; ACA_CurriculoBO.GetEntity(entCurriculo, banco); // Se curso for seriado por avaliações - EJA. if (entCurriculo.crr_regimeMatricula == (byte)ACA_CurriculoRegimeMatricula.SeriadoPorAvaliacoes) { Seriado = true; if ((EntFormatoAvaliacao.fav_tipo != (byte)ACA_FormatoAvaliacaoTipo.ConceitoGlobal) && (EntFormatoAvaliacao.fav_tipo != (byte)ACA_FormatoAvaliacaoTipo.GlobalDisciplina)) { // Curso do EJA não pode efetivar notas por disciplina - não possui ligação // com lançamento por disciplina. throw new ValidationException("O formato de avaliação \"" + EntFormatoAvaliacao.fav_nome + "\" deve ser do tipo \"Conceito global\" ou " + "\"Conceito global e nota por " + CustomResource.GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + "\", " + "pois o curso da turma é seriado por avaliações."); } } entCurriculoPeriodo = new ACA_CurriculoPeriodo { cur_id = entCurriculo.cur_id , crr_id = entCurriculo.crr_id , crp_id = listCurriculos[0].crp_id }; ACA_CurriculoPeriodoBO.GetEntity(entCurriculoPeriodo, banco); return(true); }
public new static bool Delete(CLS_CompensacaoAusencia entity) { CLS_CompensacaoAusenciaDAO dao = new CLS_CompensacaoAusenciaDAO(); dao._Banco.Open(IsolationLevel.ReadCommitted); try { ACA_FormatoAvaliacao formatoAvaliacao = ACA_FormatoAvaliacaoBO.CarregarPorTud(entity.tud_id); // Caso o fechamento seja automático, grava na fila de processamento. if (formatoAvaliacao.fav_fechamentoAutomatico && entity.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid())) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(entity.tud_id, entity.tpc_id, dao._Banco); } CLS_CompensacaoAusenciaAlunoDAO daoAluno = new CLS_CompensacaoAusenciaAlunoDAO { _Banco = dao._Banco }; List <CLS_CompensacaoAusenciaAluno> listaBanco = daoAluno.SelectByCpa_id(entity.cpa_id, entity.tud_id); foreach (CLS_CompensacaoAusenciaAluno item in listaBanco) { if (!daoAluno.Delete(item)) { throw new Exception("Erro ao tentar excluir compensação de ausência do aluno."); } } // Exclui CLS_CompensacaoAusencia if (!dao.Delete(entity)) { throw new Exception("Erro ao tentar excluir compensação de ausência."); } return(true); } catch (Exception err) { dao._Banco.Close(err); throw err; } finally { //Fechamento da transação dao._Banco.Close(); } }
/// <summary> /// Verifica se o curso da turma possui avaliação do tipo seriado. /// </summary> /// <param name="entTurma">Entidade da turma.</param> /// <param name="EntFormatoAvaliacao">Entidade do formato de avaliação da turma.</param> /// <param name="entCurriculoPeriodo">Entidade do grupamento da turma (parâmatro de sáida)</param> /// <param name="Seriado">Flag que indica se o curso ~possui avaliação do tipo seriado (parâmatro de sáida)</param> /// <returns></returns> public static bool ValidaCursoSeriadoAvaliacao(TUR_Turma entTurma, ACA_FormatoAvaliacao EntFormatoAvaliacao, out ACA_CurriculoPeriodo entCurriculoPeriodo, out bool Seriado) { TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaDAO()._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); try { return(ValidaCursoSeriadoAvaliacao(entTurma, EntFormatoAvaliacao, banco, out entCurriculoPeriodo, out Seriado)); } catch (Exception ex) { banco.Close(ex); throw; } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } }
protected void Page_Load(object sender, EventArgs e) { try { UCEfetivacaoNotas1.VisibleNavegacao = false; UCEfetivacaoNotas1.VisibleBotaoCancelar = false; if (!IsPostBack) { string message = __SessionWEB.PostMessages; if (!String.IsNullOrEmpty(message)) { lblMessage.Text = message; } if (PreviousPage == null && Session["DadosPaginaRetorno"] == null && Session["tud_id"] == null) { // Se não carregou nenhuma turma, redireciona pra busca. __SessionWEB.PostMessages = UtilBO.GetErroMessage("É necessário selecionar uma turma.", UtilBO.TipoMensagem.Alerta); if (__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Gestao || __SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.UnidadeAdministrativa) { RedirecionarPagina("~/Academico/ControleTurma/MinhaEscolaGestor.aspx"); } else { RedirecionarPagina("~/Academico/ControleTurma/Busca.aspx"); } } else { List <Struct_MinhasTurmas> dadosTodasTurmas = new List <Struct_MinhasTurmas>(); long tud_idCompartilhada = -1; if (Session["Historico"] != null) { VS_historico = Convert.ToBoolean(Session["Historico"]) && __SessionWEB.__UsuarioWEB.Docente.doc_id > 0; Session.Remove("Historico"); } if (Session["TudIdCompartilhada"] != null) { tud_idCompartilhada = Convert.ToInt64(Session["TudIdCompartilhada"]); Session.Remove("TudIdCompartilhada"); } if (Session["tud_id"] != null && Session["tdt_posicao"] != null && Session["PaginaRetorno"] != null) { UCControleTurma1.VS_tud_id = Convert.ToInt64(Session["tud_id"]); UCControleTurma1.VS_tdt_posicao = Convert.ToByte(Session["tdt_posicao"]); UCNavegacaoTelaPeriodo.VS_paginaRetorno = Session["PaginaRetorno"].ToString(); if (Session["tur_tipo"] != null && Session["tur_idNormal"] != null && Session["tud_idAluno"] != null) { UCControleTurma1.VS_tur_tipo = Convert.ToByte(Session["tur_tipo"]); UCControleTurma1.VS_tur_idNormal = Convert.ToInt64(Session["tur_idNormal"]); UCControleTurma1.VS_tud_idAluno = Convert.ToInt64(Session["tud_idAluno"]); } if (VS_EntitiesControleTurma.escola == null) { ViewState["VS_EntitiesControleTurma"] = null; } UCControleTurma1.VS_esc_id = VS_EntitiesControleTurma.escola.esc_id; UCControleTurma1.VS_uni_id = VS_EntitiesControleTurma.turma.uni_id; UCControleTurma1.VS_tur_id = VS_EntitiesControleTurma.turma.tur_id; UCControleTurma1.VS_tud_naoLancarNota = VS_EntitiesControleTurma.turmaDisciplina.tud_naoLancarNota; UCControleTurma1.VS_tud_naoLancarFrequencia = VS_EntitiesControleTurma.turmaDisciplina.tud_naoLancarFrequencia; UCControleTurma1.VS_tur_dataEncerramento = VS_EntitiesControleTurma.turma.tur_dataEncerramento; UCNavegacaoTelaPeriodo.VS_cal_id = VS_EntitiesControleTurma.turma.cal_id; UCControleTurma1.VS_tciIds = VS_EntitiesControleTurma.tciIds; if (Session["VS_TpcId"] != null) { UCNavegacaoTelaPeriodo.VS_tpc_id = Convert.ToInt32(Session["VS_TpcId"]); } if (Session["VS_TpcOrdem"] != null) { UCNavegacaoTelaPeriodo.VS_tpc_ordem = Convert.ToInt32(Session["VS_TpcOrdem"]); } } else if (PreviousPage != null && PreviousPage.IsCrossPagePostBack) { UCControleTurma1.VS_tud_id = PreviousPage.Edit_tud_id; UCControleTurma1.VS_tdt_posicao = PreviousPage.Edit_tdt_posicao; UCNavegacaoTelaPeriodo.VS_paginaRetorno = PreviousPage.PaginaRetorno; if (VS_EntitiesControleTurma.escola == null) { ViewState["VS_EntitiesControleTurma"] = null; } UCControleTurma1.VS_esc_id = VS_EntitiesControleTurma.escola.esc_id; UCControleTurma1.VS_uni_id = VS_EntitiesControleTurma.turma.uni_id; UCControleTurma1.VS_tur_id = VS_EntitiesControleTurma.turma.tur_id; UCControleTurma1.VS_tud_naoLancarNota = VS_EntitiesControleTurma.turmaDisciplina.tud_naoLancarNota; UCControleTurma1.VS_tud_naoLancarFrequencia = VS_EntitiesControleTurma.turmaDisciplina.tud_naoLancarFrequencia; UCControleTurma1.VS_tur_dataEncerramento = VS_EntitiesControleTurma.turma.tur_dataEncerramento; UCNavegacaoTelaPeriodo.VS_cal_id = VS_EntitiesControleTurma.turma.cal_id; UCControleTurma1.VS_tciIds = VS_EntitiesControleTurma.tciIds; UCControleTurma1.VS_tur_tipo = VS_EntitiesControleTurma.turma.tur_tipo; } else if (Session["DadosPaginaRetorno"] != null) { Dictionary <string, string> listaDados = (Dictionary <string, string>)Session["DadosPaginaRetorno"]; UCControleTurma1.VS_tud_id = Convert.ToInt64(listaDados["Tud_idRetorno_ControleTurma"]); UCControleTurma1.VS_tdt_posicao = Convert.ToByte(listaDados["Edit_tdt_posicao"]); UCNavegacaoTelaPeriodo.VS_paginaRetorno = listaDados["PaginaRetorno"].ToString(); UCControleTurma1.VS_esc_id = Convert.ToInt32(listaDados["Edit_esc_id"]); UCControleTurma1.VS_uni_id = Convert.ToInt32(listaDados["Edit_uni_id"]); UCControleTurma1.VS_tur_id = Convert.ToInt64(listaDados["Edit_tur_id"]); UCControleTurma1.VS_tud_naoLancarNota = Convert.ToBoolean(listaDados["Edit_tud_naoLancarNota"]); UCControleTurma1.VS_tud_naoLancarFrequencia = Convert.ToBoolean(listaDados["Edit_tud_naoLancarFrequencia"]); UCControleTurma1.VS_tur_dataEncerramento = Convert.ToDateTime(listaDados["Edit_tur_dataEncerramento"]); UCNavegacaoTelaPeriodo.VS_cal_id = Convert.ToInt32(listaDados["Edit_cal_id"]); UCControleTurma1.VS_tciIds = listaDados["Edit_tciIds"]; UCControleTurma1.VS_tur_tipo = Convert.ToByte(listaDados["Edit_tur_tipo"]); UCControleTurma1.VS_tud_idAluno = Convert.ToInt64(listaDados["Edit_tud_idAluno"]); UCControleTurma1.VS_tur_idNormal = Convert.ToInt64(listaDados["Edit_tur_idNormal"]); UCNavegacaoTelaPeriodo.VS_tpc_id = Convert.ToInt32(listaDados["Edit_tpc_id"]); UCNavegacaoTelaPeriodo.VS_tpc_ordem = Convert.ToInt32(listaDados["Edit_tpc_ordem"]); UCControleTurma1.VS_tur_tud_ids = (List <string>)(Session["tur_tud_ids"] ?? new List <string>()); UCControleTurma1.LabelTurmas = listaDados["TextoTurmas"]; } int tpcIdPendencia = -1; if (Session["tpcIdPendencia"] != null) { tpcIdPendencia = Convert.ToInt32(Session["tpcIdPendencia"]); } // Remove os dados que possam estar na sessao Session.Remove("tud_id"); Session.Remove("tdt_posicao"); Session.Remove("PaginaRetorno"); Session.Remove("DadosPaginaRetorno"); Session.Remove("VS_DadosTurmas"); Session.Remove("VS_TpcId"); Session.Remove("tur_tipo"); Session.Remove("tur_idNormal"); Session.Remove("tud_idAluno"); Session.Remove("tur_tud_ids"); Session.Remove("tipoPendencia"); Session.Remove("tpcIdPendencia"); Session.Remove("tudIdPendencia"); // List <Struct_MinhasTurmas.Struct_Turmas> dadosTurma = new List <Struct_MinhasTurmas.Struct_Turmas>(); // Se for perfil Administrador if (__SessionWEB.__UsuarioWEB.Docente.doc_id == 0) { dadosTodasTurmas.Add ( new Struct_MinhasTurmas { Turmas = TUR_TurmaBO.SelecionaMinhasTurmasComboPorTurId ( VS_EntitiesControleTurma.turmaDisciplina.tud_tipo == (byte)TurmaDisciplinaTipo.MultisseriadaDocente ? UCControleTurma1.VS_tur_idNormal : UCControleTurma1.VS_tur_id, ApplicationWEB.AppMinutosCacheCurto ) } ); // Não busca pela posição dadosTodasTurmas.All(p => { dadosTurma.AddRange(p.Turmas.Where(t => t.tud_id == UCControleTurma1.VS_tud_id)); return(true); }); UCControleTurma1.LabelTurmas = dadosTurma.FirstOrDefault().TurmaDisciplinaEscola; } else { dadosTodasTurmas = TUR_TurmaBO.SelecionaPorDocenteControleTurma(__SessionWEB.__UsuarioWEB.Usuario.ent_id, __SessionWEB.__UsuarioWEB.Docente.doc_id, ApplicationWEB.AppMinutosCacheCurto, false); dadosTodasTurmas.All(p => { dadosTurma.AddRange(p.Turmas.Where(t => t.tud_id == UCControleTurma1.VS_tud_id && t.tdt_posicao == UCControleTurma1.VS_tdt_posicao)); return(true); }); VS_situacaoTurmaDisciplina = dadosTurma.FirstOrDefault().tdt_situacao; UCControleTurma1.LabelTurmas = dadosTurma.FirstOrDefault().TurmaDisciplinaEscola; } VS_turmasAnoAtual = dadosTurma.FirstOrDefault().turmasAnoAtual; UCNavegacaoTelaPeriodo.VS_opcaoAbaAtual = eOpcaoAbaMinhasTurmas.Efetivacao; // Carrega o combo de disciplinas e seta o valor selecionado. List <Struct_MinhasTurmas.Struct_Turmas> dadosTurmas = new List <Struct_MinhasTurmas.Struct_Turmas>(); dadosTodasTurmas.All(p => { dadosTurmas.AddRange(p.Turmas); return(true); }); // Carrega combo de turmas if (__SessionWEB.__UsuarioWEB.Docente.doc_id == 0) { List <Struct_MinhasTurmas.Struct_Turmas> dadosTurmasCombo = TUR_TurmaBO.SelecionaMinhasTurmasComboPorTurId ( VS_EntitiesControleTurma.turmaDisciplina.tud_tipo == (byte)TurmaDisciplinaTipo.MultisseriadaDocente ? UCControleTurma1.VS_tur_idNormal : UCControleTurma1.VS_tur_id, ApplicationWEB.AppMinutosCacheCurto ); UCControleTurma1.CarregaTurmas(dadosTurmasCombo, UCNavegacaoTelaPeriodo.VS_cal_id, VS_EntitiesControleTurma.turmaDisciplina.tud_tipo, VS_EntitiesControleTurma.formatoAvaliacao.fav_fechamentoAutomatico, true); } else { List <Struct_MinhasTurmas.Struct_Turmas> dadosTurmasCombo = new List <Struct_MinhasTurmas.Struct_Turmas>(); if (VS_EntitiesControleTurma.turma.tur_situacao == (byte)TUR_TurmaSituacao.Ativo && VS_situacaoTurmaDisciplina == 1) { // dadosTurmasAtivas dadosTurmasCombo = TUR_TurmaBO.SelecionaTurmasAtivasDocente(dadosTodasTurmas, 0); } else { dadosTurmasCombo = dadosTurmas; } UCControleTurma1.CarregaTurmas(dadosTurmasCombo, UCNavegacaoTelaPeriodo.VS_cal_id, VS_EntitiesControleTurma.turmaDisciplina.tud_tipo, VS_EntitiesControleTurma.formatoAvaliacao.fav_fechamentoAutomatico, true); } TUR_Turma turma = new TUR_Turma(); turma.tur_id = UCControleTurma1.VS_tur_id; turma = TUR_TurmaBO.GetEntity(turma); ACA_FormatoAvaliacao formatoAvaliacao = new ACA_FormatoAvaliacao(); formatoAvaliacao.fav_id = turma.fav_id; formatoAvaliacao = ACA_FormatoAvaliacaoBO.GetEntity(formatoAvaliacao); UCNavegacaoTelaPeriodo.VS_IncluirPeriodoFinal = formatoAvaliacao.fav_avaliacaoFinalAnalitica; TUR_TurmaDisciplina entDisciplinaRelacionada = null; if (VS_EntitiesControleTurma.turmaDisciplina.tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada) { List <sTurmaDisciplinaRelacionada> lstDisciplinaCompartilhada = VS_historico ? TUR_TurmaDisciplinaBO.SelectRelacionadaVigenteBy_DisciplinaCompartilhada(VS_EntitiesControleTurma.turmaDisciplina.tud_id, ApplicationWEB.AppMinutosCacheLongo, false, __SessionWEB.__UsuarioWEB.Docente.doc_id) : TUR_TurmaDisciplinaBO.SelectRelacionadaVigenteBy_DisciplinaCompartilhada(VS_EntitiesControleTurma.turmaDisciplina.tud_id, ApplicationWEB.AppMinutosCacheLongo); bool docenciaCompartilhadaOk = false; if (lstDisciplinaCompartilhada.Count > 0) { if (tud_idCompartilhada <= 0 || !lstDisciplinaCompartilhada.Any(p => p.tud_id == tud_idCompartilhada)) { tud_idCompartilhada = lstDisciplinaCompartilhada[0].tud_id; } if (tud_idCompartilhada > 0) { docenciaCompartilhadaOk = true; entDisciplinaRelacionada = TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina { tud_id = tud_idCompartilhada }); VS_turmaDisciplinaRelacionada = lstDisciplinaCompartilhada.Find(p => p.tud_id == tud_idCompartilhada); //UCControleTurma1.CarregarDisciplinaCompartilhada(lstDisciplinaCompartilhada, VS_turmaDisciplinaRelacionada.tud_id, VS_turmaDisciplinaRelacionada.tdr_id); } } if (!docenciaCompartilhadaOk) { __SessionWEB.PostMessages = UtilBO.GetErroMessage(String.Format("{0} {1} - {2}.", GetGlobalResourceObject("Mensagens", "MSG_SEM_RELACIONAMENTO_DOCENCIA_COMPARTILHADA").ToString() , VS_EntitiesControleTurma.turma.tur_codigo , VS_EntitiesControleTurma.turmaDisciplina.tud_nome) , UtilBO.TipoMensagem.Alerta); RedirecionarPagina(UCNavegacaoTelaPeriodo.VS_paginaRetorno); } } UCNavegacaoTelaPeriodo.CarregarPeriodos(VS_ltPermissaoFrequencia, VS_ltPermissaoEfetivacao, VS_ltPermissaoPlanejamentoAnual, VS_ltPermissaoAvaliacao, entDisciplinaRelacionada, UCControleTurma1.VS_esc_id, VS_EntitiesControleTurma.turmaDisciplina.tud_tipo, UCControleTurma1.VS_tdt_posicao, turma.tur_id, VS_EntitiesControleTurma.turmaDisciplina.tud_id, false, tpcIdPendencia); if (UCNavegacaoTelaPeriodo.VS_tpc_id <= 0 && !formatoAvaliacao.fav_avaliacaoFinalAnalitica) { __SessionWEB.PostMessages = UtilBO.GetErroMessage("Escola não permite lançar dados.", UtilBO.TipoMensagem.Alerta); RedirecionarPagina(UCNavegacaoTelaPeriodo.VS_paginaRetorno); } CarregarTela(); } hdnProcessarFilaFechamentoTela.Value = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PROCESSAR_FILA_FECHAMENTO_TELA, __SessionWEB.__UsuarioWEB.Usuario.ent_id) ? "true" : "false"; } ScriptManager sm = ScriptManager.GetCurrent(this); if (sm != null) { sm.Scripts.Add(new ScriptReference("~/Includes/jsControleTurma_Efetivacao.js")); sm.Scripts.Add(new ScriptReference("~/Includes/jsUCSelecaoDisciplinaCompartilhada.js")); } UCNavegacaoTelaPeriodo.OnCarregaDadosTela += CarregaSessionPaginaRetorno; UCControleTurma1.IndexChanged = uccTurmaDisciplina_IndexChanged; UCNavegacaoTelaPeriodo.OnAlteraPeriodo += CarregarTela; UCSelecaoDisciplinaCompartilhada1.SelecionarDisciplina += UCSelecaoDisciplinaCompartilhada1_SelecionarDisciplina; UCControleTurma1.chkTurmasNormaisMultisseriadasIndexChanged += UCControleTurma_chkTurmasNormaisMultisseriadasIndexChanged; if ((__SessionWEB.__UsuarioWEB.Grupo.vis_id != SysVisaoID.Individual) && (__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_consultar && // somente permissão consulta (!__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_inserir) && (!__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_excluir) && (!__SessionWEB.__UsuarioWEB.GrupoPermissao.grp_alterar))) { UCEfetivacaoNotas1.HabilitaBoletimAluno = true; } bool mudaCorTitulo = VS_cal_ano < DateTime.Now.Year && VS_turmasAnoAtual && VS_EntitiesControleTurma.turma.tur_situacao == 1; UCControleTurma1.CorTituloTurma = mudaCorTitulo ? System.Drawing.ColorTranslator.FromHtml("#A52A2A") : System.Drawing.Color.Black; divMessageTurmaAnterior.Visible = mudaCorTitulo; } catch (ThreadAbortException) { } catch (Exception ex) { ApplicationWEB._GravaErro(ex); lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar os dados.", UtilBO.TipoMensagem.Erro); } }
public static bool Salvar(List <CLS_AlunoFrequenciaExterna> lstAlunoFrequenciaExterna, int fav_id, Guid ent_id) { TalkDBTransaction banco = new CLS_AlunoFrequenciaExternaDAO()._Banco.CopyThisInstance(); List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>(); try { if (lstAlunoFrequenciaExterna.Aggregate(true, (salvou, freq) => salvou & Save(freq, banco))) { ACA_FormatoAvaliacao entFormatoAvaliacao = new ACA_FormatoAvaliacao { fav_id = fav_id }; ACA_FormatoAvaliacaoBO.GetEntity(entFormatoAvaliacao, banco); if (entFormatoAvaliacao.fav_fechamentoAutomatico) { FilaProcessamento.AddRange (lstAlunoFrequenciaExterna.GroupBy(p => new { p.tud_id, p.tpc_id }) .Select(p => new AlunoFechamentoPendencia { tud_id = p.Key.tud_id , tpc_id = p.Key.tpc_id , afp_frequencia = false , afp_nota = false , afp_frequenciaExterna = true , afp_processado = 0 }) ); if (FilaProcessamento.Any()) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequenciaExterna( FilaProcessamento .GroupBy(g => new { g.tud_id, g.tpc_id }) .Select(p => new AlunoFechamentoPendencia { tud_id = p.FirstOrDefault().tud_id, tpc_id = p.FirstOrDefault().tpc_id, afp_frequencia = p.FirstOrDefault().afp_frequencia, afp_nota = p.FirstOrDefault().afp_nota, afp_frequenciaExterna = p.FirstOrDefault().afp_frequenciaExterna, afp_processado = FilaProcessamento .Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id) .Min(m => m.afp_processado) }) .Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)) .ToList() , banco); } } return(true); } return(false); } catch (Exception ex) { banco.Close(ex); throw; } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } }
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; }
/// <summary> /// Verifica se o botão de frequência será exibido ou não /// Se a turma existir disciplina principal, só exibe o botão de frequência para essa disciplina /// </summary> /// <param name="tud_id">Id da disciplina da turma</param> /// <param name="TelaInicial">Tela inicial a ser carregada.</param> /// <param name="entityTurma">The entity turma.</param> /// <param name="entityFormato">The entity formato.</param> public void ExibirFrequencia(long tud_id, PaginaGestao TelaInicial, TUR_Turma entityTurma, ACA_FormatoAvaliacao entityFormato) { bool BtnVisible = (TelaInicial != PaginaGestao.Lancamento_Frequencia) && (entityFormato.fav_tipoLancamentoFrequencia != Convert.ToByte(ACA_FormatoAvaliacaoTipoLancamentoFrequencia.Mensal)); if (tud_id > 0) { List <TUR_TurmaDisciplina> lista = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(entityTurma.tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo); // Se a turma possui disciplina principal e tem lançamento em conjunto. if (lista.Exists(p => p.tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal) && (!(entityFormato.fav_planejamentoAulasNotasConjunto && entityTurma.tur_docenteEspecialista))) { // Esconde o botão de lançamento de frequência caso a disciplina não seja a principal. btnLancamentoFrequencia.Visible = (lista.Find(p => p.tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal).tud_id == tud_id) && BtnVisible; } else if (lista.Exists (p => p.tud_id == tud_id && p.tud_tipo == (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia )) { // Se for a disciplina do tipo Complementação de regência, não exibe o botão de frequência. btnLancamentoFrequencia.Visible = false; } else { btnLancamentoFrequencia.Visible = BtnVisible; } } else { btnLancamentoFrequencia.Visible = BtnVisible; } }
protected void grvTurmas_RowDataBound(object sender, GridViewRowEventArgs e) { if (e.Row.RowType == DataControlRowType.DataRow && PreCarregarFechamentoCache) { long tur_id = Convert.ToInt64(DataBinder.Eval(e.Row.DataItem, "tur_id")); int fav_id = Convert.ToInt32(DataBinder.Eval(e.Row.DataItem, "fav_id")); int esc_id = Convert.ToInt32(DataBinder.Eval(e.Row.DataItem, "esc_id")); int cal_id = Convert.ToInt32(DataBinder.Eval(e.Row.DataItem, "cal_id")); byte tur_tipo = Convert.ToByte(DataBinder.Eval(e.Row.DataItem, "tur_tipo")); long tud_id = Convert.ToInt64(DataBinder.Eval(e.Row.DataItem, "tud_id")); byte tud_tipo = Convert.ToByte(DataBinder.Eval(e.Row.DataItem, "tud_tipo")); bool tud_disciplinaEspecial = Convert.ToBoolean(DataBinder.Eval(e.Row.DataItem, "tud_disciplinaEspecial")); byte tdt_posicao = Convert.ToByte(DataBinder.Eval(e.Row.DataItem, "tdt_posicao")); ACA_FormatoAvaliacao entityFormatoAvaliacao = new ACA_FormatoAvaliacao { fav_id = fav_id }; ACA_FormatoAvaliacaoBO.GetEntity(entityFormatoAvaliacao); ACA_EscalaAvaliacao entityEscalaAvaliacao = new ACA_EscalaAvaliacao { esa_id = entityFormatoAvaliacao.esa_idPorDisciplina }; ACA_EscalaAvaliacaoBO.GetEntity(entityEscalaAvaliacao); ACA_EscalaAvaliacao entityEscalaAvaliacaoDocente = new ACA_EscalaAvaliacao { esa_id = entityFormatoAvaliacao.esa_idDocente }; ACA_EscalaAvaliacaoBO.GetEntity(entityEscalaAvaliacaoDocente); double notaMinimaAprovacao = 0; int ordemParecerMinimo = 0; // Valor do conceito global ou por disciplina. string valorMinimo = tud_id > 0 ? entityFormatoAvaliacao.valorMinimoAprovacaoPorDisciplina : entityFormatoAvaliacao.valorMinimoAprovacaoConceitoGlobal; if (entityEscalaAvaliacao.esa_tipo == (byte)EscalaAvaliacaoTipo.Numerica) { notaMinimaAprovacao = Convert.ToDouble(valorMinimo.Replace(',', '.')); } else if (entityEscalaAvaliacao.esa_tipo == (byte)EscalaAvaliacaoTipo.Pareceres) { ordemParecerMinimo = ACA_EscalaAvaliacaoParecerBO.RetornaOrdem_Parecer(entityEscalaAvaliacao.esa_id, valorMinimo, ApplicationWEB.AppMinutosCacheLongo); } bool incluirFinal = entityFormatoAvaliacao.fav_avaliacaoFinalAnalitica; List <Struct_CalendarioPeriodos> tabelaPeriodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(cal_id, ApplicationWEB.AppMinutosCacheLongo); List <ESC_EscolaCalendarioPeriodo> lstEscCalPeriodo = ESC_EscolaCalendarioPeriodoBO.SelectEscolasCalendarioCache(cal_id, ApplicationWEB.AppMinutosCacheCurto); List <Struct_CalendarioPeriodos> listaCalendarioPeriodo = tabelaPeriodos.Where(calP => (lstEscCalPeriodo.Where(escP => (escP.esc_id == esc_id && escP.tpc_id == calP.tpc_id)).Count() == 0)).ToList(); int tpc_idUltimoPerido = tabelaPeriodos.Count > 0 ? tabelaPeriodos.Last().tpc_id : -1; int tpc_ordemUltimoPeriodo = tabelaPeriodos.Count > 0 ? tabelaPeriodos.Last().tpc_ordem : 0; //Busca o bimestre corrente Struct_CalendarioPeriodos periodoCorrente = listaCalendarioPeriodo.Where(x => (x.cap_dataInicio.Date <= DateTime.Now.Date && x.cap_dataFim.Date >= DateTime.Now.Date)).FirstOrDefault(); int tpc_id = periodoCorrente.tpc_id; int tpc_ordem = periodoCorrente.tpc_ordem; } }
/// <summary> /// O método salva as observações para conselho pedagógico. /// </summary> /// <param name="tur_id">ID da turma.</param> /// <param name="alu_id">ID do aluno.</param> /// <param name="mtu_id">ID da matrícula turma do aluno.</param> /// <param name="fav_id">ID do formato de avaliação.</param> /// <param name="ava_id">ID da avaliação.</param> /// <param name="ltObservacao">Lista de observações.</param> /// <param name="banco">Banco</param> /// <param name="ent_id">Id da entidade do usuário logado.</param> /// <returns></returns> public static bool SalvarObservacao ( long tur_id, long alu_id, int mtu_id, int fav_id, int ava_id, CLS_AlunoAvaliacaoTur_Observacao observacao, Guid usu_idLogado, byte resultado, string justificativaResultado, DateTime dataUltimaAlteracaoObservacao, DateTime dataUltimaAlteracaoNotaFinal, ACA_FormatoAvaliacao entFormatoAvaliacao, List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplina, List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina, int tamanhoMaximoKB, string[] TiposArquivosPermitidos, ref List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao, Guid ent_id, int tpc_id ) { TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaObservacaoDAO()._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>(); try { if (observacao.entityObservacao != null && observacao.entityObservacao != new CLS_AlunoAvaliacaoTurmaObservacao()) { Save(observacao.entityObservacao, banco); } int tpc_idUtilizado = -1; List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplinasUltimoPeriodo = new List <CLS_AvaliacaoTurDisc_Cadastro>(); listaDisciplinasUltimoPeriodo = listaDisciplina.Where(d => d.entity.ava_id != ava_id).ToList(); if (listaDisciplinasUltimoPeriodo.Count > 0) { tpc_idUtilizado = ACA_AvaliacaoBO.SelecionaMaiorBimestre_ByFormatoAvaliacao(entFormatoAvaliacao.fav_id, banco); } CLS_AlunoAvaliacaoTurmaDisciplinaBO.SaveAvaliacaoFinal( tur_id , entFormatoAvaliacao , listaDisciplina , tamanhoMaximoKB , TiposArquivosPermitidos , dataUltimaAlteracaoNotaFinal , listaMatriculaTurmaDisciplina , ref listaAtualizacaoEfetivacao , banco); tpc_idUtilizado = tpc_idUtilizado > 0 ? tpc_idUtilizado : tpc_id; if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaMatriculaTurmaDisciplina.Any()) { FilaProcessamento.AddRange(listaMatriculaTurmaDisciplina .Select(p => new AlunoFechamentoPendencia { tud_id = p.tud_id, tpc_id = tpc_idUtilizado, afp_frequencia = true, afp_nota = true, afp_processado = (Byte)(p.mtd_id <= 0 ? 0 : 2) }).ToList()); } // Se for passado o resultado, salva na MTR_MatriculaTurma. if (!usu_idLogado.Equals(Guid.Empty)) { MTR_MatriculaTurma entMatr = new MTR_MatriculaTurma { alu_id = alu_id , mtu_id = mtu_id }; MTR_MatriculaTurmaBO.GetEntity(entMatr, banco); // Se o registro foi alterado depois da data da alteração mais recente no momento em que os dados foram carregados, // interrompe o salvamento e alerta o usuário de que é necessário atualizar os dados if (entMatr != null && !entMatr.IsNew && Convert.ToDateTime(entMatr.mtu_dataAlteracao.ToString()) > dataUltimaAlteracaoObservacao) { throw new ValidationException("Existe registro alterado mais recentemente, é necessário atualizar os dados."); } else { entMatr.usu_idResultado = usu_idLogado; entMatr.mtu_resultado = resultado; entMatr.mtu_relatorio = justificativaResultado; MTR_MatriculaTurmaBO.Save(entMatr, banco); if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.GERAR_HISTORICO_SALVAR_PARECER_CONCLUSIVO, ent_id)) { ACA_AlunoHistoricoBO.GeracaoHistoricoPedagogicoPorAluno(entMatr.alu_id, entMatr.mtu_id, banco); } if (entFormatoAvaliacao.fav_fechamentoAutomatico) { FilaProcessamento.Add(new AlunoFechamentoPendencia { tud_id = listaMatriculaTurmaDisciplina.FirstOrDefault().tud_id, tpc_id = tpc_id, afp_frequencia = true, afp_nota = true, afp_processado = (Byte)(entMatr.IsNew == true ? 0 : 2) }); } } } // Limpa cache do fechamento, para atualizar o check. GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, fav_id, ava_id)); List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo); listaDisciplinas.ForEach(p => { GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(p.tud_id, fav_id, ava_id, string.Empty)); GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(p.tud_id, fav_id, ava_id, string.Empty)); // Chaves do fechamento automatico string chave = string.Empty; chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_MODEL_KEY, p.tud_id, tpc_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id, tpc_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, p.tud_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id); CacheManager.Factory.RemoveByPattern(chave); // }); if (entFormatoAvaliacao.fav_fechamentoAutomatico && FilaProcessamento.Any(a => a.tpc_id > 0)) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias( FilaProcessamento .GroupBy(g => new { g.tud_id, g.tpc_id }) .Select(p => new AlunoFechamentoPendencia { tud_id = p.FirstOrDefault().tud_id, tpc_id = p.FirstOrDefault().tpc_id, afp_frequencia = p.FirstOrDefault().afp_frequencia, afp_nota = p.FirstOrDefault().afp_nota, afp_processado = FilaProcessamento .Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id) .Min(m => m.afp_processado) }) .Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)) .ToList() , banco); } return(true); } catch (ValidationException ex) { banco.Close(ex); throw; } catch (Exception ex) { banco.Close(ex); throw; } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } }
/// <summary> /// Carregar os períodos e seta a visibilidade dos botões de acordo com a permissão do usuário. /// </summary> public void CarregarPeriodos ( List <sPermissaoDocente> VS_ltPermissaoFrequencia , List <sPermissaoDocente> VS_ltPermissaoEfetivacao , List <sPermissaoDocente> VS_ltPermissaoPlanejamentoAnual , List <sPermissaoDocente> VS_ltPermissaoAvaliacao , TUR_TurmaDisciplina VS_turmaDisciplinaRelacionada , int esc_id , byte tud_tipo , byte tdt_posicao = 0 , Int64 tur_id = -1 , Int64 tud_id = -1 , bool incluirPeriodoRecesso = false , int tpcIdPendencia = -1 ) { // Habilita a visibilidade dos botões alunos e voltar VisibleAlunos = !ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.MINHAS_TURMAS_ESCONDER_BOTAO_ALUNO, __SessionWEB.__UsuarioWEB.Usuario.ent_id); VisibleVoltar = !ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.MINHAS_TURMAS_ESCONDER_BOTAO_VOLTAR, __SessionWEB.__UsuarioWEB.Usuario.ent_id); int fav_id = -1; if (tur_id > 0 && tud_id > 0 && ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PRE_CARREGAR_CACHE_EFETIVACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id)) { TUR_Turma entityTurma = new TUR_Turma { tur_id = tur_id }; TUR_TurmaBO.GetEntity(entityTurma); ACA_FormatoAvaliacao entityFormato = new ACA_FormatoAvaliacao { fav_id = entityTurma.fav_id }; ACA_FormatoAvaliacaoBO.GetEntity(entityFormato); ACA_EscalaAvaliacao entityEscala = new ACA_EscalaAvaliacao { esa_id = entityFormato.esa_idPorDisciplina }; ACA_EscalaAvaliacaoBO.GetEntity(entityEscala); ACA_EscalaAvaliacao entityEscalaDocente = new ACA_EscalaAvaliacao { esa_id = entityFormato.esa_idDocente }; ACA_EscalaAvaliacaoBO.GetEntity(entityEscalaDocente); TUR_TurmaDisciplina entityTurmaDisciplina = new TUR_TurmaDisciplina { tud_id = tud_id }; TUR_TurmaDisciplinaBO.GetEntity(entityTurmaDisciplina); // Valor do conceito global ou por disciplina. string valorMinimo = tud_id > 0 ? entityFormato.valorMinimoAprovacaoPorDisciplina : entityFormato.valorMinimoAprovacaoConceitoGlobal; double notaMinimaAprovacao = 0; int ordemParecerMinimo = 0; EscalaAvaliacaoTipo tipoEscala = (EscalaAvaliacaoTipo)entityEscala.esa_tipo; if (tipoEscala == EscalaAvaliacaoTipo.Numerica) { notaMinimaAprovacao = Convert.ToDouble(valorMinimo.Replace(',', '.')); } else if (tipoEscala == EscalaAvaliacaoTipo.Pareceres) { ordemParecerMinimo = ACA_EscalaAvaliacaoParecerBO.RetornaOrdem_Parecer(entityEscala.esa_id, valorMinimo, ApplicationWEB.AppMinutosCacheLongo); } hdnTudId.Value = tud_id.ToString(); hdnTurId.Value = entityTurma.tur_id.ToString(); hdnFavId.Value = entityTurma.fav_id.ToString(); hdnEsaId.Value = entityEscala.esa_id.ToString(); hdnTipoEscala.Value = entityEscala.esa_tipo.ToString(); hdnTipoEscalaDocente.Value = entityEscalaDocente.esa_tipo.ToString(); hdnNotaMinima.Value = notaMinimaAprovacao.ToString(); hdnParecerMinimo.Value = ordemParecerMinimo.ToString(); hdnTipoLancamento.Value = entityFormato.fav_tipoLancamentoFrequencia.ToString(); hdnCalculoQtAulasDadas.Value = entityFormato.fav_calculoQtdeAulasDadas.ToString(); hdnTurTipo.Value = entityTurma.tur_tipo.ToString(); hdnCalId.Value = entityTurma.cal_id.ToString(); hdnTudTipo.Value = entityTurmaDisciplina.tud_tipo.ToString(); hdnVariacao.Value = entityFormato.fav_variacao.ToString(); hdnTipoDocente.Value = (__SessionWEB.__UsuarioWEB.Docente.doc_id > 0 ? (byte)ACA_TipoDocenteBO.SelecionaTipoDocentePorPosicao(tdt_posicao, ApplicationWEB.AppMinutosCacheLongo) : (byte)0).ToString(); hdnDisciplinaEspecial.Value = entityTurmaDisciplina.tud_disciplinaEspecial ? "true" : "false"; hdnFechamentoAutomatico.Value = entityFormato.fav_fechamentoAutomatico ? "true" : "false"; hdnProcessarFilaFechamentoTela.Value = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PROCESSAR_FILA_FECHAMENTO_TELA, __SessionWEB.__UsuarioWEB.Usuario.ent_id) ? "true" : "false"; fav_id = entityFormato.fav_id; } if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.TELA_UNICA_LANCAMENTO_FREQUENCIA_AVALIACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id)) { VisibleListao = VS_ltPermissaoFrequencia.Any(p => p.pdc_permissaoConsulta) || VS_ltPermissaoAvaliacao.Any(p => p.pdc_permissaoConsulta); btnFrequencia.Visible = btnAvaliacao.Visible = false; } else { VisibleListao = false; btnFrequencia.Visible = VS_ltPermissaoFrequencia.Any(p => p.pdc_permissaoConsulta); btnAvaliacao.Visible = VS_ltPermissaoAvaliacao.Any(p => p.pdc_permissaoConsulta); } VisibleEfetivacao = tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada && VS_ltPermissaoEfetivacao.Any(p => p.pdc_permissaoConsulta) && !ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.MINHAS_TURMAS_ESCONDER_BOTAO_EFETIVACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id); VisiblePlanejamentoAnual = tud_tipo == (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada ? VS_turmaDisciplinaRelacionada != null && VS_turmaDisciplinaRelacionada.tud_naoLancarPlanejamento == false : VS_ltPermissaoPlanejamentoAnual.Any(p => p.pdc_permissaoConsulta); List <Struct_CalendarioPeriodos> lstCalendarioPeriodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(VS_cal_id, ApplicationWEB.AppMinutosCacheLongo, false, __SessionWEB.__UsuarioWEB.Usuario.ent_id); if (incluirPeriodoRecesso) { VS_CalendarioPeriodo = lstCalendarioPeriodos; } else { VS_CalendarioPeriodo = lstCalendarioPeriodos.FindAll(p => p.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, __SessionWEB.__UsuarioWEB.Usuario.ent_id)); // Se o período selecionado for de recesso, // seleciono o bimestre anterior. if (VS_tpc_id == ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, __SessionWEB.__UsuarioWEB.Usuario.ent_id)) { int indiceRecesso = lstCalendarioPeriodos.FindIndex(p => p.tpc_id == VS_tpc_id); if (indiceRecesso > 0) { Struct_CalendarioPeriodos periodo = lstCalendarioPeriodos[indiceRecesso - 1]; VS_tpc_id = periodo.tpc_id; VS_tpc_ordem = periodo.tpc_ordem; } } } VS_cal_ano = VS_CalendarioPeriodo.Find(p => p.cal_id == VS_cal_id).cal_ano; List <ESC_EscolaCalendarioPeriodo> lstEscCalPeriodo = ESC_EscolaCalendarioPeriodoBO.SelectEscolasCalendarioCache(VS_cal_id, ApplicationWEB.AppMinutosCacheCurto); VS_CalendarioPeriodo = VS_CalendarioPeriodo.Where(calP => (lstEscCalPeriodo.Where(escP => (escP.esc_id == esc_id && escP.tpc_id == calP.tpc_id)).Count() == 0)).ToList(); if (VS_IncluirPeriodoFinal) { Struct_CalendarioPeriodos[] calendarioPeriodosCopy = new Struct_CalendarioPeriodos[VS_CalendarioPeriodo.Count() + 1]; VS_CalendarioPeriodo.CopyTo(calendarioPeriodosCopy, 0); Struct_CalendarioPeriodos periodoFinal = new Struct_CalendarioPeriodos(); periodoFinal.cap_descricao = periodoFinal.tpc_nomeAbreviado = GetGlobalResourceObject("UserControl", "NavegacaoTelaPeriodo.UCNavegacaoTelaPeriodo.PeriodoFinal").ToString(); periodoFinal.tpc_id = -1; calendarioPeriodosCopy[VS_CalendarioPeriodo.Count()] = periodoFinal; rptPeriodo.DataSource = calendarioPeriodosCopy; } else { rptPeriodo.DataSource = VS_CalendarioPeriodo; } if (fav_id > 0) { string tpc_id = string.Join(",", VS_CalendarioPeriodo.Select(p => p.tpc_id.ToString()).ToArray()); ltAvaliacao = ACA_AvaliacaoBO.ConsultaPor_Periodo_Relacionadas(fav_id, tpc_id, ApplicationWEB.AppMinutosCacheLongo); if (VS_IncluirPeriodoFinal) { ltAvaliacao.AddRange(ACA_AvaliacaoBO.SelectAvaliacaoFinal_PorFormato(fav_id, ApplicationWEB.AppMinutosCacheLongo)); } } rptPeriodo.DataBind(); //Seleciona o ultimo bimestre List <Struct_CalendarioPeriodos> tabelaPeriodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(VS_cal_id, ApplicationWEB.AppMinutosCacheLongo); int tpc_idUltimoPeriodo = tabelaPeriodos.Count > 0 ? tabelaPeriodos.Last().tpc_id : -1; int tpc_ordemUltimoPeriodo = tabelaPeriodos.Count > 0 ? tabelaPeriodos.Last().tpc_ordem : 0; if (tpcIdPendencia > 0) { //Busca o bimestre pendente Struct_CalendarioPeriodos periodo = VS_CalendarioPeriodo.Where(x => x.tpc_id == tpcIdPendencia).FirstOrDefault(); VS_tpc_id = periodo.tpc_id; VS_tpc_ordem = periodo.tpc_ordem; } if (VS_tpc_id <= 0 && !VS_IncluirPeriodoFinal) { //Busca o bimestre corrente Struct_CalendarioPeriodos periodo = VS_CalendarioPeriodo.Where(x => (x.cap_dataInicio.Date <= DateTime.Now.Date && x.cap_dataFim.Date >= DateTime.Now.Date)).FirstOrDefault(); VS_tpc_id = periodo.tpc_id; VS_tpc_ordem = periodo.tpc_ordem; if (VS_tpc_id <= 0) { //Se não tem bimestre selecionado e nem bimestre corrente então seleciona o próximo corrente periodo = VS_CalendarioPeriodo.Where(x => (x.cap_dataInicio.Date >= DateTime.Now.Date)).FirstOrDefault(); VS_tpc_id = periodo.tpc_id; VS_tpc_ordem = periodo.tpc_ordem; if (VS_tpc_id <= 0) { //Se não tem bimestre selecionado então seleciona o ultimo VS_tpc_id = tpc_idUltimoPeriodo; VS_tpc_ordem = tpc_ordemUltimoPeriodo; } } } if (VS_tpc_id >= 0 && VS_IncluirPeriodoFinal) { if (VS_tpc_id == tpc_idUltimoPeriodo) { // Se for o ultimo periodo e a avaliacao final estiver aberta, // selecionar a avaliacao final List <ACA_Evento> listaEventos = ACA_EventoBO.GetEntity_Efetivacao_List(VS_cal_id, tur_id, __SessionWEB.__UsuarioWEB.Grupo.gru_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo, true, __SessionWEB.__UsuarioWEB.Docente.doc_id); if (listaEventos.Exists(p => p.tev_id == ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_FINAL, __SessionWEB.__UsuarioWEB.Usuario.ent_id))) { VS_tpc_id = -1; VS_tpc_ordem = 0; } } if (VS_tpc_id == 0) { //Se não tem bimestre selecionado e nem bimestre corrente então seleciona o próximo corrente Struct_CalendarioPeriodos periodo = VS_CalendarioPeriodo.Where(x => (x.cap_dataInicio.Date >= DateTime.Now.Date)).FirstOrDefault(); VS_tpc_id = periodo.tpc_id; VS_tpc_ordem = periodo.tpc_ordem; if (VS_tpc_id <= 0) { //Se não tem bimestre selecionado então seleciona o final VS_tpc_id = -1; VS_tpc_ordem = 0; } } } if (VS_tpc_ordem < 0) { VS_tpc_ordem = 0; } // Seleciona o botão do bimestre informado (VS_tpc_id) rptPeriodo.Items.Cast <RepeaterItem>().ToList() .Select(p => (Button)p.FindControl("btnPeriodo")) .ToList().ForEach(p => RemoveClass(p, "periodo_selecionado")); rptPeriodo.Items.Cast <RepeaterItem>().ToList() .Where(p => Convert.ToInt32(((HiddenField)p.FindControl("hdnPeriodo")).Value) == VS_tpc_id && Convert.ToInt32(((HiddenField)p.FindControl("hdnPeriodoOrdem")).Value) == VS_tpc_ordem) .Select(p => (Button)p.FindControl("btnPeriodo")) .ToList() .ForEach ( p => { AddClass(p, "periodo_selecionado"); HiddenField hdn = (HiddenField)p.FindControl("hdnIdAvaliacao"); if (!string.IsNullOrEmpty(hdn.Value)) { hdnAvaId.Value = hdn.Value; } hdn = (HiddenField)p.FindControl("hdnAvaliacaoTipo"); if (!string.IsNullOrEmpty(hdn.Value)) { hdnTipoAvaliacao.Value = hdn.Value; } hdnTpcId.Value = VS_tpc_id.ToString(); hdn = (HiddenField)p.FindControl("hdnPeriodoOrdem"); if (!string.IsNullOrEmpty(hdn.Value)) { hdnTpcOrdem.Value = hdn.Value; } } ); }
private void xrAtividadeAvaliativaEfetivacao_BeforePrint(object sender, System.Drawing.Printing.PrintEventArgs e) { TUR_Turma tur = new TUR_Turma { tur_id = Convert.ToInt64(TURID.Value) }; TUR_TurmaBO.GetEntity(tur); ACA_FormatoAvaliacao fav = new ACA_FormatoAvaliacao { fav_id = tur.fav_id }; ACA_FormatoAvaliacaoBO.GetEntity(fav); ACA_EscalaAvaliacao esa = new ACA_EscalaAvaliacao { esa_id = fav.esa_idPorDisciplina }; ACA_EscalaAvaliacaoBO.GetEntity(esa); xrBarra.Visible = (esa.esa_tipo == Convert.ToByte(1)); xrPizza.Visible = (esa.esa_tipo == Convert.ToByte(2)); List <string> lstCoresRelatorio = new List <string>(); //Carrega as faixas da turma com as cores var lstFaixas = (from dadosGeral in dsGestaoEscolar2.NEW_RelatorioAvaliacao_Efetivacao_Grafico.AsEnumerable() group dadosGeral by new { far_ordenar = dadosGeral.Field <object>("far_ordenar") != null ? dadosGeral.Field <object>("far_ordenar").ToString() : "", far_cor = dadosGeral.Field <object>("far_cor") != null ? dadosGeral.Field <object>("far_cor").ToString() : "" } into faixas orderby faixas.Key.far_ordenar select faixas.Key); //Se todas as faixas tiverem cores então vai usar as cores das faixas if (!lstFaixas.Any(p => string.IsNullOrEmpty(p.far_cor))) { lstCoresRelatorio = lstFaixas.Select(p => p.far_cor).ToList(); } //Se não carregou nenhuma cor das faixas então usa as cores configuradas para o relatório if (lstCoresRelatorio.Count == 0) { lstCoresRelatorio = RelatoriosDevUtil.SelecionaCoresRelatorio((int)ReportNameGestaoAcademicaDocumentosDocente.DocDctGraficoAtividadeAvaliativa).Select(p => p.cor_corPaleta).ToList(); } Palette paletaCores = RelatoriosDevUtil.CarregarPaletaCoresRelatorio(lstCoresRelatorio); if (paletaCores.Count > 0) { if (xrPizza.Visible) { xrPizza.PaletteRepository.Add("Gestao", paletaCores); xrPizza.PaletteName = "Gestao"; } if (xrBarra.Visible) { xrBarra.PaletteRepository.Add("Gestao", paletaCores); xrBarra.PaletteName = "Gestao"; } } }
/// <summary> /// Salva as entidades turmaAula e TurmaAulaAluno nas listas - com transação. /// </summary> /// <param name="listTurmaAulaAluno">Lista de entidades CLS_TurmaAulaAluno</param> /// <param name="listTurmaAula">LIsta de entidades CLS_TurmaAula</param> /// <param name="tur_id">ID da turma</param> /// <param name="tud_id">ID da disciplina que está sendo salva as frequências</param> /// <param name="tdt_posicao">Posição do docente logado no sistema</param> /// <param name="entityTurma">Turma.</param> /// <param name="entityFormatoAvaliacao">Formato de avaliação.</param> /// <param name="entityCurriculoPeriodo">CurriculoPeriodo.</param> /// <param name="banco">Transação com banco de dados aberta</param> /// <returns></returns> internal static bool Save ( List <CLS_TurmaAulaAluno> listTurmaAulaAluno , List <CLS_TurmaAula> listTurmaAula , long tur_id , long tud_id , byte tdt_posicao , TUR_Turma entityTurma , ACA_FormatoAvaliacao entityFormatoAvaliacao , ACA_CurriculoPeriodo entityCurriculoPeriodo , TalkDBTransaction banco , Guid usu_id = new Guid() , byte origemLogAula = 0 , byte tipoLogAula = 0 , Guid ent_id = new Guid() ) { string tau_ids = string.Join(",", (from CLS_TurmaAula item in listTurmaAula select item.tau_id.ToString()). ToArray()); // Recupera a lista de entidades CLS_TurmaAulaAluno para verificar se ela já existe. List <CLS_TurmaAulaAluno> listaTurmaAulaAluno = new CLS_TurmaAulaAlunoDAO { _Banco = banco } .SelectBy_Disciplina_Aulas(tud_id, tau_ids); DataTable dtTurmaAulaAluno = CLS_TurmaAulaAluno.TipoTabela_TurmaAulaAluno(); List <LOG_TurmaAula_Alteracao> listLogAula = new List <LOG_TurmaAula_Alteracao>(); object lockObject = new object(); Parallel.ForEach ( listTurmaAulaAluno, entityTurmaAulaAluno => { // Busca se a entidade já existe na lista. CLS_TurmaAulaAluno entAux = listaTurmaAulaAluno.Find(p => p.tud_id == entityTurmaAulaAluno.tud_id && p.tau_id == entityTurmaAulaAluno.tau_id && p.alu_id == entityTurmaAulaAluno.alu_id && p.mtu_id == entityTurmaAulaAluno.mtu_id && p.mtd_id == entityTurmaAulaAluno.mtd_id ); if (entAux != null) { entityTurmaAulaAluno.IsNew = entAux.IsNew; entityTurmaAulaAluno.taa_anotacao = entAux.taa_anotacao; entityTurmaAulaAluno.usu_idDocenteAlteracao = entAux.usu_idDocenteAlteracao; } Validate(entityTurmaAulaAluno, listTurmaAula); if (entityTurmaAulaAluno.Validate()) { lock (lockObject) { DataRow dr = dtTurmaAulaAluno.NewRow(); dtTurmaAulaAluno.Rows.Add(TurmaAulaAlunoToDataRow(entityTurmaAulaAluno, dr)); } } else { throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entityTurmaAulaAluno)); } } ); // Salva os dados de todos os alunos na tabela CLS_TurmaAulaAluno SalvaFrequenciaAlunos(dtTurmaAulaAluno, banco); // Verifica se a entidade recebida por parâmetro foi alimentada, se não foi, dá o GetEntity. TUR_Turma turma = entityTurma ?? TUR_TurmaBO.GetEntity(new TUR_Turma { tur_id = tur_id }, banco); ACA_FormatoAvaliacao formatoAvaliacao = entityFormatoAvaliacao ?? ACA_FormatoAvaliacaoBO.GetEntity(new ACA_FormatoAvaliacao { fav_id = turma.fav_id }, banco); ACA_CurriculoPeriodo entityCrp = entityCurriculoPeriodo ?? ACA_CurriculoPeriodoBO.SelecionaPorTurmaTipoNormal(turma.tur_id, GestaoEscolarUtilBO.MinutosCacheLongo); List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, banco, GestaoEscolarUtilBO.MinutosCacheLongo); TUR_TurmaDisciplina entDisciplinarincipal = listaDisciplinas.Find(p => p.tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal); // Se não for para lançar na disciplina global, e a turma possuir uma disc. principal, // só poderá salvar na disciplina principal. bool validarDiscPrincipal = (!(turma.tur_docenteEspecialista && formatoAvaliacao.fav_planejamentoAulasNotasConjunto)) && (entDisciplinarincipal != null) && (formatoAvaliacao.fav_tipoApuracaoFrequencia != (byte)ACA_FormatoAvaliacaoTipoApuracaoFrequencia.Dia && entityCrp.crp_controleTempo != (byte)ACA_CurriculoPeriodoControleTempo.Horas); DateTime dataLogAula = DateTime.Now; foreach (CLS_TurmaAula entityTurmaAula in listTurmaAula) { // Se for pra validar a disc. principal, só pode lançar frequência nela. if (validarDiscPrincipal && (entDisciplinarincipal.tud_id != entityTurmaAula.tud_id)) { throw new ValidationException("A frequência dessa turma só pode ser lançada para o(a) " + CustomResource.GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + entDisciplinarincipal.tud_nome + "."); } if (origemLogAula > 0) { LOG_TurmaAula_Alteracao entLogAula = new LOG_TurmaAula_Alteracao { tud_id = entityTurmaAula.tud_id, tau_id = entityTurmaAula.tau_id, usu_id = usu_id, lta_origem = origemLogAula, lta_tipo = tipoLogAula, lta_data = dataLogAula }; listLogAula.Add(entLogAula); } } //Salva os logs de alteração de aula LOG_TurmaAula_AlteracaoBO.SalvarEmLote(listLogAula, banco); // Atualiza o campo efetivado da aula. CLS_TurmaAulaBO.AtualizarEfetivado(listTurmaAula, banco); // Caso o fechamento seja automático, grava na fila de processamento. if (formatoAvaliacao.fav_fechamentoAutomatico && listTurmaAula.Count > 0 && listTurmaAula[0].tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(tud_id, listTurmaAula[0].tpc_id, banco); } if (listTurmaAula.Any() && dtTurmaAulaAluno.Rows.Count > 0 && HttpContext.Current != null) { // Limpa o cache do fechamento try { string chave = string.Empty; int tpc_id = listTurmaAula[0].tpc_id; List <ACA_Avaliacao> avaliacao = ACA_AvaliacaoBO.GetSelectBy_FormatoAvaliacaoPeriodo(turma.fav_id, tpc_id); if (avaliacao.Any()) { int ava_id = avaliacao.First().ava_id; if (tud_id > 0) { chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(tud_id, turma.fav_id, ava_id, string.Empty); CacheManager.Factory.RemoveByPattern(chave); chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(tud_id, turma.fav_id, ava_id, string.Empty); CacheManager.Factory.RemoveByPattern(chave); } else { chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, turma.fav_id, ava_id); HttpContext.Current.Cache.Remove(chave); } } } catch { } } return(true); }
/// <summary> /// O método salva as observações para conselho pedagógico. /// </summary> /// <param name="tur_id">ID da turma.</param> /// <param name="alu_id">ID do aluno.</param> /// <param name="mtu_id">ID da matrícula turma do aluno.</param> /// <param name="fav_id">ID do formato de avaliação.</param> /// <param name="ava_id">ID da avaliação.</param> /// <param name="ltObservacao">Lista de observações.</param> /// <param name="banco">Banco</param> /// <param name="ent_id">Id da entidade do usuário logado.</param> /// <returns></returns> public static bool SalvarObservacao ( long tur_id, long alu_id, int mtu_id, long[] tud_ids, List <CLS_AlunoAvaliacaoTurmaObservacao> listaObservacao, List <CLS_AlunoAvaliacaoTurma> listaAlunoAvaliacaoTurma, List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAlunoAvaliacaoTurmaDisciplina, List <ACA_AlunoAnotacao> listaAlunoAnotacao, bool permiteEditarResultadoFinal, Guid usu_idLogado, byte resultado, DateTime dataUltimaAlteracaoObservacao, DateTime dataUltimaAlteracaoNotaFinal, ACA_FormatoAvaliacao entFormatoAvaliacao, List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplina, List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina, int tamanhoMaximoKB, string[] TiposArquivosPermitidos, ref List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao, Guid ent_id, IDictionary <int, int> dicAvaTpc, List <CLS_AlunoAvaliacaoTurmaObservacaoBO.DadosAlunoObservacao> listaDadosPeriodo ) { TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaObservacaoDAO()._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>(); int tpc_idUltimoPeriodo = (dicAvaTpc.Count() > 0 ? dicAvaTpc.Max(p => p.Value) : 0); try { foreach (CLS_AlunoAvaliacaoTurmaObservacao observacao in listaObservacao) { observacao.usu_idAlteracao = usu_idLogado; Save(observacao, banco); } foreach (CLS_AlunoAvaliacaoTurma alunoAvaliacaoTurma in listaAlunoAvaliacaoTurma) { CLS_AlunoAvaliacaoTurmaBO.Save(alunoAvaliacaoTurma, banco); } object lockObject = new object(); DataTable dtAlunoAvaliacaoTurmaDisciplina = CLS_AlunoAvaliacaoTurmaDisciplina.TipoTabela_AlunoAvaliacaoTurmaDisciplina(); if (listaAlunoAvaliacaoTurmaDisciplina.Any()) { Parallel.ForEach ( listaAlunoAvaliacaoTurmaDisciplina, alunoAvaliacaoTurmaDisciplina => { lock (lockObject) { DataRow drAlunoAvaliacaoTurmaDisciplina = dtAlunoAvaliacaoTurmaDisciplina.NewRow(); dtAlunoAvaliacaoTurmaDisciplina.Rows.Add( CLS_AlunoAvaliacaoTurmaDisciplinaBO.EntityToDataRow(alunoAvaliacaoTurmaDisciplina, drAlunoAvaliacaoTurmaDisciplina)); } } ); } if (dtAlunoAvaliacaoTurmaDisciplina.Rows.Count > 0) { CLS_AlunoAvaliacaoTurmaDisciplinaBO.SalvarEmLotePosConselho(dtAlunoAvaliacaoTurmaDisciplina, banco); if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaAlunoAvaliacaoTurmaDisciplina.Any()) { FilaProcessamento.AddRange(listaAlunoAvaliacaoTurmaDisciplina .Select(p => new AlunoFechamentoPendencia { tud_id = p.tud_id, tpc_id = (p.tpc_id > 0 ? p.tpc_id : tpc_idUltimoPeriodo), afp_frequencia = true, afp_nota = true, afp_processado = (Byte)(p.atd_id <= 0 ? 0 : 2) }).ToList()); } } foreach (ACA_AlunoAnotacao alunoAnotacao in listaAlunoAnotacao) { ACA_AlunoAnotacaoBO.Save(alunoAnotacao, banco); } CLS_AlunoAvaliacaoTurmaDisciplinaBO.SaveAvaliacaoFinal( tur_id , entFormatoAvaliacao , listaDisciplina , tamanhoMaximoKB , TiposArquivosPermitidos , dataUltimaAlteracaoNotaFinal , listaMatriculaTurmaDisciplina , ref listaAtualizacaoEfetivacao , banco); if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaMatriculaTurmaDisciplina.Any() && (tpc_idUltimoPeriodo > 0)) { FilaProcessamento.AddRange(listaMatriculaTurmaDisciplina .Select(p => new AlunoFechamentoPendencia { tud_id = p.tud_id, tpc_id = tpc_idUltimoPeriodo, afp_frequencia = true, afp_nota = true, afp_processado = (Byte)(p.mtd_id <= 0 ? 0 : 2) }).ToList()); } if (permiteEditarResultadoFinal) { // Se for passado o resultado, salva na MTR_MatriculaTurma. MTR_MatriculaTurma entMatr = new MTR_MatriculaTurma { alu_id = alu_id , mtu_id = mtu_id }; MTR_MatriculaTurmaBO.GetEntity(entMatr, banco); // So registra a alteracao do parecer conclusivo (resultado) // se for um registro novo e tem valor selecionado, ou se houve alteracao do valor. if ((entMatr.IsNew && entMatr.mtu_resultado > 0) || entMatr.mtu_resultado != resultado) { // Se o registro foi alterado depois da data da alteração mais recente no momento em que os dados foram carregados, // interrompe o salvamento e alerta o usuário de que é necessário atualizar os dados if (entMatr != null && !entMatr.IsNew && Convert.ToDateTime(entMatr.mtu_dataAlteracao.ToString()) > dataUltimaAlteracaoObservacao) { throw new ValidationException("Existe registro alterado mais recentemente, é necessário atualizar os dados."); } else { entMatr.usu_idResultado = usu_idLogado; entMatr.mtu_resultado = resultado; MTR_MatriculaTurmaBO.Save(entMatr, banco); if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.GERAR_HISTORICO_SALVAR_PARECER_CONCLUSIVO, ent_id)) { ACA_AlunoHistoricoBO.GeracaoHistoricoPedagogicoPorAluno(entMatr.alu_id, entMatr.mtu_id, banco); } if (entFormatoAvaliacao.fav_fechamentoAutomatico) { FilaProcessamento.Add(new AlunoFechamentoPendencia { tud_id = tud_ids.FirstOrDefault(), tpc_id = tpc_idUltimoPeriodo, afp_frequencia = true, afp_nota = true, afp_processado = (Byte)(entMatr.IsNew == true ? 0 : 2) }); } } } } // Limpa cache do fechamento, para atualizar o check, as notas pos-conselho, o parecer e a sintese final. string chave = string.Empty; int tpcId = -1; listaDadosPeriodo.ForEach(q => { // Fechamento de bimestre chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, entFormatoAvaliacao.fav_id, q.ava_id); if (HttpContext.Current != null) { HttpContext.Current.Cache.Remove(chave); } chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato(tur_id, entFormatoAvaliacao.fav_id, q.ava_id); CacheManager.Factory.Remove(chave); // Fechamento final chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Final(tur_id, entFormatoAvaliacao.fav_id, q.ava_id); if (HttpContext.Current != null) { HttpContext.Current.Cache.Remove(chave); } chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato_Final(tur_id, entFormatoAvaliacao.fav_id, q.ava_id); CacheManager.Factory.Remove(chave); // Fechamento automatico de bimestre if (dicAvaTpc.TryGetValue(q.ava_id, out tpcId)) { chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpcId); CacheManager.Factory.Remove(chave); } // Fechamento automatico final chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, tur_id); CacheManager.Factory.Remove(chave); }); List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo); listaDisciplinas.ForEach(p => { // Fechamento de bimestre chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_BIMESTRE_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id); CacheManager.Factory.RemoveByPattern(chave); // Fechamento final chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_FINAL_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_FINAL_FILTRO_DEFICIENCIA_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id); CacheManager.Factory.RemoveByPattern(chave); // Fechamento automatico final chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, p.tud_id); CacheManager.Factory.Remove(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id); CacheManager.Factory.Remove(chave); listaDadosPeriodo.ForEach(q => { // Fechamento automatico de bimestre if (dicAvaTpc.TryGetValue(q.ava_id, out tpcId)) { chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_MODEL_KEY, p.tud_id, tpcId); CacheManager.Factory.Remove(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id, tpcId); CacheManager.Factory.Remove(chave); } }); }); // //Adiciona tuds para processamento de pendência de notas (quando salva o parecer final foreach (long tud in tud_ids.Where(t => !FilaProcessamento.Any(f => f.tud_id == t))) { FilaProcessamento.Add(new AlunoFechamentoPendencia { tud_id = tud, tpc_id = tpc_idUltimoPeriodo, afp_frequencia = false, afp_frequenciaExterna = false, afp_nota = true, afp_processado = (byte)2 }); } if (entFormatoAvaliacao.fav_fechamentoAutomatico && FilaProcessamento.Any(a => a.tpc_id > 0)) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias( FilaProcessamento .GroupBy(g => new { g.tud_id, g.tpc_id }) .Select(p => new AlunoFechamentoPendencia { tud_id = p.FirstOrDefault().tud_id, tpc_id = p.FirstOrDefault().tpc_id, afp_frequencia = p.FirstOrDefault().afp_frequencia, afp_nota = p.FirstOrDefault().afp_nota, afp_processado = FilaProcessamento .Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id) .Min(m => m.afp_processado) }) .Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)) .ToList() , banco); } return(true); } catch (ValidationException ex) { banco.Close(ex); throw; } catch (Exception ex) { banco.Close(ex); throw; } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } }
/// <summary> /// Processa os protocolos informados. /// </summary> /// <param name="ltProtocolo">Lista de protocolos em processamento.</param> /// <param name="tentativasProtocolo">Quantidade máxima de tentativas para processar protocolos.</param> /// <returns></returns> public static bool ProcessarProtocoloCompensacao(List <DCL_Protocolo> ltProtocolo, int tentativasProtocolo) { DataTable dtProtocolo = DCL_Protocolo.TipoTabela_Protocolo(); foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa > tentativasProtocolo)) { protocolo.pro_statusObservacao = String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}" , tentativasProtocolo, protocolo.pro_statusObservacao); protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); } foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa <= tentativasProtocolo)) { // Abre uma transação para cada protocolo dentro do laço. // Assim é possível processar o próximo protocolo, mesmo que o atual esteja com erro. TalkDBTransaction bancoSincronizacao = new CLS_TurmaAulaDAO()._Banco.CopyThisInstance(); bancoSincronizacao.Open(IsolationLevel.ReadCommitted); bool processou = false; try { if (protocolo.pro_tentativa <= tentativasProtocolo) { JObject json = JObject.Parse(protocolo.pro_pacote); JArray compensacoes = ((JArray)json.SelectToken("CompensacaoFalta") ?? new JArray()); foreach (JObject compensacao in compensacoes) { long tud_id = Convert.ToInt64(compensacao.SelectToken("tud_id")); ACA_FormatoAvaliacao formatoAvaliacao = ACA_FormatoAvaliacaoBO.CarregarPorTud(tud_id); ACA_CalendarioAnual cal = ACA_CalendarioAnualBO.SelecionaPorTurmaDisciplina(tud_id, bancoSincronizacao); // apenas protocolos de turmas ativas e do ano letivo corrente podem ser processados if (!DCL_ProtocoloBO.PodeProcessarProtocolo(0, tud_id)) { throw new ValidationException("O protocolo pertence a uma turma que não esta ativa ou de um ano letivo diferente do corrente, não pode ser processado!"); } int cpa_id = Convert.ToInt32(compensacao.SelectToken("cpa_id")); int quantidadeAulasCompensadas = Convert.ToInt32(compensacao.SelectToken("cpa_quantidadeAulasCompensadas")); DateTime cpa_dataAlteracao = Convert.ToDateTime(compensacao.SelectToken("cpa_dataAlteracao")); CLS_CompensacaoAusencia compensacaoAusencia; long pro_protocoloCriacao = (long)(compensacao.GetValue("pro_protocolo", StringComparison.OrdinalIgnoreCase) ?? "0"); if (cpa_id > 0 || pro_protocoloCriacao <= 0) { compensacaoAusencia = new CLS_CompensacaoAusencia { tud_id = tud_id, cpa_id = cpa_id }; GetEntity(compensacaoAusencia, bancoSincronizacao); } else { List <DCL_Protocolo> protocoloCriacaoCompensacao = DCL_ProtocoloBO.SelectBy_Protocolos(pro_protocoloCriacao.ToString()); Guid pro_idCriacao = protocoloCriacaoCompensacao.Count() > 0 ? protocoloCriacaoCompensacao[0].pro_id : Guid.Empty; compensacaoAusencia = SelectByDisciplinaProtocolo(tud_id, pro_idCriacao); if (!compensacaoAusencia.IsNew) { compensacaoAusencia.pro_id = protocolo.pro_id; } } if (compensacaoAusencia.IsNew) { compensacaoAusencia.cpa_id = -1; compensacaoAusencia.cpa_dataCriacao = DateTime.Now; compensacaoAusencia.pro_id = protocolo.pro_id; } else if (!compensacaoAusencia.IsNew && (cpa_dataAlteracao < compensacaoAusencia.cpa_dataAlteracao)) { throw new ValidationException("Compensação existe e foi alterada mais recentemente."); } compensacaoAusencia.tpc_id = Convert.ToInt32(compensacao.SelectToken("tpc_id")); compensacaoAusencia.cpa_quantidadeAulasCompensadas = quantidadeAulasCompensadas; compensacaoAusencia.cpa_atividadesDesenvolvidas = Convert.ToString(compensacao.SelectToken("cpa_atividadesDesenvolvidas")); compensacaoAusencia.cpa_situacao = Convert.ToInt16(compensacao.SelectToken("cpa_situacao")); compensacaoAusencia.cpa_dataAlteracao = DateTime.Now; if (compensacaoAusencia.cpa_situacao != 3) { JArray arrayAlunos = ((JArray)compensacao.SelectToken("AlunosCompensados") ?? new JArray()); List <CLS_CompensacaoAusenciaAluno> listaAlunos = new List <CLS_CompensacaoAusenciaAluno>(); foreach (JObject jsonAluno in arrayAlunos) { int alu_id = Convert.ToInt32(jsonAluno.SelectToken("alu_id")); MTR_MatriculaTurmaDisciplina matricula = MTR_MatriculaTurmaDisciplinaBO.BuscarPorAlunoTurmaDisciplina(alu_id, tud_id, bancoSincronizacao); CLS_CompensacaoAusenciaAluno compensacaoAluno = new CLS_CompensacaoAusenciaAluno { tud_id = tud_id, cpa_id = compensacaoAusencia.cpa_id, alu_id = alu_id, mtu_id = matricula.mtu_id, mtd_id = matricula.mtd_id }; CLS_CompensacaoAusenciaAlunoBO.GetEntity(compensacaoAluno); if (compensacaoAluno.IsNew) { compensacaoAluno.caa_dataCriacao = DateTime.Now; } compensacaoAluno.caa_situacao = 1; compensacaoAluno.caa_dataAlteracao = DateTime.Now; listaAlunos.Add(compensacaoAluno); } processou = Save(compensacaoAusencia, listaAlunos, formatoAvaliacao.fav_fechamentoAutomatico, cal.cal_id, bancoSincronizacao); } else { // persistindo os dados. processou = true; // Caso o fechamento seja automático, grava na fila de processamento. if (formatoAvaliacao.fav_fechamentoAutomatico && compensacaoAusencia.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid())) { processou &= CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(compensacaoAusencia.tud_id, compensacaoAusencia.tpc_id, bancoSincronizacao); } processou &= Delete(compensacaoAusencia, bancoSincronizacao); } } } // Processou com sucesso. protocolo.pro_statusObservacao = String.Format("Protocolo processado com sucesso ({0}).", DateTime.Now.ToString("dd/MM/yyyy HH:mm")); protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComSucesso; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); } catch (ArgumentException ex) { // Se ocorrer uma excessão de validação, guardar novo status. protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao; protocolo.pro_statusObservacao = ex.Message; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); bancoSincronizacao.Close(ex); } catch (ValidationException ex) { // Se ocorrer uma excessão de validação, guardar novo status. protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao; protocolo.pro_statusObservacao = ex.Message; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); bancoSincronizacao.Close(ex); } catch (Exception ex) { // Se ocorrer uma excessão de erro, guardar novo status. protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErro; protocolo.pro_statusObservacao = ex.Message; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); bancoSincronizacao.Close(ex); } finally { if (bancoSincronizacao.ConnectionIsOpen) { bancoSincronizacao.Close(); } } } DCL_ProtocoloBO.AtualizaProtocolos(dtProtocolo); return(true); }
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); } }
public static bool Delete(CLS_RelatorioPreenchimentoAlunoTurmaDisciplina entity, int rea_id) { CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaDAO dao = new CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaDAO(); dao._Banco.Open(IsolationLevel.ReadCommitted); try { bool sucesso = Delete(entity, dao._Banco); if (sucesso) { CLS_RelatorioAtendimento relatorioAtendimento = CLS_RelatorioAtendimentoBO.GetEntity(new CLS_RelatorioAtendimento { rea_id = rea_id }); if (relatorioAtendimento.rea_tipo == (byte)CLS_RelatorioAtendimentoTipo.RP) { ACA_CalendarioAnual calendario = ACA_CalendarioAnualBO.SelecionaPorTurma(entity.tur_id); List <MTR_MatriculaTurma> matriculasAno = MTR_MatriculaTurmaBO.GetSelectMatriculasAlunoAno(entity.alu_id, calendario.cal_ano); matriculasAno.ForEach(p => LimpaCache_AlunoPreenchimentoPorPeriodoDisciplina(entity.tpc_id, p.tur_id)); ACA_FormatoAvaliacao fav = TUR_TurmaBO.SelecionaFormatoAvaliacao(entity.tur_id, dao._Banco); if (fav != null && fav.fav_fechamentoAutomatico) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(entity.tud_id, entity.tpc_id, dao._Banco); } } else if (relatorioAtendimento.rea_tipo == (byte)CLS_RelatorioAtendimentoTipo.NAAPA) { List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>(); ACA_CalendarioAnual cal = ACA_CalendarioAnualBO.SelecionaPorTurma(entity.tur_id, dao._Banco); var periodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(cal.cal_id, GestaoEscolarUtilBO.MinutosCacheLongo); FilaProcessamento.AddRange(TUR_TurmaDisciplinaBO.GetSelectBy_Turma(entity.tur_id, dao._Banco, GestaoEscolarUtilBO.MinutosCacheLongo) .SelectMany ( tud => periodos.Select ( tpc => new AlunoFechamentoPendencia { tud_id = tud.tud_id , tpc_id = tpc.tpc_id , afp_frequencia = true , afp_nota = true , afp_processado = 2 } ).ToList() )); if (FilaProcessamento.Any()) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(FilaProcessamento, dao._Banco); } } } return(sucesso); } catch (Exception ex) { dao._Banco.Close(ex); throw; } finally { if (dao._Banco.ConnectionIsOpen) { dao._Banco.Close(); } } }
protected void _dgvTurma_RowCommand(object sender, GridViewCommandEventArgs e) { if (e.CommandName == "Selecionar") { try { VS_cancelSelect = false; GridViewRow row = (GridViewRow)((LinkButton)e.CommandSource).NamingContainer; int index = row.RowIndex; _VS_tur_id = Convert.ToInt32(_dgvTurma.DataKeys[index].Values["tur_id"]); // Utilizado para verificar se é turma eletiva do aluno TUR_Turma tur = new TUR_Turma { tur_id = _VS_tur_id }; TUR_TurmaBO.GetEntity(tur); // verifica se existe evento de efetivacao ligado ao calendário da turma int cal_id = Convert.ToInt32(_dgvTurma.DataKeys[index].Values["cal_id"]); // Busca o evento ligado ao calendário, que seja do tipo definido // no parâmetro como de efetivação. List <ACA_Evento> listEvento = ACA_EventoBO.GetEntity_Efetivacao_List(cal_id, _VS_tur_id, __SessionWEB.__UsuarioWEB.Grupo.gru_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, ApplicationWEB.AppMinutosCacheLongo, true, __SessionWEB.__UsuarioWEB.Docente.doc_id); if (string.IsNullOrEmpty(_dgvTurma.DataKeys[index].Values["fav_id"].ToString())) { _lblMessage.Text = UtilBO.GetErroMessage("É necessário selecionar uma turma que possua um formato de avaliação.", UtilBO.TipoMensagem.Alerta); } else { _VS_fav_id = Convert.ToInt32(_dgvTurma.DataKeys[index].Values["fav_id"]); int valor = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id); int valorRecuperacao = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_RECUPERACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id); int valorFinal = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_FINAL, __SessionWEB.__UsuarioWEB.Usuario.ent_id); int valorRecuperacaoFinal = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_RECUPERACAO_FINAL, __SessionWEB.__UsuarioWEB.Usuario.ent_id); // verifica se existe evento do tipo Efetivação Nota string listaTpcIdPeriodicaPeriodicaFinal = string.Empty; IEnumerable <ACA_Evento> dadoNota = (from ACA_Evento item in listEvento where item.tev_id == valor select item); // se existir, pega os tpc_id's List <ACA_Evento> lt = dadoNota.ToList(); if (lt.Count > 0) { var x = from ACA_Evento evt in listEvento where evt.tev_id == valor select evt.tpc_id; foreach (int tpc_id in x.ToList()) { if (string.IsNullOrEmpty(listaTpcIdPeriodicaPeriodicaFinal)) { listaTpcIdPeriodicaPeriodicaFinal += Convert.ToString(tpc_id); } else { listaTpcIdPeriodicaPeriodicaFinal += "," + Convert.ToString(tpc_id); } } } // verifica se existe evento do tipo efetivação recuperacao string listaTpcIdRecuperacao = string.Empty; IEnumerable <ACA_Evento> dadoRecuperacao = (from ACA_Evento item in listEvento where item.tev_id == valorRecuperacao select item); List <ACA_Evento> ltRe = dadoRecuperacao.ToList(); // se existir, pega os tpc_id's if (ltRe.Count > 0) { var x = from ACA_Evento evt in listEvento where evt.tev_id == valorRecuperacao select evt.tpc_id; foreach (int tpc_id in x.ToList()) { if (string.IsNullOrEmpty(listaTpcIdRecuperacao)) { listaTpcIdRecuperacao += Convert.ToString(tpc_id); } else { listaTpcIdRecuperacao += "," + Convert.ToString(tpc_id); } } } // verifica se existe evento do tipo efetivação final bool existeFinal = false; IEnumerable <ACA_Evento> dadoFinal = (from ACA_Evento item in listEvento where item.tev_id == valorFinal select item); List <ACA_Evento> ltFinal = dadoFinal.ToList(); // se existir, marca para trazer as avaliações do tipo final if (ltFinal.Count > 0) { existeFinal = true; } // verifica se existe evento do tipo recuperação final bool existeRecuperacaoFinal = false; IEnumerable <ACA_Evento> dadoRecuperacaoFinal = (from ACA_Evento item in listEvento where item.tev_id == valorRecuperacaoFinal select item); List <ACA_Evento> ltRecuperacaoFinal = dadoRecuperacaoFinal.ToList(); // se existir, marca para trazer as avaliações do tipo recuperação final if (ltRecuperacaoFinal.Count > 0) { existeRecuperacaoFinal = true; } DataTable dtAvaliacoes; // Se for turma eletiva do aluno, carrega apenas os períodos do calendário em que // a turma é oferecida if ((TUR_TurmaTipo)tur.tur_tipo == TUR_TurmaTipo.EletivaAluno) { List <CadastroTurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectCadastradosBy_Turma(_VS_tur_id); dtAvaliacoes = ACA_AvaliacaoBO.ConsultaPor_Periodo_Efetivacao_TurmaDisciplinaCalendario(_VS_tur_id, listaDisciplinas[0].entTurmaDisciplina.tud_id, _VS_fav_id, listaTpcIdPeriodicaPeriodicaFinal, listaTpcIdRecuperacao, existeFinal, false, true); } else { dtAvaliacoes = ACA_AvaliacaoBO.ConsultaPor_Periodo_Efetivacao(_VS_tur_id, _VS_fav_id, 0, listaTpcIdPeriodicaPeriodicaFinal, listaTpcIdRecuperacao, existeFinal, existeRecuperacaoFinal, false, true, -1, ApplicationWEB.AppMinutosCacheLongo); } var avaliacoes = (from DataRow dr in dtAvaliacoes.Rows let fechado = Convert.ToBoolean(dr["ava_tpc_fechado"]) let cap_dataInicio = Convert.ToDateTime(string.IsNullOrEmpty(dr["cap_dataInicio"].ToString()) ? new DateTime().ToString() : dr["cap_dataInicio"]) where !(fechado && cap_dataInicio > DateTime.Now) select dr); dtAvaliacoes = avaliacoes.Any() ? avaliacoes.CopyToDataTable() : new DataTable(); if (dtAvaliacoes.Rows.Count == 0) { _lblMessage.Text = UtilBO.GetErroMessage("Turma fora do período de " + NomeModulo + ".", UtilBO.TipoMensagem.Alerta); } else if (dtAvaliacoes.Rows.Count == 1) { ACA_FormatoAvaliacao ent = new ACA_FormatoAvaliacao { fav_id = _VS_fav_id }; ACA_FormatoAvaliacaoBO.GetEntity(ent); _VS_ava_id = Convert.ToInt32(dtAvaliacoes.Rows[0]["ava_id"]); RedirecionaCadastro(); } else if (dtAvaliacoes.Rows.Count > 1) { // Carregar Avaliações. gvAvaliacoes.DataSource = dtAvaliacoes; gvAvaliacoes.DataBind(); ScriptManager.RegisterStartupScript(this, typeof(Page), "abreAvaliacoes", "$(document).ready(function(){$('#divAvaliacoes').dialog('open'); });", true); } } } 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 as avaliações.", UtilBO.TipoMensagem.Erro); } } }