Example #1
0
    private void SendMail(BusinessEntities.Orders order)
    {
        StringBuilder sb = new StringBuilder();

        sb = sb.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "NewOrder.html"));

        sb.Replace("{URL}", BaseSiteUrl);
        sb.Replace("{ORDERNUMBER}", order.OrderID.ToString());
        sb.Replace("{ORDERDATE}", GetStoreTime().ToString("MM/dd/yyyy HH:mm"));
        sb.Replace("{FULLNAME}", txtFirstName.Text + " " + txtLastName.Text);
        sb.Replace("{ADDRESS}", txtAddress.Text);
        sb.Replace("{CITY}", txtCity.Text);
        sb.Replace("{STATE}", txtState.Text);
        sb.Replace("{ZIPCODE}", txtZipCode.Text);
        sb.Replace("{PHONE}", txtTelephone.Text);
        if (!String.IsNullOrEmpty(txtMobile.Text))
        {
            sb.Replace("{MOBILE}", !String.IsNullOrEmpty(txtTelephone.Text) ? " - " + txtMobile.Text : txtMobile.Text);
        }
        else
        {
            sb.Replace("{MOBILE}", "");
        }
        if (order.OrderTypeID == BusinessEntities.OrderType.Deliver)
        {
            sb.Replace("{ORDERDELIVERY}", "Pizzaness Delivery");
        }
        else
        {
            sb.Replace("{ORDERDELIVERY}", "Self Pickup");
        }

        if (order.PaymentMethod == BusinessEntities.PaymentType.OnlinePayment)
        {
            sb.Replace("{PAYMENTMETHOD}", "Online Payment");
        }
        else
        {
            sb.Replace("{PAYMENTMETHOD}", "Cash Payment");
        }
        StringBuilder finalTemplate = new StringBuilder();

        for (int i = 0; i < order.OrderDetailsList.Count; i++)
        {
            BusinessEntities.OrderDetails orderDetails = order.OrderDetailsList.ElementAt(i);
            StringBuilder newTemplate = new StringBuilder();
            newTemplate.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "OrderDetailTemplate.html"));
            newTemplate.Replace("{ITEMQUANTITY}", orderDetails.Quantity.ToString());
            newTemplate.Replace("{PRODUCTNAME}", orderDetails.ProductName);
            newTemplate.Replace("{PRODUCTTYPE}", !String.IsNullOrEmpty(orderDetails.CategoryName) ? orderDetails.CategoryName : "");
            newTemplate.Replace("{PRICE}", orderDetails.Price.ToString());
            newTemplate.Replace("{RECIPENTNAME}", orderDetails.RecipientName);
            newTemplate.Replace("{INSTRUCTION}", orderDetails.Comments);

            StringBuilder optionTemplate = new StringBuilder();

            foreach (BusinessEntities.OrderDetailOptions obj in SessionOrderDetailOptionList.ElementAt(i))
            {
                //optionTemplate.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "OptionTemplate.html"));
                //optionTemplate.Replace("{OPTIONSTYPE}", obj.ProductOptionTypeName);
                optionTemplate.Append(obj.ProductOptionName + ",");
            }

            StringBuilder toppings = new StringBuilder();
            String        previousAddonTypeName = String.Empty;
            StringBuilder toppingTemplate       = new StringBuilder();
            if (orderDetails.IsGroupProduct)
            {
                List <BusinessEntities.OrderDetailSubProduct> subProducts = orderDetails.OrderDetailSubProducts;
                StringBuilder finalSubProductTemplate = new StringBuilder();
                foreach (BusinessEntities.OrderDetailSubProduct subProduct in subProducts)
                {
                    StringBuilder subProductTemplate = new StringBuilder();
                    subProductTemplate.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "SubProductTemplate.html"));
                    subProductTemplate.Replace("{PRODUCTNAME}", subProduct.ProductName);
                    subProductTemplate.Replace("{RECIPENTNAME}", subProduct.RecipientName);
                    subProductTemplate.Replace("{INSTRUCTION}", subProduct.Comments);

                    StringBuilder subProductOptionTemplate = new StringBuilder();

                    if (subProduct.OrderDetailSubProductOptions != null)
                    {
                        foreach (BusinessEntities.OrderDetailSubProductOption subProductOption in subProduct.OrderDetailSubProductOptions)
                        {
                            //subProductOptionTemplate.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "OptionTemplate.html"));
                            //subProductOptionTemplate.Replace("{OPTIONSTYPE}", subProductOption.ProductOptionTypeName);
                            subProductOptionTemplate.Append(subProductOption.ProductOptionName + ",");
                        }
                    }
                    toppings = new StringBuilder();
                    previousAddonTypeName = String.Empty;
                    toppingTemplate       = new StringBuilder();
                    foreach (BusinessEntities.OrderDetailSubProductAdon obj in subProduct.OrderDetailSubProductAdons)
                    {
                        if (obj.SelectedAdonOption != 0)
                        {
                            if (!obj.AdonTypeName.Equals(previousAddonTypeName))
                            {
                                toppings.Append(" <b>" + obj.AdonTypeName + ":</b>");
                                previousAddonTypeName = obj.AdonTypeName;
                            }
                            toppings.Append(Utility.GetSubString(toppingTemplate.ToString(), "<!-- Toppings-->",
                                                                 "<!-- End Topping-->", false));
                            if (obj.IsDoubleSelected)
                            {
                                toppings.Replace("{DOUBLE}", "Two times ");
                            }
                            else
                            {
                                toppings.Replace("{DOUBLE}", "");
                            }
                            toppings.Replace("{NAME}", obj.AdonName);
                            toppings.Replace("{OPTION}",
                                             ((BusinessEntities.SelectedOption)obj.SelectedAdonOption).ToString());
                        }
                    }

                    if (!String.IsNullOrEmpty(toppings.ToString()))
                    {
                        String subString = Utility.GetSubString(toppingTemplate.ToString(), "<!-- Toppings-->", "<!-- End Topping-->", true);
                        toppingTemplate.Replace(subString, toppings.ToString());
                    }
                    subProductTemplate.Replace("<!-- Options -->", subProductOptionTemplate.ToString().TrimEnd(new char[] { ',' }));
                    subProductTemplate.Replace("<!-- Topping -->", toppingTemplate.ToString());
                    finalSubProductTemplate.Append(subProductTemplate.ToString());
                }
                newTemplate.Replace("<!--SubProducts-->", finalSubProductTemplate.ToString());
                toppings        = new StringBuilder();
                toppingTemplate = new StringBuilder();
            }
            foreach (BusinessEntities.OrderDetailAdOns obj in SessionOrderAdonList.ElementAt(i))
            {
                if (obj.SelectedAdonOption != 0)
                {
                    if (!obj.AdonTypeName.Equals(previousAddonTypeName))
                    {
                        toppings.Append(" <b>" + obj.AdonTypeName + ":</b>");
                        previousAddonTypeName = obj.AdonTypeName;
                    }


                    toppings.Append(obj.AdonName);
                    if (obj.SelectedAdonOption == SelectedOption.FirstHalf)
                    {
                        if (obj.IsDoubleSelected)
                        {
                            toppings.Append("(Left 2 Times),");
                        }
                        else
                        {
                            toppings.Append("(Left),");
                        }
                    }
                    else if (obj.SelectedAdonOption == SelectedOption.SecondHalf)
                    {
                        if (obj.IsDoubleSelected)
                        {
                            toppings.Append("(Right 2 Times),");
                        }
                        else
                        {
                            toppings.Append("(Right),");
                        }
                    }
                    else
                    {
                        toppings.Append(",");
                    }
                }
            }
            if (!String.IsNullOrEmpty(toppings.ToString()))
            {
                //String subString = Utility.GetSubString(toppingTemplate.ToString(), "<!-- Toppings-->", "<!-- End Topping-->", true);
                toppingTemplate.Append(toppings.ToString());
            }
            newTemplate.Replace("<!--OrderDetailOptions-->", optionTemplate.ToString().TrimEnd(new char[] { ',' }));
            newTemplate.Replace("<!--OrderDetailToppings-->", toppingTemplate.ToString().TrimEnd(new char[] { ',' }));
            finalTemplate.Append(newTemplate.ToString());
            //finalTemplate.Append(optionTemplate.ToString());
            //finalTemplate.Append(toppingTemplate.ToString());
        }
        String DetailTemplate = Utility.GetSubString(sb.ToString(), "<!--DETAIL TEMPLATE-->", "<!--END DETAIL TEMPLATE-->", true);

        DetailTemplate = DetailTemplate.Replace("<!--DETAILTEMPLATE-->", finalTemplate.ToString());

        sb.Replace(Utility.GetSubString(sb.ToString(), "<!--DETAIL TEMPLATE-->", "<!--END DETAIL TEMPLATE-->", true), DetailTemplate.ToString());
        sb.Replace("{TIP}", order.LineTip.ToString("C2"));
        sb.Replace("{TOTALPRICE}", order.OrderTotal.ToString("C2"));
        try
        {
            var mail = new Mail();
            mail.Subject       = "New Order";
            mail.Sender        = ConfigurationManager.AppSettings["DonotReplyEmail"];
            mail.Receiver      = SessionUser.Username;
            mail.MailCc        = string.Empty;
            mail.MailBcc       = ConfigurationManager.AppSettings["OrderReceiveEmail"];
            mail.MailBody      = sb.ToString();
            mail.IsHtml        = true;
            mail.ReferenceId   = order.OrderID;
            mail.ReferenceType = "Order";
            mailManager.AddMail(mail);
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }
Example #2
0
    private void SendFax(BusinessEntities.Orders order)
    {
        StringBuilder Fax = new StringBuilder();

        Fax = Fax.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "Fax.html"));
        Fax.Replace("{URL}", BaseSiteUrl);
        Fax.Replace("{ORDERNUMBER}", order.OrderID.ToString());
        Fax.Replace("{ORDERDATE}", GetStoreTime().ToString("MM/dd/yyyy HH:mm"));
        Fax.Replace("{FULLNAME}", txtFirstName.Text + " " + txtLastName.Text);
        Fax.Replace("{ADDRESS}", txtAddress.Text + " " + txtCity.Text + ", " + txtZipCode.Text + ", " + txtState.Text);
        Fax.Replace("{PHONE}", txtTelephone.Text);
        if (!String.IsNullOrEmpty(txtMobile.Text))
        {
            Fax.Replace("{MOBILE}", !String.IsNullOrEmpty(txtTelephone.Text) ? " - " + txtMobile.Text : txtMobile.Text);
        }
        else
        {
            Fax.Replace("{MOBILE}", "");
        }
        if (order.OrderTypeID == BusinessEntities.OrderType.Deliver)
        {
            Fax.Replace("{ORDERDELIVERY}", "Pizzaness Delivery");
        }
        else
        {
            Fax.Replace("{ORDERDELIVERY}", "Self Pickup");
        }

        if (order.PaymentMethod == BusinessEntities.PaymentType.OnlinePayment)
        {
            Fax.Replace("{PAYMENTMETHOD}", "Online Payment");
        }
        else
        {
            Fax.Replace("{PAYMENTMETHOD}", "Cash Payment");
        }
        StringBuilder finalTemplate = new StringBuilder();

        for (int i = 0; i < order.OrderDetailsList.Count; i++)
        {
            BusinessEntities.OrderDetails orderDetail = order.OrderDetailsList.ElementAt(i);
            StringBuilder newTemplate = new StringBuilder();
            newTemplate.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "FaxOrderDetailTemplate.html"));
            newTemplate.Replace("{ITEMNUMBER}", (i + 1).ToString());
            newTemplate.Replace("{PRODUCTTYPE}", !String.IsNullOrEmpty(orderDetail.CategoryName) ? orderDetail.CategoryName : "");
            newTemplate.Replace("{PRODUCTNAME}", orderDetail.ProductName);
            newTemplate.Replace("{ITEMQUANTITY}", orderDetail.Quantity.ToString());
            newTemplate.Replace("{ITEMPRICE}", orderDetail.ItemTotal.ToString("C2"));
            newTemplate.Replace("{RECIPENTNAME}", orderDetail.RecipientName);
            newTemplate.Replace("{INSTRUCTION}", orderDetail.Comments);

            StringBuilder optionTemplate = new StringBuilder();

            foreach (BusinessEntities.OrderDetailOptions obj in SessionOrderDetailOptionList.ElementAt(i))
            {
                optionTemplate.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "OptionTemplate.html"));
                optionTemplate.Replace("{OPTIONSTYPE}", obj.ProductOptionTypeName);
                optionTemplate.Replace("{OPTIONS}", obj.ProductOptionName);
            }
            StringBuilder toppings = new StringBuilder();
            String        previousAddonTypeName = String.Empty;
            StringBuilder toppingTemplate       = new StringBuilder();
            if (orderDetail.IsGroupProduct)
            {
                List <BusinessEntities.OrderDetailSubProduct> subProducts = orderDetail.OrderDetailSubProducts;
                StringBuilder finalSubProductTemplate = new StringBuilder();
                foreach (BusinessEntities.OrderDetailSubProduct subProduct in subProducts)
                {
                    StringBuilder subProductTemplate = new StringBuilder();
                    subProductTemplate.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "SubProductTemplate.html"));
                    subProductTemplate.Replace("{PRODUCTNAME}", subProduct.ProductName);
                    subProductTemplate.Replace("{RECIPENTNAME}", subProduct.RecipientName);
                    subProductTemplate.Replace("{INSTRUCTION}", subProduct.Comments);

                    StringBuilder subProductOptionTemplate = new StringBuilder();

                    if (subProduct.OrderDetailSubProductOptions != null)
                    {
                        foreach (BusinessEntities.OrderDetailSubProductOption subProductOption in subProduct.OrderDetailSubProductOptions)
                        {
                            subProductOptionTemplate.Append(Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "OptionTemplate.html"));
                            subProductOptionTemplate.Replace("{OPTIONSTYPE}", subProductOption.ProductOptionTypeName);
                            subProductOptionTemplate.Replace("{OPTIONS}", subProductOption.ProductOptionName);
                        }
                    }
                    toppings = new StringBuilder();
                    previousAddonTypeName = String.Empty;
                    toppingTemplate       = new StringBuilder();
                    int j = 1;
                    foreach (BusinessEntities.OrderDetailSubProductAdon obj in subProduct.OrderDetailSubProductAdons)
                    {
                        if (obj.SelectedAdonOption != 0)
                        {
                            if (!obj.AdonTypeName.Equals(previousAddonTypeName))
                            {
                                if (!String.IsNullOrEmpty(toppings.ToString()))
                                {
                                    String subString = Utility.GetSubString(toppingTemplate.ToString(),
                                                                            "<!-- Toppings-->", "<!-- End Topping-->",
                                                                            true);
                                    toppingTemplate.Replace(subString, toppings.ToString());
                                }
                                toppings = new StringBuilder();
                                toppingTemplate.Append(
                                    Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "ToppingTemplate.html"));
                                toppingTemplate.Replace("{TOPPINGTYPE}", obj.AdonTypeName);
                                previousAddonTypeName = obj.AdonTypeName;
                            }
                            toppings.Append(Utility.GetSubString(toppingTemplate.ToString(), "<!-- Toppings-->",
                                                                 "<!-- End Topping-->", false));
                            if (obj.IsDoubleSelected)
                            {
                                toppings.Replace("{DOUBLE}", "Two times ");
                            }
                            else
                            {
                                toppings.Replace("{DOUBLE}", "");
                            }
                            toppings.Replace("{NAME}", obj.AdonName);
                            toppings.Replace("{OPTION}",
                                             ((BusinessEntities.SelectedOption)obj.SelectedAdonOption).ToString());
                        }
                    }

                    if (!String.IsNullOrEmpty(toppings.ToString()))
                    {
                        String subString = Utility.GetSubString(toppingTemplate.ToString(), "<!-- Toppings-->", "<!-- End Topping-->", true);
                        toppingTemplate.Replace(subString, toppings.ToString());
                    }
                    //if(!String.IsNullOrEmpty(subProduct.CrustType))
                    //    subProductTemplate.Replace("<!-- CrustType -->", subProduct.CrustType);
                    subProductTemplate.Replace("<!-- Options -->", subProductOptionTemplate.ToString());
                    subProductTemplate.Replace("<!-- Topping -->", toppingTemplate.ToString());
                    finalSubProductTemplate.Append(subProductTemplate.ToString());
                    if (j != subProduct.OrderDetailSubProductAdons.Count)
                    {
                        finalSubProductTemplate.Append("<tr><td colspan='2' style='border-top:1px solid black;'></td></tr>");
                    }
                }
                newTemplate.Replace("<!--SubProducts-->", finalSubProductTemplate.ToString());
                toppings        = new StringBuilder();
                toppingTemplate = new StringBuilder();
            }
            foreach (BusinessEntities.OrderDetailAdOns obj in SessionOrderAdonList.ElementAt(i))
            {
                if (obj.SelectedAdonOption != 0)
                {
                    if (!obj.AdonTypeName.Equals(previousAddonTypeName))
                    {
                        if (!String.IsNullOrEmpty(toppings.ToString()))
                        {
                            String subString = Utility.GetSubString(toppingTemplate.ToString(), "<!-- Toppings-->",
                                                                    "<!-- End Topping-->", true);
                            toppingTemplate.Replace(subString, toppings.ToString());
                        }
                        toppings = new StringBuilder();
                        toppingTemplate.Append(
                            Core.Utility.ReadFile(PhysicalApplicationPath + HtmlFolder + "FaxToppingTemplate.html"));
                        toppingTemplate.Replace("{TOPPINGTYPE}", obj.AdonTypeName);
                        previousAddonTypeName = obj.AdonTypeName;
                    }
                    toppings.Append(Utility.GetSubString(toppingTemplate.ToString(), "<!-- Toppings-->",
                                                         "<!-- End Topping-->", false));

                    if (obj.IsDoubleSelected)
                    {
                        toppings.Replace("{DOUBLE}", "Two times ");
                    }
                    else
                    {
                        toppings.Replace("{DOUBLE}", "");
                    }
                    toppings.Replace("{NAME}", obj.AdonName);
                    toppings.Replace("{OPTION}", ((BusinessEntities.SelectedOption)obj.SelectedAdonOption).ToString());
                }
            }
            if (!String.IsNullOrEmpty(toppings.ToString()))
            {
                String subString = Utility.GetSubString(toppingTemplate.ToString(), "<!-- Toppings-->", "<!-- End Topping-->", true);
                toppingTemplate.Replace(subString, toppings.ToString());
            }

            newTemplate.Replace("<!--OrderDetailOptions-->", optionTemplate.ToString());
            newTemplate.Replace("<!--OrderDetailToppings-->", toppingTemplate.ToString());

            finalTemplate.Append(newTemplate.ToString());
            //finalTemplate.Append(optionTemplate.ToString());
            //finalTemplate.Append(toppingTemplate.ToString());
        }
        String DetailTemplate = Utility.GetSubString(Fax.ToString(), "<!--DETAIL TEMPLATE-->", "<!--END DETAIL TEMPLATE-->", true);

        DetailTemplate = DetailTemplate.Replace("<!--DETAILTEMPLATE-->", finalTemplate.ToString());

        Fax.Replace(Utility.GetSubString(Fax.ToString(), "<!--DETAIL TEMPLATE-->", "<!--END DETAIL TEMPLATE-->", true), DetailTemplate.ToString());
        Fax.Replace("{TIP}", order.LineTip.ToString("C2"));
        Fax.Replace("{TOTALPRICE}", order.OrderTotal.ToString("C2"));
        if (order.PaymentMethod == BusinessEntities.PaymentType.CashPayment)
        {
            interfax.InterFax client = new InterFax();
            if (ConfigurationManager.AppSettings["AllowFax"].Equals("true"))
            {
                client.Sendfax(ConfigurationManager.AppSettings["FaxUsername"],
                               ConfigurationManager.AppSettings["FaxPassword"],
                               ConfigurationManager.AppSettings["FaxNumber"],
                               System.Text.Encoding.UTF8.GetBytes(Fax.ToString()), "HTML");
            }
            else
            {
                try
                {
                    Core.Utility.SendEmail(ConfigurationManager.AppSettings["DonotReplyEmail"], SessionUser.Username, String.Empty, ConfigurationManager.AppSettings["OrderReceiveEmail"], "New Order Fax", Fax.ToString(), true);
                }
                catch (Exception ex)
                {
                }
            }
        }
        else
        {
            SessionFax = Fax.ToString();
        }
    }
Example #3
0
    protected void AddToCartButton_Click(object sender, EventArgs e)
    {
        Products comboproduct = _productManager.GetProductById(Convert.ToInt32(Request.QueryString["PID"]));

        if (comboproduct != null)
        {
            try
            {
                Orders order = SessionUserOrder;
                if (order == null)
                {
                    order = new BusinessEntities.Orders();
                }

                if (order.OrderDetailsList == null)
                {
                    order.OrderDetailsList       = new List <BusinessEntities.OrderDetails>();
                    SessionOrderAdonList         = new List <List <BusinessEntities.OrderDetailAdOns> >();
                    SessionOrderDetailOptionList = new List <List <BusinessEntities.OrderDetailOptions> >();
                    order.OrderStatusID          = BusinessEntities.OrderStatus.NewOrder;
                }

                #region Order Detail

                BusinessEntities.OrderDetails orderdetail = new BusinessEntities.OrderDetails();
                orderdetail.Price          = comboproduct.DefaultBranchProductPrice;
                orderdetail.CategoryName   = comboproduct.CategoryName;
                orderdetail.ProductName    = comboproduct.Name;
                orderdetail.ProductID      = comboproduct.ProductID;
                orderdetail.ProductImage   = comboproduct.Image;
                orderdetail.Quantity       = 1;
                orderdetail.IsGroupProduct = true;

                orderdetail.OrderDetailSubProducts = new List <OrderDetailSubProduct>();

                #endregion

                Double price = 0;
                foreach (RadPageView pageView in RadMultiPage1.PageViews)
                {
                    price += ((MyUserControl)pageView.Controls[0]).GetPrice();
                    var orderDetailObj = ((MyUserControl)pageView.Controls[0]).GetOrderDetailSubProduct();
                    orderdetail.OrderDetailSubProducts.Add(orderDetailObj);
                    orderdetail.RecipientName = orderDetailObj.RecipientName;
                }


                #region Code Commit

                /*RepeaterItemCollection gridItems = rptProducts.Items;
                 * foreach (RepeaterItem productItem in gridItems)
                 * {
                 *  Double productPrice = 0, toppingPrice = 0;
                 *  bool CalculateAdonPrice = false;
                 *  HiddenField ProductID = productItem.FindControl("hdProductId") as HiddenField;
                 *  RadTextBox RecipientName = productItem.FindControl("txtRecipientName") as RadTextBox;
                 *  RadTextBox Instruction = productItem.FindControl("txtInstruction") as RadTextBox;
                 *  Products product = products.Where(p => p.ProductID == Convert.ToInt32(ProductID.Value)).First();
                 *
                 #region Order Detail Sub Product
                 *
                 *  OrderDetailSubProduct orderDetailSubProduct = new OrderDetailSubProduct();
                 *  orderDetailSubProduct.ProductId = product.ProductID;
                 *  orderDetailSubProduct.Quantity = 1;
                 *  orderDetailSubProduct.RecipientName = RecipientName.Text;
                 *  orderDetailSubProduct.Comments = Instruction.Text;
                 *
                 #endregion
                 *
                 *
                 *  Repeater rptOptions = productItem.FindControl("rptOptions") as Repeater;
                 *
                 *  foreach (RepeaterItem optionItem in rptOptions.Items)
                 *  {
                 #region Order Detail Sub Product Option
                 *
                 #endregion
                 *      HiddenField OptionTypeID = optionItem.FindControl("hdOptionTypeId") as HiddenField;
                 *      OptionTypesInProduct optionTypeInProduct = product.OptionTypesInProductList.Where(ot => ot.OptionTypeID == Convert.ToInt16(OptionTypeID.Value)).FirstOrDefault();
                 *      if (optionTypeInProduct.IsMultiSelect)
                 *      {
                 *          CheckBoxList chklist = optionItem.FindControl("CheckBoxList") as CheckBoxList;
                 *          if (chklist != null)
                 *          {
                 *              bool changePrice = true;
                 *              foreach (ListItem checkBox in chklist.Items)
                 *              {
                 *                  if (checkBox.Selected)
                 *                  {
                 *                      ProductOptions productOption = optionTypeInProduct.ProductOptionsList[0];
                 *                      if (optionTypeInProduct.IsSamePrice && optionTypeInProduct.IsProductPriceChangeType)
                 *                      {
                 *                          if (changePrice)
                 *                          {
                 *                              if (productPrice == 0)
                 *                                  productPrice = productOption.Price;
                 *                              else
                 *                                  productPrice += productOption.Price;
                 *                              changePrice = false;
                 *                          }
                 *                      }
                 *                      else if (optionTypeInProduct.IsProductPriceChangeType)
                 *                      {
                 *                          productPrice += productOption.Price;
                 *                      }
                 *                      OrderDetailSubProductOption orderDetailSubProductOption = new OrderDetailSubProductOption();
                 *                      orderDetailSubProductOption.ProductOptionId = productOption.OptionID;
                 *                      orderDetailSubProductOption.ProductOptionName = productOption.OptionName;
                 *                      orderDetailSubProductOption.Price = productOption.Price;
                 *                  }
                 *              }
                 *          }
                 *      }
                 *      else
                 *      {
                 *          RadioButtonList radiolist = optionItem.FindControl("RadioButtonList") as RadioButtonList;
                 *          if (radiolist != null && !String.IsNullOrEmpty(radiolist.SelectedValue))
                 *          {
                 *              CalculateAdonPrice = true;
                 *              if (optionTypeInProduct.IsSamePrice)
                 *              {
                 *                  ProductOptions productOption = optionTypeInProduct.ProductOptionsList[0];
                 *                  productPrice = productOption.Price;
                 *              }
                 *              else
                 *              {
                 *                  ProductOptions productOption = optionTypeInProduct.ProductOptionsList.Where(po => po.OptionID == Convert.ToInt32(radiolist.SelectedValue)).FirstOrDefault();
                 *                  productPrice = productOption.Price;
                 *                  toppingPrice = productOption.ToppingPrice;
                 *              }
                 *          }
                 *          else
                 *          {
                 *              productPrice = product.UnitPrice;
                 *          }
                 *      }
                 *      if (CalculateAdonPrice)
                 *      {
                 *          Repeater rptAdonsType = productItem.FindControl("rptAdonsType") as Repeater;
                 *          Int16 freeToppingCount = 0;
                 *          foreach (RepeaterItem adonTypeItem in rptAdonsType.Items)
                 *          {
                 *              HiddenField hdAdonTypeId = adonTypeItem.FindControl("hdAdonTypeId") as HiddenField;
                 *              AdOnTypeInProduct adonType = product.AdOnTypeInProductList.Where(at => at.AdonTypeID == Convert.ToInt16(hdAdonTypeId.Value)).FirstOrDefault();
                 *
                 *              Repeater rptAdons = adonTypeItem.FindControl("rptAdons") as Repeater;
                 *              foreach (RepeaterItem adonItem in rptAdons.Items)
                 *              {
                 *                  Double adonPrice = 0;
                 *                  HiddenField hdAdonId = adonItem.FindControl("hdAdonId") as HiddenField;
                 *                  Adon adon = adonType.Adons.Where(a => a.AdOnID == Convert.ToInt32(hdAdonId.Value)).FirstOrDefault();
                 *                  RadioButtonList txtAdonOptions = adonItem.FindControl("AdonOptions") as RadioButtonList;
                 *                  CheckBox txtDouble = adonItem.FindControl("txtDouble") as CheckBox;
                 *                  short selectedoption = short.Parse(txtAdonOptions.SelectedValue);
                 *                  OrderDetailSubProductAdon orderDetailSubAdon = new OrderDetailSubProductAdon();
                 *                  orderDetailSubAdon.AdOnId = adon.AdOnID;
                 *                  orderDetailSubAdon.AdonName = adon.AdOnName;
                 *                  orderDetailSubAdon.SelectedAdonOption = selectedoption;
                 *                  orderDetailSubAdon.IsDoubleSelected = txtDouble.Checked;
                 *                  if (adon.DefaultSelected == 0 && (selectedoption == 1 || selectedoption == 2 || selectedoption == 3))
                 *                  {       // When None was default selected and user has changed default selected option
                 *                      if (!adonType.IsFreeAdonType)
                 *                      {
                 *                          if (txtDouble.Checked)
                 *                          {
                 *                              if (freeToppingCount == product.NumberOfFreeTopping)
                 *                              {
                 *                                  if (toppingPrice > 0)
                 *                                      adonPrice += 2 * toppingPrice;
                 *                                  else
                 *                                      adonPrice += (2 * Convert.ToDouble(adonType.Price));
                 *                              }
                 *                              else
                 *                              {
                 *                                  if (toppingPrice > 0)
                 *                                      productPrice += toppingPrice;
                 *                                  else
                 *                                      productPrice += Convert.ToDouble(adonType.Price);
                 *                                  freeToppingCount++;
                 *                              }
                 *                          }
                 *                          else
                 *                          {
                 *                              if (freeToppingCount == product.NumberOfFreeTopping)
                 *                              {
                 *                                  if (toppingPrice > 0)
                 *                                      productPrice += toppingPrice;
                 *                                  else
                 *                                      productPrice += Convert.ToDouble(adonType.Price);
                 *                              }
                 *                              else
                 *                                  freeToppingCount++;
                 *                          }
                 *                      }
                 *                  }
                 *                  else  // When other than None is pre selected and user has also selected Double check box
                 *                  {
                 *                      if (txtDouble.Checked && selectedoption != 0)
                 *                      {
                 *                          if (toppingPrice > 0)
                 *                              adonPrice += toppingPrice;
                 *                          else
                 *                              adonPrice += Convert.ToDouble(adonType.Price);
                 *                      }
                 *                      else
                 *                      {
                 *                          txtDouble.Checked = false;
                 *                      }
                 *                  }
                 *                  orderDetailSubAdon.Price = adonPrice;
                 *                  productPrice += adonPrice;
                 *              }
                 *          }
                 *      } // CalculateAdonPrice
                 *  }
                 *
                 *  netProductPrice += productPrice;
                 *  orderDetailSubProduct.Price = productPrice;
                 * }*/
                #endregion

                orderdetail.ItemTotal = orderdetail.Price = price;
                order.OrderDetailsList.Add(orderdetail);


                //Add order details to log table when added to cart

                // Prepare data for log
                string sessionID     = HttpContext.Current.Session.SessionID;
                string recepientName = orderdetail.RecipientName == "" ? null : orderdetail.RecipientName;
                string productDetail = string.Empty;
                string adons         = string.Empty;

                foreach (OrderDetailSubProduct product in orderdetail.OrderDetailSubProducts)
                {
                    productDetail += product.ProductName + ": ";
                    foreach (var p in product.OrderDetailSubProductOptions)
                    {
                        productDetail += p.ProductOptionName + ",";
                    }
                    foreach (OrderDetailSubProductAdon adon in product.OrderDetailSubProductAdons)
                    {
                        adons += adon.AdOnId + ",";
                    }
                }

                //productDetail = productDetail[productDetail.Length - 1] == ','
                //                    ? productDetail.Substring(0, productDetail.Length - 2)
                //                    : productDetail;

                //adons = adons[adons.Length - 1] == ','
                //                    ? adons.Substring(0, adons.Length - 2)
                //                    : adons;

                productDetail = productDetail.Trim(',');
                adons         = adons.TrimEnd(',');

                productDetail = productDetail == "" ? null : productDetail;
                adons         = adons == "" ? null : adons;
                // get log message to pass to db
                string message = Common.AddToCartLogMessage(orderdetail.CategoryName, orderdetail.Price,
                                                            adons, productDetail, SessionUserFullName);

                // Log order details
                LogManager log = new LogManager();
                log.SaveLogData(sessionID, LogLevel.INFO.ToString(), Logger.AddToCart.ToString(), message, null);

                List <BusinessEntities.OrderDetailAdOns> list = new List <BusinessEntities.OrderDetailAdOns>();
                SessionOrderAdonList.Add(list);
                List <BusinessEntities.OrderDetailOptions> list1 = new List <BusinessEntities.OrderDetailOptions>();
                SessionOrderDetailOptionList.Add(list1);

                double preOrderPromoValue = 0.0d;

                //if (SessionPreOrderPromo!=null)
                //{
                //    preOrderPromoValue = SessionPreOrderPromo.PreOrderPromoValue;
                //}
                order.OrderTotal      = order.OrderTotal + price;
                SessionUserOrder      = order;
                SessionUserOrderTotal = order.OrderTotal;

                this.ClientScript.RegisterClientScriptBlock(this.GetType(), "CloseWindow", "<script type='text/javascript'>CloseOnReload()</script>");
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
Example #4
0
        private void OrderNowButton_Click(object sender, RoutedEventArgs e)
        {
            Double   productPrice = 0;
            Products product      = (Products)lbProducts.SelectedItem;
            List <OrderDetailAdOns>   orderDetailAdonList    = new List <OrderDetailAdOns>();
            List <OrderDetailOptions> orderDetailOptionsList = new List <OrderDetailOptions>();

            if (UserOrder == null)
            {
                UserOrder = new Orders();
            }
            if (_optionPrice == 0)
            {
                productPrice = product.DefaultBranchProductPrice;
            }
            else
            {
                productPrice = _optionPrice;
            }

            if (UserOrder.OrderDetailsList == null)
            {
                UserOrder.OrderDetailsList = new List <BusinessEntities.OrderDetails>();
                //SessionOrderAdonList = new List<List<BusinessEntities.OrderDetailAdOns>>();
                //SessionOrderDetailOptionList = new List<List<BusinessEntities.OrderDetailOptions>>();
                UserOrder.OrderStatusID = BusinessEntities.OrderStatus.NewOrder;
            }
            BusinessEntities.OrderDetails orderdetail = new BusinessEntities.OrderDetails();
            if (!product.IsSpecial)
            {
                if (_optionPrice > 0)
                {
                    orderdetail.Price = _optionPrice;
                }
                else
                {
                    orderdetail.Price = Convert.ToDouble(product.DefaultBranchProductPrice);
                }
            }
            orderdetail.CategoryName = _category.Name;
            orderdetail.ProductName  = product.Name;
            orderdetail.ProductID    = product.ProductID;
            orderdetail.ProductImage = product.Image;
            orderdetail.Quantity     = 1;
            if (product.IsSpecial)
            {
                MultiPorductControl control = (MultiPorductControl)MultiProductPanel.Children[0];
                orderdetail.Price = control.GetPrice();
                orderdetail.OrderDetailSubProducts = control.GetOrderDetailSubProducts();
                orderdetail.IsGroupProduct         = true;
            }
            else
            {
                #region Get Selected Option


                for (int i = 0; i < lbOptions.Items.Count; i++)
                {
                    DependencyObject obj = lbOptions.ItemContainerGenerator.ContainerFromIndex(i);
                    ContentPresenter optionTypeContentPresenter = FindVisualChild <ContentPresenter>(obj);
                    OptionType       optionType = (OptionType)optionTypeContentPresenter.Content;
                    ListBox          OptionList = FindVisualChild <ListBox>(obj);
                    if (optionType.IsSamePrice && !optionType.IsMultiSelect)
                    {
                        for (int j = 0; j < OptionList.Items.Count; j++)
                        {
                            DependencyObject obj1 = OptionList.ItemContainerGenerator.ContainerFromIndex(j);
                            // Getting the ContentPresenter of myListBoxItem
                            ContentPresenter myContentPresenter = FindVisualChild <ContentPresenter>(obj1);
                            // Finding textBlock from the DataTemplate that is set on that ContentPresenter
                            DataTemplate myDataTemplate = myContentPresenter.ContentTemplate;
                            RadioButton  selectedOption = (RadioButton)myDataTemplate.FindName("SelectedOption", myContentPresenter);
                            if (selectedOption.IsChecked.Value)
                            {
                                ProductOptions     productOptions    = (ProductOptions)myContentPresenter.Content;
                                OrderDetailOptions orderdetailoption = new OrderDetailOptions();
                                orderdetailoption.ProductOptionId   = productOptions.OptionID;
                                orderdetailoption.ProductOptionName = productOptions.OptionName;
                                orderdetailoption.Price             = Convert.ToDouble(productOptions.Price);
                                orderDetailOptionsList.Add(orderdetailoption);
                                orderdetail.Price = productOptions.Price;
                            }
                        }
                    }
                    else if (!optionType.IsSamePrice && !optionType.IsMultiSelect)
                    {
                        for (int j = 0; j < OptionList.Items.Count; j++)
                        {
                            DependencyObject obj1 = OptionList.ItemContainerGenerator.ContainerFromIndex(j);
                            // Getting the ContentPresenter of myListBoxItem
                            ContentPresenter myContentPresenter = FindVisualChild <ContentPresenter>(obj1);
                            // Finding textBlock from the DataTemplate that is set on that ContentPresenter
                            DataTemplate myDataTemplate = myContentPresenter.ContentTemplate;
                            RadioButton  selectedOption = (RadioButton)myDataTemplate.FindName("SelectedOption", myContentPresenter);
                            if (selectedOption.IsChecked.Value)
                            {
                                ProductOptions     productOptions    = (ProductOptions)myContentPresenter.Content;
                                OrderDetailOptions orderdetailoption = new OrderDetailOptions();
                                orderdetailoption.ProductOptionId   = productOptions.OptionID;
                                orderdetailoption.ProductOptionName = productOptions.OptionName;
                                orderdetailoption.Price             = productOptions.Price;
                                orderDetailOptionsList.Add(orderdetailoption);
                                orderdetail.Price = productOptions.Price;
                            }
                        }
                    }
                }

                #endregion


                #region Get Selected Toppings


                for (int i = 0; i < lbToppings.Items.Count; i++)
                {
                    DependencyObject obj = lbToppings.ItemContainerGenerator.ContainerFromIndex(i);
                    ContentPresenter adonTypeContentPresenter = FindVisualChild <ContentPresenter>(obj);
                    AdonType         adonType = (AdonType)adonTypeContentPresenter.Content;
                    ListBox          AdonList = FindVisualChild <ListBox>(obj);
                    for (int j = 0; j < AdonList.Items.Count; j++)
                    {
                        DependencyObject obj1 = AdonList.ItemContainerGenerator.ContainerFromIndex(j);
                        // Getting the ContentPresenter of myListBoxItem
                        ContentPresenter myContentPresenter = FindVisualChild <ContentPresenter>(obj1);
                        // Finding textBlock from the DataTemplate that is set on that ContentPresenter
                        DataTemplate myDataTemplate  = myContentPresenter.ContentTemplate;
                        Int16        SelectedTopping = Convert.ToInt16(((TextBlock)myDataTemplate.FindName("SelectedTopping", myContentPresenter)).Text);
                        if (SelectedTopping != 0)
                        {
                            if (!adonType.IsFreeAdonType)
                            {
                                Adon adon = (Adon)myContentPresenter.Content;

                                OrderDetailAdOns orderdetailadon = new OrderDetailAdOns();
                                orderdetailadon.AdOnId             = adon.AdOnID;
                                orderdetailadon.AdonName           = adon.AdOnName;
                                orderdetailadon.AdonTypeName       = adon.AdOnTypeName;
                                orderdetailadon.SelectedAdonOption = (SelectedOption)SelectedTopping;

                                orderDetailAdonList.Add(orderdetailadon);
                                if (adon.DefaultSelected != SelectedTopping)
                                {
                                    if (_defaultAdonPrice > 0)
                                    {
                                        productPrice += _defaultAdonPrice;
                                    }
                                    else
                                    {
                                        productPrice += (Double)adonType.Price;
                                    }
                                }
                            }
                        }
                    }
                }

                #endregion
            }
            double discountPrice = 0;
            Double.TryParse(txtDiscount.Text, out discountPrice);
            if (discountPrice > 0)
            {
                orderdetail.Price = discountPrice;
            }
            else if (orderdetail.Price == 0)
            {
                orderdetail.Price = productPrice;
            }

            UserOrder.OrderDetailsList.Add(orderdetail);
            UserOrder.OrderTotal += orderdetail.Price;
            OrderDetailOptionList.Add(orderDetailOptionsList);
            OrderDetailAdonList.Add(orderDetailAdonList);

            lbOptions.ItemsSource  = null;
            lbToppings.ItemsSource = null;
            _defaultAdonPrice      = 0;
            _optionPrice           = 0;
            SelectedAdons.Text     = string.Empty;
            txtDiscount.Text       = String.Empty;
            Price.Content          = String.Empty;
            lbProducts.UnselectAll();
            this.Close();
        }
    private decimal GetOrderOptions(BusinessEntities.OrderDetails orderdetail, decimal adonpricefromOptionType)
    {
        RadListViewDataItemCollection optioncollection  = txtOptions.Items;
        List <BusinessEntities.OrderDetailOptions> list = new List <BusinessEntities.OrderDetailOptions>();

        foreach (RadListViewDataItem item in optioncollection)
        {
            long id = (long)item.GetDataKeyValue("ProductsOptionTypeId");
            OptionTypesInProduct OTP = (from otp in entities.OptionTypesInProducts
                                        where otp.ProductsOptionTypeId == id
                                        select otp).FirstOrDefault();
            if (OTP.IsSamePrice && !OTP.IsMultiSelect)
            {
                RadioButtonList radioList = item.FindControl("RadioButtonList") as RadioButtonList;
                foreach (ListItem listitem in radioList.Items)
                {
                    if (listitem.Selected)
                    {
                        long POP_ID = long.Parse(listitem.Value); ////Product Option In Product ID
                        ProductOptionsInProduct POP_obj = (from pop in entities.ProductOptionsInProducts
                                                           where pop.ProductOptionsInProductID == POP_ID
                                                           select pop).FirstOrDefault();
                        if (OTP.IsProductPriceChangeType)
                        {
                            orderdetail.Price = Convert.ToDouble(POP_obj.Price);
                        }

                        if ((bool)OTP.IsProductPriceChangeType && OTP.IsAdonPriceVary)
                        {
                            if (POP_obj.ToppingPrice != null)
                            {
                                adonpricefromOptionType = (decimal)POP_obj.ToppingPrice;
                            }
                        }
                        BusinessEntities.OrderDetailOptions orderdetailoption = new BusinessEntities.OrderDetailOptions();
                        orderdetailoption.ProductOptionId       = POP_obj.ProductOptionID;
                        orderdetailoption.ProductOptionName     = POP_obj.ProductOption.OptionName;
                        orderdetailoption.ProductOptionTypeName =
                            POP_obj.OptionTypesInProduct.OptionType.OptionDisplayText;
                        if (OTP.IsProductPriceChangeType)
                        {
                            orderdetailoption.Price = Convert.ToDouble(POP_obj.Price.Value);
                        }
                        list.Add(orderdetailoption);
                    }
                }
            }
            else
            {
                if (OTP.IsMultiSelect)
                {
                    #region CheckBox List

                    CheckBoxList chkList = item.FindControl("CheckBoxList") as CheckBoxList;
                    foreach (ListItem listitem in chkList.Items)
                    {
                        if (listitem.Selected)
                        {
                            long POP_ID = long.Parse(listitem.Value); ////Product Option In Product ID
                            ProductOptionsInProduct POP_obj = (from pop in entities.ProductOptionsInProducts
                                                               where pop.ProductOptionsInProductID == POP_ID
                                                               select pop).FirstOrDefault();
                            orderdetail.Price += Convert.ToDouble(POP_obj.Price);

                            BusinessEntities.OrderDetailOptions orderdetailoption = new BusinessEntities.OrderDetailOptions();
                            orderdetailoption.ProductOptionId       = POP_obj.ProductOptionID;
                            orderdetailoption.ProductOptionName     = POP_obj.ProductOption.OptionName;
                            orderdetailoption.Price                 = Convert.ToDouble(POP_obj.Price.Value);
                            orderdetailoption.ProductOptionTypeName = POP_obj.OptionTypesInProduct.OptionType.OptionDisplayText;
                            list.Add(orderdetailoption);
                        }
                    }
                    #endregion
                }
                else
                {
                    RadioButtonList radioList = item.FindControl("RadioButtonList") as RadioButtonList;
                    foreach (ListItem listitem in radioList.Items)
                    {
                        #region

                        if (listitem.Selected)
                        {
                            long POP_ID = long.Parse(listitem.Value); ////Product Option In Product ID
                            ProductOptionsInProduct POP_obj = (from pop in entities.ProductOptionsInProducts
                                                               where pop.ProductOptionsInProductID == POP_ID
                                                               select pop).FirstOrDefault();
                            orderdetail.Price = Convert.ToDouble(POP_obj.Price);

                            if ((bool)OTP.IsProductPriceChangeType)
                            {
                                if (POP_obj.ToppingPrice != null)
                                {
                                    adonpricefromOptionType = (decimal)POP_obj.ToppingPrice;
                                }
                            }
                            BusinessEntities.OrderDetailOptions orderdetailoption = new BusinessEntities.OrderDetailOptions();
                            orderdetailoption.ProductOptionId       = POP_obj.ProductOptionID;
                            orderdetailoption.ProductOptionName     = POP_obj.ProductOption.OptionName;
                            orderdetailoption.ProductOptionTypeName =
                                POP_obj.OptionTypesInProduct.OptionType.OptionDisplayText;
                            orderdetailoption.Price = Convert.ToDouble(POP_obj.Price);
                            list.Add(orderdetailoption);
                        }
                        #endregion
                    }
                }
            }
        }
        SessionOrderDetailOptionList.Add(list);
        return(adonpricefromOptionType);
    }
    private void GetOrderAdons(BusinessEntities.OrderDetails orderdetail, decimal adonpricefromOptionType)
    {
        RadListViewDataItemCollection            adoncollection = txtAdonsList.Items;
        List <BusinessEntities.OrderDetailAdOns> list           = new List <BusinessEntities.OrderDetailAdOns>();

        foreach (RadListViewDataItem mainitem in adoncollection)
        {
            Label             txtAdonType       = mainitem.FindControl("txtAdonTypeName") as Label;
            RadListView       txtAdons          = mainitem.FindControl("txtAdons") as RadListView;
            long              productadontypeid = (long)mainitem.GetDataKeyValue("ProductsAdOnTypeId");
            AdOnTypeInProduct adontypeinproduct = (from ATP in entities.AdOnTypeInProducts
                                                   where ATP.ProductsAdOnTypeId == productadontypeid
                                                   select ATP).FirstOrDefault();

            RadListViewDataItemCollection childadoncollection = txtAdons.Items;
            foreach (RadListViewDataItem childitem in childadoncollection)
            {
                long        id             = (long)childitem.GetDataKeyValue("ProductAdOnID");
                ProductAdon productadonObj = (from PA in entities.ProductAdons
                                              where PA.ProductAdOnID == id
                                              select PA).FirstOrDefault();
                if (productadonObj != null)
                {
                    BusinessEntities.OrderDetailAdOns orderdetailadon = new BusinessEntities.OrderDetailAdOns();
                    orderdetailadon.AdOnId       = productadonObj.Adon.AdOnID;
                    orderdetailadon.AdonName     = productadonObj.Adon.AdOnName;
                    orderdetailadon.AdonTypeName = txtAdonType.Text;

                    if (productadonObj.AdOnTypeInProduct.DisplayFormat == 1)
                    {
                        HiddenField SelectedSize = childitem.FindControl("SelectedSize") as HiddenField;
                        HiddenField IsDouble = childitem.FindControl("IsDouble") as HiddenField;
                        short       selectedoption = 0, isDouble = 0;


                        selectedoption = short.Parse(SelectedSize.Value);
                        isDouble       = short.Parse(IsDouble.Value);
                        if (selectedoption != 0)
                        {
                            orderdetailadon.SelectedAdonOption = (BusinessEntities.SelectedOption)selectedoption;
                            if (productadonObj.DefaultSelected == 0 && (selectedoption == 1 || selectedoption == 2 || selectedoption == 3))
                            {
                                if (!productadonObj.Adon.AdonType1.IsFreeAdonType)
                                {
                                    if (isDouble == 1)
                                    {
                                        if (adonpricefromOptionType > 0)
                                        {
                                            orderdetail.Price += Convert.ToDouble(2 * adonpricefromOptionType);
                                        }
                                        else
                                        {
                                            orderdetail.Price += Convert.ToDouble(2 * (decimal)adontypeinproduct.Price);
                                        }
                                        orderdetailadon.IsDoubleSelected = true;
                                    }
                                    else
                                    {
                                        if (adonpricefromOptionType > 0)
                                        {
                                            orderdetail.Price += Convert.ToDouble(adonpricefromOptionType);
                                        }
                                        else
                                        {
                                            orderdetail.Price += Convert.ToDouble((decimal)adontypeinproduct.Price);
                                        }
                                        orderdetailadon.IsDoubleSelected = false;
                                    }
                                }
                                else
                                {
                                    orderdetail.Price += Convert.ToDouble(adontypeinproduct.Price);
                                }
                                list.Add(orderdetailadon);
                            }
                            else if (isDouble == 1)
                            {
                                if (adonpricefromOptionType > 0)
                                {
                                    orderdetail.Price += Convert.ToDouble(adonpricefromOptionType);
                                }
                                else
                                {
                                    orderdetail.Price += Convert.ToDouble((decimal)adontypeinproduct.Price);
                                }
                                orderdetailadon.IsDoubleSelected = true;
                                list.Add(orderdetailadon);
                            }
                            else if (productadonObj.DefaultSelected == 1)
                            {
                                orderdetail.Price += 0;
                                orderdetailadon.IsDoubleSelected = false;
                                list.Add(orderdetailadon);
                            }
                        }
                    }
                    else if (productadonObj.AdOnTypeInProduct.DisplayFormat == 2)
                    {
                        list.Add(orderdetailadon);
                    }
                    else if (productadonObj.AdOnTypeInProduct.DisplayFormat == 4)
                    {
                        HiddenField SelectedSize   = childitem.FindControl("SelectedSize") as HiddenField;
                        short       selectedoption = 0;
                        selectedoption = short.Parse(SelectedSize.Value);

                        orderdetailadon.SelectedAdonOption = (BusinessEntities.SelectedOption)selectedoption;
                        if (productadonObj.DefaultSelected == 0 && selectedoption == 1)
                        {
                            if (!productadonObj.Adon.AdonType1.IsFreeAdonType)
                            {
                                orderdetail.Price += Convert.ToDouble((decimal)adontypeinproduct.Price);
                            }
                        }
                        list.Add(orderdetailadon);
                    }
                }
            }
        }
        SessionOrderAdonList.Add(list);
    }
    protected void AddToCartButton_Click(object sender, EventArgs e)
    {
        BusinessEntities.Orders order = SessionUserOrder;
        if (order == null)
        {
            order = new BusinessEntities.Orders();
        }


        try
        {
            long             branchproductid = long.Parse(Request.QueryString["BPID"]);
            ProductsInBranch bpObj           = (from bp in entities.ProductsInBranches
                                                where bp.BranchProductID == branchproductid
                                                select bp).FirstOrDefault();
            if (bpObj != null)
            {
                if (order.OrderDetailsList == null)
                {
                    order.OrderDetailsList       = new List <BusinessEntities.OrderDetails>();
                    SessionOrderAdonList         = new List <List <BusinessEntities.OrderDetailAdOns> >();
                    SessionOrderDetailOptionList = new List <List <BusinessEntities.OrderDetailOptions> >();
                    order.OrderStatusID          = BusinessEntities.OrderStatus.NewOrder;
                }
                BusinessEntities.OrderDetails orderdetail = new BusinessEntities.OrderDetails();

                if (bpObj.Product.CategoryID == PizzaCategoryId)
                {
                    string thinCrust = GetThinCrustValue();
                    orderdetail.CrustType = thinCrust;
                }
                orderdetail.Price        = Convert.ToDouble(bpObj.Price);
                orderdetail.CategoryName = bpObj.Product.ProductCategory.Name;
                orderdetail.ProductName  = txtProductName.Text;
                orderdetail.ProductID    = bpObj.ProductID;
                orderdetail.ProductImage = bpObj.Product.Image;
                orderdetail.Quantity     = Convert.ToInt32(txtQuantity.Value);
                if (!string.IsNullOrEmpty(txtRecipientName.Text))
                {
                    orderdetail.RecipientName = txtRecipientName.Text;
                }
                if (!string.IsNullOrEmpty(txtInstruction.Text))
                {
                    orderdetail.Comments = txtInstruction.Text;
                }
                decimal adonpricefromOptionType = 0;
                adonpricefromOptionType = GetOrderOptions(orderdetail, adonpricefromOptionType);

                GetOrderAdons(orderdetail, adonpricefromOptionType);

                orderdetail.ItemTotal     = orderdetail.Price * orderdetail.Quantity;
                orderdetail.OrderDetailID = order.OrderDetailsList.Count + 1;
                order.OrderDetailsList.Add(orderdetail);
                order.OrderTotal     += orderdetail.ItemTotal;
                SessionUserOrder      = order;
                SessionUserOrderTotal = order.OrderTotal;
                this.ClientScript.RegisterClientScriptBlock(this.GetType(), "CloseWindow", "<script type='text/javascript'>CloseOnReload()</script>");
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }