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; }