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 IOrderedMongoQueryable <Device> SortSource(IMongoQueryable <Device> source) { IOrderedMongoQueryable <Device> orderedSource = source.OrderBy(e => e.Id); string property = string.Empty; bool alreadyOrdered = false; bool asc = true; foreach (var item in Sort) { property = stringToPropertyName.FirstOrDefault(e => e.Key == item || e.Key == item.Substring(1)).Value.Trim(); asc = !item.StartsWith("-"); if (alreadyOrdered) { orderedSource = asc ? OrderThenAsc(orderedSource, property) : OrderThenDesc(orderedSource, property); } else { orderedSource = asc ? OrderAsc(orderedSource, property) : OrderDesc(orderedSource, property); alreadyOrdered = true; } } return(orderedSource); }
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)); }
/// <summary> /// List documents /// </summary> /// <typeparam name="Tkey">Parameter type</typeparam> /// <param name="orderBy">Parameter orderBy</param> /// <param name="filter">`Parameter filter</param> /// <returns>List documents</returns> public IList <T> List <Tkey>(Expression <Func <T, Tkey> > orderBy, Expression <Func <T, bool> > filter = null) { IMongoQueryable <T> query = Collection.AsQueryable(); return((filter != null) ? query.Where(filter).OrderBy(orderBy).ToList() : query.OrderBy(orderBy).ToList()); }
/// <summary> /// List documents /// </summary> /// <typeparam name="Tkey">Parameter type</typeparam> /// <param name="orderBy">Parameter orderBy</param> /// <param name="filter">`Parameter filter</param> /// <returns>List documents</returns> public async Task <IList <T> > ListAsync <Tkey>(Expression <Func <T, Tkey> > orderBy, Expression <Func <T, bool> > filter = null) { IMongoQueryable <T> query = Collection.AsQueryable(); return((filter != null) ? await query.Where(filter).OrderBy(orderBy).ToListAsync() : await query.OrderBy(orderBy).ToListAsync()); }
public static IMongoQueryable <T> ApplyOrdering <T>(this IMongoQueryable <T> query, string propertyName, bool descending) { if (!Regex.IsMatch(propertyName ?? string.Empty, "^[a-zA-Z]+(.[a-zA-Z]+)?$")) { return(query); } return((IMongoQueryable <T>)query.OrderBy($"{propertyName} {(descending ? "DESC" : "ASC")}")); }
public TRepositoryType OrderBy <TKey>(Expression <Func <TType, TKey> > expression) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } _query = _query.OrderBy(expression); return(GetSelf()); }
public IEnumerable <TEntity> GetAll(params ISorting[] sortingColumns) { IMongoQueryable <TEntity> query = GetSet(); if (sortingColumns != null && sortingColumns.Length > 0) { query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortingColumns); } return(query.ToList()); }
public async Task <IList <TEntity> > ListAsync <Tkey>(Expression <Func <TEntity, Tkey> > orderBy, Expression <Func <TEntity, bool> > filter = null) { IMongoQueryable <TEntity> query = _collection.AsQueryable(); if (filter != null) { return(await query.Where(filter).OrderBy(orderBy).ToListAsync()); } return(await query.OrderBy(orderBy).ToListAsync()); }
public IEnumerable <TEntity> AllMatching(ISpecification <TEntity> specification, params ISorting[] sortingColumns) { IMongoQueryable <TEntity> query = GetSet().Where(specification.SatisfiedBy()); if (sortingColumns != null && sortingColumns.Length > 0) { query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortingColumns); } return(query); }
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 static IMongoQueryable <Book> SearchQuery(this IMongoQueryable <Book> collection, string query) { if (string.IsNullOrWhiteSpace(query)) { return(collection.OrderBy(x => x.Title)); } return(collection.Where(x => x.Title.ToLowerInvariant() .Contains(query.ToLowerInvariant()))); }
public TEntity GetFirst(Expression <Func <TEntity, bool> > filter, params ISorting[] sortColumns) { IMongoQueryable <TEntity> query = filter == null?GetSet() : GetSet().Where(filter); if (sortColumns != null && sortColumns.Length > 0) { query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortColumns); } return(query.FirstOrDefault()); }
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)); }
public QueryResult <QueryContractCall> ContractCall(string address, string filterAddress, int?offset, int limit) { IMongoQueryable <CirrusContractTable> totalQuary = mongoDb.CirrusContractTable.AsQueryable() .Where(q => q.ToAddress == address); if (filterAddress != null) { totalQuary = totalQuary.Where(q => q.FromAddress == filterAddress); } int total = totalQuary.Count(); IMongoQueryable <CirrusContractTable> cirrusContract = mongoDb.CirrusContractTable.AsQueryable() .Where(q => q.ToAddress == address); if (filterAddress != null) { cirrusContract = cirrusContract.Where(q => q.FromAddress == filterAddress); } int itemsToSkip = offset ?? (total < limit ? 0 : total - limit); cirrusContract = cirrusContract .OrderBy(b => b.BlockIndex) .Skip(itemsToSkip) .Take(limit); var res = cirrusContract.ToList(); IEnumerable <QueryContractCall> transactions = res.Select(item => new QueryContractCall { Success = item.Success, MethodName = item.MethodName, ToAddress = item.NewContractAddress, GasUsed = item.GasUsed, GasPrice = item.GasPrice, Amount = item.Amount, ContractBalance = item.ContractBalance, FromAddress = item.FromAddress, Error = item.Error, BlockIndex = item.BlockIndex, TransactionId = item.TransactionId }); return(new QueryResult <QueryContractCall> { Items = transactions, Offset = itemsToSkip, Limit = limit, Total = total }); }
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 IEnumerable <TEntity> GetFiltered(Expression <Func <TEntity, bool> > filter, params ISorting[] sortColumns) { if (filter == null) { throw new ArgumentException("Filter expression cannot be null", nameof(filter)); } IMongoQueryable <TEntity> query = GetSet().Where(filter); if (sortColumns != null && sortColumns.Length > 0) { query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortColumns); } return(query); }
public Task <TEntity> GetFirstAsync(Expression <Func <TEntity, bool> > filter, params ISorting[] sortingColumns) { IMongoQueryable <TEntity> query = GetSet(); if (filter != null) { query = query.Where(filter); } if (sortingColumns != null && sortingColumns.Length > 0) { query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortingColumns); } return(query.FirstOrDefaultAsync()); }
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)); }
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 IEnumerable <TEntity> GetPaged(Expression <Func <TEntity, bool> > filter, int pageIndex, int pageCount, params ISorting[] sortColumns) { IMongoQueryable <TEntity> query = GetSet(); if (filter != null) { query = query.Where(filter); } if (sortColumns != null && sortColumns.Length > 0) { query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortColumns); } if (pageCount > 0) { int skip = (pageIndex - 1) * pageCount; return(query.Skip(skip).Take(pageCount)); } return(query); }
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)); } }
public override IOrderedMongoQueryable <Termo> OrdernarPadrao(IMongoQueryable <Termo> query) { return(query.OrderBy(c => c.Nome)); }
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); }
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 IOrderedMongoQueryable <Telemetry> SortSource(IMongoQueryable <Telemetry> source) { return(source.OrderBy(e => e.OccuredAt)); }
public override IMongoQueryable <LogDocument> Sort(IMongoQueryable <LogDocument> logs) => logs.OrderBy(l => l.Date);