Ejemplo n.º 1
0
        public void calcularSaldos(int p_, int m_, Proyecto p, CuentaCorriente c)
        {
            SAG2DB db           = new SAG2DB();
            int    saldoInicial = db.Saldo.Where(s => s.CuentaCorrienteID == c.ID && s.Mes == p_ && s.Periodo == p_).Single().SaldoInicialCartola;
            int    saldo        = saldoInicial;
            int    ig           = db.Movimiento.Where(m => m.Mes == m_ && m.ProyectoID == p.ID && m.Periodo == p_ && m.Nulo == null && m.Temporal == null && m.Eliminado == null).Sum(m => m.Monto_Ingresos);
            int    eg           = db.Movimiento.Where(m => m.Mes == m_ && m.ProyectoID == p.ID && m.Periodo == p_ && m.Nulo == null && m.Temporal == null && m.Eliminado == null).Sum(m => m.Monto_Egresos);
            Saldo  sa           = db.Saldo.Where(s => s.CuentaCorrienteID == c.ID && s.Mes == m_ && s.Periodo == p_).Single();

            sa.SaldoInicialCartola = saldo;
            saldo              = saldo + ig - eg;
            sa.SaldoFinal      = saldo;
            db.Entry(sa).State = EntityState.Modified;
            db.SaveChanges();
        }
Ejemplo n.º 2
0
        public bool fondoFijoDisponible()
        {
            SAG2DB db = new SAG2DB();

            try
            {
                int monto = db.FondoFijo.Where(f => f.EgresoID == null).Sum(f => f.Monto);
                if (monto > ctes.porcentajeFondoFijo * ctes.montoFondoFijo)
                {
                    return(false);
                }
                return(true);
            }
            catch (Exception)
            {
                return(true);
            }
        }
Ejemplo n.º 3
0
        public bool anularSaldoEgreso(Movimiento movimiento, ModelStateDictionary ModelState, int montoOrginal)
        {
            SAG2DB db    = new SAG2DB();
            Saldo  Saldo = null;

            try
            {
                Saldo                 = db.Saldo.Where(s => s.CuentaCorrienteID == movimiento.CuentaCorrienteID).Where(s => s.Periodo == movimiento.Periodo).Where(s => s.Mes == movimiento.Mes).Single();
                Saldo.SaldoFinal      = Saldo.SaldoFinal + montoOrginal;
                db.Entry(Saldo).State = EntityState.Modified;
                db.SaveChanges();
            }
            catch (Exception)
            {
                return(false);
            }

            actualizarSaldos(Saldo);
            return(true);
        }
Ejemplo n.º 4
0
        private void actualizarSaldos(Saldo saldo)
        {
            if (saldo == null)
            {
                return;
            }

            SAG2DB            db = new SAG2DB();
            int               SaldoInicialPeriodo = saldo.SaldoInicialCartola;
            List <Movimiento> Movimientos         = (from m in db.Movimiento
                                                     where m.Periodo == saldo.Periodo && m.Mes == saldo.Mes && m.CuentaCorrienteID == saldo.CuentaCorrienteID &&
                                                     m.Temporal == null && m.Nulo == null && m.Eliminado == null
                                                     orderby m.ID
                                                     select m).ToList();

            foreach (Movimiento Movimiento in Movimientos)
            {
                Movimiento.Saldo           = SaldoInicialPeriodo + Movimiento.Monto_Ingresos - Movimiento.Monto_Egresos;
                SaldoInicialPeriodo        = Movimiento.Saldo;
                db.Entry(Movimiento).State = EntityState.Modified;
                db.SaveChanges();
            }
        }
Ejemplo n.º 5
0
        public void RecalcularSaldos(int p_desde, int p_hasta, int m_desde, int m_hasta, Proyecto p, CuentaCorriente c)
        {
            SAG2DB db           = new SAG2DB();
            int    saldoInicial = 0;

            try
            {
                saldoInicial = db.Saldo.Where(s => s.CuentaCorrienteID == c.ID && s.Mes == m_desde && s.Periodo == p_desde).Single().SaldoInicialCartola;
            }
            catch (Exception)
            {
                saldoInicial = 0;
            }

            int saldo = saldoInicial;

            if (p_desde == p_hasta)
            {
                for (int i = m_desde; i <= m_hasta; i++)
                {
                    int ig = db.Movimiento.Where(m => m.Mes == i && m.ProyectoID == p.ID && m.Periodo == p_desde && m.Nulo == null && m.Temporal == null && m.Eliminado == null).Sum(m => m.Monto_Ingresos);
                    int eg = db.Movimiento.Where(m => m.Mes == i && m.ProyectoID == p.ID && m.Periodo == p_desde && m.Nulo == null && m.Temporal == null && m.Eliminado == null).Sum(m => m.Monto_Egresos);

                    Saldo sa = db.Saldo.Where(s => s.CuentaCorrienteID == c.ID && s.Mes == i && s.Periodo == p_desde).Single();
                    sa.SaldoInicialCartola = saldo;
                    saldo              = saldo + ig - eg;
                    sa.SaldoFinal      = saldo;
                    db.Entry(sa).State = EntityState.Modified;
                    db.SaveChanges();
                }
            }

            // Exite cambio de año en las modificaciones
            if (p_desde < p_hasta)
            {
                for (int i = m_desde; i <= 12; i++)
                {
                    int ig = db.Movimiento.Where(m => m.Mes == i && m.ProyectoID == p.ID && m.Periodo == p_desde && m.Nulo == null && m.Temporal == null && m.Eliminado == null).Sum(m => m.Monto_Ingresos);
                    int eg = db.Movimiento.Where(m => m.Mes == i && m.ProyectoID == p.ID && m.Periodo == p_desde && m.Nulo == null && m.Temporal == null && m.Eliminado == null).Sum(m => m.Monto_Egresos);

                    Saldo sa = db.Saldo.Where(s => s.CuentaCorrienteID == c.ID && s.Mes == i && s.Periodo == p_desde).Single();
                    sa.SaldoInicialCartola = saldo;
                    saldo              = saldo + ig - eg;
                    sa.SaldoFinal      = saldo;
                    db.Entry(sa).State = EntityState.Modified;
                    db.SaveChanges();
                }

                for (int i = 1; i <= m_hasta; i++)
                {
                    int ig = db.Movimiento.Where(m => m.Mes == i && m.ProyectoID == p.ID && m.Periodo == p_hasta && m.Nulo == null && m.Temporal == null && m.Eliminado == null).Sum(m => m.Monto_Ingresos);
                    int eg = db.Movimiento.Where(m => m.Mes == i && m.ProyectoID == p.ID && m.Periodo == p_hasta && m.Nulo == null && m.Temporal == null && m.Eliminado == null).Sum(m => m.Monto_Egresos);

                    Saldo sa = db.Saldo.Where(s => s.CuentaCorrienteID == c.ID && s.Mes == i && s.Periodo == p_hasta).Single();
                    sa.SaldoInicialCartola = saldo;
                    saldo              = saldo + ig - eg;
                    sa.SaldoFinal      = saldo;
                    db.Entry(sa).State = EntityState.Modified;
                    db.SaveChanges();
                }
            }
        }
Ejemplo n.º 6
0
        public bool ingresarSaldoIngreso(Movimiento movimiento, ModelStateDictionary ModelState)
        {
            Saldo  final      = null;
            SAG2DB db         = new SAG2DB();
            int    saldoFinal = 0;

            try
            {
                // Si existe registro del saldo actual, se suma monto del ingreso al saldo final
                Saldo Saldo = db.Saldo.Where(s => s.CuentaCorrienteID == movimiento.CuentaCorrienteID).Where(s => s.Periodo == movimiento.Periodo).Where(s => s.Mes == movimiento.Mes).Single();
                Saldo.SaldoFinal = Saldo.SaldoFinal + movimiento.Monto_Ingresos - movimiento.Monto_Egresos;
                if (ModelState.IsValid)
                {
                    db.Entry(Saldo).State = EntityState.Modified;
                    db.SaveChanges();
                }
                else
                {
                    erroresState(ModelState);
                    return(false);
                }
                saldoFinal = Saldo.SaldoFinal;
                Log(1, "Existe registro de saldo para periodo actual, se actualiza el saldo final.");
                final = Saldo;
            }
            catch (Exception e)
            {
                Log(1, "No existe registro de saldo para periodo actual. " + e.Message);
                try
                {
                    // Verificamos si existe periodo anterior
                    int periodo_anterior = movimiento.Periodo, mes_anterior = movimiento.Mes;
                    if (movimiento.Mes == 1)
                    {
                        mes_anterior = 12;
                        periodo_anterior--;
                    }
                    else
                    {
                        mes_anterior--;
                    }
                    Saldo SaldoAnterior = db.Saldo.Where(s => s.CuentaCorrienteID == movimiento.CuentaCorrienteID).Where(s => s.Periodo == periodo_anterior).Where(s => s.Mes == mes_anterior).Single();
                    // Ingresamos nuevo registro de saldo y actualizamos saldo final
                    Saldo SaldoActual = new Saldo();
                    SaldoActual.SaldoInicialCartola = SaldoAnterior.SaldoFinal;
                    SaldoActual.SaldoFinal          = SaldoAnterior.SaldoFinal + movimiento.Monto_Ingresos - movimiento.Monto_Egresos;
                    SaldoActual.Periodo             = movimiento.Periodo;
                    SaldoActual.Mes = movimiento.Mes;
                    SaldoActual.CuentaCorrienteID = movimiento.CuentaCorrienteID;
                    db.Saldo.Add(SaldoActual);
                    db.SaveChanges();
                    saldoFinal = SaldoActual.SaldoFinal;
                    Log(1, "Existe registro de saldo para periodo anterior y se ingresa y actualiza saldo para periodo actual");
                    final = SaldoActual;
                }
                catch (Exception e2)
                {
                    Log(1, "No existe registro de saldo para periodo anterior. " + e2.Message);
                    try
                    {
                        // Si no existe saldo para periodo actual ni anterior, definimos saldo inicial en CERO en el periodo actual para la cuenta corriente.
                        Saldo SaldoActual = new Saldo();
                        SaldoActual.SaldoInicialCartola = 0;
                        SaldoActual.SaldoFinal          = movimiento.Monto_Ingresos - movimiento.Monto_Egresos;
                        SaldoActual.Periodo             = movimiento.Periodo;
                        SaldoActual.Mes = movimiento.Mes;
                        SaldoActual.CuentaCorrienteID = movimiento.CuentaCorrienteID;
                        db.Saldo.Add(SaldoActual);
                        db.SaveChanges();

                        saldoFinal = 0;// SaldoActual.SaldoFinal;
                        Log(1, "Se crea registro para saldo para periodo actual y se define saldo inicial CERO.");
                        final = SaldoActual;
                    }
                    catch (Exception)
                    {
                        return(false);
                    }
                }
            }

            actualizarSaldos(final);
            return(true);
        }