/// <summary>
/// Creates the query.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
public static Filter CreateQuery(ISearchCriteria criteria, string field, RangeFilterValue value)
{
var query = new BooleanFilter();
object lowerbound = value.Lower;
object upperbound = value.Upper;
const bool lowerboundincluded = true;
const bool upperboundincluded = false;
var currency = criteria.Currency.ToLower();
var upper = upperbound == null?NumericUtils.LongToPrefixCoded(long.MaxValue) : ConvertToSearchable(upperbound);
// format is "fieldname_store_currency_pricelist"
string[] pls = null;
var searchCriteria = criteria as CatalogIndexedSearchCriteria;
if (searchCriteria != null)
{
pls = searchCriteria.Pricelists;
}
var parentPriceList = String.Empty;
// Create filter of type
// price_USD_pricelist1:[100 TO 200} (-price_USD_pricelist1:[* TO *} +(price_USD_pricelist2:[100 TO 200} (-price_USD_pricelist2:[* TO *} (+price_USD_pricelist3[100 TO 200}))))
if (pls == null || !pls.Any())
{
return(null);
}
var priceListId = pls[0].ToLower();
var filter = new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceListId),
ConvertToSearchable(lowerbound),
upper,
lowerboundincluded,
upperboundincluded);
query.Add(new FilterClause(filter, Occur.SHOULD));
if (pls.Count() > 1)
{
var q = CreatePriceRangeQuery(
pls,
1,
field,
currency,
ConvertToSearchable(lowerbound),
upper,
lowerboundincluded,
upperboundincluded);
query.Add(new FilterClause(q, Occur.SHOULD));
}
return(query);
}
public void TestCombinedNullDocIdSets()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.MUST);
TstFilterCard(@"A MUST filter that returns a null DIS should never return documents", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.MUST);
TstFilterCard(@"A MUST filter that returns a null DISI should never return documents", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.SHOULD);
TstFilterCard(@"A SHOULD filter that returns a null DIS should be invisible", 1, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.SHOULD);
TstFilterCard(@"A SHOULD filter that returns a null DISI should be invisible", 1, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"A MUST_NOT filter that returns a null DIS should be invisible", 1, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"A MUST_NOT filter that returns a null DISI should be invisible", 1, booleanFilter);
}
private FacetGroup CalculateResultCount(IndexReader reader, DocIdSet baseDocIdSet, ISearchFilter filter, ISearchCriteria criteria)
{
FacetGroup result = null;
var values = filter.GetValues();
if (values != null)
{
BooleanFilter ffilter = null;
foreach (var f in criteria.CurrentFilters)
{
if (!f.Key.Equals(filter.Key))
{
if (ffilter == null)
{
ffilter = new BooleanFilter();
}
var q = LuceneQueryHelper.CreateQuery(criteria, f, Occur.SHOULD);
ffilter.Add(new FilterClause(q, Occur.MUST));
}
}
var groupLabels = filter.GetLabels();
var facetGroup = new FacetGroup(filter.Key, groupLabels);
foreach (var group in values.GroupBy(v => v.Id))
{
var value = group.FirstOrDefault();
var valueFilter = LuceneQueryHelper.CreateQueryForValue(Results.SearchCriteria, filter, value);
if (valueFilter != null)
{
var queryFilter = new BooleanFilter();
queryFilter.Add(new FilterClause(valueFilter, Occur.MUST));
if (ffilter != null)
{
queryFilter.Add(new FilterClause(ffilter, Occur.MUST));
}
var filterArray = queryFilter.GetDocIdSet(reader);
var newCount = (int)CalculateFacetCount(baseDocIdSet, filterArray);
if (newCount > 0)
{
var valueLabels = group.GetValueLabels();
var newFacet = new Facet(facetGroup, group.Key, newCount, valueLabels);
facetGroup.Facets.Add(newFacet);
}
}
}
if (facetGroup.Facets.Any())
{
result = facetGroup;
}
}
return(result);
}
public void TestToStringOfBooleanFilterContainingTermsFilter()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetTermsFilter(@"isFragile", @"Y"), BooleanClause.Occur.MUST);
assertEquals(@"BooleanFilter(+inStock:N +isFragile:Y)", booleanFilter.ToString());
}
public void TestShoulds()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
TstFilterCard(@"Shoulds are Ored together", 5, booleanFilter);
}
/// <summary>
/// Calculates the result count.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="baseDocIdSet">The base doc id set.</param>
/// <param name="facetGroup">The facet group.</param>
/// <param name="filter">The filter.</param>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
private int CalculateResultCount(IndexReader reader, DocIdSet baseDocIdSet, FacetGroup facetGroup, ISearchFilter filter, ISearchCriteria criteria)
{
var count = 0;
var values = LuceneQueryHelper.GetFilterValues(filter);
if (values == null)
{
return(0);
}
BooleanFilter ffilter = null;
foreach (var f in criteria.CurrentFilters)
{
if (!f.Key.Equals(facetGroup.FieldName))
{
if (ffilter == null)
{
ffilter = new BooleanFilter();
}
var q = LuceneQueryHelper.CreateQuery(criteria, f, Occur.SHOULD);
ffilter.Add(new FilterClause(q, Occur.MUST));
}
}
foreach (var value in values)
{
var queryFilter = new BooleanFilter();
var valueFilter = LuceneQueryHelper.CreateQueryForValue(Results.SearchCriteria, filter, value);
if (valueFilter == null)
{
continue;
}
queryFilter.Add(new FilterClause(valueFilter, Occur.MUST));
if (ffilter != null)
{
queryFilter.Add(new FilterClause(ffilter, Occur.MUST));
}
var filterArray = queryFilter.GetDocIdSet(reader);
var newCount = (int)CalculateFacetCount(baseDocIdSet, filterArray);
if (newCount == 0)
{
continue;
}
var newFacet = new Facet(facetGroup, value.Id, GetDescription(value, Results.SearchCriteria.Locale), newCount);
facetGroup.Facets.Add(newFacet);
count += newCount;
}
return(count);
}
public void TestShouldsAndMusts()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetRangeFilter(@"date", @"20040101", @"20041231"), BooleanClause.Occur.MUST);
TstFilterCard(@"Shoulds Ored but MUSTs ANDED", 1, booleanFilter);
}
/// <summary>
/// Creates the price range query.
/// </summary>
/// <param name="priceLists">The price lists.</param>
/// <param name="index">The index.</param>
/// <param name="field">The field.</param>
/// <param name="currency">The currency.</param>
/// <param name="lowerbound">The lowerbound.</param>
/// <param name="upperbound">The upperbound.</param>
/// <param name="lowerboundincluded">
/// if set to <c>true</c> [lowerboundincluded].
/// </param>
/// <param name="upperboundincluded">
/// if set to <c>true</c> [upperboundincluded].
/// </param>
/// <returns></returns>
private static BooleanFilter CreatePriceRangeQuery(
string[] priceLists,
int index,
string field,
string currency,
string lowerbound,
string upperbound,
bool lowerboundincluded,
bool upperboundincluded)
{
var query = new BooleanFilter();
// create left part
var filter =
new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
"*",
"*",
true,
false);
var leftClause = new FilterClause(filter, Occur.MUST_NOT);
query.Add(leftClause);
// create right part
if (index == priceLists.Count()) // last element
{
//var rangefilter = NumericRangeFilter.;
var filter2 =
new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded);
var rightClause = new FilterClause(filter2, Occur.MUST);
query.Add(rightClause);
}
else
{
query.Add(new FilterClause(
CreatePriceRangeQuery(
priceLists,
index + 1,
field,
currency,
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded),
Occur.SHOULD));
}
return(query);
}
public void TestMustAndMustNot()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"MUST_NOT wins over MUST for same docs", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetWrappedTermQuery(@"price", @"030"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"MUST_NOT wins over MUST for same docs", 0, booleanFilter);
}
public void TestMustAndMustNot()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), Occur.MUST);
booleanFilter.Add(GetTermsFilter(@"price", @"030"), Occur.MUST_NOT);
TstFilterCard(@"MUST_NOT wins over MUST for same docs", 0, booleanFilter);
// same with a real DISI (no OpenBitSetIterator)
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), Occur.MUST);
booleanFilter.Add(GetWrappedTermQuery(@"price", @"030"), Occur.MUST_NOT);
TstFilterCard(@"MUST_NOT wins over MUST for same docs", 0, booleanFilter);
}
public void TestShouldsAndMust()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
TstFilterCard(@"Shoulds Ored but MUST", 3, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetWrappedTermQuery(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
TstFilterCard(@"Shoulds Ored but MUST", 3, booleanFilter);
}
public static Filter JoinNonEmptyFilters(IEnumerable <Filter> filters, Occur occur)
{
Filter result = null;
if (filters != null)
{
var childFilters = filters.Where(f => f != null).ToArray();
if (childFilters.Length > 1)
{
var booleanFilter = new BooleanFilter();
foreach (var filter in childFilters)
{
booleanFilter.Add(new FilterClause(filter, occur));
}
result = booleanFilter;
}
else if (childFilters.Length > 0)
{
result = childFilters.First();
}
}
return(result);
}
public void TestShouldsAndMustsAndMustNot()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"030", @"040"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetRangeFilter(@"date", @"20050101", @"20051231"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but MUSTs ANDED and MustNot", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"030", @"040"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetWrappedTermQuery(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetRangeFilter(@"date", @"20050101", @"20051231"), BooleanClause.Occur.MUST);
booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but MUSTs ANDED and MustNot", 0, booleanFilter);
}
public void TestJustNullDocIdSets()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetNullDISFilter(), Occur.MUST);
TstFilterCard(@"A MUST filter that returns a null DIS should never return documents", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetNullDISIFilter(), Occur.MUST);
TstFilterCard(@"A MUST filter that returns a null DISI should never return documents", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetNullDISFilter(), Occur.SHOULD);
TstFilterCard(@"A single SHOULD filter that returns a null DIS should never return documents", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetNullDISIFilter(), Occur.SHOULD);
TstFilterCard(@"A single SHOULD filter that returns a null DISI should never return documents", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetNullDISFilter(), Occur.MUST_NOT);
TstFilterCard(@"A single MUST_NOT filter that returns a null DIS should be invisible", 5, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetNullDISIFilter(), Occur.MUST_NOT);
TstFilterCard(@"A single MUST_NOT filter that returns a null DIS should be invisible", 5, booleanFilter);
}
public void TestShouldsAndMust()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), Occur.SHOULD);
booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), Occur.MUST);
TstFilterCard(@"Shoulds Ored but MUST", 3, booleanFilter);
// same with a real DISI (no OpenBitSetIterator)
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), Occur.SHOULD);
booleanFilter.Add(GetWrappedTermQuery(@"accessRights", @"admin"), Occur.MUST);
TstFilterCard(@"Shoulds Ored but MUST", 3, booleanFilter);
}
public void TestNonMatchingShouldsAndMusts()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetEmptyFilter(), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
TstFilterCard(@">0 shoulds with no matches should return no docs", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
TstFilterCard(@">0 shoulds with no matches should return no docs", 0, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
TstFilterCard(@">0 shoulds with no matches should return no docs", 0, booleanFilter);
}
public void SearchText_UserDateFilter(int count)
{
if (UserQuery != null)
{
if (DateFilter != null)
{
if (UserFilter != null)
{
var filter = new BooleanFilter();
filter.Add(new FilterClause(DateFilter, Occur.MUST));
filter.Add(new FilterClause(UserFilter, Occur.MUST));
Hits = LuceneService.Searcher.Search(UserQuery, filter, count);
}
}
}
}
public void TestShouldsAndMustNot()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but AndNot", 4, booleanFilter);
booleanFilter.Add(GetTermsFilter(@"inStock", @"Maybe"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but AndNots", 3, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but AndNot", 4, booleanFilter);
booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"Maybe"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but AndNots", 3, booleanFilter);
}
public void TestToStringOfWrappedBooleanFilters()
{
BooleanFilter orFilter = new BooleanFilter();
BooleanFilter stockFilter = new BooleanFilter();
stockFilter.Add(new FilterClause(GetTermsFilter(@"inStock", @"Y"), BooleanClause.Occur.MUST));
stockFilter.Add(new FilterClause(GetTermsFilter(@"barCode", @"12345678"), BooleanClause.Occur.MUST));
orFilter.Add(new FilterClause(stockFilter, BooleanClause.Occur.SHOULD));
BooleanFilter productPropertyFilter = new BooleanFilter();
productPropertyFilter.Add(new FilterClause(GetTermsFilter(@"isHeavy", @"N"), BooleanClause.Occur.MUST));
productPropertyFilter.Add(new FilterClause(GetTermsFilter(@"isDamaged", @"Y"), BooleanClause.Occur.MUST));
orFilter.Add(new FilterClause(productPropertyFilter, BooleanClause.Occur.SHOULD));
BooleanFilter composedFilter = new BooleanFilter();
composedFilter.Add(new FilterClause(orFilter, BooleanClause.Occur.MUST));
assertEquals(@"BooleanFilter(+BooleanFilter(BooleanFilter(+inStock:Y +barCode:12345678) BooleanFilter(+isHeavy:N +isDamaged:Y)))", composedFilter.ToString());
}
public void TestShould()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.SHOULD);
TstFilterCard(@"Should retrieves only 1 doc", 1, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetWrappedTermQuery(@"price", @"030"), BooleanClause.Occur.SHOULD);
TstFilterCard(@"Should retrieves only 1 doc", 1, booleanFilter);
}
public void TestJustMust()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
TstFilterCard(@"MUST", 3, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetWrappedTermQuery(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
TstFilterCard(@"MUST", 3, booleanFilter);
}
public void TestJustMustNot()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"MUST_NOT", 4, booleanFilter);
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
TstFilterCard(@"MUST_NOT", 4, booleanFilter);
}
public void TestJustMustNot()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), Occur.MUST_NOT);
TstFilterCard(@"MUST_NOT", 4, booleanFilter);
// same with a real DISI (no OpenBitSetIterator)
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), Occur.MUST_NOT);
TstFilterCard(@"MUST_NOT", 4, booleanFilter);
}
public void TestJustMust()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), Occur.MUST);
TstFilterCard(@"MUST", 3, booleanFilter);
// same with a real DISI (no OpenBitSetIterator)
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetWrappedTermQuery(@"accessRights", @"admin"), Occur.MUST);
TstFilterCard(@"MUST", 3, booleanFilter);
}
public void TestShould()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetTermsFilter(@"price", @"030"), Occur.SHOULD);
TstFilterCard(@"Should retrieves only 1 doc", 1, booleanFilter);
// same with a real DISI (no OpenBitSetIterator)
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetWrappedTermQuery(@"price", @"030"), Occur.SHOULD);
TstFilterCard(@"Should retrieves only 1 doc", 1, booleanFilter);
}
public Task Filter(AdminSearchContext searchContext, BooleanFilter booleanFilter)
{
var contentTypeFilter = searchContext.Filters.FirstOrDefault(x => x.Key == IndexField);
if (contentTypeFilter.Value == null)
{
return(Task.CompletedTask);
}
booleanFilter.Add(new FilterClause(new FieldCacheTermsFilter(contentTypeFilter.Key, contentTypeFilter.Value), Occur.MUST));
return(Task.CompletedTask);
}
public static Filter GetFilterForUser(User u)
{
BooleanFilter userFilter = new BooleanFilter();
foreach (string rolename in u.Roles)
{
// call GetFilterForRole and add to the BooleanFilter
userFilter.Add(
new BooleanFilterClause(GetFilterForRole(rolename), BooleanClause.Occur.SHOULD)
);
}
return(userFilter);
}
public void TestShouldsAndMustNot()
{
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), Occur.SHOULD);
booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but AndNot", 4, booleanFilter);
booleanFilter.Add(GetTermsFilter(@"inStock", @"Maybe"), Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but AndNots", 3, booleanFilter);
// same with a real DISI (no OpenBitSetIterator)
booleanFilter = new BooleanFilter();
booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), Occur.SHOULD);
booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), Occur.SHOULD);
booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but AndNot", 4, booleanFilter);
booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"Maybe"), Occur.MUST_NOT);
TstFilterCard(@"Shoulds Ored but AndNots", 3, booleanFilter);
}
/// <summary>
/// Creates the query.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
public static Filter CreateQuery(string field, CategoryFilterValue value)
{
var query = new BooleanFilter();
if (!String.IsNullOrEmpty(value.Outline))
{
// workaround since there is no wildcard filter in current lucene version
var outline = value.Outline.TrimEnd('*');
var nodeQuery = new PrefixFilter(new Term(field, outline.ToLower()));
query.Add(new FilterClause(nodeQuery, Occur.MUST));
}
return(query);
}
public static Filter CreateQuery(ISearchCriteria criteria, ISearchFilter filter, Occur clause)
{
var values = GetFilterValues(filter);
if (values == null) return null;
var query = new BooleanFilter();
foreach (var value in values)
{
var valueQuery = CreateQueryForValue(criteria, filter, value);
query.Add(new FilterClause(valueQuery, Occur.SHOULD));
}
return query;
}
private static Filter CreateNotFilter(NotFilter notFilter, ICollection <string> availableFields)
{
Filter result = null;
var childFilter = GetFilterRecursive(notFilter.ChildFilter, availableFields);
if (childFilter != null)
{
var booleanFilter = new BooleanFilter();
booleanFilter.Add(new FilterClause(childFilter, Occur.MUST_NOT));
result = booleanFilter;
}
return(result);
}
/// <summary>
/// Builds the query.
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
public virtual object BuildQuery(ISearchCriteria criteria)
{
var queryBuilder = new QueryBuilder();
var queryFilter = new BooleanFilter();
var query = new BooleanQuery();
queryBuilder.Query = query;
queryBuilder.Filter = queryFilter;
if (criteria.CurrentFilters != null)
{
foreach (var filter in criteria.CurrentFilters)
{
// Skip currencies that are not part of the filter
if (filter.GetType() == typeof(PriceRangeFilter)) // special filtering
{
var currency = (filter as PriceRangeFilter).Currency;
if (!currency.Equals(criteria.Currency, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
var filterQuery = LuceneQueryHelper.CreateQuery(criteria, filter, Occur.SHOULD);
// now add other values that should also be counted?
if (filterQuery != null)
{
var clause = new FilterClause(filterQuery, Occur.MUST);
queryFilter.Add(clause);
}
}
}
return queryBuilder;
}
/// <summary>
/// Creates the query.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
public static Filter CreateQuery(string field, CategoryFilterValue value)
{
var query = new BooleanFilter();
if (!String.IsNullOrEmpty(value.Outline))
{
// workaround since there is no wildcard filter in current lucene version
var outline = value.Outline.TrimEnd('*');
var nodeQuery = new PrefixFilter(new Term(field, outline.ToLower()));
query.Add(new FilterClause(nodeQuery, Occur.MUST));
}
return query;
}
/// <summary>
/// Calculates the result count.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="baseDocIdSet">The base doc id set.</param>
/// <param name="facetGroup">The facet group.</param>
/// <param name="filter">The filter.</param>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
private int CalculateResultCount(IndexReader reader, DocIdSet baseDocIdSet, FacetGroup facetGroup, ISearchFilter filter, ISearchCriteria criteria)
{
var count = 0;
var values = LuceneQueryHelper.GetFilterValues(filter);
if (values == null)
{
return 0;
}
BooleanFilter ffilter = null;
foreach (var f in criteria.CurrentFilters)
{
if (!f.Key.Equals(facetGroup.FieldName))
{
if (ffilter == null) ffilter = new BooleanFilter();
var q = LuceneQueryHelper.CreateQuery(criteria, f, Occur.SHOULD);
ffilter.Add(new FilterClause(q, Occur.MUST));
}
}
foreach (var value in values)
{
var queryFilter = new BooleanFilter();
var valueFilter = LuceneQueryHelper.CreateQueryForValue(Results.SearchCriteria, filter, value);
if (valueFilter == null) continue;
queryFilter.Add(new FilterClause(valueFilter, Occur.MUST));
if(ffilter!=null)
queryFilter.Add(new FilterClause(ffilter, Occur.MUST));
var filterArray = queryFilter.GetDocIdSet(reader);
var newCount = (int)CalculateFacetCount(baseDocIdSet, filterArray);
if (newCount == 0) continue;
var newFacet = new Facet(facetGroup, value.Id, GetDescription(value, Results.SearchCriteria.Locale), newCount);
facetGroup.Facets.Add(newFacet);
count += newCount;
}
return count;
}
/// <summary>
/// Creates the query.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
public static Filter CreateQuery(ISearchCriteria criteria, string field, RangeFilterValue value)
{
var query = new BooleanFilter();
object lowerbound = value.Lower;
object upperbound = value.Upper;
const bool lowerboundincluded = true;
const bool upperboundincluded = false;
var currency = criteria.Currency.ToLower();
var upper = upperbound == null ? NumericUtils.LongToPrefixCoded(long.MaxValue) : ConvertToSearchable(upperbound);
// format is "fieldname_store_currency_pricelist"
string[] pls = null;
var searchCriteria = criteria as CatalogItemSearchCriteria;
if (searchCriteria != null)
{
pls = searchCriteria.Pricelists;
}
var parentPriceList = String.Empty;
// Create filter of type
// price_USD_pricelist1:[100 TO 200} (-price_USD_pricelist1:[* TO *} +(price_USD_pricelist2:[100 TO 200} (-price_USD_pricelist2:[* TO *} (+price_USD_pricelist3[100 TO 200}))))
if (pls == null || !pls.Any())
{
return null;
}
var priceListId = pls[0].ToLower();
var filter = new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceListId),
ConvertToSearchable(lowerbound),
upper,
lowerboundincluded,
upperboundincluded);
query.Add(new FilterClause(filter, Occur.SHOULD));
if (pls.Count() > 1)
{
var q = CreatePriceRangeQuery(
pls,
1,
field,
currency,
ConvertToSearchable(lowerbound),
upper,
lowerboundincluded,
upperboundincluded);
query.Add(new FilterClause(q, Occur.SHOULD));
}
return query;
}
/// <summary>
/// Creates the price range query.
/// </summary>
/// <param name="priceLists">The price lists.</param>
/// <param name="index">The index.</param>
/// <param name="field">The field.</param>
/// <param name="currency">The currency.</param>
/// <param name="lowerbound">The lowerbound.</param>
/// <param name="upperbound">The upperbound.</param>
/// <param name="lowerboundincluded">
/// if set to <c>true</c> [lowerboundincluded].
/// </param>
/// <param name="upperboundincluded">
/// if set to <c>true</c> [upperboundincluded].
/// </param>
/// <returns></returns>
private static BooleanFilter CreatePriceRangeQuery(
string[] priceLists,
int index,
string field,
string currency,
string lowerbound,
string upperbound,
bool lowerboundincluded,
bool upperboundincluded)
{
var query = new BooleanFilter();
// create left part
var filter =
new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
"*",
"*",
true,
false);
var leftClause = new FilterClause(filter, Occur.MUST_NOT);
query.Add(leftClause);
// create right part
if (index == priceLists.Count()) // last element
{
//var rangefilter = NumericRangeFilter.;
var filter2 =
new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded);
var rightClause = new FilterClause(filter2, Occur.MUST);
query.Add(rightClause);
}
else
{
query.Add(new FilterClause(
CreatePriceRangeQuery(
priceLists,
index + 1,
field,
currency,
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded),
Occur.SHOULD));
}
return query;
}
