/// <summary>
/// Get product variant attribute values
/// </summary>
/// <param name="Attributes">Attributes</param>
/// <returns>Product variant attribute values</returns>
public static ProductVariantAttributeValueCollection ParseProductVariantAttributeValues(string Attributes)
{
ProductVariantAttributeValueCollection pvaValues = new ProductVariantAttributeValueCollection();
ProductVariantAttributeCollection pvaCollection = ParseProductVariantAttributes(Attributes);
foreach (ProductVariantAttribute pva in pvaCollection)
{
if (!pva.ShouldHaveValues)
{
continue;
}
List <string> pvaValuesStr = ParseValues(Attributes, pva.ProductVariantAttributeID);
foreach (string pvaValueStr in pvaValuesStr)
{
if (!String.IsNullOrEmpty(pvaValueStr))
{
int pvaValueID = 0;
if (int.TryParse(pvaValueStr, out pvaValueID))
{
ProductVariantAttributeValue pvaValue = ProductAttributeManager.GetProductVariantAttributeValueByID(pvaValueID);
if (pvaValue != null)
{
pvaValues.Add(pvaValue);
}
}
}
}
}
return(pvaValues);
}
protected void BindAttributes()
{
ProductVariant productVariant = ProductManager.GetProductVariantById(this.ProductVariantId);
if (productVariant != null)
{
pnlData.Visible = true;
pnlMessage.Visible = false;
ProductVariantAttributeCollection productVariantAttributes = productVariant.ProductVariantAttributes;
if (productVariantAttributes.Count > 0)
{
gvProductVariantAttributes.Visible = true;
gvProductVariantAttributes.DataSource = productVariantAttributes;
gvProductVariantAttributes.DataBind();
}
else
{
gvProductVariantAttributes.Visible = false;
}
}
else
{
pnlData.Visible = false;
pnlMessage.Visible = true;
}
}
/// <summary>
/// Formats attributes
/// </summary>
/// <param name="productVariant">Product variant</param>
/// <param name="Attributes">Attributes</param>
/// <param name="customer">Customer</param>
/// <param name="Serapator">Serapator</param>
/// <param name="HTMLEncode">A value indicating whether to encode (HTML) values</param>
/// <returns>Attributes</returns>
public static string FormatAttributes(ProductVariant productVariant, string Attributes,
Customer customer, string Serapator, bool HTMLEncode)
{
StringBuilder result = new StringBuilder();
ProductVariantAttributeCollection pvaCollection = ParseProductVariantAttributes(Attributes);
foreach (ProductVariantAttribute pva in pvaCollection)
{
List <string> valuesStr = ParseValues(Attributes, pva.ProductVariantAttributeID);
foreach (string valueStr in valuesStr)
{
string pvaAttribute = string.Empty;
if (!pva.ShouldHaveValues)
{
pvaAttribute = string.Format("{0}: {1}", pva.ProductAttribute.Name, valueStr);
}
else
{
ProductVariantAttributeValue pvaValue = ProductAttributeManager.GetProductVariantAttributeValueByID(Convert.ToInt32(valueStr));
if (pvaValue != null)
{
pvaAttribute = string.Format("{0}: {1}", pva.ProductAttribute.Name, pvaValue.Name);
decimal priceAdjustmentBase = TaxManager.GetPrice(productVariant, pvaValue.PriceAdjustment, customer);
decimal priceAdjustment = CurrencyManager.ConvertCurrency(priceAdjustmentBase, CurrencyManager.PrimaryStoreCurrency, NopContext.Current.WorkingCurrency);
if (priceAdjustmentBase > 0)
{
string priceAdjustmentStr = PriceHelper.FormatPrice(priceAdjustment, false, false);
pvaAttribute += string.Format(" [+{0}]", priceAdjustmentStr);
}
}
}
if (!String.IsNullOrEmpty(pvaAttribute))
{
result.Append(Serapator);
if (HTMLEncode)
{
result.Append(HttpUtility.HtmlEncode(pvaAttribute));
}
else
{
result.Append(pvaAttribute);
}
}
}
}
return(result.ToString());
}
/// <summary>
/// Gets selected product variant attributes
/// </summary>
/// <param name="Attributes">Attributes</param>
/// <returns>Selected product variant attributes</returns>
public static ProductVariantAttributeCollection ParseProductVariantAttributes(string Attributes)
{
ProductVariantAttributeCollection pvaCollection = new ProductVariantAttributeCollection();
List <int> IDs = ParseProductVariantAttributeIDs(Attributes);
foreach (int id in IDs)
{
ProductVariantAttribute pva = ProductAttributeManager.GetProductVariantAttributeByID(id);
if (pva != null)
{
pvaCollection.Add(pva);
}
}
return(pvaCollection);
}
/// <summary>
/// Gets selected product variant attributes
/// </summary>
/// <param name="attributes">Attributes</param>
/// <returns>Selected product variant attributes</returns>
public static ProductVariantAttributeCollection ParseProductVariantAttributes(string attributes)
{
var pvaCollection = new ProductVariantAttributeCollection();
var Ids = ParseProductVariantAttributeIds(attributes);
foreach (int id in Ids)
{
var pva = ProductAttributeManager.GetProductVariantAttributeById(id);
if (pva != null)
{
pvaCollection.Add(pva);
}
}
return(pvaCollection);
}
private static ProductVariantAttributeCollection DBMapping(DBProductVariantAttributeCollection dbCollection)
{
if (dbCollection == null)
{
return(null);
}
ProductVariantAttributeCollection collection = new ProductVariantAttributeCollection();
foreach (DBProductVariantAttribute dbItem in dbCollection)
{
ProductVariantAttribute item = DBMapping(dbItem);
collection.Add(item);
}
return(collection);
}
private void BindData()
{
ProductVariant productVariant = ProductManager.GetProductVariantByID(this.ProductVariantID);
if (productVariant != null)
{
ProductVariantAttributeCollection productVariantAttributes = productVariant.ProductVariantAttributes;
if (productVariantAttributes.Count > 0)
{
gvProductVariantAttributes.Visible = true;
gvProductVariantAttributes.DataSource = productVariantAttributes;
gvProductVariantAttributes.DataBind();
}
else
{
gvProductVariantAttributes.Visible = false;
}
}
}
/// <summary>
/// Gets product variant attribute mappings by product identifier
/// </summary>
/// <param name="ProductVariantID">The product variant identifier</param>
/// <returns>Product variant attribute mapping collection</returns>
public static ProductVariantAttributeCollection GetProductVariantAttributesByProductVariantID(int ProductVariantID)
{
string key = string.Format(PRODUCTVARIANTATTRIBUTES_ALL_KEY, ProductVariantID);
object obj2 = NopCache.Get(key);
if (ProductAttributeManager.CacheEnabled && (obj2 != null))
{
return((ProductVariantAttributeCollection)obj2);
}
DBProductVariantAttributeCollection dbCollection = DBProviderManager <DBProductAttributeProvider> .Provider.GetProductVariantAttributesByProductVariantID(ProductVariantID);
ProductVariantAttributeCollection productVariantAttributes = DBMapping(dbCollection);
if (ProductAttributeManager.CacheEnabled)
{
NopCache.Max(key, productVariantAttributes);
}
return(productVariantAttributes);
}
protected void CreateAttributeControls()
{
ProductVariant productVariant = ProductManager.GetProductVariantByID(this.ProductVariantID);
if (productVariant != null)
{
ProductVariantAttributeCollection productVariantAttributes = productVariant.ProductVariantAttributes;
if (productVariantAttributes.Count > 0)
{
this.Visible = true;
foreach (ProductVariantAttribute attribute in productVariantAttributes)
{
Panel divAttribute = new Panel();
Label attributeTitle = new Label();
if (attribute.IsRequired)
{
attributeTitle.Text = "<span>*</span> ";
}
//text prompt
string textPrompt = string.Empty;
if (!string.IsNullOrEmpty(attribute.TextPrompt))
{
textPrompt = attribute.TextPrompt;
}
else
{
textPrompt += attribute.ProductAttribute.Name;
}
attributeTitle.Text += Server.HtmlEncode(textPrompt);
attributeTitle.Style.Add("font-weight", "bold");
//description
if (!string.IsNullOrEmpty(attribute.ProductAttribute.Description))
{
attributeTitle.Text += string.Format("<div>{0}</div>",
Server.HtmlEncode(
attribute.ProductAttribute.Description));
}
bool addBreak = true;
switch (attribute.AttributeControlType)
{
case AttributeControlTypeEnum.TextBox:
{
addBreak = false;
}
break;
default:
break;
}
if (addBreak)
{
attributeTitle.Text += "<br />";
}
else
{
attributeTitle.Text += " ";
}
divAttribute.Controls.Add(attributeTitle);
switch (attribute.AttributeControlType)
{
case AttributeControlTypeEnum.DropdownList:
{
DropDownList ddlAttributes = new DropDownList();
ddlAttributes.ID = attribute.ProductAttribute.Name;
if (!attribute.IsRequired)
{
ddlAttributes.Items.Add(new ListItem("---", "0"));
}
ProductVariantAttributeValueCollection pvaValues = attribute.ProductVariantAttributeValues;
foreach (ProductVariantAttributeValue pvaValue in pvaValues)
{
string pvaValueName = pvaValue.Name;
decimal priceAdjustmentBase = TaxManager.GetPrice(productVariant, pvaValue.PriceAdjustment);
decimal priceAdjustment = CurrencyManager.ConvertCurrency(priceAdjustmentBase, CurrencyManager.PrimaryStoreCurrency, NopContext.Current.WorkingCurrency);
if (priceAdjustmentBase > decimal.Zero)
{
pvaValueName += string.Format(" [+{0}]", PriceHelper.FormatPrice(priceAdjustment, false, false));
}
ListItem pvaValueItem = new ListItem(pvaValueName, pvaValue.ProductVariantAttributeValueID.ToString());
pvaValueItem.Selected = pvaValue.IsPreSelected;
ddlAttributes.Items.Add(pvaValueItem);
}
divAttribute.Controls.Add(ddlAttributes);
}
break;
case AttributeControlTypeEnum.RadioList:
{
RadioButtonList rblAttributes = new RadioButtonList();
rblAttributes.ID = attribute.ProductAttribute.Name;
ProductVariantAttributeValueCollection pvaValues = attribute.ProductVariantAttributeValues;
foreach (ProductVariantAttributeValue pvaValue in pvaValues)
{
string pvaValueName = pvaValue.Name;
decimal priceAdjustmentBase = TaxManager.GetPrice(productVariant, pvaValue.PriceAdjustment);
decimal priceAdjustment = CurrencyManager.ConvertCurrency(priceAdjustmentBase, CurrencyManager.PrimaryStoreCurrency, NopContext.Current.WorkingCurrency);
if (priceAdjustmentBase > decimal.Zero)
{
pvaValueName += string.Format(" [+{0}]", PriceHelper.FormatPrice(priceAdjustment, false, false));
}
ListItem pvaValueItem = new ListItem(Server.HtmlEncode(pvaValueName), pvaValue.ProductVariantAttributeValueID.ToString());
pvaValueItem.Selected = pvaValue.IsPreSelected;
rblAttributes.Items.Add(pvaValueItem);
}
divAttribute.Controls.Add(rblAttributes);
}
break;
case AttributeControlTypeEnum.Checkboxes:
{
CheckBoxList cblAttributes = new CheckBoxList();
cblAttributes.ID = attribute.ProductAttribute.Name;
ProductVariantAttributeValueCollection pvaValues = attribute.ProductVariantAttributeValues;
foreach (ProductVariantAttributeValue pvaValue in pvaValues)
{
string pvaValueName = pvaValue.Name;
decimal priceAdjustmentBase = TaxManager.GetPrice(productVariant, pvaValue.PriceAdjustment);
decimal priceAdjustment = CurrencyManager.ConvertCurrency(priceAdjustmentBase, CurrencyManager.PrimaryStoreCurrency, NopContext.Current.WorkingCurrency);
if (priceAdjustmentBase > decimal.Zero)
{
pvaValueName += string.Format(" [+{0}]", PriceHelper.FormatPrice(priceAdjustment, false, false));
}
ListItem pvaValueItem = new ListItem(Server.HtmlEncode(pvaValueName), pvaValue.ProductVariantAttributeValueID.ToString());
pvaValueItem.Selected = pvaValue.IsPreSelected;
cblAttributes.Items.Add(pvaValueItem);
}
divAttribute.Controls.Add(cblAttributes);
}
break;
case AttributeControlTypeEnum.TextBox:
{
TextBox txtAttribute = new TextBox();
txtAttribute.ID = attribute.ProductAttribute.Name;
divAttribute.Controls.Add(txtAttribute);
}
break;
default:
break;
}
phAttributes.Controls.Add(divAttribute);
}
}
else
{
this.Visible = false;
}
}
else
{
this.Visible = false;
}
}
/// <summary>
/// Add a product variant to shopping cart
/// </summary>
/// <param name="ShoppingCartType">Shopping cart type</param>
/// <param name="ProductVariantID">Product variant identifier</param>
/// <param name="SelectedAttributes">Selected attributes</param>
/// <param name="Quantity">Quantity</param>
/// <returns>Warnings</returns>
public static List <string> AddToCart(ShoppingCartTypeEnum ShoppingCartType, int ProductVariantID,
string SelectedAttributes, int Quantity)
{
List <string> warnings = new List <string>();
if (ShoppingCartType == ShoppingCartTypeEnum.Wishlist && !SettingManager.GetSettingValueBoolean("Common.EnableWishlist"))
{
return(warnings);
}
if (NopContext.Current.Session == null)
{
NopContext.Current.Session = NopContext.Current.GetSession(true);
}
Guid CustomerSessionGUID = NopContext.Current.Session.CustomerSessionGUID;
CustomerManager.ResetCheckoutData(NopContext.Current.Session.CustomerID, false);
ShoppingCart Cart = GetShoppingCartByCustomerSessionGUID(ShoppingCartType, CustomerSessionGUID);
ShoppingCartItem shoppingCartItem = null;
foreach (ShoppingCartItem _shoppingCartItem in Cart)
{
if (_shoppingCartItem.ProductVariantID == ProductVariantID)
{
if (ProductAttributeHelper.ParseProductVariantAttributeIDs(_shoppingCartItem.AttributesXML).Count == ProductAttributeHelper.ParseProductVariantAttributeIDs(SelectedAttributes).Count)
{
bool attributeEquals = true;
ProductVariantAttributeCollection pva1Collection = ProductAttributeHelper.ParseProductVariantAttributes(SelectedAttributes);
ProductVariantAttributeCollection pva2Collection = ProductAttributeHelper.ParseProductVariantAttributes(_shoppingCartItem.AttributesXML);
foreach (ProductVariantAttribute pva1 in pva1Collection)
{
foreach (ProductVariantAttribute pva2 in pva2Collection)
{
if (pva1.ProductVariantAttributeID == pva2.ProductVariantAttributeID)
{
List <string> pvaValues1Str = ProductAttributeHelper.ParseValues(SelectedAttributes, pva1.ProductVariantAttributeID);
List <string> pvaValues2Str = ProductAttributeHelper.ParseValues(_shoppingCartItem.AttributesXML, pva2.ProductVariantAttributeID);
if (pvaValues1Str.Count == pvaValues2Str.Count)
{
foreach (string str1 in pvaValues1Str)
{
bool hasAttribute = false;
foreach (string str2 in pvaValues2Str)
{
if (str1.Trim().ToLower() == str2.Trim().ToLower())
{
hasAttribute = true;
break;
}
}
if (!hasAttribute)
{
attributeEquals = false;
break;
}
}
}
else
{
attributeEquals = false;
break;
}
}
}
}
if (attributeEquals)
{
shoppingCartItem = _shoppingCartItem;
}
}
}
}
DateTime now = DateTime.Now;
if (shoppingCartItem != null)
{
int newQuantity = shoppingCartItem.Quantity + Quantity;
warnings.AddRange(GetShoppingCartItemWarnings(ShoppingCartType, ProductVariantID,
SelectedAttributes, newQuantity));
if (warnings.Count == 0)
{
UpdateShoppingCartItem(shoppingCartItem.ShoppingCartItemID, ShoppingCartType,
CustomerSessionGUID, ProductVariantID, SelectedAttributes, newQuantity, shoppingCartItem.CreatedOn, now);
}
}
else
{
warnings.AddRange(GetShoppingCartItemWarnings(ShoppingCartType, ProductVariantID,
SelectedAttributes, Quantity));
if (warnings.Count == 0)
{
InsertShoppingCartItem(ShoppingCartType, CustomerSessionGUID, ProductVariantID,
SelectedAttributes, Quantity, now, now);
}
}
return(warnings);
}
/// <summary>
/// Validates whether this shopping cart item is allowed
/// </summary>
/// <param name="ShoppingCartType">Shopping cart type</param>
/// <param name="ProductVariantID">Product variant identifier</param>
/// <param name="SelectedAttributes">Selected attributes</param>
/// <param name="Quantity">Quantity</param>
/// <returns>Warnings</returns>
public static List <string> GetShoppingCartItemWarnings(ShoppingCartTypeEnum ShoppingCartType,
int ProductVariantID, string SelectedAttributes, int Quantity)
{
List <string> warnings = new List <string>();
ProductVariant productVariant = ProductManager.GetProductVariantByID(ProductVariantID);
if (productVariant == null)
{
warnings.Add(string.Format("Product variant (ID={0}) can not be loaded", ProductVariantID));
return(warnings);
}
Product product = productVariant.Product;
if (product == null)
{
warnings.Add(string.Format("Product (ID={0}) can not be loaded", productVariant.ProductID));
return(warnings);
}
if (product.Deleted || productVariant.Deleted)
{
warnings.Add("Product is deleted");
return(warnings);
}
if (!product.Published || !productVariant.Published)
{
warnings.Add("Product is not published");
}
if (productVariant.DisableBuyButton)
{
warnings.Add("Buying is disabled");
}
if (Quantity < productVariant.OrderMinimumQuantity)
{
warnings.Add(string.Format(LocalizationManager.GetLocaleResourceString("ShoppingCart.MinimumQuantity"), productVariant.OrderMinimumQuantity));
}
if (Quantity > productVariant.OrderMaximumQuantity)
{
warnings.Add(string.Format(LocalizationManager.GetLocaleResourceString("ShoppingCart.MaximumQuantity"), productVariant.OrderMaximumQuantity));
}
if (productVariant.ManageInventory)
{
if (productVariant.StockQuantity < Quantity)
{
int maximumQuantityCanBeAdded = productVariant.StockQuantity;
warnings.Add(string.Format(LocalizationManager.GetLocaleResourceString("ShoppingCart.QuantityExceedsStock"), maximumQuantityCanBeAdded));
}
}
if (productVariant.AvailableStartDateTime.HasValue)
{
DateTime now = DateTimeHelper.ConvertToUtcTime(DateTime.Now);
if (productVariant.AvailableStartDateTime.Value.CompareTo(now) > 0)
{
warnings.Add("Product is not available");
}
}
else if (productVariant.AvailableEndDateTime.HasValue)
{
DateTime now = DateTimeHelper.ConvertToUtcTime(DateTime.Now);
if (productVariant.AvailableEndDateTime.Value.CompareTo(now) < 0)
{
warnings.Add("Product is not available");
}
}
//selected attributes
ProductVariantAttributeCollection pva1Collection = ProductAttributeHelper.ParseProductVariantAttributes(SelectedAttributes);
foreach (ProductVariantAttribute pva1 in pva1Collection)
{
ProductVariant pv1 = pva1.ProductVariant;
if (pv1 != null)
{
if (pv1.ProductVariantID != productVariant.ProductVariantID)
{
warnings.Add("Attribute error");
}
}
else
{
warnings.Add("Attribute error");
return(warnings);
}
}
//existing product attributes
ProductVariantAttributeCollection pva2Collection = productVariant.ProductVariantAttributes;
foreach (ProductVariantAttribute pva2 in pva2Collection)
{
if (pva2.IsRequired)
{
bool found = false;
//selected attributes
foreach (ProductVariantAttribute pva1 in pva1Collection)
{
if (pva1.ProductVariantAttributeID == pva2.ProductVariantAttributeID)
{
List <string> pvaValuesStr = ProductAttributeHelper.ParseValues(SelectedAttributes, pva1.ProductVariantAttributeID);
foreach (string str1 in pvaValuesStr)
{
if (!String.IsNullOrEmpty(str1.Trim()))
{
found = true;
break;
}
}
}
}
//if not found
if (!found)
{
if (!string.IsNullOrEmpty(pva2.TextPrompt))
{
warnings.Add(pva2.TextPrompt);
}
else
{
warnings.Add(string.Format(LocalizationManager.GetLocaleResourceString("ShoppingCart.SelectAttribute"), pva2.ProductAttribute.Name));
}
}
}
}
return(warnings);
}
