private IMongoQueryable <T> GetQueryableByConditionsAndSort <TKey>(Expression <Func <T, bool> > expression, Sort <T, TKey> sort) { if (sort == null) { throw new ArgumentNullException(nameof(sort)); } IMongoQueryable <T> entities = this.GetQueryableByConditions(expression); switch (sort.SortType) { case SortType.Asc: entities = entities.OrderBy(sort.SortExpression); break; case SortType.Desc: entities = entities.OrderByDescending(sort.SortExpression); break; default: throw new ArgumentException(); } return(entities); }
public static IMongoQueryable <T> SortBy <T>(this IMongoQueryable <T> query, IEnumerable <SortRequest> sorts) { if (sorts == null || !sorts.Any()) { return(query); } var firstSort = sorts.FirstOrDefault(); IOrderedQueryable <T> result = null; // ReSharper disable once PossibleNullReferenceException if (firstSort.Asc) { result = query.OrderBy(firstSort.Field); } else { result = query.OrderByDescending(firstSort.Field); } for (int i = 1; i < sorts.Count(); i++) { var sort = sorts.ElementAt(i); if (sort.Asc) { result = result.ThenBy(sort.Field); } else { result = result.ThenByDescending(sort.Field); } } return(result as IMongoQueryable <T>); }
public static async Task <IQueryResult <TDocument> > Paginate <TDocument>(this IMongoQueryable <TDocument> queryable, PaginationOptions <TDocument> options) { if (options == default) { options = new PaginationOptions <TDocument>() { Page = DefaultPage, PageSize = DefaultPageSize }; } if (options.Sorting != default && options.Sorting.Any()) { (var selector, var ascending) = options.Sorting.First(); var orderQueryable = ascending ? queryable.OrderBy(selector) : queryable.OrderByDescending(selector); foreach (var(selectorThen, ascendingThen) in options.Sorting.Skip(1)) { orderQueryable = ascendingThen ? orderQueryable.ThenBy(selectorThen) : orderQueryable.ThenByDescending(selectorThen); } queryable = orderQueryable; } int page = options.Page ?? DefaultPage; int pageSize = options.PageSize ?? DefaultPageSize; int toSkip = (page - 1) * pageSize; List <TDocument> listResult = await queryable.Skip(toSkip).Take(pageSize + 1).ToListAsync(); var hasNext = listResult.Count >= (pageSize + 1); if (hasNext) { listResult.RemoveAt(listResult.Count - 1); } return(new QueryResult <TDocument>(hasNext, listResult)); }
public TRepositoryType OrderByDescending <TKey>(Expression <Func <TType, TKey> > expression) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } _query = _query.OrderByDescending(expression); return(GetSelf()); }
public async Task <IReadOnlyList <LogModule.Domain.Entities.Log> > GetPagedReponseAsync(int pageNumber, int pageSize, LogLevels logLevel = LogLevels.ALL, string sorOrder = "desc") { IMongoQueryable <LogModule.Domain.Entities.Log> query = _logs.AsQueryable(); switch (logLevel) { case LogLevels.ALL: break; case LogLevels.Information: query = query.Where(x => x.Level == "Information"); break; case LogLevels.Error: query = query.Where(x => x.Level == "Error"); break; case LogLevels.Warning: query = query.Where(x => x.Level == "Warning"); break; case LogLevels.Debug: query = query.Where(x => x.Level == "Debug"); break; case LogLevels.Fatal: query = query.Where(x => x.Level == "Fatal"); break; case LogLevels.Critical: query = query.Where(x => x.Level == "Critical"); break; case LogLevels.Trace: query = query.Where(x => x.Level == "Trace"); break; case LogLevels.Verbose: query = query.Where(x => x.Level == "Verbose"); break; default: break; } switch (sorOrder) { default: query = query.OrderByDescending(x => x.Id); //.ThenByDescending(t => t.Timestamp); break; } return(await query .Skip((pageNumber - 1) *pageSize) .Take(pageSize) .ToListAsync()); }
public async Task <IEnumerable <T> > FindAsync <TKey>(Expression <Func <T, bool> > filter, Expression <Func <T, TKey> > orderBy, bool desc = false, int?top = null) { IMongoQueryable <T> query = entities.AsQueryable().Where(filter); query = desc ? query.OrderByDescending(orderBy) : query.OrderBy(orderBy); if (top != null) { query = query.Take(top ?? 0); } return(await query.ToListAsync()); }
public void _03_BooksWithMaxMinCount() { var bookMax = queryable.OrderByDescending(b => b.count).First(); Assert.IsTrue(bookMax.count == 11); var bookMin = queryable.OrderBy(b => b.count).First(); Assert.IsTrue(bookMin.count == 1); Console.WriteLine(bookMax.name + "\t" + bookMax.count + "\n\n" + bookMin.name + "\t" + bookMin.count); }
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection, string orderBy, string sortOrder, int page = 1, int resultsPerPage = 10) { if (page <= 0) { page = 1; } if (resultsPerPage <= 0) { resultsPerPage = 10; } var isEmpty = await collection.AnyAsync() == false; if (isEmpty) { return(PagedResult <T> .Empty); } var totalResults = await collection.CountAsync(); var totalPages = (int)Math.Ceiling((decimal)totalResults / resultsPerPage); List <T> data; if (string.IsNullOrWhiteSpace(orderBy)) { data = await collection.Limit(page, resultsPerPage).ToListAsync(); return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults)); } if (sortOrder?.ToLowerInvariant() == "asc") { data = await collection.OrderBy(ToLambda <T>(orderBy)).Limit(page, resultsPerPage).ToListAsync(); } else { data = await collection.OrderByDescending(ToLambda <T>(orderBy)).Limit(page, resultsPerPage) .ToListAsync(); } return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults)); }
public static async Task <PagedResult <T> > Paginate <T>(this IMongoQueryable <T> collection, string orderBy, string sortOrderDirection = DefaultSort, int page = DefaultPage, int resultsPerPage = DefaultPageSize, CancellationToken cancellationToken = default) { if (page <= 0) { page = 1; } if (resultsPerPage <= 0) { resultsPerPage = 10; } var isEmpty = await collection.AnyAsync(cancellationToken) == false; if (isEmpty) { return(PagedResult <T> .Empty); } var totalResults = await collection.CountAsync(cancellationToken); var totalPages = (int)Math.Ceiling((decimal)totalResults / resultsPerPage); List <T> data; if (string.IsNullOrWhiteSpace(orderBy)) { data = await collection.Limit(page, resultsPerPage).ToListAsync(cancellationToken); return(PagedResult <T> .From(data, page, resultsPerPage, totalPages, totalResults)); } var sortOrder = SortOrder.From(sortOrderDirection); if (sortOrder == SortOrder.Ascending) { data = await collection.OrderBy(ToLambda <T>(orderBy)).Limit(page, resultsPerPage).ToListAsync(cancellationToken); } else { data = await collection.OrderByDescending(ToLambda <T>(orderBy)).Limit(page, resultsPerPage).ToListAsync(cancellationToken); } return(PagedResult <T> .From(data, page, resultsPerPage, totalPages, totalResults)); }
/// <summary> /// 日志分页查询 /// </summary> /// <param name="pageIndex">页码</param> /// <param name="pageSize">分页大小</param> /// <param name="func">lambda表达式</param> /// <param name="totalCount">总数</param> /// <returns>查询结果</returns> public List <T> GetPageList <T>(int pageIndex, int pageSize, Expression <Func <T, bool> > func, out int totalCount) where T : Model.BaseInfo { IMongoCollection <T> mongoCollection = this.GetCollection <T>(); IMongoQueryable <T> mongoQueryable = mongoCollection.AsQueryable(); if (func != null) { mongoQueryable = mongoQueryable.Where(func); //.AsQueryable(); } totalCount = mongoQueryable.Count(); return(mongoQueryable .OrderByDescending(m => m.Time) .Skip((pageIndex) * pageSize).Take(pageSize) .ToList()); }
public async Task <IEnumerable <Notification> > GetNotificationAsync(Username username, bool?isSeen, int skip, int take, CancellationToken cancellationToken) { IMongoQueryable <Notification>?queryable = DbSet.AsQueryable(); queryable = queryable.Where(x => x.Username.Value == username.Value); if (isSeen.HasValue) { queryable = queryable.Where(x => x.IsSeen == isSeen.Value); } queryable = queryable.OrderByDescending(x => x.CreatedOn); List <Notification> notificationList = await queryable.Skip(skip).Take(take).ToListAsync(cancellationToken); if (!notificationList.Any()) { throw new NotFoundException <Notification>(); } return(notificationList); }
private static IOrderedMongoQueryable <TSource> OrderData <TSource>(this IMongoQueryable <TSource> data, string filterPropertyName, SortOrder sortOrder) { var filterProperty = typeof(TSource).GetProperty(filterPropertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase); if (filterProperty is null) { throw new MissingMemberException(); } var filterExpression = BuildFilterExpression <TSource, object>(filterProperty); switch (sortOrder) { case SortOrder.desc: return(data.OrderByDescending(filterExpression)); case SortOrder.asc: default: return(data.OrderBy(filterExpression)); } }
private IMongoQueryable <User> SetFilters(Contract request, IMongoQueryable <User> queryable) { queryable = queryable.Where(u => u.Id != request.UserId && !u.IsBlocked ); if (request.UserRole != "Admin") { queryable = queryable.Where(u => u.AllowRecommendation.HasValue && u.AllowRecommendation.Value && u.SecretaryAllowRecommendation.HasValue && u.SecretaryAllowRecommendation.Value ); } if (request.MandatoryFields) { queryable = queryable.Where(u => !string.IsNullOrEmpty(u.ImageUrl) && !string.IsNullOrEmpty(u.Name) && u.DateBorn != null && u.Address != null && !string.IsNullOrEmpty(u.Address.Street) && !string.IsNullOrEmpty(u.Address.District) && !string.IsNullOrEmpty(u.Address.City) && !string.IsNullOrEmpty(u.Address.State) && !string.IsNullOrEmpty(u.Phone) && !string.IsNullOrEmpty(u.Email) ); } if (request.Filters == null) { return(queryable); } if (!String.IsNullOrEmpty(request.Filters.Term)) { queryable = queryable.Where(user => user.Name.ToLower() .Contains(request.Filters.Term.ToLower()) || user.Email.ToLower() .Contains(request.Filters.Term.ToLower()) ); } if (!string.IsNullOrEmpty(request.Filters.SortBy)) { if (request.Filters.SortBy == "name") { if (request.Filters.IsSortAscending.Value) { queryable = queryable.OrderBy(user => user.Name); } else { queryable = queryable.OrderByDescending(user => user.Name); } } } return(queryable); }
public override IMongoQueryable <LogDocument> Sort(IMongoQueryable <LogDocument> logs) => logs.OrderByDescending(l => l.Date);
private IMongoQueryable <User> SetFilters(Contract request, IMongoQueryable <User> queryable) { queryable = queryable.Where(u => u.Id != request.UserId ); if (request.UserRole == "Student") { queryable = queryable.Where(u => u.ResponsibleId == request.UserId); } if (request.Filters == null) { return(queryable); } if (!String.IsNullOrEmpty(request.Filters.Term)) { queryable = queryable.Where(user => user.Name.ToLower() .Contains(request.Filters.Term.ToLower()) || user.Email.ToLower() .Contains(request.Filters.Term.ToLower()) ); } if (request.Filters.CreatedSince.HasValue) { queryable = queryable.Where(user => user.CreatedAt >= request.Filters.CreatedSince.Value.Date ); } if (request.UserRole == "Student" && !String.IsNullOrEmpty(request.Filters.Dependent)) { queryable = queryable.Where(user => user.LineManager.ToLower() .Contains(request.Filters.Dependent.ToLower()) ); } if (request.Filters.CategoryFilter != null && request.Filters.CategoryFilter.Count > 0) { foreach (UserCategoryFilter userCategoryFilter in request.Filters.CategoryFilter) { foreach (string contentName in userCategoryFilter.ContentNames) { queryable = FilterByCategory( queryable, userCategoryFilter.ColumnName, contentName ); } } } if (!string.IsNullOrEmpty(request.Filters.SortBy)) { if (request.Filters.SortBy == "name") { if (request.Filters.IsSortAscending.Value) { queryable = queryable.OrderBy(user => user.Name); } else { queryable = queryable.OrderByDescending(user => user.Name); } } } return(queryable); }
private async Task <PageResponse <T> > FilterAndSortQuery <T>(IMongoQueryable <T> query, PageInfo info, string senderId) where T : ISupportFiltering { if (!string.IsNullOrWhiteSpace(info.Order) && !string.IsNullOrWhiteSpace(info.OrderBy)) { if (typeof(T).GetProperty(info.Order, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance) != null) { query = info.OrderBy == "ASCENDING" ? query.OrderBy(GetPropertySelector <T>(info.Order)) : query.OrderByDescending(GetPropertySelector <T>(info.Order)); } } var responses = await query.ToListAsync(); if (info.CreatedBySender.HasValue && info.CreatedBySender.Value) { responses = responses.Where(response => response.CheckCreator(senderId)).ToList(); } if (info.DateLabels != null) { responses = responses.Where(response => response.CheckDateStatus(info.DateLabels.Select(l => l.ToLower()).ToList())).ToList(); } if (!string.IsNullOrWhiteSpace(info.Filter)) { var filters = new Regex(@"\s").Split(info.Filter.ToLower()); var groupfilters = new List <string>(); var textsfilter = new List <string>(); var groupNames = (await _groupRepository.GetAllAsync()).Select(group => group.Name).ToList(); bool groupflag; bool textflag; var filteredResponses = new List <T>(); foreach (var filter in filters) { if (groupNames.Contains(filter)) { groupfilters.Add(filter); } else { textsfilter.Add(filter); } } foreach (var response in responses) { groupflag = true; textflag = true; if (groupfilters.Count != 0) { groupflag = response.CheckGroupFilters(groupfilters); } if (textsfilter.Count != 0) { foreach (var filter in textsfilter) { textflag = response.CheckTextFilter(filter); if (!textflag) { break; } } } if (groupflag && textflag) { filteredResponses.Add(response); } } responses = filteredResponses; } return(new PageResponse <T> { CurrentPage = info.CurrentPage, ItemsPerPage = info.ItemsPerPage, TotalItems = responses.Count, TotalPages = (int)Math.Ceiling((double)responses.Count / info.ItemsPerPage), Items = responses.Skip((info.CurrentPage - 1) * info.ItemsPerPage).Take(info.ItemsPerPage) }); }
public static IMongoQueryable <T> Apply <T>(this IMongoQueryable <T> queryable, IOrderBy <T>?specification) { if (specification == null) { return(queryable); } var orderByExpression = specification.OrderByExpression; return(specification.SortDirection == SortDirection.Ascending ? queryable.OrderBy(orderByExpression) : queryable.OrderByDescending(orderByExpression)); }