Ejemplo n.º 1
0
        public async Task <IHttpActionResult> Postcuota(cuota cuota)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.cuota.Add(cuota);

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (cuotaExists(cuota.id))
                {
                    return(Conflict());
                }
                else
                {
                    throw;
                }
            }

            return(CreatedAtRoute("DefaultApi", new { id = cuota.id }, cuota));
        }
Ejemplo n.º 2
0
        //
        // GET: /Abono/Create

        public ActionResult Create(string id, string controlador, string fechaActual)
        {
            string idDecrypted = MiUtil.desEncriptar(id);
            int    intId       = Convert.ToInt32(idDecrypted);
            cuota  cuota       = db.cuota.Find(intId);

            ViewBag.cuotaId     = intId;
            ViewBag.CreditoId   = cuota.CreditoId;
            ViewBag.CreditoNro  = cuota.credito.CreditoNro;
            ViewBag.cuotaNumero = cuota.Numero;
            ViewBag.saldo       = cuota.calcularSaldoxCapital() + cuota.calcularSaldoxInteres();
            ViewBag.EmpresaId   = cuota.credito.EmpresaId;
            ViewBag.fechaActual = fechaActual;
            //ViewBag.CuotaId = new SelectList(db.Cuotas, "CuotaId", "CuotaId", cuotaId);

            abono a = new abono();

            a.CuotaId           = intId;
            a.cuota             = cuota;
            a.Valor             = ViewBag.saldo;
            a.Paga              = a.Valor;
            a.Fecha             = DateTime.Now;
            a.Estado            = true;
            ViewBag.controlador = controlador;
            return(View(a));
        }
Ejemplo n.º 3
0
        public async Task <IHttpActionResult> Putcuota(int id, cuota cuota)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != cuota.id)
            {
                return(BadRequest());
            }

            db.Entry(cuota).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!cuotaExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
Ejemplo n.º 4
0
        public ActionResult DeleteConfirmed(int id)
        {
            cuota cuota = db.cuotas.Find(id);

            db.cuotas.Remove(cuota);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Ejemplo n.º 5
0
        public async Task <IHttpActionResult> Getcuota(int id)
        {
            cuota cuota = await db.cuota.FindAsync(id);

            if (cuota == null)
            {
                return(NotFound());
            }

            return(Ok(cuota));
        }
Ejemplo n.º 6
0
 public ActionResult Edit([Bind(Include = "id,id_deuda,saldo_inicial,interes,monto_cuota,amortizacion,seguro_riesgo,recompra,Comision,saldo_final,depreciacion,ahorro_tributario,IGV,f_bruto,f_igv,f_neto,PeriodoGracia,Pagado,Fecha_De_Pago")] cuota cuota)
 {
     if (ModelState.IsValid)
     {
         db.Entry(cuota).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.id_deuda = new SelectList(db.Deudas, "id", "id", cuota.id_deuda);
     return(View(cuota));
 }
Ejemplo n.º 7
0
        public async Task <IHttpActionResult> Deletecuota(int id)
        {
            cuota cuota = await db.cuota.FindAsync(id);

            if (cuota == null)
            {
                return(NotFound());
            }

            db.cuota.Remove(cuota);
            await db.SaveChangesAsync();

            return(Ok(cuota));
        }
        public ActionResult Detalle_Cuota(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            cuota cuota = db.cuotas.Find(id);

            if (cuota == null)
            {
                return(HttpNotFound());
            }
            return(View(cuota));
        }
Ejemplo n.º 9
0
        // GET: cuotas/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            cuota cuota = db.cuotas.Find(id);

            if (cuota == null)
            {
                return(HttpNotFound());
            }
            ViewBag.id_deuda = new SelectList(db.Deudas, "id", "id", cuota.id_deuda);
            return(View(cuota));
        }
Ejemplo n.º 10
0
        //
        // GET: /Abono/Edit/5

        public ActionResult Edit(string id, string controlador)
        {
            string idDecrypted = MiUtil.desEncriptar(id);
            int    intId       = Convert.ToInt32(idDecrypted);

            ViewBag.controlador = controlador;
            abono abono = db.abono.Find(intId);
            cuota cuota = db.cuota.Find(abono.CuotaId);

            abono.cuota         = cuota;
            ViewBag.CuotaId     = cuota.CuotaId;
            ViewBag.idcuota     = cuota.CuotaId;
            ViewBag.cuotaNumero = cuota.Numero;
            ViewBag.CreditoId   = cuota.CreditoId;
            // ViewBag.CuotaId = new SelectList(db.Cuotas, "CuotaId", "CuotaId", abono.CuotaId);

            return(View(abono));
        }
Ejemplo n.º 11
0
        public ActionResult Edit(abono abono, string controlador)
        {
            ViewBag.controlador = controlador;
            if (ModelState.IsValid)
            {
                db.Entry(abono).State = EntityState.Modified;
                db.SaveChanges();
                return(RedirectToAction("Index", new { id = MiUtil.encriptar(abono.CuotaId.ToString()), controlador = controlador }));
            }
            cuota cuota = db.cuota.Find(abono.CuotaId);

            ViewBag.cuotaId     = cuota.CuotaId;
            ViewBag.cuotaNumero = cuota.Numero;
            ViewBag.CreditoId   = cuota.CreditoId;
            ViewBag.CuotaId     = abono.CuotaId;
            ViewBag.idcuota     = cuota.CuotaId;
            //  ViewBag.CuotaId = new SelectList(db.Cuotas, "CuotaId", "CuotaId", abono.CuotaId);

            return(View(abono));
        }
Ejemplo n.º 12
0
        public ViewResult Index(string id, string controlador, string fechaActual)
        {
            string idDecrypted = MiUtil.desEncriptar(id);
            int    intId       = Convert.ToInt32(idDecrypted);

            cuota cuota = db.cuota.Find(intId);

            ViewBag.CuotaId       = intId;
            ViewBag.CreditoId     = cuota.CreditoId;
            ViewBag.CreditoNro    = cuota.credito.CreditoNro;
            ViewBag.NombreCliente = cuota.credito.cliente.Nombre;
            ViewBag.fechaActual   = fechaActual;

            ViewBag.cuotaNumero = cuota.Numero;
            ViewBag.saldo       = cuota.calcularSaldoxCapital() + cuota.calcularSaldoxInteres();
            var abonos = db.abono.Include(a => a.cuota).Include(a => a.cuota.credito).Where(s => s.cuota.CreditoId == cuota.CreditoId).OrderByDescending(a => a.AbonoId);

            ViewBag.controlador = controlador;
            ViewBag.Cuota       = cuota;
            return(View(abonos.ToList()));
        }
Ejemplo n.º 13
0
        public ImpresionAbono impresionAbono(int abonoId)
        {
            ImpresionAbono ia    = null;
            abono          abono = (abono)db.abono.Find(abonoId);

            if (abono.Estado)
            {
                cuota   cuota   = (cuota)db.cuota.Find(abono.CuotaId);
                credito credito = (credito)db.credito.Find(cuota.CreditoId);
                empresa empresa = (empresa)db.empresa.Find(credito.cliente.EmpresaId);
                ia                   = new ImpresionAbono();
                ia.LogoEmpresa       = "~/Uploads/Logos/" + empresa.LogoUrl;
                ia.EmpresaId         = empresa.EmpresaId;
                ia.EmpresaNit        = empresa.Nit;
                ia.EmpresaNombre     = empresa.Nombre;
                ia.ClienteNit        = credito.cliente.Nit;
                ia.ClienteNombre     = credito.cliente.Nombre;
                ia.EmailCliente      = credito.cliente.Email;
                ia.CreditoId         = credito.CreditoId;
                ia.CreditoNro        = credito.CreditoNro;
                ia.CreditoValor      = credito.Valor;
                ia.CreditoCantCuotas = credito.cuota.Count;
                ia.CuotaNro          = cuota.Numero;
                ia.CuotaValor        = cuota.AbonoCapital + cuota.AbonoInteres + MiUtil.nullTodecimal(cuota.AjusteAbonoCapital) + MiUtil.nullTodecimal(cuota.AjusteAbonoInteres);
                ia.AbonoId           = abonoId;
                ia.AbonoNro          = abono.AbonoNro;
                ia.AbonoFecha        = abono.Fecha;
                ia.AbonoValor        = abono.Valor;
                decimal?porcenInteres = cuota.porcentajeInteres();
                decimal?porcenCapital = cuota.porcentajeCapital();
                ia.AbonoInteres        = ia.AbonoValor * (porcenInteres / 100);
                ia.AbonoCapital        = ia.AbonoValor * (porcenCapital / 100);
                ia.CreditoSaldoInteres = credito.calcularTotalInteres() - credito.calcularAbonoInteres(abono.Fecha);
                ia.CreditoSaldoCapital = credito.calcularTotalCapital() - credito.calcularAbonoCapital(abono.Fecha);
                ia.TotalAbono          = ia.AbonoCapital + ia.AbonoInteres;
                ia.SaldoCuota          = cuota.calcularSaldoxCapital(abono.Fecha) + cuota.calcularSaldoxInteres(abono.Fecha);
                //ia.CuotaValor - ia.TotalAbono;
            }
            return(ia);
        }
Ejemplo n.º 14
0
        public ActionResult Create(abono abono, string controlador, int EmpresaId, string fechaActual)
        {
            ViewBag.EmpresaId = EmpresaId;
            if (ModelState.IsValid)
            {
                if (abono.Paga > abono.Valor)
                {
                    abono.Devolucion = abono.Paga - abono.Valor;
                }
                else
                {
                    abono.Valor      = abono.Paga;
                    abono.Devolucion = 0;
                }
                consecutivo c = db.consecutivo.Find(EmpresaId);
                c.AbonoNro     = c.AbonoNro + 1;
                abono.AbonoNro = c.AbonoNro;

                db.abono.Add(abono);
                db.SaveChanges();
                // return RedirectToAction("EnviarCorreoFromAWS", new { abonoId = MiUtil.encriptar(abono.AbonoId.ToString()), abonoNro = abono.AbonoNro });
                //return RedirectToAction("Index", controlador, new { id = MiUtil.encriptar(abono.CuotaId.ToString()), controlador = controlador, fechaActual=fechaActual });
                return(RedirectToAction("Index", new { id = MiUtil.encriptar(abono.CuotaId.ToString()), controlador = controlador, fechaActual = fechaActual }));
            }
            ViewBag.CuotaId = abono.CuotaId;
            cuota cuota = db.cuota.Find(abono.CuotaId);

            abono.cuota = cuota;

            ViewBag.cuotaId     = abono.CuotaId;
            ViewBag.CreditoId   = cuota.CreditoId;
            ViewBag.CreditoNro  = cuota.credito.CreditoNro;
            ViewBag.cuotaNumero = cuota.Numero;
            ViewBag.saldo       = cuota.calcularSaldoxCapital() + cuota.calcularSaldoxInteres();
            ViewBag.controlador = controlador;
            //ViewBag.CuotaId = new SelectList(db.Cuotas, "CuotaId", "CuotaId", abono.CuotaId);
            return(View(abono));
        }
Ejemplo n.º 15
0
        List <cuota> Calcular_Cuotas(Deuda deuda)
        {
            Result       resultado = new Result();
            List <cuota> lista     = new List <cuota>();
            //Valores por defecto para la suma
            double Intereses = 0, Amortizacion = 0;
            double Total_seguro = 0, Total_comision = 0, Total_recompra = 0;
            double TEP       = 0;
            double exponente = deuda.frecuencia / deuda.dias_x_año;

            Intereses      = 0;
            Amortizacion   = 0;
            Total_seguro   = 0;
            Total_comision = 0;
            Total_recompra = 0;
            double TEA                      = deuda.TEA / 100;
            double Impuesto_renta           = deuda.i_renta / 100;
            double Recompra                 = deuda.recompra / 100;
            double Porcentaje_seguro_riesgo = deuda.seguro_riesgo / 100;
            double Ks   = deuda.tasa_ks / 100;
            double WACC = deuda.tasa_wacc / 100;

            //Precio de venta deuda.Bien.precio
            //Calcular Datos de Salida
            var precio = from c in db.Biens
                         where c.id == deuda.id_bien
                         select c;
            Bien   aux = precio.FirstOrDefault();
            double IGV = ((double)aux.precio / (1 + (deuda.IGV))) * (deuda.IGV);
            double VV  = (double)aux.precio - IGV;

            double Monto = VV + (double)(deuda.costo_notarial + deuda.costo_registral + deuda.tasacion + deuda.comision_de_estudio + deuda.comision_de_activacion);

            TEP = Math.Pow((1 + TEA), ((deuda.frecuencia * 1.0) / (deuda.dias_x_año * 1.0))) - 1;

            int    Nro_cuotas_por_año = deuda.dias_x_año / deuda.frecuencia;
            int    Total_cuotas       = Nro_cuotas_por_año * deuda.nro_años;
            double Seguro_riesgo      = Porcentaje_seguro_riesgo * (double)aux.precio / Nro_cuotas_por_año;


            double Inte, Comision_periodica;
            double SaldoI, cuota, Amort, recomp, SaldoF, depre = 0;
            double ahorroT, i_g_v, Flujo_B, Flujo_I, Flujo_N;

            List <double> Flujo_Bruto_Lista     = new List <double>();
            List <double> Flujo_Neto_Lista      = new List <double>();
            List <double> Flujo_Bruto_Lista_VAN = new List <double>();
            List <double> Flujo_Neto_Lista_VAN  = new List <double>();
            bool          PG;
            int           PG_Actual = 4;

            SaldoI             = Monto;
            Inte               = SaldoI * TEP;
            depre              = (VV / Total_cuotas);
            Flujo_B            = Monto;
            Flujo_I            = 0;
            Flujo_N            = Monto;
            Seguro_riesgo      = Seguro_riesgo * -1;
            Comision_periodica = (double)deuda.comision_periodica * -1;
            depre              = depre * -1;
            cuota              = 0.00;
            Flujo_Bruto_Lista.Add(Flujo_B);
            Flujo_Neto_Lista.Add(Flujo_N);
            switch (deuda.id_periodo_gracia)
            {
            case 2:    //Total
                PG_Actual = 2;
                break;

            case 3:    //Parcial
                PG_Actual = 3;
                break;

            case 4:
                PG_Actual = 4;
                break;

            default:
                break;
            }
            //Hacer las cuotas
            for (int i = 1; i <= Total_cuotas; i++)
            {
                cuota objCuota = new cuota();
                Inte = SaldoI * TEP;
                Inte = Inte * -1;
                if (i >= (deuda.PG_Tiempo + 1))
                {
                    PG_Actual = 4;
                }

                if (PG_Actual == 2 || PG_Actual == 3)
                {
                    PG = true;
                }
                else
                {
                    PG = false;
                }

                if (PG == true)
                {
                    Amort = 0;
                }
                else
                {
                    Amort = SaldoI / (Total_cuotas - i + 1);
                }
                Amort = Amort * -1;

                if (PG_Actual == 2)
                {
                    cuota = 0;
                }
                else
                {
                    if (PG_Actual == 3)
                    {
                        cuota = Inte;
                    }
                    else
                    {
                        cuota = Inte + Amort;
                    }
                }

                if (i == Total_cuotas)
                {
                    recomp = Recompra * VV;
                }
                else
                {
                    recomp = 0;
                }
                recomp *= -1;
                if (PG_Actual == 2)
                {
                    SaldoF = SaldoI - Inte;
                }
                else
                {
                    SaldoF = SaldoI + Amort;
                }

                ahorroT = (Inte + Seguro_riesgo + Comision_periodica + depre) * Impuesto_renta;
                i_g_v   = (cuota + Seguro_riesgo + Comision_periodica + recomp) * deuda.IGV;

                Flujo_B                    = cuota + Seguro_riesgo + Comision_periodica + recomp;
                Flujo_I                    = Flujo_B + i_g_v;
                Flujo_N                    = Flujo_B - ahorroT;
                Intereses                  = Intereses + Inte;
                Amortizacion               = Amortizacion + Amort;
                Total_seguro               = Total_seguro + Seguro_riesgo;
                Total_comision             = Total_comision + Comision_periodica;
                Total_recompra             = Total_recompra + recomp;
                objCuota.id_deuda          = deuda.id;
                objCuota.saldo_inicial     = (decimal)SaldoI;
                objCuota.interes           = (decimal)Inte;
                objCuota.monto_cuota       = (decimal)cuota;
                objCuota.amortizacion      = (decimal)Amort;
                objCuota.seguro_riesgo     = (decimal)Seguro_riesgo;
                objCuota.recompra          = (decimal)recomp;
                objCuota.Comision          = (decimal)Comision_periodica;
                objCuota.saldo_final       = (decimal)SaldoF;
                objCuota.depreciacion      = (decimal)depre;
                objCuota.ahorro_tributario = (decimal)ahorroT;
                objCuota.IGV               = (decimal)i_g_v;
                objCuota.f_bruto           = (decimal)Flujo_B;
                objCuota.f_igv             = (decimal)Flujo_I;
                objCuota.f_neto            = (decimal)Flujo_N;
                objCuota.PeriodoGracia     = PG;
                objCuota.Pagado            = false;
                objCuota.Fecha_De_Pago     = DateTime.Today.AddMonths(i);
                lista.Add(objCuota);
                SaldoI = SaldoF;

                Flujo_Bruto_Lista.Add(Flujo_B);
                Flujo_Neto_Lista.Add(Flujo_N);
                Flujo_Bruto_Lista_VAN.Add(Flujo_B);
                Flujo_Neto_Lista_VAN.Add(Flujo_N);
            }
            int index = (int)deuda.id_bien;

            resultado.Bien_id              = index;
            resultado.IGV                  = (decimal)IGV;
            resultado.ValorVenta           = (decimal)VV;
            resultado.MontoLeasing         = (decimal)Monto;
            resultado.Porcentaje_TEP       = TEP;
            resultado.Numero_Cuotas        = Nro_cuotas_por_año;
            resultado.Total_Cuotas         = Total_cuotas;
            resultado.Seguro_Riesgo        = (decimal)Seguro_riesgo;
            resultado.Intereses            = (decimal)Intereses;
            resultado.Amortizacion_Capital = (decimal)Amortizacion;
            resultado.Seguro_contra_riesgo = (decimal)Total_seguro;
            resultado.Comision_periodica   = (decimal)Total_comision;
            resultado.Recompra             = (decimal)Total_recompra;
            resultado.Desembolso_Total     = (decimal)(Intereses + Amortizacion + Total_seguro + Total_comision + Total_recompra);

            double tir_FB = Excel.FinancialFunctions.Financial.Irr(Flujo_Bruto_Lista, 1 / 100);

            tir_FB = 1 + tir_FB;
            double TCEA_FlujoB = Math.Pow(tir_FB, ((deuda.dias_x_año * 1.0) / (deuda.frecuencia * 1.0)));

            TCEA_FlujoB           = TCEA_FlujoB - 1;
            resultado.TCEA_FlujoB = TCEA_FlujoB * 100;

            double tir_FN = Excel.FinancialFunctions.Financial.Irr(Flujo_Neto_Lista, 1 / 100);

            tir_FN = 1 + tir_FN;
            double TCEA_FlujoN = Math.Pow(tir_FN, ((deuda.dias_x_año * 1.0) / (deuda.frecuencia * 1.0)));

            TCEA_FlujoN           = TCEA_FlujoN - 1;
            resultado.TCEA_FlujoN = TCEA_FlujoN * 100;

            double exp = ((deuda.frecuencia * 1.0) / (deuda.dias_x_año * 1.0));
            double n1  = Math.Pow((1 + Ks), exp);

            n1 = n1 - 1;
            double VAN_FlujoB = Excel.FinancialFunctions.Financial.Npv(n1, Flujo_Bruto_Lista_VAN);

            VAN_FlujoB           = VAN_FlujoB + Flujo_Bruto_Lista[0];
            resultado.VAN_FlujoB = (decimal)VAN_FlujoB;

            double exp2 = ((deuda.frecuencia * 1.0) / (deuda.dias_x_año * 1.0));
            double n2   = Math.Pow((1 + WACC), exp2);

            n2 = n2 - 1;
            double VAN_FlujoN = Excel.FinancialFunctions.Financial.Npv(n2, Flujo_Neto_Lista_VAN);

            VAN_FlujoN           = VAN_FlujoN + Flujo_Neto_Lista[0];
            resultado.VAN_FlujoN = (decimal)VAN_FlujoN;



            db.Results.Add(resultado);
            db.SaveChanges();
            return(lista);
        }
Ejemplo n.º 16
0
        public async Task <ActionResult> Create(NotaVenta notaVenta, string list)
        {
            try
            {
                int i = db.NotaVentas.Count() + 1;
                notaVenta.notaVentaID = i;
                db.NotaVentas.Add(notaVenta);
                await db.SaveChangesAsync();

                System.Web.Script.Serialization.JavaScriptSerializer js = new System.Web.Script.Serialization.JavaScriptSerializer();
                List <DetalleVenta> nota = js.Deserialize <List <DetalleVenta> >(list);
                foreach (var item in nota)
                {
                    int nt = db.DetalleVentas.Count();
                    item.detalleVentaID = nt + 1;
                    item.notaVentaID    = i;
                    db.DetalleVentas.Add(item);
                    await db.SaveChangesAsync();
                }
                if (notaVenta.formapago.Value)
                {
                    double   totalc = notaVenta.total.Value - notaVenta.cuotainicial.Value;
                    double   monto  = totalc / notaVenta.cantidadcouta.Value;
                    int      p      = db.planPagoes.Count() + 1;
                    planPago pl     = new planPago
                    {
                        planPagoID  = p,
                        totalVenta  = Convert.ToInt32(totalc),
                        ncuotas     = notaVenta.cantidadcouta,
                        fecha       = notaVenta.fecha,
                        monto       = Convert.ToInt32(monto),
                        notaVentaID = i
                    };
                    db.planPagoes.Add(pl);
                    await db.SaveChangesAsync();

                    int total = pl.totalVenta.Value;
                    int mon   = pl.monto.Value;

                    for (int j = 0; j < notaVenta.cantidadcouta; j++)
                    {
                        int      co = db.cuotas.Count() + 1;
                        DateTime dt = notaVenta.fecha.Value;
                        cuota    c  = new cuota()
                        {
                            cuotasID   = co,
                            saldo      = total - mon,
                            haber      = mon,
                            debe       = 0,
                            fecha      = dt.AddDays(30),
                            planPagoID = p,
                            pagado     = 0
                        };

                        db.cuotas.Add(c);
                        await db.SaveChangesAsync();
                    }
                }

                mensaje.Clear();
                mensaje.Add(Util.mensaje(Util.OK, Util.OKMENSAJE));
                return(Json(mensaje));
            }
            catch (Exception ex)
            {
                mensaje.Clear();
                mensaje.Add(Util.mensaje(Util.ERROR, ex.Message));
                return(Json(mensaje));
            }
        }