protected SearchResults <FindProduct> GetProductsForSearchAndFilters(ProductSearchData productSearchData, string searchTerm, string language)
{
var productsQuery = SearchClient.Instance.Search <FindProduct>(GetFindLanguage(language));
productsQuery = ApplyTermFilter(productsQuery, searchTerm, trackSearchTerm: true);
// common filters
productsQuery = ApplyCommonFilters(productsQuery, language);
// selected categories
if (productSearchData.ProductData.SelectedProductCategories != null &&
productSearchData.ProductData.SelectedProductCategories.Any())
{
productsQuery = productsQuery.AddFilterForIntList(productSearchData.ProductData.SelectedProductCategories, "ParentCategoryId");
}
// Add filters from the passed in fasets
foreach (FacetValues fv in productSearchData.ProductData.Facets)
{
productsQuery = fv.Definition.Filter(productsQuery);
}
// execute product search
productsQuery = productsQuery
.Skip((productSearchData.Page - 1) * productSearchData.PageSize)
.Take(productSearchData.PageSize)
.StaticallyCacheFor(TimeSpan.FromMinutes(1))
.ApplyBestBets();
var productsSearchResult = productsQuery.GetResult();
return(productsSearchResult);
}
private SearchResults <FindProduct> GetFacetResult(ProductSearchData productSearchData, string language, List <FacetValues> facets, string searchTerm, bool applyFacetFilters = true)
{
var productFacetQuery = SearchClient.Instance.Search <FindProduct>(GetFindLanguage(language));
// search term
productFacetQuery = ApplyTermFilter(productFacetQuery, searchTerm);
// common filters
productFacetQuery = ApplyCommonFilters(productFacetQuery, language);
// selected categories
if (productSearchData.ProductData.SelectedProductCategories != null &&
productSearchData.ProductData.SelectedProductCategories.Any())
{
productFacetQuery = productFacetQuery.AddFilterForIntList(productSearchData.ProductData.SelectedProductCategories, "ParentCategoryId");
}
productFacetQuery = productFacetQuery
.TermsFacetFor(x => x.ParentCategoryName)
.TermsFacetFor(x => x.MainCategoryName);
if (facets != null && facets.Any())
{
foreach (FacetValues fv in facets)
{
// productFacetQuery = productFacetQuery.TermsFacetFor(fv.Definition.FieldName, 50);
productFacetQuery = fv.Definition.Facet(productFacetQuery);
}
if (applyFacetFilters)
{
foreach (FacetValues fv in facets)
{
productFacetQuery = fv.Definition.Filter(productFacetQuery);
//var selectedFacets = fv.Values.Where(x => x.Selected.Equals(true)).Select(x => x.Name).ToList();
//if (selectedFacets.Any())
//{
// productFacetQuery = productFacetQuery.AddStringListFilter(selectedFacets, fv.Definition.FieldName);
//}
}
}
}
var productFacetsResult = productFacetQuery
.Take(0)
.GetResult();
return(productFacetsResult);
}
private static ITypeSearch <FindProduct> ApplyTermFilter(ProductSearchData productSearchData, ITypeSearch <FindProduct> query, bool trackSearchTerm = false)
{
if (!string.IsNullOrEmpty(productSearchData.ProductData.SearchTerm))
{
query = query.For(productSearchData.ProductData.SearchTerm)
.InFields(x => x.Name, x => x.MainCategoryName, x => string.Join(",", x.Color),
x => x.DisplayName, x => x.Fit, x => x.Description.ToString(), x => string.Join(",", x.ParentCategoryName))
.InAllField();
if (trackSearchTerm)
{
query = query.Track();
}
}
return(query);
}
private List <FindProduct> GetRecommendedProducts(ProductSearchData productSearchData, string language)
{
List <FindProduct> recommendedFindProducts = new List <FindProduct>();
CultureInfo currentCulture = new CultureInfo(language);
List <string> categoryCodes = new List <string>();
foreach (var categoryId in productSearchData.ProductData.SelectedProductCategories)
{
ContentReference catalogNodeRef = _referenceConverter.GetContentLink(categoryId, CatalogContentType.CatalogNode, 0);
var catalogNode = _contentLoader.Get <NodeContent>(catalogNodeRef);
if (catalogNode != null)
{
categoryCodes.Add(catalogNode.Code);
}
}
var recommendedProducts =
_recommendationService.GetRecommendedProductsByCategory(_currentCustomerService.GetCurrentUserId(),
categoryCodes,
3,
currentCulture);
if (recommendedProducts != null && recommendedProducts.Products != null && recommendedProducts.Products.Any())
{
var currentMarket = ServiceLocator.Current.GetInstance <Mediachase.Commerce.ICurrentMarket>().GetCurrentMarket();
foreach (var product in recommendedProducts.Products)
{
if (product is IIndexableContent)
{
var productContent = product as IIndexableContent;
var findProduct = productContent.GetFindProduct(currentMarket);
recommendedFindProducts.Add(findProduct);
}
}
}
return(recommendedFindProducts);
}
public JObject GetProducts(ProductSearchData productSearchData)
{
// If we do not get any facets as part of query, we use the default facets from the registry
var facetRegistry = ServiceLocator.Current.GetInstance <FacetRegistry>();
if (productSearchData.ProductData.Facets == null || productSearchData.ProductData.Facets.Any() == false)
{
productSearchData.ProductData.Facets = new List <FacetValues>();
foreach (FacetDefinition definition in facetRegistry.FacetDefinitions)
{
var valuesForFacet = new FacetValues()
{
Definition = definition
};
productSearchData.ProductData.Facets.Add(valuesForFacet);
}
}
// The language is part of the route
string language = Language;
// search term, used if part of freetext search
var searchTerm = productSearchData.ProductData.SearchTerm;
SearchResults <FindProduct> productsSearchResult = GetProductsForSearchAndFilters(productSearchData, searchTerm, language);
string selectedFacetName = productSearchData.ProductData.SelectedFacetName ?? string.Empty;
var productFacetsResult = GetFacetResult(productSearchData, language, productSearchData.ProductData.Facets, searchTerm);
// parse facet results
IEnumerable <TermCount> productCategoryFacetsResult = productFacetsResult.TermsFacetFor(x => x.ParentCategoryName).Terms;
List <FacetViewModel> allProductCategoryFacets = CreateCategoryFacetViewModels(productCategoryFacetsResult,
productSearchData.ProductData.SelectedProductCategories.Select(x => x.ToString()).ToList());
// Get all facet values based on facet registry
var facetsAndValues = GetFacetsAndValues(productFacetsResult, productSearchData.ProductData.Facets);
// If we're doing a filtering on a specific facet, we handle that one
// in a special way, in order to show the count for all terms for the facet
SearchResults <FindProduct> productSelectedFacetsResult = null;
if (string.IsNullOrEmpty(selectedFacetName) == false)
{
List <FacetValues> selectedFacet = new List <FacetValues>();
if (productSearchData.ProductData.Facets != null)
{
FacetValues selectedValues = productSearchData.ProductData.Facets.Find(f => f.Definition.Name.Equals(selectedFacetName));
if (selectedValues != null)
{
selectedFacet.Add(selectedValues);
}
}
// Get facet values and counts for the selected facet
productSelectedFacetsResult = GetFacetResult(
productSearchData,
language,
selectedFacet,
searchTerm, applyFacetFilters: false);
// Treat the selected faced specially, as it might show more data if it is selected
facetsAndValues = GetFacetsAndValues(productSelectedFacetsResult, facetsAndValues);
}
var result = new
{
products = productsSearchResult.ToList(),
productCategoryFacets = allProductCategoryFacets,
facets = facetsAndValues,
totalResult = productsSearchResult.TotalMatching
};
var serializer = new JsonSerializer();
serializer.TypeNameHandling = TypeNameHandling.Auto;
return(JObject.FromObject(result, serializer));
}
private SearchResults<FindProduct> GetFacetResult(ProductSearchData productSearchData, string language, List<FacetValues> facets, string searchTerm, bool applyFacetFilters = true)
{
var productFacetQuery = SearchClient.Instance.Search<FindProduct>(GetFindLanguage(language));
// search term
productFacetQuery = ApplyTermFilter(productFacetQuery, searchTerm);
// common filters
productFacetQuery = ApplyCommonFilters(productFacetQuery, language);
// selected categories
if (productSearchData.ProductData.SelectedProductCategories != null &&
productSearchData.ProductData.SelectedProductCategories.Any())
{
productFacetQuery = productFacetQuery.AddFilterForIntList(productSearchData.ProductData.SelectedProductCategories, "ParentCategoryId");
}
productFacetQuery = productFacetQuery
.TermsFacetFor(x => x.ParentCategoryName)
.TermsFacetFor(x => x.MainCategoryName);
if (facets != null && facets.Any())
{
foreach (FacetValues fv in facets)
{
// productFacetQuery = productFacetQuery.TermsFacetFor(fv.Definition.FieldName, 50);
productFacetQuery = fv.Definition.Facet(productFacetQuery);
}
if (applyFacetFilters)
{
foreach (FacetValues fv in facets)
{
productFacetQuery = fv.Definition.Filter(productFacetQuery);
//var selectedFacets = fv.Values.Where(x => x.Selected.Equals(true)).Select(x => x.Name).ToList();
//if (selectedFacets.Any())
//{
// productFacetQuery = productFacetQuery.AddStringListFilter(selectedFacets, fv.Definition.FieldName);
//}
}
}
}
var productFacetsResult = productFacetQuery
.Take(0)
.GetResult();
return productFacetsResult;
}
protected SearchResults<FindProduct> GetProductsForSearchAndFilters(ProductSearchData productSearchData, string searchTerm, string language)
{
var productsQuery = SearchClient.Instance.Search<FindProduct>(GetFindLanguage(language));
productsQuery = ApplyTermFilter(productsQuery, searchTerm, trackSearchTerm: true);
// common filters
productsQuery = ApplyCommonFilters(productsQuery, language);
// selected categories
if (productSearchData.ProductData.SelectedProductCategories != null &&
productSearchData.ProductData.SelectedProductCategories.Any())
{
productsQuery = productsQuery.AddFilterForIntList(productSearchData.ProductData.SelectedProductCategories, "ParentCategoryId");
}
// Add filters from the passed in fasets
foreach (FacetValues fv in productSearchData.ProductData.Facets)
{
productsQuery = fv.Definition.Filter(productsQuery);
}
// execute product search
productsQuery = productsQuery
.Skip((productSearchData.Page - 1) * productSearchData.PageSize)
.Take(productSearchData.PageSize)
.StaticallyCacheFor(TimeSpan.FromMinutes(1))
.ApplyBestBets();
var productsSearchResult = productsQuery.GetResult();
return productsSearchResult;
}
public JObject GetProducts(ProductSearchData productSearchData)
{
// If we do not get any facets as part of query, we use the default facets from the registry
var facetRegistry = ServiceLocator.Current.GetInstance<FacetRegistry>();
if (productSearchData.ProductData.Facets == null || productSearchData.ProductData.Facets.Any() == false)
{
productSearchData.ProductData.Facets = new List<FacetValues>();
foreach (FacetDefinition definition in facetRegistry.FacetDefinitions)
{
var valuesForFacet = new FacetValues()
{
Definition = definition
};
productSearchData.ProductData.Facets.Add(valuesForFacet);
}
}
// The language is part of the route
string language = Language;
// search term, used if part of freetext search
var searchTerm = productSearchData.ProductData.SearchTerm;
SearchResults<FindProduct> productsSearchResult = GetProductsForSearchAndFilters(productSearchData, searchTerm, language);
string selectedFacetName = productSearchData.ProductData.SelectedFacetName ?? string.Empty;
var productFacetsResult = GetFacetResult(productSearchData, language, productSearchData.ProductData.Facets, searchTerm);
// parse facet results
IEnumerable<TermCount> productCategoryFacetsResult = productFacetsResult.TermsFacetFor(x => x.ParentCategoryName).Terms;
List<FacetViewModel> allProductCategoryFacets = CreateCategoryFacetViewModels(productCategoryFacetsResult,
productSearchData.ProductData.SelectedProductCategories.Select(x => x.ToString()).ToList());
// Get all facet values based on facet registry
var facetsAndValues = GetFacetsAndValues(productFacetsResult, productSearchData.ProductData.Facets);
// If we're doing a filtering on a specific facet, we handle that one
// in a special way, in order to show the count for all terms for the facet
SearchResults<FindProduct> productSelectedFacetsResult = null;
if (string.IsNullOrEmpty(selectedFacetName) == false)
{
List<FacetValues> selectedFacet = new List<FacetValues>();
if (productSearchData.ProductData.Facets != null)
{
FacetValues selectedValues = productSearchData.ProductData.Facets.Find(f => f.Definition.Name.Equals(selectedFacetName));
if (selectedValues != null)
selectedFacet.Add(selectedValues);
}
// Get facet values and counts for the selected facet
productSelectedFacetsResult = GetFacetResult(
productSearchData,
language,
selectedFacet,
searchTerm, applyFacetFilters: false);
// Treat the selected faced specially, as it might show more data if it is selected
facetsAndValues = GetFacetsAndValues(productSelectedFacetsResult, facetsAndValues);
}
var result = new
{
products = productsSearchResult.ToList(),
productCategoryFacets = allProductCategoryFacets,
facets = facetsAndValues,
totalResult = productsSearchResult.TotalMatching
};
var serializer = new JsonSerializer();
serializer.TypeNameHandling = TypeNameHandling.Auto;
return JObject.FromObject(result, serializer);
}
private static ITypeSearch <FindProduct> ApplyCommonFilters(ProductSearchData productSearchData, ITypeSearch <FindProduct> query, string language)
{
return(query.Filter(x => x.Language.Match(language))
.Filter(x => x.ShowInList.Match(true)));
}
public object GetProducts(ProductSearchData productSearchData)
{
try
{
string language = Language;
//Starting the find query
var query = SearchClient.Instance.Search <FindProduct>(GetLanguage(language));
// search term
query = ApplyTermFilter(productSearchData, query, true);
// common filters
query = ApplyCommonFilters(productSearchData, query, language);
// selected categories
if (productSearchData.ProductData.SelectedProductCategories != null &&
productSearchData.ProductData.SelectedProductCategories.Any())
{
query = query.Filter(x => GetCategoryFilter(productSearchData.ProductData.SelectedProductCategories));
}
// selected colors
if (productSearchData.ProductData.SelectedColorFacets != null &&
productSearchData.ProductData.SelectedColorFacets.Any())
{
query = query.Filter(x => GetColorFilter(productSearchData.ProductData.SelectedColorFacets));
}
// selected sizes
if (productSearchData.ProductData.SelectedSizeFacets != null &&
productSearchData.ProductData.SelectedSizeFacets.Any())
{
query = query.Filter(x => GetSizeFilter(productSearchData.ProductData.SelectedSizeFacets));
}
// selected fits
if (productSearchData.ProductData.SelectedFitsFacets != null &&
productSearchData.ProductData.SelectedFitsFacets.Any())
{
query = query.Filter(x => GetFitFilter(productSearchData.ProductData.SelectedFitsFacets));
}
// selected region
if (productSearchData.ProductData.SelectedRegionFacets != null &&
productSearchData.ProductData.SelectedRegionFacets.Any())
{
query = query.Filter(x => GetRegionFilter(productSearchData.ProductData.SelectedRegionFacets));
}
// selected grapes
if (productSearchData.ProductData.SelectedGrapeFacets != null &&
productSearchData.ProductData.SelectedGrapeFacets.Any())
{
query = query.Filter(x => GetGrapeFilter(productSearchData.ProductData.SelectedGrapeFacets));
}
//selected countries
if (productSearchData.ProductData.SelectedCountryFacets != null &&
productSearchData.ProductData.SelectedCountryFacets.Any())
{
query = query.Filter(x => GetCountryFilter(productSearchData.ProductData.SelectedCountryFacets));
}
// execute search
query = query.Skip((productSearchData.Page - 1) * productSearchData.PageSize)
.Take(productSearchData.PageSize);
var searchResult = query.StaticallyCacheFor(TimeSpan.FromMinutes(1)).GetResult();
//Done with search query
#region Facet search
//Facets for product cagetories, get all, only filtered on search term and main category(menn/dame) if selected
var productFacetQuery = SearchClient.Instance.Search <FindProduct>(GetLanguage(language));
// search term
productFacetQuery = ApplyTermFilter(productSearchData, productFacetQuery);
// common filters
productFacetQuery = ApplyCommonFilters(productSearchData, productFacetQuery, language);
// categories
if (productSearchData.ProductData.SelectedMainCategoryFacets != null &&
productSearchData.ProductData.SelectedMainCategoryFacets.Any())
{
productFacetQuery =
productFacetQuery.Filter(
x => GetMainCategoryFilter(productSearchData.ProductData.SelectedMainCategoryFacets));
}
// execute
var productFacetsResult = productFacetQuery
.TermsFacetFor(x => x.ParentCategoryName)
.TermsFacetFor(x => x.MainCategoryName)
.Take(0)
.GetResult();
// results
var productCategoryFacetsResult = productFacetsResult.TermsFacetFor(x => x.ParentCategoryName).Terms;
var productMainCategoryFacetResult = productFacetsResult.TermsFacetFor(x => x.MainCategoryName).Terms;
var allProductCategoryFacets = CreateCategoryFacetViewModels(productCategoryFacetsResult,
productSearchData.ProductData.SelectedProductCategories.Select(x => x.ToString()).ToList());
var allMainCategoryFacets = CreateFacetViewModels(productMainCategoryFacetResult,
productSearchData.ProductData.SelectedMainCategoryFacets);
//Facets - To get all, color, size and fit facets, based on selected product categories
var facetsQuery = SearchClient.Instance.Search <FindProduct>(GetLanguage(language));
// search term
facetsQuery = ApplyTermFilter(productSearchData, facetsQuery);
// common filters
facetsQuery = ApplyCommonFilters(productSearchData, facetsQuery, language);
// execute search
var facetsResult = facetsQuery
.Filter(x => GetCategoryFilter(productSearchData.ProductData.SelectedProductCategories))
.Filter(x => GetMainCategoryFilter(productSearchData.ProductData.SelectedMainCategoryFacets))
.TermsFacetFor(x => x.Color, r => r.Size = 50)
.TermsFacetFor(x => x.Fit, r => r.Size = 50)
.TermsFacetFor(x => x.SizesList, r => r.Size = 200)
.TermsFacetFor(x => x.Region, r => r.Size = 50)
.TermsFacetFor(x => x.GrapeMixList, r => r.Size = 50)
.TermsFacetFor(x => x.Country, r => r.Size = 50)
.Take(0)
.StaticallyCacheFor(TimeSpan.FromMinutes(1))
.GetResult();
// results
var productColorFacetsResult = facetsResult.TermsFacetFor(x => x.Color).Terms;
var productFitFacetsResult = facetsResult.TermsFacetFor(x => x.Fit).Terms;
var productsizesResult = facetsResult.TermsFacetFor(x => x.SizesList).Terms;
var productRegionResult = facetsResult.TermsFacetFor(x => x.Region).Terms;
var productGrapeResult = facetsResult.TermsFacetFor(x => x.GrapeMixList).Terms;
var productCountryResult = facetsResult.TermsFacetFor(x => x.Country).Terms;
var allColorFacets = CreateFacetViewModels(productColorFacetsResult,
productSearchData.ProductData.SelectedColorFacets);
var allFitFacets = CreateFacetViewModels(productFitFacetsResult,
productSearchData.ProductData.SelectedFitsFacets);
var allRegionFacets = CreateFacetViewModels(productRegionResult,
productSearchData.ProductData.SelectedRegionFacets);
var allGrapeFacets = CreateFacetViewModels(productGrapeResult,
productSearchData.ProductData.SelectedGrapeFacets);
var allcountryFacets = CreateFacetViewModels(productCountryResult,
productSearchData.ProductData.SelectedCountryFacets);
//Testing different size type facets
var allDifferentSizeFacets = GetAllDifferentSizeFacets(productsizesResult,
productSearchData.ProductData.SelectedSizeFacets);
#endregion
var totalMatching = searchResult.TotalMatching;
var result = new
{
products = searchResult.ToList(),
productCategoryFacets = allProductCategoryFacets,
productColorFacets = allColorFacets,
allSizeFacetLists = allDifferentSizeFacets,
productFitFacets = allFitFacets,
productRegionFacets = allRegionFacets,
productGrapeFacets = allGrapeFacets,
productCountryFacets = allcountryFacets,
mainCategoryFacets = allMainCategoryFacets,
totalResult = totalMatching
};
return(result);
}
catch (OperationCanceledException)
{
return(null);
}
catch (ServiceException)
{
return(null);
}
}
