示例#1
0
        /// <summary> Elimina una bonificación de intereses de una cuenta. </summary>
        /// <param name="tobjAhorrosaFuturoBonificacion"> Un objeto del tipo tblAhorrosaFuturo. </param>
        /// <returns> Un string que indica si se ejecuto o no el metodo. </returns>
        public String gmtdEliminarBonificacionInteres(tblAhorrosaFuturoBonificacion tobjAhorrosaFuturoBonificacion)
        {
            String strResultado;

            try
            {
                using (dbExequial2010DataContext cuenta = new dbExequial2010DataContext())
                {
                    tblAhorrosaFuturoBonificacion bon_old = cuenta.tblAhorrosaFuturoBonificacions.SingleOrDefault(p => p.intCodigoBonificacion == tobjAhorrosaFuturoBonificacion.intCodigoBonificacion);
                    bon_old.bitAnulado      = true;
                    bon_old.dtmFechaAnulado = DateTime.Now;
                    cuenta.tblLogdeActividades.InsertOnSubmit(tobjAhorrosaFuturoBonificacion.log);

                    tblAhorrosaFuturo cue_old = cuenta.tblAhorrosaFuturos.SingleOrDefault(p => p.strCuenta == tobjAhorrosaFuturoBonificacion.strCuenta);
                    cue_old.fltIntereses -= tobjAhorrosaFuturoBonificacion.fltValor;

                    cuenta.SubmitChanges();
                    strResultado = "Registro Eliminado";
                }
            }
            catch (Exception ex)
            {
                new dao().gmtdInsertarError(ex);
                strResultado = "- No se puede eliminar el registro.";
            }
            return(strResultado);
        }
        /// <summary>
        /// Crea un objeto del tipo aplicación de acuerdo a la información de los texbox.
        /// </summary>
        /// <returns> Un objeto del tipo aplicación. </returns>
        private tblAhorrosaFuturo crearObj()
        {
            tblAhorrosaFuturo ahorros = new tblAhorrosaFuturo();

            ahorros.bitAnulado        = false;
            ahorros.bitLiquidada      = false;
            ahorros.dtmAnulado        = Convert.ToDateTime("1900-01-01");
            ahorros.dtmFechaCuenta    = this.dtpFechaCuenta.Value;
            ahorros.dtmFechaLiquidada = Convert.ToDateTime("1900-01-01");
            ahorros.fltIntereses      = 0;
            ahorros.fltPremios        = 0;
            ahorros.fltValorCuota     = Convert.ToDouble(this.txtValor.Text);
            ahorros.intAno            = Convert.ToInt32(txtAño.Text);
            ahorros.intCuotas         = Convert.ToInt32(this.txtCuotas.Text);
            ahorros.intPagadas        = 0;
            ahorros.strCuenta         = this.txtCuenta.Text;
            ahorros.strFormulario     = this.Name;
            ahorros.strComputador     = Environment.MachineName;
            ahorros.strUsuario        = propiedades.strLogin;

            if (this.txtNomAhorrador.Text == "")
            {
                ahorros.strCedulaAho = null;
            }
            else
            {
                ahorros.strCedulaAho = this.txtCedulaAho.Text;
            }


            return(ahorros);
        }
示例#3
0
        /// <summary> Inserta una bonificación de ahorro a futuro. </summary>
        /// <param name="tobjAhorroaFuturoBonificacion"> Un objeto del tipo tblAhorrosaFuturoBonificacion. </param>
        /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
        public string gmtdInsertar(tblAhorrosaFuturoBonificacion tobjAhorroaFuturoBonificacion)
        {
            String strRetornar;

            try
            {
                using (dbExequial2010DataContext ahorros = new dbExequial2010DataContext())
                {
                    ahorros.tblAhorrosaFuturoBonificacions.InsertOnSubmit(tobjAhorroaFuturoBonificacion);
                    ahorros.tblLogdeActividades.InsertOnSubmit(tobjAhorroaFuturoBonificacion.log);
                    tblAhorrosaFuturo int_old = ahorros.tblAhorrosaFuturos.SingleOrDefault(p => p.strCuenta == tobjAhorroaFuturoBonificacion.strCuenta);
                    if (tobjAhorroaFuturoBonificacion.bitIntereses == true)
                    {
                        int_old.fltIntereses += tobjAhorroaFuturoBonificacion.fltValor;
                    }
                    else
                    {
                        int_old.fltPremios += tobjAhorroaFuturoBonificacion.fltValor;
                    }
                    ahorros.SubmitChanges();
                    strRetornar = "Registro Insertado";
                }
            }
            catch (Exception ex)
            {
                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="tobjAhorroaFuturo"> Un objeto del tipo ahorro a futuro. </param>
        /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
        public string gmtdInsertar(tblAhorrosaFuturo tobjAhorroaFuturo)
        {
            if (tobjAhorroaFuturo.fltValorCuota == 0)
            {
                return("- Debe de ingresar el valor de la cuota. ");
            }

            if (tobjAhorroaFuturo.intAno == 0)
            {
                return("- Debe de ingresar el año al que pertenece la cuenta. ");
            }

            if (tobjAhorroaFuturo.strCedulaAho == null)
            {
                return("- Debe de ingresar la cédula del ahorrador para la cuenta. ");
            }

            if (tobjAhorroaFuturo.strCuenta == null)
            {
                return("- Debe de ingresar el número de la cuenta. ");
            }

            if (tobjAhorroaFuturo.strCuenta.Length != 4)
            {
                return("- El número de la cuenta debe de ser de 4 digitos. ");
            }

            tobjAhorroaFuturo.bitAnulado = false;
            tobjAhorroaFuturo.dtmAnulado = Convert.ToDateTime("1900/01/01");

            tobjAhorroaFuturo.log = metodos.gmtdLog("Ingresa el ahorro a futuro.  " + tobjAhorroaFuturo.strCuenta, tobjAhorroaFuturo.strFormulario);

            DateTime dtmFechaCuota = tobjAhorroaFuturo.dtmFechaCuenta;

            tblAhorrosaFuturo aho = new daoAhorrosaFuturo().gmtdConsultar(tobjAhorroaFuturo.strCuenta);

            if (aho.strCuenta == null)
            {
                for (int a = 0; a < 12; a++)
                {
                    tblAhorrosaFuturoDetalle ahorroDetalle = new tblAhorrosaFuturoDetalle();
                    ahorroDetalle.bitPagada     = false;
                    ahorroDetalle.dtmFechaCuota = dtmFechaCuota;
                    ahorroDetalle.dtmFechaPago  = Convert.ToDateTime("1900/01/01");
                    ahorroDetalle.strCuenta     = tobjAhorroaFuturo.strCuenta;
                    tobjAhorroaFuturo.tblAhorrosaFuturoDetalles.Add(ahorroDetalle);

                    dtmFechaCuota = dtmFechaCuota.AddMonths(1);
                }

                return(new daoAhorrosaFuturo().gmtdInsertar(tobjAhorroaFuturo));
            }
            else
            {
                return("- Esta cuenta ya aparece registrada. ");
            }
        }
        /// <summary> Elimina una cuenta de ahorro a futuro. </summary>
        /// <param name="tobjAhorrosaFuturo"> Un objeto del tipo tblAhorrosaFuturo. </param>
        /// <returns> Un string que indica si se ejecuto o no el metodo. </returns>
        public String gmtdEliminar(tblAhorrosaFuturo tobjAhorrosaFuturo)
        {
            if (tobjAhorrosaFuturo.strCuenta == null || tobjAhorrosaFuturo.strCuenta == "")
            {
                return("Debe de ingresar el número de cuenta a eliminar. ");
            }

            tblAhorrosaFuturoDetalle ahorro = new daoAhorrosaFuturo().gmtdConsultarDeatlle(tobjAhorrosaFuturo.strCuenta);

            if (ahorro.strCuenta != null)
            {
                return("No se puede eliminar por que tiene al menos una cuota paga. ");
            }

            tobjAhorrosaFuturo.log = metodos.gmtdLog("Elimina el ahorro a futuro.  " + tobjAhorrosaFuturo.strCuenta, tobjAhorrosaFuturo.strFormulario);

            return(new daoAhorrosaFuturo().gmtdEliminar(tobjAhorrosaFuturo));
        }
        /// <summary> Inserta una cuenta de ahorro a futuro. </summary>
        /// <param name="tobjAhorroaFuturo"> Un objeto del tipo ahorro a futuro. </param>
        /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
        public string gmtdInsertar(tblAhorrosaFuturo tobjAhorroaFuturo)
        {
            String strRetornar;

            try
            {
                using (dbExequial2010DataContext ahorros = new dbExequial2010DataContext())
                {
                    ahorros.tblAhorrosaFuturos.InsertOnSubmit(tobjAhorroaFuturo);
                    ahorros.tblLogdeActividades.InsertOnSubmit(tobjAhorroaFuturo.log);
                    ahorros.SubmitChanges();
                    strRetornar = "Registro Insertado";
                }
            }
            catch (Exception ex)
            {
                new dao().gmtdInsertarError(ex);
                strRetornar = "- Ocurrió un error al insertar el registro.";
            }
            return(strRetornar);
        }
        /// <summary> Elimina una cuenta de ahorro a futuro. </summary>
        /// <param name="tobjAhorrosaFuturo"> Un objeto del tipo tblAhorrosaFuturo. </param>
        /// <returns> Un string que indica si se ejecuto o no el metodo. </returns>
        public String gmtdEliminar(tblAhorrosaFuturo tobjAhorrosaFuturo)
        {
            String strResultado;

            try
            {
                using (dbExequial2010DataContext cuenta = new dbExequial2010DataContext())
                {
                    tblAhorrosaFuturo cue_old = cuenta.tblAhorrosaFuturos.SingleOrDefault(p => p.strCuenta == tobjAhorrosaFuturo.strCuenta);
                    cue_old.bitAnulado = true;
                    cue_old.dtmAnulado = DateTime.Now;
                    cuenta.tblLogdeActividades.InsertOnSubmit(tobjAhorrosaFuturo.log);
                    cuenta.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 a futuro. </summary>
        /// <param name="tobjCuentaLiquidad"> Un objeto con el código de la cuenta a aliminar. </param>
        /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
        public string gmtdEliminarLiquidaciondeCuenta(LiquidacionAhorroaFuturo tobjCuentaLiquidad)
        {
            DateTime dtmFechaActual = new blConfiguracion().gmtdCapturarFechadelServidor();
            String   strResultado;
            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 a futuro
                        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 a futuro", 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 a futuro", 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 navideño", 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 navideño", 1, tobjCuentaLiquidad.strCedulaAho, strNombre + " " + strApellido, dtmFechaActual));
                            }
                            #endregion
                        }
                    }

                    using (dbExequial2010DataContext ahorro = new dbExequial2010DataContext())
                    {
                        tblAhorrosaFuturo aho_old = ahorro.tblAhorrosaFuturos.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> Elimina una cuenta de ahorro a futuro. </summary>
 /// <param name="tobjAhorrosaFuturo"> Un objeto del tipo tblAhorrosaFuturo. </param>
 /// <returns> Un string que indica si se ejecuto o no el metodo. </returns>
 public String gmtdEliminar(tblAhorrosaFuturo tobjAhorrosaFuturo)
 {
     return(new blAhorrosaFuturo().gmtdEliminar(tobjAhorrosaFuturo));
 }
 /// <summary> Inserta una cuenta de ahorro a futuro. </summary>
 /// <param name="tobjAhorroaFuturo"> Un objeto del tipo ahorro a futuro. </param>
 /// <returns> Un string que indica si se ejecuto o no la operación. </returns>
 public string gmtdInsertar(tblAhorrosaFuturo tobjAhorroaFuturo)
 {
     return(new blAhorrosaFuturo().gmtdInsertar(tobjAhorroaFuturo));
 }