Esempio n. 1
0
        public bool registroTipoCambio(DCHisTipoCambio dcHisTipoCambio)
        {
            bool resultado = false;

            using (var context = new MBEntities())
            {
                if (dcHisTipoCambio.iIdIngreso != 0)
                {
                    context.HIS_TIPO_CAMBIO.Add(new HIS_TIPO_CAMBIO
                    {
                        vMonto     = dcHisTipoCambio.vMonto,
                        dFecha     = dcHisTipoCambio.dFecha,
                        iIdMoneda  = dcHisTipoCambio.iIdMoneda,
                        iIdIngreso = dcHisTipoCambio.iIdIngreso
                    });
                    resultado = (Convert.ToBoolean(context.SaveChanges()) == true ? true : false);
                }
                else
                {
                    context.HIS_TIPO_CAMBIO.Add(new HIS_TIPO_CAMBIO
                    {
                        vMonto    = dcHisTipoCambio.vMonto,
                        dFecha    = dcHisTipoCambio.dFecha,
                        iIdMoneda = dcHisTipoCambio.iIdMoneda,
                        iIdGasto  = dcHisTipoCambio.iIdGasto
                    });
                    resultado = (Convert.ToBoolean(context.SaveChanges()) == true ? true : false);
                }
            }
            return(resultado);
        }
Esempio n. 2
0
 public bool registroIngresos(DCIngresos dcIngersos, DCHisTipoCambio tipoCambio) => new EspecificacionIngresos().registroIngresos(dcIngersos, tipoCambio);
Esempio n. 3
0
        public bool registroIngresos(DCIngresos dcIngresos, DCHisTipoCambio tipoCambio)
        {
            bool resultado = false;

            using (var context = new MBEntities())
            {
                using (var contextTransaccion = context.Database.BeginTransaction())
                {
                    try
                    {
                        //Crear el registro de ingreso
                        context.INGRESOS.Add(new INGRESOS
                        {
                            dFecha    = dcIngresos.dFecha,
                            dMonto    = dcIngresos.dMonto,
                            vConcepto = dcIngresos.vConcepto,
                        });
                        context.SaveChanges();

                        //Obtener el ingreso recién guardado
                        var Ingresos = (from INGRESOS in context.INGRESOS
                                        orderby INGRESOS.iIdIngreso
                                        descending
                                        select INGRESOS).FirstOrDefault();

                        //Validar el tipo de moneda para guardar o no el historial de tipo de cambio
                        if (tipoCambio.iIdMoneda == 1)
                        {
                            context.HIS_TIPO_CAMBIO.Add(new HIS_TIPO_CAMBIO
                            {
                                vMonto     = tipoCambio.vMonto,
                                dFecha     = tipoCambio.dFecha,
                                iIdMoneda  = tipoCambio.iIdMoneda,
                                iIdIngreso = Ingresos.iIdIngreso
                            });
                            context.SaveChanges();
                        }
                        //Para almacenar el Historial del capital primero se obtiene el ultimo registro de capital y este caso se le suma
                        //el monto del ingreso
                        var capitalActual = (from HIS_CAPITAL_FINANCIERO in context.HIS_CAPITAL_FINANCIERO
                                             orderby HIS_CAPITAL_FINANCIERO.iIdCapitalF
                                             descending
                                             select HIS_CAPITAL_FINANCIERO).FirstOrDefault();
                        //Convertir la moneda a colones en caso de ser dólares
                        var monto = utilitarios.convertirDolarAColon(dcIngresos.dMonto, tipoCambio.vMonto);
                        //Guardar el nuevo Historial de Capital
                        capitalActual.dMontoCF      = capitalActual.dMontoCF + monto;
                        capitalActual.dFechaDeCorte = dcIngresos.dFecha;
                        capitalActual.bEstado       = true;//True para los ingresos
                        context.HIS_CAPITAL_FINANCIERO.Add(capitalActual);
                        context.SaveChanges();

                        var IdUltimoCapital = capitalActual.iIdCapitalF;
                        //Registrar la tabla de unión de Capital e ingresos
                        context.T_UNION_HIS_CF_IG.Add(new T_UNION_HIS_CF_IG
                        {
                            iIdIngreso  = Ingresos.iIdIngreso,
                            iIdCapitalF = IdUltimoCapital
                        });
                        context.SaveChanges();

                        contextTransaccion.Commit();
                    }
                    catch (Exception e)
                    {
                        var error = e;
                        contextTransaccion.Rollback();
                        resultado = false;
                    }
                }
            }
            return(resultado);
        }
Esempio n. 4
0
 public bool registroGasto(DCGastos gastos, DCHisTipoCambio tipoCambio) => new EspecificacionGastos().registroGasto(gastos, tipoCambio);
Esempio n. 5
0
 public bool registroTipoCambio(DCHisTipoCambio dcHisTipoCambio) => new EspecificacionHisTipoCambio().registroTipoCambio(dcHisTipoCambio);
 /// <summary>
 /// Función para llevar un registro historico de los tipos de cambio con cada inrgeso otra moneda
 /// </summary>
 /// <param name="dcTipoCambio">Modelo Tipo de cambio</param>
 public bool registroTipoCambio(DCHisTipoCambio dcTipoCambio) => new AccionTipoCambio().registroTipoCambio(dcTipoCambio);
Esempio n. 7
0
 /// <summary>
 /// Función para registrar los ingresos de manera manual
 /// </summary>
 /// <param name="dcIngresos">Tipo de objeto del modelo WCF que representa un ingreso</param>
 /// <returns>Verdadero o false si se almacena en Base de datos.</returns>
 public bool registroIngresos(DCIngresos dcIngresos, DCHisTipoCambio tipoCambio) => new AccionIngresos().registroIngresos(dcIngresos, tipoCambio);
Esempio n. 8
0
        public bool registroGasto(DCGastos nuevoGasto, DCHisTipoCambio tipoCambioParcial)
        {
            bool resultado = false;

            using (var context = new MBEntities())
            {
                using (var contextTransaccion = context.Database.BeginTransaction())
                {
                    try
                    {
                        //Registrar el gasto
                        context.GASTOS.Add(new GASTOS
                        {
                            iIdCatalogo  = nuevoGasto.iIdCatalogo,
                            dMonto       = nuevoGasto.dMonto,
                            dFecha       = nuevoGasto.dFecha,
                            vDetalle     = nuevoGasto.vDetalle,
                            iIdFormaPago = nuevoGasto.iIdFormaPago
                        });
                        context.SaveChanges();
                        //Obtener el gaste recién insertado
                        var ultimoGasto = (from GASTOS in context.GASTOS
                                           orderby GASTOS.iIdGastos
                                           descending
                                           select GASTOS).FirstOrDefault();
                        //Validar el tipo de moneda del gasto insertado
                        if (tipoCambioParcial.iIdMoneda == 1)
                        {
                            context.HIS_TIPO_CAMBIO.Add(new HIS_TIPO_CAMBIO
                            {
                                vMonto    = tipoCambioParcial.vMonto,
                                dFecha    = tipoCambioParcial.dFecha,
                                iIdMoneda = tipoCambioParcial.iIdMoneda,
                                iIdGasto  = ultimoGasto.iIdGastos
                            });
                            context.SaveChanges();
                        }
                        //Registrar la unión del gasto con el detalle del presupuesto para lo cual se obtiene el detalle
                        //por la fecha y el catalogo del gasto registrado
                        var detPresupuesto = (from detPrep in context.PRESUPUESTO
                                              join union in context.T_UNION_DETALLE_PRESUPUESTO on detPrep.iIdPresupuesto equals union.iIdPresupuesto
                                              join det in context.DETALLE_PRESUPUESTO on new { union.iIdDetalle } equals new { det.iIdDetalle }
                                              where nuevoGasto.dFecha <= detPrep.dFechaFinal && nuevoGasto.dFecha >= detPrep.dFechaInicio &&
                                              nuevoGasto.iIdCatalogo == det.iIdDetalle
                                              select new { det.iIdCatalogo, det.iIdDetalle, det.dMonto }).FirstOrDefault();
                        //Guardar el registro en la tabla de unión detalle y gasto
                        context.T_UNION_GAS_DET_PRESUP.Add(new T_UNION_GAS_DET_PRESUP
                        {
                            iIdDetallePresupuesto = detPresupuesto.iIdDetalle,
                            iIdGasto = ultimoGasto.iIdGastos
                        });
                        context.SaveChanges();
                        //Actualizar el monto real del presupuesto actual
                        var prep = (from PRESUPUESTO in context.PRESUPUESTO
                                    where nuevoGasto.dFecha <= PRESUPUESTO.dFechaFinal && nuevoGasto.dFecha >= PRESUPUESTO.dFechaInicio
                                    select PRESUPUESTO).FirstOrDefault();
                        prep.dMontoReal          += nuevoGasto.dMonto;
                        context.Entry(prep).State = System.Data.Entity.EntityState.Modified;
                        context.SaveChanges();
                        //Para el registro del capital primero se obtiene el capital actual y en este caso se le resta
                        //el monto del gasto registrado.
                        var capitalActual = (from HIS_CAPITAL_FINANCIERO in context.HIS_CAPITAL_FINANCIERO
                                             orderby HIS_CAPITAL_FINANCIERO.iIdCapitalF
                                             descending
                                             select HIS_CAPITAL_FINANCIERO).FirstOrDefault();
                        //Convertir el monto del gasto a colones
                        var monto = utilitarios.convertirDolarAColon(nuevoGasto.dMonto, tipoCambioParcial.vMonto);
                        //Guardar el nuevo historial menos el monto del gasto
                        context.HIS_CAPITAL_FINANCIERO.Add(new HIS_CAPITAL_FINANCIERO
                        {
                            dMontoCF      = capitalActual.dMontoCF - monto,
                            dFechaDeCorte = nuevoGasto.dFecha,
                            bEstado       = false //para los gastos
                        });
                        context.SaveChanges();

                        var IdUltimoCapital = (from HIS_CAPITAL_FINANCIERO in context.HIS_CAPITAL_FINANCIERO
                                               orderby HIS_CAPITAL_FINANCIERO.iIdCapitalF
                                               descending
                                               select HIS_CAPITAL_FINANCIERO.iIdCapitalF).FirstOrDefault();
                        //Regitrar la unión de capital y gastos
                        context.T_UNION_HIS_CF_GS.Add(new T_UNION_HIS_CF_GS
                        {
                            iIdGasto    = ultimoGasto.iIdGastos,
                            iIdCapitalF = IdUltimoCapital
                        });
                        context.SaveChanges();
                        //Actualizar el control de pagos en caso de ser uno.
                        //Buscar si el pago existe
                        var pago = (from PAGOS in context.PAGOS
                                    where PAGOS.iIdCatalogo == nuevoGasto.iIdCatalogo
                                    orderby PAGOS.dFechaVencePago
                                    descending
                                    select PAGOS).FirstOrDefault();
                        if (pago != null)
                        {
                            pago.bEstado = true;
                            context.Entry(pago).State = System.Data.Entity.EntityState.Modified;
                            context.SaveChanges();
                        }

                        contextTransaccion.Commit();
                    }
                    catch (Exception e)
                    {
                        var error = e;

                        contextTransaccion.Rollback();
                        resultado = false;
                    }
                }
            }
            return(resultado);
        }