public SortDefinition <T> FilterConditionToSort <T>(List <FilterCondition> filter) { SortDefinitionBuilder <T> sort = Builders <T> .Sort; SortDefinition <T> sd = null; if (filter == null) { return(sd); } foreach (FilterCondition s in filter) { if (!s.OrderType.HasValue) { continue; } if (s.OrderType == TableOrderType.DESCENDING) { sd = sort.Combine(sort.Descending(s.Key)); } else { sd = sort.Combine(sort.Ascending(s.Key)); } } return(sd); }
public DbQuery <TEntity> Ascending(Expression <Func <TEntity, object> > expression) { if (SortDefenition == null) { SortDefenition = _sortBuilder.Ascending(expression); } else { SortDefenition = _sortBuilder.Combine(SortDefenition, _sortBuilder.Ascending(expression)); } return(this); }
public static SortDefinition <MongoContentEntity> BuildSort(ODataUriParser query, Schema schema) { var orderBy = query.ParseOrderBy(); if (orderBy != null) { var sorts = new List <SortDefinition <MongoContentEntity> >(); while (orderBy != null) { sorts.Add(OrderBy(orderBy, schema)); orderBy = orderBy.ThenBy; } if (sorts.Count > 1) { return(Sort.Combine(sorts)); } else { return(sorts[0]); } } else { return(Sort.Descending(x => x.LastModified)); } }
public SortDefinition <TSort> GetSortDefinition <TSort>(Expression <Func <IEnumerable <TSort>, dynamic> > orderBy) { var stackMember = new Stack <string>(); var stackSortMethod = new Stack <int>(); new SortExpressionParser().Parsing <TSort>(orderBy, stackMember, stackSortMethod); if (stackMember.Any() && stackSortMethod.Any() && stackMember.Count == stackSortMethod.Count) { var length = stackMember.Count; SortDefinitionBuilder <TSort> builder = new SortDefinitionBuilder <TSort>(); List <SortDefinition <TSort> > list = new List <SortDefinition <TSort> >(); for (var i = 0; i < length; i++) { var name = stackMember.Pop(); var way = stackSortMethod.Pop(); if (way == 1) { list.Add(builder.Ascending(name)); } else { list.Add(builder.Descending(name)); } } var definition = builder.Combine(list); return(definition); } return(null); }
public static SortDefinition <BsonDocument> GetCustomerSortDefinition() { var sortBuilder = new SortDefinitionBuilder <BsonDocument>(); var daySortDefinition = sortBuilder.Ascending("Day"); var monthSortDefinition = sortBuilder.Ascending("Month"); var netWorthSortDefinition = sortBuilder.Descending("NetWorth"); var yearSortDefinition = sortBuilder.Ascending("Year"); var sortDefinition = sortBuilder.Combine(daySortDefinition, monthSortDefinition, netWorthSortDefinition, yearSortDefinition); return(sortDefinition); }
protected virtual async Task <IEnumerable <object> > GetCollection(Expression <Func <T, bool> > filter, PagingSettings paging, IEnumerable <SortingField> sortings, Expression <Func <T, object> > projection, CancellationToken token = default(CancellationToken)) { if (!CollectionExist) { return(new List <object>()); } try { var collection = filter == null?Collection.Find(_ => true) : Collection.Find(filter); var sortingBuilder = new SortDefinitionBuilder <T>(); var sorts = new List <SortDefinition <T> >(); if (sortings != null) { sorts.AddRange(from sf in sortings where !sf.IsNull select sf.SortingMode == SortingModes.Ascending ? sortingBuilder.Ascending(sf.FieldName) : sortingBuilder.Descending(sf.FieldName)); } collection.Sort(sortingBuilder.Combine(sorts)); if (projection != null) { collection.Project(projection); } if (paging == null) { return((IEnumerable <object>) await collection.ToListAsync(CancellationToken.None)); } if (paging.Skip != null) { collection = collection.Skip(paging.Skip); } if (paging.Limit != null) { collection = collection.Limit(paging.Limit); } return((IEnumerable <object>) await collection.ToListAsync(token)); } catch (Exception e) { throw new Exception(e.Message); } }
public virtual async Task <IEnumerable <T> > GetAsync( Expression <Func <T, bool> > filter, PagingOptions pagingOptions, IList <SortingOptions> sortingOptions, CancellationToken token) { try { if (!this.IsCollectionsExists) { return(Enumerable.Empty <T>()); } var sortDefinitionBuilder = new SortDefinitionBuilder <T>(); var sortDefinitions = new List <SortDefinition <T> >(); if (sortingOptions.Any()) { sortDefinitions.AddRange( sortingOptions.Select( sortingOption => sortingOption.SortingMode == SortingMode.Ascending ? sortDefinitionBuilder.Ascending(sortingOption.FieldName) : sortDefinitionBuilder.Descending(sortingOption.FieldName))); } var sourceCollection = filter == null?Collection.Find(_ => true) : Collection.Find(filter); sourceCollection.Sort(sortDefinitionBuilder.Combine(sortDefinitions)); if (pagingOptions != null && pagingOptions.Skip != null) { sourceCollection = sourceCollection.Skip(pagingOptions.Skip); } if (pagingOptions != null && pagingOptions.Limit != null) { sourceCollection = sourceCollection.Limit(pagingOptions.Limit); } return(await sourceCollection.ToListAsync(token)); } catch (Exception e) { Console.WriteLine(e); throw; } }
public List <BsonDocument> FindByKVPair(string set_name, FilterDefinition <BsonDocument> filterDef, object sort_list = null, int limit = 0, int skip = 0) { SortDefinition <BsonDocument> sorts = null; if (sort_list != null) { SortDefinitionBuilder <BsonDocument> builderSort = Builders <BsonDocument> .Sort; List <SortDefinition <BsonDocument> > sort = new List <SortDefinition <BsonDocument> >(); foreach (KeyValuePair <string, string> kvp in sort_list as Dictionary <string, string> ) { if (kvp.Value == "ASC") { sort.Add(builderSort.Ascending(kvp.Key)); } else { sort.Add(builderSort.Descending(kvp.Key)); } } sorts = builderSort.Combine(sort.ToList()); } IFindFluent <BsonDocument, BsonDocument> find_op = mdb.GetCollection <BsonDocument>(set_name).Find(filterDef); if (sorts != null) { find_op = find_op.Sort(sorts); } if (skip > 0) { find_op = find_op.Skip(skip); } if (limit > 0) { find_op = find_op.Limit(limit); } return(find_op.ToList()); }
private async Task <IEnumerable <T> > FetchEntities <T> ( string metaPhrase, ProjectionDefinition <T> projection, IMongoCollection <T> collection, double daysTolerance, int limit, GeoJsonPoint <GeoJson3DGeographicCoordinates> targetPosition = null ) where T : IIdentifiable <ObjectId>, ILocatable, IMetaScored { var referenceDate = DateTime.UtcNow; var filterBuilder = new FilterDefinitionBuilder <T>(); var filter = filterBuilder.And ( filterBuilder.Gt ( post => post._id, new ObjectId(referenceDate.Subtract(TimeSpan.FromDays(daysTolerance)), 0, 0, 0) ), filterBuilder.Or ( filterBuilder.Text(metaPhrase, new TextSearchOptions { CaseSensitive = false, DiacriticSensitive = false, }) , filterBuilder.Exists(p => p._id) ) ); var sortBuilder = new SortDefinitionBuilder <T>(); var sort = sortBuilder.Combine ( sortBuilder.MetaTextScore("metaScore"), sortBuilder.Descending(p => p._id) ); var cursor = await collection.FindAsync(filter, new FindOptions <T> { AllowPartialResults = true, Limit = limit, Sort = sort, Projection = projection }); var enumerable = cursor.ToEnumerable(); if (targetPosition != null) { enumerable = enumerable.OrderBy ( item => item.Position.Coordinates.ToGeoCoordinate().GetDistanceTo(targetPosition.Coordinates.ToGeoCoordinate()) - Math.Pow(item.MetaScore, 2) ); } return(enumerable); }