public void Can_save_and_load_productAttributeMapping()
{
var productAttributeMapping = new ProductAttributeMapping
{
TextPrompt = "TextPrompt 1",
IsRequired = true,
AttributeControlType = AttributeControlType.DropdownList,
DisplayOrder = 1,
ValidationMinLength = 2,
ValidationMaxLength = 3,
ValidationFileAllowedExtensions = "ValidationFileAllowedExtensions 1",
ValidationFileMaximumSize = 4,
DefaultValue = "DefaultValue 1",
ConditionAttributeXml = "ConditionAttributeXml 1",
Product = GetTestProduct(),
ProductAttribute = new ProductAttribute
{
Name = "Name 1",
Description = "Description 1",
}
};
var fromDb = SaveAndLoadEntity(productAttributeMapping);
fromDb.ShouldNotBeNull();
fromDb.TextPrompt.ShouldEqual("TextPrompt 1");
fromDb.IsRequired.ShouldEqual(true);
fromDb.AttributeControlType.ShouldEqual(AttributeControlType.DropdownList);
fromDb.DisplayOrder.ShouldEqual(1);
fromDb.ValidationMinLength.ShouldEqual(2);
fromDb.ValidationMaxLength.ShouldEqual(3);
fromDb.ValidationFileAllowedExtensions.ShouldEqual("ValidationFileAllowedExtensions 1");
fromDb.ValidationFileMaximumSize.ShouldEqual(4);
fromDb.DefaultValue.ShouldEqual("DefaultValue 1");
fromDb.ConditionAttributeXml.ShouldEqual("ConditionAttributeXml 1");
fromDb.Product.ShouldNotBeNull();
fromDb.ProductAttribute.ShouldNotBeNull();
fromDb.ProductAttribute.Name.ShouldEqual("Name 1");
}
/// <summary>
/// Updates the product attribute mapping
/// </summary>
/// <param name="productAttributeMapping">The product attribute mapping</param>
public virtual void UpdateProductAttributeMapping(ProductAttributeMapping productAttributeMapping)
{
if (productAttributeMapping == null)
throw new ArgumentNullException("productAttributeMapping");
_productAttributeMappingRepository.Update(productAttributeMapping);
//cache
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTEMAPPINGS_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTEVALUES_PATTERN_KEY);
_cacheManager.RemoveByPattern(PRODUCTATTRIBUTECOMBINATIONS_PATTERN_KEY);
//event notification
_eventPublisher.EntityUpdated(productAttributeMapping);
}
public ActionResult ProductAttributeMappingInsert(ProductModel.ProductAttributeMappingModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageProducts))
return AccessDeniedView();
var product = _productService.GetProductById(model.ProductId);
if (product == null)
throw new ArgumentException("No product found with the specified id");
//a vendor should have access only to his products
if (_workContext.CurrentVendor != null && product.VendorId != _workContext.CurrentVendor.Id)
{
return Content("This is not your product");
}
//insert mapping
var productAttributeMapping = new ProductAttributeMapping
{
ProductId = model.ProductId,
ProductAttributeId = model.ProductAttributeId,
TextPrompt = model.TextPrompt,
IsRequired = model.IsRequired,
AttributeControlTypeId = model.AttributeControlTypeId,
DisplayOrder = model.DisplayOrder
};
_productAttributeService.InsertProductAttributeMapping(productAttributeMapping);
//predefined values
var predefinedValues = _productAttributeService.GetPredefinedProductAttributeValues(model.ProductAttributeId);
foreach (var predefinedValue in predefinedValues)
{
var pav = new ProductAttributeValue
{
ProductAttributeMappingId = productAttributeMapping.Id,
AttributeValueType = AttributeValueType.Simple,
Name = predefinedValue.Name,
PriceAdjustment = predefinedValue.PriceAdjustment,
WeightAdjustment = predefinedValue.WeightAdjustment,
Cost = predefinedValue.Cost,
IsPreSelected = predefinedValue.IsPreSelected,
DisplayOrder = predefinedValue.DisplayOrder
};
_productAttributeService.InsertProductAttributeValue(pav);
//locales
var languages = _languageService.GetAllLanguages(true);
//localization
foreach (var lang in languages)
{
var name = predefinedValue.GetLocalized(x => x.Name, lang.Id, false, false);
if (!String.IsNullOrEmpty(name))
_localizedEntityService.SaveLocalizedValue(pav, x => x.Name, name, lang.Id);
}
}
return new NullJsonResult();
}
/// <summary>
/// Updates the product attribute mapping
/// </summary>
/// <param name="productAttributeMapping">The product attribute mapping</param>
public virtual void UpdateProductAttributeMapping(ProductAttributeMapping productAttributeMapping)
{
if (productAttributeMapping == null)
throw new ArgumentNullException("productAttributeMapping");
//_productAttributeMappingRepository.Update(productAttributeMapping);
var builder = Builders<Product>.Filter;
var filter = builder.Eq(x => x.Id, productAttributeMapping.ProductId);
filter = filter & builder.ElemMatch(x => x.ProductAttributeMappings, y => y.Id == productAttributeMapping.Id);
var update = Builders<Product>.Update
.Set(x => x.ProductAttributeMappings.ElementAt(-1).ProductAttributeId, productAttributeMapping.ProductAttributeId)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).TextPrompt, productAttributeMapping.TextPrompt)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).IsRequired, productAttributeMapping.IsRequired)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).AttributeControlTypeId, productAttributeMapping.AttributeControlTypeId)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).DisplayOrder, productAttributeMapping.DisplayOrder)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).ValidationMinLength, productAttributeMapping.ValidationMinLength)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).ValidationMaxLength, productAttributeMapping.ValidationMaxLength)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).ValidationFileAllowedExtensions, productAttributeMapping.ValidationFileAllowedExtensions)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).ValidationFileMaximumSize, productAttributeMapping.ValidationFileMaximumSize)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).DefaultValue, productAttributeMapping.DefaultValue)
.Set(x => x.ProductAttributeMappings.ElementAt(-1).ConditionAttributeXml, productAttributeMapping.ConditionAttributeXml);
var result = _productRepository.Collection.UpdateManyAsync(filter, update).Result;
//cache
_cacheManager.RemoveByPattern(string.Format(PRODUCTS_BY_ID_KEY, productAttributeMapping.ProductId));
//event notification
_eventPublisher.EntityUpdated(productAttributeMapping);
}
/// <summary>
/// Inserts a product attribute mapping
/// </summary>
/// <param name="productAttributeMapping">The product attribute mapping</param>
public virtual void InsertProductAttributeMapping(ProductAttributeMapping productAttributeMapping)
{
if (productAttributeMapping == null)
throw new ArgumentNullException("productAttributeMapping");
//_productAttributeMappingRepository.Insert(productAttributeMapping);
var updatebuilder = Builders<Product>.Update;
var update = updatebuilder.AddToSet(p => p.ProductAttributeMappings, productAttributeMapping);
_productRepository.Collection.UpdateOneAsync(new BsonDocument("Id", productAttributeMapping.ProductId), update);
//cache
_cacheManager.RemoveByPattern(string.Format(PRODUCTS_BY_ID_KEY, productAttributeMapping.ProductId));
//event notification
_eventPublisher.EntityInserted(productAttributeMapping);
}
/// <summary>
/// Create a copy of product with all depended data
/// </summary>
/// <param name="product">The product to copy</param>
/// <param name="newName">The name of product duplicate</param>
/// <param name="isPublished">A value indicating whether the product duplicate should be published</param>
/// <param name="copyImages">A value indicating whether the product images should be copied</param>
/// <param name="copyAssociatedProducts">A value indicating whether the copy associated products</param>
/// <returns>Product copy</returns>
public virtual Product CopyProduct(Product product, string newName,
bool isPublished = true, bool copyImages = true, bool copyAssociatedProducts = true)
{
if (product == null)
throw new ArgumentNullException("product");
if (String.IsNullOrEmpty(newName))
throw new ArgumentException("Product name is required");
//product download & sample download
int downloadId = product.DownloadId;
int sampleDownloadId = product.SampleDownloadId;
if (product.IsDownload)
{
var download = _downloadService.GetDownloadById(product.DownloadId);
if (download != null)
{
var downloadCopy = new Download
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = download.UseDownloadUrl,
DownloadUrl = download.DownloadUrl,
DownloadBinary = download.DownloadBinary,
ContentType = download.ContentType,
Filename = download.Filename,
Extension = download.Extension,
IsNew = download.IsNew,
};
_downloadService.InsertDownload(downloadCopy);
downloadId = downloadCopy.Id;
}
if (product.HasSampleDownload)
{
var sampleDownload = _downloadService.GetDownloadById(product.SampleDownloadId);
if (sampleDownload != null)
{
var sampleDownloadCopy = new Download
{
DownloadGuid = Guid.NewGuid(),
UseDownloadUrl = sampleDownload.UseDownloadUrl,
DownloadUrl = sampleDownload.DownloadUrl,
DownloadBinary = sampleDownload.DownloadBinary,
ContentType = sampleDownload.ContentType,
Filename = sampleDownload.Filename,
Extension = sampleDownload.Extension,
IsNew = sampleDownload.IsNew
};
_downloadService.InsertDownload(sampleDownloadCopy);
sampleDownloadId = sampleDownloadCopy.Id;
}
}
}
// product
var productCopy = new Product
{
ProductTypeId = product.ProductTypeId,
ParentGroupedProductId = product.ParentGroupedProductId,
VisibleIndividually = product.VisibleIndividually,
Name = newName,
ShortDescription = product.ShortDescription,
FullDescription = product.FullDescription,
VendorId = product.VendorId,
ProductTemplateId = product.ProductTemplateId,
AdminComment = product.AdminComment,
ShowOnHomePage = product.ShowOnHomePage,
MetaKeywords = product.MetaKeywords,
MetaDescription = product.MetaDescription,
MetaTitle = product.MetaTitle,
AllowCustomerReviews = product.AllowCustomerReviews,
LimitedToStores = product.LimitedToStores,
Sku = product.Sku,
ManufacturerPartNumber = product.ManufacturerPartNumber,
Gtin = product.Gtin,
IsGiftCard = product.IsGiftCard,
GiftCardType = product.GiftCardType,
RequireOtherProducts = product.RequireOtherProducts,
RequiredProductIds = product.RequiredProductIds,
AutomaticallyAddRequiredProducts = product.AutomaticallyAddRequiredProducts,
IsDownload = product.IsDownload,
DownloadId = downloadId,
UnlimitedDownloads = product.UnlimitedDownloads,
MaxNumberOfDownloads = product.MaxNumberOfDownloads,
DownloadExpirationDays = product.DownloadExpirationDays,
DownloadActivationType = product.DownloadActivationType,
HasSampleDownload = product.HasSampleDownload,
SampleDownloadId = sampleDownloadId,
HasUserAgreement = product.HasUserAgreement,
UserAgreementText = product.UserAgreementText,
IsRecurring = product.IsRecurring,
RecurringCycleLength = product.RecurringCycleLength,
RecurringCyclePeriod = product.RecurringCyclePeriod,
RecurringTotalCycles = product.RecurringTotalCycles,
IsRental = product.IsRental,
RentalPriceLength = product.RentalPriceLength,
RentalPricePeriod = product.RentalPricePeriod,
IsShipEnabled = product.IsShipEnabled,
IsFreeShipping = product.IsFreeShipping,
ShipSeparately = product.ShipSeparately,
AdditionalShippingCharge = product.AdditionalShippingCharge,
DeliveryDateId = product.DeliveryDateId,
IsTaxExempt = product.IsTaxExempt,
TaxCategoryId = product.TaxCategoryId,
IsTelecommunicationsOrBroadcastingOrElectronicServices = product.IsTelecommunicationsOrBroadcastingOrElectronicServices,
ManageInventoryMethod = product.ManageInventoryMethod,
UseMultipleWarehouses = product.UseMultipleWarehouses,
WarehouseId = product.WarehouseId,
StockQuantity = product.StockQuantity,
DisplayStockAvailability = product.DisplayStockAvailability,
DisplayStockQuantity = product.DisplayStockQuantity,
MinStockQuantity = product.MinStockQuantity,
LowStockActivityId = product.LowStockActivityId,
NotifyAdminForQuantityBelow = product.NotifyAdminForQuantityBelow,
BackorderMode = product.BackorderMode,
AllowBackInStockSubscriptions = product.AllowBackInStockSubscriptions,
OrderMinimumQuantity = product.OrderMinimumQuantity,
OrderMaximumQuantity = product.OrderMaximumQuantity,
AllowedQuantities = product.AllowedQuantities,
AllowAddingOnlyExistingAttributeCombinations = product.AllowAddingOnlyExistingAttributeCombinations,
DisableBuyButton = product.DisableBuyButton,
DisableWishlistButton = product.DisableWishlistButton,
AvailableForPreOrder = product.AvailableForPreOrder,
PreOrderAvailabilityStartDateTimeUtc = product.PreOrderAvailabilityStartDateTimeUtc,
CallForPrice = product.CallForPrice,
Price = product.Price,
OldPrice = product.OldPrice,
ProductCost = product.ProductCost,
SpecialPrice = product.SpecialPrice,
SpecialPriceStartDateTimeUtc = product.SpecialPriceStartDateTimeUtc,
SpecialPriceEndDateTimeUtc = product.SpecialPriceEndDateTimeUtc,
CustomerEntersPrice = product.CustomerEntersPrice,
MinimumCustomerEnteredPrice = product.MinimumCustomerEnteredPrice,
MaximumCustomerEnteredPrice = product.MaximumCustomerEnteredPrice,
BasepriceEnabled = product.BasepriceEnabled,
BasepriceAmount = product.BasepriceAmount,
BasepriceUnitId = product.BasepriceUnitId,
BasepriceBaseAmount = product.BasepriceBaseAmount,
BasepriceBaseUnitId = product.BasepriceBaseUnitId,
Weight = product.Weight,
Length = product.Length,
Width = product.Width,
Height = product.Height,
AvailableStartDateTimeUtc = product.AvailableStartDateTimeUtc,
AvailableEndDateTimeUtc = product.AvailableEndDateTimeUtc,
DisplayOrder = product.DisplayOrder,
Published = isPublished,
Deleted = product.Deleted,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow
};
//validate search engine name
_productService.InsertProduct(productCopy);
//search engine name
_urlRecordService.SaveSlug(productCopy, productCopy.ValidateSeName("", productCopy.Name, true), 0);
var languages = _languageService.GetAllLanguages(true);
//localization
foreach (var lang in languages)
{
var name = product.GetLocalized(x => x.Name, lang.Id, false, false);
if (!String.IsNullOrEmpty(name))
_localizedEntityService.SaveLocalizedValue(productCopy, x => x.Name, name, lang.Id);
var shortDescription = product.GetLocalized(x => x.ShortDescription, lang.Id, false, false);
if (!String.IsNullOrEmpty(shortDescription))
_localizedEntityService.SaveLocalizedValue(productCopy, x => x.ShortDescription, shortDescription, lang.Id);
var fullDescription = product.GetLocalized(x => x.FullDescription, lang.Id, false, false);
if (!String.IsNullOrEmpty(fullDescription))
_localizedEntityService.SaveLocalizedValue(productCopy, x => x.FullDescription, fullDescription, lang.Id);
var metaKeywords = product.GetLocalized(x => x.MetaKeywords, lang.Id, false, false);
if (!String.IsNullOrEmpty(metaKeywords))
_localizedEntityService.SaveLocalizedValue(productCopy, x => x.MetaKeywords, metaKeywords, lang.Id);
var metaDescription = product.GetLocalized(x => x.MetaDescription, lang.Id, false, false);
if (!String.IsNullOrEmpty(metaDescription))
_localizedEntityService.SaveLocalizedValue(productCopy, x => x.MetaDescription, metaDescription, lang.Id);
var metaTitle = product.GetLocalized(x => x.MetaTitle, lang.Id, false, false);
if (!String.IsNullOrEmpty(metaTitle))
_localizedEntityService.SaveLocalizedValue(productCopy, x => x.MetaTitle, metaTitle, lang.Id);
//search engine name
_urlRecordService.SaveSlug(productCopy, productCopy.ValidateSeName("", name, false), lang.Id);
}
//product tags
foreach (var productTag in product.ProductTags)
{
productCopy.ProductTags.Add(productTag);
}
_productService.UpdateProduct(productCopy);
//product pictures
//variable to store original and new picture identifiers
var originalNewPictureIdentifiers = new Dictionary<int, int>();
if (copyImages)
{
foreach (var productPicture in product.ProductPictures)
{
var picture = productPicture.Picture;
var pictureCopy = _pictureService.InsertPicture(
_pictureService.LoadPictureBinary(picture),
picture.MimeType,
_pictureService.GetPictureSeName(newName),
picture.AltAttribute,
picture.TitleAttribute);
_productService.InsertProductPicture(new ProductPicture
{
ProductId = productCopy.Id,
PictureId = pictureCopy.Id,
DisplayOrder = productPicture.DisplayOrder
});
originalNewPictureIdentifiers.Add(picture.Id, pictureCopy.Id);
}
}
// product <-> warehouses mappings
foreach (var pwi in product.ProductWarehouseInventory)
{
var pwiCopy = new ProductWarehouseInventory
{
ProductId = productCopy.Id,
WarehouseId = pwi.WarehouseId,
StockQuantity = pwi.StockQuantity,
ReservedQuantity = 0,
};
productCopy.ProductWarehouseInventory.Add(pwiCopy);
}
_productService.UpdateProduct(productCopy);
// product <-> categories mappings
foreach (var productCategory in product.ProductCategories)
{
var productCategoryCopy = new ProductCategory
{
ProductId = productCopy.Id,
CategoryId = productCategory.CategoryId,
IsFeaturedProduct = productCategory.IsFeaturedProduct,
DisplayOrder = productCategory.DisplayOrder
};
_categoryService.InsertProductCategory(productCategoryCopy);
}
// product <-> manufacturers mappings
foreach (var productManufacturers in product.ProductManufacturers)
{
var productManufacturerCopy = new ProductManufacturer
{
ProductId = productCopy.Id,
ManufacturerId = productManufacturers.ManufacturerId,
IsFeaturedProduct = productManufacturers.IsFeaturedProduct,
DisplayOrder = productManufacturers.DisplayOrder
};
_manufacturerService.InsertProductManufacturer(productManufacturerCopy);
}
// product <-> releated products mappings
foreach (var relatedProduct in _productService.GetRelatedProductsByProductId1(product.Id, true))
{
_productService.InsertRelatedProduct(
new RelatedProduct
{
ProductId1 = productCopy.Id,
ProductId2 = relatedProduct.ProductId2,
DisplayOrder = relatedProduct.DisplayOrder
});
}
// product <-> cross sells mappings
foreach (var csProduct in _productService.GetCrossSellProductsByProductId1(product.Id, true))
{
_productService.InsertCrossSellProduct(
new CrossSellProduct
{
ProductId1 = productCopy.Id,
ProductId2 = csProduct.ProductId2,
});
}
// product specifications
foreach (var productSpecificationAttribute in product.ProductSpecificationAttributes)
{
var psaCopy = new ProductSpecificationAttribute
{
ProductId = productCopy.Id,
AttributeTypeId = productSpecificationAttribute.AttributeTypeId,
SpecificationAttributeOptionId = productSpecificationAttribute.SpecificationAttributeOptionId,
CustomValue = productSpecificationAttribute.CustomValue,
AllowFiltering = productSpecificationAttribute.AllowFiltering,
ShowOnProductPage = productSpecificationAttribute.ShowOnProductPage,
DisplayOrder = productSpecificationAttribute.DisplayOrder
};
_specificationAttributeService.InsertProductSpecificationAttribute(psaCopy);
}
//store mapping
var selectedStoreIds = _storeMappingService.GetStoresIdsWithAccess(product);
foreach (var id in selectedStoreIds)
{
_storeMappingService.InsertStoreMapping(productCopy, id);
}
// product <-> attributes mappings
var associatedAttributes = new Dictionary<int, int>();
var associatedAttributeValues = new Dictionary<int, int>();
foreach (var productAttributeMapping in _productAttributeService.GetProductAttributeMappingsByProductId(product.Id))
{
var productAttributeMappingCopy = new ProductAttributeMapping
{
ProductId = productCopy.Id,
ProductAttributeId = productAttributeMapping.ProductAttributeId,
TextPrompt = productAttributeMapping.TextPrompt,
IsRequired = productAttributeMapping.IsRequired,
AttributeControlTypeId = productAttributeMapping.AttributeControlTypeId,
DisplayOrder = productAttributeMapping.DisplayOrder,
ValidationMinLength = productAttributeMapping.ValidationMinLength,
ValidationMaxLength = productAttributeMapping.ValidationMaxLength,
ValidationFileAllowedExtensions = productAttributeMapping.ValidationFileAllowedExtensions,
ValidationFileMaximumSize = productAttributeMapping.ValidationFileMaximumSize,
DefaultValue = productAttributeMapping.DefaultValue,
};
_productAttributeService.InsertProductAttributeMapping(productAttributeMappingCopy);
//save associated value (used for combinations copying)
associatedAttributes.Add(productAttributeMapping.Id, productAttributeMappingCopy.Id);
// product attribute values
var productAttributeValues = _productAttributeService.GetProductAttributeValues(productAttributeMapping.Id);
foreach (var productAttributeValue in productAttributeValues)
{
int attributeValuePictureId = 0;
if (originalNewPictureIdentifiers.ContainsKey(productAttributeValue.PictureId))
{
attributeValuePictureId = originalNewPictureIdentifiers[productAttributeValue.PictureId];
}
var attributeValueCopy = new ProductAttributeValue
{
ProductAttributeMappingId = productAttributeMappingCopy.Id,
AttributeValueTypeId = productAttributeValue.AttributeValueTypeId,
AssociatedProductId = productAttributeValue.AssociatedProductId,
Name = productAttributeValue.Name,
ColorSquaresRgb = productAttributeValue.ColorSquaresRgb,
PriceAdjustment = productAttributeValue.PriceAdjustment,
WeightAdjustment = productAttributeValue.WeightAdjustment,
Cost = productAttributeValue.Cost,
Quantity = productAttributeValue.Quantity,
IsPreSelected = productAttributeValue.IsPreSelected,
DisplayOrder = productAttributeValue.DisplayOrder,
PictureId = attributeValuePictureId,
};
_productAttributeService.InsertProductAttributeValue(attributeValueCopy);
//save associated value (used for combinations copying)
associatedAttributeValues.Add(productAttributeValue.Id, attributeValueCopy.Id);
//localization
foreach (var lang in languages)
{
var name = productAttributeValue.GetLocalized(x => x.Name, lang.Id, false, false);
if (!String.IsNullOrEmpty(name))
_localizedEntityService.SaveLocalizedValue(attributeValueCopy, x => x.Name, name, lang.Id);
}
}
}
//attribute combinations
foreach (var combination in _productAttributeService.GetAllProductAttributeCombinations(product.Id))
{
//generate new AttributesXml according to new value IDs
string newAttributesXml = "";
var parsedProductAttributes = _productAttributeParser.ParseProductAttributeMappings(combination.AttributesXml);
foreach (var oldAttribute in parsedProductAttributes)
{
if (associatedAttributes.ContainsKey(oldAttribute.Id))
{
var newAttribute = _productAttributeService.GetProductAttributeMappingById(associatedAttributes[oldAttribute.Id]);
if (newAttribute != null)
{
var oldAttributeValuesStr = _productAttributeParser.ParseValues(combination.AttributesXml, oldAttribute.Id);
foreach (var oldAttributeValueStr in oldAttributeValuesStr)
{
if (newAttribute.ShouldHaveValues())
{
//attribute values
int oldAttributeValue = int.Parse(oldAttributeValueStr);
if (associatedAttributeValues.ContainsKey(oldAttributeValue))
{
var newAttributeValue = _productAttributeService.GetProductAttributeValueById(associatedAttributeValues[oldAttributeValue]);
if (newAttributeValue != null)
{
newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml,
newAttribute, newAttributeValue.Id.ToString());
}
}
}
else
{
//just a text
newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml,
newAttribute, oldAttributeValueStr);
}
}
}
}
}
var combinationCopy = new ProductAttributeCombination
{
ProductId = productCopy.Id,
AttributesXml = newAttributesXml,
StockQuantity = combination.StockQuantity,
AllowOutOfStockOrders = combination.AllowOutOfStockOrders,
Sku = combination.Sku,
ManufacturerPartNumber = combination.ManufacturerPartNumber,
Gtin = combination.Gtin,
OverriddenPrice = combination.OverriddenPrice,
NotifyAdminForQuantityBelow = combination.NotifyAdminForQuantityBelow
};
_productAttributeService.InsertProductAttributeCombination(combinationCopy);
}
//tier prices
foreach (var tierPrice in product.TierPrices)
{
_productService.InsertTierPrice(
new TierPrice
{
ProductId = productCopy.Id,
StoreId = tierPrice.StoreId,
CustomerRoleId = tierPrice.CustomerRoleId,
Quantity = tierPrice.Quantity,
Price = tierPrice.Price
});
}
// product <-> discounts mapping
foreach (var discount in product.AppliedDiscounts)
{
productCopy.AppliedDiscounts.Add(discount);
_productService.UpdateProduct(productCopy);
}
//update "HasTierPrices" and "HasDiscountsApplied" properties
_productService.UpdateHasTierPricesProperty(productCopy);
_productService.UpdateHasDiscountsApplied(productCopy);
//associated products
if (copyAssociatedProducts)
{
var associatedProducts = _productService.GetAssociatedProducts(product.Id, showHidden: true);
foreach (var associatedProduct in associatedProducts)
{
var associatedProductCopy = CopyProduct(associatedProduct, string.Format("Copy of {0}", associatedProduct.Name),
isPublished, copyImages, false);
associatedProductCopy.ParentGroupedProductId = productCopy.Id;
_productService.UpdateProduct(productCopy);
}
}
return productCopy;
}
/// <summary>
/// Adds an attribute
/// </summary>
/// <param name="attributesXml">Attributes in XML format</param>
/// <param name="productAttributeMapping">Product attribute mapping</param>
/// <param name="value">Value</param>
/// <returns>Attributes</returns>
public virtual string AddProductAttribute(string attributesXml, ProductAttributeMapping productAttributeMapping, string value)
{
string result = string.Empty;
try
{
var xmlDoc = new XmlDocument();
if (String.IsNullOrEmpty(attributesXml))
{
var element1 = xmlDoc.CreateElement("Attributes");
xmlDoc.AppendChild(element1);
}
else
{
xmlDoc.LoadXml(attributesXml);
}
var rootElement = (XmlElement)xmlDoc.SelectSingleNode(@"//Attributes");
XmlElement attributeElement = null;
//find existing
var nodeList1 = xmlDoc.SelectNodes(@"//Attributes/ProductVariantAttribute");
foreach (XmlNode node1 in nodeList1)
{
if (node1.Attributes != null && node1.Attributes["ID"] != null)
{
string str1 =node1.Attributes["ID"].InnerText.Trim();
int id;
if (int.TryParse(str1, out id))
{
if (id == productAttributeMapping.Id)
{
attributeElement = (XmlElement)node1;
break;
}
}
}
}
//create new one if not found
if (attributeElement == null)
{
attributeElement = xmlDoc.CreateElement("ProductVariantAttribute");
attributeElement.SetAttribute("ID", productAttributeMapping.Id.ToString());
rootElement.AppendChild(attributeElement);
}
var attributeValueElement = xmlDoc.CreateElement("ProductVariantAttributeValue");
attributeElement.AppendChild(attributeValueElement);
var attributeValueValueElement = xmlDoc.CreateElement("Value");
attributeValueValueElement.InnerText = value;
attributeValueElement.AppendChild(attributeValueValueElement);
result = xmlDoc.OuterXml;
}
catch (Exception exc)
{
Debug.Write(exc.ToString());
}
return result;
}
public new void SetUp()
{
#region Test data
//color (dropdownlist)
pa1 = new ProductAttribute
{
Id = 1,
Name = "Color",
};
pam1_1 = new ProductAttributeMapping
{
Id = 11,
ProductId = 1,
TextPrompt = "Select color:",
IsRequired = true,
AttributeControlType = AttributeControlType.DropdownList,
DisplayOrder = 1,
ProductAttribute = pa1,
ProductAttributeId = pa1.Id
};
pav1_1 = new ProductAttributeValue
{
Id = 11,
Name = "Green",
DisplayOrder = 1,
ProductAttributeMapping= pam1_1,
ProductAttributeMappingId = pam1_1.Id
};
pav1_2 = new ProductAttributeValue
{
Id = 12,
Name = "Red",
DisplayOrder = 2,
ProductAttributeMapping = pam1_1,
ProductAttributeMappingId = pam1_1.Id
};
pam1_1.ProductAttributeValues.Add(pav1_1);
pam1_1.ProductAttributeValues.Add(pav1_2);
//custom option (checkboxes)
pa2 = new ProductAttribute
{
Id = 2,
Name = "Some custom option",
};
pam2_1 = new ProductAttributeMapping
{
Id = 21,
ProductId = 1,
TextPrompt = "Select at least one option:",
IsRequired = true,
AttributeControlType = AttributeControlType.Checkboxes,
DisplayOrder = 2,
ProductAttribute = pa2,
ProductAttributeId = pa2.Id
};
pav2_1 = new ProductAttributeValue
{
Id = 21,
Name = "Option 1",
DisplayOrder = 1,
ProductAttributeMapping = pam2_1,
ProductAttributeMappingId = pam2_1.Id
};
pav2_2 = new ProductAttributeValue
{
Id = 22,
Name = "Option 2",
DisplayOrder = 2,
ProductAttributeMapping = pam2_1,
ProductAttributeMappingId = pam2_1.Id
};
pam2_1.ProductAttributeValues.Add(pav2_1);
pam2_1.ProductAttributeValues.Add(pav2_2);
//custom text
pa3 = new ProductAttribute
{
Id = 3,
Name = "Custom text",
};
pam3_1 = new ProductAttributeMapping
{
Id = 31,
ProductId = 1,
TextPrompt = "Enter custom text:",
IsRequired = true,
AttributeControlType = AttributeControlType.TextBox,
DisplayOrder = 1,
ProductAttribute = pa1,
ProductAttributeId = pa3.Id
};
#endregion
_productAttributeRepo = MockRepository.GenerateMock<IRepository<ProductAttribute>>();
_productAttributeRepo.Expect(x => x.Table).Return(new List<ProductAttribute> { pa1, pa2, pa3 }.AsQueryable());
_productAttributeRepo.Expect(x => x.GetById(pa1.Id)).Return(pa1);
_productAttributeRepo.Expect(x => x.GetById(pa2.Id)).Return(pa2);
_productAttributeRepo.Expect(x => x.GetById(pa3.Id)).Return(pa3);
_productAttributeMappingRepo = MockRepository.GenerateMock<IRepository<ProductAttributeMapping>>();
_productAttributeMappingRepo.Expect(x => x.Table).Return(new List<ProductAttributeMapping> { pam1_1, pam2_1, pam3_1 }.AsQueryable());
_productAttributeMappingRepo.Expect(x => x.GetById(pam1_1.Id)).Return(pam1_1);
_productAttributeMappingRepo.Expect(x => x.GetById(pam2_1.Id)).Return(pam2_1);
_productAttributeMappingRepo.Expect(x => x.GetById(pam3_1.Id)).Return(pam3_1);
_productAttributeCombinationRepo = MockRepository.GenerateMock<IRepository<ProductAttributeCombination>>();
_productAttributeCombinationRepo.Expect(x => x.Table).Return(new List<ProductAttributeCombination>().AsQueryable());
_productAttributeValueRepo = MockRepository.GenerateMock<IRepository<ProductAttributeValue>>();
_productAttributeValueRepo.Expect(x => x.Table).Return(new List<ProductAttributeValue> { pav1_1, pav1_2, pav2_1, pav2_2 }.AsQueryable());
_productAttributeValueRepo.Expect(x => x.GetById(pav1_1.Id)).Return(pav1_1);
_productAttributeValueRepo.Expect(x => x.GetById(pav1_2.Id)).Return(pav1_2);
_productAttributeValueRepo.Expect(x => x.GetById(pav2_1.Id)).Return(pav2_1);
_productAttributeValueRepo.Expect(x => x.GetById(pav2_2.Id)).Return(pav2_2);
_eventPublisher = MockRepository.GenerateMock<IEventPublisher>();
_eventPublisher.Expect(x => x.Publish(Arg<object>.Is.Anything));
var cacheManager = new NopNullCache();
_productAttributeService = new ProductAttributeService(cacheManager,
_productAttributeRepo,
_productAttributeMappingRepo,
_productAttributeCombinationRepo,
_productAttributeValueRepo,
_eventPublisher);
_productAttributeParser = new ProductAttributeParser(_productAttributeService);
_priceCalculationService = MockRepository.GenerateMock<IPriceCalculationService>();
var workingLanguage = new Language();
_workContext = MockRepository.GenerateMock<IWorkContext>();
_workContext.Expect(x => x.WorkingLanguage).Return(workingLanguage);
_currencyService = MockRepository.GenerateMock<ICurrencyService>();
_localizationService = MockRepository.GenerateMock<ILocalizationService>();
_localizationService.Expect(x => x.GetResource("GiftCardAttribute.For.Virtual")).Return("For: {0} <{1}>");
_localizationService.Expect(x => x.GetResource("GiftCardAttribute.From.Virtual")).Return("From: {0} <{1}>");
_localizationService.Expect(x => x.GetResource("GiftCardAttribute.For.Physical")).Return("For: {0}");
_localizationService.Expect(x => x.GetResource("GiftCardAttribute.From.Physical")).Return("From: {0}");
_taxService = MockRepository.GenerateMock<ITaxService>();
_priceFormatter = MockRepository.GenerateMock<IPriceFormatter>();
_downloadService = MockRepository.GenerateMock<IDownloadService>();
_webHelper = MockRepository.GenerateMock<IWebHelper>();
_shoppingCartSettings = MockRepository.GenerateMock<ShoppingCartSettings>();
_productAttributeFormatter = new ProductAttributeFormatter(_workContext,
_productAttributeService,
_productAttributeParser,
_currencyService,
_localizationService,
_taxService,
_priceFormatter,
_downloadService,
_webHelper,
_priceCalculationService,
_shoppingCartSettings);
}
public ActionResult ProductAttributeMappingInsert(ProductModel.ProductAttributeMappingModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageProducts))
return AccessDeniedView();
var product = _productService.GetProductById(model.ProductId);
if (product == null)
throw new ArgumentException("No product found with the specified id");
//a vendor should have access only to his products
if (_workContext.CurrentVendor != null && product.VendorId != _workContext.CurrentVendor.Id)
{
return Content("This is not your product");
}
var productAttributeMapping = new ProductAttributeMapping
{
ProductId = model.ProductId,
ProductAttributeId = model.ProductAttributeId,
TextPrompt = model.TextPrompt,
IsRequired = model.IsRequired,
AttributeControlTypeId = model.AttributeControlTypeId,
DisplayOrder = model.DisplayOrder
};
_productAttributeService.InsertProductAttributeMapping(productAttributeMapping);
return new NullJsonResult();
}
/// <summary>
/// Check whether condition of some attribute is met (if specified). Return "null" if not condition is specified
/// </summary>
/// <param name="pam">Product attribute</param>
/// <param name="selectedAttributesXml">Selected attributes (XML format)</param>
/// <returns>Result</returns>
public virtual bool? IsConditionMet(Product product, ProductAttributeMapping pam, string selectedAttributesXml)
{
if (pam == null)
throw new ArgumentNullException("pam");
var conditionAttributeXml = pam.ConditionAttributeXml;
if (String.IsNullOrEmpty(conditionAttributeXml))
//no condition
return null;
//load an attribute this one depends on
var dependOnAttribute = ParseProductAttributeMappings(product, conditionAttributeXml).FirstOrDefault();
if (dependOnAttribute == null)
return true;
var valuesThatShouldBeSelected = ParseValues(conditionAttributeXml, dependOnAttribute.Id)
//a workaround here:
//ConditionAttributeXml can contain "empty" values (nothing is selected)
//but in other cases (like below) we do not store empty values
//that's why we remove empty values here
.Where(x => !String.IsNullOrEmpty(x))
.ToList();
var selectedValues = ParseValues(selectedAttributesXml, dependOnAttribute.Id);
if (valuesThatShouldBeSelected.Count != selectedValues.Count)
return false;
//compare values
var allFound = true;
foreach (var t1 in valuesThatShouldBeSelected)
{
bool found = false;
foreach (var t2 in selectedValues)
if (t1 == t2)
found = true;
if (!found)
allFound = false;
}
return allFound;
}
/// <summary>
/// Import products from XLSX file
/// </summary>
/// <param name="stream">Stream</param>
public virtual void ImportProductsFromXlsx(Stream stream)
{
//var start = DateTime.Now;
using (var xlPackage = new ExcelPackage(stream))
{
// get the first worksheet in the workbook
var worksheet = xlPackage.Workbook.Worksheets.FirstOrDefault();
if (worksheet == null)
throw new NopException("No worksheet found");
//the columns
var properties = new List<PropertyByName<Product>>();
var poz = 1;
while (true)
{
try
{
var cell = worksheet.Cells[1, poz];
if (cell == null || cell.Value == null || String.IsNullOrEmpty(cell.Value.ToString()))
break;
poz += 1;
properties.Add(new PropertyByName<Product>(cell.Value.ToString()));
}
catch
{
break;
}
}
var manager = new PropertyManager<Product>(properties.ToArray());
var attributProperties = new[]
{
new PropertyByName<ExportProductAttribute>("AttributeId"),
new PropertyByName<ExportProductAttribute>("AttributeName"),
new PropertyByName<ExportProductAttribute>("AttributeTextPrompt"),
new PropertyByName<ExportProductAttribute>("AttributeIsRequired"),
new PropertyByName<ExportProductAttribute>("AttributeControlType")
{
DropDownElements = AttributeControlType.TextBox.ToSelectList(useLocalization: false)
},
new PropertyByName<ExportProductAttribute>("AttributeDisplayOrder"),
new PropertyByName<ExportProductAttribute>("ProductAttributeValueId"),
new PropertyByName<ExportProductAttribute>("ValueName"),
new PropertyByName<ExportProductAttribute>("AttributeValueType")
{
DropDownElements = AttributeValueType.Simple.ToSelectList(useLocalization: false)
},
new PropertyByName<ExportProductAttribute>("AssociatedProductId"),
new PropertyByName<ExportProductAttribute>("ColorSquaresRgb"),
new PropertyByName<ExportProductAttribute>("ImageSquaresPictureId"),
new PropertyByName<ExportProductAttribute>("PriceAdjustment"),
new PropertyByName<ExportProductAttribute>("WeightAdjustment"),
new PropertyByName<ExportProductAttribute>("Cost"),
new PropertyByName<ExportProductAttribute>("Quantity"),
new PropertyByName<ExportProductAttribute>("IsPreSelected"),
new PropertyByName<ExportProductAttribute>("DisplayOrder"),
new PropertyByName<ExportProductAttribute>("PictureId")
};
var managerProductAttribute = new PropertyManager<ExportProductAttribute>(attributProperties);
var endRow = 2;
var allCategoriesNames = new List<string>();
var allSku = new List<string>();
var tempProperty = manager.GetProperty("Categories");
var categoryCellNum = tempProperty.Return(p => p.PropertyOrderPosition, -1);
tempProperty = manager.GetProperty("SKU");
var skuCellNum = tempProperty.Return(p => p.PropertyOrderPosition, -1);
var allManufacturersNames = new List<string>();
tempProperty = manager.GetProperty("Manufacturers");
var manufacturerCellNum = tempProperty.Return(p => p.PropertyOrderPosition, -1);
manager.SetSelectList("ProductType", ProductType.SimpleProduct.ToSelectList(useLocalization: false));
manager.SetSelectList("GiftCardType", GiftCardType.Virtual.ToSelectList(useLocalization: false));
manager.SetSelectList("DownloadActivationType", DownloadActivationType.Manually.ToSelectList(useLocalization: false));
manager.SetSelectList("ManageInventoryMethod", ManageInventoryMethod.DontManageStock.ToSelectList(useLocalization: false));
manager.SetSelectList("LowStockActivity", LowStockActivity.Nothing.ToSelectList(useLocalization: false));
manager.SetSelectList("BackorderMode", BackorderMode.NoBackorders.ToSelectList(useLocalization: false));
manager.SetSelectList("RecurringCyclePeriod", RecurringProductCyclePeriod.Days.ToSelectList(useLocalization: false));
manager.SetSelectList("RentalPricePeriod", RentalPricePeriod.Days.ToSelectList(useLocalization: false));
manager.SetSelectList("Vendor", _vendorService.GetAllVendors(showHidden: true).Select(v => v as BaseEntity).ToSelectList(p => (p as Vendor).Return(v => v.Name, String.Empty)));
manager.SetSelectList("ProductTemplate", _productTemplateService.GetAllProductTemplates().Select(pt => pt as BaseEntity).ToSelectList(p => (p as ProductTemplate).Return(pt => pt.Name, String.Empty)));
manager.SetSelectList("DeliveryDate", _shippingService.GetAllDeliveryDates().Select(dd => dd as BaseEntity).ToSelectList(p => (p as DeliveryDate).Return(dd => dd.Name, String.Empty)));
manager.SetSelectList("TaxCategory", _taxCategoryService.GetAllTaxCategories().Select(tc => tc as BaseEntity).ToSelectList(p => (p as TaxCategory).Return(tc => tc.Name, String.Empty)));
manager.SetSelectList("BasepriceUnit", _measureService.GetAllMeasureWeights().Select(mw => mw as BaseEntity).ToSelectList(p =>(p as MeasureWeight).Return(mw => mw.Name, String.Empty)));
manager.SetSelectList("BasepriceBaseUnit", _measureService.GetAllMeasureWeights().Select(mw => mw as BaseEntity).ToSelectList(p => (p as MeasureWeight).Return(mw => mw.Name, String.Empty)));
var allAttributeIds = new List<int>();
var attributeIdCellNum = managerProductAttribute.GetProperty("AttributeId").PropertyOrderPosition + ExportProductAttribute.ProducAttributeCellOffset;
//find end of data
while (true)
{
var allColumnsAreEmpty = manager.GetProperties
.Select(property => worksheet.Cells[endRow, property.PropertyOrderPosition])
.All(cell => cell == null || cell.Value == null || String.IsNullOrEmpty(cell.Value.ToString()));
if (allColumnsAreEmpty)
break;
if (new[] { 1, 2 }.Select(cellNum => worksheet.Cells[endRow, cellNum]).All(cell => cell == null || cell.Value == null || String.IsNullOrEmpty(cell.Value.ToString())) && worksheet.Row(endRow).OutlineLevel == 0)
{
var cellValue = worksheet.Cells[endRow, attributeIdCellNum].Value;
try
{
var aid = cellValue.Return(Convert.ToInt32, -1);
var productAttribute = _productAttributeService.GetProductAttributeById(aid);
if (productAttribute != null)
worksheet.Row(endRow).OutlineLevel = 1;
}
catch (FormatException)
{
if (cellValue.Return(cv => cv.ToString(), String.Empty) == "AttributeId")
worksheet.Row(endRow).OutlineLevel = 1;
}
}
if (worksheet.Row(endRow).OutlineLevel != 0)
{
managerProductAttribute.ReadFromXlsx(worksheet, endRow, ExportProductAttribute.ProducAttributeCellOffset);
if (!managerProductAttribute.IsCaption)
{
var aid = worksheet.Cells[endRow, attributeIdCellNum].Value.Return(Convert.ToInt32, -1);
allAttributeIds.Add(aid);
}
endRow++;
continue;
}
if (categoryCellNum > 0)
{
var categoryIds = worksheet.Cells[endRow, categoryCellNum].Value.Return(p => p.ToString(), string.Empty);
if (!categoryIds.IsEmpty())
allCategoriesNames.AddRange(categoryIds.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()));
}
if (skuCellNum > 0)
{
var sku = worksheet.Cells[endRow, skuCellNum].Value.Return(p => p.ToString(), string.Empty);
if (!sku.IsEmpty())
allSku.Add(sku);
}
if (manufacturerCellNum > 0)
{
var manufacturerIds = worksheet.Cells[endRow, manufacturerCellNum].Value.Return(p => p.ToString(), string.Empty);
if (!manufacturerIds.IsEmpty())
allManufacturersNames.AddRange(manufacturerIds.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()));
}
endRow++;
}
//performance optimization, the check for the existence of the categories in one SQL request
var notExistingCategories = _categoryService.GetNotExistingCategories(allCategoriesNames.ToArray());
if (notExistingCategories.Any())
{
throw new ArgumentException(string.Format("The following category name(s) don't exist - {0}", string.Join(", ", notExistingCategories)));
}
//performance optimization, the check for the existence of the manufacturers in one SQL request
var notExistingManufacturers = _manufacturerService.GetNotExistingManufacturers(allManufacturersNames.ToArray());
if (notExistingManufacturers.Any())
{
throw new ArgumentException(string.Format("The following manufacturer name(s) don't exist - {0}", string.Join(", ", notExistingManufacturers)));
}
//performance optimization, the check for the existence of the product attributes in one SQL request
var notExistingProductAttributes = _productAttributeService.GetNotExistingAttributes(allAttributeIds.ToArray());
if (notExistingProductAttributes.Any())
{
throw new ArgumentException(string.Format("The following product attribute ID(s) don't exist - {0}", string.Join(", ", notExistingProductAttributes)));
}
//performance optimization, load all products by SKU in one SQL request
var allProductsBySku = _productService.GetProductsBySku(allSku.ToArray());
//performance optimization, load all categories IDs for products in one SQL request
var allProductsCategoryIds = _categoryService.GetProductCategoryIds(allProductsBySku.Select(p => p.Id).ToArray());
//performance optimization, load all categories in one SQL request
var allCategories = _categoryService.GetAllCategories(showHidden: true);
//performance optimization, load all manufacturers IDs for products in one SQL request
var allProductsManufacturerIds = _manufacturerService.GetProductManufacturerIds(allProductsBySku.Select(p => p.Id).ToArray());
//performance optimization, load all manufacturers in one SQL request
var allManufacturers = _manufacturerService.GetAllManufacturers(showHidden: true);
//product to import images
var productPictureMetadata = new List<ProductPictureMetadata>();
Product lastLoadedProduct = null;
for (var iRow = 2; iRow < endRow; iRow++)
{
//imports product attributes
if (worksheet.Row(iRow).OutlineLevel != 0)
{
if (_catalogSettings.ExportImportProductAttributes)
{
managerProductAttribute.ReadFromXlsx(worksheet, iRow,
ExportProductAttribute.ProducAttributeCellOffset);
if (lastLoadedProduct == null || managerProductAttribute.IsCaption)
continue;
var productAttributeId = managerProductAttribute.GetProperty("AttributeId").IntValue;
var attributeControlTypeId = managerProductAttribute.GetProperty("AttributeControlType").IntValue;
var productAttributeValueId = managerProductAttribute.GetProperty("ProductAttributeValueId").IntValue;
var associatedProductId = managerProductAttribute.GetProperty("AssociatedProductId").IntValue;
var valueName = managerProductAttribute.GetProperty("ValueName").StringValue;
var attributeValueTypeId = managerProductAttribute.GetProperty("AttributeValueType").IntValue;
var colorSquaresRgb = managerProductAttribute.GetProperty("ColorSquaresRgb").StringValue;
var imageSquaresPictureId = managerProductAttribute.GetProperty("ImageSquaresPictureId").IntValue;
var priceAdjustment = managerProductAttribute.GetProperty("PriceAdjustment").DecimalValue;
var weightAdjustment = managerProductAttribute.GetProperty("WeightAdjustment").DecimalValue;
var cost = managerProductAttribute.GetProperty("Cost").DecimalValue;
var quantity = managerProductAttribute.GetProperty("Quantity").IntValue;
var isPreSelected = managerProductAttribute.GetProperty("IsPreSelected").BooleanValue;
var displayOrder = managerProductAttribute.GetProperty("DisplayOrder").IntValue;
var pictureId = managerProductAttribute.GetProperty("PictureId").IntValue;
var textPrompt = managerProductAttribute.GetProperty("AttributeTextPrompt").StringValue;
var isRequired = managerProductAttribute.GetProperty("AttributeIsRequired").BooleanValue;
var attributeDisplayOrder = managerProductAttribute.GetProperty("AttributeDisplayOrder").IntValue;
var productAttributeMapping = lastLoadedProduct.ProductAttributeMappings.FirstOrDefault(pam => pam.ProductAttributeId == productAttributeId);
if (productAttributeMapping == null)
{
//insert mapping
productAttributeMapping = new ProductAttributeMapping
{
ProductId = lastLoadedProduct.Id,
ProductAttributeId = productAttributeId,
TextPrompt = textPrompt,
IsRequired = isRequired,
AttributeControlTypeId = attributeControlTypeId,
DisplayOrder = attributeDisplayOrder
};
_productAttributeService.InsertProductAttributeMapping(productAttributeMapping);
}
else
{
productAttributeMapping.AttributeControlTypeId = attributeControlTypeId;
productAttributeMapping.TextPrompt = textPrompt;
productAttributeMapping.IsRequired = isRequired;
productAttributeMapping.DisplayOrder = attributeDisplayOrder;
_productAttributeService.UpdateProductAttributeMapping(productAttributeMapping);
}
var pav = _productAttributeService.GetProductAttributeValueById(productAttributeValueId);
var attributeControlType = (AttributeControlType) attributeControlTypeId;
if (pav == null)
{
switch (attributeControlType)
{
case AttributeControlType.Datepicker:
case AttributeControlType.FileUpload:
case AttributeControlType.MultilineTextbox:
case AttributeControlType.TextBox:
continue;
}
pav = new ProductAttributeValue
{
ProductAttributeMappingId = productAttributeMapping.Id,
AttributeValueType = (AttributeValueType) attributeValueTypeId,
AssociatedProductId = associatedProductId,
Name = valueName,
PriceAdjustment = priceAdjustment,
WeightAdjustment = weightAdjustment,
Cost = cost,
IsPreSelected = isPreSelected,
DisplayOrder = displayOrder,
ColorSquaresRgb = colorSquaresRgb,
ImageSquaresPictureId = imageSquaresPictureId,
Quantity = quantity,
PictureId = pictureId
};
_productAttributeService.InsertProductAttributeValue(pav);
}
else
{
pav.AttributeValueTypeId = attributeValueTypeId;
pav.AssociatedProductId = associatedProductId;
pav.Name = valueName;
pav.ColorSquaresRgb = colorSquaresRgb;
pav.ImageSquaresPictureId = imageSquaresPictureId;
pav.PriceAdjustment = priceAdjustment;
pav.WeightAdjustment = weightAdjustment;
pav.Cost = cost;
pav.Quantity = quantity;
pav.IsPreSelected = isPreSelected;
pav.DisplayOrder = displayOrder;
pav.PictureId = pictureId;
_productAttributeService.UpdateProductAttributeValue(pav);
}
}
continue;
}
manager.ReadFromXlsx(worksheet, iRow);
var product = skuCellNum > 0 ? allProductsBySku.FirstOrDefault(p => p.Sku == manager.GetProperty("SKU").StringValue) : null;
var isNew = product == null;
product = product ?? new Product();
if (isNew)
product.CreatedOnUtc = DateTime.UtcNow;
foreach (var property in manager.GetProperties)
{
switch (property.PropertyName)
{
case "ProductType":
product.ProductTypeId = property.IntValue;
break;
case "ParentGroupedProductId":
product.ParentGroupedProductId = property.IntValue;
break;
case "VisibleIndividually":
product.VisibleIndividually = property.BooleanValue;
break;
case "Name":
product.Name = property.StringValue;
break;
case "ShortDescription":
product.ShortDescription = property.StringValue;
break;
case "FullDescription":
product.FullDescription = property.StringValue;
break;
case "Vendor":
product.VendorId = property.IntValue;
break;
case "ProductTemplate":
product.ProductTemplateId = property.IntValue;
break;
case "ShowOnHomePage":
product.ShowOnHomePage = property.BooleanValue;
break;
case "MetaKeywords":
product.MetaKeywords = property.StringValue;
break;
case "MetaDescription":
product.MetaDescription = property.StringValue;
break;
case "MetaTitle":
product.MetaTitle = property.StringValue;
break;
case "AllowCustomerReviews":
product.AllowCustomerReviews = property.BooleanValue;
break;
case "Published":
product.Published = property.BooleanValue;
break;
case "SKU":
product.Sku = property.StringValue;
break;
case "ManufacturerPartNumber":
product.ManufacturerPartNumber = property.StringValue;
break;
case "Gtin":
product.Gtin = property.StringValue;
break;
case "IsGiftCard":
product.IsGiftCard = property.BooleanValue;
break;
case "GiftCardType":
product.GiftCardTypeId = property.IntValue;
break;
case "OverriddenGiftCardAmount":
product.OverriddenGiftCardAmount = property.DecimalValue;
break;
case "RequireOtherProducts":
product.RequireOtherProducts = property.BooleanValue;
break;
case "RequiredProductIds":
product.RequiredProductIds = property.StringValue;
break;
case "AutomaticallyAddRequiredProducts":
product.AutomaticallyAddRequiredProducts = property.BooleanValue;
break;
case "IsDownload":
product.IsDownload = property.BooleanValue;
break;
case "DownloadId":
product.DownloadId = property.IntValue;
break;
case "UnlimitedDownloads":
product.UnlimitedDownloads = property.BooleanValue;
break;
case "MaxNumberOfDownloads":
product.MaxNumberOfDownloads = property.IntValue;
break;
case "DownloadActivationType":
product.DownloadActivationTypeId = property.IntValue;
break;
case "HasSampleDownload":
product.HasSampleDownload = property.BooleanValue;
break;
case "SampleDownloadId":
product.SampleDownloadId = property.IntValue;
break;
case "HasUserAgreement":
product.HasUserAgreement = property.BooleanValue;
break;
case "UserAgreementText":
product.UserAgreementText = property.StringValue;
break;
case "IsRecurring":
product.IsRecurring = property.BooleanValue;
break;
case "RecurringCycleLength":
product.RecurringCycleLength = property.IntValue;
break;
case "RecurringCyclePeriod":
product.RecurringCyclePeriodId = property.IntValue;
break;
case "RecurringTotalCycles":
product.RecurringTotalCycles = property.IntValue;
break;
case "IsRental":
product.IsRental = property.BooleanValue;
break;
case "RentalPriceLength":
product.RentalPriceLength = property.IntValue;
break;
case "RentalPricePeriod":
product.RentalPricePeriodId = property.IntValue;
break;
case "IsShipEnabled":
product.IsShipEnabled = property.BooleanValue;
break;
case "IsFreeShipping":
product.IsFreeShipping = property.BooleanValue;
break;
case "ShipSeparately":
product.ShipSeparately = property.BooleanValue;
break;
case "AdditionalShippingCharge":
product.AdditionalShippingCharge = property.DecimalValue;
break;
case "DeliveryDate":
product.DeliveryDateId = property.IntValue;
break;
case "IsTaxExempt":
product.IsTaxExempt = property.BooleanValue;
break;
case "TaxCategory":
product.TaxCategoryId = property.IntValue;
break;
case "IsTelecommunicationsOrBroadcastingOrElectronicServices":
product.IsTelecommunicationsOrBroadcastingOrElectronicServices = property.BooleanValue;
break;
case "ManageInventoryMethod":
product.ManageInventoryMethodId = property.IntValue;
break;
case "UseMultipleWarehouses":
product.UseMultipleWarehouses = property.BooleanValue;
break;
case "WarehouseId":
product.WarehouseId = property.IntValue;
break;
case "StockQuantity":
product.StockQuantity = property.IntValue;
break;
case "DisplayStockAvailability":
product.DisplayStockAvailability = property.BooleanValue;
break;
case "DisplayStockQuantity":
product.DisplayStockQuantity = property.BooleanValue;
break;
case "MinStockQuantity":
product.MinStockQuantity = property.IntValue;
break;
case "LowStockActivity":
product.LowStockActivityId = property.IntValue;
break;
case "NotifyAdminForQuantityBelow":
product.NotifyAdminForQuantityBelow = property.IntValue;
break;
case "BackorderModeId":
product.BackorderModeId = property.IntValue;
break;
case "AllowBackInStockSubscriptions":
product.AllowBackInStockSubscriptions = property.BooleanValue;
break;
case "OrderMinimumQuantity":
product.OrderMinimumQuantity = property.IntValue;
break;
case "OrderMaximumQuantity":
product.OrderMaximumQuantity = property.IntValue;
break;
case "AllowedQuantities":
product.AllowedQuantities = property.StringValue;
break;
case "AllowAddingOnlyExistingAttributeCombinations":
product.AllowAddingOnlyExistingAttributeCombinations = property.BooleanValue;
break;
case "NotReturnable":
product.NotReturnable = property.BooleanValue;
break;
case "DisableBuyButton":
product.DisableBuyButton = property.BooleanValue;
break;
case "DisableWishlistButton":
product.DisableWishlistButton = property.BooleanValue;
break;
case "AvailableForPreOrder":
product.AvailableForPreOrder = property.BooleanValue;
break;
case "PreOrderAvailabilityStartDateTimeUtc":
product.PreOrderAvailabilityStartDateTimeUtc = property.DateTimeNullable;
break;
case "CallForPrice":
product.CallForPrice = property.BooleanValue;
break;
case "Price":
product.Price = property.DecimalValue;
break;
case "OldPrice":
product.OldPrice = property.DecimalValue;
break;
case "ProductCost":
product.ProductCost = property.DecimalValue;
break;
case "SpecialPrice":
product.SpecialPrice = property.DecimalValueNullable;
break;
case "SpecialPriceStartDateTimeUtc":
product.SpecialPriceStartDateTimeUtc = property.DateTimeNullable;
break;
case "SpecialPriceEndDateTimeUtc":
product.SpecialPriceEndDateTimeUtc = property.DateTimeNullable;
break;
case "CustomerEntersPrice":
product.CustomerEntersPrice = property.BooleanValue;
break;
case "MinimumCustomerEnteredPrice":
product.MinimumCustomerEnteredPrice = property.DecimalValue;
break;
case "MaximumCustomerEnteredPrice":
product.MaximumCustomerEnteredPrice = property.DecimalValue;
break;
case "BasepriceEnabled":
product.BasepriceEnabled = property.BooleanValue;
break;
case "BasepriceAmount":
product.BasepriceAmount = property.DecimalValue;
break;
case "BasepriceUnit":
product.BasepriceUnitId = property.IntValue;
break;
case "BasepriceBaseAmount":
product.BasepriceBaseAmount = property.DecimalValue;
break;
case "BasepriceBaseUnit":
product.BasepriceBaseUnitId = property.IntValue;
break;
case "MarkAsNew":
product.MarkAsNew = property.BooleanValue;
break;
case "MarkAsNewStartDateTimeUtc":
product.MarkAsNewStartDateTimeUtc = property.DateTimeNullable;
break;
case "MarkAsNewEndDateTimeUtc":
product.MarkAsNewEndDateTimeUtc = property.DateTimeNullable;
break;
case "Weight":
product.Weight = property.DecimalValue;
break;
case "Length":
product.Length = property.DecimalValue;
break;
case "Width":
product.Width = property.DecimalValue;
break;
case "Height":
product.Height = property.DecimalValue;
break;
}
}
//set default product type id
if (isNew && properties.All(p => p.PropertyName != "ProductTypeId"))
product.ProductType = ProductType.SimpleProduct;
product.UpdatedOnUtc = DateTime.UtcNow;
if (isNew)
{
_productService.InsertProduct(product);
}
else
{
_productService.UpdateProduct(product);
}
tempProperty = manager.GetProperty("SeName");
if (tempProperty != null)
{
var seName = tempProperty.StringValue;
//search engine name
_urlRecordService.SaveSlug(product, product.ValidateSeName(seName, product.Name, true), 0);
}
tempProperty = manager.GetProperty("Categories");
if (tempProperty != null)
{
var categoryNames = tempProperty.StringValue;
//category mappings
var categories = isNew || !allProductsCategoryIds.ContainsKey(product.Id) ? new int[0] : allProductsCategoryIds[product.Id];
foreach (var categoryId in categoryNames.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).Select(x => allCategories.First(c => c.Name == x.Trim()).Id))
{
if (categories.Any(c => c == categoryId))
continue;
var productCategory = new ProductCategory
{
ProductId = product.Id,
CategoryId = categoryId,
IsFeaturedProduct = false,
DisplayOrder = 1
};
_categoryService.InsertProductCategory(productCategory);
}
}
tempProperty = manager.GetProperty("Manufacturers");
if (tempProperty != null)
{
var manufacturerNames = tempProperty.StringValue;
//manufacturer mappings
var manufacturers = isNew || !allProductsManufacturerIds.ContainsKey(product.Id) ? new int[0] : allProductsManufacturerIds[product.Id];
foreach (var manufacturerId in manufacturerNames.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).Select(x => allManufacturers.First(m => m.Name == x.Trim()).Id))
{
if (manufacturers.Any(c => c == manufacturerId))
continue;
var productManufacturer = new ProductManufacturer
{
ProductId = product.Id,
ManufacturerId = manufacturerId,
IsFeaturedProduct = false,
DisplayOrder = 1
};
_manufacturerService.InsertProductManufacturer(productManufacturer);
}
}
var picture1 = manager.GetProperty("Picture1").Return(p => p.StringValue, String.Empty);
var picture2 = manager.GetProperty("Picture2").Return(p => p.StringValue, String.Empty);
var picture3 = manager.GetProperty("Picture3").Return(p => p.StringValue, String.Empty);
productPictureMetadata.Add(new ProductPictureMetadata
{
ProductItem = product,
Picture1Path = picture1,
Picture2Path = picture2,
Picture3Path = picture3,
IsNew = isNew
});
lastLoadedProduct = product;
//update "HasTierPrices" and "HasDiscountsApplied" properties
//_productService.UpdateHasTierPricesProperty(product);
//_productService.UpdateHasDiscountsApplied(product);
}
if (_mediaSettings.ImportProductImagesUsingHash && _pictureService.StoreInDb && _dataProvider.SupportedLengthOfBinaryHash() > 0)
ImportProductImagesUsingHash(productPictureMetadata, allProductsBySku);
else
ImportProductImagesUsingServices(productPictureMetadata);
}
//Trace.WriteLine(DateTime.Now-start);
}
/// <summary>
/// Import Product Attribute from Excel
/// </summary>
/// <param name="stream"></param>
public virtual void ImportProductsAttributeFromXlsx(Stream stream)
{
using (var xlPackage = new ExcelPackage(stream))
{
// get the first worksheet in the workbook
var worksheet = xlPackage.Workbook.Worksheets.FirstOrDefault();
if (worksheet == null)
throw new NopException("No worksheet found");
var propertiesMapping = new []
{
"ProductId",
"ProductAttributeId",
"TextPrompt",
"IsRequired",
"AttributeControlTypeId",
"DisplayOrder",
"ValidationMinLength",
"ValidationMaxLength",
"ValidationFileAllowedExtensions",
"ValidationFileMaximumSize",
"DefaultValue" ,
"AttributeValueTypeId",
"AssociatedProductId",
"Name",
"ColorSquaresRgb",
"PriceAdjustment",
"WeightAdjustment",
"Cost",
"Quantity",
"IsPreSelected",
"DisplayOrder",
"PictureId"
};
int iRow = 2;
while (true)
{
bool allColumnsAreEmpty = true;
for (var i = 1; i <= propertiesMapping.Length; i++)
if (worksheet.Cells[iRow, i].Value != null && !String.IsNullOrEmpty(worksheet.Cells[iRow, i].Value.ToString()))
{
allColumnsAreEmpty = false;
break;
}
if (allColumnsAreEmpty)
break;
int ProductId = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "ProductId")].Value);
int ProductAttributeId = Convert.ToInt32(worksheet.Cells[iRow,GetColumnIndex(propertiesMapping,"ProductAttributeId")].Value);
string TextPrompt = Convert.ToString(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "TextPrompt")].Value);
bool IsRequired = Convert.ToBoolean(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "IsRequired")].Value);
int AttributeControlTypeId = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "AttributeControlTypeId")].Value);
int DisplayOrder = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "DisplayOrder")].Value);
int ValidationMinLength = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "ValidationMinLength")].Value);
int ValidationMaxLength = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "ValidationMaxLength")].Value);
string ValidationFileAllowedExtensions = Convert.ToString(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "ValidationFileAllowedExtensions")].Value);
int ValidationFileMaximumSize = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "ValidationFileMaximumSize")].Value);
string DefaultValue = Convert.ToString(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "DefaultValue")].Value);
if (ProductAttributeId == 0)
{
iRow++;
continue;
}
var prodcutAttributeMapping = new ProductAttributeMapping();
prodcutAttributeMapping.ProductId = ProductId;
prodcutAttributeMapping.ProductAttributeId = ProductAttributeId;
prodcutAttributeMapping.TextPrompt = TextPrompt;
prodcutAttributeMapping.IsRequired = IsRequired;
prodcutAttributeMapping.AttributeControlTypeId = AttributeControlTypeId;
prodcutAttributeMapping.DisplayOrder = DisplayOrder;
prodcutAttributeMapping.ValidationMinLength = ValidationMinLength;
prodcutAttributeMapping.ValidationMaxLength = ValidationMaxLength;
prodcutAttributeMapping.ValidationFileAllowedExtensions = ValidationFileAllowedExtensions;
prodcutAttributeMapping.ValidationFileMaximumSize = ValidationFileMaximumSize;
prodcutAttributeMapping.DefaultValue = DefaultValue;
_productAttributeService.InsertProductAttributeMapping(prodcutAttributeMapping);
int AttributeValueTypeId = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "AttributeValueTypeId")].Value);
int AssociatedProductId = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "AssociatedProductId")].Value);
string Name = Convert.ToString(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "Name")].Value);
string ColorSquaresRgb = Convert.ToString(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "ColorSquaresRgb")].Value);
decimal PriceAdjustment = Convert.ToDecimal(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "PriceAdjustment")].Value);
decimal WeightAdjustment = Convert.ToDecimal(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "WeightAdjustment")].Value);
decimal Cost = Convert.ToDecimal(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "Cost")].Value);
int Quantity = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "Quantity")].Value);
bool IsPreSelected = Convert.ToBoolean(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "IsPreSelected")].Value);
// int DisplayOrder = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesVaules, "DisplayOrder")].Value);
int PictureId = Convert.ToInt32(worksheet.Cells[iRow, GetColumnIndex(propertiesMapping, "PictureId")].Value);
var pm = _productAttributeService.GetProductAttributeMappingsByProductId(ProductId);
var productAttributeValue = new ProductAttributeValue();
productAttributeValue.AttributeValueTypeId = AttributeControlTypeId;
productAttributeValue.AssociatedProductId = AssociatedProductId;
// productAttributeValue.Name = Name;
productAttributeValue.ColorSquaresRgb = ColorSquaresRgb;
productAttributeValue.PriceAdjustment = PriceAdjustment;
productAttributeValue.WeightAdjustment = WeightAdjustment;
productAttributeValue.Cost = Cost;
productAttributeValue.Quantity = Quantity;
productAttributeValue.IsPreSelected = IsPreSelected;
productAttributeValue.DisplayOrder = DisplayOrder;
productAttributeValue.PictureId = PictureId;
string[] names = Name.Split(',');
foreach (var p in pm)
{
if(p.ProductAttributeId == ProductAttributeId )
{
productAttributeValue.ProductAttributeMappingId = p.Id;
foreach (var name in names)
{
productAttributeValue.Name = name;
_productAttributeService.InsertProductAttributeValue(productAttributeValue);
}
}
}
iRow++;
}
}
}