protected void Page_PreRender(object sender, EventArgs e)
{
foreach (RepeaterItem ri in SelectedProductRepeater.Items)
{
HiddenField pid = (HiddenField)ri.FindControl("PID");
int productId = AlwaysConvert.ToInt(pid.Value);
Product p = ProductDataSource.Load(productId);
if (p != null && p.ProductOptions.Count > 0)
{
Dictionary <int, int> selectedOptions = GetSelectedOptions(ri.ItemIndex);
bool allOptionsSelected = (selectedOptions.Count == p.ProductOptions.Count);
string optionList = ProductVariantDataSource.GetOptionList(p.Id, selectedOptions, true);
ProductCalculator pcalc = ProductCalculator.LoadForProduct(p.Id, 1, optionList, string.Empty);
Literal productPrice = (Literal)ri.FindControl("ProductPrice");
productPrice.Text = pcalc.Price.LSCurrencyFormat("lc");
if (allOptionsSelected)
{
ProductVariant pv = ProductVariantDataSource.LoadForOptionList(p.Id, optionList);
if (pv != null && !pv.Available)
{
HtmlTableRow trInvalidVariant = (HtmlTableRow)ri.FindControl("trInvalidVariant");
if (trInvalidVariant != null)
{
trInvalidVariant.Visible = true;
}
}
}
}
}
// SAVE THE CUSTOM VIEWSTATE
SaveCustomViewState();
}
private string GetInventoryMessage(string optionlist)
{
string message = string.Empty;
Label label = new Label();
if (!string.IsNullOrEmpty(optionlist) && showInventoryMessage)
{
ProductVariant variant = ProductVariantDataSource.LoadForOptionList(productId, optionlist);
Product _Product = ProductDataSource.Load(productId);
bool inventoryEnabled = _Product.InventoryMode == InventoryMode.Variant && !_Product.AllowBackorder;
if (inventoryEnabled)
{
if (variant.InStock > 0)
{
string inStockformat = AbleContext.Current.Store.Settings.InventoryInStockMessage;
string inStockMessage = string.Format(inStockformat, variant.InStock);
message = inStockMessage;
}
else if (!variant.Available || variant.InStock <= 0)
{
string outOfStockformat = AbleContext.Current.Store.Settings.InventoryOutOfStockMessage;
string outOfStockMessage = string.Format(outOfStockformat, variant.InStock);
message = outOfStockMessage;
if (variant != null && variant.AvailabilityDate.HasValue && variant.AvailabilityDate >= LocaleHelper.LocalNow)
{
string availabilityMessageFormat = AbleContext.Current.Store.Settings.InventoryAvailabilityMessage;
string availabilityMessage = string.Format(availabilityMessageFormat, variant.AvailabilityDate.Value.ToShortDateString());
message += availabilityMessage;
}
}
}
}
return(string.Format("<span class='errorCondition'>{0}</span>", message));
}
protected void SaveButton_Click(object sender, EventArgs e)
{
short quantity = AlwaysConvert.ToInt16(KitQuantity.Text);
if (quantity > 0)
{
ProductVariant productVariant = null;
if (_KitProduct.Product.ProductOptions.Count > 0)
{
productVariant = ProductVariantDataSource.LoadForOptionList(_KitProduct.Product.Id, selectedOptions);
}
if (productVariant != null)
{
_KitProduct.OptionList = productVariant.OptionList;
}
_KitProduct.Name = DisplayName.Text;
_KitProduct.Quantity = quantity;
_KitProduct.PriceModeId = AlwaysConvert.ToByte(PriceMode.SelectedIndex);
_KitProduct.Price = AlwaysConvert.ToDecimal(Price.Text);
_KitProduct.WeightModeId = AlwaysConvert.ToByte(WeightMode.SelectedIndex);
_KitProduct.Weight = AlwaysConvert.ToDecimal(Weight.Text);
_KitProduct.IsSelected = IsSelected.Checked;
_KitProduct.Save();
}
Response.Redirect(string.Format("EditKit.aspx?CategoryId={0}&ProductId={1}", _CategoryId, _ProductId));
}
private bool isVariantInvalid(WishlistItem item)
{
if (item.Product.ProductOptions.Count > 0)
{
ProductVariant v = ProductVariantDataSource.LoadForOptionList(item.Product.Id, item.OptionList);
if (v == null || !v.Available)
{
return(true);
}
}
return(false);
}
protected void ShowProductForm(Product product)
{
if (product.IsSubscription)
{
if (product.SubscriptionPlan.IsRecurring && product.SubscriptionPlan.PaymentFrequencyType == PaymentFrequencyType.Optional)
{
string value = Request.Form[AutoDeliveryInterval.UniqueID];
BindAutoDelieveryOptions(product);
if (!string.IsNullOrEmpty(value))
{
ListItem item = AutoDeliveryInterval.Items.FindByValue(value);
if (item != null)
{
item.Selected = true;
}
}
}
else
{
AutoDeliveryPH.Visible = false;
}
OptionalSubscription.Visible = product.SubscriptionPlan.IsOptional;
}
else
{
trSubscriptionRow.Visible = false;
}
AddPopup.Show();
//SET NAME AND PRICE
AddProductName.Text = product.Name;
// SET QUANTITY TO ONE IF NOT SPECIFIED
if (string.IsNullOrEmpty(AddProductQuantity.Text) || AddProductQuantity.Text == "0")
{
AddProductQuantity.Text = "1";
}
AddProductId.Value = product.Id.ToString();
//BUILD PRODUCT ATTRIBUTES
_SelectedOptions = AbleCommerce.Code.ProductHelper.BuildProductOptions(product, phOptions, true);
//BUILD PRODUCT CHOICES
AbleCommerce.Code.ProductHelper.BuildProductChoices(product, phOptions);
//BUILD KIT OPTIONS, IGNORING INVENTORY
_SelectedKitProducts = AbleCommerce.Code.ProductHelper.BuildKitOptions(product, phOptions, true);
//SET PRICE
string optionList = ProductVariantDataSource.GetOptionList(product.Id, _SelectedOptions, true);
// IF ALL OPTIONS HAVE A VALUE SELECTED, SHOW THE BASKET CONTROLS
AddProductSaveButton.Visible = (_SelectedOptions.Count == product.ProductOptions.Count);
}
/// <summary>
/// Triggers the low inventory item purchased event.
/// </summary>
/// <param name="products">dctionary of product ids and respective variants</param>
public static void LowInventoryItemPurchased(Dictionary <int, string> products)
{
if (products != null && products.Count > 0)
{
List <Product> productCollection = new List <Product>();
List <ProductVariant> variantCollection = new List <ProductVariant>();
List <Vendor> vendorsCollection = new List <Vendor>();
Dictionary <int, Vendor> vendors = new Dictionary <int, Vendor>();
foreach (int productId in products.Keys)
{
if (String.IsNullOrEmpty(products[productId]))
{
// ONLY INCLUDE PRODUCTS WITHOUT VARIANT INFORMATION
Product p = ProductDataSource.Load(productId);
if (p != null)
{
productCollection.Add(p);
if (p.Vendor != null && !vendors.ContainsKey(p.Vendor.VendorId))
{
vendors.Add(p.Vendor.VendorId, p.Vendor);
}
}
}
else
{
ProductVariant v = ProductVariantDataSource.LoadForOptionList(productId, products[productId]);
if (v != null)
{
variantCollection.Add(v);
if (v.Product.Vendor != null && !vendors.ContainsKey(v.Product.Vendor.VendorId))
{
vendors.Add(v.Product.Vendor.VendorId, v.Product.Vendor);
}
}
}
}
foreach (Vendor vendor in vendors.Values)
{
vendorsCollection.Add(vendor);
}
Hashtable parameters = new Hashtable();
parameters["products"] = productCollection.ToArray();
parameters["variants"] = variantCollection.ToArray();
parameters["vendors"] = vendorsCollection.ToArray();
ProcessEmails(StoreEvent.LowInventoryItemPurchased, parameters);
}
}
private void UpdateInventory(bool sendEmails)
{
foreach (GridViewRow row in InventoryGrid.Rows)
{
int dataItemIndex = row.DataItemIndex;
dataItemIndex = (dataItemIndex - (InventoryGrid.PageSize * InventoryGrid.PageIndex));
int productId = (int)InventoryGrid.DataKeys[dataItemIndex].Values[0];
int productVariantId = AlwaysConvert.ToInt(InventoryGrid.DataKeys[dataItemIndex].Values[1].ToString());
int inStock = GetControlValue(row, "InStock");
int lowStock = GetControlValue(row, "LowStock");
TextBox availDate = (TextBox)row.FindControl("AvailabilityDate");
Product product = ProductDataSource.Load(productId);
if (productVariantId.Equals(0))
{
product.InStock = inStock;
product.InStockWarningLevel = lowStock;
product.AvailabilityDate = LocaleHelper.ToLocalTime(AlwaysConvert.ToDateTime(availDate.Text, DateTime.MinValue));
product.Save();
if (sendEmails && product.InStock > 0)
{
RestockNotify(sendEmails, product, null);
}
}
else
{
ProductVariant variant = ProductVariantDataSource.Load(productVariantId);
variant.InStock = inStock;
variant.InStockWarningLevel = lowStock;
variant.AvailabilityDate = LocaleHelper.ToLocalTime(AlwaysConvert.ToDateTime(availDate.Text, DateTime.MinValue));
variant.Save();
if (sendEmails && variant.InStock > 0)
{
RestockNotify(sendEmails, product, variant);
}
}
}
SavedMessage.Text = string.Format(SavedMessage.Text, DateTime.Now);
SavedMessage.Visible = true;
InventoryGrid.DataBind();
}
protected IList <OrderItem> GetOrderItems()
{
//GET THE PRODUCT ID
int productId = AlwaysConvert.ToInt(HiddenProductId.Value);
Product product = ProductDataSource.Load(productId);
if (product == null)
{
return(null);
}
//GET THE QUANTITY
short tempQuantity = AlwaysConvert.ToInt16(Quantity.Text);
if (tempQuantity < 1)
{
return(null);
}
if (tempQuantity > System.Int16.MaxValue)
{
tempQuantity = System.Int16.MaxValue;
}
//RECALCULATE SELECTED KIT OPTIONS
GetSelectedKitOptions(product);
// DETERMINE THE OPTION LIST
string optionList = ProductVariantDataSource.GetOptionList(productId, _SelectedOptions, false);
//CREATE THE BASKET ITEM WITH GIVEN OPTIONS
IList <OrderItem> orderItems = OrderItemDataSource.CreateForProduct(productId, tempQuantity, optionList, AlwaysConvert.ToList(",", _SelectedKitProducts));
if (orderItems.Count > 0)
{
// COLLECT ANY ADDITIONAL INPUTS FOR BASE ITEM
AbleCommerce.Code.ProductHelper.CollectProductTemplateInput(orderItems[0], phOptions);
// UPADATE THE PRICE OF BASE ITEM IF NEEDED ( KIT PRICE WILL NOT BE MODIFIED)
if (orderItems[0].Price != AlwaysConvert.ToDecimal(Price.Text) && (product.KitStatus != KitStatus.Master))
{
orderItems[0].Price = AlwaysConvert.ToDecimal(Price.Text);
}
}
return(orderItems);
}
protected void Price_PreRender(object sender, EventArgs e)
{
int productId = AlwaysConvert.ToInt(HiddenProductId.Value);
Product product = ProductDataSource.Load(productId);
if (product != null)
{
//GET THE SELECTED KIT OPTIONS
GetSelectedKitOptions(product);
}
//SET THE CURRENT CALCULATED PRICE
string optionList = ProductVariantDataSource.GetOptionList(productId, _SelectedOptions, true);
ProductCalculator pcalc = ProductCalculator.LoadForProduct(productId, 1, optionList, AlwaysConvert.ToList(",", _SelectedKitProducts));
Price.Text = string.Format("{0:F2}", pcalc.Price);
if (product.UseVariablePrice)
{
string varPriceText = string.Empty;
if (product.MinimumPrice > 0)
{
if (product.MaximumPrice > 0)
{
varPriceText = string.Format("(between {0} and {1})", product.MinimumPrice.LSCurrencyFormat("lcf"), product.MaximumPrice.LSCurrencyFormat("lcf"));
}
else
{
varPriceText = string.Format("(at least {0})", product.MinimumPrice.LSCurrencyFormat("lcf"));
}
}
else if (product.MaximumPrice > 0)
{
varPriceText = string.Format("({0} maximum)", product.MaximumPrice.LSCurrencyFormat("lcf"));
}
phVariablePrice.Controls.Add(new LiteralControl(varPriceText));
}
// CHANGING PRODUCT PRICE OPTION SHOULD NOT AVAILABLE FOR KIT PRODUCTS
Price.Enabled = (product.KitStatus != KitStatus.Master);
InventoryAlertUpdate();
}
protected void VariantGrid_RowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
bool inventoryEnabled = _Product.InventoryMode == InventoryMode.Variant && !_Product.AllowBackorder;
string optionList = DataBinder.Eval(e.Row.DataItem, "OptionList").ToString();
ProductVariant variant = ProductVariantDataSource.LoadForOptionList(_ProductId, optionList);
Control addToBasketButton = e.Row.FindControl("AddToBasketButton");
Control notificationLink = e.Row.FindControl("NotificationLink");
if (inventoryEnabled && (!variant.Available || (variant.InStock <= 0)) &&
ShowInventoryMessage && addToBasketButton != null)
{
addToBasketButton.Visible = false;
}
bool isAvailabilityDateSpecified = (variant.AvailabilityDate.HasValue && variant.AvailabilityDate >= LocaleHelper.LocalNow);
if (notificationLink != null)
{
notificationLink.Visible = !addToBasketButton.Visible && isAvailabilityDateSpecified && variant.Product.EnableRestockNotifications;
}
}
}
/// <summary>
/// Creates a basket item for a product
/// </summary>
/// <param name="productId">Id of the product for which to create the basket item</param>
/// <param name="quantity">The quantity of basket item</param>
/// <param name="optionList">List of option ids for the variant</param>
/// <param name="kitList">List of product Ids of the kit items</param>
/// <param name="userId">The user Id</param>
/// <returns>The BasketItem created</returns>
public static BasketItem CreateForProduct(int productId, short quantity, string optionList, string kitList, int userId)
{
// vALIDATE PARAMETERS
Product product = ProductDataSource.Load(productId);
if (product == null)
{
throw new ArgumentException("invalid product specified", "product");
}
if (quantity < 1)
{
throw new ArgumentException("quantity must be greater than 0", "quantity");
}
if (!string.IsNullOrEmpty(optionList))
{
ProductVariant v = ProductVariantDataSource.LoadForOptionList(productId, optionList);
if (v == null)
{
throw new ArgumentException("specified product options are invalid", "optionList");
}
}
if (product.KitStatus == KitStatus.Master)
{
Kit kit = product.Kit;
if (!kit.ValidateChoices(kitList))
{
throw new ArgumentException("specified kit configuration is invalid", "kitProductIds");
}
}
//GET THE QUANTITY
short tempQuantity = quantity;
short basketQuantity = GetExistingBasketCount(product);
if ((product.MinQuantity > 0) && ((tempQuantity + basketQuantity) < product.MinQuantity))
{
tempQuantity = (short)(product.MinQuantity - basketQuantity);
}
if ((product.MaxQuantity > 0) && ((tempQuantity + basketQuantity) > product.MaxQuantity))
{
tempQuantity = (short)(product.MaxQuantity - basketQuantity);
}
if (tempQuantity < 1)
{
return(null);
}
quantity = tempQuantity;
BasketItem item = new BasketItem();
//CALCULATE THE PRICE OF THE PRODUCT
ProductCalculator pcalc = ProductCalculator.LoadForProduct(productId, quantity, optionList, kitList, userId);
item.Sku = pcalc.Sku;
item.Price = pcalc.Price;
item.Weight = pcalc.Weight;
//SET VALUES COMMON TO ALL BASKET ITEMS
item.TaxCodeId = product.TaxCodeId;
item.Name = product.Name;
item.Quantity = quantity;
item.OrderItemType = CommerceBuilder.Orders.OrderItemType.Product;
item.Shippable = product.Shippable;
item.ProductId = productId;
item.OptionList = optionList;
item.KitList = kitList;
// COPY MERCHANT INPUT FIELDS, PRODUCT TEMPLATE FIELDS
foreach (ProductTemplateField tf in product.TemplateFields)
{
if (!string.IsNullOrEmpty(tf.InputValue))
{
InputField field = tf.InputField;
if (field.IsMerchantField && field.PersistWithOrder)
{
BasketItemInput itemInput = new BasketItemInput();
itemInput.BasketItemId = item.BasketItemId;
itemInput.InputFieldId = tf.InputFieldId;
itemInput.InputValue = tf.InputValue;
item.Inputs.Add(itemInput);
}
}
}
return(item);
}
protected void Page_Load(object sender, EventArgs e)
{
if (Product != null)
{
string checkImage = this.ShowImage.ToLowerInvariant();
string calculatedImageUrl = string.Empty;
string imageAltText = string.Empty;
string optionList = Request.QueryString["Options"];
ProductVariant variant = null;
if (!string.IsNullOrEmpty(optionList))
{
variant = ProductVariantDataSource.LoadForOptionList(Product.Id, optionList);
}
if (checkImage == "icon")
{
if (variant != null && !string.IsNullOrEmpty(variant.IconUrl))
{
calculatedImageUrl = variant.IconUrl;
imageAltText = Product.IconAltText;
}
else if (!string.IsNullOrEmpty(Product.IconUrl))
{
calculatedImageUrl = Product.IconUrl;
imageAltText = Product.IconAltText;
}
else
{
NoIcon.Visible = true;
}
}
else if (checkImage == "thumbnail")
{
if (variant != null && !string.IsNullOrEmpty(variant.ThumbnailUrl))
{
calculatedImageUrl = variant.ThumbnailUrl;
imageAltText = Product.ThumbnailAltText;
}
else if (!string.IsNullOrEmpty(Product.ThumbnailUrl))
{
calculatedImageUrl = Product.ThumbnailUrl;
imageAltText = Product.ThumbnailAltText;
}
else
{
NoThumbnail.Visible = true;
}
}
else
{
if (variant != null && !string.IsNullOrEmpty(variant.ImageUrl))
{
calculatedImageUrl = variant.ImageUrl;
imageAltText = Product.ImageAltText;
}
else if (!string.IsNullOrEmpty(Product.ImageUrl))
{
calculatedImageUrl = Product.ImageUrl;
imageAltText = Product.ImageAltText;
}
else
{
NoImage.Visible = true;
}
}
if (!string.IsNullOrEmpty(calculatedImageUrl))
{
// check if it is an absolute URL, then do not try to resize
if (calculatedImageUrl.ToLowerInvariant().StartsWith("http"))
{
this.ProductImage.ImageUrl = calculatedImageUrl;
}
else
{
this.ProductImage.ImageUrl = string.Format("~/GetImage.ashx?Path={0}&maintainAspectRatio=true", Server.UrlEncode(calculatedImageUrl));
}
this.ProductImage.AlternateText = Server.HtmlEncode(imageAltText);
ProductImageUrl.Attributes.Add("rel", "gallery");
this.ProductImageUrl.HRef = GetLargeImageUrl(calculatedImageUrl);
this.ProductImageUrl.Title = Server.HtmlEncode(imageAltText);
this.ProductImageUrl.Visible = true;
}
else
{
this.ProductImage.Visible = false;
this.ProductImageUrl.Visible = false;
}
}
if (!Page.ClientScript.IsClientScriptBlockRegistered("JQUERY_FANCY_BOX_JS_CSS"))
{
this.Page.Header.Controls.Add(new LiteralControl("<link href='" + Page.ResolveUrl("~/scripts/fancybox/") + "jquery.fancybox.css' rel='stylesheet' type='text/css' />"));
string scriptText = "<script src='" + ResolveUrl("~/scripts/fancybox/") + "jquery.fancybox.js' language='javascript'/>";
ScriptManager.RegisterStartupScript(this.Page, this.GetType(), "JQUERY_FANCY_BOX_JS_CSS", scriptText, false);
}
}
public void Page_Init(object sender, EventArgs e)
{
if (_Order == null)
{
OrderId = AbleCommerce.Code.PageHelper.GetOrderId();
}
if (_OrderShipment == null)
{
OrderShipmentId = AlwaysConvert.ToInt(Request.QueryString["OrderShipmentId"]);
}
if (_Order == null)
{
Response.Redirect("~/Admin/Orders/Default.aspx");
}
_ProductId = AlwaysConvert.ToInt(Request.QueryString["ProductId"]);
_Product = ProductDataSource.Load(_ProductId);
if (_Product == null)
{
if (_OrderShipment == null)
{
Response.Redirect("~/Admin/Orders/Edit/FindProduct.aspx?OrderNumber=" + _Order.OrderNumber.ToString());
}
else
{
Response.Redirect("~/Admin/Orders/Shipments/FindProduct.aspx?OrderShipmentId=" + _OrderShipmentId.ToString());
}
}
if (_OrderShipment == null)
{
BackButton.NavigateUrl = "~/Admin/Orders/Edit/EditOrderItems.aspx?OrderNumber=" + _Order.OrderNumber.ToString();
}
else
{
BackButton.NavigateUrl = "~/Admin/Orders/Shipments/EditShipment.aspx?OrderShipmentId=" + _OrderShipmentId.ToString();
}
// update instruction text
GiftCertMessage.Visible = _Product.IsGiftCertificate;
DigitalGoodsMessage.Visible = _Product.IsDigitalGood;
SubscriptionMessage.Visible = _Product.IsSubscription;
//SET NAME AND PRICE
Name.Text = _Product.Name;
HiddenProductId.Value = _Product.Id.ToString();
//BUILD PRODUCT ATTRIBUTES
_SelectedOptions = AbleCommerce.Code.ProductHelper.BuildProductOptions(_Product, phOptions, true);
//BUILD PRODUCT CHOICES
AbleCommerce.Code.ProductHelper.BuildProductChoices(_Product, phOptions);
//BUILD KIT OPTIONS
_SelectedKitProducts = AbleCommerce.Code.ProductHelper.BuildKitOptions(_Product, phOptions);
//SET PRICE
string optionList = ProductVariantDataSource.GetOptionList(_Product.Id, _SelectedOptions, true);
ProductCalculator pcalc = ProductCalculator.LoadForProduct(_Product.Id, 1, optionList, AlwaysConvert.ToList(",", _SelectedKitProducts), _Order.UserId);
Price.Text = string.Format("{0:F2}", pcalc.Price);
// IF ALL OPTIONS HAVE A VALUE SELECTED, SHOW THE BASKET CONTROLS
SaveButton.Visible = (_SelectedOptions.Count >= _Product.ProductOptions.Count);
//BackButton.NavigateUrl += "?OrderNumber=" + _Order.OrderNumber.ToString();
//CHECK IF SHIPMENTS NEED TO BE DISPLAYED
trShipment.Visible = (_OrderShipment == null && _Product.Shippable != Shippable.No);
if (trShipment.Visible)
{
//BIND SHIPMENT LIST
foreach (OrderShipment shipment in _Order.Shipments)
{
string address = string.Format("{0} {1} {2} {3}", shipment.ShipToFirstName, shipment.ShipToLastName, shipment.ShipToAddress1, shipment.ShipToCity);
if (address.Length > 50)
{
address = address.Substring(0, 47) + "...";
}
string name = "Shipment #" + shipment.ShipmentNumber + " to " + address;
ShipmentsList.Items.Add(new ListItem(name, shipment.Id.ToString()));
}
if (_Order.Shipments != null && _Order.Shipments.Count == 1)
{
// IF THERE IS JUST ONLY ONE SHIPMENT THEN SELECT IT
ShipmentsList.SelectedIndex = 2;
}
}
// if a new shipment option is selected then initialize the related fields
DisplayOrderShipmentFields(ShipmentsList.SelectedValue == "-1"); ShipFrom.DataSource = AbleContext.Current.Store.Warehouses;
ShipFrom.DataBind();
if (AddressList.Items.Count <= 1)
{
BindShippingAddresses(this.AddressList);
}
}
protected void InventoryAlertUpdate()
{
if (_Product != null)
{
// WE HAVE A VALID PRODUCT, ARE ANY AVAILABLE OPTIONS SELECTED?
bool allProductOptionsSelected = (_SelectedOptions.Count == _Product.ProductOptions.Count);
if (allProductOptionsSelected)
{
// OPTIONS ARE GOOD, VERIFY ANY REQUIRED KIT OPTIONS ARE SELECTED
GetSelectedKitOptions(_Product);
bool requiredKitOptionsSelected = AbleCommerce.Code.ProductHelper.RequiredKitOptionsSelected(_Product, _SelectedKitProducts);
if (requiredKitOptionsSelected)
{
// KIT OPTIONS ARE ALSO VALID, DETERMINE APPROPRIATE WARNINGS
Store store = AbleContext.Current.Store;
List <string> warningMessages = new List <string>();
string optionList = string.Empty;
if (_Product.ProductOptions.Count > 0)
{
// OPTIONS ARE PRESENT, CHECK AVAILABLILITY
optionList = ProductVariantDataSource.GetOptionList(_ProductId, _SelectedOptions, true);
ProductVariant variant = ProductVariantDataSource.LoadForOptionList(_Product.Id, optionList);
if (!variant.Available)
{
warningMessages.Add("The selected variant is marked as unavailable.");
}
// WE ALSO NEED TO ALERT INVENTORY IF ENABLED AT VARIANT LEVEL AND THIS IS NOT A KIT
if (store.Settings.EnableInventory &&
_Product.KitStatus != KitStatus.Master &&
_Product.InventoryMode == InventoryMode.Variant)
{
warningMessages.Add("The selected variant has a current stock level of " + variant.InStock + ".");
}
}
// CHECK STOCK QUANTITY FOR PRODUCT, IF STORE INVENTORY IS ENABLED
// AND THE STOCK IS MANAGED AT THE PRODUCT LEVEL OR THIS IS A KIT
if (store.Settings.EnableInventory && (_Product.InventoryMode == InventoryMode.Product || _Product.KitStatus == KitStatus.Master))
{
IInventoryManager inventoryManager = AbleContext.Resolve <IInventoryManager>();
InventoryManagerData inv = inventoryManager.CheckStock(_ProductId, optionList, _SelectedKitProducts);
if (!inv.AllowBackorder)
{
if (_Product.KitStatus == KitStatus.Master)
{
// INVENTORY MESSAGE FOR KIT PRODUCTS
warningMessages.Add("The selected configuration has a current stock level of " + inv.InStock + ".");
}
else
{
// NOT KIT OR VARIANT
warningMessages.Add("This product has a current stock level of " + inv.InStock + ".");
}
}
}
// SHOW ANY WARNING MESSAGES
if (warningMessages.Count > 0)
{
InventoryWarningMessage.Text = "Note: " + string.Join(" ", warningMessages.ToArray());
trInventoryWarning.Visible = true;
}
}
}
}
}
/// <summary>
/// Gets the order items that would result from the addition of the given product to an order.
/// </summary>
/// <param name="productId">The id of the product to add.</param>
/// <param name="quantity">The quantity of the product to add.</param>
/// <param name="optionList">List of option choice ids if this is a variant</param>
/// <param name="kitList">List of kit products if it is a Kit</param>
/// <returns>The order items that would result from the addition of the given product to an order</returns>
public static List <OrderItem> CreateForProduct(int productId, short quantity, string optionList, string kitList)
{
List <OrderItem> orderItems = new List <OrderItem>();
Product product = ProductDataSource.Load(productId);
if (product != null)
{
//CREATE THE BASE ORDER ITEM
OrderItem baseItem = new OrderItem();
baseItem.Name = product.Name;
baseItem.OrderItemType = OrderItemType.Product;
baseItem.ProductId = productId;
baseItem.TaxCodeId = product.TaxCodeId;
baseItem.Quantity = quantity;
baseItem.ShippableId = product.ShippableId;
//CALCULATE THE PRICE OF THE PRODUCT
ProductCalculator pcalc = ProductCalculator.LoadForProduct(productId, quantity, optionList, kitList);
baseItem.Sku = pcalc.Sku;
baseItem.Price = pcalc.Price;
baseItem.Weight = pcalc.Weight;
//CHECK PRODUCT VARIANT
ProductVariant variant = ProductVariantDataSource.LoadForOptionList(productId, optionList);
if (variant != null)
{
baseItem.OptionList = optionList;
baseItem.VariantName = variant.VariantName;
}
//CHECK FOR DIGITAL GOODS
foreach (ProductDigitalGood dg in product.DigitalGoods)
{
if (dg.DigitalGood != null && (String.IsNullOrEmpty(baseItem.OptionList) || baseItem.OptionList == dg.OptionList))
{
OrderItemDigitalGood oidg = new OrderItemDigitalGood();
oidg.OrderItemId = baseItem.OrderItemId;
oidg.DigitalGoodId = dg.DigitalGoodId;
oidg.Name = dg.DigitalGood.Name;
baseItem.DigitalGoods.Add(oidg);
}
}
orderItems.Add(baseItem);
//CHECK FOR KIT ITEMS
int[] kitProductIds = AlwaysConvert.ToIntArray(kitList);
if (kitProductIds != null && kitProductIds.Length > 0)
{
LSDecimal baseItemPrice = baseItem.Price;
LSDecimal baseItemWeight = baseItem.Weight;
foreach (int kitProductId in kitProductIds)
{
KitProduct kitProduct = KitProductDataSource.Load(kitProductId);
if (kitProduct != null)
{
OrderItem kitItem = new OrderItem();
kitItem.Name = kitProduct.DisplayName;
kitItem.OrderItemType = OrderItemType.Product;
kitItem.ParentItemId = baseItem.OrderItemId;
kitItem.ProductId = kitProduct.ProductId;
kitItem.OptionList = kitProduct.OptionList;
kitItem.Quantity = (short)(kitProduct.Quantity * baseItem.Quantity);
kitItem.Sku = kitProduct.Product.Sku;
kitItem.TaxCodeId = kitProduct.Product.TaxCodeId;
kitItem.Price = kitProduct.CalculatedPrice / kitProduct.Quantity;
kitItem.Weight = kitProduct.CalculatedWeight / kitProduct.Quantity;
//CHECK FOR DIGITAL GOODS
foreach (DigitalGood dg in kitItem.Product.DigitalGoods)
{
OrderItemDigitalGood oidg = new OrderItemDigitalGood();
oidg.OrderItemId = kitItem.OrderItemId;
oidg.DigitalGoodId = dg.DigitalGoodId;
kitItem.DigitalGoods.Add(oidg);
}
baseItemPrice -= kitProduct.CalculatedPrice;
baseItemWeight -= kitProduct.CalculatedWeight;
orderItems.Add(kitItem);
}
}
baseItem.Price = baseItemPrice;
baseItem.Weight = baseItemWeight;
}
}
return(orderItems);
}
protected void AddProductPrice_PreRender(object sender, EventArgs e)
{
int productId = AlwaysConvert.ToInt(AddProductId.Value);
Product product = ProductDataSource.Load(productId);
if (product != null)
{
//GET THE SELECTED KIT OPTIONS
GetSelectedKitOptions(product);
//SET THE CURRENT CALCULATED PRICE
string optionList = ProductVariantDataSource.GetOptionList(productId, _SelectedOptions, true);
bool calculateOneTimePrice = AlwaysConvert.ToBool(OptionalSubscription.SelectedValue, false);
ProductCalculator pcalc = ProductCalculator.LoadForProduct(productId, 1, optionList, AlwaysConvert.ToList(",", _SelectedKitProducts), _UserId, false, calculateOneTimePrice);
AddProductPrice.Text = string.Format("{0:F2}", pcalc.Price);
if (product.IsSubscription)
{
if (product.SubscriptionPlan.IsRecurring)
{
if (!calculateOneTimePrice)
{
short frequency = product.SubscriptionPlan.PaymentFrequencyType == PaymentFrequencyType.Optional ? AlwaysConvert.ToInt16(AutoDeliveryInterval.SelectedValue) : product.SubscriptionPlan.PaymentFrequency;
SubscriptionMessage.Text = ProductHelper.GetRecurringPaymentMessage(product.Price, 0, product.SubscriptionPlan, frequency);
SubscriptionMessage.Visible = true;
}
else
{
SubscriptionMessage.Visible = false;
}
}
else
{
trSubscriptionRow.Visible = product.SubscriptionPlan.IsOptional;
}
}
else
{
trSubscriptionRow.Visible = false;
}
if (product.UseVariablePrice && !product.IsSubscription && !product.IsKit)
{
AddProductVariablePrice.Text = string.Format("{0:F2}", pcalc.Price);
AddProductVariablePrice.Visible = true;
string varPriceText = string.Empty;
if (product.MinimumPrice > 0)
{
if (product.MaximumPrice > 0)
{
varPriceText = string.Format("(between {0} and {1})", product.MinimumPrice.LSCurrencyFormat("lcf"), product.MaximumPrice.LSCurrencyFormat("lcf"));
}
else
{
varPriceText = string.Format("(at least {0})", product.MinimumPrice.LSCurrencyFormat("lcf"));
}
}
else if (product.MaximumPrice > 0)
{
varPriceText = string.Format("({0} maximum)", product.MaximumPrice.LSCurrencyFormat("lcf"));
}
phVariablePrice.Controls.Add(new LiteralControl(varPriceText));
}
AddProductPrice.Visible = !AddProductVariablePrice.Visible;
if ((AddProductPrice.Visible && _Basket.UserId == AbleContext.Current.UserId) || (product.IsKit))
{
AddProductPrice.Enabled = false;
}
}
}
protected void DoAdjustVariants()
{
IList <ProductOption> productOptions = ProductOptionDataSource.LoadForProduct(_ProductId);
List <Option> options = (from o in productOptions orderby o.OrderBy select o.Option).ToList <Option>();
IList <ProductVariant> variants = ProductVariantDataSource.LoadForProduct(_ProductId);
foreach (ProductVariant variant in variants)
{
Option o1 = FindOptionWithChoice(options, variant.Option1);
Option o2 = FindOptionWithChoice(options, variant.Option2);
Option o3 = FindOptionWithChoice(options, variant.Option3);
Option o4 = FindOptionWithChoice(options, variant.Option4);
Option o5 = FindOptionWithChoice(options, variant.Option5);
Option o6 = FindOptionWithChoice(options, variant.Option6);
Option o7 = FindOptionWithChoice(options, variant.Option7);
Option o8 = FindOptionWithChoice(options, variant.Option8);
Dictionary <int, int> map = new Dictionary <int, int>();
if (o1 != null)
{
map.Add(o1.Id, variant.Option1);
}
if (o2 != null)
{
map.Add(o2.Id, variant.Option2);
}
if (o3 != null)
{
map.Add(o3.Id, variant.Option3);
}
if (o4 != null)
{
map.Add(o4.Id, variant.Option4);
}
if (o5 != null)
{
map.Add(o5.Id, variant.Option5);
}
if (o6 != null)
{
map.Add(o6.Id, variant.Option6);
}
if (o7 != null)
{
map.Add(o7.Id, variant.Option7);
}
if (o8 != null)
{
map.Add(o8.Id, variant.Option8);
}
if (variant.Option1 > 0)
{
variant.Option1 = map[options[0].Id];
}
if (variant.Option2 > 0)
{
variant.Option2 = map[options[1].Id];
}
if (variant.Option3 > 0)
{
variant.Option3 = map[options[2].Id];
}
if (variant.Option4 > 0)
{
variant.Option4 = map[options[3].Id];
}
if (variant.Option5 > 0)
{
variant.Option5 = map[options[4].Id];
}
if (variant.Option6 > 0)
{
variant.Option6 = map[options[5].Id];
}
if (variant.Option7 > 0)
{
variant.Option7 = map[options[6].Id];
}
if (variant.Option8 > 0)
{
variant.Option8 = map[options[7].Id];
}
variant.Save();
}
}
protected BasketItem CreateBasketItem()
{
//GET THE PRODUCT ID
int productId = AlwaysConvert.ToInt(AddProductId.Value);
Product product = ProductDataSource.Load(productId);
if (product == null)
{
return(null);
}
//GET THE QUANTITY
short tempQuantity = AlwaysConvert.ToInt16(AddProductQuantity.Text);
if (tempQuantity < 1)
{
return(null);
}
//RECALCULATE SELECTED KIT OPTIONS
GetSelectedKitOptions(product);
// DETERMINE THE OPTION LIST
string optionList = ProductVariantDataSource.GetOptionList(productId, _SelectedOptions, false);
//CREATE THE BASKET ITEM WITH GIVEN OPTIONS
bool calculateOneTimePrice = AlwaysConvert.ToBool(OptionalSubscription.SelectedValue, false);
BasketItem basketItem = BasketItemDataSource.CreateForProduct(productId, tempQuantity, optionList, AlwaysConvert.ToList(",", _SelectedKitProducts), _UserId, calculateOneTimePrice);
if (basketItem != null)
{
//BASKET ID
basketItem.BasketId = _Basket.Id;
// PRODUCT PRICE FOR VARIABLE PRICE PRODUCT
if (product.UseVariablePrice && !product.IsSubscription && !product.IsKit)
{
basketItem.Price = AlwaysConvert.ToDecimal(AddProductVariablePrice.Text);
}
else
{
basketItem.Price = AlwaysConvert.ToDecimal(AddProductPrice.Text);
}
if (product.IsSubscription)
{
if (product.SubscriptionPlan.IsOptional)
{
basketItem.IsSubscription = !calculateOneTimePrice;
}
else
{
basketItem.IsSubscription = true;
}
if (basketItem.IsSubscription && product.SubscriptionPlan.IsRecurring)
{
basketItem.Frequency = product.SubscriptionPlan.PaymentFrequencyType == PaymentFrequencyType.Optional ? AlwaysConvert.ToInt16(AutoDeliveryInterval.SelectedValue) : product.SubscriptionPlan.PaymentFrequency;
basketItem.FrequencyUnit = product.SubscriptionPlan.PaymentFrequencyUnit;
}
else if (basketItem.IsSubscription)
{
basketItem.Frequency = product.SubscriptionPlan.PaymentFrequency;
basketItem.FrequencyUnit = product.SubscriptionPlan.PaymentFrequencyUnit;
}
}
// COLLECT ANY ADDITIONAL INPUTS
AbleCommerce.Code.ProductHelper.CollectProductTemplateInput(basketItem, this);
}
return(basketItem);
}
protected void Page_Load(object sender, EventArgs e)
{
if (Product != null)
{
string checkImage = this.ShowImage.ToLowerInvariant();
string calculatedImageUrl = string.Empty;
string imageAltText = string.Empty;
string optionList = Request.QueryString["Options"];
ProductVariant variant = null;
if (!string.IsNullOrEmpty(optionList))
{
variant = ProductVariantDataSource.LoadForOptionList(Product.Id, optionList);
}
if (checkImage == "icon")
{
if (variant != null && !string.IsNullOrEmpty(variant.IconUrl))
{
calculatedImageUrl = variant.IconUrl;
imageAltText = Product.IconAltText;
}
else if (!string.IsNullOrEmpty(Product.IconUrl))
{
calculatedImageUrl = Product.IconUrl;
imageAltText = Product.IconAltText;
}
else
{
NoIcon.Visible = true;
}
}
else if (checkImage == "thumbnail")
{
if (variant != null && !string.IsNullOrEmpty(variant.ThumbnailUrl))
{
calculatedImageUrl = variant.ThumbnailUrl;
imageAltText = Product.ThumbnailAltText;
}
else if (!string.IsNullOrEmpty(Product.ThumbnailUrl))
{
calculatedImageUrl = Product.ThumbnailUrl;
imageAltText = Product.ThumbnailAltText;
}
else
{
NoThumbnail.Visible = true;
}
}
else
{
if (variant != null && !string.IsNullOrEmpty(variant.ImageUrl))
{
calculatedImageUrl = variant.ImageUrl;
imageAltText = Product.ImageAltText;
}
else if (!string.IsNullOrEmpty(Product.ImageUrl))
{
calculatedImageUrl = Product.ImageUrl;
imageAltText = Product.ImageAltText;
}
else
{
NoImage.Visible = true;
}
}
if (!string.IsNullOrEmpty(calculatedImageUrl))
{
this.ProductImage.ImageUrl = string.Format("~/GetImage.ashx?Path={0}&maintainAspectRatio=true&maxHeight={1}&maxWidth={1}", Server.UrlEncode(calculatedImageUrl), 300);
this.ProductImage.AlternateText = Server.HtmlEncode(imageAltText);
}
else
{
this.ProductImage.Visible = false;
}
}
}
protected void FinishButton_Click(object sender, EventArgs e)
{
foreach (RepeaterItem ri in SelectedProductRepeater.Items)
{
HiddenField pid = (HiddenField)ri.FindControl("PID");
int productId = AlwaysConvert.ToInt(pid.Value);
Product product = ProductDataSource.Load(productId);
if (product == null)
{
return;
}
if (!AllProductOptionsSelected(product, ri))
{
return;
}
TextBox KitQuantity = (TextBox)ri.FindControl("KitQuantity");
short quantity = AlwaysConvert.ToInt16(KitQuantity.Text);
if (quantity > 0)
{
ProductVariant productVariant = null;
string optionList = string.Empty;
if (product.ProductOptions.Count > 0)
{
Dictionary <int, int> selectedOptions = GetSelectedOptions(ri.ItemIndex);
productVariant = ProductVariantDataSource.LoadForOptionList(productId, selectedOptions);
optionList = ProductVariantDataSource.GetOptionList(productId, selectedOptions, true);
}
TextBox NameFormat = (TextBox)ri.FindControl("NameFormat");
DropDownList PriceMode = (DropDownList)ri.FindControl("PriceMode");
TextBox Price = (TextBox)ri.FindControl("Price");
DropDownList WeightMode = (DropDownList)ri.FindControl("WeightMode");
TextBox Weight = (TextBox)ri.FindControl("Weight");
CheckBox IsSelected = (CheckBox)ri.FindControl("IsSelected");
KitProduct kitProduct = new KitProduct();
kitProduct.ProductId = productId;
kitProduct.KitComponent = _KitComponent;
if (productVariant != null)
{
kitProduct.OptionList = productVariant.OptionList;
}
kitProduct.Name = NameFormat.Text;
kitProduct.Quantity = quantity;
ProductCalculator pcalc = ProductCalculator.LoadForProduct(productId, 1, optionList, string.Empty);
kitProduct.PriceModeId = AlwaysConvert.ToByte(PriceMode.SelectedIndex);
if (kitProduct.PriceMode == InheritanceMode.Inherit)
{
kitProduct.Price = pcalc.Price;
}
else
{
kitProduct.Price = AlwaysConvert.ToDecimal(Price.Text);
}
kitProduct.WeightModeId = AlwaysConvert.ToByte(WeightMode.SelectedIndex);
if (kitProduct.WeightMode == InheritanceMode.Inherit)
{
kitProduct.Weight = pcalc.Weight;
}
else
{
kitProduct.Weight = AlwaysConvert.ToDecimal(Weight.Text);
}
kitProduct.IsSelected = IsSelected.Checked;
kitProduct.Save();
}
}
Response.Redirect(string.Format("EditKit.aspx?CategoryId={0}&ProductId={1}", _CategoryId, _ProductId));
}
/// <summary>
/// Prepare list of used images
/// Many be associated with products, as thumbnail, icon, or std. images
/// or as additional images
/// or to option swathces
/// </summary>
private void InitAssociatedImageUrls()
{
associatedImages = new List <string>();
// ADD PRODUCT IMAGES
ICriteria criteria = NHibernateHelper.CreateCriteria <Product>();
criteria.Add(Restrictions.Eq("Store", AbleContext.Current.Store));
criteria.Add(Restrictions.Disjunction()
.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("IconUrl", "~/Assets/ProductImages/%")));
IList <Product> products = ProductDataSource.LoadForCriteria(criteria);
foreach (Product product in products)
{
if (product.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(product.ImageUrl);
}
if (product.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(product.ThumbnailUrl);
}
if (product.IconUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(product.IconUrl);
}
}
// ADDITIONAL IMAGES
ICriteria imageCriteria = NHibernateHelper.CreateCriteria <ProductImage>();
imageCriteria.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"));
IList <ProductImage> images = ProductImageDataSource.LoadForCriteria(imageCriteria);
foreach (ProductImage image in images)
{
associatedImages.Add(image.ImageUrl);
}
// OPTION SWATCHES
ICriteria choicesCriteria = NHibernateHelper.CreateCriteria <OptionChoice>();
choicesCriteria.Add(Restrictions.Disjunction()
.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%")));
IList <OptionChoice> choices = OptionChoiceDataSource.LoadForCriteria(choicesCriteria);
foreach (OptionChoice choice in choices)
{
if (choice.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(choice.ImageUrl);
}
if (choice.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(choice.ThumbnailUrl);
}
}
// ADD CATEGORY IMAGES
ICriteria categoryCriteria = NHibernateHelper.CreateCriteria <Category>();
categoryCriteria.Add(Restrictions.Eq("Store", AbleContext.Current.Store));
categoryCriteria.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"));
IList <Category> categories = CategoryDataSource.LoadForCriteria(categoryCriteria);
foreach (Category category in categories)
{
if (category.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(category.ThumbnailUrl);
}
}
// ADD LINK IMAGES
ICriteria linksCriteria = NHibernateHelper.CreateCriteria <Link>();
linksCriteria.Add(Restrictions.Eq("Store", AbleContext.Current.Store));
linksCriteria.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"));
IList <Link> links = LinkDataSource.LoadForCriteria(linksCriteria);
foreach (Link link in links)
{
if (link.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(link.ThumbnailUrl);
}
}
// ADD GIFT WRAPING IMAGES
ICriteria wrapstylesCriteria = NHibernateHelper.CreateCriteria <WrapStyle>();
wrapstylesCriteria.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"));
IList <WrapStyle> wrapStyles = WrapStyleDataSource.LoadForCriteria(wrapstylesCriteria);
foreach (WrapStyle ws in wrapStyles)
{
if (ws.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(ws.ImageUrl);
}
if (ws.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(ws.ThumbnailUrl);
}
}
// ADD VARIANT IMAGES
ICriteria variantsCriteria = NHibernateHelper.CreateCriteria <ProductVariant>();
criteria.Add(Restrictions.Disjunction()
.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("IconUrl", "~/Assets/ProductImages/%")));
int variantsCount = ProductVariantDataSource.CountForCriteria(variantsCriteria.Clone() as ICriteria);
int maxVariantsToCache = 500;
// avoid loading all variants at same time
for (int index = 0; index < variantsCount; index += maxVariantsToCache)
{
variantsCriteria.SetMaxResults(maxVariantsToCache);
variantsCriteria.SetFirstResult(index);
IList <ProductVariant> productVariants = ProductVariantDataSource.LoadForCriteria(variantsCriteria);
foreach (ProductVariant productVariant in productVariants)
{
if (productVariant.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(productVariant.ImageUrl);
}
if (productVariant.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(productVariant.ThumbnailUrl);
}
if (productVariant.IconUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(productVariant.IconUrl);
}
}
}
}
){kind=link}
){kind=link}