コード例 #1
0
        private BasketViewModel CreateViewModelFromBasket(Basket basket)
        {
            var pricesAndQuantities = basket.Items.Select(i => new System.Tuple <decimal, int>(i.UnitPrice, i.Quantity));
            var totals = OrderCalculator.CalculateTotals(pricesAndQuantities);

            return(new BasketViewModel
            {
                Id = basket.Id,
                BuyerId = basket.BuyerId,
                SubTotal = totals.SubTotal,
                Tax = totals.Tax,
                Total = totals.Total,
                Items = basket.Items.Select(i =>
                {
                    var itemModel = new BasketItemViewModel
                    {
                        Id = i.Id,
                        UnitPrice = i.UnitPrice,
                        Quantity = i.Quantity,
                        CatalogItemId = i.CatalogItemId
                    };
                    var item = _itemRepository.GetById(i.CatalogItemId);
                    itemModel.PictureUrl = _uriComposer.ComposePicUri(item.PictureUri);
                    itemModel.ProductName = item.Name;
                    return itemModel;
                })
                        .ToList()
            });
        }
コード例 #2
0
    private void PopulateShoppingCartControls()
    {
        if (StoreContext.ShoppingCart.GetCartItems().Length > 0)
        {
            uxShoppingCartPanel.Visible = true;
            uxTotalAmountLabel.Text     = uxCurrencyControl.CurrentCurrency.FormatPrice(GetShoppingCartTotal());

            OrderCalculator orderCalculator = new OrderCalculator();
            decimal         discount        = orderCalculator.GetPreCheckoutDiscount(
                StoreContext.Customer,
                StoreContext.ShoppingCart.SeparateCartItemGroups(),
                StoreContext.CheckoutDetails.Coupon);

            if (discount > 0)
            {
                uxDiscountTR.Visible       = true;
                uxDiscountAmountLabel.Text = uxCurrencyControl.CurrentCurrency.FormatPrice(discount * -1);
            }
            else
            {
                uxDiscountTR.Visible = false;
            }

            uxCartItemGrid.DataSource = StoreContext.ShoppingCart.GetCartItems();
            uxCartItemGrid.DataBind();
        }
        else
        {
            uxShoppingCartPanel.Visible = false;
            StoreContext.CheckoutDetails.Clear();
        }
    }
コード例 #3
0
        public void OrderCalculatorTest()
        {
            // Arrange
            AddArticlesTest();

            Customer customer = new Customer();

            Article product1 = articlesService.Get(1);

            Order order = new Order("ZAM 1/2018", customer);

            order.OrderDate = DateTime.Parse("2018-04-13");
            order.AddArticle(product1, 2);

            IStrategy strategy = new HappyDayOfWeekStrategy(DayOfWeek.Friday, 0.3m);

            OrderCalculator calculator = new OrderCalculator(strategy);

            // Acts
            calculator.Calculate(order);

            // Assets
            Assert.AreEqual(6, order.DiscountAmount);
            Assert.IsTrue(order.HasDiscount);
        }
コード例 #4
0
        public void CalculateDiscountTest()
        {
            // Arrange
            Customer customer = new Customer(1, "Sulecki");
            Order    order    = Order.Create(customer);

            order.OrderDate = DateTime.Parse("2018-09-14");

            Product product = new Product("Mouse", 100, "Red");
            Service service = new Service("Developing", 100);

            order.AddDetail(new OrderDetail(product, 10));
            order.AddDetail(new OrderDetail(service, 4));

            IOrderCalculator calculator = new OrderCalculator();

            // Acts
            decimal result = calculator.Calculate(order);

            // Asserts
            Assert.True(result > 0);
            Assert.Equal(1260, result);

            // Polecam: Install-Package FluentAssertions
        }
コード例 #5
0
ファイル: HotcakesApplication.cs プロジェクト: wncoder/core
        public bool CalculateOrderWithoutRepricing(Order o)
        {
            var calc = new OrderCalculator(this);

            calc.SkipRepricing = true;
            return(calc.Calculate(o));
        }
コード例 #6
0
        public void Calculate2DiscountTest()
        {
            // Arrange
            ICanDiscountStrategy canDiscountStrategy = new HappyHoursCanDiscountStrategy(
                TimeSpan.Parse("12:30"),
                TimeSpan.Parse("14:00"));

            IDiscountStrategy discountStrategy = new FixedDiscountStrategy(5);

            OrderCalculator orderCalculator = new OrderCalculator(canDiscountStrategy, discountStrategy);

            Order order = new Order("ZAM 001/2018", new Customer("M", "S"));

            order.CreateDate = DateTime.Parse("2018-06-19 12:30");

            Product product1 = new Product("Monitor", 1000);

            order.Details.Add(new OrderDetail(product1, 10));

            // Acts
            decimal discount = orderCalculator.CalculateDiscount(order);

            // Asserts
            Assert.AreEqual(5, discount);
        }
コード例 #7
0
ファイル: Program.cs プロジェクト: joey3001/CSharpBakery
    public static void Main()
    {
        Console.WriteLine("");
        Console.WriteLine("Hello there! Welcome to Joe's bakery. We have the following specials: ");
        Console.WriteLine("");
        Console.WriteLine("1. Bread is 5 Dollars per Loaf. Buy 2 get 1 free!");
        Console.WriteLine("2. Pastries are 2 Dollars each, or 3 for 5 Dollars!");
        Console.WriteLine("");
        Console.WriteLine("Enter the number of bread loafs you'd like to purchase: ");
        int        breadLoafs    = int.Parse(Console.ReadLine());
        BreadOrder newBreadOrder = new BreadOrder(breadLoafs);

        Console.WriteLine("Enter the number of pastries you'd like to purchase: ");
        int         pastries       = int.Parse(Console.ReadLine());
        PastryOrder newPastryOrder = new PastryOrder(pastries);

        Console.WriteLine("");
        Console.WriteLine("The cost of your bread order is: ");
        Console.WriteLine(newBreadOrder.OrderCost() + " Dollars");
        Console.WriteLine("The cost of your pastry order is: ");
        Console.WriteLine(newPastryOrder.OrderCost() + " Dollars");
        OrderCalculator newOrderCalculator = new OrderCalculator();

        Console.WriteLine("");
        Console.WriteLine("The total cost of your order is: ");
        Console.WriteLine(newOrderCalculator.TotalCost(newBreadOrder.OrderCost(), newPastryOrder.OrderCost()) + " Dollars");
    }
コード例 #8
0
        public void グレードがいいやつはボーナスがつく()
        {
            var order = new Order
                        (
                name: OrderName.Car,
                100,
                new[]
            {
                new OrderElement(Type.Wheel, 4),
                new OrderElement(Type.CarBody, 1),
            }
                        );
            var checker = new OrderCalculator(new[] { order });

            var parts = new[]
            {
                new Part(Type.Wheel, Quality.Normal, 0),
                new Part(Type.Wheel, Quality.High, 0),
                new Part(Type.Wheel, Quality.High, 0),
                new Part(Type.Wheel, Quality.Normal, 0),
                new Part(Type.CarBody, Quality.Normal, 0),
            };

            // Car指定
            var shipment1 = new ShippingParts(parts, OrderName.Car);
            var result    = checker.Calculate(shipment1);

            // 倍率で点数が上がるはず
            Assert.AreEqual((int)(100 * 1.2f * 1.2f), (int)result);
        }
コード例 #9
0
        public void Initialize()
        {
            //Setup

            //Rules section
            _rules      = new Dictionary <char, Tuple <int, double> >();
            _comboRules = new List <Tuple <char, char, double> >();

            //Adding first Rule for skuid-A
            _rules.Add('A', new Tuple <int, double>(3, 130));

            //Adding first Rule for skuid-B
            _rules.Add('B', new Tuple <int, double>(2, 45));

            _comboRules = new List <Tuple <char, char, double> >();

            //Adding combo Rule
            _comboRules.Add(new Tuple <char, char, double>('C', 'D', 30));
            _promotionRule = new PromotionRules(_rules, _comboRules);

            //Master Data section
            productWithPrice = new Dictionary <char, double>();
            productWithPrice.Add('A', 50);
            productWithPrice.Add('B', 30);
            productWithPrice.Add('C', 20);
            productWithPrice.Add('D', 15);

            _SKUCart = new SkuCart(productWithPrice);

            _promotionEngine = new PromotionEngine_V1();
            _orderCalculator = new OrderCalculator(_promotionEngine);
        }
コード例 #10
0
    private int GetRewardPoint()
    {
        OrderAmount     orderAmount = StoreContext.GetOrderAmount();
        OrderCalculator calculator  = new OrderCalculator();

        return(calculator.GetPointFromPrice((orderAmount.Subtotal - orderAmount.Discount), ConvertUtilities.ToDecimal(DataAccessContext.Configurations.GetValue("RewardPoints", StoreContext.CurrentStore))));
    }
コード例 #11
0
    private void PopulateControls()
    {
        IList <PaymentOption> paymentsWithoutButton = GetPaymentsWithoutButton();

        if (paymentsWithoutButton.Count == 0)
        {
            uxCheckOutButton.Visible = false;
        }

        uxAmountLabel.Text = StoreContext.Currency.FormatPrice(
            GetShoppingCartTotal());

        uxQuantityLabel.Text = StoreContext.ShoppingCart.GetCurrentQuantity().ToString();

        if (StoreContext.ShoppingCart.GetCartItems().Length > 0)
        {
            OrderCalculator orderCalculator = new OrderCalculator();
            decimal         discount        = orderCalculator.GetPreCheckoutDiscount(
                StoreContext.Customer,
                StoreContext.ShoppingCart.SeparateCartItemGroups(),
                StoreContext.CheckoutDetails.Coupon);

            uxDiscountTR.Visible = true;
            uxDiscountLabel.Text = StoreContext.Currency.FormatPrice(discount * -1);
        }
        else
        {
            uxDiscountTR.Visible = false;
        }
    }
コード例 #12
0
        public void CalculateOrder_WithOut_Promotion()
        {
            ///Arrange
            List <Sku> selectedSkus = new List <Sku>
            {
                new Sku {
                    SkuId = 'A', UnitPrice = 50, Quantity = 3
                },
                new Sku {
                    SkuId = 'B', UnitPrice = 30, Quantity = 3
                },
                new Sku {
                    SkuId = 'C', UnitPrice = 20, Quantity = 2
                },
                new Sku {
                    SkuId = 'D', UnitPrice = 15, Quantity = 2
                }
            };

            Cart checkoutCart = new Cart {
                Skus = selectedSkus
            };
            OrderCalculator orderCalculator = new OrderCalculator();

            ///Act
            orderCalculator.CalculateTotal(checkoutCart);

            ///Assert
            Assert.IsTrue(checkoutCart.OrderTotal.ToString().Equals("310"));
        }
コード例 #13
0
        public static void Test()
        {
            Product product1 = new Product
            {
                Name = "Szkolenie",
                UnitPrice = 100,
            };

            Order order = new Order
            {
                Details = new List<OrderDetail>
                {
                    new OrderDetail(product1, 2),
                    new OrderDetail(product1, 1),
                }
            };


            // IValidatorStrategy validatorStrategy = new HappyHoursValidatorStrategy(TimeSpan.FromHours(9), TimeSpan.FromHours(17));
            IValidatorStrategy validatorStrategy = new PeriodValidatorStrategy(new Period(DateTime.Parse("2018-06-01"), DateTime.Parse("2018-06-30")));

            IDiscountStrategy discountStrategy = new PercentageDiscountStrategy(0.1m);

            OrderCalculator calculator = new OrderCalculator(validatorStrategy, discountStrategy);

            var discount = calculator.CalculateDiscount(order);

            var finalAmount = order.TotalAmount - discount;

            Console.WriteLine($"Original amount: {order.TotalAmount} discount: {discount} finalAmount: {finalAmount}");


        }
コード例 #14
0
    private void CalculateShippingCost(
        ShippingOption shippingOption,
        out decimal shippingCost,
        out decimal handlingFee)
    {
        OrderCalculator orderCalculator = new OrderCalculator();

        ShippingMethod shippingMethod = shippingOption.CreateNonRealTimeShippingMethod();

        if (StoreContext.CheckoutDetails.Coupon.DiscountType == Vevo.Domain.Discounts.Coupon.DiscountTypeEnum.FreeShipping)
        {
            shippingCost = 0;
        }
        else
        {
            shippingCost = orderCalculator.GetShippingCost(
                shippingMethod,
                StoreContext.ShoppingCart.SeparateCartItemGroups(),
                StoreContext.WholesaleStatus,
                StoreContext.GetOrderAmount().Discount)
                           + CartItemPromotion.GetShippingCostFromPromotion(shippingMethod,
                                                                            StoreContext.ShoppingCart.SeparateCartItemGroups(),
                                                                            StoreContext.WholesaleStatus,
                                                                            StoreContext.GetOrderAmount().Discount);
        }

        handlingFee = orderCalculator.GetHandlingFee(
            shippingMethod,
            StoreContext.ShoppingCart.SeparateCartItemGroups(),
            StoreContext.WholesaleStatus);
    }
コード例 #15
0
        // Normally would split out into a separate project
        public void Returns_Correct_Value_Implementation()
        {
            var sut = new OrderCalculator();

            var result = sut.Calculate(new string[] { "Steak Sandwich" });

            Assert.Equal((decimal)5.4, result);
        }
コード例 #16
0
    private decimal GetShoppingCartTotal()
    {
        OrderCalculator orderCalculator = new OrderCalculator();

        return(orderCalculator.GetShoppingCartTotal(
                   StoreContext.Customer,
                   StoreContext.ShoppingCart.SeparateCartItemGroups(),
                   StoreContext.CheckoutDetails.Coupon));
    }
コード例 #17
0
ファイル: Tests.cs プロジェクト: michaelakin/ExamTest
        public void CalculateTotalSingleItem()
        {
            var item = new MaterialOrderItem(new Item(2, "Two", 2.00m), 1, new MaterialOrderItemCalc());

            OrderItem[] items           = { item };
            var         order           = new Order(items);
            var         orderCalculator = new OrderCalculator();
            var         total           = order.GetOrderTotal(orderCalculator, 0.0825m);

            Assert.IsTrue(total == 2.17m);
        }
コード例 #18
0
        public ActionResult DeleteCartProduct(int Prod)
        {
            ListProductCartModel listCart = new ListProductCartModel();

            listCart = (ListProductCartModel)Session["Cart"];
            var st = listCart.listProduct.Find(c => c.ProductId == Prod);

            listCart.listProduct.Remove(st);
            var modelCart = OrderCalculator.CalculatorCart(listCart);

            Session["Cart"] = modelCart;
            return(RedirectToAction("Index", "Cart"));
        }
コード例 #19
0
ファイル: Tests.cs プロジェクト: michaelakin/ExamTest
        public void CalculateTotal()
        {
            // http://www.softschools.com/math/topics/rounding_to_the_nearest_hundredth/
            var item1 = new ServiceOrderItem(new Item(1, "One", 10.00m), 1, new ServiceOrderItemCalc());
            var item2 = new MaterialOrderItem(new Item(2, "Two", 10.02m), 2, new MaterialOrderItemCalc());

            OrderItem[] items           = { item1, item2 };
            var         order           = new Order(items);
            var         orderCalculator = new OrderCalculator();
            var         total           = order.GetOrderTotal(orderCalculator, 0.0825m);

            Assert.IsTrue(total == 31.69m);
        }
コード例 #20
0
    protected string GetItemName(object cartItem)
    {
        ICartItem item = (ICartItem)cartItem;

        OrderCalculator    orderCalculator    = new OrderCalculator();
        OrderAmountPackage orderAmountPackage = orderCalculator.CalculatePackage(
            StoreContext.CheckoutDetails,
            new CartItemGroup(item),
            StoreContext.Customer);

        return(item.GetOrderItemName(
                   StoreContext.Culture, CurrenntCurrency, orderAmountPackage));
    }
コード例 #21
0
        public void Test_OrderCalculation1()
        {
            Product product = new Product
            {
                Code      = "12345",
                Name      = "Monitor",
                Type      = Type.Normal,
                UnitPrice = 200.00
            };

            Coupon coupon = new Coupon
            {
                Code           = "54321",
                ProductCode    = "12345",
                DeductAmount   = 50.00,
                ExpirationDate = DateTime.Now.AddDays(14)
            };

            Promotion promotion = new Promotion
            {
                Code           = "54321",
                ProductCode    = "456789",
                DeductRate     = 0.10,
                ExpirationDate = DateTime.Now.AddDays(10)
            };

            Order order = new Order
            {
                CustomerId        = "ABCDEFG",
                State             = "NY",
                productsBasket    = new List <Product>(),
                appliedCoupons    = new List <Coupon>(),
                appliedPromotions = new List <Promotion>()
            };

            order.AddProduct(product);
            order.AddCoupon(coupon);
            order.AddPromotion(promotion);

            OrderCalculator calculator = new OrderCalculator
            {
                CustomerOrder = order
            };


            calculator.calculateOrderPayment();
            Assert.Equal(12.00, calculator.CustomerOrder.TaxCharge);
            Assert.Equal(150.00, calculator.CustomerOrder.TotalCost);
        }
コード例 #22
0
        public void CalculateOrder_With_Promotion_With_Quotient()
        {
            ///Arrange
            List <Sku> selectedSkus = new List <Sku>
            {
                new Sku {
                    SkuId = 'A', UnitPrice = 50, Quantity = 10
                },
                new Sku {
                    SkuId = 'B', UnitPrice = 30, Quantity = 4
                },
                new Sku {
                    SkuId = 'C', UnitPrice = 20, Quantity = 13
                },
                new Sku {
                    SkuId = 'D', UnitPrice = 15, Quantity = 1
                }
            };

            List <Promotion> activePromotions = new List <Promotion>
            {
                new Promotion {
                    SkuId = 'A', IsMutualExclusive = false, PromotionPercentage = 13, PromotionQuantity = 3
                },
                new Promotion {
                    SkuId = 'B', IsMutualExclusive = false, PromotionPercentage = 4, PromotionQuantity = 2
                },
                new Promotion {
                    SkuId = 'C', IsMutualExclusive = false, PromotionPercentage = 20, PromotionQuantity = 10
                },
                new Promotion {
                    SkuId = 'D', IsMutualExclusive = false, PromotionPercentage = 0, PromotionQuantity = 1
                }
            };

            Cart checkoutCart = new Cart {
                Skus = selectedSkus, Promotions = activePromotions
            };
            OrderCalculator orderCalculator = new OrderCalculator();

            ///Act
            orderCalculator.CalculateTotal(checkoutCart);

            ///Assert
            Assert.AreEqual(checkoutCart.GrandPromotionTotal.ToString(), "103.3");
            Assert.AreEqual(checkoutCart.GrandTotal.ToString(), "895");
            Assert.AreEqual(checkoutCart.OrderTotal.ToString(), "791.7");
        }
コード例 #23
0
        public void Returns_Correct_Value()
        {
            Mock <IItemCalculator> netMoq = new Mock <IItemCalculator>();

            netMoq.Setup(m => m.Calculate(It.IsAny <string[]>())).Returns((decimal)123.45);

            Mock <ISurchargeCalculator> surchargeMoq = new Mock <ISurchargeCalculator>();

            surchargeMoq.Setup(m => m.Calculate(It.IsAny <decimal>(), It.IsAny <string[]>())).Returns((decimal)10);

            var sut = new OrderCalculator(netMoq.Object, surchargeMoq.Object);

            var result = sut.Calculate(new string[] { "Test", "Test" });

            Assert.Equal((decimal)133.45, result);
        }
コード例 #24
0
          //this method is an AJAX target for CalculateOrder
          public async Task<JsonResult> CalculateOrderAsync()
          {
               Stream req = Request.InputStream;
               req.Seek(0, SeekOrigin.Begin);
               string payload = new StreamReader(req).ReadToEnd();
               AjaxOrder requestOrder = JsonConvert.DeserializeObject<AjaxOrder>(payload);

               BusinessRules busRules = await repository.GetBusinessRulesAsync();
               TaxRate[] taxRates = await repository.GetTaxRatesAsync();

               AjaxOrder responseOrder = OrderCalculator.CalculateOrder(requestOrder, busRules, taxRates);

               JsonResult response = Json(responseOrder);
               response.JsonRequestBehavior = JsonRequestBehavior.AllowGet;
               return response;
          }  //CalculateOrderAsync
コード例 #25
0
 public ActionResult CheckGiftCode(string GiftCode)
 {
     if (GiftCode != "")
     {
         var code = _StaffService.GetStaffs().Where(p => p.Yahoo.ToLower().Equals(GiftCode.ToLower())).FirstOrDefault();
         ListProductCartModel listCart = new ListProductCartModel();
         listCart = (ListProductCartModel)Session["Cart"];
         if (code != null)
         {
             listCart.GiftCode        = GiftCode;
             listCart.GiftCodePercent = int.Parse(code.Phone);
             var modelCart = OrderCalculator.CalculatorCart(listCart);
             Session["Cart"] = modelCart;
         }
     }
     return(RedirectToAction("Index", "Cart"));
 }
コード例 #26
0
        public void TotalCost_AddCostOfPastryOrderToCostOfBreadOrderToCalculateTotalCostOfOrder_int()
        {
            int intendedTotalOrderCost = 15;

            int         numberOfPastries = 3;
            PastryOrder newPastryOrder   = new PastryOrder(numberOfPastries);
            int         pastryOrderCost  = newPastryOrder.OrderCost();

            int        numberOfLoafs  = 2;
            BreadOrder newBreadOrder  = new BreadOrder(numberOfLoafs);
            int        breadOrderCost = newBreadOrder.OrderCost();

            OrderCalculator newOrderCalculator = new OrderCalculator();
            int             totalOrderCost     = newOrderCalculator.TotalCost(breadOrderCost, pastryOrderCost);

            Assert.AreEqual(intendedTotalOrderCost, totalOrderCost);
        }
コード例 #27
0
 public OrderForm(OrderFormValuesValidator orderFormValuesValidator,
                  OrderConfigurationFormValuesValidator orderConfigurationFormValuesValidator,
                  OrderCalculator orderCalculator, OrderConverter orderConverter)
 {
     InitializeComponent();
     orderFormValues = new OrderFormValues
     {
         VehicleType = VehicleType.NONE
     };
     orderConfigurationFormValues = new OrderConfigurationFormValues();
     orderFormErrors = new OrderFormErrors();
     orderConfigurationFormErrors  = new OrderConfigurationFormErrors();
     this.OrderFormValuesValidator = orderFormValuesValidator;
     this.OrderConfigurationFormValuesValidator = orderConfigurationFormValuesValidator;
     this.OrderCalculator = orderCalculator;
     this.OrderConverter  = orderConverter;
 }
コード例 #28
0
        public void CalculateOrderTest()
        {
            // Arrange
            var order = new Order
            {
                Price     = 40,
                Quantity  = 2,
                OrderDate = DateTime.Parse("2018-03-06")
            };

            // Act
            var orderCalculator = new OrderCalculator(new NoDiscountStrategy());

            var amount = orderCalculator.Calculate(order);

            // Assert
            Assert.AreEqual(80, amount);
        }
コード例 #29
0
 private void SubmitButton_Click(object sender, EventArgs e)
 {
     if (IsFormValid())
     {
         HideValidationErrorLabel();
         order = OrderConverter.convertFromFormValues(orderFormValues, orderConfigurationFormValues);
         OrderCalulationResult       calulationResult       = OrderCalculator.CalculateCost(order);
         OrderCalculationsResultForm calculationsResultForm = new OrderCalculationsResultForm(calulationResult)
         {
             Visible = true
         };
     }
     else
     {
         System.Console.Out.WriteLine("Form is invalid");
         DisplayValidationErrors();
     }
 }
コード例 #30
0
    private void PopulateControls()
    {
        if (StoreContext.ShoppingCart.GetCartItems().Length > 0)
        {
            uxPanel.Visible         = true;
            uxTotalAmountLabel.Text = StoreContext.Currency.FormatPrice(
                GetShoppingCartTotal());

            OrderCalculator orderCalculator = new OrderCalculator();
            decimal         discount        = orderCalculator.GetPreCheckoutDiscount(
                StoreContext.Customer,
                StoreContext.ShoppingCart.SeparateCartItemGroups(),
                StoreContext.CheckoutDetails.Coupon);

            if (discount > 0)
            {
                uxDiscountTR.Visible       = true;
                uxDiscountAmountLabel.Text = StoreContext.Currency.FormatPrice(discount * -1);
            }
            else
            {
                uxDiscountTR.Visible = false;
            }

            uxGrid.DataSource = StoreContext.ShoppingCart.GetCartItems();
            uxGrid.DataBind();
        }
        else
        {
            uxPanel.Visible           = false;
            uxShoppingCartDiv.Visible = true;
            uxMessageLabel.Text       = "[$Your shopping cart is empty]";
            uxBackHomeLink.Visible    = true;
            StoreContext.CheckoutDetails.Clear();
        }
        if (uxTaxIncludePanel.Visible)
        {
            uxTaxIncludeMessageLabel.Text =
                String.Format("[$TaxIncludeMessage1] {0} [$TaxIncludeMessage2]",
                              DataAccessContext.Configurations.GetValue("TaxPercentageIncludedInPrice").ToString());
        }

        PopulateContinueUrl();
    }