Example #1
0
        public ActionResult Index(BasketRenderingViewModel model)
        {
            var cartServiceProvider = new CartServiceProvider();
            var cart = GetCart();

            foreach (var orderLine in model.OrderLines)
            {
                var newQuantity = orderLine.Quantity;

                if (model.RemoveOrderlineId == orderLine.OrderLineId)
                {
                    newQuantity = 0;
                }

                var bmw = cart.Lines.First(i => i.Product.ProductId == orderLine.Sku);

                bmw.Quantity = (uint)newQuantity;

                if (newQuantity > 0)
                {
                    var updateCartLinesRequest = new UpdateCartLinesRequest(cart, new Collection <CartLine> {
                        bmw
                    });
                    cartServiceProvider.UpdateCartLines(updateCartLinesRequest);
                }
                else
                {
                    var request = new RemoveCartLinesRequest(cart, cart.Lines.Where(l => l.Product.ProductId == bmw.Product.ProductId).ToArray());
                    cartServiceProvider.RemoveCartLines(request);
                }
            }

            return(Redirect("/Cart"));
        }
        protected CartLinesRequest CreateCartLinesRequest(CommerceEventInstance eventInstance)
        {
            var cart  = MapEventToCartEntity(eventInstance);
            var lines = cart.Lines; // Only the modified lines are passed in the event, so modified equal total cart lines
            CartLinesRequest request;

            if (eventInstance.CommerceEventId == LinesAddedEventId) //TODO: When there will be more events implemented, create an enum thats more maintainable.
            {
                request = new AddCartLinesRequest(cart, lines);
            }
            else if (eventInstance.CommerceEventId == LinesRemovedEventId)
            {
                request = new RemoveCartLinesRequest(cart, lines);
            }
            else
            {
                throw new NotImplementedException($"Tracking for CommerceEvent with id {eventInstance.CommerceEventId} not implemented");
            }

            request.Shop = new Sitecore.Commerce.Entities.Shop {
                Name = eventInstance.ShopName
            };

            return(request);
        }
Example #3
0
        /// <summary>
        /// Initializes a new instance of the <see cref="RemoveLinesFromCartTest"/> class.
        /// </summary>
        public RemoveLinesFromCartTest()
        {
            this.visitorId = Guid.NewGuid();

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

            this.request = new RemoveCartLinesRequest(this.cart, new[] { this.lineToRemove });
            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 RemoveLinesFromCart {
                ClientFactory = clientFactory
            };
        }
Example #4
0
        private CartResult RemoveCartLines(Cart cart, IEnumerable <CartLine> cartLines, bool refreshCart = false)
        {
            Assert.ArgumentNotNull(cart, nameof(cart));
            Assert.ArgumentNotNull(cartLines, nameof(cartLines));

            var request = new RemoveCartLinesRequest(cart, cartLines);

            RefreshCart(request, refreshCart);
            var result = CartServiceProvider.RemoveCartLines(request);

            result.WriteToSitecoreLog();
            return(result);
        }
        /// <summary>
        /// Removes product from the visitor's cart.
        /// </summary>
        /// <param name="cart">The cart.</param>
        /// <param name="cartLines">The cart lines.</param>
        /// <param name="refreshCart">if set to <c>true</c> [refresh cart].</param>
        /// <returns>
        /// the cart result.
        /// </returns>
        protected virtual CartResult RemoveCartLines(Cart cart, IEnumerable <CartLine> cartLines, bool refreshCart = false)
        {
            Assert.ArgumentNotNull(cart, "cart");
            Assert.ArgumentNotNull(cartLines, "cartLine");

            var request = new RemoveCartLinesRequest(cart, cartLines);

            request.RefreshCart(refreshCart);
            var result = this.CartServiceProvider.RemoveCartLines(request);

            Helpers.LogSystemMessages(result.SystemMessages, result);
            return(result);
        }
        /// <summary>
        /// Removes the line item from cart.
        /// </summary>
        /// <param name="storefront">The storefront.</param>
        /// <param name="visitorContext">The visitor context.</param>
        /// <param name="externalCartLineId">The external cart line identifier.</param>
        /// <returns>
        /// The manager response where the modified CommerceCart is returned in the Result.
        /// </returns>
        public virtual ManagerResponse <CartResult, CommerceCart> RemoveLineItemFromCart([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] string externalCartLineId)
        {
            Assert.ArgumentNotNullOrEmpty(externalCartLineId, "externalCartLineId");

            var cartResult = this.LoadCartByName(storefront.ShopName, storefront.DefaultCartName, visitorContext.UserId, false);

            if (!cartResult.Success || cartResult.Cart == null)
            {
                var message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.CartNotFoundError);
                cartResult.SystemMessages.Add(new SystemMessage
                {
                    Message = message
                });
                return(new ManagerResponse <CartResult, CommerceCart>(cartResult, cartResult.Cart as CommerceCart));
            }

            var cartCache = CommerceTypeLoader.CreateInstance <CartCacheHelper>();

            cartCache.InvalidateCartCache(visitorContext.GetCustomerId());

            CommerceCart cart         = cartResult.Cart as CommerceCart;
            var          lineToRemove = cart.Lines.SingleOrDefault(cl => cl.ExternalCartLineId == externalCartLineId);

            if (lineToRemove == null)
            {
                return(new ManagerResponse <CartResult, CommerceCart>(new CartResult {
                    Success = true
                }, cart));
            }

            var removeLinesRequest = new RemoveCartLinesRequest(cart, new[] { new CartLine {
                                                                                  ExternalCartLineId = externalCartLineId, Quantity = lineToRemove.Quantity, Product = lineToRemove.Product
                                                                              } });

            removeLinesRequest.RefreshCart(true);
            var removeLinesResult = this.CartServiceProvider.RemoveCartLines(removeLinesRequest);

            if (removeLinesResult.Success && removeLinesResult.Cart != null)
            {
                cartCache.AddCartToCache(removeLinesResult.Cart as CommerceCart);
            }

            Helpers.LogSystemMessages(removeLinesResult.SystemMessages, removeLinesResult);
            return(new ManagerResponse <CartResult, CommerceCart>(removeLinesResult, removeLinesResult.Cart as CommerceCart));
        }
        public ManagerResponse <CartResult, Cart> RemoveLineItemsFromCart(Cart cart, IEnumerable <string> cartLineIds)
        {
            Assert.ArgumentNotNull(cart, nameof(cart));
            Assert.ArgumentNotNull(cartLineIds, nameof(cartLineIds));

            var cartLineList = new List <CartLine>();

            foreach (var cartLineId in cartLineIds)
            {
                var cartLine = cart.Lines.FirstOrDefault(line => line.ExternalCartLineId == cartLineId);
                cartLineList.Add(cartLine);
            }

            var request = new RemoveCartLinesRequest(cart, cartLineList);
            var serviceProviderResult = this.cartServiceProvider.RemoveCartLines(request);

            return(new ManagerResponse <CartResult, Cart>(serviceProviderResult, serviceProviderResult.Cart));
        }
Example #8
0
        public ManagerResponse <CartResult, CommerceCart> RemoveLineItemFromCart(string userId, string externalCartLineId)
        {
            Assert.ArgumentNotNullOrEmpty(externalCartLineId, nameof(externalCartLineId));

            var cartResult = LoadCartByName(CommerceConstants.CartSettings.DefaultCartName, userId);

            if (!cartResult.Success || cartResult.Cart == null)
            {
                var message = DictionaryPhraseRepository.Current.Get("/System Messages/Cart/Cart Not Found Error", "Could not retrieve the cart for the current user");
                cartResult.SystemMessages.Add(new SystemMessage {
                    Message = message
                });
                return(new ManagerResponse <CartResult, CommerceCart>(cartResult, cartResult.Cart as CommerceCart));
            }

            CartCacheHelper.InvalidateCartCache(userId);

            var cart         = cartResult.Cart as CommerceCart;
            var lineToRemove = cart.Lines.SingleOrDefault(cl => cl.ExternalCartLineId == externalCartLineId);

            if (lineToRemove == null)
            {
                return(new ManagerResponse <CartResult, CommerceCart>(new CartResult {
                    Success = true
                }, cart));
            }

            var removeLinesRequest = new RemoveCartLinesRequest(cart, new[] { lineToRemove });

            RefreshCart(removeLinesRequest, true);
            var removeLinesResult = CartServiceProvider.RemoveCartLines(removeLinesRequest);

            if (removeLinesResult.Success && removeLinesResult.Cart != null)
            {
                CartCacheHelper.AddCartToCache(removeLinesResult.Cart as CommerceCart);
            }

            AddBasketErrorsToResult(removeLinesResult.Cart as CommerceCart, removeLinesResult);

            removeLinesResult.WriteToSitecoreLog();
            return(new ManagerResponse <CartResult, CommerceCart>(removeLinesResult, removeLinesResult.Cart as CommerceCart));
        }
        /// <summary>
        /// Removes product from the visitor's cart.
        /// </summary>
        /// <param name="externalCartLineId">
        /// The product id.
        /// </param>
        /// <returns>
        /// The <see cref="Cart"/>.
        /// </returns>
        public Cart RemoveFromCart(string externalCartLineId)
        {
            Assert.ArgumentNotNull(externalCartLineId, "externalCartLineId");

            var cart = this.GetCart();

            if (string.IsNullOrWhiteSpace(cart.ShopName))
            {
                cart.ShopName = this.ShopName;
            }

            var lineToRemove = cart.Lines.SingleOrDefault(cl => cl.ExternalCartLineId == externalCartLineId);

            if (lineToRemove == null)
            {
                return(cart);
            }

            var request = new RemoveCartLinesRequest(cart, new[] { lineToRemove });

            var cartResult = this._cartServiceProvider.RemoveCartLines(request);

            return(this.UpdatePrices(cartResult.Cart));
        }
        public PipelineExecutionResult Execute(IPipelineArgs <UpdateLineItemRequest, UpdateLineItemResponse> subject)
        {
            if (subject.Request.Properties.ContainsKey("FromUCommerce"))
            {
                if (!(bool)subject.Request.Properties["FromUCommerce"])
                {
                    return(PipelineExecutionResult.Success);
                }
            }

            if (subject.Request.Quantity == 0)
            {
                var cart                = MappingLibrary.MapPurchaseOrderToCart(subject.Request.OrderLine.PurchaseOrder);
                var cartLine            = MappingLibrary.MapOrderLineToCartLine(subject.Request.OrderLine);
                var cartServiceProvider = new CartServiceProvider();

                var request = new RemoveCartLinesRequest(cart, new Collection <CartLine> {
                    cartLine
                });
                request.Properties["FromUCommerce"] = true;
                cartServiceProvider.RemoveCartLines(request);
            }
            return(PipelineExecutionResult.Success);
        }
        /// <summary>
        /// Removes product from the visitor's cart.
        /// </summary>
        /// <param name="cart">The cart.</param>
        /// <param name="cartLines">The cart lines.</param>
        /// <param name="refreshCart">if set to <c>true</c> [refresh cart].</param>
        /// <returns>
        /// the cart result.
        /// </returns>
        protected virtual CartResult RemoveCartLines(Cart cart, IEnumerable<CartLine> cartLines, bool refreshCart = false)
        {
            Assert.ArgumentNotNull(cart, "cart");
            Assert.ArgumentNotNull(cartLines, "cartLine");

            var request = new RemoveCartLinesRequest(cart, cartLines);
            request.RefreshCart(refreshCart);
            var result = this.CartServiceProvider.RemoveCartLines(request);

            Helpers.LogSystemMessages(result.SystemMessages, result);
            return result;
        }
        /// <summary>
        /// Removes the line item from cart.
        /// </summary>
        /// <param name="storefront">The storefront.</param>
        /// <param name="visitorContext">The visitor context.</param>
        /// <param name="externalCartLineId">The external cart line identifier.</param>
        /// <returns>
        /// The manager response where the modified CommerceCart is returned in the Result.
        /// </returns>
        public virtual ManagerResponse<CartResult, CommerceCart> RemoveLineItemFromCart([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] string externalCartLineId)
        {
            Assert.ArgumentNotNullOrEmpty(externalCartLineId, "externalCartLineId");

            // We remove the curly brackets from the JSON for the lineitem id.  We need to add them back.
            externalCartLineId = Guid.Parse(externalCartLineId).ToString("B");

            var cartResult = this.LoadCartByName(storefront.ShopName, storefront.DefaultCartName, visitorContext.UserId, false);
            if (!cartResult.Success || cartResult.Cart == null)
            {
                var message = StorefrontManager.GetSystemMessage("CartNotFoundError");
                cartResult.SystemMessages.Add(new SystemMessage { Message = message });
                return new ManagerResponse<CartResult, CommerceCart>(cartResult, cartResult.Cart as CommerceCart);
            }

            var cartCache = CommerceTypeLoader.CreateInstance<CartCacheHelper>();
            cartCache.InvalidateCartCache(visitorContext.GetCustomerId());

            CommerceCart cart = cartResult.Cart as CommerceCart;
            var lineToRemove = cart.Lines.SingleOrDefault(cl => cl.ExternalCartLineId == externalCartLineId);
            if (lineToRemove == null)
            {
                return new ManagerResponse<CartResult, CommerceCart>(new CartResult { Success = true }, cart);
            }

            var removeLinesRequest = new RemoveCartLinesRequest(cart, new[] { lineToRemove });
            removeLinesRequest.RefreshCart(true);
            var removeLinesResult = this.CartServiceProvider.RemoveCartLines(removeLinesRequest);
            if (removeLinesResult.Success && removeLinesResult.Cart != null)
            {
                cartCache.AddCartToCache(removeLinesResult.Cart as CommerceCart);
            }

            this.AddBasketErrorsToResult(removeLinesResult.Cart as CommerceCart, removeLinesResult);

            Helpers.LogSystemMessages(removeLinesResult.SystemMessages, removeLinesResult);
            return new ManagerResponse<CartResult, CommerceCart>(removeLinesResult, removeLinesResult.Cart as CommerceCart);
        }