public static ITypeSearch <T> Filter <T>(this ITypeSearch <T> query, IFilterStatementRequest request) where T : IContent
{
if (request?.Filters?.Items == null)
{
return(query);
}
var filterBuilder = ClientExtensions.BuildFilter <T>(SearchClient.Instance);
filterBuilder = request.Filters.Items.Aggregate(filterBuilder, (builder, item) =>
{
if (item.Connector == FilterStatementConnector.And)
{
return(builder.And(GetExpression <T>(item)));
}
else
{
var expression = GetExpression <T>(item);
if (expression == null)
{
expression = GetExpression <T>(item);
}
return(expression == null ? builder : builder.Or(expression));
}
});
if (filterBuilder.HasFilter)
{
query = TypeSearchExtensions.Filter(query, filterBuilder);
}
return(query);
}
protected virtual IEnumerable <IFacetContent> GetSearchResults(ITypeSearch <IFacetContent> query, PropertyDataCollection properties, int skip, int take, out int total)
{
var result = query
.Select(x => new FacetContent
{
PropertyCollection = properties,
Name = x.Name,
ContentGuid = x.ContentGuid,
ContentLink = x.ContentLink,
IsDeleted = x.IsDeleted,
VariationLinks = x.VariationLinks,
ParentLink = x.ParentLink,
StartPublish = x.StartPublish,
StopPublish = x.StopPublish,
Code = x.Code,
DefaultPrice = x.DefaultPrice,
ContentTypeID = x.ContentTypeID,
ApplicationId = x.ApplicationId,
MetaClassId = x.MetaClassId,
ProductLinks = x.ProductLinks,
NodeLinks = x.NodeLinks,
ThumbnailPath = x.ThumbnailPath,
DefaultCurrency = x.DefaultCurrency,
WeightBase = x.WeightBase,
LengthBase = x.LengthBase,
Prices = x.Prices,
Inventories = x.Inventories
})
.Skip(skip)
.Take(take)
.GetResult();
total = result.TotalMatching;
return(result);
}
public static ITypeSearch <T> WildcardSearch <T>(this ITypeSearch <T> search,
string query, Expression <Func <T, string> > fieldSelector, double?boost = null)
{
if (string.IsNullOrWhiteSpace(query))
{
return(search);
}
query = query?.ToLowerInvariant();
query = WrapInAsterisks(query);
var fieldName = search.Client.Conventions
.FieldNameConvention
.GetFieldNameForAnalyzed(fieldSelector);
var wildcardQuery = new WildcardQuery(fieldName, query)
{
Boost = boost
};
return(new Search <T, WildcardQuery>(search, context =>
{
if (context.RequestBody.Query != null)
{
var boolQuery = new BoolQuery();
boolQuery.Should.Add(context.RequestBody.Query);
boolQuery.Should.Add(wildcardQuery);
boolQuery.MinimumNumberShouldMatch = 1;
context.RequestBody.Query = boolQuery;
}
else
{
context.RequestBody.Query = wildcardQuery;
}
}));
}
public override ITypeSearch<FindProduct> ApplyFilter(ITypeSearch<FindProduct> query)
{
if(string.IsNullOrEmpty(FieldName) == false)
{
string fullFieldName = query.Client.GetFullFieldName(FieldName, typeof(double));
switch (FieldOperator)
{
case NumericOperatorSelectionFactory.OperatorNames.GreaterThan:
RangeFilter<double> greaterThanFilter = RangeFilter.Create(fullFieldName, FieldValue, double.MaxValue);
greaterThanFilter.IncludeLower = false;
greaterThanFilter.IncludeUpper = true;
query = query.Filter(greaterThanFilter);
break;
case NumericOperatorSelectionFactory.OperatorNames.LessThan:
RangeFilter<double> lessThanFilter = RangeFilter.Create(fullFieldName, double.MinValue, FieldValue);
lessThanFilter.IncludeLower = false;
lessThanFilter.IncludeUpper = true;
query = query.Filter(lessThanFilter);
break;
default:
case NumericOperatorSelectionFactory.OperatorNames.Equal:
var termFilter = new TermFilter(fullFieldName, FieldValue);
query = query.Filter(termFilter);
break;
}
}
return query;
}
/// <summary>
/// Basic text search in all fields for a given query
/// </summary>
/// <param name="cli"></param>
static ITypeSearch <Hotel> TextSearchExample(ITypeSearch <Hotel> q)
{
Console.Write("What should we search for? ");
string query = Console.ReadLine();
return(q.For(query));
}
private static ITypeSearch <object> GetSortedSearch(SortColumn sortColumn, ITypeSearch <IFacetContent> query)
{
switch (sortColumn.ColumnName)
{
case "name":
{
return(sortColumn.SortDescending ? query.OrderByDescending(x => x.Name) : query.OrderBy(x => x.Name));
}
case "code":
{
return(sortColumn.SortDescending ? query.OrderByDescending(x => x.Code) : query.OrderBy(x => x.Code));
}
case "startPublish":
{
return(sortColumn.SortDescending ? query.OrderByDescending(x => x.StartPublish) : query.OrderBy(x => x.StartPublish));
}
case "stopPublish":
{
return(sortColumn.SortDescending ? query.OrderByDescending(x => x.StopPublish) : query.OrderBy(x => x.StopPublish));
}
case "metaClassName":
{
return(sortColumn.SortDescending ? query.OrderByDescending(x => x.MetaClassId) : query.OrderBy(x => x.MetaClassId));
}
default:
{
return(sortColumn.SortDescending ? query.OrderByDescending(x => x.ContentTypeID) : query.OrderBy(x => x.ContentTypeID));
}
}
}
/// <summary>
/// Show all hotels, best first
/// </summary>
/// <param name="cli"></param>
static ITypeSearch <Hotel> BasicSortingExample(ITypeSearch <Hotel> q)
{
return(q
.OrderByDescending(h => h.StarRating)
.ThenByDescending(h => h.Ratings.Overall)
.ThenByDescending(h => h.ReviewCount));
}
public static ITypeSearch <T> AddWildCardQuery <T>(
this ITypeSearch <T> search,
string query,
Expression <Func <T, string> > fieldSelector)
{
var fieldName = search.Client.Conventions.FieldNameConvention
.GetFieldNameForAnalyzed(fieldSelector);
var wildcardQuery = new WildcardQuery(fieldName, query.ToLowerInvariant());
return(new Search <T, WildcardQuery>(search, context =>
{
if (context.RequestBody.Query != null)
{
var boolQuery = new BoolQuery();
boolQuery.Should.Add(context.RequestBody.Query);
boolQuery.Should.Add(wildcardQuery);
boolQuery.MinimumNumberShouldMatch = 1;
context.RequestBody.Query = boolQuery;
}
else
{
context.RequestBody.Query = wildcardQuery;
}
}));
}
public static ITypeSearch <TSource> NumericRangeFacetFor <TSource>(this ITypeSearch <TSource> search,
string name,
IEnumerable <NumericRange> range)
{
return(search.RangeFacetFor(GetTermFacetForResult <TSource>(name),
NumericRangfeFacetRequestAction(search.Client, name, range, typeof(double))));
}
public static ITypeSearch <TSource> TermsFacetFor <TSource>(this ITypeSearch <TSource> search,
string name,
Type type,
Filter filter,
Action <FacetFilterRequest> facetRequestAction = null,
int size = 50)
{
var fieldName = name;
if (type != null)
{
fieldName = search.Client.GetFullFieldName(name, type);
}
return(new Search <TSource, IQuery>(search,
context =>
{
var facetRequest = new TermsFacetFilterRequest(name, filter)
{
Field = fieldName,
Size = size
};
if (facetRequestAction.IsNotNull())
{
facetRequestAction(facetRequest);
}
context.RequestBody.Facets.Add(facetRequest);
}));
}
protected ITypeSearch <FindProduct> ApplySortOrder(ITypeSearch <FindProduct> query)
{
if (SortOrder == null)
{
return(query);
}
if (SortOrder.Equals("popularity"))
{
return(query.OrderByDescending(x => x.Score));
}
if (SortOrder.Equals("priceAscending"))
{
return(query.OrderBy(x => x.DefaultPriceAmount));
}
if (SortOrder.Equals("priceDescending"))
{
return(query.OrderByDescending(x => x.DefaultPriceAmount));
}
if (SortOrder.Equals("rating"))
{
return(query.OrderByDescending(x => x.AverageRating));
}
return(query);
}
public static ITypeSearch <T> FilterOutline <T>(this ITypeSearch <T> search, IEnumerable <string> value)
{
var filterBuilder = new FilterBuilder <T>(search.Client)
.FilterOutline(value);
return(search.Filter(x => filterBuilder));
}
public LandingNodeViewModel(string language)
{
_query = SearchClient.Instance.Search<FindProduct>(ShoppingController.GetLanguage(language))
.Filter(x => x.Language.Match(language))
.Filter(x => x.ShowInList.Match(true))
.OrderByDescending(x => x.SalesCounter);
}
/// <summary>
/// Exercise 4: Advanced filtering -> Show hotels with more than 2 stars within 10 km of the cosmopolitan hotel
/// that offer room service, have air condition and are of chain specified by user
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
static ITypeSearch<Hotel> AdvancedFiltering(ITypeSearch<Hotel> q)
{
return q.Filter(x => x.StarRating.GreaterThan(2))
.Filter(x => x.GeoCoordinates.WithinDistanceFrom(COSMOPOLITAN_HOTEL_GEO, 10.Kilometer()))
.Filter(x => x.Features.MatchCaseInsensitive("Air conditioned"))
.Filter(x => x.Features.MatchCaseInsensitive("Room service"));
}
/// <summary>
/// Exercise 4: Advanced filtering -> Show hotels with more than 2 stars within 10 km of the cosmopolitan hotel
/// that offer room service, have air condition and are of chain specified by user
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
static ITypeSearch <Hotel> AdvancedFiltering(ITypeSearch <Hotel> q)
{
return(q.Filter(x => x.StarRating.GreaterThan(2))
.Filter(x => x.GeoCoordinates.WithinDistanceFrom(COSMOPOLITAN_HOTEL_GEO, 10.Kilometer()))
.Filter(x => x.Features.MatchCaseInsensitive("Air conditioned"))
.Filter(x => x.Features.MatchCaseInsensitive("Room service")));
}
public LandingNodeViewModel(string language)
{
_query = SearchClient.Instance.Search <FindProduct>(ShoppingController.GetLanguage(language))
.Filter(x => x.Language.Match(language))
.Filter(x => x.ShowInList.Match(true))
.OrderByDescending(x => x.SalesCounter);
}
public static FilterBuilder <T> GetOrFilterForIntList <T>(this ITypeSearch <T> query, IEnumerable <int> values, string fieldName, Type type)
{
// Appends type convention to field name (like "$$string")
IClient client = query.Client;
string fullFieldName = client.GetFullFieldName(fieldName, type);
List <Filter> filters = new List <Filter>();
foreach (int value in values)
{
filters.Add(new TermFilter(fullFieldName, value));
}
FilterBuilder <T> filterBuilder;
if (filters.Count > 1)
{
OrFilter orFilter = new OrFilter(filters);
filterBuilder = new FilterBuilder <T>(client, orFilter);
}
else
{
// If we only have one filer, don't wrap it in an Or filter
filterBuilder = new FilterBuilder <T>(client, filters[0]);
}
return(filterBuilder);
}
/// <summary>
/// Exercise 7: Basic text search, query entered by user, in fields Name and Description
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
static ITypeSearch <Hotel> BasicTextSearch(ITypeSearch <Hotel> q)
{
Console.Write("What should we search for? ");
string query = Console.ReadLine();
return(q.For(query).InFields(x => x.Name, x => x.Description));
}
private static FilterBuilder <T> GetOrFilterForNumericRange <T>(ITypeSearch <T> query,
IEnumerable <SelectableNumericRange> range,
string fieldName,
Type type)
{
// Appends type convention to field name (like "$$string")
var client = query.Client;
var fullFieldName = client.GetFullFieldName(fieldName, type);
var filters = new List <Filter>();
foreach (var rangeItem in range)
{
var rangeFilter = RangeFilter.Create(fullFieldName,
rangeItem.From ?? 0,
rangeItem.To ?? double.MaxValue);
rangeFilter.IncludeUpper = false;
filters.Add(rangeFilter);
}
var orFilter = new OrFilter(filters);
var filterBuilder = new FilterBuilder <T>(client, orFilter);
return(filterBuilder);
}
public override ITypeSearch <FindProduct> ApplyFilter(ITypeSearch <FindProduct> query)
{
if (string.IsNullOrEmpty(FieldName) == false)
{
string fullFieldName = query.Client.GetFullFieldName(FieldName, typeof(double));
switch (FieldOperator)
{
case NumericOperatorSelectionFactory.OperatorNames.GreaterThan:
RangeFilter <double> greaterThanFilter = RangeFilter.Create(fullFieldName, FieldValue, double.MaxValue);
greaterThanFilter.IncludeLower = false;
greaterThanFilter.IncludeUpper = true;
query = query.Filter(greaterThanFilter);
break;
case NumericOperatorSelectionFactory.OperatorNames.LessThan:
RangeFilter <double> lessThanFilter = RangeFilter.Create(fullFieldName, double.MinValue, FieldValue);
lessThanFilter.IncludeLower = false;
lessThanFilter.IncludeUpper = true;
query = query.Filter(lessThanFilter);
break;
default:
case NumericOperatorSelectionFactory.OperatorNames.Equal:
var termFilter = new TermFilter(fullFieldName, FieldValue);
query = query.Filter(termFilter);
break;
}
}
return(query);
}
public override ITypeSearch <T> Filter <T>(ITypeSearch <T> query)
{
if (SelectedTerms.Any())
{
return(query.AddStringFilter(SelectedTerms, FieldName));
}
return(query);
}
public static ITypeSearch <ISearchContent> AddCategoryBoost(
this ITypeSearch <ISearchContent> query,
Dictionary <string, int> favoriteCategories)
{
return(favoriteCategories.Aggregate(
query,
(current, favoriteCategory) => current.BoostMatching(x => x.SearchCategories.In(new[] { favoriteCategory.Key }), favoriteCategory.Value)));
}
public static ITypeSearch <TSource> OrFilter <TSource, TListItem>(this ITypeSearch <TSource> search, Expression <Func <TSource, IEnumerable <TListItem> > > nestedExpression,
Expression <Func <TListItem, Filter> > filterExpression)
{
var filter = new FilterExpressionParser(search.Client.Conventions)
.GetFilter(new NestedFilterExpression <TSource, TListItem>(nestedExpression, filterExpression, search.Client.Conventions).Expression);
return(search.OrFilter(filter));
}
public static ITypeSearch <T> AddStringListFilter <T>(this ITypeSearch <T> query, List <string> stringFieldValues, string fieldName)
{
if (stringFieldValues != null && stringFieldValues.Any())
{
return(query.Filter(GetOrFilterForStringList <T>(stringFieldValues, query.Client, fieldName)));
}
return(query);
}
/// <summary>
/// Filters by page and page size
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <param name="search">The search.</param>
/// <param name="page">Page number.</param>
/// <param name="pageSize">Page size.</param>
/// <returns>Updated search.</returns>
public static ITypeSearch <TSource> FilterPaging <TSource>(
this ITypeSearch <TSource> search, int page, int pageSize)
{
var take = pageSize;
var skip = pageSize * (page - 1);
return(search.Skip(skip).Take(take));
}
/// <summary>
/// Adds a code-ordered ascending ordering request for the specified field to an existing search.
/// </summary>
public static ITypeSearch <FindDocument> ThenByField <TField>(this ITypeSearch <FindDocument> search, IFieldConfiguration <TField> field, bool isDescending = false)
{
if (!isDescending)
{
return(search.ThenBy <FindDocument, TField>(field.TypedGetValueExpression));
}
return(search.ThenByDescending <FindDocument, TField>(field.TypedGetValueExpression));
}
/// <summary>
/// Adds faceting requests to the search for the specified pricing.
/// </summary>
public static ITypeSearch <FindDocument> AddPriceFacet(this ITypeSearch <FindDocument> search, SearchFilter filter, Mediachase.Commerce.Currency currency, MarketId marketId)
{
foreach (KeyValuePair <string, Expression <Func <FindDocument, Filter> > > priceFacet in search.GetPriceFacets(filter, currency, marketId))
{
search = search.FilterFacet <FindDocument>(priceFacet.Key, priceFacet.Value);
}
return(search);
}
/// <summary>
/// Adds faceting requests to the search for the specified filter and locale.
/// </summary>
public static ITypeSearch <FindDocument> AddFacet(this ITypeSearch <FindDocument> search, SearchFilter filter, string locale)
{
foreach (KeyValuePair <string, Expression <Func <FindDocument, Filter> > > facet in search.GetFacets(filter, locale))
{
search = search.FilterFacet <FindDocument>(facet.Key, facet.Value);
}
return(search);
}
public static ITypeSearch <TSource> NumericRangeFacetFor <TSource>(this ITypeSearch <TSource> search,
string name,
double from,
double to)
{
return(search.RangeFacetFor(GetTermFacetForResult <TSource>(name),
NumericRangfeFacetRequestAction(search.Client, name, from, to, typeof(double))));
}
public override ITypeSearch <FindProduct> ApplyFilter(ITypeSearch <FindProduct> query)
{
if (string.IsNullOrEmpty(FieldName) == false && string.IsNullOrEmpty(FieldValue) == false)
{
query = query.AddStringFilter(FieldValue, FieldName);
}
return(query);
}
static void SearchPeople()
{
WriteLine("* Search for people");
ITypeSearch <Person> search = client.Search <Person>();
OutputResults(search);
}
private ITypeSearch <FindProduct> ApplyCategoryFilter(ITypeSearch <FindProduct> query, List <int> categories)
{
if (categories.Any())
{
return(query.Filter(query.GetOrFilterForIntList(categories, "ParentCategoryId", type: null))); // Filter array of int is without type specifier in Find
}
return(query);
}
public override ITypeSearch <T> Filter(IContent currentCntent, ITypeSearch <T> query, IEnumerable <string> values)
{
var marketFilter = SearchClient.Instance.BuildFilter <T>();
marketFilter = values.Aggregate(marketFilter, Aggregate);
return(query.Filter(marketFilter));
}
public override ITypeSearch<FindProduct> ApplyFilter(ITypeSearch<FindProduct> query)
{
if(string.IsNullOrEmpty(FieldName) == false && string.IsNullOrEmpty(FieldValue) == false)
{
query = query.AddStringFilter(FieldValue, FieldName);
}
return query;
}
public override ITypeSearch<FindProduct> ApplyFilter(ITypeSearch<FindProduct> query)
{
if(string.IsNullOrEmpty(FieldName) == false)
{
string fullFieldName = query.Client.GetFullFieldName(FieldName);
query = query.Filter(new ExistsFilter(fullFieldName));
}
return query;
}
public ITypeSearch<EpiFindNotice> ApplyOrdering(ITypeSearch<EpiFindNotice> source, NoticesSearchOptions.SortOptions sortOptions)
{
switch (sortOptions)
{
case NoticesSearchOptions.SortOptions.Surname:
return source.OrderBy(x => x.Surname);
case NoticesSearchOptions.SortOptions.DateOfDeath:
return source.OrderByDescending(x => x.DateOfDeath);
}
return source;
}
public LandingNodeViewModel(FashionStoreSubLandingNodeContent category, string language)
: this(language)
{
// main category
string mainCategory = "";
var mainCategoryNode = category.GetParent();
if (mainCategoryNode != null)
{
mainCategory = mainCategoryNode.Name;
}
if (!string.IsNullOrEmpty(mainCategory))
{
_query = _query.Filter(x => x.MainCategoryName.Match(mainCategory));
}
_query = _query.Filter(x => x.ParentCategoryName.Match(category.Name));
}
/// <summary>
/// Applies the filters selected
/// </summary>
/// <param name="query">The query.</param>
/// <returns></returns>
protected override ITypeSearch<FindProduct> ApplyFilters(ITypeSearch<FindProduct> query)
{
// Only get products from the selected nodes
if(Nodes != null)
{
IEnumerable<int> nodeIds = Nodes.FilteredItems.Select(x => x.ContentLink.ID);
query = query.AddFilterForIntList(nodeIds, "ParentCategoryId");
}
// Allow all filters to add their Find filters to the query
if (Filters != null)
{
foreach (var item in Filters.FilteredItems)
{
FilterBaseBlock filter = item.GetContent() as FilterBaseBlock;
if (filter != null)
{
query = filter.ApplyFilter(query);
}
}
}
return query;
}
public LandingNodeViewModel(FashionStoreLandingNodeContent mainCategory, string language)
: this(language)
{
_query = _query.Filter(x => x.MainCategoryName.Match(mainCategory.Name));
}
private static ITypeSearch<FindProduct> ApplyCommonFilters(ITypeSearch<FindProduct> query, string language)
{
return query.Filter(x => x.Language.Match(language));
}
/// <summary>
/// Exercise 5: Range facets -> create range facets for price ranges 20-50, 51-100 and 101-150 USD
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
static ITypeSearch<Hotel> RangeFacets(ITypeSearch<Hotel> q)
{
var ranges = new[] {new NumericRange(20, 50), new NumericRange(51, 100), new NumericRange(101, 150)};
return q.RangeFacetFor(x => x.PriceUSD, ranges);
}
/// <summary>
/// Exercise 2: Filter on rating/review -> Find all hotels that have a star rating of either 4 o 5, OR
/// review rate of 9 or 10 with more than 50 reviews
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
static ITypeSearch<Hotel> FilterOnRating(ITypeSearch<Hotel> q)
{
return q.Filter(x => x.StarRating.InRange(4, 5))
.OrFilter(x => x.ReviewCount.GreaterThan(50) & x.Ratings.Overall.InRange(8, 9));
}
/// <summary>
/// Exercise 1: Filter on price -> Get all hotels that have price between 100 and 200
/// </summary>
/// <param name="q"></param>
static ITypeSearch<Hotel> FilterOnPrice(ITypeSearch<Hotel> q)
{
return q.Filter(x => x.PriceUSD.InRange(100, 200));
}
/// <summary>
/// Exercise 3: Filter on location -> Get all hotels within 5 km of the cosmopolitan hotel,
/// order by distance from cosmopolitan hotel (closest first)
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
static ITypeSearch<Hotel> FilterOnLocation(ITypeSearch<Hotel> q)
{
return q.Filter(x => x.GeoCoordinates.WithinDistanceFrom(COSMOPOLITAN_HOTEL_GEO, 5.Kilometer()))
.OrderBy(x => x.GeoCoordinates).DistanceFrom(COSMOPOLITAN_HOTEL_GEO);
}
/// <summary>
/// Exercise 6: Facet for country -> List name of all countries that have hotels
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
static ITypeSearch<Hotel> FacetForCountry(ITypeSearch<Hotel> q)
{
return q.TermsFacetFor(x => x.Location.Country.Title, request => request.Size = 500).Take(0);
}
/// <summary>
/// Exercise 7: Basic text search, query entered by user, in fields Name and Description
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
static ITypeSearch<Hotel> BasicTextSearch(ITypeSearch<Hotel> q)
{
Console.Write("What should we search for? ");
string query = Console.ReadLine();
return q.For(query).InFields(x => x.Name, x => x.Description);
}
private ITypeSearch<FindProduct> ApplyCategoryFilter(ITypeSearch<FindProduct> query, List<int> categories)
{
if(categories.Any())
return query.Filter(query.GetOrFilterForIntList(categories, "ParentCategoryId", type: null)); // Filter array of int is without type specifier in Find
return query;
}
public abstract ITypeSearch<FindProduct> ApplyFilter(ITypeSearch<FindProduct> query);
/// <summary>
/// Adds freetext search filter to known fields
/// </summary>
/// <param name="query">The query.</param>
/// <param name="searchTerm">The search term.</param>
/// <param name="trackSearchTerm">if set to <c>true</c> [track search term].</param>
/// <returns></returns>
private ITypeSearch<FindProduct> ApplyTermFilter(ITypeSearch<FindProduct> query, string searchTerm, bool trackSearchTerm = false)
{
if (!string.IsNullOrEmpty(searchTerm))
{
query = query.For(searchTerm)
.InFields(x => x.Name,
x => x.MainCategoryName,
x => string.Join(",", x.Color),
x => x.DisplayName,
x => x.Fit,
x => x.Description.ToString(),
x => string.Join(",", x.ParentCategoryName))
.InAllField();
if (trackSearchTerm)
{
query = query.Track();
}
}
return query;
}
/// <summary>
/// Applies the filters applicable to this given model.
/// </summary>
/// <param name="query">The query.</param>
/// <returns></returns>
protected override ITypeSearch<FindProduct> ApplyFilters(ITypeSearch<FindProduct> query)
{
if (ProductBrands != null && ProductBrands.Any())
query = query.Filter(x => GetBrandFilter(ProductBrands));
//if (category != null && category.Any())
// query = query.Filter(x => GetWineTypeFilter(category));
if (CountryList != null && CountryList.Any())
query = query.Filter(x => GetCountryFilter(CountryList));
return query;
}
/// <summary> /// Let derived classes apply additional filters that only they know /// as the data being filtered on is part of the model /// </summary> /// <param name="query">The query.</param> /// <returns></returns> protected abstract ITypeSearch<FindProduct> ApplyFilters(ITypeSearch<FindProduct> query);
/// <summary>
/// Get order by
/// </summary>
/// <param name="search"></param>
/// <param name="query"></param>
/// <returns></returns>
private ITypeSearch<Hotel> GetOrderBy(ITypeSearch<Hotel> search, SearchQuery query)
{
switch (query.SortBy)
{
case "price":
return search.OrderBy(h => h.PriceUSD);
case "ratings":
return search.OrderByDescending(h => h.StarRating);
case "Popularity":
return search.OrderByDescending(h => h.StarRating);
default:
return search.OrderByDescending(h => h.PriceUSD);
}
}
/// <summary>
/// Filter on rating
/// </summary>
/// <param name="search"></param>
/// <param name="query"></param>
/// <returns></returns>
private ITypeSearch<Hotel> GetRatingFilter(ITypeSearch<Hotel> search, SearchQuery query)
{
if (query.RatingFilter > 0)
{
search = search.Filter(x => x.StarRating.Match(query.RatingFilter));
}
return search;
}
/// <summary>
/// Use this to filter on the Features list. This Filter use the Match method for the filtering for each selected facility
/// </summary>
/// <param name="search"></param>
/// <param name="query"></param>
/// <returns></returns>
private ITypeSearch<Hotel> GetFacilityFilter(ITypeSearch<Hotel> search, SearchQuery query)
{
if (query.FacilityFilter != null)
{
foreach (var item in query.FacilityFilter)
{
var facility = _facilityService.GetById(item);
if (facility != null)
{
search = search.Filter(x => x.Features.Match(facility.Value));
}
}
}
return search;
}
/// <summary>
/// Filter on price
/// </summary>
/// <param name="search"></param>
/// <param name="query"></param>
/// <returns></returns>
private ITypeSearch<Hotel> GetPriceFilter(ITypeSearch<Hotel> search, SearchQuery query)
{
if (query.PriceTo > 0)
{
search = search.Filter(x => x.PriceUSD.InRange((int)query.PriceFrom, (int)query.PriceTo));
}
return search;
}
/// <summary>
/// Use this to filter for only specific cities. Unfortunately there isn't a city property available. So when searching
/// for hotels in particular city Geo search is used. For this example site a range of 20 kilometer is used.
/// </summary>
/// <param name="search"></param>
/// <param name="query"></param>
/// <returns></returns>
private ITypeSearch<Hotel> GetCityFilter(ITypeSearch<Hotel> search, SearchQuery query)
{
var cities =_popularCitiesService.GetCities();
var city = cities.FirstOrDefault(c => c.Title.Equals(query.Query, StringComparison.InvariantCultureIgnoreCase));
if (city != null)
{
search = search.Filter(h => h.GeoCoordinates.WithinDistanceFrom(
new GeoLocation(city.Coordinates.Latitude, city.Coordinates.Longitude), 20.Kilometers()));
}
return search;
}
/// <summary>
/// Get filters
/// </summary>
/// <param name="search"></param>
/// <param name="query"></param>
/// <returns></returns>
private ITypeSearch<Hotel> GetFilters(ITypeSearch<Hotel> search, SearchQuery query)
{
search = GetPriceFilter(search, query);
search = GetRatingFilter(search, query);
search = GetFacilityFilter(search, query);
search = GetCityFilter(search, query);
return search;
}
