示例#1
0
        private void btnCancelarFacPen_Click(object sender, EventArgs e)
        {
            if (this.dgvFacturasPorCancelar.CurrentRow == null)
            {
                UtilLocal.MensajeAdvertencia("No hay ninguna factura por cancelar seleccionada.");
                return;
            }

            this.btnCancelarFacPen.Enabled = false;
            Cargando.Mostrar();

            int    iVentaFacturaDevolucionID = Util.Entero(this.dgvFacturasPorCancelar.CurrentRow.Cells["VentaFacturaDevolucionID"].Value);
            string sFolioFiscal = Util.Cadena(this.dgvFacturasPorCancelar.CurrentRow.Cells["FolioFiscal"].Value);
            var    Res          = VentasLoc.GenerarFacturaCancelacion(sFolioFiscal, iVentaFacturaDevolucionID);

            if (Res.Exito)
            {
                this.ActualizarFacturasPorCancelar();
                Cargando.Cerrar();
            }
            else
            {
                Cargando.Cerrar();
                UtilLocal.MensajeAdvertencia("Hubo un error al cancelar la factura:\n\n" + Res.Mensaje);
            }

            this.btnCancelarFacPen.Enabled = true;
        }
示例#2
0
        public override bool Ejecutar()
        {
            // Se verifica si ya se hizo el cierre de caja
            if (UtilDatos.VerCierreDeDaja())
            {
                UtilLocal.MensajeAdvertencia("Ya se hizo el Corte de Caja. No se puede continuar.");
                return(false);
            }

            // Se valida la parte de detalle
            if (!this.ctlDetalle.Validar())
            {
                return(false);
            }
            // Se valida la parte de búsqueda
            if (!this.ctlBusqueda.Validar())
            {
                return(false);
            }

            int iVentaID = this.ctlBusqueda.VentaID;

            // Se valida que no sea una venta usada para cobro de Control de Cascos
            if (Datos.Exists <CascosRegistrosView>(c => c.CobroVentaID == iVentaID &&
                                                   (c.VentaEstatusID != Cat.VentasEstatus.Cancelada && c.VentaEstatusID != Cat.VentasEstatus.CanceladaSinPago)))
            {
                UtilLocal.MensajeAdvertencia("La venta seleccionado fue utilizada para un cobro de Control de Cascos. No se puede cancelar.");
                return(false);
            }

            //
            bool bCancelacion = this.ctlDetalle.TodosMarcados();
            var  oVentaV      = Datos.GetEntity <VentasView>(q => q.VentaID == iVentaID);

            // Se verifica si es una cancelación de otra sucursal
            if (oVentaV.SucursalID != GlobalClass.SucursalID)
            {
                if (UtilLocal.MensajePregunta("La Venta seleccionada es de otra Sucursal. ¿Deseas continuar?") != DialogResult.Yes)
                {
                    return(false);
                }
            }

            // Se verifica si es una cancelación de factura de varios tickets
            int  iVentaFacturaID        = 0;
            bool bFacturaMultiple       = false;
            bool bCancelarTodaLaFactura = this.ctlBusqueda.CancelarTodaLaFactura;
            List <VentaFacturaDetalle> oVentasFactura = null;

            if (oVentaV.Facturada)
            {
                iVentaFacturaID  = Datos.GetEntity <VentaFacturaDetalle>(q => q.VentaID == oVentaV.VentaID && q.Estatus).VentaFacturaID;
                oVentasFactura   = Datos.GetListOf <VentaFacturaDetalle>(q => q.VentaFacturaID == iVentaFacturaID && q.Estatus);
                bFacturaMultiple = (oVentasFactura.Count > 1);

                // Se muestran los datos de detalle de todas las ventas de la factura
                if (bCancelarTodaLaFactura && bFacturaMultiple)
                {
                    if (!this.MostrarDetalleVentasFactura(oVentasFactura))
                    {
                        return(false);
                    }
                }
            }

            // Se verifica si se creará vale, para pedir el cliente en caso de que no haya
            int iValeClienteID = oVentaV.ClienteID;

            if (this.ctlBusqueda.FormaDeDevolucion == Cat.FormasDePago.Vale && iValeClienteID == Cat.Clientes.Mostrador)
            {
                var frmValor = new MensajeObtenerValor("Selecciona el cliente para crear el Vale:", "", MensajeObtenerValor.Tipo.Combo);
                frmValor.CargarCombo("ClienteID", "Nombre", Datos.GetListOf <Cliente>(q => q.ClienteID != Cat.Clientes.Mostrador && q.Estatus));
                if (frmValor.ShowDialog(Principal.Instance) == DialogResult.OK)
                {
                    iValeClienteID = Util.Entero(frmValor.Valor);
                }
                frmValor.Dispose();
                if (iValeClienteID == 0)
                {
                    return(false);
                }
            }

            // Se pregunta el usuario que realiza la devolución
            int iUsuarioID = 0;
            var ResU       = UtilLocal.ValidarObtenerUsuario("Ventas.Devolucion.Agregar");

            if (ResU.Error)
            {
                return(false);
            }
            iUsuarioID = ResU.Respuesta.UsuarioID;

            // Se solicita la autorización
            int iAutorizoID = 0;

            ResU = UtilLocal.ValidarObtenerUsuario("Autorizaciones.Ventas.Devoluciones.Agregar", "Autorización");
            if (ResU.Exito)
            {
                iAutorizoID = ResU.Respuesta.UsuarioID;
            }

            // Se procede a guardar los cambios
            DateTime dAhora = DateTime.Now;

            // Si es factura múltiple, se cancelan todas las ventas de la factura, si no, sólo la venta seleccionada
            var oIdsDev    = new List <int>();
            var oIdsCascos = new List <int>();

            if (bFacturaMultiple && bCancelarTodaLaFactura)
            {
                var oDevGeneral = this.ctlBusqueda.GenerarDevolucion();
                foreach (var oVentaFac in oVentasFactura)
                {
                    // Se genera la devolución
                    var oDev = new VentaDevolucion()
                    {
                        VentaID          = oVentaFac.VentaID,
                        Fecha            = dAhora,
                        RealizoUsuarioID = iUsuarioID,
                        EsCancelacion    = true,
                        MotivoID         = oDevGeneral.MotivoID,
                        Observacion      = oDevGeneral.Observacion,
                        TipoFormaPagoID  = oDevGeneral.TipoFormaPagoID
                    };
                    // Se genera el detalle de la devolución
                    var oDevDet       = new List <VentaDevolucionDetalle>();
                    var oVentaDetalle = Datos.GetListOf <VentaDetalle>(c => c.VentaID == oVentaFac.VentaID && c.Estatus);
                    foreach (var oParte in oVentaDetalle)
                    {
                        oDevDet.Add(new VentaDevolucionDetalle()
                        {
                            ParteID           = oParte.ParteID,
                            Costo             = oParte.Costo,
                            CostoConDescuento = oParte.CostoConDescuento,
                            Cantidad          = oParte.Cantidad,
                            PrecioUnitario    = oParte.PrecioUnitario,
                            Iva = oParte.Iva
                        });
                    }
                    // Se manda guardar la devolución
                    this.GuardarDevolucion(oDev, oDevDet, iValeClienteID);
                    // Se agrega a la lisa de devoluciones
                    oIdsDev.Add(oDev.VentaDevolucionID);

                    // Se verifica si requiere un casco
                    foreach (var oReg in oDevDet)
                    {
                        if (Datos.Exists <Parte>(c => c.ParteID == oReg.ParteID && c.RequiereCascoDe > 0 && c.Estatus))
                        {
                            oIdsCascos.Add(oReg.VentaDevolucionDetalleID);
                        }
                    }
                }
            }
            else
            {
                // Se genera la devolución
                var oDevolucion = this.ctlBusqueda.GenerarDevolucion();
                oDevolucion.Fecha            = dAhora;
                oDevolucion.EsCancelacion    = bCancelacion;
                oDevolucion.RealizoUsuarioID = iUsuarioID;
                // Se genera el detalle de la devolución
                var oDevDetalle = new List <VentaDevolucionDetalle>();
                var oProductos  = this.ctlDetalle.ProductosSel();
                foreach (var oProducto in oProductos)
                {
                    oDevDetalle.Add(new VentaDevolucionDetalle()
                    {
                        ParteID           = oProducto.ParteID,
                        Costo             = oProducto.Costo,
                        CostoConDescuento = oProducto.CostoConDescuento,
                        Cantidad          = oProducto.Cantidad,
                        PrecioUnitario    = oProducto.PrecioUnitario,
                        Iva = oProducto.Iva
                    });
                }
                // Se guarda la devolución
                this.GuardarDevolucion(oDevolucion, oDevDetalle, iValeClienteID);
                //
                oIdsDev.Add(oDevolucion.VentaDevolucionID);

                // Se verifica si requiere un casco
                foreach (var oReg in oDevDetalle)
                {
                    if (Datos.Exists <Parte>(c => c.ParteID == oReg.ParteID && c.RequiereCascoDe > 0 && c.Estatus))
                    {
                        oIdsCascos.Add(oReg.VentaDevolucionDetalleID);
                    }
                }
            }

            // Se verifica si es factura, en cuyo caso, se cancela la factura o se genera nota de crédito, según aplique
            if (oVentaV.Facturada)
            {
                if (bCancelacion && (!bFacturaMultiple || (bFacturaMultiple && bCancelarTodaLaFactura)))
                {
                    var ResFactura = VentasLoc.GenerarFacturaCancelacion(iVentaFacturaID, oIdsDev);
                    if (ResFactura.Error)
                    {
                        UtilLocal.MensajeAdvertencia("Hubo un error al cancelar la factura.\n\n" + ResFactura.Mensaje);
                    }
                }
                else
                {
                    var ResFactura = VentasLoc.GenerarFacturaDevolucionPorDevolucion(oIdsDev[0]);
                    if (ResFactura.Error)
                    {
                        UtilLocal.MensajeAdvertencia("Hubo un error al generar la factura de la devolución.\n\n" + ResFactura.Mensaje);
                    }
                }
            }

            // Se verifica si hay una cancelación de control de cascos
            foreach (int iDevDetID in oIdsCascos)
            {
                this.DevolverControlCasco(iDevDetID, iUsuarioID);
            }

            // Se manda a afectar contabilidad (AfeConta)
            foreach (int iDevID in oIdsDev)
            {
                var oDevV = Datos.GetEntity <VentasDevolucionesView>(c => c.VentaDevolucionID == iDevID);
                if (oDevV.Facturada)
                {
                    if (oDevV.VentaACredito)
                    {
                        if (oDevV.FormaDePagoID == Cat.FormasDePago.Vale)
                        {
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaCreditoFacturadaVale, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
                        }
                        else
                        {
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaCreditoFacturadaPago, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
                        }
                    }
                    else
                    {
                        if (oDevV.FormaDePagoID == Cat.FormasDePago.Vale)
                        {
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaValeFactura, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
                        }
                        else
                        {
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaPago, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
                        }
                    }
                }
                else
                {
                    if (oDevV.FormaDePagoID == Cat.FormasDePago.Vale)
                    {
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaValeTicket, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
                    }

                    // Si es tiecket a crédito, se hace ajuste temporal de pólizas
                    if (oDevV.VentaACredito)
                    {
                        ContaProc.BorrarPolizaTemporalTicketCredito(oDevV.VentaID);
                        if (!bCancelacion)
                        {
                            var oVentaVi = Datos.GetEntity <VentasView>(c => c.VentaID == oDevV.VentaID);
                            ContaProc.CrearPolizaTemporalTicketCredito(oDevV.VentaID, (oVentaVi.Total - oVentaVi.Pagado));
                        }
                    }
                }
            }

            //
            foreach (int iDevID in oIdsDev)
            {
                // Se guarda la autorización, si aplica
                VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.DevolucionCancelacion, Cat.Tablas.VentaDevolucion, iDevID, iAutorizoID);
                // Se genera el ticket correspondiente
                VentasLoc.GenerarTicketDevolucion(iDevID);

                // Se agrega al Kardex

                /* Ahora se hace desde que se guarda la devolución - Guardar.VentaDevolucion()
                 * var oDevV = General.GetEntity<VentasDevolucionesView>(c => c.VentaDevolucionID == iDevID);
                 * var oDet = General.GetListOf<VentaDevolucionDetalle>(c => c.VentaDevolucionID == iDevID && c.Estatus);
                 * foreach (var oReg in oDet)
                 * {
                 *  AdmonProc.RegistrarKardex(new ParteKardex()
                 *  {
                 *      ParteID = oReg.ParteID,
                 *      OperacionID = Cat.OperacionesKardex.VentaCancelada,
                 *      SucursalID = oDevV.SucursalID,
                 *      Folio = oDevV.FolioDeVenta,
                 *      Fecha = DateTime.Now,
                 *      RealizoUsuarioID = oDevV.RealizoUsuarioID,
                 *      Entidad = oVentaV.Cliente,
                 *      Origen = oVentaV.ClienteID.ToString(),
                 *      Destino = oDevV.Sucursal,
                 *      Cantidad = oReg.Cantidad,
                 *      Importe = (oReg.PrecioUnitario + oReg.Iva),
                 *      RelacionTabla = Cat.Tablas.VentaDevolucion,
                 *      RelacionID = oDevV.VentaDevolucionID
                 *  });
                 * }
                 */
            }

            // Se manda aviso de cancelación de factura a crédito de días anteriores, si aplica
            if (oVentaV.Facturada && oVentaV.ACredito && oVentaV.Fecha < DateTime.Now.Date)
            {
                var oUsuarios = Datos.GetListOf <Usuario>(c => c.AlertaDevFacturaCreditoAnt == true && c.Estatus);
                foreach (var oReg in oUsuarios)
                {
                    Proc.EnviarMensajeTcp(oReg.Ip, Proc.MensajesTcp.DevolucionFacturaCreditoAnt, oIdsDev[0].ToString());
                }
            }

            // Se muestra una notifiación con el resultado
            UtilLocal.MostrarNotificacion((bCancelacion ? "Cancelación" : "Devolución") + " guardada correctamente.");

            // Se limpia después de haberse guardado
            this.Limpiar();

            return(true);
        }