Example #1
0
        public void ActualizarPagos()
        {
            foreach (VentaItem ventaItems in VentaItems)
            {
                ventaItems.QuitarPagos();
            }

            foreach (VentaPago pago in Pagos)
            {
                pago.ActualizarMontoRestante(pago.MontoPago.Monto);
                pago.ActualizarIva(0);
                pago.ActualizarDescuento(0);

                foreach (VentaItem ventaItems in VentaItems.Where(x => x.PorcentajePago < 1))
                {
                    decimal montoRestante = ventaItems.AgregarPago(pago, pago.PorcentajeRecargo, PorcentajeFacturacion, TipoCliente);
                    ventaItems.ActualizarPorcentajePago();

                    if (montoRestante == 0)
                    {
                        break;
                    }
                }
            }
        }
Example #2
0
        public IEnumerable <VentaItem> OrdenarItemsVenta()
        {
            List <VentaItem> Ventas       = new List <VentaItem>();
            List <VentaItem> Devoluciones = new List <VentaItem>();

            IEnumerable <IGrouping <bool, VentaItem> > ventaItemGroup = VentaItems.GroupBy(x => x.Cantidad > 0);

            if (TipoCliente == TipoCliente.Mayorista)
            {
                Ventas       = ventaItemGroup.Where(x => x.Key == true).SelectMany(x => x).ToList();
                Devoluciones = ventaItemGroup.Where(x => x.Key == false).SelectMany(x => x).ToList();
            }
            else
            {
                Ventas       = ventaItemGroup.Where(x => x.Key == true).SelectMany(x => x).OrderByDescending(x => x.PorcentajeBonificacion).ThenBy(x => x.Cantidad).ThenBy(x => x.Producto.Codigo).ToList();
                Devoluciones = ventaItemGroup.Where(x => x.Key == false).SelectMany(x => x).OrderByDescending(x => x.PorcentajeBonificacion).ThenBy(x => x.Cantidad).ThenBy(x => x.Producto.Codigo).ToList();
            }

            List <VentaItem> Aux = new List <VentaItem>(Devoluciones);

            Aux.AddRange(Ventas);

            VentaItems = Aux;
            return(Aux);
        }
Example #3
0
        public ActionResult DeleteConfirmed(int id)
        {
            VentaItems ventaItems = db.Items.Find(id);

            db.Items.Remove(ventaItems);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Example #4
0
        public MontoPago ObtenerPendienteMontoPago(decimal porcentajeCft, decimal porcentajeFacturacion, TipoCliente tipoCliente, TipoPago formaDePago)
        {
            if (EstaPaga || VentaItems.Count == 0)
            {
                return(new MontoPago(0, 0, 0, 0));
            }

            return(VentaItems.Select(x => x.ObtenerMontoPagoPendiente(porcentajeCft, porcentajeFacturacion, tipoCliente, formaDePago)).Aggregate((x, y) => x + y));
        }
Example #5
0
        public void Anular(string motivo, string usuario)
        {
            VentaItems.ToList().ForEach(x => x.AumentarStock());

            MotivoAnulada  = motivo;
            UsuarioAnulada = usuario;
            FechaAnulada   = DateTime.Now;
            Anulada        = true;
        }
Example #6
0
        public MontoProducto ObtenerPendientePago()
        {
            if (EstaPaga)
            {
                return(new MontoProducto(0, 0));
            }

            return(VentaItems.Select(x => x.ObtenerPendientePago()).Aggregate((x, y) => x + y));
        }
Example #7
0
 public ActionResult Edit([Bind(Include = "ItemId,Descripcion,EsServicio,Cantidad,Precio,VentaId,ArtServId")] VentaItems ventaItems)
 {
     if (ModelState.IsValid)
     {
         db.Entry(ventaItems).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(ventaItems));
 }
Example #8
0
        public ActionResult Create([Bind(Include = "ItemId,Descripcion,EsServicio,Cantidad,Precio,VentaId,ArtServId")] VentaItems ventaItems)
        {
            if (ModelState.IsValid)
            {
                db.Items.Add(ventaItems);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(ventaItems));
        }
 public VentaDetalleViewModel(Modelo.Venta venta)
 {
     Venta       = venta;
     FechaAlta   = venta.FechaAlta;
     UsuarioAlta = venta.UsuarioAlta;
     FormaPago   = venta.Pago.FormaPago.ToString();
     MontoPago   = venta.Pago.MontoPago;
     venta.VentaItems.ToList().ForEach(x => VentaItems.Add(new VentaItem(x.Producto, x.Cantidad, x.Precio)));
     MotivoAnulacion  = venta.MotivoAnulada;
     FechaAnulacion   = venta.FechaAnulada;
     UsuarioAnulacion = venta.UsuarioAnulada;
 }
Example #10
0
        public int ObtenerCantidadDeUnidadesDeProducto(string codigoProducto)
        {
            VentaItem ventaItem = VentaItems.FirstOrDefault(x => x.Producto.Codigo == codigoProducto);

            if (ventaItem == null)
            {
                return(0);
            }
            else
            {
                return(ventaItem.Cantidad);
            }
        }
Example #11
0
 private void ActualizarTotalesVenta()
 {
     if (VentaItems.Count == 0)
     {
         CantidadTotal = 0;
         MontoTotal    = new MontoProducto(0, 0);
     }
     else
     {
         CantidadTotal = VentaItems.Sum(x => x.Costo.Cantidad);
         MontoTotal    = VentaItems.Select(x => x.Costo.MontoProducto).Aggregate((x, y) => x + y);
     }
 }
Example #12
0
        public decimal ObtenerPorcentajeBonificacionPorTipoDeCliente(string codigoProducto, TipoCliente tipoCliente)
        {
            VentaItem ventaItem = VentaItems.FirstOrDefault(x => x.Producto.Codigo == codigoProducto);

            if (ventaItem == null)
            {
                throw new NegocioException($"Error al obtener el porcentaje bonificación para el producto código {codigoProducto}. No se encuentran el producto en lo productos ingresado a vender.");
            }
            else
            {
                return(ventaItem.ObtenerPorcentajeBonificacionPorTipoDeCliente(tipoCliente));
            }
        }
Example #13
0
        public decimal ObtenerBonificacionPorListaDePrecion(string codigoProducto, TipoCliente tipoClienteSeleccionado)
        {
            VentaItem ventaItem = VentaItems.FirstOrDefault(x => x.Producto.Codigo == codigoProducto);

            if (ventaItem == null)
            {
                return(0);
            }
            else
            {
                return(ventaItem.Cantidad);
            }
        }
Example #14
0
        // GET: VentaItems/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            VentaItems ventaItems = db.Items.Find(id);

            if (ventaItems == null)
            {
                return(HttpNotFound());
            }
            return(View(ventaItems));
        }
Example #15
0
        public void QuitarPago(long idPago)
        {
            VentaItems.ToList().ForEach(x => x.QuitarPago(idPago));

            VentaPago pago = Pagos.FirstOrDefault(x => x.Id == idPago);

            Pagos.Remove(pago);

            if (pago.TipoPago == TipoPago.Cheque)
            {
                QuitarChequeDesdePago(pago);
            }

            ActualizarTotalesPago();
        }
Example #16
0
        private bool AgregarVentaItemSuelto(ModeloVenta.Producto producto)
        {
            ProductoSueltoForm productoSueltoForm = new ProductoSueltoForm();

            if (productoSueltoForm.ShowDialog() == DialogResult.Cancel)
            {
                return(false);
            }

            decimal montoSuelto = productoSueltoForm.Monto;

            VentaItems.Add(new VentaItem(producto, 1, montoSuelto));

            return(true);
        }
Example #17
0
        private bool AgregarVentaItem(ModeloVenta.Producto producto)
        {
            int cantidad = Cantidad > 0 ? Cantidad : 1;

            VentaItem ventaItems = VentaItems.FirstOrDefault(x => x.Codigo == producto.Codigo);

            if (ventaItems == null)
            {
                VentaItems.Add(new VentaItem(producto, cantidad, producto.Precio));
            }
            else
            {
                ventaItems.Cantidad += cantidad;
            }

            return(true);
        }
Example #18
0
        public void ActualizarVentaItem(string codigoProducto, decimal monto, int cantidad, decimal porcentajeBonificacion, decimal porcentajeFacturacion, TipoCliente tipoCliente)
        {
            if (porcentajeBonificacion > 1)
            {
                porcentajeBonificacion = 1;
            }

            VentaItem ventaItem = VentaItems.FirstOrDefault(x => x.Producto.Codigo == codigoProducto);

            ventaItem.ActualizarMontoProducto(monto, cantidad, porcentajeBonificacion, porcentajeFacturacion, tipoCliente);

            OrdenarItemsVenta();

            ActualizarPagos();

            ActualizarTotalesPago();

            ActualizarTotalesVenta();
        }
Example #19
0
        public void QuitarVentaItem(string codigoProducto)
        {
            VentaItem ventaItem = VentaItems.FirstOrDefault(x => x.Producto.Codigo == codigoProducto);

            if (ventaItem == null)
            {
                throw new NegocioException($"Error al quitar el pago. El producto con código {codigoProducto} no se encuentra registrados en la venta.");
            }

            VentaItems.Remove(ventaItem);

            OrdenarItemsVenta();

            ActualizarPagos();

            ActualizarTotalesPago();

            ActualizarTotalesVenta();
        }
Example #20
0
        public void AgregaPago(Pago pago)
        {
            if (VentaItems.Count == 0)
            {
                throw new NegocioException("Error al registrar el pago. No se encuentran productos registrados en la venta.");
            }
            if (EstaPaga)
            {
                throw new NegocioException("Error al registrar el pago. La venta ya cuenta con el/los pagos necesarios para ser finalizada.");
            }

            decimal montoPago = pago.MontoPago.Total;

            foreach (VentaItem ventaItem in VentaItems.Where(x => x.PorcentajePago != 1))
            {
                montoPago = ventaItem.Pagar(montoPago);
            }

            Pagos.Add(pago);
            ActualizarTotalesPago();
        }
Example #21
0
        public void AgregaVentaItem(Producto producto, decimal monto, int cantidad, bool esDevolucion, decimal porcentajeBonificacion, decimal porcentajeFacturacion, TipoCliente tipoCliente, decimal montoProductoMinorista, decimal porcentajeBonificacionMinorista, decimal montoProductoMayorista, decimal porcentajeBonificacionMayorista)
        {
            VentaItem ventaItem = VentaItems.FirstOrDefault(x => x.Producto.Codigo == producto.Codigo);

            if (ventaItem == null)
            {
                ventaItem = new VentaItem(Id, producto, monto, cantidad, esDevolucion, porcentajeBonificacion, porcentajeFacturacion, tipoCliente, montoProductoMinorista, porcentajeBonificacionMinorista, montoProductoMayorista, porcentajeBonificacionMayorista);
                VentaItems.Add(ventaItem);
            }
            else
            {
                ventaItem.ActualizarMontoProducto(monto, cantidad, porcentajeBonificacion, porcentajeFacturacion, tipoCliente);
            }

            OrdenarItemsVenta();

            ActualizarPagos();

            ActualizarTotalesPago();

            ActualizarTotalesVenta();
        }
Example #22
0
        private async Task <ModeloVenta.Producto> BuscarProducto()
        {
            if (string.IsNullOrWhiteSpace(CodigoDescripcion))
            {
                throw new NegocioException(Resources.productoNoExiste);
            }

            VentaItem ventaItem = VentaItems.Where(x => x.Codigo == CodigoDescripcion || x.Descripcion == CodigoDescripcion).FirstOrDefault();

            if (ventaItem != null)
            {
                return(ventaItem.Producto);
            }

            ModeloVenta.Producto producto = await ProductoService.Obtener(CodigoDescripcion);

            if (producto == null)
            {
                throw new NegocioException(Resources.productoNoExiste);
            }

            return(producto);
        }
Example #23
0
        internal async Task GuardarAsyn()
        {
            CobroForm cobroForm = new CobroForm(Total);

            if (cobroForm.ShowDialog() == DialogResult.OK)
            {
                ModeloVenta.Pago pago = new ModeloVenta.Pago(cobroForm.FormaPago, Total, cobroForm.MontoPago, 0, 0);

                IList <ModeloVenta.VentaItem> ventaItems = VentaItems.Select(x => new ModeloVenta.VentaItem(x.Producto, x.Cantidad, x.Precio)).ToList();

                ModeloVenta.Venta venta = new ModeloVenta.Venta(Sesion.Usuario.Alias, ventaItems, pago);
                venta.DisminuirStock();
                await VentaService.Guardar(venta);

                Imprimir(venta);

                VueltoForm vueltoForm = new VueltoForm(pago.Vuelto);
                vueltoForm.ShowDialog();

                VentaItems.Clear();
                NotifyPropertyChanged(nameof(VentaItems));
            }
        }
Example #24
0
 public void DisminuirStock() => VentaItems.ToList().ForEach(x => x.DisminuirStock());
Example #25
0
 public void QuitarPagos()
 {
     VentaItems.ToList().ForEach(x => x.QuitarPagos());
     Pagos.Clear();
     ActualizarTotalesPago();
 }
Example #26
0
 public void QuitarVentaItem(VentaItem ventaItem)
 {
     VentaItems.Remove(ventaItem);
     ActualizarTotalesVenta();
 }
Example #27
0
 public void AgregaVentaItem(VentaItem ventaItem)
 {
     VentaItems.Add(ventaItem);
     ActualizarTotalesVenta();
 }
Example #28
0
 internal void Quitar(VentaItem ventaItems)
 {
     VentaItems.Remove(ventaItems);
     NotifyPropertyChanged(nameof(VentaItems));
 }