public static bool ContainsFilter(this SearchQuery searchQuery, string exceptTag = null, bool includePriceFilter = true)
 {
     return searchQuery.Tags.Any(x => exceptTag is null || exceptTag != x.Key)
         || searchQuery.Category.Count > 0
         || searchQuery.ContainsNewsFilter()
         || (includePriceFilter && searchQuery.ContainsPriceFilter())
         || searchQuery.ContainsCategoryFilter();
 }
Exemple #2
0
        public override SearchResponse Search(SearchQuery searchQuery,
                                              IDictionary <string, ISet <string> > tags = null,
                                              bool addPriceFilterTags    = false,
                                              bool addNewsFilterTags     = false,
                                              bool addCategoryFilterTags = false)
        {
            var pageModel       = _requestModelAccessor.RequestModel.CurrentPageModel;
            var isBrandPageType = pageModel.IsBrandPageType();

            if (string.IsNullOrEmpty(searchQuery.Text) && searchQuery.CategorySystemId.GetValueOrDefault() == Guid.Empty && searchQuery.ProductListSystemId == null && !isBrandPageType)
            {
                return(null);
            }

            var searchQueryBuilder = _searchQueryBuilderFactory.Create(CultureInfo.CurrentCulture, ProductCatalogSearchDomains.Products, searchQuery);

            if (isBrandPageType)
            {
                if (tags != null)
                {
                    if (!tags.ContainsKey(BrandListViewModel.TagName))
                    {
                        tags.Add(BrandListViewModel.TagName, new SortedSet <string>(new[] { pageModel.Page.Localizations.CurrentUICulture.Name }));
                    }
                }
                else
                {
                    tags = new Dictionary <string, ISet <string> > {
                        { BrandListViewModel.TagName, new SortedSet <string>(new[] { pageModel.Page.Localizations.CurrentUICulture.Name }) }
                    };
                }
            }

            searchQueryBuilder.ApplySelectedFilterTags(tags);

            if (addCategoryFilterTags)
            {
                searchQueryBuilder.ApplySelectedFilterCategories();
            }

            if (addPriceFilterTags)
            {
                searchQueryBuilder.ApplyPriceFilterTags();
            }

            if (addNewsFilterTags)
            {
                searchQueryBuilder.ApplyNewsFilterTags();
            }

            searchQueryBuilder.AddFilterReadTags();
            searchQueryBuilder.ApplyProductCatalogDefaultSearchTag();
            searchQueryBuilder.ApplyOrganizationSearchTags();

            if (searchQuery.ProductListSystemId == null)
            {
                searchQueryBuilder.ApplyCategoryTags();
                searchQueryBuilder.ApplyCategorySorting();
                searchQueryBuilder.ApplyDefaultSortOrder();
                searchQueryBuilder.ApplyFreeTextSearchTags();
            }
            else
            {
                searchQueryBuilder.ApplyProductListSorting();
            }

            var request = searchQueryBuilder.Build();

            request.ReadTags.Add(VariantIndexDocumentMerger.MergeTagName);
            request.ReadTags.Add(TagNames.ArticleNumber);
            var searchResponse = _searchService.Search(request);
            var priceTagName   = _requestModelAccessor.RequestModel.Cart.IncludeVAT ? "-price-incl_vat" : "-price";
            var searchResult   = searchResponse.Hits
                                 .Select(hit =>
            {
                var priceTags = hit.Tags
                                .Where(x => x.Name.EndsWith(priceTagName, StringComparison.OrdinalIgnoreCase))
                                .Select(x => x.OriginalValue)
                                .Cast <decimal>()
                                .DefaultIfEmpty(decimal.MinusOne)
                                .Min();

                return(new SortableSearchHit(hit)
                {
                    Price = priceTags
                });
            })
                                 .ToList();

            if (addPriceFilterTags && (searchQuery.ContainsPriceFilter() || searchQuery.SortBy == SearchQueryConstants.Price))
            {
                searchResult = FilterAndSortOnPrice(searchResult, searchQuery);
            }

            return(new SearchResponse
            {
                ETag = searchResponse.ETag,
                Hits = new Collection <Hit>(searchResult.Cast <Hit>().ToList()),
                MaxScore = searchResult.Count == 0 ? 0 : searchResult.Max(x => x.Score),
                TotalHitCount = searchResult.Count
            });
        }