Пример #1
0
        /// <summary>
        /// Verifica se j� existe um tema com o mesmo nome.
        /// </summary>
        /// <param name="tep_id">ID do tema.</param>
        /// <param name="tep_nome">Nome do tema.</param>
        /// <returns></returns>
        public static bool VerificaExistePorNome(int tep_id, string tep_nome, TalkDBTransaction banco = null)
        {
            TalkDBTransaction bancoCore = banco == null ? new CFG_TemaPadraoDAO()._Banco.CopyThisInstance() : banco;

            if (banco == null || (!bancoCore.ConnectionIsOpen))
            {
                bancoCore.Open(IsolationLevel.ReadCommitted);
            }

            try
            {
                return(new CFG_TemaPadraoDAO {
                    _Banco = bancoCore
                }.VerificaExistePorNome(tep_id, tep_nome));
            }
            catch (Exception ex)
            {
                if (banco == null)
                {
                    bancoCore.Close(ex);
                }

                throw;
            }
            finally
            {
                if (banco == null && bancoCore.ConnectionIsOpen)
                {
                    bancoCore.Close();
                }
            }
        }
 public static void Save(List <ACA_TipoDisciplinaRelacionada> lstRelacionadas)
 {
     if (lstRelacionadas.Count > 0)
     {
         ACA_TipoDisciplinaRelacionadaDAO dao = new ACA_TipoDisciplinaRelacionadaDAO();
         TalkDBTransaction banco = dao._Banco.CopyThisInstance();
         banco.Open(IsolationLevel.ReadCommitted);
         try
         {
             dao.DeleteByTdsId(lstRelacionadas[0].tds_id);
             lstRelacionadas.ForEach(p => { if (p.Validate())
                                            {
                                                Save(p, banco);
                                            }
                                            else
                                            {
                                                throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(p));
                                            } });
         }
         catch (Exception err)
         {
             banco.Close(err);
             throw;
         }
         finally
         {
             banco.Close();
         }
     }
 }
Пример #3
0
        /// <summary>
        /// Verifica se o registro � utilizado em outras tabelas.
        /// </summary>
        /// <param name="tep_id">ID do tema padr�o.</param>
        /// <param name="tpl_id">ID do tema de cores.</param>
        /// <param name="banco"></param>
        /// <returns></returns>
        private static bool VerificaIntegridade(int tep_id, int tpl_id, TalkDBTransaction banco = null)
        {
            TalkDBTransaction bancoCore = banco == null ? new CFG_TemaPaletaDAO()._Banco.CopyThisInstance() : banco;

            if (banco == null || (!bancoCore.ConnectionIsOpen))
            {
                bancoCore.Open(IsolationLevel.ReadCommitted);
            }

            try
            {
                return(new CFG_TemaPaletaDAO {
                    _Banco = bancoCore
                }.VerificaIntegridade(tep_id, tpl_id));
            }
            catch (Exception ex)
            {
                if (banco == null)
                {
                    bancoCore.Close(ex);
                }

                throw;
            }
            finally
            {
                if (banco == null && bancoCore.ConnectionIsOpen)
                {
                    bancoCore.Close();
                }
            }
        }
Пример #4
0
        /// <summary>
        /// Salva as justificativas de pendencia em lote.
        /// </summary>
        /// <param name="dtFechamentoJustificativaPendencia">Tabela com os dados das justificativas.</param>
        /// <returns></returns>
        public static bool SalvarEmLote(List <CLS_FechamentoJustificativaPendencia> lstFechamentoJustificativaPendencia)
        {
            CLS_FechamentoJustificativaPendenciaDAO dao = new CLS_FechamentoJustificativaPendenciaDAO();
            TalkDBTransaction banco = dao._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);
            try
            {
                DataTable dtFechamentoJustificativaPendencia = CLS_FechamentoJustificativaPendencia.TipoTabela_FechamentoJustificativaPendencia();
                lstFechamentoJustificativaPendencia.ForEach(p =>
                {
                    DataRow drFechamentoJustificativaPendencia = dtFechamentoJustificativaPendencia.NewRow();
                    dtFechamentoJustificativaPendencia.Rows.Add(EntityToDataRow(p, drFechamentoJustificativaPendencia));
                });

                if (new CLS_FechamentoJustificativaPendenciaDAO {
                    _Banco = banco
                }.SalvarEmLote(dtFechamentoJustificativaPendencia)
                    // Se tiver registro de inserção na tabela, atualizo a lista de pendências no fechamento.
                    && lstFechamentoJustificativaPendencia.Any(p => p.fjp_id <= 0))
                {
                    CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
                        lstFechamentoJustificativaPendencia
                        .Select(p => new AlunoFechamentoPendencia
                    {
                        tud_id         = p.tud_id,
                        tpc_id         = p.tpc_id,
                        afp_frequencia = false,
                        afp_nota       = false,
                        afp_processado = 2
                    })
                        .ToList()
                        , banco);
                }

                // Limpa o cache.
                try
                {
                    if (lstFechamentoJustificativaPendencia.Count > 0 && HttpContext.Current != null)
                    {
                        lstFechamentoJustificativaPendencia.ForEach(p => GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.FECHAMENTO_JUSTIFICATIVA_PENDENCIA_MODEL_KEY, p.tud_id, p.cal_id, p.tpc_id)));
                    }
                }
                catch
                { }

                return(true);
            }
            catch (Exception err)
            {
                banco.Close(err);
                throw;
            }
            finally
            {
                banco.Close();
            }
        }
        public static bool SaveList(int esc_id, List <ESC_EscolaCalendarioPeriodo> listPeriodos)
        {
            ESC_EscolaDAO     daoEscola   = new ESC_EscolaDAO();
            TalkDBTransaction bancoGestao = daoEscola._Banco;

            bancoGestao.Open();
            daoEscola._Banco = bancoGestao;

            try
            {
                DataTable dtPeriodosEscola = SelectEscolaPeriodos(esc_id);

                foreach (ESC_EscolaCalendarioPeriodo escolaPeriodo in listPeriodos)
                {
                    bool existePeriodo = dtPeriodosEscola.Rows.Cast <DataRow>().Any(row => row["tpc_id"].ToString().Equals(escolaPeriodo.tpc_id.ToString()) && row["cal_id"].ToString().Equals(escolaPeriodo.cal_id.ToString()));

                    if (!existePeriodo)
                    {
                        escolaPeriodo.esc_id = esc_id;
                        Save(escolaPeriodo, bancoGestao);
                    }

                    RemoveCacheEscolaCalendarioPeriodo(escolaPeriodo.cal_id);
                }

                // Se exister no DataTable, mas não exister na Lista -> Exclui
                foreach (DataRow row in dtPeriodosEscola.Rows)
                {
                    ESC_EscolaCalendarioPeriodo escolaPeriodo = listPeriodos.Find(p => p.cal_id == Convert.ToInt32(row["cal_id"]) && p.tpc_id == Convert.ToInt32(row["tpc_id"]));
                    if (escolaPeriodo == null)
                    {
                        ESC_EscolaCalendarioPeriodo entityEscolaPeriodo = new ESC_EscolaCalendarioPeriodo
                        {
                            esc_id = esc_id,
                            cal_id = Convert.ToInt32(row["cal_id"].ToString()),
                            tpc_id = Convert.ToInt32(row["tpc_id"].ToString())
                        };

                        Delete(entityEscolaPeriodo, bancoGestao);
                    }
                }
            }
            catch (Exception ex)
            {
                bancoGestao.Close(ex);
                throw (ex);
            }
            finally
            {
                if (bancoGestao.ConnectionIsOpen)
                {
                    bancoGestao.Close();
                }
            }

            return(true);
        }
Пример #6
0
        public static void ApagarAgendaHorarios(int req_id, Guid ent_id)
        {
            DCL_AgendaRequisicaoDAO dao   = new DCL_AgendaRequisicaoDAO();
            TalkDBTransaction       banco = dao._Banco;

            try
            {
                DCL_AgendaRequisicao agendaRequisicao = new DCL_AgendaRequisicao()
                {
                    req_id = req_id
                    ,
                    ent_id = ent_id
                };

                DCL_AgendaRequisicaoBO.GetEntity(agendaRequisicao);

                agendaRequisicao.age_situacao      = 3;
                agendaRequisicao.age_dataAlteracao = DateTime.Now;

                DCL_AgendaRequisicaoBO.Save(agendaRequisicao, banco);


                DataTable dtAgenda = DCL_AgendaHorarioRequisicaoBO.BuscarBy_ent_id_req_id(ent_id, req_id);

                foreach (DataRow row in dtAgenda.Rows)
                {
                    DCL_AgendaHorarioRequisicao agendaHorarioRequisicao = new DCL_AgendaHorarioRequisicao()
                    {
                        ent_id = ent_id
                        ,
                        req_id = req_id
                        ,
                        agh_seq =
                            int.Parse(
                                row["agh_seq"].ToString())
                    };

                    DCL_AgendaHorarioRequisicaoBO.GetEntity(agendaHorarioRequisicao);

                    agendaHorarioRequisicao.agh_situacao      = 3;
                    agendaHorarioRequisicao.agh_dataAlteracao = DateTime.Now;

                    DCL_AgendaHorarioRequisicaoBO.Save(agendaHorarioRequisicao, banco);
                }

                banco.Close();
            }
            catch (Exception err)
            {
                banco.Close(err);
                throw err;
            }
        }
Пример #7
0
        public static bool Excluir(CLS_FechamentoJustificativaPendencia fechamentoJustificativaPendencia)
        {
            CLS_FechamentoJustificativaPendenciaDAO dao = new CLS_FechamentoJustificativaPendenciaDAO();
            TalkDBTransaction banco = dao._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);
            try
            {
                if (CLS_FechamentoJustificativaPendenciaBO.Delete(fechamentoJustificativaPendencia, banco))
                {
                    // Atualizo a lista de pendências no fechamento.
                    CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
                        new List <AlunoFechamentoPendencia> {
                        new AlunoFechamentoPendencia
                        {
                            tud_id         = fechamentoJustificativaPendencia.tud_id,
                            tpc_id         = fechamentoJustificativaPendencia.tpc_id,
                            afp_frequencia = false,
                            afp_nota       = false,
                            afp_processado = 2
                        }
                    }
                        , banco);
                }

                // Limpa o cache.
                try
                {
                    if (HttpContext.Current != null)
                    {
                        GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.FECHAMENTO_JUSTIFICATIVA_PENDENCIA_MODEL_KEY, fechamentoJustificativaPendencia.tud_id, fechamentoJustificativaPendencia.cal_id, fechamentoJustificativaPendencia.tpc_id));
                    }
                }
                catch
                { }

                return(true);
            }
            catch (Exception err)
            {
                banco.Close(err);
                throw;
            }
            finally
            {
                banco.Close();
            }
        }
Пример #8
0
        public static bool SaveOrdem
        (
            ACA_CurriculoObjetivo entityDescer
            , ACA_CurriculoObjetivo entitySubir
        )
        {
            ACA_CurriculoObjetivoDAO dao   = new ACA_CurriculoObjetivoDAO();
            TalkDBTransaction        banco = dao._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);

            try
            {
                if (entityDescer.Validate())
                {
                    Save(entityDescer, banco);
                }
                else
                {
                    throw new ValidationException(entityDescer.PropertiesErrorList[0].Message);
                }

                if (entitySubir.Validate())
                {
                    Save(entitySubir, banco);
                }
                else
                {
                    throw new ValidationException(entitySubir.PropertiesErrorList[0].Message);
                }

                return(true);
            }
            catch (Exception ex)
            {
                banco.Close(ex);
                throw;
            }
            finally
            {
                if (banco.ConnectionIsOpen)
                {
                    banco.Close();
                }
            }
        }
Пример #9
0
        /// <summary>
        /// Salva uma lista de turma horários da turma
        /// </summary>
        /// <param name="listaTurmaHorario"></param>
        /// <returns></returns>
        public static bool SalvarTurmaHorario(long tur_id, List <TUR_TurmaHorario> listaTurmaHorario, TalkDBTransaction _banco = null)
        {
            TalkDBTransaction banco = _banco == null ? new TUR_TurmaHorarioDAO()._Banco.CopyThisInstance() : _banco;

            if (_banco == null)
            {
                banco.Open(IsolationLevel.ReadCommitted);
            }

            try
            {
                List <TUR_TurmaDisciplina> lstTud = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, banco, GestaoEscolarUtilBO.MinutosCacheLongo);

                //Se há uma turma disciplina da turma que não está na lista de turma horário então não permite salvar
                if (lstTud.Where(t => t.tud_tipo != (byte)TurmaDisciplinaTipo.ComponenteRegencia).Any(t => !listaTurmaHorario.Any(th => th.tud_id == t.tud_id)))
                {
                    throw new ValidationException(CustomResource.GetGlobalResourceObject("BLL", "TUR_TurmaHorarioBO.SalvarTurmaHorario.ValidarTudsTurmaHorario"));
                }

                ValidarCarga(listaTurmaHorario, banco);

                listaTurmaHorario.Where(p => p.thr_id > 0 && p.tud_id <= 0)
                .Aggregate(true, (deletou, horario) => deletou & Delete(horario, banco));

                listaTurmaHorario.ForEach(p => p.IsNew = p.thr_id <= 0);

                listaTurmaHorario.Where(p => p.tud_id > 0)
                .Aggregate(true, (salvou, horario) => salvou & Save(horario, banco));

                return(true);
            }
            catch (Exception ex)
            {
                banco.Close(ex);
                throw;
            }
            finally
            {
                if (banco.ConnectionIsOpen)
                {
                    banco.Close();
                }
            }
        }
Пример #10
0
        public static bool Save
        (
            int crc_id
            , ACA_CurriculoSugestao entity
        )
        {
            ACA_CurriculoCapituloSugestaoDAO dao = new ACA_CurriculoCapituloSugestaoDAO();
            TalkDBTransaction banco = dao._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);

            try
            {
                bool novo = entity.IsNew;
                ACA_CurriculoSugestaoBO.Save(entity, banco);
                if (novo)
                {
                    Save(new ACA_CurriculoCapituloSugestao {
                        crc_id = crc_id, crs_id = entity.crs_id
                    }, banco);
                }
                return(true);
            }
            catch (Exception ex)
            {
                banco.Close(ex);
                throw;
            }
            finally
            {
                if (banco.ConnectionIsOpen)
                {
                    banco.Close();
                }
            }
        }
Пример #11
0
        /// <summary>
        /// Salva os registros recebidos pela API validando e encerrando os registros vigentes.
        /// </summary>
        /// <param name="listaTurmaHorario"></param>
        /// <param name="_banco"></param>
        /// <returns></returns>
        public static bool SalvarTurmaHorarioAPI(List <TUR_TurmaHorarioDTO> listaTurmaHorario, TalkDBTransaction _banco = null)
        {
            TalkDBTransaction banco = _banco == null ? new TUR_TurmaHorarioDAO()._Banco.CopyThisInstance() : _banco;

            if (_banco == null)
            {
                banco.Open(IsolationLevel.ReadCommitted);
            }

            try
            {
                if (!listaTurmaHorario.Any())
                {
                    return(false);
                }

                List <TUR_TurmaHorario> listaTurmaHorarioSalvar = new List <TUR_TurmaHorario>();
                foreach (TUR_TurmaHorarioDTO thr in listaTurmaHorario)
                {
                    TUR_TurmaHorario thrAdd = new TUR_TurmaHorario
                    {
                        trn_id             = thr.trn_id,
                        trh_id             = thr.trh_id,
                        tud_id             = thr.tud_id,
                        thr_vigenciaInicio = thr.thr_vigenciaInicio,
                        IsNew               = true,
                        thr_dataAlteracao   = DateTime.Now,
                        thr_dataCriacao     = DateTime.Now,
                        thr_situacao        = thr.thr_situacao,
                        thr_registroExterno = true
                    };

                    listaTurmaHorarioSalvar.Add(thrAdd);
                }

                ValidarCarga(listaTurmaHorarioSalvar, banco);

                string tud_ids = string.Join(";", listaTurmaHorarioSalvar.Where(p => p.tud_id > 0).GroupBy(p => p.tud_id).Select(p => p.Key.ToString()).ToArray());
                if (!string.IsNullOrEmpty(tud_ids))
                {
                    List <TUR_TurmaHorario> listaEncerrar = SelecionaPorTurmaDisciplinasVigentes(tud_ids, banco);

                    foreach (TUR_TurmaHorario thr in listaEncerrar)
                    {
                        thr.thr_vigenciaFim = listaTurmaHorarioSalvar.First().thr_vigenciaInicio.AddDays(-1);
                        thr.thr_situacao    = 4;//Inativo

                        Save(thr, banco);
                    }
                }

                if (!listaTurmaHorarioSalvar.Any(t => t.thr_situacao == 3) && listaTurmaHorarioSalvar.Any(t => !Save(t, banco)))
                {
                    throw new ValidationException("Erro ao salvar turma horário.");
                }

                return(true);
            }
            catch (Exception ex)
            {
                banco.Close(ex);
                throw;
            }
            finally
            {
                if (banco.ConnectionIsOpen)
                {
                    banco.Close();
                }
            }
        }
Пример #12
0
        public static void SalvarAgendaHorarios(DataTable _VS_Agenda, Guid ent_id, int req_id, DCL_AgendaRequisicao agendaRequisicao)
        {
            DCL_AgendaHorarioRequisicaoDAO dao = new DCL_AgendaHorarioRequisicaoDAO();
            TalkDBTransaction banco            = dao._Banco;

            try
            {
                DCL_AgendaRequisicaoBO.Save(agendaRequisicao, banco);

                for (int i = 0; i < _VS_Agenda.Rows.Count; i++)
                {
                    DCL_AgendaHorarioRequisicao agendaHorarioRequisicao = new DCL_AgendaHorarioRequisicao();

                    if (_VS_Agenda.Rows[i].RowState != DataRowState.Deleted)
                    {
                        if (int.Parse(_VS_Agenda.Rows[i]["agh_seq"].ToString()) < 1)
                        {
                            agendaHorarioRequisicao.IsNew             = true;
                            agendaHorarioRequisicao.agh_dataAlteracao = DateTime.Now;
                            agendaHorarioRequisicao.agh_dataCriacao   = DateTime.Now;
                            agendaHorarioRequisicao.agh_horarioFim    =
                                TimeSpan.Parse(_VS_Agenda.Rows[i]["agh_horarioFim"].ToString());
                            agendaHorarioRequisicao.agh_horarioInicio =
                                TimeSpan.Parse(_VS_Agenda.Rows[i]["agh_horarioInicio"].ToString());
                            agendaHorarioRequisicao.agh_intervalo =
                                Int32.Parse(_VS_Agenda.Rows[i]["agh_intervalo"].ToString());
                            agendaHorarioRequisicao.agh_seq      = 1;
                            agendaHorarioRequisicao.agh_situacao = 1;
                            agendaHorarioRequisicao.ent_id       = ent_id;
                            agendaHorarioRequisicao.req_id       = req_id;
                        }
                        else
                        {
                            agendaHorarioRequisicao.ent_id  = ent_id;
                            agendaHorarioRequisicao.agh_seq = int.Parse(_VS_Agenda.Rows[i]["agh_seq"].ToString());
                            agendaHorarioRequisicao.req_id  = req_id;

                            DCL_AgendaHorarioRequisicaoBO.GetEntity(agendaHorarioRequisicao);

                            agendaHorarioRequisicao.agh_horarioFim =
                                TimeSpan.Parse(_VS_Agenda.Rows[i]["agh_horarioFim"].ToString());
                            agendaHorarioRequisicao.agh_horarioInicio =
                                TimeSpan.Parse(_VS_Agenda.Rows[i]["agh_horarioInicio"].ToString());
                            agendaHorarioRequisicao.agh_intervalo =
                                Int32.Parse(_VS_Agenda.Rows[i]["agh_intervalo"].ToString());
                            agendaHorarioRequisicao.agh_dataAlteracao = DateTime.Now;
                            agendaHorarioRequisicao.IsNew             = false;
                        }
                    }
                    else
                    {
                        agendaHorarioRequisicao.ent_id  = ent_id;
                        agendaHorarioRequisicao.agh_seq =
                            int.Parse(_VS_Agenda.Rows[i]["agh_seq", DataRowVersion.Original].ToString());
                        agendaHorarioRequisicao.req_id = req_id;

                        DCL_AgendaHorarioRequisicaoBO.GetEntity(agendaHorarioRequisicao);

                        agendaHorarioRequisicao.agh_dataAlteracao = DateTime.Now;
                        agendaHorarioRequisicao.agh_situacao      = 3;
                        agendaHorarioRequisicao.IsNew             = false;
                    }

                    DCL_AgendaHorarioRequisicaoBO.Save(agendaHorarioRequisicao, banco);

                    banco.Close();
                }
            }
            catch (Exception err)
            {
                banco.Close(err);
                throw err;
            }
        }
Пример #13
0
        /// <summary>
        /// Colocar um protocolo executado com erro para reprocessar
        /// </summary>
        /// <param name="pro_id">Id do Protocolo</param>
        /// <param name="novoPacote">Novo pacote a ser processado</param>
        /// <param name="versao">Versão do aplicativo que enviou o protocolo</param>
        /// <returns></returns>
        public static bool Reprocessar(Guid pro_id, string novoPacote, string versao)
        {
            DCL_ProtocoloReprocessoDAO dao   = new DCL_ProtocoloReprocessoDAO();
            TalkDBTransaction          banco = dao._Banco;

            try
            {
                DCL_Protocolo protocolo = new DCL_Protocolo()
                {
                    pro_id = pro_id
                };
                DCL_ProtocoloReprocesso entity = null;

                DCL_ProtocoloBO.GetEntity(protocolo);

                if (protocolo.IsNew)
                {
                    throw new ProtocoloNãoEncontrado();
                }

                //Verifica se está com status de "Processado com Erro"
                if (protocolo.pro_status == (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErro)
                {
                    entity = new DCL_ProtocoloReprocesso()
                    {
                        pro_id              = protocolo.pro_id,
                        prp_pacote          = protocolo.pro_pacote,
                        prp_status          = protocolo.pro_status,
                        prp_statusObervacao = protocolo.pro_statusObservacao,
                        prp_situacao        = protocolo.pro_situacao,
                        prp_dataCriacao     = DateTime.Now,
                        prp_dataAlteracao   = DateTime.Now
                    };

                    if (!string.IsNullOrEmpty(versao))
                    {
                        protocolo.pro_versaoAplicativo = versao;
                    }

                    protocolo.pro_status           = 1;
                    protocolo.pro_statusObservacao = string.Empty;

                    if (!string.IsNullOrEmpty(novoPacote))
                    {
                        protocolo.pro_pacote = novoPacote;
                    }

                    banco.Open();

                    DCL_ProtocoloReprocessoBO.Save(entity, banco);
                    DCL_ProtocoloBO.Save(protocolo, banco);

                    return(true);
                }
                else
                {
                    throw new ReprocessarProtocoloSemErro();
                }
            }
            catch (Exception err)
            {
                banco.Close(err);
                throw;
            }
            finally
            {
                banco.Close();
            }
        }