示例#1
0
        private bool AccionGuardar()
        {
            if (!this.Validar())
            {
                return(false);
            }

            Cargando.Mostrar();

            // Se crea el movimiento bancario
            DateTime dFecha   = this.dtpFechaMovimiento.Value;
            var      oMovBanc = new BancoCuentaMovimiento()
            {
                BancoCuentaID   = this.OrigenBancoCuentaID,
                EsIngreso       = true,
                Fecha           = dFecha,
                FechaAsignado   = dFecha,
                SucursalID      = GlobalClass.SucursalID,
                Importe         = Util.Decimal(this.txtImporte.Text),
                Concepto        = this.txtConcepto.Text,
                Referencia      = GlobalClass.UsuarioGlobal.NombreUsuario,
                TipoFormaPagoID = Cat.FormasDePago.Efectivo
            };

            ContaProc.RegistrarMovimientoBancario(oMovBanc);

            // Se crea la póliza correspondiente (AfeConta)
            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DepositoBancario, oMovBanc.BancoCuentaMovimientoID
                                            , oMovBanc.Referencia, oMovBanc.Concepto, oMovBanc.Fecha);

            Cargando.Cerrar();

            return(true);
        }
示例#2
0
        protected override bool AccionGuardar()
        {
            if (!this.Validar())
                return false;

            Cargando.Mostrar();

            // Se crea el movimiento bancario
            DateTime dFecha = DateTime.Now;  // Se toma la fecha de hoy
            var oMovBanc = new BancoCuentaMovimiento()
            {
                BancoCuentaID = this.OrigenBancoCuentaID,
                EsIngreso = true,
                Fecha = dFecha,
                FechaAsignado = dFecha,
                SucursalID = GlobalClass.SucursalID,
                Importe = Helper.ConvertirDecimal(this.txtImporte.Text),
                Concepto = this.txtConcepto.Text,
                Referencia = GlobalClass.UsuarioGlobal.NombreUsuario,
                TipoFormaPagoID = Cat.FormasDePago.Efectivo
            };
            ContaProc.RegistrarMovimientoBancario(oMovBanc);

            // Se crea la póliza correspondiente (AfeConta)
            var oPoliza = ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DepositoBancario, oMovBanc.BancoCuentaMovimientoID, oMovBanc.Referencia, oMovBanc.Concepto);
            oPoliza.Fecha = oMovBanc.Fecha;
            Guardar.Generico<ContaPoliza>(oPoliza);

            Cargando.Cerrar();

            return true;
        }
示例#3
0
        private bool AccionGuardar()
        {
            if (!this.Validar())
                return false;

            Cargando.Mostrar();

            // Se crea el movimiento bancario
            DateTime dFecha = this.dtpFechaMovimiento.Value;
            var oMovBanc = new BancoCuentaMovimiento()
            {
                BancoCuentaID = this.OrigenBancoCuentaID,
                EsIngreso = true,
                Fecha = dFecha,
                FechaAsignado = dFecha,
                SucursalID = GlobalClass.SucursalID,
                Importe = Util.Decimal(this.txtImporte.Text),
                Concepto = this.txtConcepto.Text,
                Referencia = GlobalClass.UsuarioGlobal.NombreUsuario,
                TipoFormaPagoID = Cat.FormasDePago.Efectivo
            };
            ContaProc.RegistrarMovimientoBancario(oMovBanc);

            // Se crea la póliza correspondiente (AfeConta)
            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DepositoBancario, oMovBanc.BancoCuentaMovimientoID
                , oMovBanc.Referencia, oMovBanc.Concepto, oMovBanc.Fecha);

            Cargando.Cerrar();

            return true;
        }
示例#4
0
        private void AgregarMovimiento()
        {
            var frmMov = new MovimientoBancarioGen()
            {
                Text = "Agregar movimiento"
            };

            frmMov.LlenarComboCuenta();
            frmMov.cmbBancoCuenta.SelectedValue = this.ConBancoCuentaID;
            frmMov.lblEtImporteInfo.Visible     = false;
            frmMov.lblImporteInfo.Visible       = false;
            frmMov.ActiveControl = frmMov.txtImporte;
            // Para validar los datos
            frmMov.delValidar += () =>
            {
                frmMov.ctlError.LimpiarErrores();
                if (frmMov.BancoCuentaID <= 0)
                {
                    frmMov.ctlError.PonerError(frmMov.cmbBancoCuenta, "Debes especificar una cuenta.");
                }
                if (frmMov.Importe == 0)
                {
                    frmMov.ctlError.PonerError(frmMov.txtImporte, "El importe especificado es inválido.");
                }
                if (frmMov.txtConcepto.Text == "")
                {
                    frmMov.ctlError.PonerError(frmMov.txtConcepto, "Debes especificar un concepto.", ErrorIconAlignment.BottomLeft);
                }
                return(frmMov.ctlError.Valido);
            };
            if (frmMov.ShowDialog(Principal.Instance) == DialogResult.OK)
            {
                Cargando.Mostrar();

                // Se crea el movimiento bancario
                var oMov = new BancoCuentaMovimiento
                {
                    BancoCuentaID = frmMov.BancoCuentaID,
                    EsIngreso     = (frmMov.Importe >= 0),
                    Fecha         = frmMov.dtpFecha.Value,
                    FechaAsignado = frmMov.dtpFecha.Value,
                    SucursalID    = GlobalClass.SucursalID,
                    Importe       = (frmMov.Importe > 0 ? frmMov.Importe : (frmMov.Importe * -1)),
                    Concepto      = frmMov.txtConcepto.Text,
                    Referencia    = GlobalClass.UsuarioGlobal.NombreUsuario,
                    FueManual     = true
                };
                ContaProc.RegistrarMovimientoBancario(oMov);

                Cargando.Cerrar();
                this.LlenarConciliaciones();
            }
            frmMov.Dispose();
        }
示例#5
0
        private void AgregarMovimiento()
        {
            var frmMov = new MovimientoBancarioGen() { Text = "Agregar movimiento" };
            frmMov.LlenarComboCuenta();
            frmMov.cmbBancoCuenta.SelectedValue = this.ConBancoCuentaID;
            frmMov.lblEtImporteInfo.Visible = false;
            frmMov.lblImporteInfo.Visible = false;
            frmMov.ActiveControl = frmMov.txtImporte;
            // Para validar los datos
            frmMov.delValidar += () =>
            {
                frmMov.ctlError.LimpiarErrores();
                if (frmMov.BancoCuentaID <= 0)
                    frmMov.ctlError.PonerError(frmMov.cmbBancoCuenta, "Debes especificar una cuenta.");
                if (frmMov.Importe == 0)
                    frmMov.ctlError.PonerError(frmMov.txtImporte, "El importe especificado es inválido.");
                if (frmMov.txtConcepto.Text == "")
                    frmMov.ctlError.PonerError(frmMov.txtConcepto, "Debes especificar un concepto.", ErrorIconAlignment.BottomLeft);
                return frmMov.ctlError.Valido;
            };
            if (frmMov.ShowDialog(Principal.Instance) == DialogResult.OK)
            {
                Cargando.Mostrar();

                // Se crea el movimiento bancario
                var oMov = new BancoCuentaMovimiento
                {
                    BancoCuentaID = frmMov.BancoCuentaID,
                    EsIngreso = (frmMov.Importe >= 0),
                    Fecha = frmMov.dtpFecha.Value,
                    FechaAsignado = frmMov.dtpFecha.Value,
                    SucursalID = GlobalClass.SucursalID,
                    Importe = (frmMov.Importe > 0 ? frmMov.Importe : (frmMov.Importe * -1)),
                    Concepto = frmMov.txtConcepto.Text,
                    Referencia = GlobalClass.UsuarioGlobal.NombreUsuario,
                    FueManual = true
                };
                ContaProc.RegistrarMovimientoBancario(oMov);

                Cargando.Cerrar();
                this.LlenarConciliaciones();
            }
            frmMov.Dispose();
        }
示例#6
0
        protected override bool AccionGuardar()
        {
            if (!this.Validar())
            {
                return(false);
            }

            Cargando.Mostrar();

            // Se crea el movimiento bancario
            DateTime dFecha   = DateTime.Now; // Se toma la fecha de hoy
            var      oMovBanc = new BancoCuentaMovimiento()
            {
                BancoCuentaID   = this.OrigenBancoCuentaID,
                EsIngreso       = true,
                Fecha           = dFecha,
                FechaAsignado   = dFecha,
                SucursalID      = GlobalClass.SucursalID,
                Importe         = Helper.ConvertirDecimal(this.txtImporte.Text),
                Concepto        = this.txtConcepto.Text,
                Referencia      = GlobalClass.UsuarioGlobal.NombreUsuario,
                TipoFormaPagoID = Cat.FormasDePago.Efectivo
            };

            ContaProc.RegistrarMovimientoBancario(oMovBanc);

            // Se crea la póliza correspondiente (AfeConta)
            var oPoliza = ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DepositoBancario, oMovBanc.BancoCuentaMovimientoID, oMovBanc.Referencia, oMovBanc.Concepto);

            oPoliza.Fecha = oMovBanc.Fecha;
            Guardar.Generico <ContaPoliza>(oPoliza);

            Cargando.Cerrar();

            return(true);
        }
示例#7
0
        public bool AccionGuardar()
        {
            // Se valida
            if (!this.Validar())
            {
                return(false);
            }

            Cargando.Mostrar();

            // Se guardan los datos
            // DateTime dAhora = DateTime.Now;
            int?iDocID = Util.Entero(this.cmbDocumento.SelectedValue);
            // Se guarda el gasto
            ContaEgreso oGasto = (this.EsMod ? this.oEgreso : new ContaEgreso());

            oGasto.ContaCuentaAuxiliarID = Util.Entero(this.cmbCuentaAuxiliar.SelectedValue);
            oGasto.Fecha            = this.dtpFecha.Value;
            oGasto.Importe          = Util.Decimal(this.txtImporte.Text);
            oGasto.TipoFormaPagoID  = Util.Entero(this.cmbFormaDePago.SelectedValue);
            oGasto.FolioDePago      = this.txtFolioDePago.Text;
            oGasto.FolioFactura     = this.txtFolioFactura.Text;
            oGasto.BancoCuentaID    = (int?)this.cmbCuentaBancaria.SelectedValue;
            oGasto.TipoDocumentoID  = (iDocID > 0 ? iDocID : null);
            oGasto.EsFiscal         = this.chkEsFiscal.Checked;
            oGasto.Observaciones    = this.txtObservaciones.Text;
            oGasto.RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID;
            oGasto.SucursalID       = GlobalClass.SucursalID;
            Datos.Guardar <ContaEgreso>(oGasto);
            // Se guarda el detalle, si aplica
            foreach (DataGridViewRow Fila in this.dgvDetalle.Rows)
            {
                if (Fila.IsNewRow)
                {
                    continue;
                }

                int iCambioID = Util.Entero(Fila.Cells["_Cambio"].Value);
                if (iCambioID == Cat.TiposDeAfectacion.SinCambios)
                {
                    continue;
                }

                ContaEgresoDetalle oGastoDet;
                if (iCambioID == Cat.TiposDeAfectacion.Agregar)
                {
                    oGastoDet = new ContaEgresoDetalle();
                    oGastoDet.ContaEgresoID = oGasto.ContaEgresoID;
                }
                else
                {
                    oGastoDet = (Fila.Tag as ContaEgresoDetalle);
                    if (iCambioID == Cat.TiposDeAfectacion.Borrar)
                    {
                        Datos.Eliminar <ContaEgresoDetalle>(oGastoDet, true);
                        continue;
                    }
                }
                oGastoDet.ContaConsumibleID = Util.Entero(Fila.Cells["ContaConsumibleID"].Value);
                oGastoDet.Cantidad          = Util.Decimal(Fila.Cells["Cantidad"].Value);
                oGastoDet.Importe           = Util.Decimal(Fila.Cells["Precio"].Value);
                Datos.Guardar <ContaEgresoDetalle>(oGastoDet);
            }
            // Se manda devengar automáticamente, si aplica
            ContaProc.GastoVerDevengarAutomaticamente(oGasto);

            // Se ejecutan procesos para gastos nuevos únicamente
            if (!this.EsMod)
            {
                // Se crean la pólizas contable correspondientes (AfeConta),
                ContaProc.CrearPolizasDeGastoContable(oGasto);

                // Se crea el movimiento bancario correspondiente, si aplica
                // Como se afecta la cuenta de bancos, se crea el movimiento bancario para mandarlo a conciliación y así llevar el control de todos los
                // movimientos bancarios
                if (oGasto.TipoFormaPagoID == Cat.FormasDePago.Cheque || oGasto.TipoFormaPagoID == Cat.FormasDePago.Tarjeta ||
                    oGasto.TipoFormaPagoID == Cat.FormasDePago.Transferencia)
                {
                    var oMovBanc = new BancoCuentaMovimiento()
                    {
                        BancoCuentaID   = oGasto.BancoCuentaID,
                        EsIngreso       = false,
                        Fecha           = oGasto.Fecha,
                        FechaAsignado   = oGasto.Fecha,
                        SucursalID      = oGasto.SucursalID,
                        Importe         = oGasto.Importe,
                        Concepto        = oGasto.Observaciones,
                        Referencia      = oGasto.FolioFactura,
                        TipoFormaPagoID = oGasto.TipoFormaPagoID,
                        RelacionTabla   = Cat.Tablas.ContaEgreso,
                        RelacionID      = oGasto.ContaEgresoID
                    };
                    ContaProc.RegistrarMovimientoBancario(oMovBanc);
                }
            }

            Cargando.Cerrar();

            // Se muestra una notificación
            this.RestaurarControles();
            UtilLocal.MostrarNotificacion("Proceso completado correctamente.");

            return(true);
        }
示例#8
0
        private bool AccionGuardar()
        {
            if (!this.Validaciones() || !this.ValidarTotales())
                return false;

            // Se manda guardar la información
            if (!this.SoloGuardar(false))
                return false;

            //
            DateTime dPago = this.dtpFechaMovimiento.Value;
            int iCuentaID = Util.Entero(this.cmbCuentaBancaria.SelectedValue);
            int iFormaDePagoID = Util.Entero(this.cboFormaPago.SelectedValue);
            string sFolioDePago = this.txtDocumento.Text;

            // Se marcan los abonos como ya pagados
            int iPolizaNuevaID = 0, iPolizaAntID = 0, iPolizaGeneralID = 0;
            var oPolizaDetalle = new List<ProveedorPolizaDetalle>();
            var oIdsPagosDeCaja = new List<int>();
            decimal mImportePago = 0;
            foreach (DataGridViewRow oFila in this.dgvAbonos.Rows)
            {
                int iAbonoID = Util.Entero(oFila.Cells["abo_ProveedorPolizaDetalleID"].Value);
                var oAbono = Datos.GetEntity<ProveedorPolizaDetalle>(c => c.ProveedorPolizaDetalleID == iAbonoID && c.Estatus);

                if (oAbono.OrigenID == Cat.OrigenesPagosAProveedores.PagoDirecto)
                {
                    // Se marca el primer pago directo que se encuentre como principal
                    if (Util.Logico(oFila.Cells["abo_EsNuevo"].Value))
                    {
                        if (iPolizaNuevaID == 0)
                            iPolizaNuevaID = oAbono.ProveedorPolizaID;
                    }
                    else
                    {
                        if (iPolizaAntID == 0)
                            iPolizaAntID = oAbono.ProveedorPolizaID;
                    }

                    //
                    mImportePago += (oAbono.Subtotal + oAbono.Iva);
                    oAbono.TipoFormaPagoID = iFormaDePagoID;
                    oAbono.Folio = sFolioDePago;
                    oAbono.BancoCuentaID = iCuentaID;
                }
                if (iPolizaGeneralID == 0)
                    iPolizaGeneralID = oAbono.ProveedorPolizaID;

                // Se guarda si es un pago de caja, para uso posterior al hacer las pólizas
                if (oAbono.OrigenID == Cat.OrigenesPagosAProveedores.PagoDeCaja)
                    oIdsPagosDeCaja.Add(oAbono.CajaEgresoID.Valor());

                // Se guarda
                oAbono.FechaPago = dPago;
                oAbono.Pagado = true;
                Datos.Guardar<ProveedorPolizaDetalle>(oAbono);
                oPolizaDetalle.Add(oAbono);
            }
            int iPolizaID = (iPolizaNuevaID > 0 ? iPolizaNuevaID : iPolizaAntID);
            iPolizaID = (iPolizaID > 0 ? iPolizaID : iPolizaGeneralID);
            var poliza = Datos.GetEntity<ProveedorPoliza>(c => c.ProveedorPolizaID == iPolizaID && c.Estatus);

            // Se guarda el movimiento bancario
            if (mImportePago > 0)
            {
                var oProveedor = Datos.GetEntity<Proveedor>(c => c.ProveedorID == ProveedorId && c.Estatus);
                var oMovBanc = new BancoCuentaMovimiento()
                {
                    BancoCuentaID = Util.Entero(this.cmbCuentaBancaria.SelectedValue),
                    EsIngreso = false,
                    Fecha = poliza.FechaPago,
                    FechaAsignado = poliza.FechaPago,
                    Importe = mImportePago,
                    Concepto = oProveedor.NombreProveedor,
                    Referencia = iPolizaID.ToString(),
                    TipoFormaPagoID = iFormaDePagoID,
                    DatosDePago = sFolioDePago,
                    RelacionID = iPolizaID
                };
                ContaProc.RegistrarMovimientoBancario(oMovBanc);
            }

            // Se manda a afectar contabilidad (AfeConta)
            foreach (var oReg in oPolizaDetalle)
            {
                var oMovInv = Datos.GetEntity<MovimientoInventario>(c => c.MovimientoInventarioID == oReg.MovimientoInventarioID && c.Estatus);
                switch (oReg.OrigenID)
                {
                    case Cat.OrigenesPagosAProveedores.NotaDeCredito:
                        int iNotaDeCreditoID = oReg.NotaDeCreditoID.Valor();
                        var oNota = Datos.GetEntity<ProveedorNotaDeCredito>(c => c.ProveedorNotaDeCreditoID == iNotaDeCreditoID);
                        if (oNota.OrigenID == Cat.OrigenesNotasDeCreditoProveedor.Garantia)
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoCompraCreditoNotaDeCreditoGarantia, oReg.ProveedorPolizaDetalleID
                                , oNota.Folio, ("GARANTÍA / " + oMovInv.FolioFactura), poliza.FechaPago);
                        else if (oNota.OrigenID == Cat.OrigenesNotasDeCreditoProveedor.Devolucion)
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoCompraCreditoNotaDeCreditoDevolucion, oReg.ProveedorPolizaDetalleID
                                , oNota.Folio, ("DEVOLUCIÓN / " + oMovInv.FolioFactura), poliza.FechaPago);
                        break;
                    case Cat.OrigenesPagosAProveedores.DescuentoFactura:
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoCompraCreditoDescuentoFactura, oReg.ProveedorPolizaDetalleID
                            , oMovInv.FolioFactura, "DESCUENTO FACTURA", poliza.FechaPago);
                        break;
                    case Cat.OrigenesPagosAProveedores.DescuentoDirecto:
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoCompraCreditoDescuentoDirecto, oReg.ProveedorPolizaDetalleID
                            , oMovInv.FolioFactura, "DESCUENTO DIRECTO", poliza.FechaPago);
                        break;
                    case Cat.OrigenesPagosAProveedores.PagoDeCaja:
                        int iGastoID = oIdsPagosDeCaja[0];
                        oIdsPagosDeCaja.RemoveAt(0);
                        var oGasto = Datos.GetEntity<CajaEgreso>(c => c.CajaEgresoID == iGastoID && c.Estatus);
                        if (oGasto.Facturado.Valor())
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoCompraCreditoGastoCajaFacturado, oReg.ProveedorPolizaDetalleID
                                , oGasto.FolioFactura, oGasto.Concepto, oGasto.SucursalID, poliza.FechaPago);
                        else
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoCompraCreditoGastoCaja, oReg.ProveedorPolizaDetalleID
                                , "PAGO CAJA", oGasto.Concepto, oGasto.SucursalID, poliza.FechaPago);
                        break;
                    case Cat.OrigenesPagosAProveedores.PagoDirecto:
                        if (oReg.BancoCuentaID == Cat.CuentasBancarias.Banamex || oReg.BancoCuentaID == Cat.CuentasBancarias.Scotiabank)
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoCompraCredito, oReg.ProveedorPolizaDetalleID, this.txtDocumento.Text
                                , ("PAGO DIRECTO / " + this.cmbCuentaBancaria.Text), poliza.FechaPago);
                        else
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoProveedorDirectoCpcp, oReg.ProveedorPolizaDetalleID, this.txtDocumento.Text
                                , ("PAGO DIRECTO / " + this.cmbCuentaBancaria.Text), poliza.FechaPago);
                        break;
                }
            }
            //

            Cargando.Cerrar();

            // Se manda imprimir el reporte,
            var resp = UtilLocal.MensajePregunta("Guardado exitosamente. ¿Deseas ver el reporte?");
            if (resp == DialogResult.Yes)
                this.MostrarReporte(poliza.ProveedorPolizaID);

            return true;
        }
示例#9
0
        private void AgruparMovimientos()
        {
            // Se obtienen los movimientos marcados
            var oMovsIds = new List<int>();
            decimal mDeposito = 0, mRetiro = 0;
            foreach (DataGridViewRow oFila in this.dgvConciliacion.Rows)
            {
                if (!Util.Logico(oFila.Cells["con_Sel"].Value))
                    continue;
                mDeposito += Util.Decimal(oFila.Cells["con_Depositos"].Value);
                mRetiro += Util.Decimal(oFila.Cells["con_Retiros"].Value);
                oMovsIds.Add(Util.Entero(oFila.Cells["con_BancoCuentaMovimientoID"].Value));
            }

            // Se valida que haya movimientos o importe
            if ((mDeposito + mRetiro) == 0)
            {
                UtilLocal.MensajeAdvertencia("No hay ningún movimiento seleccionado o el importe es igual a cero.");
                return;
            }
            // Se valida que sean puros depósitos o puros retiros
            if (mDeposito > 0 && mRetiro > 0)
            {
                UtilLocal.MensajeAdvertencia("No es posible agrupar movimientos de tipo depósito con movimientos de tipo retiro.");
                return;
            }

            // Se abre forma para guardar los datos
            var frmDatos = new AgruparMovimientosBancarios();
            frmDatos.Deposito = (mDeposito > 0);
            frmDatos.Importe = (mDeposito + mRetiro);
            // Se llenan los datos con el primer movimiento seleccionado
            int iPrimerMovID = oMovsIds[0];
            var oPrimerMov = Datos.GetEntity<BancoCuentaMovimiento>(c => c.BancoCuentaMovimientoID == iPrimerMovID);
            frmDatos.Fecha = oPrimerMov.FechaAsignado.Valor();
            frmDatos.SucursalID = oPrimerMov.SucursalID;
            frmDatos.Concepto = oPrimerMov.Concepto;
            frmDatos.Referencia = oPrimerMov.Referencia;
            // Se muestra el formulario
            if (frmDatos.ShowDialog(Principal.Instance) == DialogResult.OK)
            {
                Cargando.Mostrar();
                // Se obtienen los movimientos a agrupar
                var oMovs = new List<BancoCuentaMovimiento>();
                foreach (int iModID in oMovsIds)
                    oMovs.Add(Datos.GetEntity<BancoCuentaMovimiento>(c => c.BancoCuentaMovimientoID == iModID));
                // Se genera y guarda el movimiento agrupador
                var oMovAgrupador = new BancoCuentaMovimiento()
                {
                    BancoCuentaID = oPrimerMov.BancoCuentaID,
                    EsIngreso = (mDeposito > 0),
                    Fecha = DateTime.Now,
                    FechaAsignado = frmDatos.Fecha,
                    SucursalID = frmDatos.SucursalID,
                    Importe = oMovs.Sum(c => c.Importe),
                    Concepto = frmDatos.Concepto,
                    Referencia = frmDatos.Referencia,
                    SaldoAcumulado = oMovs.OrderBy(c=> c.FechaAsignado).Last().SaldoAcumulado
                };
                Datos.Guardar<BancoCuentaMovimiento>(oMovAgrupador);
                // Se agrupan los movimientos
                foreach (var oMov in oMovs)
                {
                    oMov.MovimientoAgrupadorID = oMovAgrupador.BancoCuentaMovimientoID;
                    Datos.Guardar<BancoCuentaMovimiento>(oMov);
                }
                // Se recalcula el acumulado
                this.RecalcularAcumulado(oMovAgrupador.FechaAsignado.Valor());
                //
                Cargando.Cerrar();
                this.LlenarConciliaciones();
            }
            frmDatos.Dispose();
        }
示例#10
0
        private void HacerTraspaso()
        {
            var frmTraspaso = new MovimientoBancarioGen() { OrigenBancoCuentaID = this.ConBancoCuentaID, Text = "Traspaso entre cuentas" };
            frmTraspaso.LlenarComboCuenta();
            frmTraspaso.lblImporteInfo.Text = this.lblSaldoOperacion.Text;
            frmTraspaso.txtConcepto.Text = "Traspaso entre cuentas";
            // Para concatenar la cuenta destino
            frmTraspaso.cmbBancoCuenta.SelectedIndexChanged += new EventHandler((s, e) =>
            {
                frmTraspaso.txtConcepto.Text = ("Traspaso entre cuentas - " + frmTraspaso.cmbBancoCuenta.Text);
            });
            // Para validar los datos
            frmTraspaso.delValidar += () => {
                frmTraspaso.ctlError.LimpiarErrores();
                if (frmTraspaso.BancoCuentaID <= 0)
                    frmTraspaso.ctlError.PonerError(frmTraspaso.cmbBancoCuenta, "Debes especificar una cuenta.");
                if (frmTraspaso.Importe == 0)
                    frmTraspaso.ctlError.PonerError(frmTraspaso.txtImporte, "El importe especificado es inválido.");
                return frmTraspaso.ctlError.Valido;
            };
            if (frmTraspaso.ShowDialog(Principal.Instance) == DialogResult.OK)
            {
                Cargando.Mostrar();

                // Se crea el retiro de la cuenta origen
                var oMovOrigen = new BancoCuentaMovimiento
                {
                    BancoCuentaID = this.ConBancoCuentaID,
                    EsIngreso = false,
                    Fecha = frmTraspaso.dtpFecha.Value,
                    FechaAsignado = frmTraspaso.dtpFecha.Value,
                    SucursalID = GlobalClass.SucursalID,
                    Importe = frmTraspaso.Importe,
                    Concepto = frmTraspaso.txtConcepto.Text,
                    Referencia = GlobalClass.UsuarioGlobal.NombreUsuario
                };
                ContaProc.RegistrarMovimientoBancario(oMovOrigen);
                // Se crea el depósito a la cuenta destino
                var oMovDestino = new BancoCuentaMovimiento
                {
                    BancoCuentaID = frmTraspaso.BancoCuentaID,
                    EsIngreso = true,
                    Fecha = frmTraspaso.dtpFecha.Value,
                    FechaAsignado = frmTraspaso.dtpFecha.Value,
                    SucursalID = GlobalClass.SucursalID,
                    Importe = frmTraspaso.Importe,
                    Concepto = frmTraspaso.txtConcepto.Text,
                    Referencia = GlobalClass.UsuarioGlobal.NombreUsuario
                };
                ContaProc.RegistrarMovimientoBancario(oMovDestino);

                // Se crea la póliza sencilla correspondiente (AfeConta)
                var oCuentaOrigen = Datos.GetEntity<BancoCuenta>(c => c.BancoCuentaID == oMovOrigen.BancoCuentaID);
                var oCuentaDestino = Datos.GetEntity<BancoCuenta>(c => c.BancoCuentaID == oMovDestino.BancoCuentaID);
                var oCuentaAuxOrigen = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID ==
                    (oCuentaOrigen.EsCpcp ? Cat.ContaCuentasDeMayor.CuentasPorPagarCortoPlazo : Cat.ContaCuentasDeMayor.Bancos) && c.RelacionID == oMovOrigen.BancoCuentaID);
                var oCuentaAuxDestino = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID ==
                    (oCuentaDestino.EsCpcp ? Cat.ContaCuentasDeMayor.CuentasPorPagarCortoPlazo : Cat.ContaCuentasDeMayor.Bancos) && c.RelacionID == oMovDestino.BancoCuentaID);
                if (oCuentaAuxOrigen == null || oCuentaAuxDestino == null)
                {
                    Cargando.Cerrar();
                    UtilLocal.MensajeAdvertencia("No se encontró las cuenta auxiliar de alguna de las cuentas bancarias. No se realizará la Póliza.");
                }
                else
                {
                    var oPoliza = ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Diario, oMovOrigen.Concepto, oCuentaAuxDestino.ContaCuentaAuxiliarID,
                        oCuentaAuxOrigen.ContaCuentaAuxiliarID, oMovOrigen.Importe, oMovOrigen.Referencia, Cat.Tablas.BancoCuentaMovimiento, oMovOrigen.BancoCuentaMovimientoID);
                    oPoliza.Fecha = oMovOrigen.Fecha;
                    Datos.Guardar<ContaPoliza>(oPoliza);
                }

                Cargando.Cerrar();
                this.LlenarConciliaciones();
            }
            frmTraspaso.Dispose();
        }
示例#11
0
        public bool AccionGuardar()
        {
            // Se valida
            if (!this.Validar()) return false;

            Cargando.Mostrar();

            // Se guardan los datos
            // DateTime dAhora = DateTime.Now;
            int? iDocID = Util.Entero(this.cmbDocumento.SelectedValue);
            // Se guarda el gasto
            ContaEgreso oGasto = (this.EsMod ? this.oEgreso : new ContaEgreso());
            oGasto.ContaCuentaAuxiliarID = Util.Entero(this.cmbCuentaAuxiliar.SelectedValue);
            oGasto.Fecha = this.dtpFecha.Value;
            oGasto.Importe = Util.Decimal(this.txtImporte.Text);
            oGasto.TipoFormaPagoID = Util.Entero(this.cmbFormaDePago.SelectedValue);
            oGasto.FolioDePago = this.txtFolioDePago.Text;
            oGasto.FolioFactura = this.txtFolioFactura.Text;
            oGasto.BancoCuentaID = (int?)this.cmbCuentaBancaria.SelectedValue;
            oGasto.TipoDocumentoID = (iDocID > 0 ? iDocID : null);
            oGasto.EsFiscal = this.chkEsFiscal.Checked;
            oGasto.Observaciones = this.txtObservaciones.Text;
            oGasto.RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID;
            oGasto.SucursalID = GlobalClass.SucursalID;
            Datos.Guardar<ContaEgreso>(oGasto);
            // Se guarda el detalle, si aplica
            foreach (DataGridViewRow Fila in this.dgvDetalle.Rows)
            {
                if (Fila.IsNewRow) continue;

                int iCambioID = Util.Entero(Fila.Cells["_Cambio"].Value);
                if (iCambioID == Cat.TiposDeAfectacion.SinCambios) continue;

                ContaEgresoDetalle oGastoDet;
                if (iCambioID == Cat.TiposDeAfectacion.Agregar)
                {
                    oGastoDet = new ContaEgresoDetalle();
                    oGastoDet.ContaEgresoID = oGasto.ContaEgresoID;
                }
                else
                {
                    oGastoDet = (Fila.Tag as ContaEgresoDetalle);
                    if (iCambioID == Cat.TiposDeAfectacion.Borrar)
                    {
                        Datos.Eliminar<ContaEgresoDetalle>(oGastoDet, true);
                        continue;
                    }
                }
                oGastoDet.ContaConsumibleID = Util.Entero(Fila.Cells["ContaConsumibleID"].Value);
                oGastoDet.Cantidad = Util.Decimal(Fila.Cells["Cantidad"].Value);
                oGastoDet.Importe = Util.Decimal(Fila.Cells["Precio"].Value);
                Datos.Guardar<ContaEgresoDetalle>(oGastoDet);
            }
            // Se manda devengar automáticamente, si aplica
            ContaProc.GastoVerDevengarAutomaticamente(oGasto);

            // Se ejecutan procesos para gastos nuevos únicamente
            if (!this.EsMod)
            {
                // Se crean la pólizas contable correspondientes (AfeConta),
                ContaProc.CrearPolizasDeGastoContable(oGasto);

                // Se crea el movimiento bancario correspondiente, si aplica
                // Como se afecta la cuenta de bancos, se crea el movimiento bancario para mandarlo a conciliación y así llevar el control de todos los
                // movimientos bancarios
                if (oGasto.TipoFormaPagoID == Cat.FormasDePago.Cheque || oGasto.TipoFormaPagoID == Cat.FormasDePago.Tarjeta
                    || oGasto.TipoFormaPagoID == Cat.FormasDePago.Transferencia)
                {
                    var oMovBanc = new BancoCuentaMovimiento()
                    {
                        BancoCuentaID = oGasto.BancoCuentaID,
                        EsIngreso = false,
                        Fecha = oGasto.Fecha,
                        FechaAsignado = oGasto.Fecha,
                        SucursalID = oGasto.SucursalID,
                        Importe = oGasto.Importe,
                        Concepto = oGasto.Observaciones,
                        Referencia = oGasto.FolioFactura,
                        TipoFormaPagoID = oGasto.TipoFormaPagoID,
                        RelacionTabla = Cat.Tablas.ContaEgreso,
                        RelacionID = oGasto.ContaEgresoID
                    };
                    ContaProc.RegistrarMovimientoBancario(oMovBanc);
                }
            }

            Cargando.Cerrar();

            // Se muestra una notificación
            this.RestaurarControles();
            UtilLocal.MostrarNotificacion("Proceso completado correctamente.");

            return true;
        }
示例#12
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);
        }
示例#13
0
        public static ResAcc VentaPago(VentaPago oPago, List<VentaPagoDetalle> Detalle)
        {
            // Se generan datos predeterminados o globales, en caso de que apliquen
            oPago.Fecha = (oPago.Fecha != DateTime.MinValue ? oPago.Fecha : DateTime.Now);
            oPago.SucursalID = (oPago.SucursalID > 0 ? oPago.SucursalID : Theos.SucursalID);

            // Se guarda el pago
            Datos.Guardar<VentaPago>(oPago);

            // Se guarda el detalle
            var oVentaV = Datos.GetEntity<VentasView>(q => q.VentaID == oPago.VentaID);
            foreach (var PartePago in Detalle)
            {
                PartePago.VentaPagoID = oPago.VentaPagoID;
                Datos.Guardar<VentaPagoDetalle>(PartePago);

                // Se afectan las notas de crédito, si hay alguna
                if (PartePago.TipoFormaPagoID == Cat.FormasDePago.Vale && PartePago.Importe > 0)
                {
                    int iNotaID = PartePago.NotaDeCreditoID.Valor();
                    var oNota = Datos.GetEntity<NotaDeCredito>(q => q.NotaDeCreditoID == iNotaID && q.Estatus);
                    if (oNota != null)
                    {
                        // Se verifica si se usó el importe total o sólo una parte
                        if (PartePago.Importe < oNota.Importe)
                        {
                            // Se crea una nueva nota, con el importe restante
                            // 25/11/2015 - Se busca el vale original para usarlo como origen de todas las notas derivadas, en vez de el OrigenVentaID que se mandaba antes
                            int iOrigenValeID = (oNota.OrigenID == Cat.OrigenesNotaDeCredito.ImporteRestante ? oNota.RelacionID.Valor() : oNota.NotaDeCreditoID);
                            VentasProc.GenerarNotaDeCredito(oNota.ClienteID, (oNota.Importe - PartePago.Importe), "", Cat.OrigenesNotaDeCredito.ImporteRestante
                                , iOrigenValeID);
                            //
                            oNota.Importe = PartePago.Importe;
                        }
                        //
                        oNota.Valida = false;
                        oNota.FechaDeUso = DateTime.Now;
                        oNota.UsoVentaID = oPago.VentaID;
                        Datos.Guardar<NotaDeCredito>(oNota);
                    }
                }

                // Si es un pago bancario, se genera el movimiento correspondiente
                if (PartePago.TipoFormaPagoID == Cat.FormasDePago.Tarjeta || PartePago.TipoFormaPagoID == Cat.FormasDePago.TarjetaDeDebito
                    || PartePago.TipoFormaPagoID == Cat.FormasDePago.Transferencia || PartePago.TipoFormaPagoID == Cat.FormasDePago.Cheque)
                {
                    var oBanco = Datos.GetEntity<Banco>(c => c.BancoID == PartePago.BancoID && c.Estatus);

                    var oMovBanc = new BancoCuentaMovimiento()
                    {
                        // BancoCuentaID = (PartePago.TipoFormaPagoID == Cat.FormasDePago.Tarjeta ? (int?)Cat.CuentasBancarias.Banamex : null),
                        EsIngreso = true,
                        Fecha = oPago.Fecha,
                        FechaAsignado = ((PartePago.TipoFormaPagoID == Cat.FormasDePago.Tarjeta || PartePago.TipoFormaPagoID == Cat.FormasDePago.TarjetaDeDebito)
                            ? (DateTime?)oPago.Fecha : null),
                        SucursalID = oPago.SucursalID,
                        Importe = PartePago.Importe,
                        Concepto = oVentaV.Cliente,
                        Referencia = oVentaV.Folio,
                        TipoFormaPagoID = PartePago.TipoFormaPagoID,
                        DatosDePago = string.Format("{0}-{1}-{2}", oBanco.NombreBanco, PartePago.Folio, PartePago.Cuenta),
                        RelacionTabla = Cat.Tablas.VentaPagoDetalle,
                        RelacionID = PartePago.VentaPagoDetalleID,
                    };
                    ContaProc.RegistrarMovimientoBancario(oMovBanc);
                }
            }

            // Se verifica el estatus de la venta, por si debe cambiar según el pago
            if (oVentaV.VentaEstatusID == Cat.VentasEstatus.Cobrada)
            {
                // Se obtiene el total de los pagos
                decimal mPagado = Datos.GetListOf<VentasPagosView>(q => q.VentaID == oVentaV.VentaID).Sum(q => q.Importe);
                if (mPagado >= oVentaV.Total)
                {
                    var oVenta = Datos.GetEntity<Venta>(q => q.Estatus && q.VentaID == oPago.VentaID);
                    oVenta.VentaEstatusID = Cat.VentasEstatus.Completada;
                    // Se guarda con el nuevo estatus
                    Datos.Guardar<Venta>(oVenta);
                }
            }

            return new ResAcc(true);
        }
示例#14
0
        private void HacerTraspaso()
        {
            var frmTraspaso = new MovimientoBancarioGen()
            {
                OrigenBancoCuentaID = this.ConBancoCuentaID, Text = "Traspaso entre cuentas"
            };

            frmTraspaso.LlenarComboCuenta();
            frmTraspaso.lblImporteInfo.Text = this.lblSaldoOperacion.Text;
            frmTraspaso.txtConcepto.Text    = "Traspaso entre cuentas";
            // Para concatenar la cuenta destino
            frmTraspaso.cmbBancoCuenta.SelectedIndexChanged += new EventHandler((s, e) =>
            {
                frmTraspaso.txtConcepto.Text = ("Traspaso entre cuentas - " + frmTraspaso.cmbBancoCuenta.Text);
            });
            // Para validar los datos
            frmTraspaso.delValidar += () => {
                frmTraspaso.ctlError.LimpiarErrores();
                if (frmTraspaso.BancoCuentaID <= 0)
                {
                    frmTraspaso.ctlError.PonerError(frmTraspaso.cmbBancoCuenta, "Debes especificar una cuenta.");
                }
                if (frmTraspaso.Importe == 0)
                {
                    frmTraspaso.ctlError.PonerError(frmTraspaso.txtImporte, "El importe especificado es inválido.");
                }
                return(frmTraspaso.ctlError.Valido);
            };
            if (frmTraspaso.ShowDialog(Principal.Instance) == DialogResult.OK)
            {
                Cargando.Mostrar();

                // Se crea el retiro de la cuenta origen
                var oMovOrigen = new BancoCuentaMovimiento
                {
                    BancoCuentaID = this.ConBancoCuentaID,
                    EsIngreso     = false,
                    Fecha         = frmTraspaso.dtpFecha.Value,
                    FechaAsignado = frmTraspaso.dtpFecha.Value,
                    SucursalID    = GlobalClass.SucursalID,
                    Importe       = frmTraspaso.Importe,
                    Concepto      = frmTraspaso.txtConcepto.Text,
                    Referencia    = GlobalClass.UsuarioGlobal.NombreUsuario
                };
                ContaProc.RegistrarMovimientoBancario(oMovOrigen);
                // Se crea el depósito a la cuenta destino
                var oMovDestino = new BancoCuentaMovimiento
                {
                    BancoCuentaID = frmTraspaso.BancoCuentaID,
                    EsIngreso     = true,
                    Fecha         = frmTraspaso.dtpFecha.Value,
                    FechaAsignado = frmTraspaso.dtpFecha.Value,
                    SucursalID    = GlobalClass.SucursalID,
                    Importe       = frmTraspaso.Importe,
                    Concepto      = frmTraspaso.txtConcepto.Text,
                    Referencia    = GlobalClass.UsuarioGlobal.NombreUsuario
                };
                ContaProc.RegistrarMovimientoBancario(oMovDestino);

                // Se crea la póliza sencilla correspondiente (AfeConta)
                var oCuentaOrigen    = Datos.GetEntity <BancoCuenta>(c => c.BancoCuentaID == oMovOrigen.BancoCuentaID);
                var oCuentaDestino   = Datos.GetEntity <BancoCuenta>(c => c.BancoCuentaID == oMovDestino.BancoCuentaID);
                var oCuentaAuxOrigen = Datos.GetEntity <ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID ==
                                                                             (oCuentaOrigen.EsCpcp ? Cat.ContaCuentasDeMayor.CuentasPorPagarCortoPlazo : Cat.ContaCuentasDeMayor.Bancos) && c.RelacionID == oMovOrigen.BancoCuentaID);
                var oCuentaAuxDestino = Datos.GetEntity <ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID ==
                                                                              (oCuentaDestino.EsCpcp ? Cat.ContaCuentasDeMayor.CuentasPorPagarCortoPlazo : Cat.ContaCuentasDeMayor.Bancos) && c.RelacionID == oMovDestino.BancoCuentaID);
                if (oCuentaAuxOrigen == null || oCuentaAuxDestino == null)
                {
                    Cargando.Cerrar();
                    UtilLocal.MensajeAdvertencia("No se encontró las cuenta auxiliar de alguna de las cuentas bancarias. No se realizará la Póliza.");
                }
                else
                {
                    var oPoliza = ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Diario, oMovOrigen.Concepto, oCuentaAuxDestino.ContaCuentaAuxiliarID,
                                                        oCuentaAuxOrigen.ContaCuentaAuxiliarID, oMovOrigen.Importe, oMovOrigen.Referencia, Cat.Tablas.BancoCuentaMovimiento, oMovOrigen.BancoCuentaMovimientoID);
                    oPoliza.Fecha = oMovOrigen.Fecha;
                    Datos.Guardar <ContaPoliza>(oPoliza);
                }

                Cargando.Cerrar();
                this.LlenarConciliaciones();
            }
            frmTraspaso.Dispose();
        }
示例#15
0
        private void AgruparMovimientos()
        {
            // Se obtienen los movimientos marcados
            var     oMovsIds = new List <int>();
            decimal mDeposito = 0, mRetiro = 0;

            foreach (DataGridViewRow oFila in this.dgvConciliacion.Rows)
            {
                if (!Util.Logico(oFila.Cells["con_Sel"].Value))
                {
                    continue;
                }
                mDeposito += Util.Decimal(oFila.Cells["con_Depositos"].Value);
                mRetiro   += Util.Decimal(oFila.Cells["con_Retiros"].Value);
                oMovsIds.Add(Util.Entero(oFila.Cells["con_BancoCuentaMovimientoID"].Value));
            }

            // Se valida que haya movimientos o importe
            if ((mDeposito + mRetiro) == 0)
            {
                UtilLocal.MensajeAdvertencia("No hay ningún movimiento seleccionado o el importe es igual a cero.");
                return;
            }
            // Se valida que sean puros depósitos o puros retiros
            if (mDeposito > 0 && mRetiro > 0)
            {
                UtilLocal.MensajeAdvertencia("No es posible agrupar movimientos de tipo depósito con movimientos de tipo retiro.");
                return;
            }

            // Se abre forma para guardar los datos
            var frmDatos = new AgruparMovimientosBancarios();

            frmDatos.Deposito = (mDeposito > 0);
            frmDatos.Importe  = (mDeposito + mRetiro);
            // Se llenan los datos con el primer movimiento seleccionado
            int iPrimerMovID = oMovsIds[0];
            var oPrimerMov   = Datos.GetEntity <BancoCuentaMovimiento>(c => c.BancoCuentaMovimientoID == iPrimerMovID);

            frmDatos.Fecha      = oPrimerMov.FechaAsignado.Valor();
            frmDatos.SucursalID = oPrimerMov.SucursalID;
            frmDatos.Concepto   = oPrimerMov.Concepto;
            frmDatos.Referencia = oPrimerMov.Referencia;
            // Se muestra el formulario
            if (frmDatos.ShowDialog(Principal.Instance) == DialogResult.OK)
            {
                Cargando.Mostrar();
                // Se obtienen los movimientos a agrupar
                var oMovs = new List <BancoCuentaMovimiento>();
                foreach (int iModID in oMovsIds)
                {
                    oMovs.Add(Datos.GetEntity <BancoCuentaMovimiento>(c => c.BancoCuentaMovimientoID == iModID));
                }
                // Se genera y guarda el movimiento agrupador
                var oMovAgrupador = new BancoCuentaMovimiento()
                {
                    BancoCuentaID  = oPrimerMov.BancoCuentaID,
                    EsIngreso      = (mDeposito > 0),
                    Fecha          = DateTime.Now,
                    FechaAsignado  = frmDatos.Fecha,
                    SucursalID     = frmDatos.SucursalID,
                    Importe        = oMovs.Sum(c => c.Importe),
                    Concepto       = frmDatos.Concepto,
                    Referencia     = frmDatos.Referencia,
                    SaldoAcumulado = oMovs.OrderBy(c => c.FechaAsignado).Last().SaldoAcumulado
                };
                Datos.Guardar <BancoCuentaMovimiento>(oMovAgrupador);
                // Se agrupan los movimientos
                foreach (var oMov in oMovs)
                {
                    oMov.MovimientoAgrupadorID = oMovAgrupador.BancoCuentaMovimientoID;
                    Datos.Guardar <BancoCuentaMovimiento>(oMov);
                }
                // Se recalcula el acumulado
                this.RecalcularAcumulado(oMovAgrupador.FechaAsignado.Valor());
                //
                Cargando.Cerrar();
                this.LlenarConciliaciones();
            }
            frmDatos.Dispose();
        }
示例#16
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;
        }
示例#17
0
        public static void RegistrarMovimientoBancario(BancoCuentaMovimiento oMov)
        {
            // Se llanan algunos datos, si no han sido llenados
            oMov.Fecha = (oMov.Fecha == DateTime.MinValue ? DateTime.Now : oMov.Fecha);
            oMov.SucursalID = (oMov.SucursalID == 0 ? Theos.SucursalID : oMov.SucursalID);

            // Se calcula el nuevo saldo acumulado, si ya está asignado
            if (oMov.FechaAsignado.HasValue)
            {
                ContaProc.RecalcularSaldoAcumulado(oMov.BancoCuentaID.Valor(), oMov.FechaAsignado.Value);
            }

            Datos.Guardar<BancoCuentaMovimiento>(oMov);
        }
示例#18
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;
        }
示例#19
0
        private void ImpAccionGuardar()
        {
            if (!this.ImpValidar())
                return;

            Cargando.Mostrar();

            // Se inserta el pago de impuesto
            var oImpuesto = new NominaImpuesto()
            {
                ContaCuentaDeMayorID = Util.Entero(this.cmbImpTipo.SelectedValue),
                Fecha = this.dtpImpFecha.Value,
                Periodo = Util.Entero(this.cmbImpPeriodo.SelectedValue),
                BancoCuentaID = Util.Entero(this.cmbImpCuenta.SelectedValue),
                TipoFormaPagoID = Util.Entero(this.cmbImpFormaDePago.SelectedValue),
                FolioDePago = this.txtImpFolioDePago.Text
            };
            Datos.Guardar<NominaImpuesto>(oImpuesto);

            string sPeriodo = this.cmbImpPeriodo.Text;
            decimal mImporteTotal = 0;
            foreach (DataGridViewRow oFila in this.dgvImpDatos.Rows)
            {
                if (!Util.Logico(oFila.Cells["imp_Sel"].Value))
                    continue;

                // Se inserta el impuesto usuario
                var oImpUsuario = new NominaImpuestoUsuario()
                {
                    NominaImpuestoID = oImpuesto.NominaImpuestoID,
                    IdUsuario = Util.Entero(oFila.Cells["imp_UsuarioID"].Value),
                    SucursalID = Util.Entero(oFila.Cells["imp_SucursalID"].Value),
                    Retenido = Util.Decimal(oFila.Cells["imp_Retenido"].Value),
                    Total = Util.Decimal(oFila.Cells["imp_Total"].Value)
                };
                Datos.Guardar<NominaImpuestoUsuario>(oImpUsuario);
                mImporteTotal += oImpUsuario.Total;

                // Se inserta el gasto contable
                var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == oImpuesto.ContaCuentaDeMayorID && c.RelacionID == oImpUsuario.IdUsuario);
                if (oCuentaAux == null)
                {
                    UtilLocal.MensajeAdvertencia("El usuario " + Util.Cadena(oFila.Cells["imp_Usuario"].Value)
                        + " no tiene una cuenta auxiliar relacionada. No se generará el gasto contable.");
                }
                else
                {
                    var oEgreso = new ContaEgreso()
                    {
                        ContaCuentaAuxiliarID = oCuentaAux.ContaCuentaAuxiliarID,
                        Fecha = oImpuesto.Fecha,
                        Importe = oImpUsuario.Total,
                        TipoFormaPagoID = oImpuesto.TipoFormaPagoID,
                        FolioDePago = oImpuesto.FolioDePago,
                        TipoDocumentoID = Cat.TiposDeDocumento.Factura,
                        EsFiscal = true,
                        Observaciones = ("PAGO " + this.cmbImpTipo.Text + " " + sPeriodo),
                        SucursalID = oImpUsuario.SucursalID,
                        RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID,
                        FolioFactura = sPeriodo,
                        BancoCuentaID = oImpuesto.BancoCuentaID
                    };
                    ContaProc.GastoCrear(oEgreso);
                }

                // Se registra la póliza correspondiente (AfeConta)
                switch (oImpuesto.ContaCuentaDeMayorID)
                {
                    case Cat.ContaCuentasDeMayor.Nomina2Por:
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.Pago2Por, oImpUsuario.NominaImpuestoUsuarioID, oImpuesto.FolioDePago
                            , ("PAGO 2% " + sPeriodo), oImpuesto.Fecha);
                        break;
                    case Cat.ContaCuentasDeMayor.Imss:
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoImss, oImpUsuario.NominaImpuestoUsuarioID, oImpuesto.FolioDePago
                            , ("PAGO IMSS " + sPeriodo), oImpuesto.Fecha);
                        break;
                    case Cat.ContaCuentasDeMayor.Infonavit:
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoInfonavit, oImpUsuario.NominaImpuestoUsuarioID, oImpuesto.FolioDePago
                            , ("PAGO INFONAVIT " + sPeriodo), oImpuesto.Fecha);
                        break;
                }
            }

            // Se inserta el movimiento bancario
            var oMov = new BancoCuentaMovimiento()
            {
                BancoCuentaID = oImpuesto.BancoCuentaID,
                EsIngreso = false,
                Fecha = oImpuesto.Fecha,
                FechaAsignado = oImpuesto.Fecha,
                SucursalID = Cat.Sucursales.Matriz,
                Importe = mImporteTotal,
                Concepto = ("PAGO IMPUESTO " + this.cmbImpTipo.Text + " " + sPeriodo),
                Referencia = GlobalClass.UsuarioGlobal.NombreUsuario,
                TipoFormaPagoID = oImpuesto.TipoFormaPagoID,
                DatosDePago = oImpuesto.FolioDePago,
                RelacionTabla = Cat.Tablas.NominaImpuesto,
                RelacionID = oImpuesto.NominaImpuestoID
            };
            ContaProc.RegistrarMovimientoBancario(oMov);

            Cargando.Cerrar();
            UtilLocal.MensajeInformacion("Proceso completado exitosamente.");
        }
示例#20
0
        public static ResAcc VentaPago(VentaPago oPago, List <VentaPagoDetalle> Detalle)
        {
            // Se generan datos predeterminados o globales, en caso de que apliquen
            oPago.Fecha      = (oPago.Fecha != DateTime.MinValue ? oPago.Fecha : DateTime.Now);
            oPago.SucursalID = (oPago.SucursalID > 0 ? oPago.SucursalID : Theos.SucursalID);

            // Se guarda el pago
            Datos.Guardar <VentaPago>(oPago);

            // Se guarda el detalle
            var oVentaV = Datos.GetEntity <VentasView>(q => q.VentaID == oPago.VentaID);

            foreach (var PartePago in Detalle)
            {
                PartePago.VentaPagoID = oPago.VentaPagoID;
                Datos.Guardar <VentaPagoDetalle>(PartePago);

                // Se afectan las notas de crédito, si hay alguna
                if (PartePago.TipoFormaPagoID == Cat.FormasDePago.Vale && PartePago.Importe > 0)
                {
                    int iNotaID = PartePago.NotaDeCreditoID.Valor();
                    var oNota   = Datos.GetEntity <NotaDeCredito>(q => q.NotaDeCreditoID == iNotaID && q.Estatus);
                    if (oNota != null)
                    {
                        // Se verifica si se usó el importe total o sólo una parte
                        if (PartePago.Importe < oNota.Importe)
                        {
                            // Se crea una nueva nota, con el importe restante
                            // 25/11/2015 - Se busca el vale original para usarlo como origen de todas las notas derivadas, en vez de el OrigenVentaID que se mandaba antes
                            int iOrigenValeID = (oNota.OrigenID == Cat.OrigenesNotaDeCredito.ImporteRestante ? oNota.RelacionID.Valor() : oNota.NotaDeCreditoID);
                            VentasProc.GenerarNotaDeCredito(oNota.ClienteID, (oNota.Importe - PartePago.Importe), "", Cat.OrigenesNotaDeCredito.ImporteRestante
                                                            , iOrigenValeID);
                            //
                            oNota.Importe = PartePago.Importe;
                        }
                        //
                        oNota.Valida     = false;
                        oNota.FechaDeUso = DateTime.Now;
                        oNota.UsoVentaID = oPago.VentaID;
                        Datos.Guardar <NotaDeCredito>(oNota);
                    }
                }

                // Si es un pago bancario, se genera el movimiento correspondiente
                if (PartePago.TipoFormaPagoID == Cat.FormasDePago.Tarjeta || PartePago.TipoFormaPagoID == Cat.FormasDePago.TarjetaDeDebito ||
                    PartePago.TipoFormaPagoID == Cat.FormasDePago.Transferencia || PartePago.TipoFormaPagoID == Cat.FormasDePago.Cheque)
                {
                    var oBanco = Datos.GetEntity <Banco>(c => c.BancoID == PartePago.BancoID && c.Estatus);

                    var oMovBanc = new BancoCuentaMovimiento()
                    {
                        // BancoCuentaID = (PartePago.TipoFormaPagoID == Cat.FormasDePago.Tarjeta ? (int?)Cat.CuentasBancarias.Banamex : null),
                        EsIngreso     = true,
                        Fecha         = oPago.Fecha,
                        FechaAsignado = ((PartePago.TipoFormaPagoID == Cat.FormasDePago.Tarjeta || PartePago.TipoFormaPagoID == Cat.FormasDePago.TarjetaDeDebito)
                            ? (DateTime?)oPago.Fecha : null),
                        SucursalID      = oPago.SucursalID,
                        Importe         = PartePago.Importe,
                        Concepto        = oVentaV.Cliente,
                        Referencia      = oVentaV.Folio,
                        TipoFormaPagoID = PartePago.TipoFormaPagoID,
                        DatosDePago     = string.Format("{0}-{1}-{2}", oBanco.NombreBanco, PartePago.Folio, PartePago.Cuenta),
                        RelacionTabla   = Cat.Tablas.VentaPagoDetalle,
                        RelacionID      = PartePago.VentaPagoDetalleID,
                    };
                    ContaProc.RegistrarMovimientoBancario(oMovBanc);
                }
            }

            // Se verifica el estatus de la venta, por si debe cambiar según el pago
            if (oVentaV.VentaEstatusID == Cat.VentasEstatus.Cobrada)
            {
                // Se obtiene el total de los pagos
                decimal mPagado = Datos.GetListOf <VentasPagosView>(q => q.VentaID == oVentaV.VentaID).Sum(q => q.Importe);
                if (mPagado >= oVentaV.Total)
                {
                    var oVenta = Datos.GetEntity <Venta>(q => q.Estatus && q.VentaID == oPago.VentaID);
                    oVenta.VentaEstatusID = Cat.VentasEstatus.Completada;
                    // Se guarda con el nuevo estatus
                    Datos.Guardar <Venta>(oVenta);
                }
            }

            return(new ResAcc(true));
        }