public override LambdaQuery <T> OrderBy <TResult>(System.Linq.Expressions.Expression <Func <T, TResult> > expression, bool desc = true) { //var sortBuild = Builders<T>.Sort; var field = GetSelectField(false, expression.Body, false, typeof(T)).First(); if (desc) { _MongoDBSort = _MongoDBSort.Descending(field.MemberName); } else { _MongoDBSort = _MongoDBSort.Ascending(field.MemberName); } return(this); }
public static SortDefinition <T> getSortDefinition(Dictionary <string, int> sortfields) { SortDefinition <T> sd = null; foreach (var item in sortfields) { if (sd == null) { if (item.Value == 1) { sd = Builders <T> .Sort.Ascending(item.Key); } else { sd = Builders <T> .Sort.Descending(item.Key); } } else { if (item.Value == 1) { sd.Ascending(item.Key); } else { sd.Descending(item.Key); } } } return(sd); }
/// <summary> /// 构造排序 /// </summary> /// <param name="interfaceSortId"></param> /// <returns></returns> private SortDefinition <BsonDocument> StructureSortDefinition(Guid interfaceSortId) { var builder = new SortDefinitionBuilder <BsonDocument>(); SortDefinition <BsonDocument> sort = null; if (interfaceSortId == Guid.Empty) { return(builder.Ascending("_id")); } var sorts = _interfaceSortRepository.GetInterfaceSortByParentId(interfaceSortId) ?? new List <InterfaceSort>(0); foreach (var item in sorts) { switch (item.GetSortType()) { case SortTypeEnum.DESC: sort = sort?.Descending(item.MetaFieldShortCode) ?? builder.Descending(item.MetaFieldShortCode); break; case SortTypeEnum.ASC: sort = sort?.Ascending(item.MetaFieldShortCode) ?? builder.Ascending(item.MetaFieldShortCode); break; default: break; } } return(sort); }
/// <summary> /// Creates a SortDefintiion for the sort order /// </summary> /// <remarks>Error codes follow the format DAL-SM-5XX</remarks> /// <typeparam name="T">The document type</typeparam> /// <param name="sort">The sort string</param> /// <returns>A generated Sort Definition</returns> public static SortDefinition <T> CreateSort <T>(string sort) { var builder = Builders <T> .Sort; SortDefinition <T> sortDef = null; if (String.IsNullOrEmpty(sort)) { return(sortDef); } foreach (string s in sort.Split(',')) { string[] sortItemParts = s.Trim().Split(' '); string sortItemDirection = sortItemParts.Length > 1 ? sortItemParts[1] : "asc"; var sortField = ConvertCase <T>(sortItemParts[0]); if (sortItemDirection.ToLower() == "desc") { sortDef = (sortDef == null) ? builder.Descending(sortField) : sortDef.Descending(sortField); } else { sortDef = (sortDef == null) ? builder.Ascending(sortField) : sortDef.Ascending(sortField); } } return(sortDef); }
public override LambdaQuery <T> OrderBy <TResult>(System.Linq.Expressions.Expression <Func <T, TResult> > expression, bool desc = true) { //var sortBuild = Builders<T>.Sort; var parameters = expression.Parameters.Select(b => b.Type).ToArray(); var field = GetSelectField(false, expression.Body, false, parameters).mapping.First(); if (desc) { _MongoDBSort = _MongoDBSort.Descending(field.ResultName); } else { _MongoDBSort = _MongoDBSort.Ascending(field.ResultName); } return(this); }
SortDefinition <TEntity> BuildSortDefinitionFromFilterOptions(FilterOptions <TEntity> filterOptions) { if (filterOptions?.SortFields == null) { return(null); } var builder = new SortDefinitionBuilder <TEntity>(); SortDefinition <TEntity> sortDefinition = null; foreach (var sortField in filterOptions.SortFields) { switch (sortField.Order) { case FilterOptions <TEntity> .SortOrderEnum.Ascending: sortDefinition = sortDefinition?.Ascending(sortField.Field) ?? builder.Ascending(sortField.Field); break; case FilterOptions <TEntity> .SortOrderEnum.Descending: sortDefinition = sortDefinition?.Descending(sortField.Field) ?? builder.Descending(sortField.Field); break; } } return(sortDefinition); }
private static SortDefinition <BsonDocument> CreateSortBy(IList <Tuple <string, SortOrder> > sortItems) { if (sortItems.Any() == false) { return(null); } SortDefinition <BsonDocument> sortDefinition = null; var first = sortItems.FirstOrDefault(); if (first.Item2 == SortOrder.Ascending) { sortDefinition = Builders <BsonDocument> .Sort.Ascending(first.Item1); } else { sortDefinition = Builders <BsonDocument> .Sort.Descending(first.Item1); } sortItems.Remove(first); foreach (Tuple <string, SortOrder> sortItem in sortItems) { if (sortItem.Item2 == SortOrder.Ascending) { sortDefinition = sortDefinition.Ascending(sortItem.Item1); } else { sortDefinition = sortDefinition.Descending(sortItem.Item1); } } return(sortDefinition); }
public ItemList Query(string collection, DataQuery query) { FilterDefinition <BsonDocument> filter = FilterDefinition <BsonDocument> .Empty; var dataContext = new Dictionary <string, object>(); dataContext["expando"] = query.Expando; if (query.RawQuery != null) { filter = new JsonFilterDefinition <BsonDocument>(query.RawQuery); } InvokeAlterQuery(collection, filter); IFindFluent <BsonDocument, BsonDocument> results = _mongoService .GetCollection <BsonDocument>(collection).Find <BsonDocument>(filter) .Skip((query.PageNumber - 1) * query.PageSize) .Limit(query.PageSize); if (query.Sort != null) { var sort = new SortDefinitionBuilder <BsonDocument>(); SortDefinition <BsonDocument> sortDef = null; foreach (var sortable in query.Sort) { FieldDefinition <BsonDocument> field = sortable.Field; if (sortable.Ascending) { sortDef = (sortDef == null) ? sort.Ascending(field) : sortDef.Ascending(field); } else { sortDef = (sortDef == null) ? sort.Descending(field) : sortDef.Descending(field); } } results = results.Sort(sortDef); } long count = Count(collection, filter); List <BsonDocument> list = results.ToList(); //sanitize id format foreach (BsonDocument item in list) { item["_id"] = item["_id"].ToString(); } string json = list.ToJson(js); var result = JArray.Parse(json); for (int i = 0; i < result.Count; i++) { var node = (JObject)result[i]; InvokeProcess(collection, ref node, PipelineStage.PostOperation, DataOperation.Read, dataContext); } return(new ItemList(result, (int)count, query.PageNumber, query.PageSize)); }
public async Task <BaseResultModel <T> > GetPageListAsync(int pageIndex, int pageSize, Dictionary <string, string> sortDic, Expression <Func <T, bool> > expression) { BaseResultModel <T> baseResultModel = new BaseResultModel <T>(); string msg = string.Empty; try { var filters = new List <FilterDefinition <T> >(); filters.Add(GetAction(expression)); FilterDefinition <T> filter = Builders <T> .Filter.And(filters); baseResultModel.total = await collection.CountDocumentsAsync(filter); var sort = Builders <T> .Sort; SortDefinition <T> sortDefinition = null; foreach (var item in sortDic) { if (null == sortDefinition) { if (item.Value == "d") { sortDefinition = sort.Descending(item.Key); } else { sortDefinition = sort.Ascending(item.Key); } } else { if (item.Value == "d") { sortDefinition = sortDefinition.Descending(item.Key); } else { sortDefinition = sortDefinition.Ascending(item.Key); } } } FindOptions <T, T> findOptions = new FindOptions <T, T>(); findOptions.Limit = pageSize; findOptions.Skip = (pageIndex - 1) * pageSize; findOptions.Sort = sortDefinition; //Pageable pageable = PageRequest.of(pageNUmber, pageSize); var fullCollectioin = await collection.FindAsync(filter, findOptions); baseResultModel.rows = await fullCollectioin.ToListAsync(); baseResultModel.success = true; } catch (Exception ex) { baseResultModel.success = false; baseResultModel.msg = ex.Message; } return(baseResultModel); }
/// <summary> /// 获取Top多少条数据 /// </summary> /// <param name="limit">条数</param> /// <param name="sortDic">排序字典</param> /// <param name="expression">条件</param> /// <returns></returns> public async Task <List <T> > GetListAsync(int limit, Dictionary <string, string> sortDic, Expression <Func <T, bool> > expression) { List <T> list = new List <T>(); try { var filters = new List <FilterDefinition <T> >(); filters.Add(GetAction(expression)); FilterDefinition <T> filter = Builders <T> .Filter.And(filters); var sort = Builders <T> .Sort; SortDefinition <T> sortDefinition = null; foreach (var item in sortDic) { if (null == sortDefinition) { if (item.Value == "d") { sortDefinition = sort.Descending(item.Key); } else { sortDefinition = sort.Ascending(item.Key); } } else { if (item.Value == "d") { sortDefinition = sortDefinition.Descending(item.Key); } else { sortDefinition = sortDefinition.Ascending(item.Key); } } } FindOptions <T, T> findOptions = new FindOptions <T, T>(); findOptions.Limit = limit; findOptions.Sort = sortDefinition; //Pageable pageable = PageRequest.of(pageNUmber, pageSize); var fullCollectioin = await collection.FindAsync(filter, findOptions); list = await fullCollectioin.ToListAsync(); } catch (Exception ex) { Console.WriteLine(ex.Message); } return(list); }
/// <summary> /// 初始化排序条件 主要当条件为空时 会默认以ObjectId递增的一个排序 /// </summary> /// <param name="sortBy"></param> /// <returns></returns> private SortDefinition <BsonDocument> InitSortBy(string sortBy, params string[] fields) { SortDefinitionBuilder <BsonDocument> sortBuilder = Builders <BsonDocument> .Sort; SortDefinition <BsonDocument> sortFilter = null; if (sortBy == null) { //默认ObjectId 递增 sortFilter = Builders <BsonDocument> .Sort.Descending(OBJECTID_KEY); // new BsonDocument(OBJECTID_KEY, 1); } else { if (sortBy.ToLower() == "asc") { foreach (var item in fields) { if (sortFilter == null) { sortFilter = sortBuilder.Ascending(item); } else { sortFilter = sortFilter.Ascending(item); } } } else if (sortBy.ToLower() == "desc") { foreach (var item in fields) { if (sortFilter == null) { sortFilter = sortBuilder.Descending(item); } else { sortFilter = sortFilter.Descending(item); } } } else { sortFilter = sortFilter.Descending(OBJECTID_KEY); } } return(sortFilter); }
public SortDefinition <BsonDocument> GetSortDefinitionBySortFields(int metaObjectId, SortField[] sortFields) { var builder = new SortDefinitionBuilder <BsonDocument>(); if (sortFields == null || !sortFields.Any()) { //默认给更新时间倒序排列 sortFields = new[] { new SortField { Column = "ModifyTime", IsDesc = true } }; } //获取全部字段 var metaFieldDic = GetMetaFieldDicUnDeleted(metaObjectId); SortDefinition <BsonDocument> sort = null; foreach (var item in sortFields) { if (!metaFieldDic.ContainsKey(item.Column)) { throw new ArgumentNullException(item.Column, $"field of {item.Column} is not exist in current MetaObject"); } if (item.IsDesc) { if (sort == null) { sort = builder.Descending(item.Column); } else { sort = sort.Descending(item.Column); } } else { if (sort == null) { sort = builder.Ascending(item.Column); } else { sort = sort.Ascending(item.Column); } } } return(sort); }
private static SortDefinition <T> CreateODataSort <T>(IODataQuery query, bool check = false) { var orderby = query.Order; SortDefinitionBuilder <T> sortBuilder = Builders <T> .Sort; SortDefinition <T> sortDefinition = null; SortDefinition <T> defaultSortDefinition = sortBuilder.Descending("CreateDate"); if (String.IsNullOrEmpty(orderby)) { return(defaultSortDefinition); } var sections = orderby.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries); foreach (var section in sections) { var order = section.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries); var field = order.FirstOrDefault(); var direction = "asc"; if (check && !typeof(T).HasField(field)) { continue; } if (order.LastOrDefault().ToLower() == "desc") { direction = "desc"; } if (sortDefinition == null) { sortDefinition = direction == "asc" ? sortBuilder.Ascending(field) : sortBuilder.Descending(field); } sortDefinition = direction == "asc" ? sortDefinition.Ascending(field) : sortDefinition.Descending(field); } return(sortDefinition ?? defaultSortDefinition); }
public SortDefinition <BsonDocument> GetSortDefinitionBySortFields(QueryPiplineContext queryPiplineContext, SortField[] sortFields) { var builder = new SortDefinitionBuilder <BsonDocument>(); if (sortFields == null || !sortFields.Any()) { return(builder.Ascending("_id")); } //获取全部字段 SortDefinition <BsonDocument> sort = null; var metaFieldDic = queryPiplineContext.MetaFieldsUnDeletedCodeDic; foreach (var item in sortFields) { if (!metaFieldDic.ContainsKey(item.Column)) { throw new ArgumentNullException(item.Column, $"field of {item.Column} is not exist in current MetaObject"); } if (item.IsDesc) { if (sort == null) { sort = builder.Descending(item.Column); } else { sort = sort.Descending(item.Column); } } else { if (sort == null) { sort = builder.Ascending(item.Column); } else { sort = sort.Ascending(item.Column); } } } return(sort); }
public IList <TEntity> GetSelected(string query, int pageNo, int pageSize, string sortBy, string sortDirection, out long totalCount) { try { SortDefinition <TEntity> sortDefinition = null; SortDefinitionBuilder <TEntity> sortDefinitionBuilder = Builders <TEntity> .Sort; switch (sortDirection) { case "asc": if (sortDefinition == null) { sortDefinition = sortDefinitionBuilder.Ascending(sortBy); } else { sortDefinition = sortDefinition.Ascending(sortBy); } break; case "desc": if (sortDefinition == null) { sortDefinition = sortDefinitionBuilder.Descending(sortBy); } else { sortDefinition = sortDefinition.Descending(sortBy); } break; } var result = collection.Find(query).ToList(); totalCount = result.Count(); return(collection.Find(query).Sort(sortDefinition).Skip(pageSize * (pageNo - 1)).Limit(pageSize).ToList()); } catch (Exception ex) { totalCount = 0; return(new List <TEntity>()); } }
private SortDefinition <T> BuildSort() { SortDefinition <T> sort = null; if (_sorts != null) { foreach (var oneSort in _sorts) { if (oneSort.Order == SortOrder.Ascending) { sort.Ascending(oneSort.SortKey.Name.UppercaseFirstLetter()); } else { sort.Descending(oneSort.SortKey.Name.UppercaseFirstLetter()); } } } return(sort); }
/// <summary> /// Generate a sort definition from a Query Information /// </summary> /// <returns>MongoDB Filter definition for T</returns> internal SortDefinition <T> buildSortingDefinition() { SortDefinition <T> sortDef = null; if (SortFields.Count > 0) { var sortBuilder = Builders <T> .Sort; foreach (var sortField in SortFields) { if (sortDef == null) { sortDef = (sortField.Ascending) ? sortBuilder.Ascending(sortField.Field) : sortBuilder.Descending(sortField.Field); } else { sortDef = (sortField.Ascending) ? sortDef.Ascending(sortField.Field) : sortDef.Descending(sortField.Field); } } } return(sortDef); }
/// <summary> /// Converts sorting parameters to MongoDB sort definition. /// </summary> /// <param name="sorting">The sorting parameters to convert.</param> /// <returns>The converted MongoDB sorting parameters.</returns> public static SortDefinition <BsonDocument> ToSortDefinition(this SortingParameters sorting) { if (sorting == null) { return(null); } var builder = Builders <BsonDocument> .Sort; SortDefinition <BsonDocument> result = null; foreach (var sort in sorting.Sorts) { if (result == null) { if (sort.Direction == SortingDirection.Ascending) { result = builder.Ascending(sort.Attribute); } else { result = builder.Descending(sort.Attribute); } } else { if (sort.Direction == SortingDirection.Ascending) { result = result.Ascending(sort.Attribute); } else { result = result.Descending(sort.Attribute); } } } return(result); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="E"></typeparam> public void Apply <T, E>() where T : class, IDto <E, T>, new() where E : class, IDocumentEntity, IEntity, new() { FilterDefinition <E> filter = (CreateFilter == null) ? null : (FilterDefinition <E>)CreateFilter?.Invoke(); ProjectionDefinition <E> projection = (CreateProjection == null) ? null : (ProjectionDefinition <E>)CreateProjection?.Invoke(); filter = CreateFilters <E>(Filter, filter); if (IsAggregate) { var query = MongoDbServices.Instance(IntanceMongoDb).GetCollection <E>().Aggregate().Match(filter).Group(projection); } else { IFindFluent <E, E> query = null; if (filter != null) { query = MongoDbServices.Instance(IntanceMongoDb).GetCollection <E>().Find(filter); } else { query = MongoDbServices.Instance(IntanceMongoDb).GetCollection <E>().Find(x => true); } if (projection != null) { query.Project(projection); } var sortB = Builders <E> .Sort; SortDefinition <E> sort = null; foreach (var item in Order) { switch (item.Direction.ToString()) { case "-": { if (sort == null) { sort = sortB.Descending(item.Property); } else { sort = sort.Descending(item.Property); } break; } case "+": { if (sort == null) { sort = sortB.Ascending(item.Property); } else { sort = sort.Ascending(item.Property); } break; } } } if (sort != null) { query.Sort(sort); } PageSize = PageSize ?? 1; RecordCount = query.Count(); PageCount = (RecordCount / PageSize); PageCount += (PageCount < ((float)RecordCount / (float)PageSize)) ? 1 : 0; Data = new T().SetEntity(query.Skip((PageIndex - 1) * PageSize).Limit(PageSize).ToList <E>()); } }
public IList <TEntity> SearchFor(PagingFiltering criteria, int pageNo, int pageSize, out long totalCount) { try { var resultItems = new List <TEntity>(); FilterDefinition <TEntity> filter = null; SortDefinition <TEntity> sortDefinition = null; SortDefinitionBuilder <TEntity> sortDefinitionBuilder = Builders <TEntity> .Sort; int searchval; if (null != criteria.filter) { // TODO: Need expand query filter base on datatype. if (criteria.filter.Filters != null) { foreach (var item in criteria.filter.Filters) { switch (item.Operator) { case "startswith": if (int.TryParse(item.Value, out searchval)) { if (filter == null) { filter = Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex("^" + searchval))); } else { filter = filter & Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex("^" + searchval))); } } else { if (filter == null) { filter = Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex("^" + item.Value))); } else { filter = filter & Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex("^" + item.Value))); } } break; case "eq": if (item.DataType == "int") { if (filter == null) { filter = Builders <TEntity> .Filter.Eq(item.Field, item.intValue); } else { filter = filter & Builders <TEntity> .Filter.Eq(item.Field, item.intValue); } } else { if (int.TryParse(item.Value, out searchval)) { if (filter == null) { filter = Builders <TEntity> .Filter.Eq(item.Field, searchval); } else { filter = filter & Builders <TEntity> .Filter.Eq(item.Field, searchval); } } else { if (filter == null) { filter = Builders <TEntity> .Filter.Eq(item.Field, item.Value); } else { filter = filter & Builders <TEntity> .Filter.Eq(item.Field, item.Value); } } } break; case "neq": if (filter == null) { filter = Builders <TEntity> .Filter.Ne(item.Field, item.Value); } else { filter = filter & Builders <TEntity> .Filter.Ne(item.Field, item.Value); } break; case "contains": if (filter == null) { filter = Builders <TEntity> .Filter.Regex(item.Field, "/" + item.Value + "/i"); } else { filter = (filter | Builders <TEntity> .Filter.Regex(item.Field, "/" + item.Value + "/i")); } int result = 0; //As we are not getting DataType of field in search cases so checking that the given search value is a integer. If yes adding it as a number filter as well. if ((!string.IsNullOrEmpty(item.Value)) && int.TryParse(item.Value, out result)) { filter = (filter | Builders <TEntity> .Filter.Eq(item.Field, result)); } break; case "endswith": if (filter == null) { filter = Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex(item.Value + "$"))); } else { filter = filter & Builders <TEntity> .Filter.Regex(item.Field, new BsonRegularExpression(new Regex(item.Value + "$"))); } break; case "lt": if (filter == null) { filter = Builders <TEntity> .Filter.Lt(item.Field, item.Value); } else { filter = filter & Builders <TEntity> .Filter.Lt(item.Field, item.Value); } break; case "gt": if (filter == null) { filter = Builders <TEntity> .Filter.Gt(item.Field, item.Value); } else { filter = filter & Builders <TEntity> .Filter.Gt(item.Field, item.Value); } break; case "lte": if (filter == null) { filter = Builders <TEntity> .Filter.Lte(item.Field, item.Value); } else { filter = filter & Builders <TEntity> .Filter.Lte(item.Field, item.Value); } break; case "gte": if (filter == null) { filter = Builders <TEntity> .Filter.Gte(item.Field, item.Value); } else { filter = filter & Builders <TEntity> .Filter.Gte(item.Field, item.Value); } break; default: break; } } } } //Added new sort block if (null != criteria.Sort) { foreach (var sort in criteria.Sort) { if (!string.IsNullOrEmpty(sort.Field)) { switch (sort.Dir) { case "asc": if (sortDefinition == null) { sortDefinition = sortDefinitionBuilder.Ascending(sort.Field); } else { sortDefinition = sortDefinition.Ascending(sort.Field); } break; case "desc": if (sortDefinition == null) { sortDefinition = sortDefinitionBuilder.Descending(sort.Field); } else { sortDefinition = sortDefinition.Descending(sort.Field); } break; } } } } FilterDefinition <TEntity> filterCriteria; if (filter == null) { filterCriteria = Builders <TEntity> .Filter.Empty; } else { filterCriteria = filter; } IFindFluent <TEntity, TEntity> cursor; if (sortDefinition == null) { cursor = collection.Find(filterCriteria); } else { cursor = collection.Find(filterCriteria).Sort(sortDefinition); } totalCount = cursor.Count(); cursor = cursor.Skip(pageSize * (pageNo - 1)); if (pageSize >= 0) { cursor = cursor.Limit(pageSize); } resultItems.AddRange(cursor.ToList()); return(resultItems); } catch (Exception ex) { logManager.LogMessage("Message: " + ex.Message + Environment.NewLine + "StackTrace: " + ex.StackTrace + Environment.NewLine + "InnerException: " + ex.InnerException, "", "", LogLevel.Error); totalCount = 0; return(new List <TEntity>()); } }
public ResponseObject <List <ToDoMgModel> > GetToDoModel(RequestGet requestObject, CurrentUser currentUser) { ResponseObject <List <ToDoMgModel> > responseObject = new ResponseObject <List <ToDoMgModel> >(); responseObject.Code = 0; try { List <ToDoMgModel> result = new List <ToDoMgModel>(); Expression <Func <ToDoMgModel, bool> > queryConditionLam = (x) => x.To == currentUser.UserID && x.CompanyID == currentUser.CompanyID; if (requestObject.QueryConditions != null && requestObject.QueryConditions.Count > 0) { var conditionals = SqlSugarUtil.GetConditionalFull(requestObject.QueryConditions).Where(p => !string.IsNullOrWhiteSpace(p.FieldValue)).ToList(); var whereConditional = ConditionalModelToExpression.BuildExpression <ToDoMgModel>(conditionals); queryConditionLam = queryConditionLam.And(whereConditional); } SortDefinition <ToDoMgModel> sort = null; //排序条件 if (requestObject.OrderByConditions != null && requestObject.OrderByConditions.Count > 0) { foreach (var item in requestObject.OrderByConditions) { var exp = SqlSugarUtil.GetExpression <ToDoMgModel>(item.Column); if (exp == null) { continue; } if (item.Condition.ToLower() == "asc") { if (sort == null) { sort = Builders <ToDoMgModel> .Sort.Ascending(exp); } else { sort = sort.Ascending(exp); } } else if (item.Condition.ToLower() == "desc") { if (sort == null) { sort = Builders <ToDoMgModel> .Sort.Descending(exp); } else { sort = sort.Descending(exp); } } } } long totalNum = 0; if (requestObject.IsPaging == true) { result = MongoDbUtil.GetDoc <ToDoMgModel>(queryConditionLam, requestObject.PageIndex, requestObject.PageSize, sort, ref totalNum); } else { result = MongoDbUtil.GetDoc <ToDoMgModel>(queryConditionLam, sort).ToList(); } return(ResponseUtil <List <ToDoMgModel> > .SuccessResult(result, totalNum)); } catch (Exception ex) { return(ResponseUtil <List <ToDoMgModel> > .FailResult(null, ex.Message)); } }
private async Task <IEnumerable <T> > Find <T>(ObjectSerializer Serializer, IMongoCollection <BsonDocument> Collection, int Offset, int MaxCount, FilterDefinition <BsonDocument> BsonFilter, params string[] SortOrder) { IFindFluent <BsonDocument, BsonDocument> ResultSet = Collection.Find <BsonDocument>(BsonFilter); if (SortOrder.Length > 0) { SortDefinition <BsonDocument> SortDefinition = null; foreach (string SortBy in SortOrder) { if (SortDefinition == null) { if (SortBy.StartsWith("-")) { SortDefinition = Builders <BsonDocument> .Sort.Descending(Serializer.ToShortName(SortBy.Substring(1))); } else { SortDefinition = Builders <BsonDocument> .Sort.Ascending(Serializer.ToShortName(SortBy)); } } else { if (SortBy.StartsWith("-")) { SortDefinition = SortDefinition.Descending(Serializer.ToShortName(SortBy.Substring(1))); } else { SortDefinition = SortDefinition.Ascending(Serializer.ToShortName(SortBy)); } } } ResultSet = ResultSet.Sort(SortDefinition); } if (Offset > 0) { ResultSet = ResultSet.Skip(Offset); } if (MaxCount < int.MaxValue) { ResultSet = ResultSet.Limit(MaxCount); } IAsyncCursor <BsonDocument> Cursor = await ResultSet.ToCursorAsync(); LinkedList <T> Result = new LinkedList <T>(); BsonDeserializationArgs Args = new BsonDeserializationArgs() { NominalType = typeof(T) }; while (await Cursor.MoveNextAsync()) { foreach (BsonDocument Document in Cursor.Current) { BsonDocumentReader Reader = new BsonDocumentReader(Document); BsonDeserializationContext Context = BsonDeserializationContext.CreateRoot(Reader); T Obj = (T)Serializer.Deserialize(Context, Args); Result.AddLast(Obj); } } return(Result); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="collection"></param> /// <param name="filter"></param> /// <param name="projection"></param> private void Apply <T>(IMongoCollection <T> collection, FilterDefinition <T> filter, ProjectionDefinition <T> projection) { filter = CreateFilters <T>(Filter, filter); if (IsAggregate) { var sortB = Builders <T> .Sort; SortDefinition <T> sort = null; foreach (var item in Order) { switch (item.Direction.ToString()) { case "-": { if (sort == null) { sort = sortB.Descending(item.Property); } else { sort = sort.Descending(item.Property); } break; } case "+": { if (sort == null) { sort = sortB.Ascending(item.Property); } else { sort = sort.Ascending(item.Property); } break; } } } var Group = BsonDocumentWrapper.Parse(JsonConvert.SerializeObject(GroupBy)); IAggregateFluent <T> query = null; var options = new AggregateOptions(); if (sort != null) { query = collection.Aggregate().Match(filter).Sort(sort).Group <T>(Group).Project <T>(BsonDocumentWrapper.Parse("{'id':'$_id','count':'$count'}")); } else { query = collection.Aggregate().Match(filter).Group <T>(Group).Project <T>(BsonDocumentWrapper.Parse("{'id':'$_id','count':'$count'}")); } Data = query.ToList <T>(); } else { IFindFluent <T, T> query = null; if (filter != null) { query = collection.Find(filter); } else { query = collection.Find(x => true); } if (projection != null) { query = query.Project <T>(projection); } var sortB = Builders <T> .Sort; SortDefinition <T> sort = null; foreach (var item in Order) { switch (item.Direction.ToString()) { case "-": { if (sort == null) { sort = sortB.Descending(item.Property); } else { sort = sort.Descending(item.Property); } break; } case "+": { if (sort == null) { sort = sortB.Ascending(item.Property); } else { sort = sort.Ascending(item.Property); } break; } } } if (sort != null) { query.Sort(sort); } PageSize = PageSize ?? 1; RecordCount = query.Count(); if (PageSize != int.MaxValue) { PageCount = (RecordCount / PageSize); PageCount += (PageCount < ((float)RecordCount / (float)PageSize)) ? 1 : 0; Data = query.Skip((PageIndex - 1) * PageSize).Limit(PageSize).ToList <T>(); } else { PageCount = 1; Data = query.ToList <T>(); } } }