Ejemplo n.º 1
0
        public MenuViewModel(Menu menu, Cart cart)
        {
            List<CartLine> tempLines = new List<CartLine>();

            foreach (var dish in menu.Dishes)
            {
                CartLine line = new CartLine() {Dish = dish};

                if (cart.Contains(dish))
                {
                    line.Quantity = cart.Get(dish).Quantity;
                }

                tempLines.Add(line);
            }

            Starters = tempLines
                .Where(x => x.Dish.DishType == DishType.Starter)
                .ToList();

            MainDishes = tempLines
                .Where(x => x.Dish.DishType == DishType.MainDish)
                .ToList();

            Deserts = tempLines
                .Where(x => x.Dish.DishType == DishType.Desert)
                .ToList();
        }
Ejemplo n.º 2
0
 public void AddToCart(Product p)
 {
     if (lineItems.Find(li=>li.product.ProductID==p.ProductID)!=null)
     {
         CartLine cartLine = lineItems.Find(li => li.product.ProductID == p.ProductID);
         cartLine.quantity += 1;
     }
     else
     {
         CartLine cartLine = new CartLine();
         cartLine.product = p;
         cartLine.quantity = 1;
         lineItems.Add(cartLine);
     }
 }
Ejemplo n.º 3
0
        [HttpPost] // it is critical that the parameter has the same name as the <select> tag.
        public IActionResult CartLineForm(string itmSelect) // ----------------------------------------
        {
            // action method to display info from CiFilteredList.itmSelect <select>tag return 
            // from CartForm 

            if (itmSelect != null)
            {
                CartLine cl;
                CatalogItem c = repository.CatalogItems.FirstOrDefault(ci => ci.ItemId == itmSelect);

                // cast CatalogItem object to CartLine type
                cl = new CartLine(c);

                //  call CartForm view to enable input additional information as CartLine 
                return View(cl);
            }
            else
            {
                return RedirectToAction("/Home/Index");
            }

        } //eo CartLineForm  -----------------------------------------------------------------------------       
Ejemplo n.º 4
0
        /// <summary>
        /// Creates the cart.
        /// </summary>
        /// <returns>Cart with one line item.</returns>
        public Cart CreateCart()
        {
            var shoppingCartId = GenerateTransactionId();
            var cart           = new Cart
            {
                Id         = shoppingCartId,
                CustomerId = this.Customer.AccountNumber,
                CartType   = CartType.Checkout
            };

            OrderManager.CreateOrUpdateCart(cart, 0);

            //// get cart line from the product
            var variants  = this.Product.CompositionInformation.VariantInformation.IndexedVariants;
            var variantId = variants.Keys.FirstOrDefault();

            var productVariant = variants[variantId];

            var cartLines = new Collection <CartLine>();
            var cartLine  = new CartLine();

            var cartLineData = new CartLineData
            {
                ItemId = productVariant.ItemId,
                InventoryDimensionId = productVariant.InventoryDimensionId,
                ProductId            = productVariant.DistinctProductVariantId,
                Quantity             = 1,
                Comment            = string.Empty,
                ["ProductDetails"] = string.Empty
            };

            cartLine.LineData = cartLineData;
            cartLines.Add(cartLine);

            var modes = CalculationModes.Totals | CalculationModes.Discounts | CalculationModes.Prices;

            return(OrderManager.AddCartLines(shoppingCartId, this.Customer.AccountNumber, cartLines, new CalculationModes?(modes)));
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="UpdateLinesOnCartTest"/> class.
        /// </summary>
        public UpdateLinesOnCartTest()
        {
            this.visitorId = Guid.NewGuid();

            this.lineToUpdate = new CartLine
            {
                ExternalCartLineId = "LineId2",
                Product            = new CartProduct
                {
                    ProductId = "100500",
                    Price     = new Price {
                        Amount = 100
                    }
                },
                Quantity = 12
            };
            this.cart = new Cart
            {
                ExternalId = this.visitorId.ToString(),
                Lines      = new ReadOnlyCollection <CartLine>(new List <CartLine> {
                    new CartLine(), this.lineToUpdate
                })
            };

            this.request = new UpdateCartLinesRequest(this.cart, new[] { this.lineToUpdate });
            this.result  = new CartResult();
            this.args    = new ServicePipelineArgs(this.request, this.result);

            this.client = Substitute.For <ICartsServiceChannel>();

            var clientFactory = Substitute.For <ServiceClientFactory>();

            clientFactory.CreateClient <ICartsServiceChannel>(Arg.Any <string>(), Arg.Any <string>()).Returns(this.client);

            this.processor = new UpdateLinesOnCart {
                ClientFactory = clientFactory
            };
        }
        public ActionResult OrderList(int page = 1, int category = 0)
        {
            List <OrderDetailItem> orderDetailItemList = _orderDetailService.GetAllItems();
            string actionName     = CookieHelper.GetPropertyNameFromCookies("action");
            string controllerName = CookieHelper.GetPropertyNameFromCookies("controller");

            CartLine cartList    = new CartLine();
            string   userName    = "";
            bool     isCompleted = false;
            int      orderNumber = 0;

            foreach (var item in orderDetailItemList)
            {
                cartList    = JsonConvert.DeserializeObject <CartLine>(item.List);
                userName    = item.UserName;
                isCompleted = item.IsCompleted;
                orderNumber = item.OrderDetailId;
            }

            OrderDetailViewModel orderDetailViewModel = new OrderDetailViewModel
            {
                OrderDetailItemList = orderDetailItemList.Skip((page - 1) * PageSize).Take(5).ToList(),
                CartList            = cartList,
                UserName            = userName,
                IsCompleted         = isCompleted,
                OrderNumber         = orderNumber,
                Route      = String.Format("/{0}/{1}", controllerName, actionName),
                PagingInfo = new PagingInfo
                {
                    ItemsPerPage    = PageSize,
                    TotalItems      = orderDetailItemList.Count(),
                    CurrentPage     = page,
                    CurrentCategory = category
                }
            };

            return(View(orderDetailViewModel));
        }
        public void ShouldLeaveThePriceIntactIfFailedToRetrievePrices()
        {
            // arrange
            var cartLine = new CartLine {
                Product = new CartProduct {
                    ProductId = "TestProductId"
                }
            };

            this.cart.Lines = new ReadOnlyCollectionAdapter <CartLine> {
                cartLine
            };

            var result = new GetProductPricesResult();

            this.pricingService.GetProductPrices(Arg.Is <GetProductPricesRequest>(r => r.ProductId == "TestProductId")).Returns(result);

            // act
            var cartModel = this.service.GetCart();

            // assert
            cartModel.Lines.Single().Product.Price.Should().BeNull();
        }
Ejemplo n.º 8
0
        public void Can_Mark_Shipped()
        {
            // Arrange
            var mock     = new Mock <IOrderRepository>();
            var cartLine = new CartLine {
                Product = new Product(), Quantity = 1
            };
            var order = new Order {
                OrderId = 1, Shipped = false, Lines = new[] { cartLine }
            };

            mock.Setup(m => m.Orders).Returns(new[] { order }.AsQueryable());

            var controller = new OrderController(mock.Object, new Cart());

            // Act
            var result = controller.MarkShipped(1) as RedirectToActionResult;

            // Assert
            mock.Verify(m => m.SaveOrder(order), Times.Once);
            Assert.True(order.Shipped);
            Assert.Equal("List", result.ActionName);
        }
Ejemplo n.º 9
0
        public virtual void Initialize(Order order)
        {
            this.OrderId = order.OrderID;
            foreach (CartLine line in order.Lines)
            {
                CartLine orderLine = line;
                OrderLineVariantRenderingModel model = this.ModelProvider.GetModel <OrderLineVariantRenderingModel>();

                Party        party    = null;
                ShippingInfo shipping = order.Shipping.FirstOrDefault(s => s.LineIDs.ToList().Contains(orderLine.ExternalCartLineId));
                if (shipping != null)
                {
                    party = order.Parties.FirstOrDefault(p => p.ExternalId.Equals(shipping.PartyID, StringComparison.OrdinalIgnoreCase));
                }

                model.Initialize(orderLine, shipping, party);
                this.Lines.Add(model);
            }
            this.StoreOrder     = order.Status.ToLower() == "storeorder" ? true : false;
            this.StoreName      = !String.IsNullOrEmpty(order.ShopName) ? GetDisplayName(order.ShopName) : "";
            this.TrackingNumber = order.TrackingNumber;
            this.InitializeDataSourceValues();
        }
Ejemplo n.º 10
0
        //This is the base method that enables an item to be added to a cart
        public virtual void AddItem(Book book, int qty)
        {
            //grab the line that stores the book that is being added
            CartLine line = Lines
                .Where(p => p.Book.BookID == book.BookID)
                .FirstOrDefault();

            //If nothing is returned, the book is not currently in the Lines list
            //If that is the case, add the book to the list and set the qty of for that book
            if (line == null)
            {
                Lines.Add(new CartLine
                {
                    Book = book,
                    Quantity = qty
                });
            }
            //If the book is already in the list, increase the quantity
            else
            {
                line.Quantity += qty;
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Adds specified quantity of product to cart.
        /// </summary>
        /// <param name="cart">Cart</param>
        /// <param name="product">Add this product to cart.</param>
        /// <param name="quantity">Add specified quantity.</param>
        public void AddItem(Cart cart, Product product, int quantity = 1)
        {
            CartLine line = cart.CartLines
                            ?.Where(p => p.Product.ID == product.ID)
                            .DefaultIfEmpty()
                            .FirstOrDefault();

            if (line == null)
            {
                line = new CartLine
                {
                    Product  = product,
                    Quantity = quantity,
                    Cart_Id  = cart.ID
                };
                cart.CartLines.Add(line);
            }
            else
            {
                line.Quantity += quantity;
            }
            Update(cart);
        }
Ejemplo n.º 12
0
        public void When_Map_CartLine_To_ViewModel_Expect_Valid_Properties()
        {
            //Arrange
            var cartLine = new CartLine()
            {
                Amount = 5, Id = 1, Product = new Product()
                {
                    Description = "description", Id = 15, Name = "name", Price = 19.95
                }
            };

            //Act
            var viewModel = _mapper.Map <CartLineViewModel>(cartLine);

            //Assert
            Assert.Equal(cartLine.Id, viewModel.Id);
            Assert.Equal(cartLine.Amount, viewModel.Amount);
            Assert.Equal(cartLine.Product.Id, viewModel.Product.Id);
            Assert.Equal(cartLine.Product.Description, viewModel.Product.Description);
            Assert.Equal(cartLine.Product.Name, viewModel.Product.Name);
            Assert.Equal(cartLine.Product.Price, viewModel.Product.Price);
            Assert.Equal(cartLine.Product.Price * cartLine.Amount, viewModel.TotalPrice);
        }
Ejemplo n.º 13
0
        //Pass in the project object and the quantity
        public void AddItem(Project proj, int quant)
        {
            //New instance of a cart line, created here
            //Go out to lines and look first in the list for the BookId and the one that's been added
            CartLine line = Lines
                            .Where(p => p.Project.BookId == proj.BookId)
                            .FirstOrDefault();

            //Check if they match, and if not add a new CartLine
            if (line == null)
            {
                Lines.Add(new CartLine
                {
                    Project  = proj,
                    Quantity = quant
                });
            }
            //Otherwise, update quantity
            else
            {
                line.Quantity += quant;
            }
        }
Ejemplo n.º 14
0
        public void CalcualteTotal(List <CartLine> cartLines)
        {
            decimal total;
            // seperate out each kind of prodcut from the orderlist and
            // apply the promotional discount accordingly.


            CartLine productA = new CartLine();
            CartLine productB = new CartLine();
            CartLine productC = new CartLine();

            foreach (CartLine cartline in cartLines)
            {
                if (cartline.Product.Name == ProductType.A)
                {
                    productA = cartline;
                }
                if (cartline.Product.Name == ProductType.B)
                {
                    productB = cartline;
                }
                if (cartline.Product.Name == ProductType.c)
                {
                    productC = cartline;
                }
            }
            ComputeTotalValueBase computeTotalA = CartLineComputeTotalService.GetComputedPaymentFor(ProductType.A);

            Buy1Get1Total = computeTotalA.ComputeTotalValue(productA);
            ComputeTotalValueBase computeTotalB = CartLineComputeTotalService.GetComputedPaymentFor(ProductType.B);

            ThreeFor10Total = computeTotalB.ComputeTotalValue(productB);
            ComputeTotalValueBase computeTotalC = CartLineComputeTotalService.GetComputedPaymentFor(ProductType.c);

            NoOfferTotal = computeTotalC.ComputeTotalValue(productC);
            Total        = Buy1Get1Total + ThreeFor10Total + NoOfferTotal;
        }
        public ManagerResponse <CartResult, Cart> UpdateLineItemsInCart(Cart cart, IEnumerable <CartLineArgument> cartLines, string giftCardProductId, string giftCardPageLink)
        {
            Assert.ArgumentNotNull(cart, nameof(cart));
            Assert.ArgumentNotNull(cartLines, nameof(cartLines));

            var cartLineList = new List <CartLine>();

            foreach (CartLineArgument cartLine in cartLines)
            {
                Assert.ArgumentNotNullOrEmpty(cartLine.ProductId, "inputModel.ProductId");
                Assert.ArgumentNotNullOrEmpty(cartLine.CatalogName, "inputModel.CatalogName");
                Assert.ArgumentNotNull(cartLine.Quantity, "inputModel.Quantity");
                decimal quantity = cartLine.Quantity;

                bool Selector(CartLine x)
                {
                    var product = (CommerceCartProduct)x.Product;

                    return(x.Product.ProductId == cartLine.ProductId && product.ProductVariantId == cartLine.VariantId && product.ProductCatalog == cartLine.CatalogName);
                }

                CartLine commerceCartLine = cart.Lines.FirstOrDefault(Selector)
                                            ?? new CommerceCartLine(cartLine.CatalogName, cartLine.ProductId, cartLine.VariantId == "-1" ? null : cartLine.VariantId, quantity);
                commerceCartLine.Quantity = quantity;
                cartLineList.Add(commerceCartLine);
            }

            var request          = new UpdateCartLinesRequest(cart, cartLineList);
            var updateCartResult = this.cartServiceProvider.UpdateCartLines(request);

            if (!updateCartResult.Success)
            {
                updateCartResult.SystemMessages.LogSystemMessages(this);
            }

            return(new ManagerResponse <CartResult, Cart>(updateCartResult, updateCartResult.Cart));
        }
Ejemplo n.º 16
0
 private void SetQteOrItem(decimal qte, CartLine cart)
 {
     try
     {
         var exited = CurrentTicket?.CarteLines?.Where(a => a == cart).FirstOrDefault();
         if (exited != null)
         {// Just add qts
             exited.Qts = qte;
         }
         else
         {
             //AllCartLines?.Add(cart);
         }
         if (CurrentTicket != null)
         {
             CurrentTicket.EstEnvoyerCuisine = false;
         }
         CreateCartLines();
     }
     catch (Exception s)
     {
         MessageQueue.Enqueue(s.Message);
     }
 }
Ejemplo n.º 17
0
        public async void When_CartLine_Is_Updated_Expect_Ok_StatusCode_And_Updated_Amount()
        {
            //Arrange
            var newAmount = 10;

            var product     = _fixture.GenerateProduct();
            var newCartLine = new CartLine()
            {
                ProductId = product.Id, Amount = 5
            };
            await _fixture.Context.CartLines.AddAsync(newCartLine);

            await _fixture.Context.SaveChangesAsync();

            var content = new StringContent(JsonConvert.SerializeObject(new UpdateCartLineDTO()
            {
                LineId = newCartLine.Id, Amount = newAmount
            }), Encoding.UTF8, "application/json");

            //Act
            var response = await _fixture.Client.PutAsync("api/cart/" + newCartLine.Id, content);

            //Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            var result = await response.Content.ReadAsStringAsync();

            var viewModel = JsonConvert.DeserializeObject <CartLineViewModel>(result);

            Assert.Equal(newCartLine.Id, viewModel.Id);
            Assert.Equal(newAmount, viewModel.Amount);

            await _fixture.Context.Entry(newCartLine).ReloadAsync(); //reload entity to refresh data

            ;
            Assert.Equal(newAmount, newCartLine.Amount);
        }
        public Result <CartModel> UpdateProductVariantQuantity(string productId, string variantId, decimal quantity)
        {
            ManagerResponse <CartResult, Cart> model = this.CartManager.GetCurrentCart(this.StorefrontContext.ShopName, this.VisitorContext.ContactId);

            CartLine cartLine = model.Result.Lines.FirstOrDefault(x =>
            {
                var current = x.Product as CommerceCartProduct;
                return(current?.ProductId == productId && current?.ProductVariantId == variantId);
            });

            if (cartLine != null)
            {
                if (quantity <= 0)
                {
                    return(this.RemoveProductVariantFromCart(cartLine.ExternalCartLineId));
                }

                var cartLineArgument = new CartLineArgument
                {
                    CatalogName = this.StorefrontContext.CatalogName,
                    ProductId   = productId,
                    Quantity    = quantity,
                    VariantId   = variantId
                };

                ManagerResponse <CartResult, Cart> cart = this.CartManager.UpdateLineItemsInCart(model.Result, new[] { cartLineArgument }, null, null);
                Result <CartModel> result = this.GetCart(cart.ServiceProviderResult, cart.Result);
                return(result);
            }
            else if (quantity > 0)
            {
                return(this.AddProductVariantToCart(productId, variantId, quantity));
            }

            return(null);
        }
Ejemplo n.º 19
0
        //the Virtual keyword will allow you to override members of a class
        public virtual void AddItem(Book book, int qty)
        //public void AddItem(Book book, int qty, double price)
        {
            //the next block will check to see if you have the selected item in your cart
            CartLine line = Lines
                            .Where(b => b.Book.BookId == book.BookId)
                            .FirstOrDefault();

            //if you don't, it'll add it to the cart
            if (line == null)
            {
                Lines.Add(new CartLine
                {
                    Book     = book,
                    Quantity = qty
                               //Price = (decimal)price
                });
            }
            //if you do, it'll update the quantity rather than adding the item twice
            else
            {
                line.Quantity += qty;
            }
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Initializes a new instance of the <see cref="CartLineModel" /> class.
        /// </summary>
        /// <param name="line">The line.</param>
        /// <param name="productName">Name of the product.</param>
        public CartLineModel([NotNull] CartLine line, string productName = null)
        {
            Assert.ArgumentNotNull(line, "line");

            this.Id       = line.ExternalCartLineId;
            this.Quantity = line.Quantity;

            if (line.Product != null)
            {
                this.ProductId = line.Product.ProductId;

                if (line.Product.Price != null)
                {
                    this.UnitPrice = line.Product.Price.Amount;
                }

                this.ProductName = productName ?? line.Product.ProductId;
            }

            if (line.Total != null)
            {
                this.TotalPrice = line.Total.Amount.ToString("C", Context.Language.CultureInfo);
            }
        }
        public void ShouldGetPriceForProduct()
        {
            // arrange
            var cartLine = new CartLine {
                Product = new CartProduct {
                    ProductId = "TestProductId"
                }
            };

            this.cart.Lines = new ReadOnlyCollectionAdapter <CartLine> {
                cartLine
            };

            var result = new GetProductPricesResult();

            result.Prices.Add("List", new Price(10.50m, "USD"));
            this.pricingService.GetProductPrices(Arg.Is <GetProductPricesRequest>(r => r.ProductId == "TestProductId")).Returns(result);

            // act
            var cartModel = this.service.GetCart();

            // assert
            cartModel.Lines.Single().Product.Price.Amount.Should().Be(10.50m);
        }
    /// <summary>
    /// Changes the lines.
    /// </summary>
    /// <param name="cartModel">The cart model.</param>
    /// <param name="client">The client.</param>
    /// <param name="cartLine">The cart line.</param>
    /// <returns>The changed cart model.</returns>
    protected override ShoppingCartModel ChangeLines(ShoppingCartModel cartModel, ICartsServiceChannel client, CartLine cartLine)
    {
      if (cartLine.Product != null)
      {
        cartModel = client.UpdateQuantity(cartModel.CustomerGuid, cartLine.Product.ProductId, (int)cartLine.Quantity);
      }

      return cartModel;
    }
Ejemplo n.º 23
0
        public JsonResult AddToCart(Cart cart, string productId, int quantity = 1)
        {
            bool addNew         = false;
            var  warningMessage = "";

            if (quantity < 0)
            {
                quantity = 1;
            }

            var product = _productRepo.FindById(productId);

            if (product != null)
            {
                CartLine line = cart.LineCollection.Where(p => p.Product.Id == product.Id).FirstOrDefault();

                if (product.Quantity != 0)
                {
                    if (quantity != 0)
                    {
                        if (line == null)
                        {
                            line = new CartLine
                            {
                                Product  = product,
                                Quantity = quantity
                            };
                            product.Images = _productRepo.GetImages(product.Id).ToList();
                            if (product.Images.Count == 0)
                            {
                                product.Images.Add(ImageLinks.BrokenProductImage);
                            }

                            cart.LineCollection.Add(line);
                            addNew = true;
                        }
                        else
                        {
                            line.Quantity += quantity;
                        }
                    }

                    if (line.Quantity > product.Quantity)
                    {
                        line.Quantity  = product.Quantity;
                        warningMessage = "Some product is out of stock, so you can only set max quantity we have in stock!";
                    }
                }
                else
                {
                    warningMessage = "Some product is out of stock, so you can only set max quantity we have in stock!";
                }
            }

            return(Json(new
            {
                success = true,
                addNew = addNew,
                warningMessage = warningMessage,
                cart = cart,
                summary = cart.Summary,
                summaryQuantity = cart.SummaryQuantity
            }));
        }
        public ActionResult UpdateQuantity(Cart cart, CartLine line)
        {
            CartLine lineItem = cart.Lines.First(p => p.Product.ProductID == line.Product.ProductID);

            lineItem.Quantity = line.Quantity;

            CartIndexViewModel model = new CartIndexViewModel
                                           {
                                               Cart = cart,
                                               ReturnUrl = "",
                                               Total = cart.ComputeTotalValue()
                                           };

            //return Json(new { success = true, lineTotal = lineItem.LineTotal, total = cart.ComputeTotalValue() });

            return Json(new {success = true, model});
        }
Ejemplo n.º 25
0
        private static CommerceShippingInfo GetOrderLineShippingInfo(CommerceOrder commerceOrder, CartLine orderLine)
        {
            var uniqueShippingInfo = commerceOrder.Shipping.FirstOrDefault(shipping => shipping.LineIDs.ToList().Contains(orderLine.ExternalCartLineId) && shipping.LineIDs.Count == 1) as CommerceShippingInfo;

            if (uniqueShippingInfo != null)
            {
                return(uniqueShippingInfo);
            }
            return(commerceOrder.Shipping.FirstOrDefault(s => s.LineIDs.Contains(orderLine.ExternalCartLineId)) as CommerceShippingInfo);
        }
Ejemplo n.º 26
0
        public void ChangeQuantity(Product prod, int quantity)
        {
            CartLine cline = line.Find(x => x.Product.ID == prod.ID);

            cline.Quantity = quantity;
        }
        [ProducesResponseType(500)] //Returned when there was an error in the repo
        public ActionResult <CartLine> GetCartLine(long id)
        {
            CartLine cartLine = _repo.Find(id);

            return(cartLine ?? (ActionResult <CartLine>)NotFound());
        }
Ejemplo n.º 28
0
 private static bool DoesProductIdMatch(string productId, CartLine cartLine)
 {
     return((cartLine.Product.ProductId.Contains("|")
                ? cartLine.Product.ProductId.Split('|')[1]
                : cartLine.Product.ProductId) == productId);
 }
Ejemplo n.º 29
0
        private AddToBasketPipelineArgs GetAddToBasketPipelineArgs(ICatalogContext catalogContext, PurchaseOrder purchaseOrder, CartLine cartLine)
        {
            var addToBasketPipelineArgs = new AddToBasketPipelineArgs(
                new AddToBasketRequest
            {
                AddToExistingOrderLine = true,
                ExecuteBasketPipeline  = false,
                PriceGroup             = catalogContext.CurrentPriceGroup,
                Product       = GetProduct(cartLine.Product),
                PurchaseOrder = purchaseOrder,
                Quantity      = (int)cartLine.Quantity
            },
                new AddToBasketResponse());

            addToBasketPipelineArgs.Request.Properties["FromUCommerce"] = false;

            return(addToBasketPipelineArgs);
        }
Ejemplo n.º 30
0
        public IActionResult RemoveFromCart([DataSourceRequest] DataSourceRequest request, CartLine cartLine)
        {
            var cart = GetCart();

            cart.RemoveLine(cartLine.Id);
            HttpContext.Session.SetObjectAsJson(sessionKey, cart);
            return(Json(ModelState.ToDataSourceResult()));
        }
Ejemplo n.º 31
0
 public IViewComponentResult Invoke(CartLine line)
 {
     return(View(line));
 }
 public virtual OrderLine MapCartLineToOrderLine(CartLine cartLine)
 {
     return(_mapCartLineToOrderLine.Map(cartLine));
 }
Ejemplo n.º 33
0
 public override void Initialize(CartLine cartLine, ShippingInfo shippingInfo, Sitecore.Commerce.Entities.Party party)
 {
     base.Initialize(cartLine, shippingInfo, party);
 }