public ActionResult Rendering()
        {
            var miniBasketViewModel = new MiniBasketRenderingViewModel
            {
                IsEmpty    = true,
                RefreshUrl = Url.Action("Refresh")
            };

            if (!_transactionLibrary.HasBasket())
            {
                return(View("/Views/MiniBasket/Rendering.cshtml", miniBasketViewModel));
            }

            var cart = GetCart();

            var currency = new Currency()
            {
                ISOCode = cart.CurrencyCode
            };

            miniBasketViewModel.NumberOfItems = (int)cart.Lines.Sum(x => x.Quantity);
            miniBasketViewModel.IsEmpty       = miniBasketViewModel.NumberOfItems == 0;
            miniBasketViewModel.Total         = cart.Total != null ? new Money(cart.Total.Amount, currency.ISOCode) : new Money(0, currency.ISOCode);

            return(View("/Views/MiniBasket/Rendering.cshtml", miniBasketViewModel));
        }
        public MiniBasketRefreshViewModel Refresh()
        {
            var viewModel = new MiniBasketRefreshViewModel
            {
                IsEmpty = true
            };

            if (!_transactionLibrary.HasBasket())
            {
                return(viewModel);
            }

            var purchaseOrder = _transactionLibrary.GetBasket();

            var quantity = purchaseOrder.OrderLines.Sum(x => x.Quantity);

            var total = purchaseOrder.OrderTotal.HasValue
                                ? new Money(purchaseOrder.OrderTotal.Value, purchaseOrder.BillingCurrency.ISOCode)
                                : new Money(0, purchaseOrder.BillingCurrency.ISOCode);

            viewModel.NumberOfItems = quantity.ToString();
            viewModel.IsEmpty       = quantity == 0;
            viewModel.Total         = total.ToString();

            return(viewModel);
        }
        public void Rendering_When_BasketModel_IsNotNull_Should_Return_View_With_Non_Empty_Model()
        {
            // Arrange
            _transactionLibraryInternal.GetBasket().Returns(new PurchaseOrder
            {
                BillingCurrency = new Currency
                {
                    ISOCode = "USD"
                }
            });
            _transactionLibraryInternal.HasBasket().Returns(true);


            // Act
            var result = _controller.Rendering();

            // Assert
            var viewResult = result as ViewResult;
            var model      = viewResult != null ? viewResult.Model as BasketRenderingViewModel : null;

            Assert.NotNull(viewResult);
            Assert.NotNull(model);
            Assert.NotEmpty(model.RefreshUrl);
            Assert.NotEmpty(model.RemoveOrderlineUrl);

            Assert.NotNull(model.OrderTotal);
            Assert.NotNull(model.DiscountTotal);
            Assert.NotNull(model.TaxTotal);
            Assert.NotNull(model.SubTotal);
        }
        public void Rendering_When_Basket_Is_Empty_Should_Return_View_With_Empty_Model()
        {
            //Arrange
            _transactionLibraryInternal.HasBasket().Returns(false);

            //Act
            var result = _controller.Rendering();

            //Assert
            var viewResult = result as ViewResult;
            var model      = viewResult != null ? viewResult.Model as MiniBasketRenderingViewModel : null;

            Assert.NotNull(viewResult);
            Assert.NotNull(model);
            Assert.True(model.IsEmpty);
            Assert.Equal(0, model.NumberOfItems);
            Assert.Null(model.Total);
            Assert.NotEmpty(model.RefreshUrl);
        }
        public ActionResult Rendering()
        {
            var basketModel = new BasketRenderingViewModel();

            if (!_transactionLibrary.HasBasket())
            {
                return(View(basketModel));
            }

            PurchaseOrder basket = _transactionLibrary.GetBasket();

            foreach (var orderLine in basket.OrderLines)
            {
                var orderLineViewModel = new BasketRenderingViewModel.OrderlineViewModel();

                orderLineViewModel.Quantity    = orderLine.Quantity;
                orderLineViewModel.ProductName = orderLine.ProductName;
                orderLineViewModel.Sku         = orderLine.Sku;
                orderLineViewModel.VariantSku  = orderLine.VariantSku;
                orderLineViewModel.Total       = new Money(orderLine.Total.GetValueOrDefault(), basket.BillingCurrency.ISOCode).ToString();
                orderLineViewModel.Discount    = orderLine.Discount;
                orderLineViewModel.Tax         = new Money(orderLine.VAT, basket.BillingCurrency.ISOCode).ToString();
                orderLineViewModel.Price       = new Money(orderLine.Price, basket.BillingCurrency.ISOCode).ToString();
                orderLineViewModel.ProductUrl  = _urlService.GetUrl(_catalogContext.CurrentCatalog,
                                                                    _catalogLibrary.GetProduct(orderLine.Sku));
                orderLineViewModel.PriceWithDiscount = new Money(orderLine.Price - orderLine.UnitDiscount.GetValueOrDefault(), basket.BillingCurrency.ISOCode).ToString();
                orderLineViewModel.OrderLineId       = orderLine.OrderLineId;

                basketModel.OrderLines.Add(orderLineViewModel);
            }

            basketModel.OrderTotal    = new Money(basket.OrderTotal.GetValueOrDefault(), basket.BillingCurrency.ISOCode).ToString();
            basketModel.DiscountTotal = new Money(basket.DiscountTotal.GetValueOrDefault(), basket.BillingCurrency.ISOCode).ToString();
            basketModel.TaxTotal      = new Money(basket.TaxTotal.GetValueOrDefault(), basket.BillingCurrency.ISOCode).ToString();
            basketModel.SubTotal      = new Money(basket.SubTotal.GetValueOrDefault(), basket.BillingCurrency.ISOCode).ToString();

            basketModel.RefreshUrl         = Url.Action("UpdateBasket");
            basketModel.RemoveOrderlineUrl = Url.Action("RemoveOrderline");

            return(View(basketModel));
        }
        public ActionResult Rendering()
        {
            var miniBasketViewModel = new MiniBasketRenderingViewModel
            {
                IsEmpty    = true,
                RefreshUrl = Url.Action("Refresh")
            };

            if (!_transactionLibrary.HasBasket())
            {
                return(View(miniBasketViewModel));
            }

            var purchaseOrder = _transactionLibrary.GetBasket();

            miniBasketViewModel.NumberOfItems = purchaseOrder.OrderLines.Sum(x => x.Quantity);
            miniBasketViewModel.IsEmpty       = miniBasketViewModel.NumberOfItems == 0;
            miniBasketViewModel.Total         = purchaseOrder.OrderTotal.HasValue ?
                                                new Money(purchaseOrder.OrderTotal.Value, purchaseOrder.BillingCurrency.ISOCode)
                                : new Money(0, purchaseOrder.BillingCurrency.ISOCode);

            return(View(miniBasketViewModel));
        }