public PostsViewerViewModel(ICanPersistData dataPersistenceService,
ISearchFilter <FluentNHibernateSQLiteCSharp.Entities.Post> searchfilter,
IPostService postService, IValidationService validationService)
: base(dataPersistenceService, searchfilter, validationService)
{
ItemsList = postService.GetAllPosts();
}
public static ISearchFilterValue[] GetValues(this ISearchFilter filter)
{
var attributeFilter = filter as AttributeFilter;
if (attributeFilter != null)
{
return(attributeFilter.Values);
}
var rangeFilter = filter as RangeFilter;
if (rangeFilter != null)
{
return(rangeFilter.Values);
}
var priceRangeFilter = filter as PriceRangeFilter;
if (priceRangeFilter != null)
{
return(priceRangeFilter.Values);
}
var categoryFilter = filter as CategoryFilter;
if (categoryFilter != null)
{
return(categoryFilter.Values);
}
return(null);
}
public async Task <SearchResult <Entry> > GetArticlesByTag(string tagKey)
{
var searchFilters = new ISearchFilter[] {
new EqualitySearchFilter(BuiltInProperties.ContentType, contentType),
new EqualitySearchFilter("fields.tags", tagKey.ToLower())
};
try
{
var articles = await contentfulClient.SearchAsync <Entry>(cancellationToken, searchFilters);
if (articles.Total == 0)
{
return new SearchResult <Entry> {
Total = 0, Items = null
}
}
;
return(articles);
}
catch (Exception Ex)
{
return(null);
}
}
public void Initialize()
{
_modifierName = "Alex";
_bins = ProductsListInitializer.InitFakeList().AsQueryable();
_filter = new LastModifiedByFilter();
}
/// <summary>
/// Search for Assets that match filters defined in an ISearchFilter object.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public ResponseCollection <T> FindAll(ISearchFilter filter)
{
string response = _reqManager.Get(_endPoint, filter);
ResponseCollection <T> results = JsonConvert.DeserializeObject <ResponseCollection <T> >(response);
return(results);
}
public static IQueryable <T> AddFilter <T>(this IQueryable <T> queryable, ISearchFilter <T> filter)
where T : SearchResultItem
{
queryable = queryable.Filter(filter.Filter());
return(queryable);
}
public virtual void Apply(ISearchFilter filter)
{
if (filter != null)
{
_appliedFilters.Add(filter);
}
}
public static BoolFilter<ESDocument> CreateQueryForValue(ISearchCriteria criteria, ISearchFilter filter, ISearchFilterValue value)
{
var query = new BoolFilter<ESDocument>();
var field = filter.Key.ToLower();
if (filter.GetType() == typeof(PriceRangeFilter))
{
var tempQuery = CreatePriceRangeFilter(criteria, field, value as RangeFilterValue);
if (tempQuery != null)
{
query.Must(q => q.Bool(b => tempQuery));
}
}
else
{
if (value.GetType() == typeof(AttributeFilterValue))
{
query.Must(q => q.Term(t=>t.Field(field).Value(((AttributeFilterValue)value).Value)));
}
else if (value.GetType() == typeof(RangeFilterValue))
{
var tempValue = value as RangeFilterValue;
var tempFilter = new RangeFilter<ESDocument>();
tempFilter.Field(field).From(tempValue.Lower).To(tempValue.Upper).IncludeLower(true).IncludeUpper(false);
query.Should(q => q.Range(r => tempFilter));
}
}
return query;
}
public TransactionsViewerViewModel(ICanPersistData dataPersistenceService,
ISearchFilter <Transaction> searchfilter,
ITransactionService transactionService, IValidationService validationService)
: base(dataPersistenceService, searchfilter, validationService)
{
ItemsList = transactionService.GetAllTransactions();
}
private static bool FilterAsset(string assetPath, string filterClassName)
{
// 根据规则设置获取标签名称
ISearchFilter filter = GetSearchFilterInstance(filterClassName);
return(filter.FilterAsset(assetPath));
}
private void AssertIsValidFilterInstance(ISearchFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
}
/// <summary>
/// Converts the specified filter to filter model.
/// </summary>
/// <param name="helper"></param>
/// <param name="filter">The search filter.</param>
/// <returns>Filter model</returns>
public static FilterModel Convert(this SearchHelper helper, ISearchFilter filter)
{
var model = new FilterModel();
if (filter is AttributeFilter)
{
var prop = filter as AttributeFilter;
model.Key = prop.Key;
model.Name = helper.CatalogClient.GetPropertyName(prop.Key);
model.Name = string.IsNullOrEmpty(model.Name) ? model.Key : model.Name;
return model;
}
if (filter is RangeFilter)
{
var prop = filter as RangeFilter;
model.Key = prop.Key;
model.Name = helper.CatalogClient.GetPropertyName(prop.Key);
model.Name = string.IsNullOrEmpty(model.Name) ? model.Key : model.Name;
return model;
}
if (filter is PriceRangeFilter)
{
var prop = filter as PriceRangeFilter;
model.Key = prop.Key;
model.Name = "Price";
return model;
}
return null;
}
/// <summary>
/// Finds all objects that match the filter and returns the first
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public T FindOne(ISearchFilter filter)
{
string response = ReqManager.Get(EndPoint, filter);
var result = JsonConvert.DeserializeObject <ResponseCollection <T> >(response);
return(result?.Rows?.FirstOrDefault());
}
/// <summary>
/// Finds all objects that match the filter and returns the first
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public T FindOne(ISearchFilter filter)
{
string response = _reqManager.Get(_endPoint, filter);
ResponseCollection <T> result = JsonConvert.DeserializeObject <ResponseCollection <T> >(response);
return((result.Rows != null) ? result.Rows[0] : default(T));
}
public static ISearchFilterValue[] GetValues(this ISearchFilter filter)
{
var attributeFilter = filter as AttributeFilter;
if (attributeFilter != null)
{
return(attributeFilter.Values != null?attributeFilter.Values.OfType <ISearchFilterValue>().ToArray() : null);
}
var rangeFilter = filter as RangeFilter;
if (rangeFilter != null)
{
return(rangeFilter.Values != null?rangeFilter.Values.OfType <ISearchFilterValue>().ToArray() : null);
}
var priceRangeFilter = filter as PriceRangeFilter;
if (priceRangeFilter != null)
{
return(priceRangeFilter.Values != null?priceRangeFilter.Values.OfType <ISearchFilterValue>().ToArray() : null);
}
var categoryFilter = filter as CategoryFilter;
if (categoryFilter != null)
{
return(categoryFilter.Values != null?categoryFilter.Values.OfType <ISearchFilterValue>().ToArray() : null);
}
return(null);
}
public DonatorsViewerViewModel(IDonatorService donatorService,
ICanPersistData dataPersistenceService,
ISearchFilter <Donator> searchFilter,
IValidationService validationService)
: base(dataPersistenceService, searchFilter, validationService)
{
ItemsList = donatorService.GetAllDonators();
}
/// <summary>
/// Adds to the search filter history lists and RecentSearch
/// </summary>
/// <param name="filter">The filter.</param>
private void AddToSearchHistory(ISearchFilter filter)
{
Log($"Adding filter to search history");
_searchHistory.RecentSearches.Add(new SearchHistory()
{
Filter = filter,
});
}
/// <summary>
/// Creates a new instance of <see cref="ModSearchRequestBuilder" />
/// </summary>
/// <param name="client">The <see cref="ModrinthClient" /> to build with</param>
public ModSearchRequestBuilder(ModrinthClient client) : base(client)
{
Limit = 10;
Offset = 0;
Query = string.Empty;
Filter = null;
Indexing = SearchIndex.Relevance;
}
public CombinedSearchFilter Add(ISearchFilter filter)
{
Guard.NotNull(filter, nameof(filter));
_filters.Add(filter);
return(this);
}
public static bool Unregister(ISearchFilter searchFilter)
{
if (searchFilter is null)
{
throw new ArgumentNullException(nameof(searchFilter));
}
return(_filters.TryRemove(new(searchFilter.Key, searchFilter)));
}
public void SetSearchFilter(string searchFilter)
{
if (string.IsNullOrWhiteSpace(searchFilter))
{
_searchFilter = null;
return;
}
_searchFilter = _searchFilterFromConstructor;
_searchFilter.SetSearch(searchFilter);
}
public void GetRequestUrlReturnsFiltersOnly()
{
var filters = new ISearchFilter[]
{
new EqualitySearchFilter("title", "hello"),
new EqualitySearchFilter("name", "test")
};
var result = ContentfulClient.GetRequestUrl(RequestBaseUrl, filters: filters);
Assert.AreEqual("http://test.com/?title=hello&name=test", result);
}
public ViewerViewModelBase(ICanPersistData dataPersistenceService, ISearchFilter <T> searchfilter,
IValidationService validationService)
{
_dataPersistenceService = dataPersistenceService;
_searchfilter = searchfilter;
_validationService = validationService;
_valueToFilterOn = _propertyToFilterOn = string.Empty;
_itemsList = new List <T>();
SaveChangesCommand = new RelayCommand(param => PersistData());
InitializeFilterCriterias();
}
public void AddOrUpdateFilter(ISearchFilter searchFilter)
{
if (searchFilter == null)
{
return;
}
var searchFilterType = searchFilter.GetType();
filters[searchFilterType] = searchFilter;
}
/// <summary>
/// Default method to be called for filter types for that type-specific handling was not implemented.
/// </summary>
/// <param name="filter">Filter to handle.</param>
/// <remarks>
/// This is the default Visit method that should be called only for parameter of type
/// that is not handled by Visit methods defined for specific filter types.
/// </remarks>
public void Visit(ISearchFilter filter)
{
AssertIsValidFilterInstance(filter);
Label filteringNotSupportedInfo = new Label();
filteringNotSupportedInfo.Content = "Filtering control is not available for this filter type.";
filteringNotSupportedInfo.ToolTip = filter.Description;
FilterControl = GetControlForFilter(filteringNotSupportedInfo, filter);
}
public void SetSearchFilter(string searchFilter)
{
if (string.IsNullOrWhiteSpace(searchFilter))
{
this._searchFilter = (ISearchFilter <T>)null;
}
else
{
this._searchFilter = this._searchFilterFromConstructor;
this._searchFilter.SetSearch(searchFilter);
}
}
public void TestQueryStringReturnsForValidFilters()
{
var filters = new ISearchFilter[]
{
new SkipSearchFilter(0),
new LimitSearchFilter(15),
new EqualitySearchFilter("test", "true"),
};
var result = ContentfulClient.GetQueryStringFromSearchFilters(filters);
const string expectedQueryString = "skip=0&limit=15&test=true";
Assert.AreEqual(expectedQueryString, result);
}
/// <inheritdoc />
internal override void Resolve(ISearchFilter filter = null)
{
if (null != _objects)
{
return;
}
try
{
var endPoint = ApiHelper.Instance.Assets;
if (BindingType.Integer == QueryUnion.Type)
{
var result = endPoint.GetOptional(QueryUnion.IntegerValue);
Value = result.HasValue ? new Asset[] { result.Value } : new Asset[0];
Error = result.Exception;
}
else if (BindingType.String == QueryUnion.Type)
{
int id; // used later for parsing integers
ApiOptionalResponse <Asset> result;
ApiOptionalMultiResponse <Asset> multiResponse; // used later for retrieving by serial
switch (ParseQuery(QueryUnion.StringValue, out var tag, out var value))
{
case BindingQueryType.Absent:
// tag -> serial -> name -> id
result = endPoint.GetByTagOptional(value);
if (result.HasValue)
{
break;
}
multiResponse = endPoint.FindBySerialOptional(value);
if (multiResponse.HasValue)
{
Value = multiResponse.Value;
Error = multiResponse.Exception;
return;
}
result = endPoint.GetOptional(value, QueryUnion.CaseSensitive);
if (result.HasValue)
{
break;
}
else if (int.TryParse(value, out id))
{
result = endPoint.GetOptional(id);
}
else
{
// fall back to search as the last-ditch try.
goto case BindingQueryType.Search;
}
break;
public QueryPlan <Album> BuildPlan(string query)
{
var words = SearchParser.ParseQuery(query);
var filters = new List <ISearchFilter <Album> >();
var names = words.TakeAll(string.Empty);
if (names.Any())
{
filters.Add(new AlbumNameFilter(names.Select(n => n.Value)));
}
var artists = words.TakeAll("artist");
if (artists.Any())
{
filters.Add(new AlbumArtistNameFilter(artists.Select(n => n.Value)));
}
while (words.Any())
{
var word = words.TakeNext();
ISearchFilter <Album> filter = null;
switch (word.PropertyName.ToLowerInvariant())
{
case "artistId":
int artistId;
if (int.TryParse(word.Value, out artistId))
{
filter = new AlbumArtistFilter(artistId);
}
break;
case "tag":
filter = new AlbumTagFilter(word.Value);
break;
default:
filter = new AlbumNameFilter(new[] { word.Value });
break;
}
if (filter != null)
{
filters.Add(filter);
}
}
return(new QueryPlan <Album>(filters));
}
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;
}
/// <inheritdoc />
internal override void Resolve(ISearchFilter filter = null)
{
if (null != _objects)
{
return;
}
try
{
var endPoint = ApiHelper.Instance.Users;
if (BindingType.Integer == QueryUnion.Type)
{
var result = endPoint.GetOptional(QueryUnion.IntegerValue);
Value = result.HasValue ? new User[] { result.Value } : new User[0];
Error = result.Exception;
}
else if (BindingType.String == QueryUnion.Type)
{
int id; // used later for parsing integers
ApiOptionalResponse <User> result;
var userFilter = filter as UserSearchFilter ?? new UserSearchFilter();
switch (ParseQuery(QueryUnion.StringValue, out var tag, out var value))
{
case BindingQueryType.Absent:
// username -> email -> name -> id
result = endPoint.GetByUserNameOptional(value, userFilter);
if (result.HasValue)
{
break;
}
result = endPoint.GetByEmailAddressOptional(value, userFilter);
if (result.HasValue)
{
break;
}
result = endPoint.GetOptional(value, QueryUnion.CaseSensitive);
if (result.HasValue)
{
break;
}
else if (int.TryParse(value, out id))
{
result = endPoint.GetOptional(id);
}
else
{
// fall back to search as the last-ditch try.
goto case BindingQueryType.Search;
}
break;
public static ISearchFilter Convert(this ISearchFilterService helper, ISearchFilter filter, string[] keys)
{
// get values that we have filters set for
var values = from v in filter.GetValues() where keys.Contains(v.Id) select v;
var attributeFilter = filter as AttributeFilter;
if (attributeFilter != null)
{
var newFilter = new AttributeFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType <AttributeFilterValue>().ToArray();
return(newFilter);
}
var rangeFilter = filter as RangeFilter;
if (rangeFilter != null)
{
var newFilter = new RangeFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType <RangeFilterValue>().ToArray();
return(newFilter);
}
var priceRangeFilter = filter as PriceRangeFilter;
if (priceRangeFilter != null)
{
var newFilter = new PriceRangeFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType <RangeFilterValue>().ToArray();
return(newFilter);
}
var categoryFilter = filter as CategoryFilter;
if (categoryFilter != null)
{
var newFilter = new CategoryFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType <CategoryFilterValue>().ToArray();
return(newFilter);
}
return(null);
}
public string Get(string path, ISearchFilter filter)
{
CheckApiTokenAndUrl();
path = path + "?" + this.QueryParameterBuilder.GetParameters(filter);
var result = string.Empty;
var response = Task.Run(() => Client.GetAsync(path)).Result;
if (response.IsSuccessStatusCode)
{
result = response.Content.ReadAsStringAsync().Result;
}
return(result);
}
public static BoolFilter<ESDocument> CreateQuery(ISearchCriteria criteria, ISearchFilter filter)
{
var values = GetFilterValues(filter);
if (values == null) return null;
var query = new BoolFilter<ESDocument>();
foreach (var value in values)
{
var valueQuery = CreateQueryForValue(criteria, filter, value);
//var boolQuery = new Query<ESDocument>();
//boolQuery.Bool(x => valueQuery);
query.Should(x=>x.Bool(y=>valueQuery));
}
return query;
}
public static Filter CreateQueryForValue(ISearchCriteria criteria, ISearchFilter filter, ISearchFilterValue value)
{
Filter q = null;
var priceQuery = filter is PriceRangeFilter;
if (value is RangeFilterValue && priceQuery)
{
q = LuceneQueryHelper.CreateQuery(
criteria, filter.Key, value as RangeFilterValue);
}
else if (value is CategoryFilterValue)
{
q = CreateQuery(filter.Key, value as CategoryFilterValue);
}
else
{
q = CreateQuery(filter.Key, value);
}
return q;
}
public static Filter CreateQueryForValue(ISearchCriteria criteria, ISearchFilter filter, ISearchFilterValue value)
{
Filter q;
var priceQuery = filter is PriceRangeFilter;
var rangeFilterValue = value as RangeFilterValue;
if (rangeFilterValue != null && priceQuery)
{
q = CreateQuery(criteria, filter.Key, rangeFilterValue);
}
else if (value is CategoryFilterValue)
{
q = CreateQuery(filter.Key, (CategoryFilterValue)value);
}
else
{
q = CreateQuery(filter.Key, value);
}
return q;
}
public static ISearchFilterValue[] GetFilterValues(ISearchFilter filter)
{
ISearchFilterValue[] values = null;
if (filter is AttributeFilter)
{
values = ((AttributeFilter)filter).Values;
}
else if (filter is RangeFilter)
{
values = ((RangeFilter)filter).Values;
}
else if (filter is PriceRangeFilter)
{
values = ((PriceRangeFilter)filter).Values;
}
else if (filter is CategoryFilter)
{
values = ((CategoryFilter)filter).Values;
}
return values;
}
/// <summary>
/// Converts the specified filter to filter model.
/// </summary>
/// <param name="helper"></param>
/// <param name="filter">The search filter.</param>
/// <returns>Filter model</returns>
public static FilterModel Convert(this ISearchFilterService helper, ISearchFilter filter)
{
var model = new FilterModel();
if (filter is AttributeFilter)
{
var prop = filter as AttributeFilter;
model.Key = prop.Key;
model.Name = ClientContext.Clients.CreateCatalogClient().GetPropertyName(prop.Key);
model.Name = string.IsNullOrEmpty(model.Name) ? model.Key : model.Name;
return model;
}
if (filter is RangeFilter)
{
var prop = filter as RangeFilter;
model.Key = prop.Key;
model.Name = ClientContext.Clients.CreateCatalogClient().GetPropertyName(prop.Key);
model.Name = string.IsNullOrEmpty(model.Name) ? model.Key : model.Name;
return model;
}
if (filter is PriceRangeFilter)
{
var prop = filter as PriceRangeFilter;
model.Key = prop.Key;
model.Name = "Price";
return model;
}
if (filter is CategoryFilter)
{
var prop = filter as CategoryFilter;
model.Key = prop.Key;
model.Name = "Category";
return model;
}
return null;
}
private bool TryBuildLanguageFilter(string language, out ISearchFilter filter)
{
if (String.IsNullOrEmpty(language) ||
!SystemManager.CurrentContext.AppSettings.Multilingual)
{
filter = null;
return false;
}
filter = ObjectFactory.Resolve<ISearchFilter>();
filter.Clauses = new List<ISearchFilterClause>()
{
new SearchFilterClause(PublishingConstants.LanguageField, this.TransformLanguageFieldValue(language), FilterOperator.Equals),
new SearchFilterClause(PublishingConstants.LanguageField, "nullvalue", FilterOperator.Equals)
};
filter.Operator = QueryOperator.Or;
return true;
}
/// <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="currency">The currency.</param>
/// <returns></returns>
private int CalculateResultCount(
IndexReader reader, DocIdSet baseDocIdSet, FacetGroup facetGroup, ISearchFilter filter, string currency)
{
var count = 0;
ISearchFilterValue[] values = null;
var priceQuery = false;
if (filter is s.AttributeFilter)
{
values = ((s.AttributeFilter)filter).Values;
}
else if (filter is s.RangeFilter)
{
values = ((s.RangeFilter)filter).Values;
}
else if (filter is s.PriceRangeFilter)
{
values = ((s.PriceRangeFilter)filter).Values;
priceQuery = true;
}
if (values == null)
{
return 0;
}
foreach (var value in values)
{
Query q = null;
if (priceQuery)
{
q = LuceneQueryHelper.CreateQuery(
this.Results.SearchCriteria, filter.Key, value as s.RangeFilterValue);
}
else
{
q = LuceneQueryHelper.CreateQuery(filter.Key, value);
}
if (q == null) continue;
var queryFilter = new CachingWrapperFilter(new QueryWrapperFilter(q));
var filterArray = queryFilter.GetDocIdSet(reader);
var newCount = (int)this.CalculateFacetCount(baseDocIdSet, filterArray);
if (newCount == 0) continue;
var newFacet = new Facet(facetGroup, value.Id, this.GetDescription(value, this.Results.SearchCriteria.Locale), newCount);
facetGroup.Facets.Add(newFacet);
count += newCount;
}
return count;
}
public bool Equals(ISearchFilter other)
{
return other != null && other.GetHashCode() == this.GetHashCode();
}
/// <summary>
/// Gets the filter values.
/// </summary>
/// <param name="filter">The filter.</param>
/// <returns>IEnumerable{ISearchFilterValue}.</returns>
public IEnumerable<ISearchFilterValue> GetFilterValues(ISearchFilter filter)
{
var attributeFilter = filter as AttributeFilter;
if (attributeFilter != null)
{
return attributeFilter.Values;
}
var rangeFilter = filter as RangeFilter;
if (rangeFilter != null)
{
return rangeFilter.Values;
}
var priceRangeFilter = filter as PriceRangeFilter;
if (priceRangeFilter != null)
{
return priceRangeFilter.Values;
}
return null;
}
public virtual void Add(ISearchFilter filter, ISearchFilterValue value)
{
_CurrentFilters.Add(filter, value);
}
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;
}
/*
/// <summary>
/// Converts the specified filter to filter model.
/// </summary>
/// <param name="helper"></param>
/// <param name="filter">The search filter.</param>
/// <returns>Filter model</returns>
public static Facet Convert(this IBrowseFilterService helper, ISearchFilter filter)
{
var model = new Facet();
if (filter is AttributeFilter)
{
var prop = filter as AttributeFilter;
model.Field = prop.Key;
model.Label = prop.Key;
model.FacetType = "attr";
model.Values = prop.Values
//model.Label = ClientContext.Clients.CreateCatalogClient().GetPropertyName(prop.Key);
//model.Name = string.IsNullOrEmpty(model.Name) ? model.Key : model.Name;
return model;
}
if (filter is RangeFilter)
{
var prop = filter as RangeFilter;
model.Field = prop.Key;
model.Label = prop.Key;
//model.Name = ClientContext.Clients.CreateCatalogClient().GetPropertyName(prop.Key);
//model.Name = string.IsNullOrEmpty(model.Name) ? model.Key : model.Name;
return model;
}
if (filter is PriceRangeFilter)
{
var prop = filter as PriceRangeFilter;
model.Field = prop.Key;
model.Label = "Price";
return model;
}
if (filter is CategoryFilter)
{
var prop = filter as CategoryFilter;
model.Field = prop.Key;
model.Label = "Category";
return model;
}
return null;
}
public static FacetValue ToModel(this AttributeFilterValue value)
{
var ret = new FacetValue() { Value = value.Value };
return ret;
}
/// <summary>
/// Converts the specified filter value to facet model.
/// </summary>
/// <param name="helper"></param>
/// <param name="val">The search filter value.</param>
/// <returns>facet model</returns>
public static FacetModel Convert(this IBrowseFilterService helper, ISearchFilterValue val)
{
var model = new FacetModel();
if (val is AttributeFilterValue)
{
var v = val as AttributeFilterValue;
model.Key = v.Id;
model.Name = v.Value;
return model;
}
if (val is CategoryFilterValue)
{
var v = val as CategoryFilterValue;
model.Key = v.Id;
model.Name = v.Name;
return model;
}
if (val is RangeFilterValue)
{
var v = val as RangeFilterValue;
model.Key = v.Id;
var name = String.Empty;
if (v.Displays != null)
{
var disp = (from d in v.Displays where d.Language == "en" select d).SingleOrDefault();
if (disp != null)
{
name = disp.Value;
}
}
model.Name = name;
return model;
}
return null;
}
/// <summary>
/// Converts the specified facet groups into filter model.
/// </summary>
/// <param name="helper">The helper.</param>
/// <param name="groups">The groups.</param>
/// <returns>
/// FilterModel[][].
/// </returns>
public static FilterModel[] Convert(this IBrowseFilterService helper, FacetGroup[] groups)
{
var list = new List<FilterModel>();
if (groups != null)
{
list.AddRange(groups.Select(x => Convert(helper, x)));
}
return list.ToArray();
}
/// <summary>
/// Converts the specified facet group.
/// </summary>
/// <param name="helper">The helper.</param>
/// <param name="group">The facet group.</param>
/// <returns>
/// facet group
/// </returns>
public static FilterModel Convert(this IBrowseFilterService helper, FacetGroup group)
{
return new FilterModel
{
Key = @group.FieldName,
Name = GetDescriptionFromFilter(@group.FieldName),
Facets = @group.Facets.Select(x => Convert(helper, x)).ToArray()
};
}
/// <summary>
/// Converts the specified facet to facet model.
/// </summary>
/// <param name="helper">The helper.</param>
/// <param name="facet">The facet.</param>
/// <returns>
/// facet model
/// </returns>
public static FacetModel Convert(this IBrowseFilterService helper, Facet facet)
{
return new FacetModel
{
Key = facet.Key,
Name = GetNameFromFilterValue(helper, facet),
Count = facet.Count
};
}
* */
#region Public Methods and Operators
public static ISearchFilter Convert(this IBrowseFilterService helper, ISearchFilter filter, string[] keys)
{
if (filter != null && keys != null)
{
// get values that we have filters set for
var values = from v in filter.GetValues() where keys.Contains(v.Id, StringComparer.OrdinalIgnoreCase) select v;
var attributeFilter = filter as AttributeFilter;
if (attributeFilter != null)
{
var newFilter = new AttributeFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType<AttributeFilterValue>().ToArray();
return newFilter;
}
var rangeFilter = filter as RangeFilter;
if (rangeFilter != null)
{
var newFilter = new RangeFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType<RangeFilterValue>().ToArray();
return newFilter;
}
var priceRangeFilter = filter as PriceRangeFilter;
if (priceRangeFilter != null)
{
var newFilter = new PriceRangeFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType<RangeFilterValue>().ToArray();
return newFilter;
}
var categoryFilter = filter as CategoryFilter;
if (categoryFilter != null)
{
var newFilter = new CategoryFilter();
newFilter.InjectFrom(filter);
newFilter.Values = values.OfType<CategoryFilterValue>().ToArray();
return newFilter;
}
}
return null;
}
/// <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 GetRequestUrlReturnsFiltersOnly()
{
var filters = new ISearchFilter[]
{
new EqualitySearchFilter("title", "hello"),
new EqualitySearchFilter("name", "test")
};
var result = ContentfulClient.GetRequestUrl(RequestBaseUrl, filters: filters);
Assert.AreEqual("http://test.com/?title=hello&name=test", result);
}
public SearchResult(ISearchFilter filter)
{
Filter = filter;
}
public void TestQueryStringReturnsForValidFilters()
{
var filters = new ISearchFilter[]
{
new SkipSearchFilter(0),
new LimitSearchFilter(15),
new EqualitySearchFilter("test", "true"),
};
var result = ContentfulClient.GetQueryStringFromSearchFilters(filters);
const string expectedQueryString = "skip=0&limit=15&test=true";
Assert.AreEqual(expectedQueryString, result);
}
public virtual void Apply(ISearchFilter filter)
{
_appliedFilters.Add(filter);
}
private string BuildQueryFilter(ISearchFilter filter)
{
var result = new StringBuilder();
result.Append("(");
var groupOperator = filter.Operator == QueryOperator.And ? " and " : " or ";
result.Append(groupOperator);
foreach (var clause in filter.Clauses)
{
var value = clause.Value;
if (value is DateTime)
{
var dateTime = (DateTime)clause.Value;
value = dateTime.ToUniversalTime().ToString("o", CultureInfo.InvariantCulture);
}
else if (value is int)
{
value = value.ToString();
}
else if (value is string)
{
// Amazon search does not accept null values
if (value == "nullvalue")
continue;
// String values should be surrounded by quotation marks
value = string.Format("'{0}'", value);
}
switch (clause.FilterOperator)
{
case FilterOperator.Equals: result.Append(string.Format("{0}:{1} ", clause.Field.ToUpperInvariant(), value));
break;
case FilterOperator.Contains: result.Append(string.Format("{0}:{1}", clause.Field.ToUpperInvariant(), value));
break;
case FilterOperator.Greater: result.Append(string.Format("{0}:[{1}, {2}", clause.Field, value, "}"));
break;
case FilterOperator.Less: result.Append(string.Format("{0}:{2}, {1}]", clause.Field, value, "{"));
break;
}
}
var groupResult = new StringBuilder();
foreach (var filterGroup in filter.Groups)
{
groupResult.Append(this.BuildQueryFilter(filterGroup));
}
result.Append(groupResult.ToString());
result.Append(")");
return result.ToString();
}
protected SearchResult2(ISearchFilter filter)
{
Filter = filter;
}
public virtual void Add(ISearchFilter filter)
{
_Filters.Add(filter);
}
