private void AddItemToShoppingCart()
{
OptionItemValueCollection selectedOptions = uxOptionGroupDetails.GetSelectedOptions();
ProductKitItemValueCollection selectedKits = uxProductKitGroupDetails.GetSelectedProductKitItems();
CartItemGiftDetails giftDetails = CreateGiftDetails();
decimal customPrice = decimal.Parse(uxEnterAmountText.Text);
customPrice = decimal.Divide(customPrice, Convert.ToDecimal(StoreContext.Currency.ConversionRate));
CartAddItemService addToCartService = new CartAddItemService(
StoreContext.Culture, StoreContext.ShoppingCart);
int currentStock;
string errorOptionName;
bool stockOK = addToCartService.AddToCart(
CurrentProduct,
selectedOptions,
selectedKits,
ConvertUtilities.ToInt32(uxQuantityText.Text),
giftDetails,
customPrice,
out errorOptionName,
out currentStock);
if (stockOK)
{
Response.Redirect("ShoppingCart.aspx");
}
else
{
DisplayOutOfStockError(currentStock, errorOptionName);
}
}
private void AddItemToWishListCart(object sender, EventArgs e)
{
string errorMessage;
if (VerifyValidInput(out errorMessage))
{
OptionItemValueCollection selectedOptions = uxOptionGroupDetails.GetSelectedOptions();
ProductKitItemValueCollection selectedKits = uxProductKitGroupDetails.GetSelectedProductKitItems();
if (CurrentProduct.MinQuantity <= ConvertUtilities.ToInt32(uxQuantityText.Text))
{
uxAddtoWishListButton.AddItemToWishListCart(CurrentProduct.ProductID, selectedOptions, uxQuantityText.Text);
}
else
{
uxAddtoWishListButton.AddItemToWishListCart(CurrentProduct.ProductID, selectedOptions, CurrentProduct.MinQuantity.ToString());
}
Response.Redirect("WishList.aspx");
}
else
{
uxMessage.Text = errorMessage;
}
}
private void ReorderProcess()
{
Order order = DataAccessContext.OrderRepository.GetOne(CurrentOrderID);
IList <OrderItem> orderList = order.OrderItems;
foreach (OrderItem orderItem in orderList)
{
int productCount = DataAccessContext.ProductRepository.GetAllProductCountBySku(orderItem.Sku);
Product product;
if (productCount > 1)
{
IList <Product> products = DataAccessContext.ProductRepository.GetProductByName(StoreContext.Culture, StoreContext.CurrentStore.StoreID, orderItem.Name);
if (products.Count == 1)
{
product = products[0];
}
else
{
return;
}
}
else
{
product = DataAccessContext.ProductRepository.GetOneBySku(StoreContext.Culture, StoreContext.CurrentStore.StoreID, orderItem.Sku);
}
IList <ProductOptionGroup> productOptionGroup = product.ProductOptionGroups;
ArrayList optionItemNameArray = new ArrayList();
ProductKitItemValueCollection itemCollection = new ProductKitItemValueCollection();
if (!IsProductIsValid(product, orderItem, out optionItemNameArray, out itemCollection))
{
return;
}
string optionItemIDs = string.Empty;
for (int i = 0; i < productOptionGroup.Count; i++)
{
optionItemIDs += GetOptionItemIDsFromItemName(productOptionGroup[i].OptionGroup, optionItemNameArray);
}
if (!ReOrderToCart(product, orderItem, optionItemIDs, itemCollection))
{
return;
}
}
Response.Redirect("ShoppingCart.aspx");
}
private void AddItemToShoppingCart()
{
OptionItemValueCollection selectedOptions = uxOptionGroupDetails.GetSelectedOptions();
ProductKitItemValueCollection selectedKits = uxProductKitGroupDetails.GetSelectedProductKitItems();
CartItemGiftDetails giftDetails = CreateGiftDetails();
decimal customPrice = decimal.Parse(uxEnterAmountText.Text);
customPrice = decimal.Divide(customPrice, Convert.ToDecimal(StoreContext.Currency.ConversionRate));
CartAddItemService addToCartService = new CartAddItemService(
StoreContext.Culture, StoreContext.ShoppingCart);
int currentStock;
string errorOptionName;
bool stockOK = addToCartService.AddToCart(
CurrentProduct,
selectedOptions,
selectedKits,
ConvertUtilities.ToInt32(uxQuantityText.Text),
giftDetails,
customPrice,
out errorOptionName,
out currentStock);
if (stockOK)
{
bool enableNotification = ConvertUtilities.ToBoolean(DataAccessContext.Configurations.GetValue("EnableAddToCartNotification", StoreContext.CurrentStore));
if (UrlManager.IsMobileDevice(Request))
{
enableNotification = false;
}
if (enableNotification)
{
uxAddToCartNotification.Show(CurrentProduct, ConvertUtilities.ToInt32(uxQuantityText.Text), customPrice, giftDetails, selectedOptions, selectedKits);
}
else
{
Response.Redirect("ShoppingCart.aspx");
}
}
else
{
DisplayOutOfStockError(currentStock, errorOptionName);
}
}
private ProductKitItemValueCollection GenerateProductKitItemValueCollection(Product product, OrderItem orderItem, ArrayList productKit, ArrayList productKitCount, ArrayList productKitGroupID)
{
ProductKitItemValueCollection kitCollection = new ProductKitItemValueCollection();
for (int i = 0; i < productKit.Count; i++)
{
Product subProduct = (Product)productKit[i];
ProductKitItem item = new ProductKitItem();
item.IsUserDefinedQuantity = true;
item.ProductKitGroupID = (string)productKitGroupID[i];
item.ProductID = subProduct.ProductID;
ProductKitItemValue value = new ProductKitItemValue(item, ProductKitGroup.ProductKitGroupType.Unknown, "",
(int)productKitCount[i]);
kitCollection.Add(value);
}
return(kitCollection);
}
public ProductKitItemValueCollection GetSelectedProductKitItems()
{
// loop for each option in datalist
// get selected option for each option
//string[] result = new string[uxOptionDataList.Items.Count];
ProductKitItemValueCollection itemSelected = new ProductKitItemValueCollection();
for (int i = 0; i < uxOptionDataList.Items.Count; i++)
{
Components_ProductKitItemDetails details =
(Components_ProductKitItemDetails)uxOptionDataList.Items[i].FindControl("uxProductKitItemDetails");
foreach (ProductKitItemValue item in details.GetSelectedItem())
{
itemSelected.Add(item);
}
}
return(itemSelected);
}
public void Show(Product product, int quantity, decimal customPrice, CartItemGiftDetails giftDetails, OptionItemValueCollection selectedOptions, ProductKitItemValueCollection productKitItemCollection)
{
ProductImage image = product.GetPrimaryProductImage();
uxProductImage.ImageUrl = "~/" + image.RegularImage;
uxProductNameLink.NavigateUrl = UrlManager.GetProductUrl(product.ProductID, product.Locales[StoreContext.Culture].UrlName);
uxProductNameLink.Text = "<div class='ProductName'>" + product.Name + "</div>";
uxQuantityLabel.Text = quantity.ToString();
decimal productPrice = product.GetDisplayedPrice(StoreContext.WholesaleStatus);
if (product.IsCustomPrice)
{
productPrice = customPrice;
}
if (product.IsGiftCertificate && !product.IsFixedPrice)
{
productPrice = giftDetails.GiftValue;
}
if (productKitItemCollection.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (OptionItemValue optionItemValue in selectedOptions)
{
sb.Append("<div class='OptionName'>");
sb.Append(optionItemValue.GetDisplayedName(StoreContext.Culture, StoreContext.Currency));
sb.Append("</div>");
}
if ((!productKitItemCollection.IsNull) && (productKitItemCollection.Count > 0))
{
sb.Append("<div class='OptionName'>");
sb.Append("Items:");
sb.Append("</div>");
}
foreach (ProductKitItemValue value in productKitItemCollection)
{
sb.Append("<div class='OptionName'>");
sb.Append("- " + value.GetGroupName(StoreContext.Culture, StoreContext.CurrentStore.StoreID) + ":" + value.GetDisplayedName(StoreContext.Culture, StoreContext.CurrentStore.StoreID));
sb.Append("</div>");
}
uxProductNameLink.Text = uxProductNameLink.Text + sb.ToString();
}
else
{
if (selectedOptions.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (OptionItemValue optionItemValue in selectedOptions)
{
sb.Append("<div class='OptionName'>");
sb.Append(optionItemValue.GetDisplayedName(StoreContext.Culture, StoreContext.Currency));
sb.Append("</div>");
productPrice += optionItemValue.OptionItem.PriceToAdd;
}
uxProductNameLink.Text = uxProductNameLink.Text + sb.ToString();
}
}
uxPriceLabel.Text = StoreContext.Currency.FormatPrice(productPrice);
uxMessage.Text = product.Name + "[$AddSuccess]";
uxAddToCartPopup.Show();
}
private bool IsProductIsValid(Product product, OrderItem orderItem, out ArrayList optionItemNameArray, out ProductKitItemValueCollection itemCollection)
{
//check product enabled
optionItemNameArray = null;
itemCollection = ProductKitItemValueCollection.Null;
if (!product.IsEnabled)
{
StoreContext.ClearCheckoutSession();
string message = "<p class=\"ErrorHeader\">[$Product is inactive]</p>";
ErrorMessage(message);
return(false);
}
//check is product option valid
if (!IsProductOptionValid(product, orderItem, out optionItemNameArray))
{
StoreContext.ClearCheckoutSession();
string message = "<p class=\"ErrorHeader\">[$Product changed]</p>";
ErrorMessage(message);
return(false);
}
//check is category enabled
if (!product.IsProductAvailable(StoreContext.CurrentStore.StoreID))
{
StoreContext.ClearCheckoutSession();
string message = "<p class=\"ErrorHeader\">[$Product is inactive]</p>";
ErrorMessage(message);
return(false);
}
ArrayList productKitArray = new ArrayList();
ArrayList productKitCountArray = new ArrayList();
ArrayList productKitGroupIDArray = new ArrayList();
if (product.IsProductKit)
{
if (!IsProductKitValid(product, orderItem, StoreContext.Culture, new StoreRetriever().GetCurrentStoreID(), out productKitArray, out productKitCountArray, out productKitGroupIDArray))
{
StoreContext.ClearCheckoutSession();
string message = "<p class=\"ErrorHeader\">[$ProductKit is inactive]</p>";
ErrorMessage(message);
return(false);
}
itemCollection = GenerateProductKitItemValueCollection(product, orderItem, productKitArray, productKitCountArray, productKitGroupIDArray);
}
ProductSubscription subscriptionItem = new ProductSubscription(product.ProductID);
//check customer can subscription this product
if (subscriptionItem.IsSubscriptionProduct())
{
if (CustomerSubscription.IsContainsProductSubscriptionHigherLevel(
subscriptionItem.ProductSubscriptions[0].SubscriptionLevelID,
DataAccessContextDeluxe.CustomerSubscriptionRepository.GetCustomerSubscriptionsByCustomerID(StoreContext.Customer.CustomerID)))
{
StoreContext.ClearCheckoutSession();
string message = "<p class=\"ErrorHeader\">[$Cannot subscription]</p>";
ErrorMessage(message);
return(false);
}
}
return(true);
}
private bool ReOrderToCart(Product product, OrderItem orderItem, string optionItemIDs, ProductKitItemValueCollection itemCollection)
{
string errorCurrentStock = string.Empty;
int currentStock = 0;
bool isAddToCartSuccess = false;
OptionItemValueCollection optionCollection = new OptionItemValueCollection(StoreContext.Culture, optionItemIDs, product.ProductID);
CartItemGiftDetails giftDetails = new CartItemGiftDetails();
if (product.IsGiftCertificate)
{
GiftCertificateProduct giftProduct = (GiftCertificateProduct)product;
IList <GiftCertificate> giftCertificateList = DataAccessContext.GiftCertificateRepository.GetAllByOrderID(orderItem.OrderID);
foreach (GiftCertificate giftCertificate in giftCertificateList)
{
if (orderItem.OrderItemID == giftCertificate.OrderItemID)
{
giftDetails = new CartItemGiftDetails(
giftCertificate.Recipient,
giftCertificate.PersonalNote,
giftCertificate.NeedPhysical,
giftCertificate.GiftValue);
}
}
if (giftProduct.GiftAmount == 0)
{
giftProduct.GiftAmount = orderItem.UnitPrice;
}
product = (Product)giftProduct;
CartAddItemService addToCartService = new CartAddItemService(
StoreContext.Culture, StoreContext.ShoppingCart);
isAddToCartSuccess = addToCartService.AddToCart(
product,
optionCollection,
itemCollection,
orderItem.Quantity,
giftDetails,
0,
out errorCurrentStock,
out currentStock);
}
else if (product.IsCustomPrice)
{
CartAddItemService addToCartService = new CartAddItemService(
StoreContext.Culture, StoreContext.ShoppingCart);
isAddToCartSuccess = addToCartService.AddToCart(
product,
optionCollection,
itemCollection,
GetProductQuantity(product, orderItem),
giftDetails,
orderItem.UnitPrice,
out errorCurrentStock,
out currentStock);
}
else
{
CartAddItemService addToCartService = new CartAddItemService(
StoreContext.Culture, StoreContext.ShoppingCart);
isAddToCartSuccess = addToCartService.AddToCart(
product,
optionCollection,
itemCollection,
GetProductQuantity(product, orderItem),
giftDetails,
0,
out errorCurrentStock,
out currentStock);
}
if (!isAddToCartSuccess)
{
StoreContext.ClearCheckoutSession();
string message = "<p class=\"ErrorHeader\">[$StockError]</p>";
ErrorMessage(message);
return(false);
}
return(true);
}
private bool IsEnoughStock(out string message)
{
message = String.Empty;
int rowIndex;
for (rowIndex = 0; rowIndex < uxGrid.Rows.Count; rowIndex++)
{
GridViewRow row = uxGrid.Rows[rowIndex];
if (row.RowType == DataControlRowType.DataRow)
{
ICartItem cartItem = (ICartItem)StoreContext.ShoppingCart.FindCartItemByID((string)uxGrid.DataKeys[rowIndex]["CartItemID"]);
bool isPromotion = (bool)uxGrid.DataKeys[rowIndex]["IsPromotion"];
bool isProductKit = (bool)uxGrid.DataKeys[rowIndex]["IsProductKit"];
string productID = uxGrid.DataKeys[rowIndex]["ProductID"].ToString();
string productName = ((HyperLink)row.FindControl("uxItemNameLink")).Text;
int quantity = ConvertUtilities.ToInt32(((TextBox)row.FindControl("uxQuantityText")).Text);
if (!isPromotion)
{
Product product = DataAccessContext.ProductRepository.GetOne(StoreContext.Culture, productID, new StoreRetriever().GetCurrentStoreID());
OptionItemValueCollection options = (OptionItemValueCollection)uxGrid.DataKeys[rowIndex]["Options"];
int productStock = product.GetStock(options.GetUseStockOptionItemIDs());
int currentStock = productStock - quantity;
if (currentStock != DataAccessContext.Configurations.GetIntValue("OutOfStockValue"))
{
if (CatalogUtilities.IsOutOfStock(currentStock, CheckUseInventory(productID)))
{
message += "<li>" + productName;
if (DataAccessContext.Configurations.GetBoolValue("ShowQuantity"))
{
int displayStock = productStock - DataAccessContext.Configurations.GetIntValue("OutOfStockValue");
if (displayStock < 0)
{
displayStock = 0;
}
message += " ( available " + displayStock + " items )";
}
else
{
message += "</li>";
}
}
}
if (isProductKit)
{
ProductKitItemValueCollection valueCollection = cartItem.ProductKits;
foreach (ProductKitItemValue value in valueCollection)
{
product = DataAccessContext.ProductRepository.GetOne(StoreContext.Culture, value.ProductID, new StoreRetriever().GetCurrentStoreID());
productStock = product.GetStock(new string[0]);
currentStock = productStock - quantity;
if (currentStock != DataAccessContext.Configurations.GetIntValue("OutOfStockValue"))
{
if (CatalogUtilities.IsOutOfStock(currentStock, CheckUseInventory(product.ProductID)))
{
message += "<li>" + product.Name + " of " + productName;
if (DataAccessContext.Configurations.GetBoolValue("ShowQuantity"))
{
int displayStock = productStock - DataAccessContext.Configurations.GetIntValue("OutOfStockValue");
if (displayStock < 0)
{
displayStock = 0;
}
message += " ( available " + displayStock + " items )";
}
else
{
message += "</li>";
}
}
}
}
}
}
else
{
CartItemPromotion promotionCartItem = (CartItemPromotion)cartItem;
PromotionSelected promotionSelected = promotionCartItem.PromotionSelected;
foreach (PromotionSelectedItem item in promotionSelected.PromotionSelectedItems)
{
Product product = item.Product;
IList <ProductOptionGroup> groups = DataAccessContext.ProductRepository.GetProductOptionGroups(StoreContext.Culture, product.ProductID);
string[] optionsUseStock = item.GetUseStockOptionItems().ToArray(typeof(string)) as string[];
int productStock = product.GetStock(optionsUseStock);
int currentStock = productStock - quantity;
if (currentStock != DataAccessContext.Configurations.GetIntValue("OutOfStockValue"))
{
if (CatalogUtilities.IsOutOfStock(currentStock, CheckUseInventory(product.ProductID)))
{
message += "<li>" + productName;
message += "</li>";
}
}
}
}
}
}
if (!String.IsNullOrEmpty(message))
{
message =
"<p class=\"ErrorHeader\">[$StockError]</p>" +
"<ul class=\"ErrorBody\">" + message + "</ul>";
return(false);
}
else
{
return(true);
}
}
