public static void ShouldEqual(this FieldFilterValue actual, string expected)
{
if (!actual.Equals(expected))
{
throw new AssertException("Expected \"" + expected + "\" to equal " + actual);
}
}
public override Filter GetFilter()
{
if (!string.IsNullOrEmpty(FieldName) && !string.IsNullOrEmpty(FieldValue))
{
return(new TermFilter($"{FieldName}$$string", FieldFilterValue.Create(FieldValue)));
}
return(null);
}
private TermFilter CreateTermFilter(string fieldName, object value)
{
FieldFilterValue filterValue = null;
if (value is string)
{
filterValue = (string)value;
}
else if (value is int)
{
filterValue = (int)value;
}
else if (value is double)
{
filterValue = (double)value;
}
else if (value is bool)
{
filterValue = (bool)value;
}
else if (value is DateTime)
{
filterValue = (DateTime)value;
}
else if (value is Enum)
{
filterValue = (Enum)value;
}
else if (value is Type)
{
var typeValue = (Type)value;
filterValue = typeValue + ", " + typeValue.Assembly.GetName().Name;
}
var termFilter = new TermFilter(fieldName, filterValue);
return(termFilter);
}
public SlugFilter(string field, FieldFilterValue value) : base(field, value)
{
}
private Filter GetSelectedFilter(List <FacetGroupOption> options, string currentField)
{
var filters = new List <Filter>();
var facets = _facetRegistry.GetFacetDefinitions();
foreach (var facetGroupOption in options)
{
if (facetGroupOption.GroupFieldName.Equals(currentField))
{
continue;
}
var filter = facets.FirstOrDefault(x => x.FieldName.Equals(facetGroupOption.GroupFieldName));
if (filter == null)
{
continue;
}
if (!facetGroupOption.Facets.Any(x => x.Selected))
{
continue;
}
if (filter is FacetStringDefinition)
{
filters.Add(new TermsFilter(_findClient.GetFullFieldName(facetGroupOption.GroupFieldName, typeof(string)),
facetGroupOption.Facets.Where(x => x.Selected).Select(x => FieldFilterValue.Create(x.Name))));
}
else if (filter is FacetStringListDefinition)
{
var termFilters = facetGroupOption.Facets.Where(x => x.Selected)
.Select(s => new TermFilter(facetGroupOption.GroupFieldName, FieldFilterValue.Create(s.Name)))
.Cast <Filter>()
.ToList();
filters.AddRange(termFilters);
}
else if (filter is FacetNumericRangeDefinition)
{
var rangeFilters = filter as FacetNumericRangeDefinition;
foreach (var selectedRange in facetGroupOption.Facets.Where(x => x.Selected))
{
var rangeFilter = rangeFilters.Range.FirstOrDefault(x => x.Id.Equals(selectedRange.Key.Split(':')[1]));
if (rangeFilter == null)
{
continue;
}
filters.Add(RangeFilter.Create(_findClient.GetFullFieldName(facetGroupOption.GroupFieldName, typeof(double)),
rangeFilter.From ?? 0,
rangeFilter.To ?? double.MaxValue));
}
}
}
if (!filters.Any())
{
return(null);
}
if (filters.Count == 1)
{
return(filters.FirstOrDefault());
}
var boolFilter = new BoolFilter();
foreach (var filter in filters)
{
boolFilter.Should.Add(filter);
}
return(boolFilter);
}
public MatchContainedFilter(string field, FieldFilterValue valueToMatch)
{
Field = field;
ValueToMatch = valueToMatch;
FieldSuffix = string.Empty;
}
public MatchFilter(string field, FieldFilterValue valueToMatch)
{
Field = field;
ValueToMatch = valueToMatch;
}
public MinShouldMatchQueryStringQuery(FieldFilterValue query)
: base(query)
{
}
public FieldFilter(string field, FieldFilterValue value)
{
Field = field;
Value = value;
ComparisonOperator = ComparisonOperator.Equals;
}
