Ejemplo n.º 1
0
        public static ContaPoliza CrearPoliza(int iTipoPolizaID, string sConcepto, int iCuentaCargo, int iCuentaAbono, decimal mImporte, string sReferencia
            , string sTabla, int? iRelacionID, int iSucursalID)
        {
            var oPoliza = new ContaPoliza()
            {
                Fecha = DateTime.Now,
                ContaTipoPolizaID = iTipoPolizaID,
                Concepto = sConcepto,
                RealizoUsuarioID = Theos.UsuarioID,
                SucursalID = iSucursalID,
                RelacionID = iRelacionID
            };
            Datos.Guardar<ContaPoliza>(oPoliza);

            var oDetCargo = new ContaPolizaDetalle()
            {
                ContaPolizaID = oPoliza.ContaPolizaID,
                ContaCuentaAuxiliarID = iCuentaCargo,
                SucursalID = oPoliza.SucursalID,
                Cargo = mImporte,
                Abono = 0,
                Referencia = sReferencia
            };
            var oDetAbono = new ContaPolizaDetalle()
            {
                ContaPolizaID = oPoliza.ContaPolizaID,
                ContaCuentaAuxiliarID = iCuentaAbono,
                SucursalID = oPoliza.SucursalID,
                Cargo = 0,
                Abono = mImporte,
                Referencia = sReferencia
            };
            if (iCuentaCargo > 0)
                Datos.Guardar<ContaPolizaDetalle>(oDetCargo);
            if (iCuentaAbono > 0)
                Datos.Guardar<ContaPolizaDetalle>(oDetAbono);

            return oPoliza;
        }
Ejemplo n.º 2
0
        public static ContaPoliza CrearPoliza(ContaPoliza oPoliza, int iCuentaCargo, int iCuentaAbono, decimal mImporte, string sReferencia
            , int iSucursalCargo, int iSucursalAbono)
        {
            if (oPoliza.Fecha == DateTime.MinValue)
                oPoliza.Fecha = DateTime.Now;
            if (oPoliza.RealizoUsuarioID <= 0)
                oPoliza.RealizoUsuarioID = Theos.UsuarioID;
            if (oPoliza.SucursalID <= 0)
                oPoliza.SucursalID = Theos.SucursalID;

            Datos.Guardar<ContaPoliza>(oPoliza);

            var oDetCargo = new ContaPolizaDetalle()
            {
                ContaPolizaID = oPoliza.ContaPolizaID,
                ContaCuentaAuxiliarID = iCuentaCargo,
                SucursalID = iSucursalCargo,
                Cargo = mImporte,
                Abono = 0,
                Referencia = sReferencia
            };
            var oDetAbono = new ContaPolizaDetalle()
            {
                ContaPolizaID = oPoliza.ContaPolizaID,
                ContaCuentaAuxiliarID = iCuentaAbono,
                SucursalID = iSucursalAbono,
                Cargo = 0,
                Abono = mImporte,
                Referencia = sReferencia
            };
            if (iCuentaCargo > 0)
                Datos.Guardar<ContaPolizaDetalle>(oDetCargo);
            if (iCuentaAbono > 0)
                Datos.Guardar<ContaPolizaDetalle>(oDetAbono);

            return oPoliza;
        }
Ejemplo n.º 3
0
 public static ContaPoliza CrearPoliza(ContaPoliza oPoliza, int iCuentaCargo, int iCuentaAbono, decimal mImporte, string sReferencia)
 {
     return ContaProc.CrearPoliza(oPoliza, iCuentaCargo, iCuentaAbono, mImporte, sReferencia, oPoliza.SucursalID, oPoliza.SucursalID);
 }
Ejemplo n.º 4
0
        public static ContaPoliza CrearPolizaAfectacion(int iAfectacionID, int iId, string sReferencia, string sConcepto, int iSucursalID, DateTime dFecha)
        {
            // Se genera el detalle de la poliza
            ContaPolizaDetalle oRegPoliza;
            var oPolizaDet = new List<ContaPolizaDetalle>();

            decimal mCargo = 0, mAbono = 0;
            string sVales = "";
            var oAfectacion = Datos.GetEntity<ContaConfigAfectacion>(c => c.ContaConfigAfectacionID == iAfectacionID);
            var oAfectacionDet = Datos.GetListOf<ContaConfigAfectacionDetalle>(c => c.ContaConfigAfectacionID == iAfectacionID);
            foreach (var oReg in oAfectacionDet)
            {
                oRegPoliza = null;
                bool bFacturaGlobalAnticipoClientes = false;

                if (oReg.EsCasoFijo)
                {
                    // Actualmente sólo hay un caso fijo y por tanto no se verifica más ni se hacen casos
                    oRegPoliza = ContaProc.GafClientes(iAfectacionID, iId);
                    switch (iSucursalID)
                    {
                        case Cat.Sucursales.Matriz: oRegPoliza.ContaCuentaAuxiliarID = Cat.ContaCuentasAuxiliares.ClientesHectorRicardo; break;
                        case Cat.Sucursales.Sucursal2: oRegPoliza.ContaCuentaAuxiliarID = Cat.ContaCuentasAuxiliares.ClientesEdgarAron; break;
                        case Cat.Sucursales.Sucursal3: oRegPoliza.ContaCuentaAuxiliarID = Cat.ContaCuentasAuxiliares.ClientesJoseManuel; break;
                    }
                }
                else if (oReg.EsCuentaDeMayor)
                {
                    switch (oReg.CuentaID)
                    {
                        case Cat.ContaCuentasDeMayor.Clientes:
                            oRegPoliza = ContaProc.GafClientes(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerClienteCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.Proveedores:
                            oRegPoliza = ContaProc.GafProveedores(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerProveedorCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.Bancos:
                            oRegPoliza = ContaProc.GafBancos(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerBancoCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.Agua:  // Se usa como si fuera *Gastos
                            oRegPoliza = ContaProc.GafGastos(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerGastoCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.InteresesBancarios:
                            oRegPoliza = ContaProc.GafInteresesBancarios(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerGastoCuentaAuxiliarID(iAfectacionID, iId);  // Se parte de un ContaEgresoID
                            break;
                        case Cat.ContaCuentasDeMayor.CuentasPorPagarCortoPlazo:
                            oRegPoliza = ContaProc.GafCuentasPorPagarCortoPlazo(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerCpcpCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.ReparteDeUtilidades:
                            oRegPoliza = ContaProc.GafRepartoDeUtilidades(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerGastoCuentaAuxiliarID(iAfectacionID, iId);
                            break;

                        case Cat.ContaCuentasDeMayor.Salarios:
                            oRegPoliza = ContaProc.GafSalarios(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Salarios);
                            break;
                        case Cat.ContaCuentasDeMayor.TiempoExtra:
                            oRegPoliza = ContaProc.GafTiempoExtra(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.TiempoExtra);
                            break;
                        case Cat.ContaCuentasDeMayor.PremioDeAsistencia:
                            oRegPoliza = ContaProc.GafPremioDeAsistencia(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.PremioDeAsistencia);
                            break;
                        case Cat.ContaCuentasDeMayor.PremioDePuntualidad:
                            oRegPoliza = ContaProc.GafPremioDePuntualidad(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.PremioDePuntualidad);
                            break;
                        case Cat.ContaCuentasDeMayor.Vacaciones:
                            oRegPoliza = ContaProc.GafVacaciones(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Vacaciones);
                            break;
                        case Cat.ContaCuentasDeMayor.PrimaVacacional:
                            oRegPoliza = ContaProc.GafPrimaVacacional(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.PrimaVacacional);
                            break;
                        case Cat.ContaCuentasDeMayor.Aguinaldo:
                            oRegPoliza = ContaProc.GafAguinaldo(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Aguinaldo);
                            break;
                        case Cat.ContaCuentasDeMayor.Ptu:
                            oRegPoliza = ContaProc.GafPtu(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Ptu);
                            break;
                        case Cat.ContaCuentasDeMayor.Imss:
                            oRegPoliza = ContaProc.GafImss(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Imss);
                            break;
                        case Cat.ContaCuentasDeMayor.Ispt:
                            oRegPoliza = ContaProc.GafIspt(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Ispt);
                            break;
                        case Cat.ContaCuentasDeMayor.Infonavit:
                            oRegPoliza = ContaProc.GafInfonavit(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Infonavit);
                            break;
                        case Cat.ContaCuentasDeMayor.RetencionImss:
                            oRegPoliza = ContaProc.GafRetencionImss(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.RetencionImss);
                            break;
                        case Cat.ContaCuentasDeMayor.SubsidioAlEmpleo:
                            oRegPoliza = ContaProc.GafSubsidioAlEmpleo(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.SubsidioAlEmpleo);
                            break;
                        case Cat.ContaCuentasDeMayor.RetencionInfonavit:
                            oRegPoliza = ContaProc.GafRetencionInfonavit(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.RetencionInfonavit);
                            break;

                        case Cat.ContaCuentasDeMayor.Nomina2Por:
                            oRegPoliza = ContaProc.GafNomina2Por(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaImpuestoUsuarioCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Nomina2Por);
                            break;
                    }
                }
                else
                {
                    switch (oReg.CuentaID)
                    {
                        case Cat.ContaCuentasAuxiliares.Inventario:
                            oRegPoliza = ContaProc.GafInventario(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.InventarioGarantias:
                            oRegPoliza = ContaProc.GafInventarioGarantias(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.CostoVenta:
                            oRegPoliza = ContaProc.GafCostoVenta(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.VentasContado:
                            oRegPoliza = ContaProc.GafVentasContado(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.VentasCredito:
                            oRegPoliza = ContaProc.GafVentasCredito(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.IvaTrasladadoCobrado:
                            oRegPoliza = ContaProc.GafIvaTrasladadoCobrado(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.IvaTrasladadoNoCobrado:
                            oRegPoliza = ContaProc.GafIvaTrasladadoNoCobrado(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.Caja:
                            oRegPoliza = ContaProc.GafCaja(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.IvaAcreditablePorPagar:
                            oRegPoliza = ContaProc.GafIvaAcreditablePorPagar(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.IvaAcreditablePagado:
                            oRegPoliza = ContaProc.GafIvaAcreditablePagado(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.CapitalFijo:
                            oRegPoliza = ContaProc.GafCapitalFijo(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.Resguardo:
                            oRegPoliza = ContaProc.GafResguardo(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.GastosNoDeducibles:
                            oRegPoliza = ContaProc.GafResguardo(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.AnticipoClientes:
                            oRegPoliza = ContaProc.GafAnticipoClientes(iAfectacionID, iId);
                            // Se obtiene el vale usado de la afectación. Se guarda en la referencia
                            if (oRegPoliza.Referencia != "")
                                sVales += ("," + oRegPoliza.Referencia);
                            //
                            if (iAfectacionID == Cat.ContaAfectaciones.VentaContadoPagoFacturaGlobal)
                                bFacturaGlobalAnticipoClientes = true;
                            break;
                        case Cat.ContaCuentasAuxiliares.DescuentoSobreVentaClientes:
                            oRegPoliza = ContaProc.GafDescuentoSobreVentaClientes(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.DevolucionSobreVentaClientes:
                            oRegPoliza = ContaProc.GafDevolucionesSobreVentaClientes(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.ReservaNomina:
                            oRegPoliza = ContaProc.GafReservaNomina(iAfectacionID, iId);
                            break;
                    }

                    if (oRegPoliza != null)
                        oRegPoliza.ContaCuentaAuxiliarID = oReg.CuentaID;
                }

                if (oRegPoliza != null)
                {
                    // oRegPoliza.ContaCuentaAuxiliarID = oReg.ContaCuentaAuxiliarID;
                    oRegPoliza.Cargo = Math.Round(oRegPoliza.Cargo, 2);
                    if (!oReg.EsCargo)
                    {
                        oRegPoliza.Abono = oRegPoliza.Cargo;
                        oRegPoliza.Cargo = 0;
                    }
                    oRegPoliza.Referencia = sReferencia;
                    // oRegPoliza.RelacionID = iId;

                    // Se verifica y ajusta el dato de la sucursal, si se debe modificar
                    switch (oReg.ContaPolizaAsigSucursalID)
                    {
                        case Cat.ContaPolizaAsignacionDeSucursales.Local: oRegPoliza.SucursalID = iSucursalID; break;
                        case Cat.ContaPolizaAsignacionDeSucursales.Matriz: oRegPoliza.SucursalID = Cat.Sucursales.Matriz; break;
                        case Cat.ContaPolizaAsignacionDeSucursales.DondeSeHizo: break;  // La sucursal se llena en la afectación del importe
                    }
                    // Si no se llenó la sucursal, porque no se dió el caso, se llena con la sucursal local
                    if (oRegPoliza.SucursalID == 0)
                        oRegPoliza.SucursalID = iSucursalID;

                    oPolizaDet.Add(oRegPoliza);

                    // Para la validación
                    mCargo += oRegPoliza.Cargo;
                    mAbono += oRegPoliza.Abono;

                    // Se verifica si es la afectación de Anticipo Clientes en la Factura Global, para hacer un ajuste especial
                    if (bFacturaGlobalAnticipoClientes)
                    {
                        DateTime dHoy = DateTime.Now;
                        var oPagosVales = Datos.GetListOf<VentasPagosDetalleAvanzadoView>(c => c.SucursalID == Theos.SucursalID
                            && EntityFunctions.TruncateTime(c.Fecha) == dHoy && !c.Facturada && c.Importe > 0 && c.FormaDePagoID == Cat.FormasDePago.Vale);
                        foreach (var oPagoVale in oPagosVales)
                        {
                            var oVale = Datos.GetEntity<NotaDeCredito>(c => c.NotaDeCreditoID == oPagoVale.NotaDeCreditoID && c.Estatus);
                            var oRegAntC = new ContaPolizaDetalle()
                            {
                                ContaCuentaAuxiliarID = Cat.ContaCuentasAuxiliares.AnticipoClientes,
                                Referencia = sReferencia,
                                Cargo = (oReg.EsCargo ? oPagoVale.Importe : 0),
                                Abono = (oReg.EsCargo ? 0 : oPagoVale.Importe),
                                SucursalID = oVale.SucursalID.Valor()
                            };
                            oPolizaDet.Add(oRegAntC);
                            // Para la validación
                            mCargo += oRegAntC.Cargo;
                            mAbono += oRegAntC.Abono;
                        }

                        // Se borra la PolizaDetalle creada por el proceso normal
                        if (oPagosVales.Count > 0)
                            oPolizaDet.Remove(oRegPoliza);
                    }
                }
            }

            // Se validan que los movimientos den cero como resultado
            bool bError = (mCargo != mAbono);
            if (bError)
            {
                // Se registra la diferencia y se sale, pues no coincide
                var oError = new ContaPolizaError()
                {
                    Fecha = dFecha,
                    ContaTipoPolizaID = oAfectacion.ContaTipoPolizaID,
                    Concepto = (sReferencia + " / " + sConcepto),
                    RealizoUsuarioID = Theos.UsuarioID,
                    SucursalID = iSucursalID,
                    Detalle = ""
                };
                foreach (var oReg in oPolizaDet)
                {
                    var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaAuxiliarID == oReg.ContaCuentaAuxiliarID);
                    oError.Detalle += string.Format("{0}\t{1}\t{2}\t{3}\n", oReg.ContaCuentaAuxiliarID, oCuentaAux.CuentaAuxiliar.RellenarCortarDerecha(32)
                        , oReg.Cargo.ToString(Con.Formatos.Moneda), oReg.Abono.ToString(Con.Formatos.Moneda));
                }
                // Se deja de llenar el registro de ContaPolizaError por incompatibilidad con los nuevos cambios de ContaPoliza - Moi 2015-10-26
                // Datos.Guardar<ContaPolizaError>(oError);
                // Se muestra un mensaje de error
                // dpend
                // Util.MensajeAdvertencia(string.Format("Se encontró una diferencia al tratar de crear la Póliza Contable.\n\n\t\t\t\tCargo\tAbono\n{0}\t\t\t\t{1}\t{2}"
                //    , oError.Detalle, mCargo.ToString(Con.Formatos.Moneda), mAbono.ToString(Con.Formatos.Moneda)), Theos.Titulo);
                // Ya no se sale, se guarda la póliza y se marca como error
                // return;
            }

            // Se genera la Póliza
            var oPoliza = new ContaPoliza()
            {
                Fecha = dFecha,
                ContaTipoPolizaID = oAfectacion.ContaTipoPolizaID,
                Concepto = (sReferencia + " / " + sConcepto),
                RealizoUsuarioID = Theos.UsuarioID,
                SucursalID = iSucursalID,
                RelacionTabla = ContaProc.ObtenerTablaDeAfectacion(iAfectacionID),
                RelacionID = iId,
                Origen = oAfectacion.Operacion,
                Error = bError
            };

            // Se verifica si se afectaron vales (cuanta anticipo clientes), para concatenarlos en la observación de la póliza
            string sObsAnticipo = "";
            var oVales = sVales.Split(',');
            foreach (string sVale in oVales)
            {
                int iVale = Util.Entero(sVale);
                var oVale = Datos.GetEntity<NotaDeCredito>(c => c.NotaDeCreditoID == iVale && c.Estatus);
                if (oVale != null)
                    sObsAnticipo += (", " + sVale + (oVale.OrigenID == Cat.OrigenesNotaDeCredito.ImporteRestante ? (" (" + oVale.RelacionID.ToString() + ")") : ""));
            }
            if (sObsAnticipo != "")
                oPoliza.Concepto += (" / VALES: " + sObsAnticipo.Substring(2).Truncar(256));

            // Se guardan los datos
            Datos.Guardar<ContaPoliza>(oPoliza);
            foreach (var oReg in oPolizaDet)
            {
                oReg.ContaPolizaID = oPoliza.ContaPolizaID;
                Datos.Guardar<ContaPolizaDetalle>(oReg);
            }

            return oPoliza;
        }
Ejemplo n.º 5
0
        public static ContaPoliza CrearPoliza(int iTipoPolizaID, string sConcepto, int iCuentaCargo, int iCuentaAbono, decimal mImporte, string sReferencia
            , string sTabla, int? iRelacionID, int iSucursalID)
        {
            var oPoliza = new ContaPoliza()
            {
                Fecha = DateTime.Now,
                ContaTipoPolizaID = iTipoPolizaID,
                Concepto = sConcepto,
                RealizoUsuarioID = Theos.UsuarioID,
                SucursalID = iSucursalID,
                RelacionTabla = sTabla,
                RelacionID = iRelacionID
            };

            return ContaProc.CrearPoliza(oPoliza, iCuentaCargo, iCuentaAbono, mImporte, sReferencia);
        }
Ejemplo n.º 6
0
        private bool AccionGuardar()
        {
            if (!this.Validar())
                return false;

            Cargando.Mostrar();

            // Se obtiene la póliza
            ContaPoliza oPoliza;
            if (this.iPolizaID > 0)
                oPoliza = Datos.GetEntity<ContaPoliza>(c => c.ContaPolizaID == iPolizaID);
            else
                oPoliza = new ContaPoliza() { SucursalID = GlobalClass.SucursalID, RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID, FueManual = true };

            // Se guarda la póliza
            oPoliza.Fecha = this.dtpFecha.Value;
            oPoliza.ContaTipoPolizaID = Util.Entero(this.cmbTipoPoliza.SelectedValue);
            oPoliza.Concepto = this.txtConcepto.Text;
            oPoliza.Origen = this.txtOrigen.Text;
            oPoliza.Error = false;
            Datos.Guardar<ContaPoliza>(oPoliza);

            // Se procede a guardar el detalle
            ContaPolizaDetalle oReg = null;
            foreach (DataGridViewRow oFila in this.dgvDetalle.Rows)
            {
                if (oFila.IsNewRow) continue;

                int iCuentaAuxID = Util.Entero(oFila.Cells["ContaCuentaAuxiliarID"].Value);
                int iId = this.dgvDetalle.ObtenerId(oFila);
                int iCambio = this.dgvDetalle.ObtenerIdCambio(oFila);
                switch (iCambio)
                {
                    case Cat.TiposDeAfectacion.Agregar:
                    case Cat.TiposDeAfectacion.Modificar:
                        if (iCambio == Cat.TiposDeAfectacion.Agregar)
                            oReg = new ContaPolizaDetalle() { ContaPolizaID = oPoliza.ContaPolizaID };
                        else
                            oReg = Datos.GetEntity<ContaPolizaDetalle>(c => c.ContaPolizaDetalleID == iId);

                        oReg.ContaCuentaAuxiliarID = iCuentaAuxID;
                        oReg.Cargo = Util.Decimal(oFila.Cells["Cargo"].Value);
                        oReg.Abono = Util.Decimal(oFila.Cells["Abono"].Value);
                        oReg.Referencia = Util.Cadena(oFila.Cells["Referencia"].Value);
                        oReg.SucursalID = Util.Entero(oFila.Cells["SucursalID"].Value);

                        Datos.Guardar<ContaPolizaDetalle>(oReg);
                        break;
                    case Cat.TiposDeAfectacion.Borrar:
                        oReg = Datos.GetEntity<ContaPolizaDetalle>(c => c.ContaPolizaDetalleID == iId);
                        Datos.Eliminar<ContaPolizaDetalle>(oReg);
                        break;
                }

                // Se verifica si se afecta una cuenta bancaria, en cuyo caso, se crea un movimiento bancario
                if (iCambio == Cat.TiposDeAfectacion.Agregar)
                {
                    var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaAuxiliarID == iCuentaAuxID);
                    if ((oCuentaAux.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Bancos || oCuentaAux.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.CuentasPorPagarCortoPlazo)
                        && oCuentaAux.RelacionID.HasValue)
                    {
                        var oMovBanc = new BancoCuentaMovimiento()
                        {
                            BancoCuentaID = oCuentaAux.RelacionID.Valor(),
                            EsIngreso = (oReg.Cargo > 0),
                            Fecha = oPoliza.Fecha,
                            FechaAsignado = oPoliza.Fecha,
                            SucursalID = oPoliza.SucursalID,
                            Importe = (oReg.Cargo > 0 ? oReg.Cargo : oReg.Abono),
                            Concepto = oPoliza.Concepto,
                            Referencia = oReg.Referencia,
                            TipoFormaPagoID = Cat.FormasDePago.Efectivo,
                            RelacionID = oReg.ContaPolizaDetalleID
                        };
                        ContaProc.RegistrarMovimientoBancario(oMovBanc);
                    }
                }
            }

            Cargando.Cerrar();
            return true;
        }
Ejemplo n.º 7
0
        public static ContaPoliza CrearPolizaAfectacion(int iAfectacionID, int iId, string sReferencia, string sConcepto, int iSucursalID)
        {
            // Se genera el detalle de la poliza
            ContaPolizaDetalle oRegPoliza;
            var oPolizaDet = new List<ContaPolizaDetalle>();

            decimal mCargo = 0, mAbono = 0;
            var oAfectacion = Datos.GetEntity<ContaConfigAfectacion>(c => c.ContaConfigAfectacionID == iAfectacionID);
            var oAfectacionDet = Datos.GetListOf<ContaConfigAfectacionDetalle>(c => c.ContaConfigAfectacionID == iAfectacionID);
            foreach (var oReg in oAfectacionDet)
            {
                oRegPoliza = null;

                if (oReg.EsCasoFijo)
                {
                    // Actualmente sólo hay un caso fijo y por tanto no se verifica más ni se hacen casos
                    oRegPoliza = ContaProc.GafClientes(iAfectacionID, iId);
                    switch (Theos.SucursalID)
                    {
                        case Cat.Sucursales.Matriz: oRegPoliza.ContaCuentaAuxiliarID = Cat.ContaCuentasAuxiliares.ClientesHectorRicardo; break;
                        case Cat.Sucursales.Sucursal2: oRegPoliza.ContaCuentaAuxiliarID = Cat.ContaCuentasAuxiliares.ClientesEdgarAron; break;
                        case Cat.Sucursales.Sucursal3: oRegPoliza.ContaCuentaAuxiliarID = Cat.ContaCuentasAuxiliares.ClientesJoseManuel; break;
                    }
                }
                else if (oReg.EsCuentaDeMayor)
                {
                    switch (oReg.CuentaID)
                    {
                        case Cat.ContaCuentasDeMayor.Clientes:
                            oRegPoliza = ContaProc.GafClientes(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerClienteCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.Proveedores:
                            oRegPoliza = ContaProc.GafProveedores(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerProveedorCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.Bancos:
                            oRegPoliza = ContaProc.GafBancos(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerBancoCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.Agua:  // Se usa como si fuera *Gastos
                            oRegPoliza = ContaProc.GafGastos(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerGastoCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.InteresesBancarios:
                            oRegPoliza = ContaProc.GafInteresesBancarios(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerGastoCuentaAuxiliarID(iAfectacionID, iId);  // Se parte de un ContaEgresoID
                            break;
                        case Cat.ContaCuentasDeMayor.CuentasPorPagarCortoPlazo:
                            oRegPoliza = ContaProc.GafCuentasPorPagarCortoPlazo(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerCpcpCuentaAuxiliarID(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasDeMayor.ReparteDeUtilidades:
                            oRegPoliza = ContaProc.GafRepartoDeUtilidades(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerGastoCuentaAuxiliarID(iAfectacionID, iId);
                            break;

                        case Cat.ContaCuentasDeMayor.Salarios:
                            oRegPoliza = ContaProc.GafSalarios(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Salarios);
                            break;
                        case Cat.ContaCuentasDeMayor.TiempoExtra:
                            oRegPoliza = ContaProc.GafTiempoExtra(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.TiempoExtra);
                            break;
                        case Cat.ContaCuentasDeMayor.PremioDeAsistencia:
                            oRegPoliza = ContaProc.GafPremioDeAsistencia(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.PremioDeAsistencia);
                            break;
                        case Cat.ContaCuentasDeMayor.PremioDePuntualidad:
                            oRegPoliza = ContaProc.GafPremioDePuntualidad(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.PremioDePuntualidad);
                            break;
                        case Cat.ContaCuentasDeMayor.Vacaciones:
                            oRegPoliza = ContaProc.GafVacaciones(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Vacaciones);
                            break;
                        case Cat.ContaCuentasDeMayor.PrimaVacacional:
                            oRegPoliza = ContaProc.GafPrimaVacacional(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.PrimaVacacional);
                            break;
                        case Cat.ContaCuentasDeMayor.Aguinaldo:
                            oRegPoliza = ContaProc.GafAguinaldo(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Aguinaldo);
                            break;
                        case Cat.ContaCuentasDeMayor.Ptu:
                            oRegPoliza = ContaProc.GafPtu(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Ptu);
                            break;
                        case Cat.ContaCuentasDeMayor.Imss:
                            oRegPoliza = ContaProc.GafImss(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Imss);
                            break;
                        case Cat.ContaCuentasDeMayor.Ispt:
                            oRegPoliza = ContaProc.GafIspt(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Ispt);
                            break;
                        case Cat.ContaCuentasDeMayor.Infonavit:
                            oRegPoliza = ContaProc.GafInfonavit(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Infonavit);
                            break;
                        case Cat.ContaCuentasDeMayor.RetencionImss:
                            oRegPoliza = ContaProc.GafRetencionImss(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.RetencionImss);
                            break;
                        case Cat.ContaCuentasDeMayor.SubsidioAlEmpleo:
                            oRegPoliza = ContaProc.GafSubsidioAlEmpleo(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.SubsidioAlEmpleo);
                            break;
                        case Cat.ContaCuentasDeMayor.RetencionInfonavit:
                            oRegPoliza = ContaProc.GafRetencionInfonavit(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaOficialCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.RetencionInfonavit);
                            break;

                        case Cat.ContaCuentasDeMayor.Nomina2Por:
                            oRegPoliza = ContaProc.GafNomina2Por(iAfectacionID, iId);
                            oRegPoliza.ContaCuentaAuxiliarID = ContaProc.ObtenerNominaImpuestoUsuarioCuentaAuxiliarID(iAfectacionID, iId, Cat.ContaCuentasDeMayor.Nomina2Por);
                            break;
                    }
                }
                else
                {
                    switch (oReg.CuentaID)
                    {
                        case Cat.ContaCuentasAuxiliares.Inventario:
                            oRegPoliza = ContaProc.GafInventario(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.InventarioGarantias:
                            oRegPoliza = ContaProc.GafInventarioGarantias(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.CostoVenta:
                            oRegPoliza = ContaProc.GafCostoVenta(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.VentasContado:
                            oRegPoliza = ContaProc.GafVentasContado(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.VentasCredito:
                            oRegPoliza = ContaProc.GafVentasCredito(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.IvaTrasladadoCobrado:
                            oRegPoliza = ContaProc.GafIvaTrasladadoCobrado(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.IvaTrasladadoNoCobrado:
                            oRegPoliza = ContaProc.GafIvaTrasladadoNoCobrado(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.Caja:
                            oRegPoliza = ContaProc.GafCaja(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.IvaAcreditablePorPagar:
                            oRegPoliza = ContaProc.GafIvaAcreditablePorPagar(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.IvaAcreditablePagado:
                            oRegPoliza = ContaProc.GafIvaAcreditablePagado(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.CapitalFijo:
                            oRegPoliza = ContaProc.GafCapitalFijo(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.Resguardo:
                            oRegPoliza = ContaProc.GafResguardo(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.GastosNoDeducibles:
                            oRegPoliza = ContaProc.GafResguardo(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.AnticipoClientes:
                            oRegPoliza = ContaProc.GafAnticipoClientes(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.DescuentoSobreVentaClientes:
                            oRegPoliza = ContaProc.GafDescuentoSobreVentaClientes(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.DevolucionSobreVentaClientes:
                            oRegPoliza = ContaProc.GafDevolucionesSobreVentaClientes(iAfectacionID, iId);
                            break;
                        case Cat.ContaCuentasAuxiliares.ReservaNomina:
                            oRegPoliza = ContaProc.GafReservaNomina(iAfectacionID, iId);
                            break;
                    }

                    if (oRegPoliza != null)
                        oRegPoliza.ContaCuentaAuxiliarID = oReg.CuentaID;
                }

                if (oRegPoliza != null)
                {
                    // oRegPoliza.ContaCuentaAuxiliarID = oReg.ContaCuentaAuxiliarID;
                    oRegPoliza.Cargo = Math.Round(oRegPoliza.Cargo, 2);
                    if (!oReg.EsCargo)
                    {
                        oRegPoliza.Abono = oRegPoliza.Cargo;
                        oRegPoliza.Cargo = 0;
                    }
                    oRegPoliza.Referencia = sReferencia;
                    // oRegPoliza.RelacionID = iId;
                    oPolizaDet.Add(oRegPoliza);

                    // Para la validación
                    mCargo += oRegPoliza.Cargo;
                    mAbono += oRegPoliza.Abono;
                }
            }

            // Se validan que los movimientos den cero como resultado
            DateTime dAhora = DateTime.Now;
            bool bError = (mCargo != mAbono);
            /* if (bError)
            {
                // Se registra la diferencia y se sale, pues no coincide
                var oError = new ContaPolizaError()
                {
                    Fecha = dAhora,
                    ContaTipoPolizaID = oAfectacion.ContaTipoPolizaID,
                    Concepto = (sReferencia + " / " + sConcepto),
                    RealizoUsuarioID = Theos.UsuarioID,
                    SucursalID = iSucursalID,
                    Detalle = ""
                };
                foreach (var oReg in oPolizaDet)
                {
                    var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaAuxiliarID == oReg.ContaCuentaAuxiliarID);
                    oError.Detalle += string.Format("{0}\t{1}\t{2}\t{3}\n", oReg.ContaCuentaAuxiliarID, oCuentaAux.CuentaAuxiliar.RellenarCortarDerecha(32)
                        , oReg.Cargo.ToString(Util.FormatoMoneda), oReg.Abono.ToString(Util.FormatoMoneda));
                }
                Datos.Guardar<ContaPolizaError>(oError);
                // Se muestra un mensaje de error
                UtilLocal.MensajeAdvertencia(string.Format("Se encontró una diferencia al tratar de crear la Póliza Contable.\n\n\t\t\t\tCargo\tAbono\n{0}\t\t\t\t{1}\t{2}"
                    , oError.Detalle, mCargo.ToString(GlobalClass.FormatoMoneda), mAbono.ToString(GlobalClass.FormatoMoneda)));
                // Ya no se sale, se guarda la póliza y se marca como error
                // return;
            }
            */

            // Se genera la Póliza
            var oPoliza = new ContaPoliza()
            {
                Fecha = dAhora,
                ContaTipoPolizaID = oAfectacion.ContaTipoPolizaID,
                Concepto = (sReferencia + " / " + sConcepto),
                RealizoUsuarioID = Theos.UsuarioID,
                SucursalID = iSucursalID,
                RelacionTabla = ContaProc.ObtenerTablaDeAfectacion(iAfectacionID),
                RelacionID = iId,
                Origen = oAfectacion.Operacion,
                Error = bError
            };

            // Se guardan los datos
            Datos.Guardar<ContaPoliza>(oPoliza);
            foreach (var oReg in oPolizaDet)
            {
                oReg.ContaPolizaID = oPoliza.ContaPolizaID;
                Datos.Guardar<ContaPolizaDetalle>(oReg);
            }

            return oPoliza;
        }
Ejemplo n.º 8
0
        private void CrearPoliza(DataGridViewRow oFilaGasto)
        {
            decimal mImporte = Util.Decimal(oFilaGasto.Cells["Importe"].Value);
            var frmGastoPol = new GastoCajaAPoliza(mImporte);
            if (frmGastoPol.ShowDialog(Principal.Instance) == DialogResult.OK)
            {
                // Se llenan los datos del gasto
                int iEgresoID = Util.Entero(oFilaGasto.Cells["CajaEgresoID"].Value);
                var oGasto = Datos.GetEntity<CajaEgreso>(c => c.CajaEgresoID == iEgresoID && c.Estatus);
                oGasto.Facturado = frmGastoPol.Facturado;
                oGasto.FolioFactura = frmGastoPol.Folio;
                oGasto.FechaFactura = frmGastoPol.Fecha;
                oGasto.Subtotal = frmGastoPol.Subtotal;
                oGasto.Iva = frmGastoPol.Iva;
                Datos.Guardar<CajaEgreso>(oGasto);

                // Se manda crear la Póliza, si no es de Proveedores
                var oContaEgreso = Datos.GetEntity<ContaEgreso>(c => c.ContaEgresoID == oGasto.ContaEgresoID);
                if (oContaEgreso == null || !Datos.Exists<ContaCuentaAuxiliar>(c => c.ContaCuentaAuxiliarID == oContaEgreso.ContaCuentaAuxiliarID
                    && c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Proveedores))
                {
                    var oUsuario = Datos.GetEntity<Usuario>(c => c.UsuarioID == oGasto.RealizoUsuarioID && c.Estatus);

                    // Caso especial para reparto de utilidades
                    if (Datos.Exists<ContaCuentaAuxiliar>(c => c.ContaCuentaAuxiliarID == oContaEgreso.ContaCuentaAuxiliarID
                        && c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.ReparteDeUtilidades))
                    {
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.GastoReparteUtilidades, oGasto.CajaEgresoID, oUsuario.NombreUsuario, oGasto.Concepto
                            , oGasto.SucursalID, oGasto.Fecha);
                    }
                    else
                    {
                        if (oGasto.Facturado.Valor())
                        {
                            // Se manda a afectar contabilidad (AfeConta)
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.GastoCajaFacturado, iEgresoID, oGasto.FolioFactura, oGasto.Concepto
                                , oGasto.SucursalID, oGasto.Fecha);
                        }
                        else
                        {
                            // Se crea una póliza simple
                            var oPoliza = new ContaPoliza()
                            {
                                Fecha = oGasto.Fecha,
                                ContaTipoPolizaID = Cat.ContaTiposDePoliza.Egreso,
                                Concepto = oGasto.Concepto,
                                SucursalID = oGasto.SucursalID,
                                RelacionTabla = Cat.Tablas.CajaEgreso,
                                RelacionID = iEgresoID
                            };
                            ContaProc.CrearPoliza(oPoliza, Cat.ContaCuentasAuxiliares.GastosNoDeducibles, Cat.ContaCuentasAuxiliares.Caja, oGasto.Importe
                                , oUsuario.NombreUsuario);
                        }
                    }
                }

                // Se marca el gasto como afectado, y se guardan los datos
                oGasto.AfectadoEnPolizas = true;
                Datos.Guardar<CajaEgreso>(oGasto);

                this.LlenarGastos();
            }
            frmGastoPol.Dispose();
        }
Ejemplo n.º 9
0
        private bool AccionGuardar()
        {
            if (!this.Validar())
                return false;

            if (this.bDomingo)
                return this.GuardarDomingo();

            Cargando.Mostrar();

            // Se guarda la nómina
            int iBancoCuentaID = Util.Entero(this.cmbCuentaBancaria.SelectedValue);
            DateTime dAhora = DateTime.Now;
            DateTime dOficial = this.dtpOficial.Value;
            DateTime dComplementaria = this.dtpComplementaria.Value;
            string sDiaOficial = dOficial.ToString("yyMMdd");
            string sDiaComplementaria = dComplementaria.ToString("yyMMdd");
            DateTime dSemana = Util.FechaHora(this.cmbSemana.SelectedValue);
            bool bEsAguinaldo = (this.cmbSemana.Text == "AGUINALDO");
            var oNomina = new Nomina()
            {
                Semana = dSemana,
                Fecha = dAhora,
                BancoCuentaID = iBancoCuentaID,
                EsAguinaldo = bEsAguinaldo
            };
            Datos.Guardar<Nomina>(oNomina);

            // Se guarda el detalle
            decimal mTotalOficial = 0;
            foreach (DataGridViewRow oFila in this.dgvDatos.Rows)
            {
                if (!Util.Logico(oFila.Cells["Sel"].Value))
                    continue;

                int iUsuarioID = Util.Entero(oFila.Cells["UsuarioID"].Value);
                int iSucursalID = Util.Entero(oFila.Cells["SucursalID"].Value);
                // Se llenan los datos de la nómina oficial (dinámico)
                for (int iCol = this.iColumnasFijas; iCol < this.dgvDatos.Columns.Count; iCol++)
                {
                    var oNominaOfCuentaV = (this.dgvDatos.Columns[iCol].Tag as NominaOficialCuentasView);
                    var oNominaOf = new NominaUsuarioOficial()
                    {
                        NominaID = oNomina.NominaID,
                        IdUsuario = iUsuarioID,
                        ContaCuentaDeMayorID = oNominaOfCuentaV.ContaCuentaDeMayorID,
                        Importe = Util.Decimal(oFila.Cells[iCol].Value),
                        Suma = oNominaOfCuentaV.Suma
                    };
                    Datos.Guardar<NominaUsuarioOficial>(oNominaOf);
                }
                // Se guardan los datos no dinámicos
                var oNominaFijo = new NominaUsuario()
                {
                    NominaID = oNomina.NominaID,
                    IdUsuario = iUsuarioID,
                    SucursalID = Util.Entero(oFila.Cells["SucursalID"].Value),
                    SuperoMinimo = (oFila.Cells["SueldoMinimo"].Style.ForeColor == Color.Gray),
                    SueldoFijo = Util.Decimal(oFila.Cells["SueldoFijo"].Value),
                    SueldoVariable = Util.Decimal(oFila.Cells["SueldoVariable"].Value),
                    Sueldo9500 = Util.Decimal(oFila.Cells["Sueldo9500"].Value),
                    SueldoMinimo = Util.Decimal(oFila.Cells["SueldoMinimo"].Value),
                    Bono = Util.Decimal(oFila.Cells["Bono"].Value),
                    Adicional = Util.Decimal(oFila.Cells["Adicional"].Value),
                    Tickets = Util.Decimal(oFila.Cells["Tickets"].Value),
                    Adelanto = Util.Decimal(oFila.Cells["Adelanto"].Value),
                    MinutosTarde = Util.Decimal(oFila.Cells["MinutosTarde"].Value),
                    Otros = Util.Decimal(oFila.Cells["Otros"].Value)
                };
                Datos.Guardar<NominaUsuario>(oNominaFijo);

                // Se generan los gastos contables correspondientes, de lo oficial
                for (int iCol = this.iColumnasFijas; iCol < this.dgvDatos.Columns.Count; iCol++)
                {
                    decimal mImporte = Util.Decimal(oFila.Cells[iCol].Value);
                    var oNominaOfCuentaV = (this.dgvDatos.Columns[iCol].Tag as NominaOficialCuentasView);
                    int iCuentaDeMayorID = oNominaOfCuentaV.ContaCuentaDeMayorID;
                    var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == iCuentaDeMayorID && c.RelacionID == iUsuarioID);
                    if (oCuentaAux == null)
                        continue;
                    var oGasto = new ContaEgreso()
                    {
                        ContaCuentaAuxiliarID = oCuentaAux.ContaCuentaAuxiliarID,
                        Fecha = dOficial,
                        Importe = mImporte,
                        TipoFormaPagoID = Cat.FormasDePago.Transferencia,
                        FolioDePago = sDiaOficial,
                        TipoDocumentoID = Cat.TiposDeDocumento.Factura,
                        EsFiscal = true,
                        Observaciones = ("NÓMINA " + this.cmbSemana.Text),
                        SucursalID = iSucursalID,
                        RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID,
                        FolioFactura = sDiaOficial,
                        BancoCuentaID = iBancoCuentaID
                    };
                    ContaProc.GastoCrear(oGasto);
                }
                // Se genera el gasto contable por la diferencia, si aplica
                decimal mDiferencia = Util.Decimal(oFila.Cells["Diferencia"].Value);
                if (mDiferencia != 0)
                {
                    var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Salarios && c.RelacionID == iUsuarioID);
                    if (oCuentaAux != null)
                    {
                        var oGasto = new ContaEgreso()
                        {
                            ContaCuentaAuxiliarID = oCuentaAux.ContaCuentaAuxiliarID,
                            Fecha = dComplementaria,
                            Importe = mDiferencia,
                            TipoFormaPagoID = Cat.FormasDePago.Efectivo,
                            TipoDocumentoID = Cat.TiposDeDocumento.Nota,
                            EsFiscal = false,
                            Observaciones = ("CN " + this.cmbSemana.Text),
                            SucursalID = iSucursalID,
                            RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID,
                            FolioFactura = sDiaComplementaria,
                        };
                        ContaProc.GastoCrear(oGasto);
                    }
                }

                mTotalOficial += Util.Decimal(oFila.Cells["TotalOficial"].Value);
            }

            // Se genera el moviemiento bancario, con lo oficial
            var oMov = new BancoCuentaMovimiento()
            {
                BancoCuentaID = iBancoCuentaID,
                EsIngreso = false,
                Fecha = dOficial,
                FechaAsignado = dAhora,
                SucursalID = GlobalClass.SucursalID,
                Importe = mTotalOficial,
                Concepto = "NÓMINA BANCARIA",
                Referencia = GlobalClass.UsuarioGlobal.NombreUsuario,
                TipoFormaPagoID = Cat.FormasDePago.Transferencia,
                RelacionTabla = Cat.Tablas.Nomina,
                RelacionID = oNomina.NominaID
            };
            ContaProc.RegistrarMovimientoBancario(oMov);

            // Se generan las pólizas contables correspondientes (AfeConta)
            var oNominaUsuariosV = Datos.GetListOf<NominaUsuariosView>(c => c.NominaID == oNomina.NominaID);
            var oPolizaBase = new ContaPoliza()
            {
                ContaTipoPolizaID = Cat.ContaTiposDePoliza.Egreso,
                Fecha = dComplementaria,
                Concepto = "",
                RelacionTabla = Cat.Tablas.NominaUsuario,
                RelacionID = oNomina.NominaID
            };
            foreach (var oReg in oNominaUsuariosV)
            {
                // Se crea la póliza de lo oficial
                ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.NominaOficial, oReg.NominaUsuarioID, this.cmbSemana.Text, ("NÓMINA " + this.cmbSemana.Text)
                    , oReg.SucursalID, dOficial);
                // Se crea la póliza de la diferencia, si aplica
                if (oReg.Diferencia != 0)
                {
                    var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Salarios && c.RelacionID == oReg.UsuarioID);
                    if (oCuentaAux == null)
                    {
                        UtilLocal.MensajeAdvertencia("No se encontró la cuenta auxiliar: Salarios -> " + oReg.Usuario + ". No se creará la póliza de Complemento Nómina.");
                        continue;
                    }
                    var oPoliza = Util.CrearCopia<ContaPoliza>(oPolizaBase);
                    oPoliza.Concepto = ("COMPLEMENTO NÓMINA " + this.cmbSemana.Text);
                    ContaProc.CrearPoliza(oPoliza, oCuentaAux.ContaCuentaAuxiliarID, Cat.ContaCuentasAuxiliares.ReservaNomina, oReg.Diferencia.Valor(), oReg.Usuario
                        , oReg.SucursalID, Cat.Sucursales.Matriz);
                    /* ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, ("COMPLEMENTO NÓMINA " + this.cmbSemana.Text)
                        , oCuentaAux.ContaCuentaAuxiliarID, Cat.ContaCuentasAuxiliares.ReservaNomina, oReg.Diferencia.Valor(), oReg.Usuario
                        , Cat.Tablas.NominaUsuario, oReg.NominaID.Valor());
                    */
                }

                // Se crea la póliza del adelanto, si aplica
                if (oReg.Adelanto > 0)
                {
                    var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.DeudoresDiversos
                        && c.RelacionID == oReg.UsuarioID);
                    if (oCuentaAux != null)
                    {
                        // ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Ingreso, "ADELANTO", Cat.ContaCuentasAuxiliares.Caja, oCuentaAux.ContaCuentaAuxiliarID
                        //    , oReg.Adelanto, oReg.Usuario, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor(), oReg.SucursalID);
                        var oPoliza = Util.CrearCopia<ContaPoliza>(oPolizaBase);
                        oPoliza.ContaTipoPolizaID = Cat.ContaTiposDePoliza.Ingreso;
                        oPoliza.Concepto = "ADELANTO";
                        oPoliza.SucursalID = oReg.SucursalID;
                        ContaProc.CrearPoliza(oPoliza, Cat.ContaCuentasAuxiliares.Caja, oCuentaAux.ContaCuentaAuxiliarID, oReg.Adelanto, oReg.Usuario
                            , Cat.Sucursales.Matriz, oReg.SucursalID);

                        // Se crea adicionalmente, un ingreso de caja por el importe del adelanto
                        var oIngreso = new CajaIngreso()
                        {
                            CajaTipoIngresoID = Cat.CajaTiposDeIngreso.Otros,
                            Concepto = ("PAGO ADELANTO " + oReg.Usuario),
                            Importe = oReg.Adelanto,
                            Fecha = dAhora,
                            SucursalID = oReg.SucursalID,
                            RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID
                        };
                        Datos.Guardar<CajaIngreso>(oIngreso);
                    }
                }
                // Se crea la póliza de minutos tarde y otros, si aplica
                if (oReg.MinutosTarde > 0 || oReg.Otros > 0)
                {
                    var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Salarios
                        && c.RelacionID == oReg.UsuarioID);
                    if (oCuentaAux != null)
                    {
                        if (oReg.MinutosTarde > 0)
                        {
                            // ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, "MINUTOS TARDE", Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID
                            //     , oReg.MinutosTarde, oReg.Usuario, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor());
                            var oPoliza = Util.CrearCopia<ContaPoliza>(oPolizaBase);
                            oPoliza.Concepto = "MINUTOS TARDE";
                            ContaProc.CrearPoliza(oPoliza, Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID, oReg.MinutosTarde, oReg.Usuario
                                , Cat.Sucursales.Matriz, oReg.SucursalID);
                        }
                        if (oReg.Otros > 0)
                        {
                            // ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, "OTROS DESCUENTOS", Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID
                            //     , oReg.Otros, oReg.Usuario, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor());
                            var oPoliza = Util.CrearCopia<ContaPoliza>(oPolizaBase);
                            oPoliza.Concepto = "OTROS DESCUENTOS";
                            ContaProc.CrearPoliza(oPoliza, Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID, oReg.Otros, oReg.Usuario
                                , Cat.Sucursales.Matriz, oReg.SucursalID);
                        }
                    }
                }
            }

            // Se genera el resguardo y refuerzo especiales
            /* Este procedimiento hacía crecer el Resguardo, porque el dinero no se tomaba de ReservaNómina y se
             * mandaba a Resguardo cuando en realidad quedaba en el salario de los usuarios 17/11/2015
            var oResguardos = new Dictionary<int, decimal>();
            var oRefuerzos = new Dictionary<int, decimal>();
            foreach (DataGridViewRow oFila in this.dgvDatos.Rows)
            {
                if (!Util.ConvertirBool(oFila.Cells["Sel"].Value))
                    continue;

                int iSucursalID = Util.ConvertirEntero(oFila.Cells["SucursalID"].Value);
                if (!oResguardos.ContainsKey(iSucursalID))
                    oResguardos.Add(iSucursalID, 0);
                if (!oRefuerzos.ContainsKey(iSucursalID))
                    oRefuerzos.Add(iSucursalID, 0);

                decimal mDiferencia = Util.ConvertirDecimal(oFila.Cells["Diferencia"].Value);
                decimal mTickets = Util.ConvertirDecimal(oFila.Cells["Tickets"].Value);
                decimal mMinutosTarde = Util.ConvertirDecimal(oFila.Cells["MinutosTarde"].Value);
                decimal mOtros = Util.ConvertirDecimal(oFila.Cells["Otros"].Value);
                decimal mAdelanto = Util.ConvertirDecimal(oFila.Cells["Adelanto"].Value);
                oRefuerzos[iSucursalID] += (mDiferencia - mMinutosTarde - mOtros);
                // Se quita el adelanto a los resguardos de acuerdo a una nueva petición - Moi 03/08/2015
                // oResguardos[iSucursalID] += (mDiferencia - mMinutosTarde - mOtros + mAdelanto);
                // Se suman ahora los tickets a los resguardos porque no están seguros y están haciendo pruebas - Moi 08/08/2015
                oResguardos[iSucursalID] += (mDiferencia - mMinutosTarde - mOtros + mTickets);
            }
            // Se crean los resguardos / refuerzos y las pólizas correspondientes (AfeConta)
            foreach (var oReg in oResguardos)
            {
                var oResguardo = VentasProc.GenerarResguardo(oReg.Value, oReg.Key);
                ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.Resguardo, oResguardo.CajaEgresoID, "NO MOVER", "NO MOVER DE TIENDA / RESGUARDO", oReg.Key);
            }
            foreach (var oReg in oRefuerzos)
            {
                var oRefuerzo = VentasProc.GenerarRefuerzo(oReg.Value, oReg.Key);
                ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.Refuerzo, oRefuerzo.CajaIngresoID, "REFUERZO", "REFUERZO NÓMINA", oReg.Key);
            }
            */

            // Se manda a imprimir la nómina de cada usuario
            var oNominaUsuariosOfV = Datos.GetListOf<NominaUsuariosOficialView>(c => c.NominaID == oNomina.NominaID);
            var oNominaOficialTotales = oNominaUsuariosOfV.GroupBy(c => c.UsuarioID).Select(c => new
            {
                UsuarioID = c.Key,
                Ingreso = c.Where(s => s.Suma).Sum(s => s.Importe),
                Egreso = c.Where(s => !s.Suma).Sum(s => s.Importe)
            });
            var oRep = new Report();
            oRep.Load(UtilLocal.RutaReportes("Nomina.frx"));
            oRep.RegisterData(new List<Nomina>() { oNomina }, "Nomina");
            oRep.RegisterData(oNominaUsuariosV, "Usuarios");
            oRep.RegisterData(oNominaUsuariosOfV, "UsuariosOficial");
            oRep.RegisterData(oNominaOficialTotales, "UsuariosOficialTotales");

            Cargando.Cerrar();
            UtilLocal.EnviarReporteASalida("Reportes.Nomina.Salida", oRep);

            this.LlenarNomina();
            return true;
        }
Ejemplo n.º 10
0
        private bool AccionGuardar()
        {
            if (!this.Validar())
            {
                return(false);
            }

            Cargando.Mostrar();

            // Se obtiene la póliza
            ContaPoliza oPoliza;

            if (this.iPolizaID > 0)
            {
                oPoliza = Datos.GetEntity <ContaPoliza>(c => c.ContaPolizaID == iPolizaID);
            }
            else
            {
                oPoliza = new ContaPoliza()
                {
                    SucursalID = GlobalClass.SucursalID, RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID, FueManual = true
                }
            };

            // Se guarda la póliza
            oPoliza.Fecha             = this.dtpFecha.Value;
            oPoliza.ContaTipoPolizaID = Util.Entero(this.cmbTipoPoliza.SelectedValue);
            oPoliza.Concepto          = this.txtConcepto.Text;
            oPoliza.Origen            = this.txtOrigen.Text;
            oPoliza.Error             = false;
            Datos.Guardar <ContaPoliza>(oPoliza);

            // Se procede a guardar el detalle
            ContaPolizaDetalle oReg = null;

            foreach (DataGridViewRow oFila in this.dgvDetalle.Rows)
            {
                if (oFila.IsNewRow)
                {
                    continue;
                }

                int iCuentaAuxID = Util.Entero(oFila.Cells["ContaCuentaAuxiliarID"].Value);
                int iId          = this.dgvDetalle.ObtenerId(oFila);
                int iCambio      = this.dgvDetalle.ObtenerIdCambio(oFila);
                switch (iCambio)
                {
                case Cat.TiposDeAfectacion.Agregar:
                case Cat.TiposDeAfectacion.Modificar:
                    if (iCambio == Cat.TiposDeAfectacion.Agregar)
                    {
                        oReg = new ContaPolizaDetalle()
                        {
                            ContaPolizaID = oPoliza.ContaPolizaID
                        }
                    }
                    ;
                    else
                    {
                        oReg = Datos.GetEntity <ContaPolizaDetalle>(c => c.ContaPolizaDetalleID == iId);
                    }

                    oReg.ContaCuentaAuxiliarID = iCuentaAuxID;
                    oReg.Cargo      = Util.Decimal(oFila.Cells["Cargo"].Value);
                    oReg.Abono      = Util.Decimal(oFila.Cells["Abono"].Value);
                    oReg.Referencia = Util.Cadena(oFila.Cells["Referencia"].Value);
                    oReg.SucursalID = Util.Entero(oFila.Cells["SucursalID"].Value);

                    Datos.Guardar <ContaPolizaDetalle>(oReg);
                    break;

                case Cat.TiposDeAfectacion.Borrar:
                    oReg = Datos.GetEntity <ContaPolizaDetalle>(c => c.ContaPolizaDetalleID == iId);
                    Datos.Eliminar <ContaPolizaDetalle>(oReg);
                    break;
                }

                // Se verifica si se afecta una cuenta bancaria, en cuyo caso, se crea un movimiento bancario
                if (iCambio == Cat.TiposDeAfectacion.Agregar)
                {
                    var oCuentaAux = Datos.GetEntity <ContaCuentaAuxiliar>(c => c.ContaCuentaAuxiliarID == iCuentaAuxID);
                    if ((oCuentaAux.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Bancos || oCuentaAux.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.CuentasPorPagarCortoPlazo) &&
                        oCuentaAux.RelacionID.HasValue)
                    {
                        var oMovBanc = new BancoCuentaMovimiento()
                        {
                            BancoCuentaID   = oCuentaAux.RelacionID.Valor(),
                            EsIngreso       = (oReg.Cargo > 0),
                            Fecha           = oPoliza.Fecha,
                            FechaAsignado   = oPoliza.Fecha,
                            SucursalID      = oPoliza.SucursalID,
                            Importe         = (oReg.Cargo > 0 ? oReg.Cargo : oReg.Abono),
                            Concepto        = oPoliza.Concepto,
                            Referencia      = oReg.Referencia,
                            TipoFormaPagoID = Cat.FormasDePago.Efectivo,
                            RelacionID      = oReg.ContaPolizaDetalleID
                        };
                        ContaProc.RegistrarMovimientoBancario(oMovBanc);
                    }
                }
            }

            Cargando.Cerrar();
            return(true);
        }
Ejemplo n.º 11
0
        private void CrearPoliza(DataGridViewRow oFilaGasto)
        {
            decimal mImporte    = Util.Decimal(oFilaGasto.Cells["Importe"].Value);
            var     frmGastoPol = new GastoCajaAPoliza(mImporte);

            if (frmGastoPol.ShowDialog(Principal.Instance) == DialogResult.OK)
            {
                // Se llenan los datos del gasto
                int iEgresoID = Util.Entero(oFilaGasto.Cells["CajaEgresoID"].Value);
                var oGasto    = Datos.GetEntity <CajaEgreso>(c => c.CajaEgresoID == iEgresoID && c.Estatus);
                oGasto.Facturado    = frmGastoPol.Facturado;
                oGasto.FolioFactura = frmGastoPol.Folio;
                oGasto.FechaFactura = frmGastoPol.Fecha;
                oGasto.Subtotal     = frmGastoPol.Subtotal;
                oGasto.Iva          = frmGastoPol.Iva;
                Datos.Guardar <CajaEgreso>(oGasto);

                // Se manda crear la Póliza, si no es de Proveedores
                var oContaEgreso = Datos.GetEntity <ContaEgreso>(c => c.ContaEgresoID == oGasto.ContaEgresoID);
                if (oContaEgreso == null || !Datos.Exists <ContaCuentaAuxiliar>(c => c.ContaCuentaAuxiliarID == oContaEgreso.ContaCuentaAuxiliarID &&
                                                                                c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Proveedores))
                {
                    var oUsuario = Datos.GetEntity <Usuario>(c => c.UsuarioID == oGasto.RealizoUsuarioID && c.Estatus);

                    // Caso especial para reparto de utilidades
                    if (Datos.Exists <ContaCuentaAuxiliar>(c => c.ContaCuentaAuxiliarID == oContaEgreso.ContaCuentaAuxiliarID &&
                                                           c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.ReparteDeUtilidades))
                    {
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.GastoReparteUtilidades, oGasto.CajaEgresoID, oUsuario.NombreUsuario, oGasto.Concepto
                                                        , oGasto.SucursalID, oGasto.Fecha);
                    }
                    else
                    {
                        if (oGasto.Facturado.Valor())
                        {
                            // Se manda a afectar contabilidad (AfeConta)
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.GastoCajaFacturado, iEgresoID, oGasto.FolioFactura, oGasto.Concepto
                                                            , oGasto.SucursalID, oGasto.Fecha);
                        }
                        else
                        {
                            // Se crea una póliza simple
                            var oPoliza = new ContaPoliza()
                            {
                                Fecha             = oGasto.Fecha,
                                ContaTipoPolizaID = Cat.ContaTiposDePoliza.Egreso,
                                Concepto          = oGasto.Concepto,
                                SucursalID        = oGasto.SucursalID,
                                RelacionTabla     = Cat.Tablas.CajaEgreso,
                                RelacionID        = iEgresoID
                            };
                            ContaProc.CrearPoliza(oPoliza, Cat.ContaCuentasAuxiliares.GastosNoDeducibles, Cat.ContaCuentasAuxiliares.Caja, oGasto.Importe
                                                  , oUsuario.NombreUsuario);
                        }
                    }
                }

                // Se marca el gasto como afectado, y se guardan los datos
                oGasto.AfectadoEnPolizas = true;
                Datos.Guardar <CajaEgreso>(oGasto);

                this.LlenarGastos();
            }
            frmGastoPol.Dispose();
        }