protected virtual IList <IFilter> GetFilters(CategorySearchCriteria criteria)
{
var result = new List <IFilter>();
if (!string.IsNullOrEmpty(criteria.SearchPhrase))
{
var parseResult = _searchPhraseParser.Parse(criteria.SearchPhrase);
criteria.SearchPhrase = parseResult.SearchPhrase;
result.AddRange(parseResult.Filters);
}
if (criteria.ObjectIds != null)
{
result.Add(new IdsFilter {
Values = criteria.ObjectIds
});
}
if (!string.IsNullOrEmpty(criteria.CatalogId))
{
result.Add(FiltersHelper.CreateTermFilter("catalog", criteria.CatalogId.ToLowerInvariant()));
}
result.Add(FiltersHelper.CreateOutlineFilter(criteria));
var terms = criteria.GetTerms();
result.AddRange(terms.Select(term => FiltersHelper.CreateTermFilter(term.Key, term.Values)));
return(result);
}
protected virtual IList <IFilter> GetPermanentFilters(ProductIndexedSearchCriteria criteria)
{
var result = new List <IFilter>();
if (!string.IsNullOrEmpty(criteria.Keyword))
{
var parseResult = _searchPhraseParser.Parse(criteria.Keyword);
criteria.Keyword = parseResult.Keyword;
result.AddRange(parseResult.Filters);
}
if (criteria.ObjectIds != null)
{
result.Add(new IdsFilter {
Values = criteria.ObjectIds
});
}
if (!string.IsNullOrEmpty(criteria.CatalogId))
{
result.Add(FiltersHelper.CreateTermFilter("catalog", criteria.CatalogId.ToLowerInvariant()));
}
result.Add(FiltersHelper.CreateOutlineFilter(criteria));
if (criteria.StartDateFrom.HasValue)
{
result.Add(FiltersHelper.CreateDateRangeFilter("startdate", criteria.StartDateFrom, criteria.StartDate, false, true));
}
if (criteria.EndDate.HasValue)
{
result.Add(FiltersHelper.CreateDateRangeFilter("enddate", criteria.EndDate, null, false, false));
}
if (!criteria.ClassTypes.IsNullOrEmpty())
{
result.Add(FiltersHelper.CreateTermFilter("__type", criteria.ClassTypes));
}
if (!criteria.WithHidden)
{
result.Add(FiltersHelper.CreateTermFilter("status", "visible"));
}
if (criteria.PriceRange != null)
{
var range = criteria.PriceRange;
result.Add(FiltersHelper.CreatePriceRangeFilter(criteria.Currency, criteria.Pricelists, range.Lower, range.Upper, range.IncludeLower, range.IncludeUpper));
}
if (criteria.GeoDistanceFilter != null)
{
result.Add(criteria.GeoDistanceFilter);
}
return(result);
}
public IndexSearchRequestBuilder ParseFacets(ISearchPhraseParser phraseParser, string facetPhrase, IList <AggregationRequest> predefinedAggregations = null)
{
if (phraseParser == null)
{
throw new ArgumentNullException(nameof(phraseParser));
}
SearchRequest.Aggregations = predefinedAggregations ?? new List <AggregationRequest>();
if (string.IsNullOrEmpty(facetPhrase))
{
return(this);
}
//TODO: Support aliases for Facet expressions e.g price.usd[TO 200) as price_below_200
//TODO: Need to create a new Antlr file with g4-lexer rules and generate parser especially for facets expression that will return proper AggregationRequests objects
var parseResult = phraseParser.Parse(facetPhrase);
//Term facets
if (!string.IsNullOrEmpty(parseResult.Keyword))
{
var termFacetExpressions = parseResult.Keyword.Split(" ");
parseResult.Filters.AddRange(termFacetExpressions.Select(x => new TermFilter
{
FieldName = x,
Values = new List <string>()
}));
}
SearchRequest.Aggregations = parseResult.Filters
.Select <IFilter, AggregationRequest>(filter =>
{
FilterSyntaxMapper.MapFilterAdditionalSyntax(filter);
return(filter switch
{
RangeFilter rangeFilter => new RangeAggregationRequest
{
Id = filter.Stringify(),
FieldName = rangeFilter.FieldName,
Values = rangeFilter.Values.Select(x => new RangeAggregationRequestValue
{
Id = x.Stringify(),
Lower = x.Lower,
Upper = x.Upper,
IncludeLower = x.IncludeLower,
IncludeUpper = x.IncludeUpper
}).ToList()
},
TermFilter termFilter => new TermAggregationRequest
{
FieldName = termFilter.FieldName,
Id = filter.Stringify(),
Filter = termFilter
},
_ => null,
});
})
public SearchRequestBuilder ParseFilters(string filterPhrase)
{
if (filterPhrase == null)
{
return(this);
}
if (_phraseParser == null)
{
throw new OperationCanceledException("phrase parser must be initialized");
}
var parseResult = _phraseParser.Parse(filterPhrase);
var filters = new List <IFilter>();
foreach (var filter in parseResult.Filters)
{
FilterSyntaxMapper.MapFilterSyntax(filter);
if (filter is TermFilter termFilter)
{
var wildcardValues = termFilter.Values.Where(x => new[] { "?", "*" }.Any(x.Contains));
if (wildcardValues.Any())
{
filters.AddRange(wildcardValues.Select(x => new WildCardTermFilter {
FieldName = termFilter.FieldName, Value = x
}));
termFilter.Values = termFilter.Values.Except(wildcardValues).ToList();
}
if (termFilter.Values.Any())
{
filters.Add(termFilter);
}
}
else
{
filters.Add(filter);
}
}
((AndFilter)SearchRequest.Filter).ChildFilters.AddRange(filters);
return(this);
}
public CartSearchCriteriaBuilder ParseFilters(string filterPhrase)
{
if (string.IsNullOrEmpty(filterPhrase))
{
return(this);
}
if (_phraseParser == null)
{
throw new OperationCanceledException("phrase parser must be initialized");
}
var parseResult = _phraseParser.Parse(filterPhrase);
_mapper.Map(parseResult.Filters, _searchCriteria);
return(this);
}
public DynamicPropertySearchCriteriaBuilder ParseFilters(string filterPhrase)
{
if (filterPhrase == null)
{
return(this);
}
if (_phraseParser == null)
{
throw new OperationCanceledException("phrase parser must be set");
}
var parseResult = _phraseParser.Parse(filterPhrase);
_mapper.Map(parseResult.Filters, _searchCriteria);
return(this);
}
protected virtual IList <IFilter> GetFilters(MembersSearchCriteria criteria)
{
var result = new List <IFilter>();
if (!string.IsNullOrEmpty(criteria.Keyword))
{
var parseResult = _searchPhraseParser.Parse(criteria.Keyword);
criteria.Keyword = parseResult.Keyword;
result.AddRange(parseResult.Filters);
}
if (criteria.ObjectIds?.Any() == true)
{
result.Add(new IdsFilter {
Values = criteria.ObjectIds
});
}
if (criteria.MemberTypes?.Any() == true)
{
result.Add(CreateTermFilter("MemberType", criteria.MemberTypes));
}
if (criteria.Groups?.Any() == true)
{
result.Add(CreateTermFilter("Groups", criteria.Groups));
}
if (!string.IsNullOrEmpty(criteria.MemberId))
{
result.Add(CreateTermFilter("ParentOrganizations", criteria.MemberId));
// TODO: criteria.DeepSearch requires something like outlines in the catalog module
}
else if (!criteria.DeepSearch)
{
result.Add(CreateTermFilter("HasParentOrganizations", "false"));
}
return(result);
}
public virtual async Task <FiltersContainer> GetTermFiltersAsync(ProductIndexedSearchCriteria criteria)
{
var result = new FiltersContainer();
var terms = criteria.GetTerms();
if (terms.Any())
{
var browseFilters = await _browseFilterService.GetBrowseFiltersAsync(criteria);
var filtersAndValues = browseFilters
?.Select(f => new { Filter = f, Values = f.GetValues() })
.ToList();
foreach (var term in terms)
{
var browseFilter = browseFilters?.SingleOrDefault(x => x.Key.EqualsInvariant(term.Key));
// Handle special filter term with a key = "tags", it contains just values and we need to determine which filter to use
if (browseFilter == null && term.Key == "tags")
{
foreach (var termValue in term.Values)
{
// Try to find filter by value
var filterAndValues = filtersAndValues?.FirstOrDefault(x => x.Values?.Any(v => v.Id.Equals(termValue)) == true);
if (filterAndValues != null)
{
var filter = ConvertBrowseFilter(filterAndValues.Filter, term.Values, criteria);
result.PermanentFilters.Add(filter);
}
else
{
// Unknown term values should produce empty result
result.PermanentFilters.Add(new IdsFilter {
Values = new[] { string.Empty }
});
}
}
}
else if (browseFilter != null) // Predefined filter
{
var filter = ConvertBrowseFilter(browseFilter, term.Values, criteria);
result.RemovableFilters.Add(new KeyValuePair <string, IFilter>(browseFilter.Key, filter));
}
else // Custom term
{
IFilter filter = null;
//Workaround VP-5872: Try to parse range filter from terms first
if (term.Values.Count() == 1 && _searchPhraseParser != null)
{
filter = _searchPhraseParser.Parse($"{term.Key}:{term.Values.First()}").Filters.OfType <RangeFilter>().FirstOrDefault();
}
if (filter == null)
{
filter = FiltersHelper.CreateTermFilter(term.Key, term.Values);
}
result.PermanentFilters.Add(filter);
}
}
}
return(result);
}
public IndexSearchRequestBuilder ParseFilters(ISearchPhraseParser phraseParser, string filterPhrase)
{
if (phraseParser == null)
{
throw new ArgumentNullException(nameof(phraseParser));
}
if (string.IsNullOrEmpty(filterPhrase))
{
return(this);
}
var parseResult = phraseParser.Parse(filterPhrase);
var filters = new List <IFilter>();
foreach (var filter in parseResult.Filters)
{
FilterSyntaxMapper.MapFilterAdditionalSyntax(filter);
if (filter is TermFilter termFilter)
{
var wildcardValues = termFilter.Values.Where(x => new[] { "?", "*" }.Any(x.Contains)).ToArray();
if (wildcardValues.Any())
{
var orFilter = new OrFilter
{
ChildFilters = new List <IFilter>()
};
var wildcardTermFilters = wildcardValues.Select(x => new WildCardTermFilter
{
FieldName = termFilter.FieldName,
Value = x
}).ToList();
orFilter.ChildFilters.AddRange(wildcardTermFilters);
termFilter.Values = termFilter.Values.Except(wildcardValues).ToList();
if (termFilter.Values.Any())
{
orFilter.ChildFilters.Add(termFilter);
}
filters.Add(orFilter);
}
else
{
filters.Add(termFilter);
}
}
else
{
filters.Add(filter);
}
}
AddFiltersToSearchRequest(filters.ToArray());
return(this);
}