/// <summary> /// Get an IQueryable of parents matching a supplied IQueryable of children for this relationship. /// </summary> /// <typeparam name="TParent">The type of the parent IEntity</typeparam> /// <param name="children">An IQueryable of children</param> /// <param name="options">An optional AggregateOptions object</param> public IMongoQueryable <TParent> ParentsQueryable <TParent>(IMongoQueryable <TChild> children, AggregateOptions options = null) where TParent : IEntity { if (typeof(TParent) == typeof(TChild)) { throw new InvalidOperationException("Both parent and child types cannot be the same"); } if (isInverse) { return(children .Join( JoinQueryable(options), c => c.ID, j => j.ParentID, (_, j) => j) .Join( DB.Collection <TParent>(db), j => j.ChildID, p => p.ID, (_, p) => p) .Distinct()); } else { return(children .Join( JoinQueryable(options), c => c.ID, j => j.ChildID, (_, j) => j) .Join( DB.Collection <TParent>(db), j => j.ParentID, p => p.ID, (_, p) => p) .Distinct()); } }
public static PaginatedItems <T> Paginate <T>(this IMongoQueryable <T> source, int rowsPerPage = 0, int pageNumber = 1) { if (rowsPerPage == 0) { return(new PaginatedItems <T> { PageCount = 1, TotalItemsCount = source.Count(), Items = source }); } var skip = Math.Max(0, pageNumber - 1) * rowsPerPage; var totalCount = source.Count(); var pageCount = (int)Math.Ceiling((double)totalCount / rowsPerPage); return(new PaginatedItems <T> { PageCount = pageCount, TotalItemsCount = totalCount, Items = source.Skip(skip).Take(rowsPerPage) }); }
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection, int page = 1, int resultsPerPage = 10) { if (page <= 10) { 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); var data = await collection.Limit(page, resultsPerPage).ToListAsync(); return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults)); }
public static async Task <PagedResult <T> > PaginateAsync <T, TKey>(this IMongoQueryable <T> collection, int resultsPerPage = 10) where T : IIdentifiable <TKey> { if (resultsPerPage <= 0) { resultsPerPage = 10; } var result = await collection .Take(resultsPerPage + 1) .ToListAsync(); var hasNextData = result.Count > resultsPerPage; if (result.Count > 1 && hasNextData) { result.RemoveAt(result.Count - 1); } var last = result.LastOrDefault(); return(PagedResult <T> .Create(result, result.Count, last?.Id.ToString(), hasNextData)); }
public MJoin(IMongoQueryable <T1> source1, IMongoQueryable <T2> source2, string source1OnField, string source2OnField, QueryDocument filter, List <KeyValuePair <string, string> > source1Projection, List <KeyValuePair <string, string> > source2Projection) { // PropertyDescriptor fld1 = TypeDescriptor.GetProperties(typeof(T1)).Find(source1OnField, true); //PropertyDescriptor fld2 = TypeDescriptor.GetProperties(typeof(T2)).Find(source2OnField, true); //var fld1 = typeof(T1).GetProperty(source1OnField); //var fld2 = typeof(T2).GetProperty(source2OnField); PropertyDescriptor fld1 = TypeDescriptor.GetProperties(typeof(Student)).Find("ClassId", true); DynamicProperty dfld1 = new DynamicProperty("ClassId", fld1.PropertyType); PropertyDescriptor fld2 = TypeDescriptor.GetProperties(typeof(ClassRoom)).Find("Id", true); DynamicProperty dfld2 = new DynamicProperty("Id", fld2.PropertyType); var zz = from s1Item in source1 join s2Item in source2 on dfld1 equals dfld2 into grp select s1Item; var cc = zz.Count(); BlockProvider = zz; }
public async Task <StaticPagedList <T> > PaginationAsync <TKey>(int pageIndex, int pageSize, Expression <Func <T, TKey> > orderBy, bool isOrderByAsc = true, Expression <Func <T, bool> > where = null) { long num; long num1 = (long)0; IMongoQueryable <T> mongoQueryable = IMongoCollectionExtensions.AsQueryable <T>(this.Collection); num = (where != null ? await this.CountAsync(where) : await this.CountAsync()); num1 = num; if (where != null) { mongoQueryable = MongoQueryable.Where <T>(mongoQueryable, where); } if (isOrderByAsc) { mongoQueryable = MongoQueryable.Take <T>(MongoQueryable.Skip <T>(MongoQueryable.OrderBy <T, TKey>(mongoQueryable, orderBy), (pageIndex - 1) * pageSize), pageSize); } else { mongoQueryable = MongoQueryable.Take <T>(MongoQueryable.Skip <T>(MongoQueryable.OrderByDescending <T, TKey>(mongoQueryable, orderBy), (pageIndex - 1) * pageSize), pageSize); } StaticPagedList <T> staticPagedList = new StaticPagedList <T>(mongoQueryable.ToList <T>(), pageIndex, pageSize, (int)num1); return(staticPagedList); }
public override void GetResult(IMongoQueryable <Order> collection) { var timer = Stopwatch.StartNew(); var query = collection.GroupBy(x => x.Service.Name) .Select(x => new { Service = x.Key, OrderCount = x.Count() } ) .OrderByDescending(x => x.OrderCount) .ToList(); timer.Stop(); foreach (var item in query) { Console.WriteLine($"Service: {item.Service} OrderCount: {item.OrderCount}"); } Console.WriteLine($"Execute time: {timer.ElapsedMilliseconds}"); Thread.Sleep(5000); }
///<inheritdoc cref="MongoPaginationService.Paginate{T}(IMongoQueryable{T}, int, int, Func{IMongoQueryable{T}, int})"/> public static IPaginationResult <IMongoQueryable <T> > Paginate <T>(this IMongoQueryable <T> query, int page, int pageSize, Func <IMongoQueryable <T>, int> countFunction) { var entriesCount = countFunction(query); return(CreateResult(page, pageSize, query, entriesCount)); }
public MongoCollectionWrapper(IMongoCollection <TKey> collection, IMongoQueryable <TKey> queryable) { Collection = collection ?? throw new ArgumentNullException(nameof(collection)); Queryable = queryable ?? throw new ArgumentNullException(nameof(queryable)); }
public static IAsyncQueryable <T> AsAsync <T>(this IMongoQueryable <T> queryable) { return(new MongoAsyncQueryable <T>(queryable)); }
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); }
protected virtual IMongoQueryable <DocumentWithoutContent> ApplyFilterForGetAll( IMongoQueryable <Document> query, Guid?projectId, string name, string version, string languageCode, string fileName, string format, DateTime?creationTimeMin, DateTime?creationTimeMax, DateTime?lastUpdatedTimeMin, DateTime?lastUpdatedTimeMax, DateTime?lastSignificantUpdateTimeMin, DateTime?lastSignificantUpdateTimeMax, DateTime?lastCachedTimeMin, DateTime?lastCachedTimeMax, CancellationToken cancellationToken = default) { if (projectId.HasValue) { query = query.Where(d => d.ProjectId == projectId.Value); } if (name != null) { query = query.Where(d => d.Name != null && d.Name.Contains(name)); } if (version != null) { query = query.Where(d => d.Version != null && d.Version == version); } if (languageCode != null) { query = query.Where(d => d.LanguageCode != null && d.LanguageCode == languageCode); } if (fileName != null) { query = query.Where(d => d.FileName != null && d.FileName.Contains(fileName)); } if (creationTimeMin.HasValue) { query = query.Where(d => d.CreationTime.Date >= creationTimeMin.Value.Date); } if (creationTimeMax.HasValue) { query = query.Where(d => d.CreationTime.Date <= creationTimeMax.Value.Date); } if (lastUpdatedTimeMin.HasValue) { query = query.Where(d => d.LastUpdatedTime.Date >= lastUpdatedTimeMin.Value.Date); } if (lastUpdatedTimeMax.HasValue) { query = query.Where(d => d.LastUpdatedTime.Date <= lastUpdatedTimeMax.Value.Date); } if (lastSignificantUpdateTimeMin.HasValue) { query = query.Where(d => d.LastSignificantUpdateTime != null && d.LastSignificantUpdateTime.Value.Date >= lastSignificantUpdateTimeMin.Value.Date); } if (lastSignificantUpdateTimeMax.HasValue) { query = query.Where(d => d.LastSignificantUpdateTime != null && d.LastSignificantUpdateTime.Value.Date <= lastSignificantUpdateTimeMax.Value.Date); } if (lastCachedTimeMin.HasValue) { query = query.Where(d => d.LastCachedTime.Date >= lastCachedTimeMin.Value.Date); } if (lastCachedTimeMax.HasValue) { query = query.Where(d => d.LastCachedTime.Date <= lastCachedTimeMax.Value.Date); } return(query.Select(x => new DocumentWithoutContent { Id = x.Id, ProjectId = x.ProjectId, Name = x.Name, Version = x.Version, LanguageCode = x.LanguageCode, FileName = x.FileName, Format = x.Format, CreationTime = x.CreationTime, LastUpdatedTime = x.LastUpdatedTime, LastSignificantUpdateTime = x.LastSignificantUpdateTime, LastCachedTime = x.LastCachedTime })); }
private static IPaginationResult <IMongoQueryable <T> > CreateResult <T>(int page, int pageSize, IMongoQueryable <T> query, int entriesCount) { return(new PaginationResult <IMongoQueryable <T> >(page, pageSize, query.Skip((page - 1) * pageSize).Take(pageSize), entriesCount)); }
public static IOrderedMongoQueryable <T> Sort <T>(this IMongoQueryable <T> source, IMongoSorter <T> sorter) { return(sorter.SortSource(source)); }
public static IMongoQueryable <TResult> Filter <TSource, TResult>(this IMongoQueryable <TSource> source, IMongoFilter <TSource, TResult> filter) { return(filter.FilterSource(source)); }
public MongoFrameworkQueryProvider(IMongoDbConnection connection, IMongoQueryable <TOutput> underlyingQueryable) { Connection = connection; UnderlyingQueryable = underlyingQueryable; }
public MongoFrameworkQueryProvider(IMongoQueryable <TOutput> underlyingQueryable) { UnderlyingQueryable = underlyingQueryable; }
///<inheritdoc cref="MongoPaginationService.PaginateAsync{T}(IMongoQueryable{T}, int, int)" /> public static async Task <IPaginationResult <IMongoQueryable <T> > > PaginateAsync <T>(this IMongoQueryable <T> query, int page, int pageSize) { var entriesCount = await query.CountAsync(); return(CreateResult(page, pageSize, query, entriesCount)); }
public static async Task <IPaginationResult <IMongoQueryable <T> > > PaginateAsync <T>(this IMongoQueryable <T> query, int page, int pageSize, Func <IMongoQueryable <T>, Task <int> > asyncCountFunction) { var entriesCount = await asyncCountFunction(query); return(CreateResult(page, pageSize, query, entriesCount)); }
public static IMongoQueryable <T> Limit <T>(this IMongoQueryable <T> collection, PagedQueryBase query) => collection.Limit(query.Page, query.Results);
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection, PagedQueryBase query) => await collection.PaginateAsync(query.Page, query.Results);
public static async Task <PagedResults <TEntity> > PaginateAsync <TEntity, TQuery>(this IMongoQueryable <TEntity> collection, TQuery query) where TQuery : IPagedQuery => await collection.PaginateAsync <TEntity, TQuery>(query.Page, query.ResultsPerPage, query.OrderBy, query.SortOrder);
public Set(IMongoDatabase database) { this.collection = database.GetCollection <TEntity>(typeof(TEntity).Name); this.internalQueryable = collection.AsQueryable(); }
private static async Task <PagedResults <TEntity> > PaginateAsync <TEntity, TQuery>(this IMongoQueryable <TEntity> collection, int page, int resultsPerPage, string orderbyKey, SortOrder sortOrder) { page = page <= 0 ? 1 : page; resultsPerPage = resultsPerPage <= 0 ? 10 : resultsPerPage; var isEmpty = await collection.AnyAsync() == false; if (isEmpty) { return(PagedResults <TEntity> .Empty); } var totalResults = await collection.CountAsync(); var totalPages = (int)(totalResults / resultsPerPage) + 1; var skip = (page - 1) * resultsPerPage; var data = await collection.OrderData(orderbyKey, sortOrder).Skip(skip).Take(resultsPerPage).ToListAsync(); return(PagedResults <TEntity> .Create(data, page, resultsPerPage, totalPages, totalResults)); }
public static IMongoQueryable <T> ActiveRegisters <T>(this IMongoQueryable <T> queryable) where T : Entity { return(queryable.Where(new ActiveRegisters <T>())); }
internal static IQueryable <T> ToQueryable <T>(this IMongoQueryable <T> source) { return(source); }
private static IMongoQueryable <UserModel> ApplyFilters(GetAllUsersQuery filters, IMongoQueryable <UserModel> query) { if (!string.IsNullOrWhiteSpace(filters.Gender)) { query = query.Where(u => u.Gender == filters.Gender); } if (!string.IsNullOrWhiteSpace(filters.RoleName)) { query = query.Where(u => u.RoleName == filters.RoleName); } if (!string.IsNullOrWhiteSpace(filters.Username)) { query = query.Where(u => u.Username == filters.Username); } return(query); }
public static IMongoQueryable <T> BaseFilter <T>(this IMongoQueryable <T> queryable) where T : BaseMongoCollection { queryable = queryable.Where(x => x.IsDeleted == null || x.IsDeleted == false); return(queryable); }
public static IAsyncQueryable AsAsync(this IMongoQueryable queryable) { return(new MongoAsyncQueryable(queryable)); }
public IList <StoredEvent> ObterEventos(string aggregateId) { IMongoQueryable <StoredEvent> query = _collection.AsQueryable(); return(query.Where(x => x.AggregatedId == aggregateId).OrderBy(x => x.DataOcorrencia).ToList()); }