public ProductFactory(ProductAttributeCollection productAttributes,
CatalogInventoryCollection catalogInventories, ProductOptionCollection productOptions, ProductVariantCollection productVariantCollection)
{
_productVariantFactory = new ProductVariantFactory(productAttributes, catalogInventories);
_productOptionCollection = productOptions;
_productVariantCollection = productVariantCollection;
}
public void Can_Get_A_ProductVariant_From_GetVariantForPurchase_Method_Given_A_List_Of_Attributes()
{
//// Arrange
var att = new ProductAttribute("Choice1", "choice")
{
Key = Guid.NewGuid()
};
var attCollection = new ProductAttributeCollection();
attCollection.Add(att);
var expected = new ProductVariant(Guid.NewGuid(), attCollection, new CatalogInventoryCollection(), false, false,
"Variant", "variant", 5M);
_product.ProductOptions.Add(new ProductOption("Option1")
{
Key = Guid.NewGuid()
});
_product.ProductOptions.First(x => x.Name == "Option1").Choices.Add(att);
_product.ProductVariants.Add(expected);
//// Act
var variant = _product.GetProductVariantForPurchase(attCollection);
//// Assert
Assert.NotNull(variant);
Assert.AreEqual(expected.Key, variant.Key);
}
void BindGrid()
{
ProductAttributeCollection productAttributes = ProductAttributeManager.GetAllProductAttributes();
gvProductAttributes.DataSource = productAttributes;
gvProductAttributes.DataBind();
}
public void Can_Serialize_A_Product_To_Xml()
{
//// Arrange
var att = new ProductAttribute("Choice1", "choice")
{
Key = Guid.NewGuid()
};
var attCollection = new ProductAttributeCollection();
attCollection.Add(att);
var expected = new ProductVariant(Guid.NewGuid(), attCollection, new CatalogInventoryCollection(), false, false,
"Variant", "variant", 5M);
_product.ProductOptions.Add(new ProductOption("Option1")
{
Key = Guid.NewGuid()
});
_product.ProductOptions.First(x => x.Name == "Option1").Choices.Add(att);
_product.ProductVariants.Add(expected);
//// Act
var xml = _product.SerializeToXml();
Console.Write(xml.ToString());
//// Assert
Assert.NotNull(xml);
}
public void Can_Verify_ProductAttributeCollection_Equals_Returns_False_For_Different_Attributes_DifferentCount()
{
//// Arrange
var collection = new ProductAttributeCollection()
{
new ProductAttribute("Att1", "Sku1")
{
Key = Guid.NewGuid()
},
new ProductAttribute("Att2", "Sku2")
{
Key = Guid.NewGuid()
},
new ProductAttribute("Att3", "Sku3")
{
Key = Guid.NewGuid()
},
new ProductAttribute("Att4", "Sku4")
{
Key = Guid.NewGuid()
},
};
//// Act / Assert
Console.Write("Collections are equal: " + _productVariant.Attributes.Equals(collection));
Assert.IsFalse(_productVariant.Attributes.Equals(collection));
}
/// <summary>
/// Creates a <see cref="IProductVariant" /> of the <see cref="IProduct" /> passed defined by the collection of
/// <see cref="IProductAttribute" />
/// without saving it to the database
/// </summary>
/// <param name="product">The <see cref="IProduct" /></param>
/// <param name="variants">
/// Existing variants to check against
/// </param>
/// <param name="attributes">The <see cref="IProductVariant" /></param>
/// <returns>
/// Either a new <see cref="IProductVariant" /> or, if one already exists with associated attributes, the existing
/// <see cref="IProductVariant" />
/// </returns>
internal IProductVariant CreateProductVariant(IProduct product, List <IProductVariant> variants,
ProductAttributeCollection attributes)
{
var skuSeparator = MerchelloConfiguration.Current.DefaultSkuSeparator;
// verify the order of the attributes so that a sku can be constructed in the same order as the UI
var optionIds = product.ProductOptionsForAttributes(attributes).OrderBy(x => x.SortOrder).Select(x => x.Key)
.Distinct();
// the base sku
var sku = product.Sku;
var name = string.Format("{0} - ", product.Name);
foreach (var att in optionIds.Select(key => attributes.FirstOrDefault(x => x.OptionKey == key))
.Where(att => att != null))
{
name += att.Name + " ";
sku += skuSeparator + (string.IsNullOrEmpty(att.Sku)
? Regex.Replace(att.Name, "[^0-9a-zA-Z]+", string.Empty)
: att.Sku);
}
return(CreateProductVariant(product, variants, name, sku, product.Price, attributes));
}
public void Can_Retrieve_All_Variants_For_A_Product()
{
//// Arrange
var attributes1 = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg")
};
var attributes2 = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL")
};
_productVariantService.CreateProductVariantWithKey(_product, attributes1);
_productVariantService.CreateProductVariantWithKey(_product, attributes2);
Assert.IsTrue(_product.ProductVariants.Count == 2);
//// Act
var variants = _productVariantService.GetByProductKey(_product.Key);
//// Assert
Assert.IsTrue(variants.Any());
Assert.IsTrue(2 == variants.Count());
}
/// <summary>
/// Creates a <see cref="IProductVariant" /> of the <see cref="IProduct" /> passed defined by the collection of
/// <see cref="IProductAttribute" />
/// </summary>
/// <param name="product">The <see cref="IProduct" /></param>
/// <param name="name">The name of the product variant</param>
/// <param name="sku">The unique SKU of the product variant</param>
/// <param name="price">The price of the product variant</param>
/// <param name="attributes">The <see cref="IProductVariant" /></param>
/// <param name="raiseEvents">Optional boolean indicating whether or not to raise events</param>
/// <returns>
/// Either a new <see cref="IProductVariant" /> or, if one already exists with associated attributes, the existing
/// <see cref="IProductVariant" />
/// </returns>
public IProductVariant CreateProductVariantWithKey(IProduct product, string name, string sku, decimal price,
ProductAttributeCollection attributes, bool raiseEvents = true)
{
var productVariant = CreateProductVariant(product, GetByProductKey(product.Key).ToList(), name, sku, price,
attributes);
if (raiseEvents)
{
if (Creating.IsRaisedEventCancelled(new Events.NewEventArgs <IProductVariant>(productVariant), this))
{
((ProductVariant)productVariant).WasCancelled = true;
return(productVariant);
}
}
using (new WriteLock(Locker))
{
var uow = UowProvider.GetUnitOfWork();
using (var repository = RepositoryFactory.CreateProductVariantRepository(uow))
{
repository.AddOrUpdate(productVariant);
uow.Commit();
}
}
if (raiseEvents)
{
Created.RaiseEvent(new Events.NewEventArgs <IProductVariant>(productVariant), this);
}
product.ProductVariants.Add(productVariant);
return(productVariant);
}
/// <summary>
/// Creates a collection of <see cref="IProductVariant"/> that can be created based on unmapped product options.
/// </summary>
/// <param name="product">The <see cref="IProduct"/></param>
/// <returns>A collection of <see cref="IProductVariant"/></returns>
/// <remarks>
///
/// This is an expensive method due to the potential number of database calls and should probably
/// be refactored
///
/// </remarks>
public IEnumerable <IProductVariant> GetProductVariantsThatCanBeCreated(IProduct product)
{
var variants = new List <IProductVariant>();
if (!product.ProductOptions.Any())
{
return(variants);
}
var possibleCombinations = GetPossibleProductAttributeCombinations(product);
foreach (var combo in possibleCombinations)
{
var attributes = new ProductAttributeCollection();
foreach (var att in combo)
{
attributes.Add(att);
}
if (!ProductVariantWithAttributesExists(product, attributes))
{
variants.Add(CreateProductVariant(product, attributes));
}
}
return(variants);
}
/// <summary>
/// Compares the <see cref="ProductAttributeCollection"/> with other <see cref="IProductVariant"/>s of the <see cref="IProduct"/> pass
/// to determine if the a variant already exists with the attributes passed
/// </summary>
/// <param name="product">The <see cref="IProduct"/> to reference</param>
/// <param name="attributes"><see cref="ProductAttributeCollection"/> to compare</param>
/// <returns>True/false indicating whether or not a <see cref="IProductVariant"/> already exists with the <see cref="ProductAttributeCollection"/> passed</returns>
public bool ProductVariantWithAttributesExists(IProduct product, ProductAttributeCollection attributes)
{
using (var repository = _repositoryFactory.CreateProductVariantRepository(_uowProvider.GetUnitOfWork()))
{
return(repository.ProductVariantWithAttributesExists(product, attributes));
}
}
/// <summary>
/// Compares the <see cref="ProductAttributeCollection" /> with other <see cref="IProductVariant" />s of the
/// <see cref="IProduct" /> pass
/// to determine if the a variant already exists with the attributes passed
/// </summary>
/// <param name="product">The <see cref="IProduct" /> to reference</param>
/// <param name="variants">
/// Variants to check against
/// </param>
/// <param name="attributes"><see cref="ProductAttributeCollection" /> to compare</param>
/// <returns>
/// True/false indicating whether or not a <see cref="IProductVariant" /> already exists with the
/// <see cref="ProductAttributeCollection" /> passed
/// </returns>
private bool ProductVariantWithAttributesExists(IProduct product, List <IProductVariant> variants,
ProductAttributeCollection attributes)
{
using (var repository = RepositoryFactory.CreateProductVariantRepository(UowProvider.GetUnitOfWork()))
{
return(repository.ProductVariantWithAttributesExists(product, variants, attributes));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ProductVariantFactory"/> class.
/// </summary>
/// <param name="productAttributes">
/// The product attributes.
/// </param>
/// <param name="catalogInventories">
/// The catalog inventories.
/// </param>
/// <param name="detachedContentCollection">
/// The <see cref="DetachedContentCollection{IProductVariantDetachedContent}"/>
/// </param>
public ProductVariantFactory(ProductAttributeCollection productAttributes,
CatalogInventoryCollection catalogInventories,
DetachedContentCollection <IProductVariantDetachedContent> detachedContentCollection)
{
_productAttributeCollection = productAttributes;
_catalogInventories = catalogInventories;
_detachedContentCollection = detachedContentCollection;
}
/// <summary>
/// Compares the <see cref="ProductAttributeCollection"/> with other <see cref="IProductVariant"/>s of the <see cref="IProduct"/> pass
/// to determine if the a variant already exists with the attributes passed
/// </summary>
/// <param name="product">The <see cref="IProduct"/> to reference</param>
/// <param name="attributes"><see cref="ProductAttributeCollection"/> to compare</param>
/// <returns>True/false indicating whether or not a <see cref="IProductVariant"/> already exists with the <see cref="ProductAttributeCollection"/> passed</returns>
public bool ProductVariantWithAttributesExists(IProduct product, ProductAttributeCollection attributes)
{
var variants = GetByProductKey(product.Key).ToArray();
var keys = attributes.Select(x => x.Key);
return(variants.Any(x => x.Attributes.All(z => keys.Contains(z.Key))));
}
public void Can_Add_A_New_Product_To_The_Index()
{
PreTestDataWorker.DeleteAllProducts();
//// Arrange
var provider = (ProductIndexer)ExamineManager.Instance.IndexProviderCollection["MerchelloProductIndexer"];
provider.RebuildIndex();
var searcher = ExamineManager.Instance.SearchProviderCollection["MerchelloProductSearcher"];
var productVariantService = PreTestDataWorker.ProductVariantService;
//// Act
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
_productService.Save(product);
var attributes = new ProductAttributeCollection()
{
product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blue"),
product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL")
};
productVariantService.CreateProductVariantWithKey(product, attributes);
provider.AddProductToIndex(product);
//// Assert
var criteria = searcher.CreateSearchCriteria("productvariant", BooleanOperation.And);
criteria.Field("productKey", product.Key.ToString()).And().Field("master", "true");
ISearchResults results = searcher.Search(criteria);
Assert.IsTrue(results.Count() == 1);
var result = results.First();
Assert.NotNull(result.Fields["productOptions"]);
provider.RebuildIndex();
}
internal ProductVariant(Guid productKey, ProductAttributeCollection attributes, InventoryCollection inventory, bool template, string name, string sku, decimal price)
: base(name, sku, price)
{
Mandate.ParameterNotNull(attributes, "attributes");
Mandate.ParameterNotNull(inventory, "inventory");
_productKey = productKey;
_attibutes = attributes;
_template = template;
}
internal ProductVariant(Guid productKey, ProductAttributeCollection attributes, CatalogInventoryCollection catalogInventoryCollection, bool master, string name, string sku, decimal price)
: base(name, sku, price, catalogInventoryCollection)
{
Mandate.ParameterNotNull(attributes, "attributes");
Mandate.ParameterNotNull(catalogInventoryCollection, "warehouseInventory");
_productKey = productKey;
_attibutes = attributes;
_master = master;
}
protected void gvProductVariantAttributes_RowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
ProductVariantAttribute productVariantAttribute = (ProductVariantAttribute)e.Row.DataItem;
Button btnUpdate = e.Row.FindControl("btnUpdate") as Button;
if (btnUpdate != null)
{
btnUpdate.CommandArgument = e.Row.RowIndex.ToString();
}
DropDownList ddlProductAttribute = e.Row.FindControl("ddlProductAttribute") as DropDownList;
if (ddlProductAttribute != null)
{
ddlProductAttribute.Items.Clear();
ProductAttributeCollection productAttributes = ProductAttributeManager.GetAllProductAttributes();
foreach (ProductAttribute productAttribute in productAttributes)
{
ListItem item = new ListItem(productAttribute.Name,
productAttribute.ProductAttributeId.ToString());
ddlProductAttribute.Items.Add(item);
if (productAttribute.ProductAttributeId == productVariantAttribute.ProductAttributeId)
{
item.Selected = true;
}
}
}
DropDownList ddlAttributeControlType = e.Row.FindControl("ddlAttributeControlType") as DropDownList;
{
if (ddlAttributeControlType != null)
{
CommonHelper.FillDropDownWithEnum(ddlAttributeControlType, typeof(AttributeControlTypeEnum));
}
CommonHelper.SelectListItem(ddlAttributeControlType, productVariantAttribute.AttributeControlTypeId);
}
HyperLink hlAttributeValues = e.Row.FindControl("hlAttributeValues") as HyperLink;
if (hlAttributeValues != null)
{
if (productVariantAttribute.ShouldHaveValues)
{
hlAttributeValues.Visible = true;
hlAttributeValues.NavigateUrl = string.Format("{0}ProductVariantAttributeValues.aspx?ProductVariantAttributeID={1}",
CommonHelper.GetStoreAdminLocation(),
productVariantAttribute.ProductVariantAttributeId);
hlAttributeValues.Text = string.Format(GetLocaleResourceString("Admin.ProductVariantAttributes.Values.Count"), productVariantAttribute.ProductVariantAttributeValues.Count);
}
else
{
hlAttributeValues.Visible = false;
}
}
}
}
public void Init()
{
_attributes = new ProductAttributeCollection()
{
new ProductAttribute("Att1", "Sku1") { Key = Guid.NewGuid() },
new ProductAttribute("Att2", "Sku2") { Key = Guid.NewGuid() },
new ProductAttribute("Att3", "Sku3") { Key = Guid.NewGuid() }
};
_productVariant = new ProductVariant(Guid.NewGuid(), _attributes, new CatalogInventoryCollection(), false, "Product1", "P1", 11M);
}
/// <summary>
/// Converts an enumeration of ProductAttributes to a ProductAttributecollection
/// </summary>
/// <param name="attributes">
/// The attributes.
/// </param>
/// <returns>
/// The <see cref="ProductAttributeCollection"/>.
/// </returns>
internal static ProductAttributeCollection ToProductAttributeCollection(this IEnumerable <IProductAttribute> attributes)
{
var collection = new ProductAttributeCollection();
foreach (var att in attributes)
{
collection.Add(att);
}
return(collection);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProductFactory"/> class.
/// </summary>
/// <param name="getProductAttributes">
/// The product attributes.
/// </param>
/// <param name="getCatalogInventories">
/// The catalog inventories.
/// </param>
/// <param name="getProductOptions">
/// The product options.
/// </param>
/// <param name="getProductVariantCollection">
/// The product variant collection.
/// </param>
/// <param name="getDetachedContentCollection">
/// Gets the detached content collection
/// </param>
public ProductFactory(
ProductAttributeCollection getProductAttributes,
CatalogInventoryCollection getCatalogInventories,
Func <Guid, ProductOptionCollection> getProductOptions,
Func <Guid, ProductVariantCollection> getProductVariantCollection,
DetachedContentCollection <IProductVariantDetachedContent> getDetachedContentCollection)
{
_productVariantFactory = new ProductVariantFactory(getProductAttributes, getCatalogInventories, getDetachedContentCollection);
this._getProductOptionCollection = getProductOptions;
this._getProductVariantCollection = getProductVariantCollection;
}
/// <summary>
/// Compares the <see cref="ProductAttributeCollection"/> with other <see cref="IProductVariant"/>s of the <see cref="IProduct"/> pass
/// to determine if the a variant already exists with the attributes passed
/// </summary>
/// <param name="product">The <see cref="IProduct"/> to reference</param>
/// <param name="attributes"><see cref="ProductAttributeCollection"/> to compare</param>
/// <returns>True/false indicating whether or not a <see cref="IProductVariant"/> already exists with the <see cref="ProductAttributeCollection"/> passed</returns>
public bool ProductVariantWithAttributesExists(IProduct product, ProductAttributeCollection attributes)
{
var variants = GetByProductKey(product.Key).ToArray();
//// http://issues.merchello.com/youtrack/issue/M-941
var keys = attributes.Select(x => x.Key);
return(variants.Any(x => x.Attributes.All(z => keys.Contains(z.Key))));
//// return variants.Any(x => x.Attributes.Equals(attributes));
}
public void Can_Add_A_New_Product_To_The_Index()
{
PreTestDataWorker.DeleteAllProducts();
//// Arrange
var provider = (ProductIndexer) ExamineManager.Instance.IndexProviderCollection["MerchelloProductIndexer"];
provider.RebuildIndex();
var searcher = ExamineManager.Instance.SearchProviderCollection["MerchelloProductSearcher"];
var productVariantService = PreTestDataWorker.ProductVariantService;
//// Act
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
_productService.Save(product);
var attributes = new ProductAttributeCollection()
{
product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blue" ),
product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL")
};
productVariantService.CreateProductVariantWithKey(product, attributes);
provider.AddProductToIndex(product);
//// Assert
var criteria = searcher.CreateSearchCriteria("productvariant", BooleanOperation.And);
criteria.Field("productKey", product.Key.ToString()).And().Field("master", "true");
ISearchResults results = searcher.Search(criteria);
Assert.IsTrue(results.Count() == 1);
var result = results.First();
Assert.NotNull(result.Fields["productOptions"]);
provider.RebuildIndex();
}
internal ProductOption(string name, bool required, ProductAttributeCollection choices)
{
// This is required so that we can create attributes from the WebApi without a lot of
// round trip traffic to the db to generate the Key(s). Key is virtual so also forces
// this class to be sealed
Key = Guid.NewGuid();
HasIdentity = false;
_name = name;
_required = required;
_choices = choices;
}
private void FillDropDowns()
{
this.ddlNewProductAttributes.Items.Clear();
ProductAttributeCollection productAttributes = ProductAttributeManager.GetAllProductAttributes();
foreach (ProductAttribute pa in productAttributes)
{
ListItem item2 = new ListItem(pa.Name, pa.ProductAttributeId.ToString());
this.ddlNewProductAttributes.Items.Add(item2);
}
CommonHelper.FillDropDownWithEnum(this.ddlAttributeControlType, typeof(AttributeControlTypeEnum));
}
public void Init()
{
var warehouseService = PreTestDataWorker.WarehouseService;
_warehouse = warehouseService.GetDefaultWarehouse();
var productVariantService = PreTestDataWorker.ProductVariantService;
var productService = PreTestDataWorker.ProductService;
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
product.Manufacturer = "Nike";
product.ManufacturerModelNumber = "N01-012021-A";
product.TrackInventory = true;
productService.Save(product);
_productKey = product.Key;
var attributes = new ProductAttributeCollection()
{
product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blue"),
product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL")
};
var variant = productVariantService.CreateProductVariantWithKey(product, attributes);
variant.AddToCatalogInventory(_warehouse.DefaultCatalog());
productVariantService.Save(variant);
_productVariantKey = variant.Key;
_examineId = ((ProductVariant)variant).ExamineId;
var provider = (ProductIndexer)ExamineManager.Instance.IndexProviderCollection["MerchelloProductIndexer"];
provider.AddProductToIndex(product);
}
public void Can_Verify_ProductAttributeCollection_Equals_Returns_False_For_Different_Attributes_SameCount()
{
//// Arrange
var collection = new ProductAttributeCollection()
{
new ProductAttribute("Att1", "Sku1") { Key = Guid.NewGuid() },
new ProductAttribute("Att6", "Sku6") { Key = Guid.NewGuid() },
new ProductAttribute("Att3", "Sku3") { Key = Guid.NewGuid() }
};
//// Act / Assert
Console.Write("Collections are equal: " + _productVariant.Attributes.Equals(collection));
Assert.IsFalse(_productVariant.Attributes.Equals(collection));
}
public void Can_Not_Create_A_Duplicate_ProductVariant()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg")
};
//// Act
//// Assert
Assert.Throws <ArgumentException>(() => _productVariantService.CreateProductVariantWithKey(_product, attributes));
}
public void Can_Create_A_ProductVariant()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg")
};
//// Act
var variant = _productVariantService.CreateProductVariantWithKey(_product, attributes);
//// Assert
Assert.IsTrue(variant.HasIdentity);
}
public void Can_RetrieveProductOptions_From_ProductInIndex()
{
//// Arrange
var merchello = new MerchelloHelper(MerchelloContext.Services);
var productVariantService = PreTestDataWorker.ProductVariantService;
var productService = PreTestDataWorker.ProductService;
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
productService.Save(product);
var attributes = new ProductAttributeCollection()
{
product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blue"),
product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL")
};
productVariantService.CreateProductVariantWithKey(product, attributes);
_provider.AddProductToIndex(product);
//// Act
var productDisplay = merchello.Query.Product.GetByKey(product.Key);
//// Assert
Assert.NotNull(productDisplay);
Assert.IsTrue(productDisplay.ProductOptions.Any());
}
private static ProductAttributeCollection DBMapping(DBProductAttributeCollection dbCollection)
{
if (dbCollection == null)
{
return(null);
}
ProductAttributeCollection collection = new ProductAttributeCollection();
foreach (DBProductAttribute dbItem in dbCollection)
{
ProductAttribute item = DBMapping(dbItem);
collection.Add(item);
}
return(collection);
}
public ProductVariantDisplay NewProductVariant(ProductVariantDisplay productVariant)
{
IProductVariant newProductVariant;
try
{
var product = _productService.GetByKey(productVariant.ProductKey) as Product;
if (product != null)
{
var productAttributes = new ProductAttributeCollection();
foreach (var attribute in productVariant.Attributes)
{
// TODO: This should be refactored into an extension method
var productOption = product.ProductOptions.FirstOrDefault(x => x.Key == attribute.OptionKey) as ProductOption;
if (productOption != null)
{
productAttributes.Add(productOption.Choices[attribute.Key]);
}
}
newProductVariant = _productVariantService.CreateProductVariantWithKey(product, productAttributes);
if (productVariant.TrackInventory)
{
newProductVariant.AddToCatalogInventory(_warehouseService.GetDefaultWarehouse().DefaultCatalog());
}
newProductVariant = productVariant.ToProductVariant(newProductVariant);
_productVariantService.Save(newProductVariant);
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
catch (Exception e)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
return(newProductVariant.ToProductVariantDisplay());
}
/// <summary>
/// Creates a <see cref="IProductVariant" /> of the <see cref="IProduct" /> passed defined by the collection of
/// <see cref="IProductAttribute" />
/// without saving it to the database
/// </summary>
/// <param name="product">The <see cref="IProduct" /></param>
/// <param name="variants"></param>
/// <param name="name">The name of the product variant</param>
/// <param name="sku">The unique SKU of the product variant</param>
/// <param name="price">The price of the product variant</param>
/// <param name="attributes">The <see cref="ProductAttributeCollection" /></param>
/// <returns>
/// Either a new <see cref="IProductVariant" /> or, if one already exists with associated attributes, the existing
/// <see cref="IProductVariant" />
/// </returns>
internal IProductVariant CreateProductVariant(IProduct product, List <IProductVariant> variants, string name,
string sku, decimal price, ProductAttributeCollection attributes)
{
Mandate.ParameterNotNull(product, "product");
Mandate.ParameterNotNull(attributes, "attributes");
Mandate.ParameterCondition(attributes.Count >= product.ProductOptions.Count(x => x.Required),
"An attribute must be assigned for every required option");
//// http://issues.merchello.com/youtrack/issue/M-740
// verify there is not already a variant with these attributes
////Mandate.ParameterCondition(false == ProductVariantWithAttributesExists(product, attributes), "A ProductVariant already exists for the ProductAttributeCollection");
if (ProductVariantWithAttributesExists(product, variants, attributes))
{
LogHelper.Debug <ProductVariantService>(
"Attempt to create a new variant that already exists. Returning existing variant.");
return(GetProductVariantWithAttributes(product, variants, attributes.Select(x => x.Key).ToArray()));
}
var newVariant = new ProductVariant(product.Key, attributes, name, sku, price)
{
CostOfGoods = product.CostOfGoods,
SalePrice = product.SalePrice,
OnSale = product.OnSale,
Weight = product.Weight,
Length = product.Length,
Width = product.Width,
Height = product.Height,
Barcode = product.Barcode,
Available = product.Available,
Manufacturer = product.Manufacturer,
ManufacturerModelNumber = product.ManufacturerModelNumber,
TrackInventory = product.TrackInventory,
OutOfStockPurchase = product.OutOfStockPurchase,
Taxable = product.Taxable,
Shippable = product.Shippable,
Download = product.Download,
VersionKey = Guid.NewGuid()
};
// Update existing ones in memory for checks in next loop
variants.Add(newVariant);
return(newVariant);
}
public void Can_RetrieveProductOptions_From_ProductInIndex()
{
//// Arrange
var merchello = new MerchelloHelper();
var productVariantService = PreTestDataWorker.ProductVariantService;
var productService = PreTestDataWorker.ProductService;
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
productService.Save(product);
var attributes = new ProductAttributeCollection()
{
product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blue" ),
product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL")
};
productVariantService.CreateProductVariantWithKey(product, attributes);
_provider.AddProductToIndex(product);
//// Act
var productDisplay = merchello.Product(product.Key);
//// Assert
Assert.NotNull(productDisplay);
Assert.IsTrue(productDisplay.ProductOptions.Any());
}
public void Can_Map_ProductOption_To_ProductOptionDisplay()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
new ProductAttribute("One", "One"),
new ProductAttribute("Two", "Two"),
new ProductAttribute("Three", "Three"),
new ProductAttribute("Four", "Four")
};
var productOption = new ProductOption("Numbers", true, attributes);
//// Act
var productOptionDisplay = AutoMapper.Mapper.Map<ProductOptionDisplay>(productOption);
//// Assert
Assert.NotNull(productOptionDisplay);
}
public void Can_Get_A_ProductVariant_From_GetVariantForPurchase_Method_Given_A_List_Of_Attributes()
{
//// Arrange
var att = new ProductAttribute("Choice1", "choice") { Key = Guid.NewGuid() };
var attCollection = new ProductAttributeCollection();
attCollection.Add(att);
var expected = new ProductVariant(Guid.NewGuid(), attCollection, new CatalogInventoryCollection(), false,
"Variant", "variant", 5M);
_product.ProductOptions.Add(new ProductOption("Option1") { Key = Guid.NewGuid() });
_product.ProductOptions.First(x => x.Name == "Option1").Choices.Add(att);
_product.ProductVariants.Add(expected);
//// Act
var variant = _product.GetProductVariantForPurchase(attCollection);
//// Assert
Assert.NotNull(variant);
Assert.AreEqual(expected.Key, variant.Key);
}
public void Can_Map_ProductOption_To_ProductOptionDisplay()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
new ProductAttribute("One", "One"),
new ProductAttribute("Two", "Two"),
new ProductAttribute("Three", "Three"),
new ProductAttribute("Four", "Four")
};
var productOption = new ProductOption("Numbers", true, attributes);
//// Act
var productOptionDisplay = AutoMapper.Mapper.Map <ProductOptionDisplay>(productOption);
//// Assert
Assert.NotNull(productOptionDisplay);
}
public void Can_Retrieve_A_ProductVariant_Given_A_Product_And_A_Collection_Of_AttributeIds()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg")
};
Assert.IsTrue(_product.ProductVariants.Any());
//// Act
var attIds = attributes.Select(x => x.Key).ToArray();
var retrieved = _productVariantService.GetProductVariantWithAttributes(_product, attIds);
//// Assert
Assert.NotNull(retrieved);
}
/// <summary>
/// Creates a <see cref="IProductVariant"/> of the <see cref="IProduct"/> passed defined by the collection of <see cref="IProductAttribute"/>
/// </summary>
/// <param name="product">The <see cref="IProduct"/></param>
/// <param name="attributes">The <see cref="IProductVariant"/></param>
/// <param name="raiseEvents">Optional boolean indicating whether or not to raise events</param>
/// <returns>Either a new <see cref="IProductVariant"/> or, if one already exists with associated attributes, the existing <see cref="IProductVariant"/></returns>
public IProductVariant CreateProductVariantWithKey(IProduct product, ProductAttributeCollection attributes, bool raiseEvents = true)
{
var skuSeparator = MerchelloConfiguration.Current.DefaultSkuSeparator;
// verify the order of the attributes so that a sku can be constructed in the same order as the UI
var optionIds = product.ProductOptionsForAttributes(attributes).OrderBy(x => x.SortOrder).Select(x => x.Key).Distinct();
// the base sku
var sku = product.Sku;
var name = string.Format("{0} - ", product.Name);
foreach (var att in optionIds.Select(key => attributes.FirstOrDefault(x => x.OptionKey == key)).Where(att => att != null))
{
name += att.Name + " ";
sku += skuSeparator + (string.IsNullOrEmpty(att.Sku) ? Regex.Replace(att.Name, "[^0-9a-zA-Z]+", string.Empty) : att.Sku);
}
return CreateProductVariantWithKey(product, name.Trim(), sku, product.Price, attributes, raiseEvents);
}
private ProductAttributeCollection GetProductAttributeCollection(Guid optionKey)
{
var sql = new Sql();
sql.Select("*")
.From <ProductAttributeDto>()
.Where <ProductAttributeDto>(x => x.OptionKey == optionKey);
var dtos = Database.Fetch <ProductAttributeDto>(sql);
var attributes = new ProductAttributeCollection();
var factory = new ProductAttributeFactory();
foreach (var dto in dtos)
{
var attribute = factory.BuildEntity(dto);
attributes.Add(attribute);
}
return(attributes);
}
public void Init()
{
_attributes = new ProductAttributeCollection()
{
new ProductAttribute("Att1", "Sku1")
{
Key = Guid.NewGuid()
},
new ProductAttribute("Att2", "Sku2")
{
Key = Guid.NewGuid()
},
new ProductAttribute("Att3", "Sku3")
{
Key = Guid.NewGuid()
}
};
_productVariant = new ProductVariant(Guid.NewGuid(), _attributes, new CatalogInventoryCollection(), false, false, "Product1", "P1", 11M);
}
/// <summary>
/// Creates a <see cref="IProductVariant"/> of the <see cref="IProduct"/> passed defined by the collection of <see cref="IProductAttribute"/>
/// </summary>
/// <param name="product">The <see cref="IProduct"/></param>
/// <param name="name">The name of the product variant</param>
/// <param name="sku">The unique sku of the product variant</param>
/// <param name="price">The price of the product variant</param>
/// <param name="attributes">The <see cref="IProductVariant"/></param>
/// <param name="raiseEvents">Optional boolean indicating whether or not to raise events</param>
/// <returns>Either a new <see cref="IProductVariant"/> or, if one already exists with associated attributes, the existing <see cref="IProductVariant"/></returns>
public IProductVariant CreateProductVariantWithKey(IProduct product, string name, string sku, decimal price, ProductAttributeCollection attributes, bool raiseEvents = true)
{
var productVariant = CreateProductVariant(product, name, sku, price, attributes);
if(raiseEvents)
if (Creating.IsRaisedEventCancelled(new Events.NewEventArgs<IProductVariant>(productVariant), this))
{
((ProductVariant)productVariant).WasCancelled = true;
return productVariant;
}
using (new WriteLock(Locker))
{
var uow = _uowProvider.GetUnitOfWork();
using (var repository = _repositoryFactory.CreateProductVariantRepository(uow))
{
repository.AddOrUpdate(productVariant);
uow.Commit();
}
}
if (raiseEvents)
Created.RaiseEvent(new Events.NewEventArgs<IProductVariant>(productVariant), this);
product.ProductVariants.Add(productVariant);
return productVariant;
}
public ProductVariantDisplay NewProductVariant(ProductVariantDisplay productVariant)
{
IProductVariant newProductVariant;
try
{
var product = _productService.GetByKey(productVariant.ProductKey) as Product;
if (product != null)
{
var productAttributes = new ProductAttributeCollection();
foreach (var attribute in productVariant.Attributes)
{
// TODO: This should be refactored into an extension method
var productOption = product.ProductOptions.FirstOrDefault(x => x.Key == attribute.OptionKey) as ProductOption;
if (productOption != null) productAttributes.Add(productOption.Choices[attribute.Key]);
}
newProductVariant = _productVariantService.CreateProductVariantWithKey(product, productAttributes);
if (productVariant.TrackInventory)
{
newProductVariant.AddToCatalogInventory(_warehouseService.GetDefaultWarehouse().DefaultCatalog());
}
newProductVariant = productVariant.ToProductVariant(newProductVariant);
_productVariantService.Save(newProductVariant);
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
catch (Exception e)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
return newProductVariant.ToProductVariantDisplay();
}
public void Init()
{
var warehouseService = PreTestDataWorker.WarehouseService;
_warehouse = warehouseService.GetDefaultWarehouse();
var productVariantService = PreTestDataWorker.ProductVariantService;
var productService = PreTestDataWorker.ProductService;
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
product.Manufacturer = "Nike";
product.ManufacturerModelNumber = "N01-012021-A";
product.TrackInventory = true;
productService.Save(product);
_productKey = product.Key;
var attributes = new ProductAttributeCollection()
{
product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blue"),
product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL" )
};
var variant = productVariantService.CreateProductVariantWithKey(product, attributes);
variant.AddToCatalogInventory(_warehouse.DefaultCatalog());
productVariantService.Save(variant);
_productVariantKey = variant.Key;
_examineId = ((ProductVariant) variant).ExamineId;
var provider = (ProductIndexer)ExamineManager.Instance.IndexProviderCollection["MerchelloProductIndexer"];
provider.AddProductToIndex(product);
}
public void Can_Delete_A_Variant()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg" )
};
var variant = _productVariantService.CreateProductVariantWithKey(_product, attributes);
var key = variant.Key;
Assert.IsTrue(_product.ProductVariants.Any());
//// Act
_productVariantService.Delete(variant);
//// Assert
var retrieved = _productVariantService.GetByKey(key);
Assert.IsNull(retrieved);
}
public void Can_Retrieve_All_Variants_For_A_Product()
{
//// Arrange
var attributes1 = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg" )
};
var attributes2 = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL" )
};
_productVariantService.CreateProductVariantWithKey(_product, attributes1);
_productVariantService.CreateProductVariantWithKey(_product, attributes2);
Assert.IsTrue(_product.ProductVariants.Count == 2);
//// Act
var variants = _productVariantService.GetByProductKey(_product.Key);
//// Assert
Assert.IsTrue(variants.Any());
Assert.IsTrue(2 == variants.Count());
}
/// <summary>
/// Initializes a new instance of the <see cref="ProductVariant"/> class.
/// </summary>
/// <param name="productKey">
/// The product key.
/// </param>
/// <param name="attributes">
/// The attributes.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// <param name="sku">
/// The SKU.
/// </param>
/// <param name="price">
/// The price.
/// </param>
internal ProductVariant(
Guid productKey,
ProductAttributeCollection attributes,
string name,
string sku,
decimal price)
: this(productKey, attributes, new CatalogInventoryCollection(), false, name, sku, price)
{
}
/// <summary>
/// Creates a <see cref="IProductVariant"/> of the <see cref="IProduct"/> passed defined by the collection of <see cref="IProductAttribute"/>
/// without saving it to the database
/// </summary>
/// <param name="product">The <see cref="IProduct"/></param>
/// <param name="name">The name of the product variant</param>
/// <param name="sku">The unique SKU of the product variant</param>
/// <param name="price">The price of the product variant</param>
/// <param name="attributes">The <see cref="ProductAttributeCollection"/></param>
/// <returns>Either a new <see cref="IProductVariant"/> or, if one already exists with associated attributes, the existing <see cref="IProductVariant"/></returns>
internal IProductVariant CreateProductVariant(IProduct product, string name, string sku, decimal price, ProductAttributeCollection attributes)
{
Mandate.ParameterNotNull(product, "product");
Mandate.ParameterNotNull(attributes, "attributes");
Mandate.ParameterCondition(attributes.Count >= product.ProductOptions.Count(x => x.Required), "An attribute must be assigned for every required option");
//// http://issues.merchello.com/youtrack/issue/M-740
// verify there is not already a variant with these attributes
////Mandate.ParameterCondition(false == ProductVariantWithAttributesExists(product, attributes), "A ProductVariant already exists for the ProductAttributeCollection");
if (this.ProductVariantWithAttributesExists(product, attributes))
{
LogHelper.Debug<ProductVariantService>("Attempt to create a new variant that already exists. Returning existing variant.");
return this.GetProductVariantWithAttributes(product, attributes.Select(x => x.Key).ToArray());
}
return new ProductVariant(product.Key, attributes, name, sku, price)
{
CostOfGoods = product.CostOfGoods,
SalePrice = product.SalePrice,
OnSale = product.OnSale,
Weight = product.Weight,
Length = product.Length,
Width = product.Width,
Height = product.Height,
Barcode = product.Barcode,
Available = product.Available,
Manufacturer = product.Manufacturer,
ManufacturerModelNumber = product.ManufacturerModelNumber,
TrackInventory = product.TrackInventory,
OutOfStockPurchase = product.OutOfStockPurchase,
Taxable = product.Taxable,
Shippable = product.Shippable,
Download = product.Download
};
}
/// <summary>
/// Converts an enumeration of ProductAttributes to a ProductAttributecollection
/// </summary>
/// <param name="attributes">
/// The attributes.
/// </param>
/// <returns>
/// The <see cref="ProductAttributeCollection"/>.
/// </returns>
internal static ProductAttributeCollection ToProductAttributeCollection(this IEnumerable<IProductAttribute> attributes)
{
var collection = new ProductAttributeCollection();
foreach (var att in attributes)
{
collection.Add(att);
}
return collection;
}
public void Can_Verify_That_ProductVariant_Is_Deleted_When_An_Option_Is_Deleted()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg" )
};
_productVariantService.CreateProductVariantWithKey(_product, attributes);
Assert.IsTrue(_product.ProductVariants.Any());
//// Act
_product.ProductOptions.Remove(_product.ProductOptions.First(x => x.Name == "Size"));
_productService.Save(_product);
//// Assert
Assert.IsFalse(_product.ProductVariants.Any());
}
public void Can_Retrieve_A_ProductVariant_by_Its_Key()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg" )
};
var expected = _productVariantService.CreateProductVariantWithKey(_product, attributes);
var id = expected.Key;
Assert.AreNotEqual(id, Guid.Empty);
//// Act
var retrieved = _productVariantService.GetByKey(id);
//// Assert
Assert.NotNull(retrieved);
Assert.IsTrue(id == retrieved.Key);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProductVariant"/> class.
/// </summary>
/// <param name="productKey">
/// The product key.
/// </param>
/// <param name="attributes">
/// The attributes.
/// </param>
/// <param name="catalogInventoryCollection">
/// The catalog inventory collection.
/// </param>
/// <param name="detachedContents">
/// The detached contents.
/// </param>
/// <param name="master">
/// The master.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// <param name="sku">
/// The SKU.
/// </param>
/// <param name="price">
/// The price.
/// </param>
internal ProductVariant(Guid productKey, ProductAttributeCollection attributes, CatalogInventoryCollection catalogInventoryCollection, DetachedContentCollection<IProductVariantDetachedContent> detachedContents, bool master, string name, string sku, decimal price)
: base(name, sku, price, catalogInventoryCollection, detachedContents)
{
Ensure.ParameterNotNull(attributes, "attributes");
Ensure.ParameterNotNull(catalogInventoryCollection, "warehouseInventory");
_productKey = productKey;
_attibutes = attributes;
_master = master;
}
public void Can_Create_A_ProductVariant()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg" )
};
//// Act
var variant = _productVariantService.CreateProductVariantWithKey(_product, attributes);
//// Assert
Assert.IsTrue(variant.HasIdentity);
}
public void Can_Serialize_A_Product_To_Xml()
{
//// Arrange
var att = new ProductAttribute("Choice1", "choice") { Key = Guid.NewGuid() };
var attCollection = new ProductAttributeCollection();
attCollection.Add(att);
var expected = new ProductVariant(Guid.NewGuid(), attCollection, new CatalogInventoryCollection(), false,
"Variant", "variant", 5M);
_product.ProductOptions.Add(new ProductOption("Option1") { Key = Guid.NewGuid() });
_product.ProductOptions.First(x => x.Name == "Option1").Choices.Add(att);
_product.ProductVariants.Add(expected);
//// Act
var xml = _product.SerializeToXml();
Console.Write(xml.ToString());
//// Assert
Assert.NotNull(xml);
}
/// <summary>
/// Compares the <see cref="ProductAttributeCollection"/> with other <see cref="IProductVariant"/>s of the <see cref="IProduct"/> pass
/// to determine if the a variant already exists with the attributes passed
/// </summary>
/// <param name="product">The <see cref="IProduct"/> to reference</param>
/// <param name="attributes"><see cref="ProductAttributeCollection"/> to compare</param>
/// <returns>True/false indicating whether or not a <see cref="IProductVariant"/> already exists with the <see cref="ProductAttributeCollection"/> passed</returns>
public bool ProductVariantWithAttributesExists(IProduct product, ProductAttributeCollection attributes)
{
using (var repository = _repositoryFactory.CreateProductVariantRepository(_uowProvider.GetUnitOfWork()))
{
return repository.ProductVariantWithAttributesExists(product, attributes);
}
}
public void Can_Not_Create_A_Duplicate_ProductVariant()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg" )
};
//// Act
//// Assert
Assert.Throws<ArgumentException>(() => _productVariantService.CreateProductVariantWithKey(_product, attributes));
}
public void Can_Retrieve_A_ProductVariant_Given_A_Product_And_A_Collection_Of_AttributeIds()
{
//// Arrange
var attributes = new ProductAttributeCollection
{
_product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blk"),
_product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "Lg")
};
Assert.IsTrue(_product.ProductVariants.Any());
//// Act
var attIds = attributes.Select(x => x.Key).ToArray();
var retrieved = _productVariantService.GetProductVariantWithAttributes(_product, attIds);
//// Assert
Assert.NotNull(retrieved);
}
/// <summary>
/// Creates a collection of <see cref="IProductVariant"/> that can be created based on unmapped product options.
/// </summary>
/// <param name="product">The <see cref="IProduct"/></param>
/// <returns>A collection of <see cref="IProductVariant"/></returns>
/// <remarks>
///
/// This is an expensive method due to the potential number of database calls and should probably
/// be refactored
///
/// </remarks>
public IEnumerable<IProductVariant> GetProductVariantsThatCanBeCreated(IProduct product)
{
var variants = new List<IProductVariant>();
if (!product.ProductOptions.Any()) return variants;
var possibleCombinations = GetPossibleProductAttributeCombinations(product);
foreach (var combo in possibleCombinations)
{
var attributes = new ProductAttributeCollection();
foreach(var att in combo) attributes.Add(att);
if (!ProductVariantWithAttributesExists(product, attributes)) variants.Add(CreateProductVariant(product, attributes));
}
return variants;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProductVariant"/> class.
/// </summary>
/// <param name="productKey">
/// The product key.
/// </param>
/// <param name="attributes">
/// The attributes.
/// </param>
/// <param name="catalogInventoryCollection">
/// The catalog inventory collection.
/// </param>
/// <param name="master">
/// The master.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// <param name="sku">
/// The SKU.
/// </param>
/// <param name="price">
/// The price.
/// </param>
internal ProductVariant(Guid productKey, ProductAttributeCollection attributes, CatalogInventoryCollection catalogInventoryCollection, bool master, string name, string sku, decimal price)
: this(productKey, attributes, catalogInventoryCollection, new DetachedContentCollection<IProductVariantDetachedContent>(), false, name, sku, price)
{
}
/// <summary>
/// Creates a <see cref="IProductVariant"/> of the <see cref="IProduct"/> passed defined by the collection of <see cref="IProductAttribute"/>
/// without saving it to the database
/// </summary>
/// <param name="product"><see cref="IProduct"/></param>
/// <param name="name">The name of the product variant</param>
/// <param name="sku">The unique sku of the product variant</param>
/// <param name="price">The price of the product variant</param>
/// <param name="attributes"><see cref="IProductVariant"/></param>
/// <returns>Either a new <see cref="IProductVariant"/> or, if one already exists with associated attributes, the existing <see cref="IProductVariant"/></returns>
internal IProductVariant CreateProductVariant(IProduct product, string name, string sku, decimal price, ProductAttributeCollection attributes)
{
Mandate.ParameterNotNull(product, "product");
Mandate.ParameterNotNull(attributes, "attributes");
Mandate.ParameterCondition(attributes.Count >= product.ProductOptions.Count(x => x.Required), "An attribute must be assigned for every required option");
// verify there is not already a variant with these attributes
Mandate.ParameterCondition(false == ProductVariantWithAttributesExists(product, attributes), "A ProductVariant already exists for the ProductAttributeCollection");
return new ProductVariant(product.Key, attributes, name, sku, price)
{
CostOfGoods = product.CostOfGoods,
SalePrice = product.SalePrice,
OnSale = product.OnSale,
Weight = product.Weight,
Length = product.Length,
Width = product.Width,
Height = product.Height,
Barcode = product.Barcode,
Available = product.Available,
TrackInventory = product.TrackInventory,
OutOfStockPurchase = product.OutOfStockPurchase,
Taxable = product.Taxable,
Shippable = product.Shippable,
Download = product.Download
};
}
public ProductVariant(Guid productKey, ProductAttributeCollection attributes, InventoryCollection inventory, string name, string sku, decimal price)
: this(productKey, attributes, inventory, false, name, sku, price)
{
}
