Blog posts by Calin Lupas2020-08-16T22:46:17.0000000Zhttps://world.optimizely.com/blogs/calin-lupas/Optimizely WorldEpiserver Commerce - Catalog Low-level APIs - Improve the performance when importing thousands of product variants in bulk<p>The proposed implementation aims to offer a solution for importing thousands of product variants in a performant way using catalog low-level APIs.</p>
<h2><span style="text-decoration: underline;">Introduction</span></h2>
<p>In our projects, we’ve built a connector between Dynamics 365 and Episerver to synchronize the online store and the published catalogs. The D365-Episerver connector, among other functionalities, has few Episerver scheduled jobs to import categories, products and variants from D365 into Episerver.</p>
<p>We are using the Catalog content APIs to synchronize and import catalogs, categories, products, variants, related entries, prices, inventories, images and more.</p>
<p>For one of the projects, we were facing a performance issue to import the catalog due to the number of variants that a product can have.</p>
<p>Some products have 100, 500, 1K, 2K, 3K, 4K, 5K, 6K and even 12+K variants for a total of ~ <span style="text-decoration: underline;">100 000 variants in the entire catalog</span>.</p>
<p>Using the Catalog content APIs for variants, the sync products job always failed with timeout exceptions and took in some cases more than 9 hours.</p>
<p>As you can imagine, we had to find a solution to import all these variants in a fast and performant way to reduce the synchronization time.</p>
<h2><span style="text-decoration: underline;">Solution</span></h2>
<p>Leverage Episerver Commerce - Catalog Low-level APIs to import thousands of product variants in bulk to minimize the synchronization and import time.</p>
<p><strong><span style="text-decoration: underline;">Sync a full online catalog from D365 into Episerver in less than 1.5h (25 categories, 83 products and 99 201 variants in 85 minutes)</span>.</strong></p>
<p><img src="/link/671beca56a5246efbdefd9a3a35cc78b.aspx" /></p>
<p>This blog post describes in detail the complete solution to import and bulk save thousands of variants using low-level APIs.</p>
<h2><span style="text-decoration: underline;">How it works</span></h2>
<p>An Episerver scheduled job “<em>Sync All Products from D365 into Episerver</em>” is syncing the published Catalogs of the Online Store from Dynamics 365 into Episerver. The sync includes the catalogs, the categories of each catalog, the products of each categories and the variants for each products.</p>
<p>The current solution describes the implementation we are using to bulk save product variants.</p>
<h2><span style="text-decoration: underline;">Implementation</span></h2>
<p>Let’s go into detail and explain the solution from a code implementation perspective. It consists of:</p>
<ol>
<li>The <strong>data models</strong> - <code>BaseDTO.cs</code> and <code>VariantDTO.cs</code></li>
<li>The <strong>service interface</strong> – <code>IVariantIntegrationService.cs</code></li>
<li>The <strong>service implementation</strong> – <code>VariantIntegrationService.cs</code></li>
<li>The <strong>scheduled job</strong> caller method - <code>D365SyncProductsScheduledJob.cs</code></li>
</ol>
<h3><span style="text-decoration: underline;">1. Data Models</span></h3>
<p>The base DTO model for all the sync models defines the base properties and a dictionary of key=value properties used to sync the content properties:</p>
<pre class="language-csharp"><code>public class BaseDTO
{
public int? Id { get; set; }
public string Code { get; set; }
public string Name { get; set; }
public string DisplayName { get; set; }
public string Description { get; set; }
public string Language { get; set; }
// The key is the property name
// The value is the property value
public Dictionary<string, object> Properties { get; set; }
public object SourceObject { get; set; }
public string GetJsonSourceObject()
{
if (SourceObject == null)
return string.Empty;
return JObject
.FromObject(SourceObject)
.ToString();
}
}</code></pre>
<p>The variant DTO model has the following properties:</p>
<pre class="language-csharp"><code>public class VariantDTO : BaseDTO
{
public WebCategory Category { get; set; }
public WebProduct Product { get; set; }
}</code></pre>
<p>The <code>WebCategory</code> and the <code>WebProduct</code> types are simply the catalog content types that we are using for the <code>NodeContent</code> and <code>ProductContent</code>.</p>
<p>The result DTO model has the following implementation:</p>
<pre class="language-csharp"><code>public class ResultModelDTO
{
private List<Exception> _exceptions = null;
public IEnumerable<Exception> Exceptions
{
get
{
if (_exceptions != null)
return _exceptions;
return Enumerable.Empty<Exception>();
}
}
public bool IsSuccess
{
get
{
return (_exceptions == null || !_exceptions.Any());
}
}
public bool IsFail => !IsSuccess;
public void AddException(Exception exc)
{
if (exc == null)
return;
_exceptions = _exceptions ?? new List<Exception>();
_exceptions.Add(exc);
}
public void AddError(string errorMessage)
{
AddException(new ApplicationException(errorMessage));
}
public void Fail(string errorMessage)
{
if (IsFail)
return;
AddException(new ApplicationException(errorMessage));
}
}
</code></pre>
<h3><span style="text-decoration: underline;">2. Service Interface - IVariantIntegrationService.cs</span></h3>
<p>We have an integration library that is responsible for importing data into Episerver Commerce using the Episerver APIs.</p>
<p>It acts as a wrapper library on top of the Episerver APIs and it is used by other libraries to accomplish our integration scenarios.</p>
<p>The variant interface defines the following method pertaining to bulk import variants (<em>the other methods exposed are not relevant to this solution</em>):</p>
<pre class="language-csharp"><code>public interface IVariantIntegrationService
{
...
ResultModelDTO SaveBulk(IList<VariantDTO> models);
...
}</code></pre>
<p><strong></strong></p>
<h3><span style="text-decoration: underline;">3. Service Implementation – VariantIntegrationService.cs</span></h3>
<p>The integration library contains a service implementation for the above variant interface and the save bulk method (<em>additional code not related to his solution has been removed</em>):</p>
<pre class="language-csharp"><code>public class VariantIntegrationService : IVariantIntegrationService
{
#region Members
private readonly CatalogMetaObjectRepository _catalogMetaObjectRepository;
private readonly int _batchSize = 1000;
private static readonly ILogger Logger = LogManager.GetLogger();
#endregion
#region Constructors
public VariantIntegrationService(
CatalogMetaObjectRepository catalogMetaObjectRepository
)
{
_catalogMetaObjectRepository = catalogMetaObjectRepository;
}
#endregion
#region IVariantIntegrationService
public ResultModelDTO SaveBulk(IList<VariantDTO> models)
{
var result = new ResultModelDTO();
var category = models.FirstOrDefault()?.Category;
var product = models.FirstOrDefault()?.Product;
if (category == null || product == null)
{
result.Fail("SaveBulk - Variants - Category or product models are empty.");
return result;
}
var catalogId = product.CatalogId;
var startDate = DateTime.UtcNow;
var endDate = DateTime.UtcNow.AddYears(10);
MetaClass mcsku = MetaClass.Load(CatalogContext.MetaDataContext, "WebVariant");
int skuMetaClassId = mcsku.Id;
var catalogContextCurrent = CatalogContext.Current;
var catalogDto = catalogContextCurrent.GetCatalogDto(catalogId, new CatalogResponseGroup(CatalogResponseGroup.ResponseGroup.CatalogInfo));
if (catalogDto.Catalog.Count > 0)
{
var productEntry = catalogContextCurrent.GetCatalogEntryDto(product.Code, new CatalogEntryResponseGroup(CatalogEntryResponseGroup.ResponseGroup.Variations));
if (productEntry == null || productEntry.CatalogEntry.Count == 0)
{
result.Fail("SaveBulk - Variants - Product entry is empty.");
return result;
}
// Step 1: Create all variants
foreach (var variantDto in models)
{
var variantEntryRow = productEntry.CatalogEntry.FirstOrDefault(i => i.Code == variantDto.Code);
if (variantEntryRow == null)
{
var variantCatalogEntryDto = catalogContextCurrent.GetCatalogEntryDto(variantDto.Code);
variantEntryRow = (variantCatalogEntryDto.CatalogEntry != null && variantCatalogEntryDto.CatalogEntry.Count > 0)
? variantCatalogEntryDto.CatalogEntry[0]
: null;
}
if (variantEntryRow == null)
{
variantEntryRow = productEntry.CatalogEntry.NewCatalogEntryRow();
variantEntryRow.CatalogId = catalogId;
variantEntryRow.ClassTypeId = "Variation";
variantEntryRow.Code = variantDto.Code;
variantEntryRow.MetaClassId = skuMetaClassId;
variantEntryRow.IsActive = true;
variantEntryRow.Name = variantDto.Name;
variantEntryRow.StartDate = startDate;
variantEntryRow.EndDate = endDate;
if (variantEntryRow.RowState == DataRowState.Detached)
productEntry.CatalogEntry.AddCatalogEntryRow(variantEntryRow);
var newVariationRow = productEntry.Variation.NewVariationRow();
newVariationRow.SetMerchantIdNull();
newVariationRow.SetListPriceNull();
newVariationRow.TaxCategoryId = 0;
newVariationRow.TrackInventory = false;
newVariationRow.PackageId = 0;
newVariationRow.WarehouseId = 0;
newVariationRow.Weight = 0;
newVariationRow.Height = 0;
newVariationRow.Length = 0;
newVariationRow.Width = 0;
newVariationRow.MinQuantity = 0;
newVariationRow.MaxQuantity = 0;
newVariationRow.CatalogEntryId = variantEntryRow.CatalogEntryId;
if (newVariationRow.RowState == DataRowState.Detached)
productEntry.Variation.AddVariationRow(newVariationRow);
}
else
{
variantEntryRow.IsActive = true;
variantEntryRow.Name = variantDto.Name;
variantEntryRow.StartDate = startDate;
variantEntryRow.EndDate = endDate;
}
variantDto.Id = variantEntryRow.CatalogEntryId;
}
// Step 2 : Save product variants changes
try
{
if (productEntry.HasChanges())
SaveCatalogEntryDtoByBatch(productEntry);
// Once saved by batches, set the variantDto.Id
if (productEntry.CatalogEntry.Count > _batchSize
|| models.Any(i => !i.Id.HasValue || i.Id.GetValueOrDefault() <= 0))
{
productEntry = catalogContextCurrent.GetCatalogEntryDto(product.Code, new CatalogEntryResponseGroup(CatalogEntryResponseGroup.ResponseGroup.Variations));
Parallel.ForEach(models.Where(i => !i.Id.HasValue || i.Id.GetValueOrDefault() <= 0), variantDto =>
{
variantDto.Id = productEntry.CatalogEntry.FirstOrDefault(i => i.Code == variantDto.Code)?.CatalogEntryId;
if (!variantDto.Id.HasValue)
{
variantDto.Id = catalogContextCurrent.GetCatalogEntryDto(variantDto.Code)?.CatalogEntry[0]?.CatalogEntryId;
}
});
}
}
catch (Exception ex)
{
var error = $"VariantIntegrationService - Save Bulk - Error when saving product entry with code = {product.Code}";
Logger.Error(error, ex);
result.AddError($"{error} : {ex.Message}");
return result;
}
// Step 3: Save variant properties (meta objects)
var language = product.Language.Name;
var identityName = Thread.CurrentPrincipal.Identity != null ? Thread.CurrentPrincipal.Identity.Name : string.Empty;
var metaDataContext = CreateMetaDataContext(language);
var variantMetaObjects = new List<MetaObject>();
foreach (var variantDto in models)
{
if (!variantDto.Id.HasValue)
continue;
var metaObject = _catalogMetaObjectRepository.Load(variantDto.Id.Value, skuMetaClassId, language, ReadMode.UnCached);
if (metaObject == null)
{
metaObject = new MetaObject(mcsku, variantDto.Id.Value)
{
CreatorId = identityName,
ModifierId = identityName
};
}
metaObject["DisplayName"] = variantDto.DisplayName;
metaObject["Description"] = variantDto.Description;
metaObject["JsonSourceData"] = variantDto.GetJsonSourceObject();
metaObject["Epi_IsPublished"] = true;
metaObject["Epi_StartPublish"] = startDate;
metaObject["Epi_StopPublish"] = endDate;
metaObject.SetProperties(variantDto);
variantMetaObjects.Add(metaObject);
}
try
{
SaveCatalogMetaObjectsByBatch(language, variantMetaObjects);
}
catch (Exception ex)
{
Logger.Error($"VariantIntegrationService - Save Bulk - Error when saving meta objects for product code = {product.Code}: ", ex);
// Update meta object 1 by 1
foreach (var metaObject in variantMetaObjects)
{
try
{
_catalogMetaObjectRepository.Update(metaObject, language);
}
catch (Exception exc)
{
var error = $"VariantIntegrationService - Save Bulk - Error when saving meta object for product code = {product.Code}";
Logger.Error(error, exc);
result.AddError($"{error} : {exc.Message}");
return result;
}
}
}
// Step 4: Create all relations (variant - category AND product - variant)
var categoryEntry = catalogContextCurrent.GetCatalogNodeDto(category.Code);
if (categoryEntry == null || categoryEntry.CatalogNode.Count == 0)
{
result.Fail("SaveBulk - Variants - Category entry is empty.");
return result;
}
var categoryRelation = catalogContextCurrent.GetCatalogRelationDto(catalogId,
categoryEntry.CatalogNode[0].CatalogNodeId, 0, "",
new CatalogRelationResponseGroup(CatalogRelationResponseGroup.ResponseGroup.NodeEntry));
var productRelation = catalogContextCurrent.GetCatalogRelationDto(catalogId,
categoryEntry.CatalogNode[0].CatalogNodeId, productEntry.CatalogEntry[0].CatalogEntryId, "",
new CatalogRelationResponseGroup(CatalogRelationResponseGroup.ResponseGroup.CatalogEntry));
foreach (var variantDto in models)
{
if (!variantDto.Id.HasValue || variantDto.Id.GetValueOrDefault() <= 0)
continue;
// Variant - Category
var variantNodeEntryRelationRow = categoryRelation.NodeEntryRelation.FirstOrDefault(i => i.CatalogEntryId == variantDto.Id);
if (variantNodeEntryRelationRow == null)
{
var variantRelation = catalogContextCurrent.GetCatalogRelationDto(variantDto.Id.Value);
variantNodeEntryRelationRow = variantRelation.NodeEntryRelation.FirstOrDefault(i => i.IsPrimary);
}
if (variantNodeEntryRelationRow == null)
{
variantNodeEntryRelationRow = categoryRelation.NodeEntryRelation.NewNodeEntryRelationRow();
variantNodeEntryRelationRow.CatalogId = catalogId;
variantNodeEntryRelationRow.CatalogEntryId = variantDto.Id.Value;
variantNodeEntryRelationRow.CatalogNodeId = categoryEntry.CatalogNode[0].CatalogNodeId;
variantNodeEntryRelationRow.IsPrimary = true;
variantNodeEntryRelationRow.SortOrder = 0;
if (variantNodeEntryRelationRow.RowState == DataRowState.Detached)
categoryRelation.NodeEntryRelation.AddNodeEntryRelationRow(variantNodeEntryRelationRow);
}
else
{
variantNodeEntryRelationRow.CatalogId = catalogId;
variantNodeEntryRelationRow.CatalogEntryId = variantDto.Id.Value;
variantNodeEntryRelationRow.CatalogNodeId = categoryEntry.CatalogNode[0].CatalogNodeId;
variantNodeEntryRelationRow.IsPrimary = true;
variantNodeEntryRelationRow.SortOrder = 0;
}
// Product - Variant
var variantCatalogEntryRelationRow = productRelation.CatalogEntryRelation.FirstOrDefault(i => i.ChildEntryId == variantDto.Id);
if (variantCatalogEntryRelationRow == null)
{
variantCatalogEntryRelationRow = productRelation.CatalogEntryRelation.NewCatalogEntryRelationRow();
variantCatalogEntryRelationRow.ChildEntryId = variantDto.Id.Value;
variantCatalogEntryRelationRow.ParentEntryId = productEntry.CatalogEntry[0].CatalogEntryId;
variantCatalogEntryRelationRow.RelationTypeId = "ProductVariation";
variantCatalogEntryRelationRow.Quantity = 1;
variantCatalogEntryRelationRow.GroupName = "Default";
variantCatalogEntryRelationRow.SortOrder = 0;
if (variantCatalogEntryRelationRow.RowState == DataRowState.Detached)
productRelation.CatalogEntryRelation.AddCatalogEntryRelationRow(variantCatalogEntryRelationRow);
}
}
// Step 5: Save all relation changes
try
{
if (productRelation.HasChanges())
catalogContextCurrent.SaveCatalogRelationDto(productRelation);
}
catch (Exception ex)
{
var error = $"VariantIntegrationService - Save Bulk - Error when saving product relations for product code = {product.Code}";
Logger.Error(error, ex);
result.AddError($"{error} : {ex.Message}");
return result;
}
try
{
if (categoryRelation.HasChanges())
catalogContextCurrent.SaveCatalogRelationDto(categoryRelation);
}
catch (Exception ex)
{
var error = $"VariantIntegrationService - Save Bulk - Error when saving category relations for product code = {product.Code}";
Logger.Error(error, ex);
result.AddError($"{error} : {ex.Message}");
return result;
}
}
return result;
}
#endregion
#region Private Methods
private void SaveCatalogEntryDtoByBatch(CatalogEntryDto dto)
{
if (dto.CatalogEntry.Count <= _batchSize)
{
CatalogContext.Current.SaveCatalogEntry(dto);
}
else
{
int index = 0;
var newDto = new CatalogEntryDto();
foreach (var catalogEntryRow in dto.CatalogEntry)
{
newDto.CatalogEntry.ImportRow(catalogEntryRow);
foreach (var catalogItemSeoRow in catalogEntryRow.GetCatalogItemSeoRows())
newDto.CatalogItemSeo.ImportRow(catalogItemSeoRow);
++index;
if (index % _batchSize == 0)
{
CatalogContext.Current.SaveCatalogEntry(newDto);
newDto = new CatalogEntryDto();
}
}
CatalogContext.Current.SaveCatalogEntry(newDto);
}
}
private void SaveCatalogMetaObjectsByBatch(string language, IList<MetaObject> metaObjects)
{
var skip = 0;
while (skip < metaObjects.Count)
{
var variantMetaObjects = metaObjects.Skip(skip).Take(_batchSize).ToList();
// Save batch meta objects
_catalogMetaObjectRepository.UpdateBatch(new Dictionary<string, IEnumerable<MetaObject>>()
{
{ language, variantMetaObjects }
}, true);
skip += variantMetaObjects.Count;
}
}
private MetaDataContext CreateMetaDataContext(string language)
{
MetaDataContext metaDataContext = CatalogContext.MetaDataContext.Clone();
metaDataContext.UseCurrentThreadCulture = false;
metaDataContext.Language = language;
return metaDataContext;
}
#endregion
}</code></pre>
<p>The extension class to set the properties on the variant <code>MetaObject</code>:</p>
<pre class="language-csharp"><code>public static class ModelsExtensions
{
public static void SetProperties(this MetaObject metaObject, BaseDTO model)
{
if (model == null || model.Properties == null)
return;
var values = metaObject.GetValues();
foreach (var property in model.Properties)
{
if (!values.ContainsKey(property.Key))
continue;
metaObject.SetMetaField(property.Key, property.Value);
}
}
}
</code></pre>
<p>Brief description of the above implementation:</p>
<ul>
<li><strong>Step 1</strong>: <strong>Create all the variants</strong>
<ul>
<li>Using the <code>CatalogEntryDto</code> of the product we find the existing variant or we create a new catalog entry using <code>productEntry.CatalogEntry.NewCatalogEntryRow()</code> method and a new variant entry using <code>productEntry.Variation.NewVariationRow()</code></li>
<li>When creating a new variation row it is important to set the default values<br /><br /></li>
</ul>
</li>
<li><strong>Step 2 : Save product variants changes</strong>
<ul>
<li>If the product entry has changes, then save the changes by batches using <code>SaveCatalogEntryDtoByBatch(productEntry)</code></li>
<li>Once saved by batches, initialize the <code>variantDto.Id</code> as it will be needed later on to save the variant properties<br /><br /></li>
</ul>
</li>
<li><strong>Step 3: Save variant properties (meta objects)</strong>
<ul>
<li>Get the <code>MetaClass</code> of the <code>WebVariant</code> type using the <code>MetaClass.Load()</code></li>
<li>Initialize a meta data context: <code>CreateMetaDataContext(language)</code></li>
<li>Using the <code>CatalogMetaObjectRepository</code> repository, for each variant load or create the <code>MetaObject</code> and save the properties.</li>
<li>Use an extension methods to save all properties from the dictionary to the meta object: <code>metaObject.SetProperties(variantDto);</code></li>
<li>Save catalog meta objects by batch<br /><br /></li>
</ul>
</li>
<li><strong>Step 4: Create all the relations (variant - category AND product - variant)</strong>
<ul>
<li>A variant belongs to a category and has a <code>NodeEntryRelation</code> with a category</li>
<li>A variant is related to a product and has a <code>CatalogEntryRelation</code> with the product</li>
<li>For each variant, build the variant-category relation and product-variant relation using the <code>GetCatalogRelationDto()</code>, <code>categoryRelation.NodeEntryRelation.NewNodeEntryRelationRow()</code> and the <code>productRelation.CatalogEntryRelation.NewCatalogEntryRelationRow()</code> methods<br /><br /></li>
</ul>
</li>
<li><strong>Step 5: Save all relation changes</strong>
<ul>
<li>If there are product and category relations, use the <code>SaveCatalogRelationDto()</code> to save the changes<br /><br /></li>
</ul>
</li>
<li><strong>Return the result model</strong>
<ul>
<li>During the entire process of importing the variants, if there are any errors or exceptions, these are logged and captured in the <code>ResultModelDTO.cs</code> to be returned to the upper calling layers.</li>
</ul>
</li>
</ul>
<h3><span style="text-decoration: underline;">4. The scheduled job caller method - D365SyncProductsScheduledJob.cs</span></h3>
<p>The variant integration service is called during the <code>InternalExecute()</code> method of the scheduled job to sync all products from D365 into Episerver.</p>
<p>A snippet of the pseudo code that is triggering the save bulk variants implementation:</p>
<pre class="language-csharp"><code>private async Task<D365SyncResultModel> SyncProductsInternal(IList<ProductModel> products)
{
…
foreach (var product in products)
{
// Get product variants
var productWithVariants = await syncService.GetProductById(channelId, catalogId, catalogName, product.RecordId);
product.Variants = productWithVariants.Variants.ToList();
// Create product dto and variant dtos
var productDto = ToProductDto(product, language, webCategory);
var resultModelSaveProductDto = SaveProductDto(productDto);
…
// Bulk save variants
if (productDto.Variants.Count > 0)
{
var resultModelSaveVariantDtos = SaveVariantDtos(productDto.Variants);
resultModel.AddExceptions(resultModelSaveVariantDtos.Exceptions);
// Fallback to individual save variant (1 by 1)
if (!resultModelSaveVariantDtos.IsSuccess)
{
ChangeStatus($"Bulk Sync {productDto.Variants.Count} Variants for product code {resultModelSaveProductDto.Model.Code} - Failed. Sync variants 1 by 1 will take a while...", true);
Parallel.ForEach(productDto.Variants, variantDto =>
{
SaveVariantDto(variantDto);
});
}
}
}
…
}
private ResultModel SaveVariantDtos(IList<VariantDTO> dtos)
{
var resultModel = new ResultModel<ResultModelDTO>();
try
{
resultModel.Model = _variantIntegrationService.SaveBulk(dtos);
if (resultModel.Model.IsFail)
LogError(new ApplicationException($"Product {dtos.First().Product.Code} variants not saved successfully. See logs for error details."), resultModel);
resultModel.AddExceptions(resultModel.Model.Exceptions);
}
catch (Exception exc)
{
LogError(new ApplicationException($"Product {dtos.First().Product.Code} variants not saved successfully. An exception error has been logged!", exc), resultModel);
}
return resultModel;
}
</code></pre>
<p>We build a list of products and variants DTOs that we save in bulk and if it fails we fallback to the Catalog content APIs to save the variants one by one.</p>
<p>The <code>ToProductDto()</code> converts the <code>ProductModel</code> we have from our <code>SyncService.cs</code> into a DTO model used to import the Product content into Episerver:</p>
<pre class="language-csharp"><code>private ProductDTO ToProductDto(ProductModel product, string language, WebCategory webCategory, bool skipProperties = false)
{
var productDto = new ProductDTO()
{
CatalogName = product.CatalogName,
Category = webCategory,
Code = product.GetCode(),
Language = language,
SourceObject = !skipProperties
? product.SourceObject
: null
};
var propertyMapper = new D365PropertyMapper(D365Settings.RetailServerSelectDefaultValue, language);
productDto.Name = GetProductName(product, language);
productDto.DisplayName = propertyMapper.GetPropertyValue(product?.ProductProperties, "Description") ?? productDto.Name;
productDto.Description = propertyMapper.GetPropertyValue(product?.ProductProperties, "ProductDescription");
productDto.Properties = propertyMapper.MapProperties(product, language);
productDto.Variants = product.Variants?.Select(variant =>
{
var variantDto = !skipProperties
? ToVariantDto(product, variant, language)
: ToVariantDtoImages(product, variant, language);
variantDto.Category = productDto.Category;
variantDto.ProductName = productDto.Name;
return variantDto;
}).ToList() ?? new List<VariantDTO>();
return productDto;
}
</code></pre>
<p>The <code>ToVariantDto()</code> converts the <code>ProductVariantModel</code> into a DTO model used to import the Variation content into Episerver:</p>
<pre class="language-csharp"><code>private VariantDTO ToVariantDto(ProductModel product, ProductVariantModel variant, string language, bool skipProperties = false)
{
var variantName = GetVariantName(variant, language);
var variantDto = new VariantDTO()
{
CatalogName = product.CatalogName,
Code = variant.GetCode(),
Name = variantName,
DisplayName = variantName,
Language = language,
SourceObject = variant.SourceObject
};
if (skipProperties)
return variantDto;
var propertyMapper = new D365PropertyMapper(D365Settings.RetailServerSelectDefaultValue, language);
variantDto.Properties = propertyMapper.MapProperties(variant, language);
return variantDto;
}
</code></pre>
<p>Due to the number of variants under a product, we also setup the following property in the configuration file:</p>
<pre class="language-markup"><code><add key="SimplifiedCatalogListingThreshold" value="100000" /></code></pre>
<h2><span style="text-decoration: underline;">Conclusion</span></h2>
<p>As mentioned in Episerver Commerce documentation, the recommended approach of working with the catalog is using the Catalog content APIs. We are using these APIs for importing the catalog, categories, products, relations and more.</p>
<p>However, in specific scenarios, like ours, the Episerver Commerce low-level APIs are useful for working with the Catalog.</p>
<p>It allowed us to reduce significantly the synchronization time and to <strong><span style="text-decoration: underline;">sync a full catalog with 85 products and ~ 100 000 variants in less than 1.5h</span></strong>.</p>
<p>I hope it will help you too when importing large catalogs like in our use case!</p>
<p> </p>
<p>The Episerver Commerce low-level APIs are described here: <a href="/link/f3d3cfcf60be45b4be2bbcefdea47816.aspx">https://world.episerver.com/documentation/developer-guides/commerce/catalogs/low-level-apis/</a></p>
<p> </p>
<p>I hope you enjoyed the reading and the proposed solution. Looking forward to your feedback! Thank you!</p>2020-08-16T22:46:17.0000000ZBlog postConfigurable Episerver Find Facets<p>The proposed solution aims to offer an easy way for content editors to dynamically change the Find facet filters and proposes full flexibly on the filters used to narrow down the search results and guide the user experience in finding the right products.</p>
<h2><span style="text-decoration: underline;">Introduction</span></h2>
<p>Searching and finding the product you want to buy is a key feature for an E-commerce solution. Having the flexibility to narrow down search results based on different criteria improves the user experience and facilitates the finding of the product that the customer is looking for.</p>
<p>Episerver Find facets allow us to group search results based on specific terms, price ranges and other criteria that we can establish based on the project requirements.</p>
<p>During the design phase of the project we establish the product attributes and the facets we want to filter the search results with the client. We end-up with a list of facets displayed as filter criteria on the search results page or on the category landing page.</p>
<p>We often hard-code the facets configuration (what facets, the display order, the display type, the numeric ranges, etc.) based on the initial design we agreed with the client.</p>
<p>What if, after we go live, the client wants to add more facets, change the facets order, add new numeric ranges or even remove some existing facets? We will need to change the code, test and redeploy the hotfix into Production.</p>
<p>Would it be nice to allow CMS editors or administrators to configure the Find facets dynamically from Episerver CMS Start page?</p>
<h2><span style="text-decoration: underline;">Solution</span></h2>
<p>Implement a solution that allows dynamic configuration of Find facets by CMS content editors.</p>
<p>This blog post will describe in detail the solution to dynamically configure the Find facets.</p>
<p>The code is part of Episerver Foundation and can be found here: <a href="https://github.com/episerver/Foundation">https://github.com/episerver/Foundation</a></p>
<p><img src="/link/1a18ceb2a8524adc9bb4606899d4bf36.aspx" /></p>
<h2><span style="text-decoration: underline;">How it works?</span></h2>
<p>Episerver Foundation defines by default in code the following facets: Price, Brand, Size and Color and registers them as facets to be displayed on the search results page and be used by the Find engine:</p>
<p><img src="/link/6e6b7c742dbc414f8249170979128a38.aspx" /></p>
<p>In Episerver <em>CMS > Home page</em>, under <em>Search settings</em> tab, we’ve added a new field called “<em>Search Filters Configuration</em>” that allows content editors to dynamically define and configure the facets displayed on the search results page:</p>
<p><img src="/link/24b795d1336d4e909e843e6cbe282c1f.aspx" /></p>
<p>Content editors can add, remove and move up/down the filters to reorder them, change the numeric ranges, display mode and direction, exclude specific values or display only specific values.</p>
<p><img src="/link/9f3b196bc5a14c64a34882d76b3c3005.aspx" /></p>
<p>As a result, after we save the search filters configuration and publish the Home page, the new facets will be displayed on the search results page:<br /><br /></p>
<p><img src="/link/4e6daf24c4a24799b6ada48753501b0f.aspx" /></p>
<h2><span style="text-decoration: underline;">Implementation</span></h2>
<p>Let’s go into the detail and explain the solution from a code implementation perspective.</p>
<p>The solution consists of <span style="text-decoration: underline;">3 main steps</span>:</p>
<ol>
<li>Define the <strong>facet configuration model</strong> and include it in the Home page as a new property list.</li>
<li>Implement the <strong>facet configuration factory</strong> that will transform the configuration model into a facet definition and provide the list of facet filters.</li>
<li>Configure the <strong>facet configuration initialization</strong> and registration of all the facet definitions.</li>
</ol>
<h3><span style="text-decoration: underline;">1. Facet Configuration Model</span></h3>
<p>We first need to define an interface <code>IFacetConfiguration.cs </code>that will contain the definition of the new search configuration field:</p>
<pre class="language-csharp"><code>public interface IFacetConfiguration
{
IList<FacetFilterConfigurationItem> SearchFiltersConfiguration { get; set; }
}</code></pre>
<p>We implement this interface in the <code>DemoHomePage.cs</code> page and define the new field as follows:</p>
<p><code></code></p>
<p><code></code></p>
<pre class="language-csharp"><code>public class DemoHomePage : CommerceHomePage, IFacetConfiguration
{
…
#region Search Settings
…
[Display(
Name = "Search Filters Configuration",
Description = "Manage filters to be displayed on Search",
GroupName = CommerceTabNames.SearchSettings,
Order = 300)]
[EditorDescriptor(EditorDescriptorType = typeof(IgnoreCollectionEditorDescriptor<FacetFilterConfigurationItem>))]
public virtual IList<FacetFilterConfigurationItem> SearchFiltersConfiguration { get; set; }
#endregion
}</code></pre>
<p><code></code></p>
<p>Since we use a list of facet configuration items, we have implemented a custom <code>PropertyListBase.cs</code> and defined our own configuration property:</p>
<p><code></code></p>
<pre class="language-csharp"><code>[PropertyDefinitionTypePlugIn]
public class FacetFilterConfigurationProperty : PropertyListBase<FacetFilterConfigurationItem>
{
}</code></pre>
<p><code></code><code></code></p>
<p><code></code></p>
<p>The new model <code>FacetFilterConfigurationItem.cs </code>contains all the properties needed to allow the facet definition and the customization of the search filters.</p>
<ul>
<li><strong>Attribute as Filter</strong> (FieldName)
<ul>
<li>The name of the field indexed by Find; Attribute to be used as a filter</li>
</ul>
</li>
<li><strong>Display Name</strong> (DisplayName)
<ul>
<li>Display name for filter group</li>
</ul>
</li>
<li><strong>Filter Type</strong> (FieldType)
<ul>
<li>Data type of the attribute</li>
</ul>
</li>
<li><strong>Display Mode</strong> (DisplayMode)
<ul>
<li>How the values of the filter are displayed</li>
</ul>
</li>
<li><strong>Display Direction</strong> (DisplayDirection)
<ul>
<li>The direction of the facet option values: vertical or horizontal</li>
</ul>
</li>
<li><strong>Numeric Ranges</strong> <strong>(From-To)</strong> (NumericRanges)
<ul>
<li>Set of ranges based on field type in format: from-to, from- and -to</li>
</ul>
</li>
<li><strong>Exclude Flag Attributes</strong> <strong>or Specific Values</strong> (ExcludeFlagFields)
<ul>
<li>Exclude specific attributes from Flags or specific values of an attribute</li>
</ul>
</li>
<li><strong>Display Specific Values</strong> (DisplaySpecificValues)
<ul>
<li>Display only specific values of the facet</li>
</ul>
</li>
</ul>
<p><code></code></p>
<pre class="language-csharp"><code> public class FacetFilterConfigurationItem
{
public FacetFilterConfigurationItem()
{
FieldType = FacetFieldType.String.ToString();
DisplayMode = FacetDisplayMode.Checkbox.ToString();
DisplayDirection = FacetDisplayDirection.Vertical.ToString();
}
[Display(
Name = "Attribute as Filter (required)",
Description = "Attribute to be used as a filter",
Order = 1)]
[Required]
public virtual string FieldName { get; set; }
[Display(
Name = "Display Name",
Description = "Display name for filter in English")]
public virtual string DisplayNameEN { get; set; }
[Display(
Name = "Display Name (FR)",
Description = "Display name for filter in French")]
[Ignore]
[ScaffoldColumn(false)]
public virtual string DisplayNameFR { get; set; }
[Display(
Name = "Filter Type (required)",
Description = "Data type of attribute")]
[SelectOneEnum(typeof(FacetFieldType))]
[DefaultValue(FacetFieldType.String)]
[Required]
public virtual string FieldType { get; set; }
[Display(
Name = "Display Mode (required)",
Description = "How the values of the filter are displayed")]
[SelectOneEnum(typeof(FacetDisplayMode))]
[DefaultValue(FacetDisplayMode.Button)]
[Required]
public virtual string DisplayMode { get; set; }
[Display(
Name = "Display direction (optional)",
Description = "Only applies to color swatch and size swatch.")]
[SelectOneEnum(typeof(FacetDisplayDirection))]
[DefaultValue(FacetDisplayDirection.Vertical)]
public virtual string DisplayDirection { get; set; }
[Display(
Name = "Numeric Ranges (From-To)",
Description = "Set ranges based on field type in format: from-to, from- and -to.")]
[ItemRegularExpression("[0-9]*\\.?[0-9]*-[0-9]*\\.?[0-9]*")]
public virtual IList<string> NumericRanges { get; set; }
[Display(
Name = "Exclude Flag Attributes or Specific Values",
Description = "Used to exclude specific attributes from Flags or specific values of an attribute")]
public virtual IList<string> ExcludeFlagFields { get; set; }
[Display(
Name = "Display Specific Values",
Description = "Used to display specific values of an Attribute as Filter: e.g. Brand. Must be exact match to value of attribute.")]
public virtual IList<string> DisplaySpecificValues { get; set; }
}</code></pre>
<p><code></code></p>
<p>To ease the definition of the facet configuration item, we’ve create the following enumerations within <code>FacetEnums.cs</code>:</p>
<ul>
<li><code>FacetFieldType</code></li>
<li><code>FacetDisplayMode</code></li>
<li><code>FacetDisplayDirection</code></li>
</ul>
<pre class="language-csharp"><code> public enum FacetFieldType
{
[EnumSelectionDescription(Text = "String", Value = "String")]
String = 1,
[EnumSelectionDescription(Text = "List of String", Value = "ListOfString")]
ListOfString,
[EnumSelectionDescription(Text = "Integer", Value = "Integer")]
Integer,
[EnumSelectionDescription(Text = "2 Decimal Places", Value = "Double")]
Double,
[EnumSelectionDescription(Text = "Boolean", Value = "Boolean")]
Boolean,
[EnumSelectionDescription(Text = "Enhanced Boolean", Value = "NullableBoolean")]
NullableBoolean
}
public enum FacetDisplayMode
{
[EnumSelectionDescription(Text = "Checkbox", Value = "Checkbox")]
Checkbox = 1,
[EnumSelectionDescription(Text = "Button", Value = "Button")]
Button,
[EnumSelectionDescription(Text = "Color Swatch", Value = "ColorSwatch")]
ColorSwatch,
[EnumSelectionDescription(Text = "Size Swatch", Value = "SizeSwatch")]
SizeSwatch,
[EnumSelectionDescription(Text = "Numeric Range", Value = "Range")]
Range,
[EnumSelectionDescription(Text = "Rating", Value = "Rating")]
Rating,
[EnumSelectionDescription(Text = "Slider", Value = "Slider")]
Slider,
[EnumSelectionDescription(Text = "Price Range", Value = "PriceRange")]
PriceRange,
}
public enum FacetDisplayDirection
{
[EnumSelectionDescription(Text = "Vertical", Value = "Vertical")]
Vertical = 1,
[EnumSelectionDescription(Text = "Horizontal", Value = "Horizontal")]
Horizontal
}</code></pre>
<p><code></code></p>
<p>To allow the selection of one option from these listings we created <code>SelectOneEnumAttribute.cs</code> and apply it to the property as follows:</p>
<pre class="language-csharp"><code> [Display(
Name = "Filter Type (required)",
Description = "Data type of attribute")]
[SelectOneEnum(typeof(FacetFieldType))]
[DefaultValue(FacetFieldType.String)]
[Required]
public virtual string FieldType { get; set; }</code></pre>
<p><code></code></p>
<p>The <code>SelectOneEnumAttribute.cs</code> attribute will allow editors to select a value of the enumeration:</p>
<p><code></code></p>
<pre class="language-csharp"><code> public class SelectOneEnumAttribute : SelectOneAttribute, IMetadataAware
{
public SelectOneEnumAttribute(Type enumType)
{
EnumType = enumType;
}
public Type EnumType { get; set; }
public new void OnMetadataCreated(ModelMetadata metadata)
{
var enumType = metadata.ModelType;
SelectionFactoryType = typeof(EnumSelectionFactory<>).MakeGenericType(EnumType);
base.OnMetadataCreated(metadata);
}
}</code></pre>
<p><code></code></p>
<p>Until now we defined the new search configuration property under the home page and added all the necessary code to allow content editors to define and configure the facets:</p>
<p><img src="/link/6985163c9a704a378022f12252cd0ac8.aspx" /></p>
<p>The next steps will be to define the facet configuration factory.</p>
<h3><span style="text-decoration: underline;">2. Facet Configuration Factory</span></h3>
<p>The facet configuration factory will transform the configuration model into a facet definition and provide the list of facet configuration items.</p>
<p>The interface <code>IFacetConfigFactory.cs</code> defines 3 methods:</p>
<ul>
<li><code><em>GetDefaultFacetDefinitions</em>()</code> – returns the default facet definitions: Price, Brand, Size and Color.</li>
<li><code><em>GetFacetFilterConfigurationItems</em>()</code> – returns the list of facet configuration models that are configured on the start page.</li>
<li><code><em>GetFacetDefinition</em>()</code> – converts a facet configuration model into a facet definition that is used by the Find search service implementation.</li>
</ul>
<pre class="language-csharp"><code> public interface IFacetConfigFactory
{
List<FacetDefinition> GetDefaultFacetDefinitions();
List<FacetFilterConfigurationItem> GetFacetFilterConfigurationItems();
FacetDefinition GetFacetDefinition(FacetFilterConfigurationItem facetConfiguration);
}</code></pre>
<p>The <code>FacetConfigFactory.cs</code> is default implementation of this interface and implements the methods as follow:</p>
<pre class="language-csharp"><code> public class FacetConfigFactory : IFacetConfigFactory
{
private readonly IContentLoader _contentLoader;
public FacetConfigFactory(IContentLoader contentLoader)
{
_contentLoader = contentLoader;
}
public virtual List<FacetDefinition> GetDefaultFacetDefinitions()
{
return new List<FacetDefinition>();
}
public virtual FacetDefinition GetFacetDefinition(FacetFilterConfigurationItem facetConfiguration)
{
switch (Enum.Parse(typeof(FacetFieldType), facetConfiguration.FieldType))
{
case FacetFieldType.String:
return new FacetStringDefinition
{
FieldName = facetConfiguration.FieldName,
DisplayName = facetConfiguration.GetDisplayName()
};
case FacetFieldType.ListOfString:
return new FacetStringListDefinition
{
FieldName = facetConfiguration.FieldName,
DisplayName = facetConfiguration.GetDisplayName()
};
case FacetFieldType.Boolean:
case FacetFieldType.NullableBoolean:
return new FacetStringListDefinition
{
FieldName = facetConfiguration.FieldName,
DisplayName = facetConfiguration.GetDisplayName(),
};
}
return new FacetStringDefinition
{
FieldName = facetConfiguration.FieldName,
DisplayName = facetConfiguration.GetDisplayName(),
};
}
public List<FacetFilterConfigurationItem> GetFacetFilterConfigurationItems()
{
if (ContentReference.IsNullOrEmpty(ContentReference.StartPage))
{
return new List<FacetFilterConfigurationItem>();
}
var startPage = _contentLoader.Get<IContent>(ContentReference.StartPage);
var facetsConfiguration = startPage as IFacetConfiguration;
if (facetsConfiguration?.SearchFiltersConfiguration != null)
{
return facetsConfiguration
.SearchFiltersConfiguration
.ToList();
}
return new List<FacetFilterConfigurationItem>();
}
}
</code></pre>
<p>Based on the facet configuration model field type we create instances of <code><em>FacetStringDefinition</em> </code>or <code><em>FacetStringListDefinition</em></code>.</p>
<p>The commerce facet configuration factory <code>CommerceFacetConfigFactory.cs</code> inherits from the default implementation and override the <code><em>GetFacetDefinition()</em> </code>and <code><em>GetDefaultFacetDefinitions()</em> </code>methods.</p>
<pre class="language-csharp"><code> public class CommerceFacetConfigFactory : FacetConfigFactory
{
private readonly ICurrentMarket _currentMarket;
public CommerceFacetConfigFactory(ICurrentMarket currentMarket,
IContentLoader contentLoader) : base(contentLoader)
{
_currentMarket = currentMarket;
}
public override FacetDefinition GetFacetDefinition(FacetFilterConfigurationItem facetConfiguration)
{
switch (Enum.Parse(typeof(FacetFieldType), facetConfiguration.FieldType))
{
case FacetFieldType.Integer:
return new FacetNumericRangeDefinition(_currentMarket)
{
FieldName = facetConfiguration.FieldName,
DisplayName = facetConfiguration.GetDisplayName(),
BackingType = typeof(int)
};
case FacetFieldType.Double:
if (facetConfiguration.DisplayMode == FacetDisplayMode.Range.ToString()
|| facetConfiguration.DisplayMode == FacetDisplayMode.PriceRange.ToString())
{
var rangeDefinition = new FacetNumericRangeDefinition(_currentMarket)
{
FieldName = facetConfiguration.FieldName,
DisplayName = facetConfiguration.GetDisplayName(),
BackingType = typeof(double)
};
rangeDefinition.Range = facetConfiguration.GetSelectableNumericRanges();
return rangeDefinition;
}
else if (facetConfiguration.DisplayMode == FacetDisplayMode.Rating.ToString())
{
var rangeDefinition = new FacetAverageRatingDefinition(_currentMarket)
{
FieldName = facetConfiguration.FieldName,
DisplayName = facetConfiguration.GetDisplayName(),
BackingType = typeof(double)
};
rangeDefinition.Range = facetConfiguration.GetSelectableNumericRanges();
return rangeDefinition;
}
break;
}
return base.GetFacetDefinition(facetConfiguration);
}
public override List<FacetDefinition> GetDefaultFacetDefinitions()
{
var brand = new FacetStringDefinition
{
FieldName = "Brand",
DisplayName = "Brand"
};
var color = new FacetStringListDefinition
{
DisplayName = "Color",
FieldName = "AvailableColors"
};
var size = new FacetStringListDefinition
{
DisplayName = "Size",
FieldName = "AvailableSizes"
};
var priceRanges = new FacetNumericRangeDefinition(_currentMarket)
{
DisplayName = "Price",
FieldName = "DefaultPrice",
BackingType = typeof(double)
};
priceRanges.Range.Add(new SelectableNumericRange() { To = 50 });
priceRanges.Range.Add(new SelectableNumericRange() { From = 50, To = 100 });
priceRanges.Range.Add(new SelectableNumericRange() { From = 100, To = 500 });
priceRanges.Range.Add(new SelectableNumericRange() { From = 500, To = 1000 });
priceRanges.Range.Add(new SelectableNumericRange() { From = 1000 });
return new List<FacetDefinition>() { priceRanges, brand, size, color };
}
}
</code></pre>
<p>Based on the facet configuration model field type and display mode we create instances of <code>FacetNumericRangeDefinition.cs</code> or <code>FacetAverageRatingDefinition.cs</code>.</p>
<p>We also define the 4 default facet definitions: Price, Brand, Size and Color.</p>
<p>With the facet configuration factory and facet configuration model ready, the only step remaining is to initialize the facet configuration during the initialization module.</p>
<h3><span style="text-decoration: underline;">3. Facet Configuration Initialization</span></h3>
<p>First, we need to register the 2 new facet configuration factories in the initialization module <code>Initialize.cs</code> of <em>Find.Cms</em> and <em>Find.Commerce</em>:</p>
<pre class="language-csharp"><code>namespace Foundation.Find.Cms
{
[ModuleDependency(typeof(Foundation.Cms.Initialize))]
public class Initialize : IConfigurableModule
{
void IConfigurableModule.ConfigureContainer(ServiceConfigurationContext context)
{
…
services.AddSingleton<IFacetConfigFactory, FacetConfigFactory>();
</code></pre>
<pre class="language-csharp"><code>namespace Foundation.Find.Commerce
{
[ModuleDependency(typeof(Cms.Initialize), typeof(FindCommerceInitializationModule))]
public class Initialize : IConfigurableModule
{
void IConfigurableModule.ConfigureContainer(ServiceConfigurationContext context)
{
…
services.AddSingleton<IFacetConfigFactory, CommerceFacetConfigFactory>();
</code></pre>
<p>We have the code in place to dynamically configure the Find facets. We need now to write the code to glue everything together during the initialize module and every time the start page is published.</p>
<p>Episerver Foundation uses the <code><em>IFacetRegistry.cs</em></code> interface to register the Find facets that will be used by the Find service and that will be displayed on the search results page.</p>
<p>To facilitate the integration into the initialization engine we implemented an <code><em>InitializationEngine</em> </code>extension as follows:</p>
<pre class="language-csharp"><code> public static class InitializationEngineExtensions
{
private static Lazy<IContentEvents> _contentEvents = new Lazy<IContentEvents>(() => ServiceLocator.Current.GetInstance<IContentEvents>());
private static Lazy<IFacetRegistry> _facetRegistry = new Lazy<IFacetRegistry>(() => ServiceLocator.Current.GetInstance<IFacetRegistry>());
private static Lazy<IFacetConfigFactory> _facetConfigFactory = new Lazy<IFacetConfigFactory>(() => ServiceLocator.Current.GetInstance<IFacetConfigFactory>());
public static void InitializeFoundationFindCms(this InitializationEngine context)
{
InitializeFacets(_facetConfigFactory.Value.GetFacetFilterConfigurationItems());
_contentEvents.Value.PublishedContent += OnPublishedContent;
}
static void OnPublishedContent(object sender, ContentEventArgs contentEventArgs)
{
if (contentEventArgs.Content is IFacetConfiguration facetConfiguration)
{
InitializeFacets(facetConfiguration.SearchFiltersConfiguration);
}
}
private static void InitializeFacets(IList<FacetFilterConfigurationItem> configItems)
{
_facetRegistry.Value.Clear();
if (configItems != null && configItems.Any())
{
configItems
.ToList()
.ForEach(x => _facetRegistry.Value.AddFacetDefinitions(_facetConfigFactory.Value.GetFacetDefinition(x)));
}
else
{
_facetConfigFactory.Value.GetDefaultFacetDefinitions()
.ForEach(x => _facetRegistry.Value.AddFacetDefinitions(x));
}
}
}</code></pre>
<p>Using the facet configuration factory, we register the facet definitions configured by the content editors in start page or we fallback to the default one.</p>
<p>When the start page is published we listen to the published content even and reset the facet registration with the new facet definitions and configurations.</p>
<p>The last thing to do is to call the initialization engine extension we’ve created inside the initialize method of the <code>InitializeSite.cs</code></p>
<pre class="language-csharp"><code>namespace Foundation.Infrastructure
{
public class InitializeSite : IConfigurableModule
{
…
public void Initialize(InitializationEngine context)
{
…
context.InitializeFoundationCms();
context.InitializeFoundationCommerce();
context.InitializeFoundationFindCms();
context.InitializeFoundationDemo();</code></pre>
<h2><span style="text-decoration: underline;">Conclusion</span></h2>
<p>Enabling the configuration of the search facets and allowing live changes of what the end-user will see and filter on, brings an added value to any e-commerce solution and allows enrichment of the search engine.</p>
<p>The enrichments and next steps of the solution include:</p>
<ul>
<li><em>Display modes</em>: color swatches, checkboxes, sliders, etc. Use the facet display mode in the view to call a partial view that displays the facet options in different ways;</li>
<li><em>Display direction</em>: vertically or horizontally. For some facets we might want to display the facet options horizontally, one beside the other, like for Size;</li>
<li><em>Exclude flags:</em> for Boolean facets we might want to group all of them under one facet group, like Status and have facet options like New, On Sale, Featured, Available on Store, etc.</li>
<li><em>Exclude values:</em> Exclude specific values that we do not want to be displayed as facet options; and</li>
<li><em>Display specific values</em>: Only display specific values in case we have too many facet options we might want to display on the top brands.</li>
</ul>
<p>The facet configuration model properties can be transferred to the facet definition <code>FacetDefinition.cs</code> and implement the additional logic inside <code>PopulateFacet()</code> method.</p>
<p>The facet configuration can be then transferred to the <code>FacetGroupOption.cs</code> and used in the view to customize the display of a facet by rendering a partial view for each display mode.</p>
<p><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" /></p>
<p>I hope you enjoyed the reading and the proposed solution. Looking forward to your feedback! Thank you!</p>
<p>The full source code is available on Episerver Foundation GitHub repository: <a href="https://github.com/episerver/Foundation">https://github.com/episerver/Foundation</a></p>2019-12-15T13:48:20.0000000ZBlog post