コード例 #1
0
        /// <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();
            }
        }
コード例 #2
0
        /// <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);
        }
コード例 #3
0
        /// <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();
            }
        }
コード例 #4
0
        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();
            }
        }
コード例 #5
0
        /// <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(',', '.');
            //
        }
コード例 #6
0
        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);
            }
        }
コード例 #7
0
ファイル: Cadastro.aspx.cs プロジェクト: Mualumene/SGP
    /// <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;
    }
コード例 #8
0
        /// <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);
        }
コード例 #9
0
        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();
            }
        }
コード例 #10
0
        /// <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();
                }
            }
        }
コード例 #11
0
ファイル: Efetivacao.aspx.cs プロジェクト: Mualumene/SGP
        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);
            }
        }
コード例 #12
0
        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();
                }
            }
        }
コード例 #13
0
ファイル: Cadastro.aspx.cs プロジェクト: Mualumene/SGP
    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;
    }
コード例 #14
0
        /// <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;
            }
        }
コード例 #15
0
ファイル: Busca.aspx.cs プロジェクト: Mualumene/SGP
        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;
            }
        }
コード例 #16
0
        /// <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();
                }
            }
        }
コード例 #17
0
        /// <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;
                }
            }
            );
        }
コード例 #18
0
        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";
                }
            }
        }
コード例 #19
0
        /// <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);
        }
コード例 #20
0
        /// <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();
                }
            }
        }
コード例 #21
0
        /// <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);
        }
コード例 #22
0
        private void UCComboTurmaDisciplina_IndexChanged()
        {
            try
            {
                UCCPeriodoCalendario.Valor         = new[] { -1, -1 };
                UCCPeriodoCalendario.PermiteEditar = false;
                // utilizado para evitar chamar o evento de alteracao do calendario periodo duas vezes seguidas.
                bool selecionouComboPeriodos = false;

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

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

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

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

                    VS_FechamentoAutomatico = entFormatoAvaliacao.fav_fechamentoAutomatico;

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

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

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

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

                        VS_DisciplinaEspecial = entityTurmaDisciplina.tud_disciplinaEspecial;

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

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

                if (!selecionouComboPeriodos)
                {
                    UCCPeriodoCalendario_IndexChanged();
                }
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar os dados.", UtilBO.TipoMensagem.Erro);
            }
        }
コード例 #23
0
        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();
                }
            }
        }
コード例 #24
0
ファイル: Busca.aspx.cs プロジェクト: rafysanchez/SME-SGP
    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);
            }
        }
    }