public void ValidarMateria(ref DetConcepto ObjDetConcepto, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn =
                {
                    "p_id_ficha_detalle_concepto",
                    "p_id_materia"
                };
                object[] Valores =
                {
                    ObjDetConcepto.IdConcepto,
                    ObjDetConcepto.IdDetConcepto
                };
                string[] ParametrosOut =
                {
                    "p_Resultado"
                };

                Cmd = CDDatos.GenerarOracleCommand("val_materias", ParametrosIn, Valores, ParametrosOut);

                Verificador = Convert.ToString(Cmd.Parameters["p_Resultado"].Value);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 2
0
        public void Delete_Observaciones_edit(ref cuentas_contables Objinformativa, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "p_id" };
                object[] Valores       = { Objinformativa.id };
                string[] ParametrosOut = { "p_bandera" };

                Cmd = CDDatos.GenerarOracleCommand("DEL_SAF_INFORMATIVA", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 3
0
 public void Sel_tabulador(ref Pres_Costeo objcosteo, ref string Verificador)
 {
     CD_Datos CDDatos = new CD_Datos("DPP");
     OracleCommand Cmd = null;
     try
     {
         String[] Parametros = { "P_Ejercicio", "P_Tipo_personal" };
         object[] Valores = { objcosteo.Ejercicio, objcosteo.Tipo_personal };
         String[] ParametrosOut = { "P_PRIMA_VACACIONAL","P_AGUINALDO","P_AJUSTE_CALENDARIO","P_ISSSTE","P_FOVISSSTE","P_SAR","p_Bandera" };
         Cmd = CDDatos.GenerarOracleCommand("SEL_TABULADOR_PRES", ref Verificador, Parametros, Valores, ParametrosOut);
         if (Verificador == "0")
         {
             objcosteo = new Pres_Costeo();
             objcosteo.Prima_Vacacional = Convert.ToString(Cmd.Parameters["P_PRIMA_VACACIONAL"].Value);
             objcosteo.Aguinaldo = Convert.ToString(Cmd.Parameters["P_AGUINALDO"].Value);
             objcosteo.Ajuste_Calendario = Convert.ToString(Cmd.Parameters["P_AJUSTE_CALENDARIO"].Value);
             objcosteo.Issste = Convert.ToString(Cmd.Parameters["P_ISSSTE"].Value);
             objcosteo.Fovissste = Convert.ToString(Cmd.Parameters["P_FOVISSSTE"].Value);
             objcosteo.Sar = Convert.ToString(Cmd.Parameters["P_SAR"].Value);
         }
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
     finally
     {
         CDDatos.LimpiarOracleCommand(ref Cmd);
     }
 }
Esempio n. 4
0
        public void ObtenerDatosCogidoAdecuaciones(ref Adecuaciones objAdecuaciones, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_CODIGO" };
                object[] Valores       = { objAdecuaciones.Codigo_Programatico };
                string[] ParametrosOut = { "P_MES", "P_TIPO_OPE", "P_C_CONTAB", "P_ORIGEN", "P_DEPENDENCIA", "P_CENTRO_CONTABLE", "P_EJERCICIO", "p_bandera" };

                Cmd = CDDatos.GenerarOracleCommand("OBT_COD_PROG_ADECUACIONES", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objAdecuaciones                     = new Adecuaciones();
                    objAdecuaciones.Mes                 = Convert.ToString(Cmd.Parameters["P_MES"].Value);
                    objAdecuaciones.TipoOperacion       = Convert.ToString(Cmd.Parameters["P_TIPO_OPE"].Value);
                    objAdecuaciones.Centro_Contab       = Convert.ToString(Cmd.Parameters["P_C_CONTAB"].Value);
                    objAdecuaciones.Origen              = Convert.ToString(Cmd.Parameters["P_ORIGEN"].Value);
                    objAdecuaciones.Codigo_Programatico = Convert.ToString(Cmd.Parameters["P_CODIGO"].Value);
                    objAdecuaciones.Dependencia         = Convert.ToString(Cmd.Parameters["P_DEPENDENCIA"].Value);
                    objAdecuaciones.Centro_Contab       = Convert.ToString(Cmd.Parameters["P_CENTRO_CONTABLE"].Value);
                    objAdecuaciones.Ejercicio           = Convert.ToString(Cmd.Parameters["P_EJERCICIO"].Value);
                    objAdecuaciones.Destino             = "0";
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 5
0
        public void Consultar_Observaciones(ref cuentas_contables Objinformativa, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos("DPP");
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "p_ejercicio", "p_usuario" };
                object[] Valores       = { Objinformativa.ejercicio, Objinformativa.usuario };
                string[] ParametrosOut = { "p_observaciones", "p_bandera" };

                Cmd = CDDatos.GenerarOracleCommand("SEL_DPP_INFORMATIVA", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    Objinformativa = new cuentas_contables();
                    Objinformativa.observaciones = Convert.ToString(Cmd.Parameters["p_observaciones"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
        public void InsertarConceptoPago(ref string Verificador, ref List <ConceptoPago> List)
        {
            CD_Datos      CDDatos   = new CD_Datos();
            OracleCommand OracleCmd = null;

            try
            {
                string[] Parametros = { "p_ID",
                                        "p_ID_FICHA_BANCARIA",
                                        "p_ID_CONCEPTO",
                                        "p_IMPORTE",
                                        "p_ANEXO" };
                string[] ParametrosOut = { "p_BANDERA" };


                foreach (ConceptoPago ListRecorre in List)
                {
                    object[] Valores = { ListRecorre.Id,
                                         ListRecorre.IdFichaBancaria.ToString(),
                                         ListRecorre.IdConcepto,
                                         ListRecorre.ImporteConcepto,
                                         ListRecorre.Anexo };
                    OracleCmd = CDDatos.GenerarOracleCommand("INS_FICHA_DETALLE_CONCEPTOS", ref Verificador, Parametros, Valores, ParametrosOut);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref OracleCmd);
            }
        }
        public void ActualizaConceptoPago(ref string Verificador, ref ConceptoPago ObjConceptoPago)
        {
            CD_Datos      CDDatos   = new CD_Datos();
            OracleCommand OracleCmd = null;

            try
            {
                string[] Parametros = { "p_id_ficha_detalle_concepto",
                                        "p_label_materias",
                                        "p_importe" };
                string[] ParametrosOut = { "p_Bandera" };

                object[] Valores =
                {
                    ObjConceptoPago.IdConcepto,
                    ObjConceptoPago.Observaciones,
                    ObjConceptoPago.ImporteConcepto
                };
                OracleCmd = CDDatos.GenerarOracleCommand("UPD_FICHA_DETALLE_CONCEPTO", ref Verificador, Parametros, Valores, ParametrosOut);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally {
                CDDatos.LimpiarOracleCommand(ref OracleCmd);
            }
        }
Esempio n. 8
0
        public void ObtenerDatosCapitulo(ref Basicos objBasicos, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_ID" };
                object[] Valores       = { objBasicos.id };
                string[] ParametrosOut = { "P_CLAVE", "P_DESCRIPCION", "P_BANDERA" };

                Cmd = CDDatos.GenerarOracleCommand("OBT_SAF_BASICOS_CAP", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objBasicos             = new Basicos();
                    objBasicos.id          = Convert.ToString(Cmd.Parameters["P_ID"].Value);
                    objBasicos.clave       = Convert.ToString(Cmd.Parameters["P_CLAVE"].Value);
                    objBasicos.descripcion = Convert.ToString(Cmd.Parameters["P_DESCRIPCION"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
        public string Desencripta(string Palabra)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand cmm     = null;
            string        clave   = "0";

            try
            {
                string[] Parametros    = { "p_palabra", "p_tipo" };
                string[] ParametrosOut = { "p_encripta" };
                object[] Valores       = { Palabra, "D" };

                cmm   = CDDatos.GenerarOracleCommand("Gnr_Encripta", Parametros, Valores, ParametrosOut);
                clave = Convert.ToString(cmm.Parameters["p_encripta"].Value);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref cmm);
            }
            return(clave);
        }
        public void ObtenerServicio(ref MultiPago ObjMultipago, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_ID_SERVICIO" };
                object[] Valores       = { ObjMultipago.Id_Service };
                string[] ParametrosOut =
                {
                    "P_RUTA_RESP_OK", "P_BANDERA"
                };

                Cmd = CDDatos.GenerarOracleCommand("OBT_SERVICIO_EXTERNO", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                ObjMultipago.UrlResp = Convert.ToString(Cmd.Parameters["P_RUTA_RESP_OK"].Value);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 11
0
        public void ObtenerDatosProyecto(ref Proyectos objProyecto, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_EJERCICIO", "P_ID" };
                object[] Valores       = { objProyecto.Ejercicio, objProyecto.Id };
                string[] ParametrosOut = { "P_ID_TIPO_PROYECTO", "P_CLAVE", "P_DESCRIPCION", "P_BANDERA" };

                Cmd = CDDatos.GenerarOracleCommand("OBT_SAF_PRESUP_PROYECTOS", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objProyecto    = new Proyectos();
                    objProyecto.Id = Convert.ToString(Cmd.Parameters["P_ID"].Value);
                    objProyecto.Id_Tipo_Proyecto = Convert.ToString(Cmd.Parameters["P_ID_TIPO_PROYECTO"].Value);
                    objProyecto.Clave_Proy       = Convert.ToString(Cmd.Parameters["P_CLAVE"].Value);
                    objProyecto.Descrip          = Convert.ToString(Cmd.Parameters["P_DESCRIPCION"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 12
0
        public void ValidarToken(ref Usuario ObjUsuario, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos("siga");
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "p_token" };
                object[] Valores       = { ObjUsuario.Token };
                string[] ParametrosOut = { "p_usuario", "p_contrasena", "p_bandera" };

                Cmd = CDDatos.GenerarOracleCommand("SEL_SISTEMAS_TOKEN", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    ObjUsuario          = new Usuario();
                    ObjUsuario.CUsuario = Convert.ToString(Cmd.Parameters["p_usuario"].Value);
                    ObjUsuario.Password = Convert.ToString(Cmd.Parameters["p_contrasena"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 13
0
        public void ObtenerUsuario(ref Usuario ObjUsuario, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_CORREO", "P_ID_SISTEMA" };
                object[] Valores       = { ObjUsuario.Correo_UNACH, 15939 };
                string[] ParametrosOut = { "P_USUARIO", "P_TIPO_USU", "P_BANDERA" };

                Cmd = CDDatos.GenerarOracleCommand("VAL_USUARIO_PRESUPUESTO", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    ObjUsuario          = new Usuario();
                    ObjUsuario.TipoUsu  = Convert.ToString(Cmd.Parameters["P_TIPO_USU"].Value);
                    ObjUsuario.CUsuario = Convert.ToString(Cmd.Parameters["P_USUARIO"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 14
0
        public void Verificar_Correo_UNACH(ref Usuario objUsuario, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                String[] Parametros    = { "P_USUARIO" };
                Object[] Valores       = { objUsuario.CUsuario };
                String[] ParametrosOut = { "P_RESULTADO", "p_bandera" };
                Cmd = CDDatos.GenerarOracleCommand("OBT_STATUS_MAIL_TEL_USER", ref Verificador, Parametros, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objUsuario.Status = Convert.ToString(Cmd.Parameters["P_RESULTADO"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
        public void GenerarID(ref FichaReferenciada ObjFichaReferenciada)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { };
                object[] Valores       = { };
                string[] ParametrosOut =
                {
                    "p_Id"
                };

                Cmd = CDDatos.GenerarOracleCommand("GNR_ID_FICHA_BANCARIA", ParametrosIn, Valores, ParametrosOut);

                ObjFichaReferenciada.IdFichaBancaria = Convert.ToInt32(Cmd.Parameters["p_Id"].Value);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 16
0
        public void ObtenerDatosCContab(ref CentrosContab objCContab, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_ID", "P_EJERCICIO" };
                object[] Valores       = { objCContab.Id, objCContab.Ejercicio };
                string[] ParametrosOut = { "P_CLAVE", "P_DESCRIPCION", "P_DIRECTOR", "P_ADMINISTRADOR", "P_SALIENTE", "P_ENTRANTE", "P_BANDERA" };

                Cmd = CDDatos.GenerarOracleCommand("OBT_CAT_C_CONTAB", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objCContab               = new CentrosContab();
                    objCContab.Id            = Convert.ToString(Cmd.Parameters["P_ID"].Value);
                    objCContab.C_Contab      = Convert.ToString(Cmd.Parameters["P_CLAVE"].Value);
                    objCContab.Descrip       = Convert.ToString(Cmd.Parameters["P_DESCRIPCION"].Value);
                    objCContab.Director      = Convert.ToString(Cmd.Parameters["P_DIRECTOR"].Value);
                    objCContab.Administrador = Convert.ToString(Cmd.Parameters["P_ADMINISTRADOR"].Value);
                    objCContab.Saliente      = Convert.ToString(Cmd.Parameters["P_SALIENTE"].Value);
                    objCContab.Entrante      = Convert.ToString(Cmd.Parameters["P_ENTRANTE"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 17
0
        public void ObtenerDatosFuenteFin(ref FuentesFin objFuenteFin, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_ID", "P_EJERCICIO" };
                object[] Valores       = { objFuenteFin.Id, objFuenteFin.Ejercicio };
                string[] ParametrosOut = { "P_FUENTE", "P_DESCRIPCION", "P_DESCRIPCION_FUENTE", "P_ID_FUENTE", "P_BANDERA" };

                Cmd = CDDatos.GenerarOracleCommand("OBT_SAF_FUENTES", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objFuenteFin                      = new FuentesFin();
                    objFuenteFin.Fuente               = Convert.ToString(Cmd.Parameters["P_FUENTE"].Value);
                    objFuenteFin.Descrip              = Convert.ToString(Cmd.Parameters["P_DESCRIPCION"].Value);
                    objFuenteFin.Id                   = Convert.ToString(Cmd.Parameters["P_ID"].Value);
                    objFuenteFin.Ejercicio            = Convert.ToString(Cmd.Parameters["P_EJERCICIO"].Value);
                    objFuenteFin.IdFuenteFin          = Convert.ToString(Cmd.Parameters["P_ID_FUENTE"].Value);
                    objFuenteFin.DescripcionFuenteFin = Convert.ToString(Cmd.Parameters["P_DESCRIPCION_FUENTE"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 18
0
        public void ObtenerConsecutivoTipoOperacion(ref PresupUnv objPresupUnv, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_TIPO_OPE", "P_EJERCICIO" };
                object[] Valores       = { objPresupUnv.TipoOper, objPresupUnv.Ejercicio };
                string[] ParametrosOut = { "P_ID", "p_bandera" };

                Cmd = CDDatos.GenerarOracleCommand("OBT_ULTIMO_CONSECUTIVO", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objPresupUnv    = new PresupUnv();
                    objPresupUnv.Id = Convert.ToInt32(Cmd.Parameters["P_ID"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
        public void EliminarConceptoPago(ref string Verificador, ref ConceptoPago ObjConcepto)
        {
            CD_Datos      CDDatos   = new CD_Datos();
            OracleCommand OracleCmd = null;

            try
            {
                string[] Parametros =
                {
                    "p_id_ficha_detalle_concepto"
                };
                string[] ParametrosOut = { "p_BANDERA" };

                object[] Valores =
                {
                    ObjConcepto.Id
                };


                OracleCmd = CDDatos.GenerarOracleCommand("DEL_FICHA_DETALLE_CONCEPTO_CAS", ref Verificador, Parametros, Valores, ParametrosOut);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally {
                CDDatos.LimpiarOracleCommand(ref OracleCmd);
            }
        }
Esempio n. 20
0
        public void Insertar_PresupUnv(ref PresupUnv objPresup, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                String[] Parametros = { "P_TIPOPRES",   "P_DEPENDORIG", "P_DEP_ORIGEN", "P_REF_DOCTO",     "P_FECHA_DOC", "P_CONCEPTO", "P_AUTORIZADO", "P_MES", "P_TIPOOPER", "P_C_CONTAB", "P_DEPEND",
                                        "P_CODIGO_PRO", "P_FECHA_OPER", "P_ESTAT_REG",  "P_FECHA_CAPTURA", "P_FECHA_APL", "P_STAT_CONTAB" };
                object[] Valores = { objPresup.TipoPres, objPresup.DependOrig, objPresup.Dep_Origen, objPresup.Ref_Docto, objPresup.Fecha_Doc,        objPresup.Concepto,   objPresup.Autorizado,
                                     objPresup.Mes,      objPresup.TipoOper,   objPresup.C_Contab,   objPresup.Depend,    objPresup.Cod_Programatico, objPresup.Fecha_Oper, objPresup.Estat_Reg, objPresup.Fecha_Captura,objPresup.Fecha_Aplicacion,
                                     objPresup.Stat_Contab };
                String[] ParametrosOut = { "p_Bandera" };

                Cmd = CDDatos.GenerarOracleCommand("INS_REG_PRESUP", ref Verificador, Parametros, Valores, ParametrosOut);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 21
0
        public void Consultarcuenta(ref cuentas_contables Objcuentas_contables, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "p_id" };
                object[] Valores       = { Objcuentas_contables.id };
                string[] ParametrosOut = { "P_CENTRO_CONTABLE", "P_CUENTA", "P_DESCRIPCION", "P_TIPO", "P_CLASIFICACION", "P_NIVEL", "P_STATUS", "P_ID_CUENTA_MAYOR", "p_bandera" };

                Cmd = CDDatos.GenerarOracleCommand("SEL_SAF_CUENTAS_CONTABLES", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    Objcuentas_contables = new cuentas_contables();
                    Objcuentas_contables.centro_contable = Convert.ToString(Cmd.Parameters["P_CENTRO_CONTABLE"].Value);
                    Objcuentas_contables.cuenta_contable = Convert.ToString(Cmd.Parameters["p_cuenta"].Value);
                    Objcuentas_contables.descripcion     = Convert.ToString(Cmd.Parameters["p_descripcion"].Value);
                    Objcuentas_contables.tipo            = Convert.ToString(Cmd.Parameters["p_tipo"].Value);
                    Objcuentas_contables.clasificacion   = Convert.ToString(Cmd.Parameters["p_clasificacion"].Value);
                    Objcuentas_contables.nivel           = Convert.ToString(Cmd.Parameters["p_nivel"].Value);
                    Objcuentas_contables.status          = Convert.ToString(Cmd.Parameters["p_status"].Value);
                    Objcuentas_contables.cuenta_mayor    = Convert.ToString(Cmd.Parameters["p_id_cuenta_mayor"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 22
0
        public void Consulta_Basico(ref Basicos ObjBasicos, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "p_id" };
                object[] Valores       = { ObjBasicos.id };
                string[] ParametrosOut = { "P_TIPO", "P_CLAVE", "P_STATUS", "P_DESCRIPCION", "P_VALOR", "P_ORDEN", "p_bandera" };

                Cmd = CDDatos.GenerarOracleCommand("SEL_SAF_BASICOS", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    ObjBasicos             = new Basicos();
                    ObjBasicos.tipo        = Convert.ToString(Cmd.Parameters["P_tipo"].Value);
                    ObjBasicos.clave       = Convert.ToString(Cmd.Parameters["p_clave"].Value);
                    ObjBasicos.status      = Convert.ToString(Cmd.Parameters["p_status"].Value);
                    ObjBasicos.descripcion = Convert.ToString(Cmd.Parameters["p_descripcion"].Value);
                    ObjBasicos.valor       = Convert.ToString(Cmd.Parameters["p_valor"].Value);
                    ObjBasicos.orden       = Convert.ToString(Cmd.Parameters["p_orden"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
        public void ObtDisponibleCodigoProg(Pres_Documento_Detalle objDocDet, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                CDDatos.StartTrans();
                String[] Parametros = { "P_ID_CODIGO_PROG",
                                        "P_MES",
                                        "P_SUPERTIPO",
                                        "P_TIPO",
                                        "P_EJERCICIO" };
                object[] Valores = { objDocDet.Id_Codigo_Prog,
                                     objDocDet.Mes_inicial,
                                     objDocDet.SuperTipo,
                                     objDocDet.Tipo,
                                     objDocDet.Ejercicios };
                String[] ParametrosOut = { "P_DISPONIBLE", "P_BANDERA" };
                Cmd = CDDatos.GenerarOracleCommand("OBT_DISPONIBLE_CODIGO_PROG", ref Verificador, Parametros, Valores, ParametrosOut);
                objDocDet.Importe_disponible = Convert.ToDouble(Cmd.Parameters["P_DISPONIBLE"].Value);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 24
0
        public void ObtenerDatosCodProg(string Id, ref Cat_Ctrl_Presp_Saf objPresupUnv, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_ID" };
                object[] Valores       = { Id };
                string[] ParametrosOut = { "P_CENTRO_CONTABLE", "P_PROGRAMA", "P_SUBPROGRAMA", "P_DEPENDENCIA", "P_PROYECTO", "P_STATUS", "P_BANDERA" };

                cmd = CDDatos.GenerarOracleCommand("OBT_DESC_CAT_ESTRUCT", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objPresupUnv = new Cat_Ctrl_Presp_Saf();
                    objPresupUnv.Centro_Contable = Convert.ToString(cmd.Parameters["P_CENTRO_CONTABLE"].Value);
                    objPresupUnv.Programa        = Convert.ToString(cmd.Parameters["P_PROGRAMA"].Value);
                    objPresupUnv.SubPrograma     = Convert.ToString(cmd.Parameters["P_SUBPROGRAMA"].Value);
                    objPresupUnv.Dependencia     = Convert.ToString(cmd.Parameters["P_DEPENDENCIA"].Value);
                    objPresupUnv.Proyecto        = Convert.ToString(cmd.Parameters["P_PROYECTO"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref cmd);
            }
        }
Esempio n. 25
0
        public void Consultar_Observaciones_edit(ref cuentas_contables Objinformativa, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "p_id" };
                object[] Valores       = { Objinformativa.id };
                string[] ParametrosOut = { "p_centro_contable", "p_observaciones", "p_fecha_inicial", "p_fecha_final", "p_status", "p_bandera" };

                Cmd = CDDatos.GenerarOracleCommand("SEL_SAF_EDIT_informativa", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    Objinformativa    = new cuentas_contables();
                    Objinformativa.id = Convert.ToString(Cmd.Parameters["p_id"].Value);
                    Objinformativa.centro_contable = Convert.ToString(Cmd.Parameters["p_centro_contable"].Value);
                    Objinformativa.observaciones   = Convert.ToString(Cmd.Parameters["p_observaciones"].Value);
                    Objinformativa.fecha_inicial   = Convert.ToString(Cmd.Parameters["p_fecha_inicial"].Value);
                    Objinformativa.fecha_final     = Convert.ToString(Cmd.Parameters["p_fecha_final"].Value);
                    Objinformativa.status          = Convert.ToString(Cmd.Parameters["p_status"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 26
0
        public void ObtenerDatosPartida(ref Partidas objPartidas, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_ID", "P_EJERCICIO" };
                object[] Valores       = { objPartidas.Id, objPartidas.Ejercicio };
                string[] ParametrosOut = { "P_CLAVE", "P_CONCEPTO", "P_DESCRIPCION", "P_BANDERA" };

                Cmd = CDDatos.GenerarOracleCommand("OBT_SAF_PRESUP_PARTIDAS", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objPartidas           = new Partidas();
                    objPartidas.Id        = Convert.ToString(Cmd.Parameters["P_ID"].Value);
                    objPartidas.Clave     = Convert.ToString(Cmd.Parameters["P_CLAVE"].Value);
                    objPartidas.Concepto  = Convert.ToString(Cmd.Parameters["P_CONCEPTO"].Value);
                    objPartidas.Descrip   = Convert.ToString(Cmd.Parameters["P_DESCRIPCION"].Value);
                    objPartidas.Ejercicio = Convert.ToString(Cmd.Parameters["P_EJERCICIO"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 27
0
        public void AlumnoInsertar(Alumno ObjAlumno, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                String[] Parametros = { "p_matricula",  "p_dependencia", "p_nivel",
                                        "p_nombre",     "p_paterno",     "p_materno","p_carrera",
                                        "p_id_carrera", "p_semestre",    "p_grupo",  "p_usuario", "p_sexo",
                                        "p_email",      "p_status" };
                object[] Valores = { ObjAlumno.Matricula, ObjAlumno.Dependencia, ObjAlumno.Nivel,
                                     ObjAlumno.Nombre,    ObjAlumno.APaterno,    ObjAlumno.AMaterno,ObjAlumno.DescCarrera,
                                     ObjAlumno.Carrera,   ObjAlumno.Semestre,    ObjAlumno.Grupo,   ObjAlumno.UsuNombre, ObjAlumno.Genero,ObjAlumno.Correo, ObjAlumno.StatusMatricula };
                String[] ParametrosOut = { "p_Bandera", "p_matricula_generada" };
                Cmd = CDDatos.GenerarOracleCommand("INS_ALUMNO_POSGRADO_2016", ref Verificador, Parametros, Valores, ParametrosOut);

                ObjAlumno.Matricula = Convert.ToString(Cmd.Parameters["p_matricula_generada"].Value);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 28
0
        public void Obt_Datos_Terminal(ref Terminal Terminal, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_USUARIO" };
                object[] Valores       = { Terminal.Usuario.Login };
                string[] ParametrosOut = { "P_NOMBRE_CONV", "P_NUMERO_CONV", "P_BANDERA" };

                Cmd = CDDatos.GenerarOracleCommand("SEL_DATOS_TERMINAL", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    Terminal = new Terminal();
                    Terminal.Nombre_Convenio = Convert.ToString(Cmd.Parameters["P_NOMBRE_CONV"].Value);
                    Terminal.Numero_Convenio = Convert.ToString(Cmd.Parameters["P_NUMERO_CONV"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
Esempio n. 29
0
        public void ObtenerDatosPrograma(ref Programa objPrograma, ref string Verificador)
        {
            CD_Datos      CDDatos = new CD_Datos();
            OracleCommand Cmd     = null;

            try
            {
                string[] ParametrosIn  = { "P_ID" };
                object[] Valores       = { objPrograma.Id };
                string[] ParametrosOut = { "P_ID_FUNCION", "P_CLAVE", "P_DESCRIPCION", "P_BANDERA" };

                Cmd = CDDatos.GenerarOracleCommand("OBT_SAF_FUNCION_PROG", ref Verificador, ParametrosIn, Valores, ParametrosOut);
                if (Verificador == "0")
                {
                    objPrograma                = new Programa();
                    objPrograma.Id             = Convert.ToString(Cmd.Parameters["P_ID"].Value);
                    objPrograma.Id_FuncionProg = Convert.ToString(Cmd.Parameters["P_ID_FUNCION"].Value);
                    objPrograma.Clave          = Convert.ToString(Cmd.Parameters["P_CLAVE"].Value);
                    objPrograma.Descripcion    = Convert.ToString(Cmd.Parameters["P_DESCRIPCION"].Value);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref Cmd);
            }
        }
        public void EliminarDetConcepto(ref string Verificador, ref DetConcepto ObjDetConcepto)
        {
            CD_Datos      CDDatos   = new CD_Datos();
            OracleCommand OracleCmd = null;

            try
            {
                string[] Parametros =
                {
                    "p_id_ficha_detalle_concepto",
                    "p_id_materia",
                    "p_tipo_registro"
                };
                string[] ParametrosOut = { "p_BANDERA" };

                object[] Valores =
                {
                    ObjDetConcepto.IdConcepto,
                    ObjDetConcepto.IdDetConcepto,
                    ObjDetConcepto.TipoRegistro
                };


                OracleCmd = CDDatos.GenerarOracleCommand("DEL_FICHA_DETALLE_MATERIA_ARBL", ref Verificador, Parametros, Valores, ParametrosOut);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                CDDatos.LimpiarOracleCommand(ref OracleCmd);
            }
        }