public ProductDto PrepareProductDTO(Product product)
{
var productDto = product.ToDto();
var productPictures = _productService.GetProductPicturesByProductId(product.Id);
PrepareProductImages(productPictures, productDto);
var x =
productDto.SeName = _urlRecordService.GetSeName(product);
productDto.DiscountIds = _discountService.GetAppliedDiscounts(product).Select(discount => discount.Id).ToList();
productDto.ManufacturerIds = _manufacturerService.GetProductManufacturersByProductId(product.Id).Select(pm => pm.Id).ToList();
productDto.RoleIds = _aclService.GetAclRecords(product).Select(acl => acl.CustomerRoleId).ToList();
productDto.StoreIds = _storeMappingService.GetStoreMappings(product).Select(mapping => mapping.StoreId)
.ToList();
productDto.Tags = _productTagService.GetAllProductTagsByProductId(product.Id).Select(tag => tag.Name)
.ToList();
productDto.AssociatedProductIds = GetRelatedProductIdsByProductId(product.Id);
// load product attributes
var productAttributeMappings = _productAttributeService
.GetProductAttributeMappingsByProductId(product.Id);
PrepareProductAttributes(productAttributeMappings, productDto);
// load product specification attributes
var productSpecificationAttributeMappings = _specificationAttributeService
.GetProductSpecificationAttributes(productId: product.Id);
PrepareProductSpecificationAttributes(productSpecificationAttributeMappings, productDto);
var allLanguages = _languageService.GetAllLanguages();
productDto.LocalizedNames = new List <LocalizedNameDto>();
foreach (var language in allLanguages)
{
var localizedNameDto = new LocalizedNameDto
{
LanguageId = language.Id,
LocalizedName = _localizationService.GetLocalized(product, x => x.Name, language.Id)
};
productDto.LocalizedNames.Add(localizedNameDto);
}
return(productDto);
}
public ProductDto PrepareProductDTO(Product product)
{
var productDto = product.ToDto();
PrepareProductImages(product.ProductPictures, productDto);
PrepareProductAttributes(product.ProductAttributeMappings, productDto);
PrepareProductSpecificationAttributes(product.ProductSpecificationAttributes, productDto);
productDto.SeName = _urlRecordService.GetSeName(product);
productDto.DiscountIds = product.AppliedDiscounts.Select(discount => discount.Id).ToList();
productDto.ManufacturerIds = product.ProductManufacturers.Select(pm => pm.ManufacturerId).ToList();
productDto.RoleIds = _aclService.GetAclRecords(product).Select(acl => acl.CustomerRoleId).ToList();
productDto.StoreIds = _storeMappingService.GetStoreMappings(product).Select(mapping => mapping.StoreId)
.ToList();
productDto.Tags = _productTagService.GetAllProductTagsByProductId(product.Id).Select(tag => tag.Name)
.ToList();
productDto.AssociatedProductIds =
_productService.GetAssociatedProducts(product.Id, showHidden: true)
.Select(associatedProduct => associatedProduct.Id)
.ToList();
var allLanguages = _languageService.GetAllLanguages();
productDto.LocalizedNames = new List <LocalizedNameDto>();
foreach (var language in allLanguages)
{
var localizedNameDto = new LocalizedNameDto
{
LanguageId = language.Id,
LocalizedName = _localizationService.GetLocalized(product, x => x.Name, language.Id)
};
productDto.LocalizedNames.Add(localizedNameDto);
}
/*EXTRA*/
PrepareProductAttributeCombinations(product.ProductAttributeCombinations, productDto);
PrepareProductTierPrices(product.TierPrices, productDto);
PrepareProductGenericAttributes(product, productDto);
/*EXTRA*/
return(productDto);
}
/// <summary>
/// Prepare the product tag models
/// </summary>
/// <param name="product">Product</param>
/// <returns>List of product tag model</returns>
protected virtual IList <ProductTagModel> PrepareProductTagModels(Product product)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
var productTagsCacheKey = string.Format(ModelCacheEventConsumer.PRODUCTTAG_BY_PRODUCT_MODEL_KEY, product.Id, _workContext.WorkingLanguage.Id, _storeContext.CurrentStore.Id);
var model = _cacheManager.Get(productTagsCacheKey, () =>
_productTagService.GetAllProductTagsByProductId(product.Id)
//filter by store
.Where(x => _productTagService.GetProductCount(x.Id, _storeContext.CurrentStore.Id) > 0)
.Select(x => new ProductTagModel
{
Id = x.Id,
Name = _localizationService.GetLocalized(x, y => y.Name),
SeName = _urlRecordService.GetSeName(x),
ProductCount = _productTagService.GetProductCount(x.Id, _storeContext.CurrentStore.Id)
})
.ToList());
return(model);
}
public void AddUpdateLuceneIndex(Product product)
{
var analyzer = new StandardAnalyzer(LuceneVersion.LUCENE_48);
var iwc = new IndexWriterConfig(LuceneVersion.LUCENE_48, analyzer);
iwc.OpenMode = OpenMode.CREATE_OR_APPEND;
var productTagNames = _productTagService.GetAllProductTagsByProductId(product.Id).Select(x => x.Name);
var productCategories = _categoryService.GetProductCategoriesByProductId(product.Id);
var categories = _categoryService.GetCategoriesByIds(productCategories.Select(x => x.CategoryId).ToArray());
var productManufacturers = _manufacturerService.GetProductManufacturersByProductId(product.Id);
var manufacturers = from m in _manufacturerService.GetAllManufacturers()
join pm in productManufacturers on m.Id equals pm.ManufacturerId
select m;
using (var writer = new IndexWriter(LuceneDirectory, iwc))
{
InternalAddToLuceneIndex(product, productTagNames, categories, manufacturers, writer);
writer.Dispose();
}
}
/// <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(nameof(product));
}
if (string.IsNullOrEmpty(newName))
{
throw new ArgumentException("Product name is required");
}
var productCopy = CopyBaseProductData(product, newName, isPublished);
//localization
CopyLocalizationData(product, productCopy);
//copy product tags
foreach (var productTag in _productTagService.GetAllProductTagsByProductId(product.Id))
{
_productTagService.InsertProductProductTagMapping(new ProductProductTagMapping {
ProductTagId = productTag.Id, ProductId = productCopy.Id
});
}
_productService.UpdateProduct(productCopy);
//copy product pictures
var originalNewPictureIdentifiers = CopyProductPictures(product, newName, copyImages, productCopy);
//quantity change history
_productService.AddStockQuantityHistoryEntry(productCopy, product.StockQuantity, product.StockQuantity, product.WarehouseId,
string.Format(_localizationService.GetResource("Admin.StockQuantityHistory.Messages.CopyProduct"), product.Id));
//product specifications
CopyProductSpecifications(product, productCopy);
//product <-> warehouses mappings
CopyWarehousesMapping(product, productCopy);
//product <-> categories mappings
CopyCategoriesMapping(product, productCopy);
//product <-> manufacturers mappings
CopyManufacturersMapping(product, productCopy);
//product <-> related products mappings
CopyRelatedProductsMapping(product, productCopy);
//product <-> cross sells mappings
CopyCrossSellsMapping(product, productCopy);
//product <-> attributes mappings
CopyAttributesMapping(product, productCopy, originalNewPictureIdentifiers);
//product <-> discounts mapping
CopyDiscountsMapping(product, productCopy);
//store mapping
var selectedStoreIds = _storeMappingService.GetStoresIdsWithAccess(product);
foreach (var id in selectedStoreIds)
{
_storeMappingService.InsertStoreMapping(productCopy, id);
}
//tier prices
CopyTierPrices(product, productCopy);
//update "HasTierPrices" and "HasDiscountsApplied" properties
_productService.UpdateHasTierPricesProperty(productCopy);
_productService.UpdateHasDiscountsApplied(productCopy);
//associated products
CopyAssociatedProducts(product, isPublished, copyImages, copyAssociatedProducts, productCopy);
return(productCopy);
}
private void UpdateProductTags(Product product, IReadOnlyCollection <string> productTags)
{
if (productTags == null)
{
return;
}
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
//Copied from UpdateProductTags method of ProductTagService
//product tags
var existingProductTags = _productTagService.GetAllProductTagsByProductId(product.Id);
var productTagsToRemove = new List <ProductTag>();
foreach (var existingProductTag in existingProductTags)
{
var found = false;
foreach (var newProductTag in productTags)
{
if (!existingProductTag.Name.Equals(newProductTag, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
found = true;
break;
}
if (!found)
{
productTagsToRemove.Add(existingProductTag);
}
}
foreach (var productTag in productTagsToRemove)
{
//product.ProductTags.Remove(productTag);
product.ProductProductTagMappings
.Remove(product.ProductProductTagMappings.FirstOrDefault(mapping => mapping.ProductTagId == productTag.Id));
_productService.UpdateProduct(product);
}
foreach (var productTagName in productTags)
{
ProductTag productTag;
var productTag2 = _productTagService.GetProductTagByName(productTagName);
if (productTag2 == null)
{
//add new product tag
productTag = new ProductTag
{
Name = productTagName
};
_productTagService.InsertProductTag(productTag);
}
else
{
productTag = productTag2;
}
if (!_productService.ProductTagExists(product, productTag.Id))
{
product.ProductProductTagMappings.Add(new ProductProductTagMapping {
ProductTag = productTag
});
_productService.UpdateProduct(product);
}
var seName = _urlRecordService.ValidateSeName(productTag, string.Empty, productTag.Name, true);
_urlRecordService.SaveSlug(productTag, seName, 0);
}
}
private void UpdateProductTags(Product product, IReadOnlyCollection <string> productTags)
{
if (productTags == null)
{
return;
}
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
var existingProductTags = _productTagService.GetAllProductTagsByProductId(product.Id);
var productTagsToRemove = new List <ProductTag>();
foreach (var existingProductTag in existingProductTags)
{
var found = false;
foreach (var newProductTag in productTags)
{
if (!existingProductTag.Name.Equals(newProductTag, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
found = true;
break;
}
if (!found)
{
productTagsToRemove.Add(existingProductTag);
}
}
try
{
this._productTagService.UpdateProductTags(product, productTagsToRemove.Select(o => o.Name).ToArray());
foreach (var productTagName in productTags)
{
ProductTag productTag;
var productTag2 = _productTagService.GetProductTagByName(productTagName);
if (productTag2 == null)
{
//add new product tag
productTag = new ProductTag
{
Name = productTagName
};
_productTagService.InsertProductTag(productTag);
}
else
{
productTag = productTag2;
}
var seName = _urlRecordService.ValidateSeName(productTag, string.Empty, productTag.Name, true);
_urlRecordService.SaveSlug(productTag, seName, 0);
//Perform a final check to deal with duplicates etc.
var currentProductTags = _productTagService.GetAllProductTagsByProductId(product.Id);
if (!currentProductTags.Any(o => o.Id == productTag.Id))
{
_productTagService.InsertProductProductTagMapping(new ProductProductTagMapping()
{
ProductId = product.Id,
ProductTagId = productTag.Id
});
}
}
}
catch (Exception ex)
{
throw;
}
}
/// <summary>
/// Prepare product model
/// </summary>
/// <param name="model">Product model</param>
/// <param name="product">Product</param>
/// <param name="excludeProperties">Whether to exclude populating of some properties of model</param>
/// <returns>Product model</returns>
public virtual ProductModel PrepareProductModel(ProductModel model, Product product, bool excludeProperties = false)
{
Action <ProductLocalizedModel, int> localizedModelConfiguration = null;
if (product != null)
{
//fill in model values from the entity
model = model ?? product.ToModel <ProductModel>();
var parentGroupedProduct = _productService.GetProductById(product.ParentGroupedProductId);
if (parentGroupedProduct != null)
{
model.AssociatedToProductId = product.ParentGroupedProductId;
model.AssociatedToProductName = parentGroupedProduct.Name;
}
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(product.CreatedOnUtc, DateTimeKind.Utc);
model.UpdatedOn = _dateTimeHelper.ConvertToUserTime(product.UpdatedOnUtc, DateTimeKind.Utc);
model.ProductTags = string.Join(", ", _productTagService.GetAllProductTagsByProductId(product.Id).Select(tag => tag.Name));
if (!excludeProperties)
{
model.SelectedCategoryIds = _categoryService.GetProductCategoriesByProductId(product.Id, true)
.Select(productCategory => productCategory.CategoryId).ToList();
}
//prepare copy product model
PrepareCopyProductModel(model.CopyProductModel, product);
//prepare nested search model
PrepareRelatedProductSearchModel(model.RelatedProductSearchModel, product);
PrepareAssociatedProductSearchModel(model.AssociatedProductSearchModel, product);
PrepareProductPictureSearchModel(model.ProductPictureSearchModel, product);
//define localized model configuration action
localizedModelConfiguration = (locale, languageId) =>
{
locale.Name = _localizationService.GetLocalized(product, entity => entity.Name, languageId, false, false);
locale.FullDescription = _localizationService.GetLocalized(product, entity => entity.FullDescription, languageId, false, false);
locale.ShortDescription = _localizationService.GetLocalized(product, entity => entity.ShortDescription, languageId, false, false);
locale.MetaKeywords = _localizationService.GetLocalized(product, entity => entity.MetaKeywords, languageId, false, false);
locale.MetaDescription = _localizationService.GetLocalized(product, entity => entity.MetaDescription, languageId, false, false);
locale.MetaTitle = _localizationService.GetLocalized(product, entity => entity.MetaTitle, languageId, false, false);
locale.SeName = _urlRecordService.GetSeName(product, languageId, false, false);
};
}
//set default values for the new model
if (product == null)
{
model.AllowCustomerReviews = true;
model.Published = true;
model.VisibleIndividually = true;
}
model.IsLoggedInAsVendor = _workContext.CurrentVendor != null;
//prepare localized models
if (!excludeProperties)
{
model.Locales = _localizedModelFactory.PrepareLocalizedModels(localizedModelConfiguration);
}
//prepare editor settings
model.ProductEditorSettingsModel = _settingModelFactory.PrepareProductEditorSettingsModel();
//prepare available product templates
_baseAdminModelFactory.PrepareProductTemplates(model.AvailableProductTemplates, false);
//prepare available product types
var productTemplates = _productTemplateService.GetAllProductTemplates();
foreach (var productType in Enum.GetValues(typeof(ProductType)).OfType <ProductType>())
{
model.ProductsTypesSupportedByProductTemplates.Add((int)productType, new List <SelectListItem>());
foreach (var template in productTemplates)
{
var list = (IList <int>)TypeDescriptor.GetConverter(typeof(List <int>)).ConvertFrom(template.IgnoredProductTypes) ?? new List <int>();
if (string.IsNullOrEmpty(template.IgnoredProductTypes) || !list.Contains((int)productType))
{
model.ProductsTypesSupportedByProductTemplates[(int)productType].Add(new SelectListItem
{
Text = template.Name,
Value = template.Id.ToString()
});
}
}
}
//prepare available vendors
_baseAdminModelFactory.PrepareVendors(model.AvailableVendors,
defaultItemText: _localizationService.GetResource("Admin.Catalog.Products.Fields.Vendor.None"));
//prepare model categories
_baseAdminModelFactory.PrepareCategories(model.AvailableCategories, false);
foreach (var categoryItem in model.AvailableCategories)
{
categoryItem.Selected = int.TryParse(categoryItem.Value, out var categoryId) &&
model.SelectedCategoryIds.Contains(categoryId);
}
//prepare model customer roles
_aclSupportedModelFactory.PrepareModelCustomerRoles(model, product, excludeProperties);
//prepare model stores
_storeMappingSupportedModelFactory.PrepareModelStores(model, product, excludeProperties);
return(model);
}