/// <summary> Inserta un credito. </summary>
        /// <param name="tobjMunicipio"> Un objeto del tipo tblCredito. </param>
        /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
        public string gmtdInsertar(tblCredito tobjCredito)
        {
            String strRetornar;

            try
            {
                using (dbExequial2010DataContext recibosEgresos = new dbExequial2010DataContext())
                {
                    tblEgresosEgreso egresoEgreso = new tblEgresosEgreso();
                    egresoEgreso.decIva             = 0;
                    egresoEgreso.decRetencion       = 0;
                    egresoEgreso.decValorBruto      = tobjCredito.decMonto;
                    egresoEgreso.decValorIva        = 0;
                    egresoEgreso.decValorNeto       = tobjCredito.decMonto;
                    egresoEgreso.decValorRetencion  = 0;
                    egresoEgreso.strCodOtrosEgresos = "0001";
                    egresoEgreso.strDescripcion     = "Se le registro el crédito " + tobjCredito.intCodigoCre.ToString() + " Linea: " + tobjCredito.strNombreLinea;

                    tblEgreso egreso = new tblEgreso();
                    egreso.bitEgreso     = true;
                    egreso.decTotal      = tobjCredito.decMonto;
                    egreso.dtmFechaAnu   = Convert.ToDateTime("1/1/1900");
                    egreso.dtmFechaRec   = new daoUtilidadesConfiguracion().gmtdCapturarFechadelServidor();
                    egreso.strApellido   = tobjCredito.strApellido1Pre + " " + tobjCredito.strApellido2Pre;
                    egreso.strCedulaEgre = tobjCredito.strCedulaPre;
                    egreso.strFormulario = tobjCredito.strFormulario;
                    egreso.strLetras     = new blConfiguracion().montoenLetras(tobjCredito.decMonto.ToString());
                    egreso.strNombre     = tobjCredito.strNombrePre;
                    egreso.strMaquina    = tobjCredito.strComputador;
                    egreso.strUsuario    = tobjCredito.strUsuario;

                    List <tblEgresosEgreso> lstEgresosDetalle = new List <tblEgresosEgreso>();
                    lstEgresosDetalle.Add(egresoEgreso);

                    egreso.egresoEgreso = lstEgresosDetalle;
                    XmlDocument xml       = blRecibosEgresos.SerializeServicio(egreso);
                    string      strEgreso = new daoRecibosEgresos().gmtdInsertar(xml);
                    tobjCredito.intCodigoRec = Convert.ToInt32(strEgreso);
                }

                using (dbExequial2010DataContext tipo = new dbExequial2010DataContext())
                {
                    tipo.tblCreditos.InsertOnSubmit(tobjCredito);
                    tipo.tblLogdeActividades.InsertOnSubmit(tobjCredito.log);
                    tipo.SubmitChanges();
                }

                strRetornar = "Registro Insertado. Se registro el egreso # " + tobjCredito.intCodigoRec.ToString();
            }
            catch (Exception ex)
            {
                EventLog even = new EventLog();
                even.Source = "Exequial2010";
                even.WriteEntry(ex.Message, EventLogEntryType.Information);
                new dao().gmtdInsertarError(ex);
                strRetornar = "- Ocurrió un error al insertar el registro.";
            }
            return(strRetornar);
        }
        /// <summary> Inserta una cuenta de ahorro a futuro. </summary>
        /// <param name="tobjIngreso"> Un objeto del tipo ingreso. </param>
        /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
        public string gmtdInsertar(tblEgreso tobjEgreso)
        {
            if (tobjEgreso.egresoEgreso != null)
            {
                for (int a = 0; a < tobjEgreso.egresoEgreso.Count; a++)
                {
                    tobjEgreso.egresoEgreso[a].strCodigoPar = new blOtroEgreso().gmtdConsultar(tobjEgreso.egresoEgreso[a].strCodOtrosEgresos).strCodigoPar;
                }
            }

            if (tobjEgreso.egresoAbonoaPrestamo != null)
            {
                tobjEgreso.egresoAbonoaPrestamo.strCodigoPar = "0001";
            }

            if (tobjEgreso.egresoAhorroalaVista != null)
            {
                tobjEgreso.egresoAhorroalaVista.strCodigoPar = "0001";
            }

            if (tobjEgreso.egresoAhorroEstudiantil != null)
            {
                tobjEgreso.egresoAhorroEstudiantil.strCodigoPar = "0001";
            }

            if (tobjEgreso.egresoAhorroFijo != null)
            {
                tobjEgreso.egresoAhorroFijo.strCodigoPar = "0001";
            }

            if (tobjEgreso.egresoIntereses != null)
            {
                tobjEgreso.egresoIntereses.strCodigoPar = "0001";
            }

            XmlDocument xml = blRecibosEgresos.SerializeServicio(tobjEgreso);

            string Resultado = new daoRecibosEgresos().gmtdInsertar(xml);

            if (Resultado == "0")
            {
                return("- Ha ocurrido un error al ingresar el egreso.");
            }
            else
            {
                return(Resultado + "+Egreso ingresado.");
            }
        }
        static public XmlDocument SerializeServicio(tblEgreso objIngreso)
        {
            XmlSerializer ser = new XmlSerializer(typeof(tblEgreso));

            StringBuilder sb = new StringBuilder();

            StringWriter writer = new StringWriter(sb);

            ser.Serialize(writer, objIngreso);

            XmlDocument doc = new XmlDocument();

            doc.LoadXml(sb.ToString());

            writer.Close();

            return(doc);
        }
        /// <summary> Elimina un de credito de la base de datos. </summary>
        /// <param name="tobjMunicipio"> Un objeto del tipo credito. </param>
        /// <returns> Un string que indica si se ejecuto o no el metodo. </returns>
        public String gmtdEliminar(tblCredito tobjCredito)
        {
            String strResultado;

            try
            {
                using (dbExequial2010DataContext tipo = new dbExequial2010DataContext())
                {
                    tblCredito cre_old = tipo.tblCreditos.SingleOrDefault(p => p.intCodigoCre == tobjCredito.intCodigoCre);
                    cre_old.dtmFechaAnu = new daoUtilidadesConfiguracion().gmtdCapturarFechadelServidor();
                    cre_old.bitAnulado  = true;
                    tipo.tblLogdeActividades.InsertOnSubmit(tobjCredito.log);
                    tipo.SubmitChanges();
                }

                using (dbExequial2010DataContext recibosEgresos = new dbExequial2010DataContext())
                {
                    if (tobjCredito.intCodigoRec != 0)
                    {
                        tblEgreso egr = recibosEgresos.tblEgresos.SingleOrDefault(p => p.intCodigoEgr == tobjCredito.intCodigoRec);
                        egr.bitAnulado  = true;
                        egr.dtmFechaAnu = new daoUtilidadesConfiguracion().gmtdCapturarFechadelServidor();

                        recibosEgresos.tblLogdeActividades.InsertOnSubmit(metodos.gmtdLog("Elimino el egreso " + tobjCredito.intCodigoRec.ToString(), "FrmPrestamos"));

                        recibosEgresos.SubmitChanges();
                    }
                }

                strResultado = "Registro Eliminado";
            }
            catch (Exception ex)
            {
                new dao().gmtdInsertarError(ex);
                strResultado = "- No se puede eliminar el registro.";
            }
            return(strResultado);
        }
        /// <summary> Elimina la liquidación de una cuenta de ahorro navideño. </summary>
        /// <param name="tobjCuentaLiquidad"> Un objeto con el código de la cuenta a eliminar. </param>
        /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
        public string gmtdEliminarLiquidaciondeCuenta(LiquidacionAhorroNavideno tobjCuentaLiquidad)
        {
            String   strResultado;
            DateTime dtmFechaActual      = new blConfiguracion().gmtdCapturarFechadelServidor();
            decimal  decValorLiquidacion = 0;
            decimal  decValorMulta       = 0;
            string   strNombre           = "";
            string   strApellido         = "";

            try
            {
                using (TransactionScope ts = new TransactionScope())
                {
                    using (dbExequial2010DataContext reciboEgreso = new dbExequial2010DataContext())
                    {
                        tblEgreso egre_old = reciboEgreso.tblEgresos.SingleOrDefault(p => p.intCodigoEgr == tobjCuentaLiquidad.intCodigoEgr);
                        egre_old.bitAnulado  = true;
                        egre_old.dtmFechaAnu = dtmFechaActual;
                        decValorLiquidacion  = egre_old.decTotal;
                        strNombre            = egre_old.strNombre;
                        strApellido          = egre_old.strApellido;
                        reciboEgreso.tblLogdeActividades.InsertOnSubmit(metodos.gmtdLog("Elimino el egreso " + tobjCuentaLiquidad.intCodigoEgr.ToString(), "FrmAhorrosaFuturoLiquidacion"));
                        reciboEgreso.SubmitChanges();

                        #region Mvto ingreso x anular liquidación de ahorro navideño
                        List <cuentaValores>[] cuotasValores = new blCuentaPar().gmtdCalcularValores("0001", decValorLiquidacion);
                        List <cuentaValores>   cuentasDebito = cuotasValores[0];
                        for (int a = 0; a < cuentasDebito.Count; a++)
                        {
                            reciboEgreso.tblCuentasOperacionesContabilidads.InsertOnSubmit(new blRecibosIngresos().gmtdMvtoContableIngresos(cuentasDebito[a].decValor, 0, cuentasDebito[a].strCuenta, "Recibo de ingreso x Anular liquidación de ahorro navideño", 1, tobjCuentaLiquidad.strCedulaAho, strNombre + " " + strApellido, dtmFechaActual));
                        }
                        List <cuentaValores> cuentasCredito = cuotasValores[1];
                        for (int a = 0; a < cuentasCredito.Count; a++)
                        {
                            reciboEgreso.tblCuentasOperacionesContabilidads.InsertOnSubmit(new blRecibosIngresos().gmtdMvtoContableIngresos(cuentasCredito[a].decValor, 0, cuentasCredito[a].strCuenta, "Recibo de ingreso x Anular liquidación de ahorro navideño", 2, tobjCuentaLiquidad.strCedulaAho, strNombre + " " + strApellido, dtmFechaActual));
                        }
                        #endregion
                    }

                    if (tobjCuentaLiquidad.intCodigoIng > 0)
                    {
                        using (dbExequial2010DataContext reciboEgreso = new dbExequial2010DataContext())
                        {
                            tblIngreso ing_old = reciboEgreso.tblIngresos.SingleOrDefault(p => p.intCodigoIng == tobjCuentaLiquidad.intCodigoIng);
                            ing_old.bitAnulado  = true;
                            ing_old.dtmFechaAnu = dtmFechaActual;
                            decValorMulta       = ing_old.decTotalIng;
                            reciboEgreso.tblLogdeActividades.InsertOnSubmit(metodos.gmtdLog("Elimino el ingreso " + tobjCuentaLiquidad.intCodigoIng.ToString(), "FrmAhorrosaFuturoLiquidacion"));
                            reciboEgreso.SubmitChanges();

                            #region Mvto egreso x anular liquidación de ahorro navideño
                            List <cuentaValores>[] cuotasValores = new blCuentaPar().gmtdCalcularValores("0001", decValorMulta);
                            List <cuentaValores>   cuentasDebito = cuotasValores[0];
                            for (int a = 0; a < cuentasDebito.Count; a++)
                            {
                                reciboEgreso.tblCuentasOperacionesContabilidads.InsertOnSubmit(new blRecibosIngresos().gmtdMvtoContableIngresos(cuentasDebito[a].decValor, 0, cuentasDebito[a].strCuenta, "Recibo de egreso x Anular liquidación de ahorro a futuro", 2, tobjCuentaLiquidad.strCedulaAho, strNombre + " " + strApellido, dtmFechaActual));
                            }
                            List <cuentaValores> cuentasCredito = cuotasValores[1];
                            for (int a = 0; a < cuentasCredito.Count; a++)
                            {
                                reciboEgreso.tblCuentasOperacionesContabilidads.InsertOnSubmit(new blRecibosIngresos().gmtdMvtoContableIngresos(cuentasCredito[a].decValor, 0, cuentasCredito[a].strCuenta, "Recibo de egreso x Anular liquidación de ahorro a futuro", 1, tobjCuentaLiquidad.strCedulaAho, strNombre + " " + strApellido, dtmFechaActual));
                            }
                            #endregion
                        }
                    }

                    using (dbExequial2010DataContext ahorro = new dbExequial2010DataContext())
                    {
                        tblAhorrosNavideno aho_old = ahorro.tblAhorrosNavidenos.SingleOrDefault(p => p.strCuenta == tobjCuentaLiquidad.strCuenta);
                        aho_old.bitLiquidada      = false;
                        aho_old.dtmFechaLiquidada = Convert.ToDateTime("1900/01/01");
                        ahorro.tblLogdeActividades.InsertOnSubmit(tobjCuentaLiquidad.log);
                        ahorro.SubmitChanges();
                        strResultado = "Registro Anulado";
                    }

                    ts.Complete();
                }
            }
            catch (Exception ex)
            {
                new dao().gmtdInsertarError(ex);
                strResultado = "- Ocurrió un error al Actualizar el registro";
            }
            return(strResultado);
        }
        /// <summary> Registra la liquidación de una cuenta de ahorro navideño. </summary>
        /// <param name="tstrCuenta"> Cuenta de ahorro navideño a liquidar. </param>
        /// <returns> Un string que indica si se registro o no la liquidación. </returns>
        public string gmtdLiquidarAhorroNavideno(LiquidacionAhorroNavideno tobjLiquidacion, string pstrUsuario, string pstrMaquina)
        {
            String     strResultado;
            string     strIngreso = "";
            string     strEgreso  = "";
            DateTime   dtmFechaActual;
            tblEgreso  egreso  = new tblEgreso();
            tblIngreso ingreso = new tblIngreso();
            DataTable  dt      = new DataTable();
            tblEgresosAhorrosNavidenoLiquidacion egresoLiquidacionNavideno = new tblEgresosAhorrosNavidenoLiquidacion();

            try
            {
                egresoLiquidacionNavideno.strCuenta    = tobjLiquidacion.strCuenta;
                egresoLiquidacionNavideno.decDescuento = tobjLiquidacion.decDescuento;

                egreso.bitRetiroAhorroNavidenoLiquidacion = true;
                if (tobjLiquidacion.bitAplicarMulta)
                {
                    egresoLiquidacionNavideno.decValorLiquidacion = tobjLiquidacion.decTotalRecaudado;
                    egreso.decTotal = tobjLiquidacion.decTotalRecaudado;
                    egresoLiquidacionNavideno.decRecaudado = egreso.decTotal;
                    egresoLiquidacionNavideno.decIntereses = tobjLiquidacion.decIntereses;
                }
                else
                {
                    egresoLiquidacionNavideno.decValorLiquidacion = tobjLiquidacion.decTotalLiquidacion;
                    egreso.decTotal = tobjLiquidacion.decTotalLiquidacion;
                    egresoLiquidacionNavideno.decRecaudado = egreso.decTotal - tobjLiquidacion.decIntereses;
                    egresoLiquidacionNavideno.decIntereses = tobjLiquidacion.decIntereses;
                }
                egreso.dtmFechaAnu   = Convert.ToDateTime("1/1/1900");
                dtmFechaActual       = new daoUtilidadesConfiguracion().gmtdCapturarFechadelServidor();
                egreso.dtmFechaRec   = dtmFechaActual;
                egreso.strApellido   = "";
                egreso.strCedulaEgre = tobjLiquidacion.strCedulaAho;
                egreso.strFormulario = tobjLiquidacion.strFormulario;
                egreso.strLetras     = new blConfiguracion().montoenLetras(tobjLiquidacion.decTotalLiquidacion.ToString());
                egreso.strNombre     = tobjLiquidacion.strAhorrador;
                egreso.strMaquina    = pstrMaquina;
                egreso.strUsuario    = pstrUsuario;
                egreso.objAhorroNavidenoLiquidacion = egresoLiquidacionNavideno;

                if (egresoLiquidacionNavideno.decDescuento > 0)
                {
                    tblIngresosAhorrosNavidenosMulta ingresoNavidenoMulta = new tblIngresosAhorrosNavidenosMulta();
                    ingresoNavidenoMulta.decValorMulta = tobjLiquidacion.decDescuento;
                    ingresoNavidenoMulta.strCuenta     = tobjLiquidacion.strCuenta;

                    ingreso.bitAhorroNavidenoMulta = true;
                    ingreso.decTotalIng            = tobjLiquidacion.decDescuento;
                    ingreso.dtmFechaAnu            = Convert.ToDateTime("1/1/1900");
                    ingreso.dtmFechaRec            = dtmFechaActual;
                    ingreso.strCedulaIng           = tobjLiquidacion.strCedulaAho;
                    ingreso.strComputador          = tobjLiquidacion.strComputador;
                    ingreso.strFormulario          = "FrmAhorrosNavideñoLiquidacion";
                    ingreso.strLetras      = new blConfiguracion().montoenLetras(tobjLiquidacion.decDescuento.ToString());
                    ingreso.strNombreIng   = tobjLiquidacion.strAhorrador;
                    ingreso.strApellidoIng = "";
                    ingreso.strUsuario     = tobjLiquidacion.strUsuario;
                    ingreso.objIngresosAhorrosNavidenosMulta = ingresoNavidenoMulta;
                    egreso.objIngreso = ingreso;
                }

                XmlDocument xml = blRecibosEgresos.SerializeServicio(egreso);

                List <SqlParameter> lstParametros = new List <SqlParameter>();
                SqlParameter        objParameter  = new SqlParameter();
                objParameter.DbType        = DbType.Xml;
                objParameter.Direction     = ParameterDirection.Input;
                objParameter.ParameterName = "xmlEgreso";
                objParameter.Value         = xml.OuterXml;
                lstParametros.Add(objParameter);

                dt = new Utilidad().ejecutarSpConeccionDB(lstParametros, Sp.spEgresoInsertar);
            }
            catch (Exception ex)
            {
                new dao().gmtdInsertarError(ex);
                return("- Ocurrió un error al Actualizar el registro");
            }

            strEgreso  = dt.Rows[0]["intCodigoEgr"].ToString();
            strIngreso = dt.Rows[0]["intCodigoIng"].ToString();

            if (egresoLiquidacionNavideno.decDescuento > 0)
            {
                strResultado = "Se hace el registro de los siguientes recibos" + " \n " + strEgreso + " \n " + strIngreso;
            }
            else
            {
                strResultado = "Se hace el registro del siguiente egreso" + " \n " + strEgreso;
            }
            return(strResultado);
        }
Beispiel #7
0
        /// <summary> Consulta los datos de un determinado egreso. </summary>
        /// <param name="tintRecibo"> Código del egreso a consultar. </param>
        /// <returns> Retorna los datos del egreso. </returns>
        public tblEgreso gmtdConsultaEgreso(int tintRecibo)
        {
            using (dbExequial2010DataContext recibosEgresos = new dbExequial2010DataContext())
            {
                var query = from rec in recibosEgresos.tblEgresos
                            where rec.intCodigoEgr == tintRecibo
                            select rec;

                if (query.ToList().Count > 0)
                {
                    tblEgreso egreso = query.ToList()[0];

                    if (egreso.bitEgreso == true)
                    {
                        var queryEgreso = from rec in recibosEgresos.tblEgresosEgresos
                                          where rec.intCodigoEgr == tintRecibo
                                          select rec;
                        egreso.egresoEgreso = queryEgreso.ToList();
                    }

                    if (egreso.bitRetiro == true)
                    {
                        var queryRetiro = from rec in recibosEgresos.tblEgresosAhorros
                                          where rec.intCodigoEgr == tintRecibo
                                          select rec;
                        egreso.egresoAhorroalaVista = queryRetiro.ToList()[0];
                    }

                    if (egreso.bitRetiroAbonos == true)
                    {
                        var queryAbonoaPrestamo = from rec in recibosEgresos.tblEgresosPrestamosAbonos
                                                  where rec.intCodigoEgr == tintRecibo
                                                  select rec;
                        egreso.egresoAbonoaPrestamo = queryAbonoaPrestamo.ToList()[0];
                    }

                    if (egreso.bitRetiroAhorroEstudiante == true)
                    {
                        var queryRetiroEstudiantil = from rec in recibosEgresos.tblEgresosAhorrosEstudiantes
                                                     where rec.intCodigoEgr == tintRecibo
                                                     select rec;
                        egreso.egresoAhorroEstudiantil = queryRetiroEstudiantil.ToList()[0];
                    }

                    if (egreso.bitRetiroAhorroFijo == true)
                    {
                        var queryRetiroFijo = from rec in recibosEgresos.tblEgresosAhorrosFijos
                                              where rec.intCodigoEgr == tintRecibo
                                              select rec;
                        egreso.egresoAhorroFijo = queryRetiroFijo.ToList()[0];
                    }

                    if (egreso.bitRetiroIntereses == true)
                    {
                        var queryRetiroIntereses = from rec in recibosEgresos.tblEgresosIntereses
                                                   where rec.intCodigoEgr == tintRecibo
                                                   select rec;
                        egreso.egresoIntereses = queryRetiroIntereses.ToList()[0];
                    }

                    return(egreso);
                }
                else
                {
                    return(new tblEgreso());
                }
            }
        }
Beispiel #8
0
        /// <summary> Inserta una liquidacion de cdt. </summary>
        /// <param name="tobjAhorroaFuturo"> Un objeto del tipo tblAhorrosCdtsLiquidacion cdt. </param>
        /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
        public string gmtdInsertar(tblAhorrosCdtsLiquidacion tobjAhorroCdtLiquidacion)
        {
            string    strIngreso = "";
            string    strEgreso  = "";
            DateTime  dtmFechaActual;
            DataTable dt = new DataTable();
            tblEgresosAhorrosCdtLiquidacion egresoLiquidacionCdt = new tblEgresosAhorrosCdtLiquidacion();

            try
            {
                egresoLiquidacionCdt.decValorLiquidacion        = tobjAhorroCdtLiquidacion.decBrutoLiquidacion;
                egresoLiquidacionCdt.intNumeroCdt               = tobjAhorroCdtLiquidacion.intNumeroCdt;
                egresoLiquidacionCdt.decRetencionLiquidacionCdt = tobjAhorroCdtLiquidacion.decRetencionLiquidacionCdt;

                tblEgreso egreso = new tblEgreso();
                egreso.bitRetiroAhorroCdtLiquidacion = true;
                egreso.decTotal      = tobjAhorroCdtLiquidacion.decBrutoLiquidacion;
                egreso.dtmFechaAnu   = Convert.ToDateTime("1/1/1900");
                dtmFechaActual       = new daoUtilidadesConfiguracion().gmtdCapturarFechadelServidor();
                egreso.dtmFechaRec   = dtmFechaActual;
                egreso.strApellido   = tobjAhorroCdtLiquidacion.strApellidoAho;
                egreso.strCedulaEgre = tobjAhorroCdtLiquidacion.strCedulaAho;
                egreso.strFormulario = tobjAhorroCdtLiquidacion.strFormulario;
                egreso.strLetras     = new blConfiguracion().montoenLetras(tobjAhorroCdtLiquidacion.decBrutoLiquidacion.ToString());
                egreso.strNombre     = tobjAhorroCdtLiquidacion.strNombreAho;
                egreso.objEgresosAhorrosCdtLiquidacion = egresoLiquidacionCdt;

                if (egresoLiquidacionCdt.decRetencionLiquidacionCdt > 0)
                {
                    tblIngresosAhorrosCdtMulta ingresoCdtMulta = new tblIngresosAhorrosCdtMulta();
                    ingresoCdtMulta.decValorMulta    = tobjAhorroCdtLiquidacion.decRetencionLiquidacionCdt;
                    ingresoCdtMulta.intNumeroCdt     = tobjAhorroCdtLiquidacion.intNumeroCdt;
                    ingresoCdtMulta.strTipoOperacion = "Retención";

                    tblIngreso ingreso = new tblIngreso();
                    ingreso.bitAhorroCdtMulta          = true;
                    ingreso.decTotalIng                = tobjAhorroCdtLiquidacion.decRetencionLiquidacionCdt;
                    ingreso.dtmFechaAnu                = Convert.ToDateTime("1/1/1900");
                    ingreso.dtmFechaRec                = dtmFechaActual;
                    ingreso.strCedulaIng               = tobjAhorroCdtLiquidacion.strCedulaAho;
                    ingreso.strComputador              = "";
                    ingreso.strFormulario              = tobjAhorroCdtLiquidacion.strFormulario;;
                    ingreso.strLetras                  = new blConfiguracion().montoenLetras(tobjAhorroCdtLiquidacion.decRetencionLiquidacionCdt.ToString());
                    ingreso.strNombreIng               = tobjAhorroCdtLiquidacion.strNombreAho;
                    ingreso.strApellidoIng             = tobjAhorroCdtLiquidacion.strApellidoAho;
                    ingreso.strUsuario                 = "";
                    ingreso.objIngresosAhorrosCdtMulta = ingresoCdtMulta;
                    egreso.objIngreso                  = ingreso;
                }

                XmlDocument xml = blRecibosEgresos.SerializeServicio(egreso);

                List <SqlParameter> lstParametros = new List <SqlParameter>();
                SqlParameter        objParameter  = new SqlParameter();
                objParameter.DbType        = DbType.Xml;
                objParameter.Direction     = ParameterDirection.Input;
                objParameter.ParameterName = "xmlEgreso";
                objParameter.Value         = xml.OuterXml;
                lstParametros.Add(objParameter);

                dt = new Utilidad().ejecutarSpConeccionDB(lstParametros, Sp.spEgresoInsertar);
            }
            catch (Exception ex)
            {
                new dao().gmtdInsertarError(ex);
                return("- Ocurrió un error al insertar el registro.");
            }

            strEgreso  = dt.Rows[0]["intCodigoEgr"].ToString();
            strIngreso = dt.Rows[0]["intCodigoIng"].ToString();

            if (egresoLiquidacionCdt.decRetencionLiquidacionCdt > 0)
            {
                return("Se hace el registro de los siguientes recibos" + " \n " + strEgreso + " \n " + strIngreso);
            }
            else
            {
                return("Se hace el registro del siguiente egreso" + " \n " + strEgreso);
            }
        }
 /// <summary> Inserta una cuenta de ahorro a futuro. </summary>
 /// <param name="tobjIngreso"> Un objeto del tipo ingreso. </param>
 /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
 public string gmtdInsertar(tblEgreso tobjEgreso)
 {
     return(new blRecibosEgresos().gmtdInsertar(tobjEgreso));
 }