public void PagingOptions_Apply_Return_Requested_Page_With_Multiple_Sort() { var contacts = new List<Contact>(); for (int i = 1; i <= 5; i++) { contacts.Add(new Contact { Name = "Test User " + (i % 2), ContactTypeId = i}); } const int resultingPage = 2; const int pageSize = 2; var qo = new PagingOptions<Contact>(resultingPage, pageSize, "Name", isDescending: true); qo.ThenSortBy("ContactTypeId", isDescending: true); IQueryable<Contact> queryable = qo.Apply(contacts.AsQueryable()); queryable.Count().ShouldEqual(2); var contact = queryable.First(); contact.Name.ShouldEqual("Test User 1"); contact.ContactTypeId.ShouldEqual(1); var qo2 = new PagingOptions<Contact, string>(resultingPage, pageSize, x => x.Name, isDescending: true); qo2.ThenSortBy(x => x.ContactTypeId, isDescending: true); queryable = qo2.Apply(contacts.AsQueryable()); queryable.Count().ShouldEqual(2); contact = queryable.First(); contact.Name.ShouldEqual("Test User 1"); contact.ContactTypeId.ShouldEqual(1); }
public override SqlQuery PageQuery(SqlQuery sqlQuery, PagingOptions pagingOptions) { if (sqlQuery == null) { throw new ArgumentNullException("sqlQuery"); } var arguments = new SqlArgument[sqlQuery.Arguments.Count + 2]; Array.Copy(sqlQuery.ArgumentsArray, 0, arguments, 0, sqlQuery.Arguments.Count); arguments[arguments.Length - 2] = new SqlArgument(pagingOptions.Offset, DbType.Int32); arguments[arguments.Length - 1] = new SqlArgument(pagingOptions.Count, DbType.Int32); var sqlString = SqlString.Parse(sqlQuery.CommandText, Clauses.OrderBy); var commandText = string.IsNullOrEmpty(sqlString.OrderBy) ? sqlQuery.CommandText + " ORDER BY GETDATE()" : sqlQuery.CommandText; var stringBuilder = new StringBuilder(commandText) .Replace(Environment.NewLine, string.Empty) .Append(" OFFSET ") .Append(this.SqlCharacters.GetParameterName(arguments.Length - 2)) .Append(" ROWS FETCH NEXT ") .Append(this.SqlCharacters.GetParameterName(arguments.Length - 1)) .Append(" ROWS ONLY"); return new SqlQuery(stringBuilder.ToString(), arguments); }
public override SqlQuery PageQuery(SqlQuery sqlQuery, PagingOptions pagingOptions) { if (sqlQuery == null) { throw new ArgumentNullException("sqlQuery"); } var sqlString = SqlString.Parse(sqlQuery.CommandText, Clauses.OrderBy); if (string.IsNullOrEmpty(sqlString.OrderBy)) { throw new MicroLiteException(ExceptionMessages.SqlServerCeDialect_PagedRequiresOrderBy); } var arguments = new object[sqlQuery.Arguments.Count + 2]; Array.Copy(sqlQuery.ArgumentsArray, 0, arguments, 0, sqlQuery.Arguments.Count); arguments[arguments.Length - 2] = pagingOptions.Offset; arguments[arguments.Length - 1] = pagingOptions.Count; var stringBuilder = new StringBuilder(sqlQuery.CommandText) .Replace(Environment.NewLine, string.Empty) .Append(" OFFSET ") .Append(this.SqlCharacters.GetParameterName(arguments.Length - 2)) .Append(" ROWS FETCH NEXT ") .Append(this.SqlCharacters.GetParameterName(arguments.Length - 1)) .Append(" ROWS ONLY"); return new SqlQuery(stringBuilder.ToString(), arguments); }
public override SqlQuery PageQuery(SqlQuery sqlQuery, PagingOptions pagingOptions) { if (sqlQuery == null) { throw new ArgumentNullException("sqlQuery"); } var arguments = new object[sqlQuery.Arguments.Count + 2]; Array.Copy(sqlQuery.ArgumentsArray, 0, arguments, 0, sqlQuery.Arguments.Count); arguments[arguments.Length - 2] = pagingOptions.Offset + 1; arguments[arguments.Length - 1] = pagingOptions.Offset + pagingOptions.Count; var sqlString = SqlString.Parse(sqlQuery.CommandText, Clauses.Select | Clauses.From | Clauses.Where | Clauses.OrderBy); var qualifiedTableName = sqlString.From; var position = qualifiedTableName.LastIndexOf('.') + 1; var tableName = position > 0 ? qualifiedTableName.Substring(position, qualifiedTableName.Length - position) : qualifiedTableName; var whereClause = !string.IsNullOrEmpty(sqlString.Where) ? " WHERE " + sqlString.Where : string.Empty; var orderByClause = !string.IsNullOrEmpty(sqlString.OrderBy) ? sqlString.OrderBy : "(SELECT NULL)"; var stringBuilder = new StringBuilder(sqlQuery.CommandText.Length * 2) .Append("SELECT ") .Append(sqlString.Select) .Append(" FROM") .AppendFormat(CultureInfo.InvariantCulture, " (SELECT {0},ROW_NUMBER() OVER(ORDER BY {1}) AS RowNumber FROM {2}{3}) AS {4}", sqlString.Select, orderByClause, qualifiedTableName, whereClause, tableName) .AppendFormat(CultureInfo.InvariantCulture, " WHERE (RowNumber >= {0} AND RowNumber <= {1})", this.SqlCharacters.GetParameterName(arguments.Length - 2), this.SqlCharacters.GetParameterName(arguments.Length - 1)); return new SqlQuery(stringBuilder.ToString(), arguments); }
/// <summary> /// 获取数据列表 /// </summary> /// <param name="paging">分页参数</param> /// <returns>返回数据列表</returns> public WebApiPagingResult<IQueryable<Basic_Logs>> List(PagingOptions paging) { var result = new WebApiPagingResult<IQueryable<Basic_Logs>> { Data = from item in DataContext.Basic_Logs orderby item.LogTime descending select item }; return result.AsPaging(paging); }
public void GetAll_Should_Return_Every_Items_With_Paging(ICompoundKeyRepository<User, string, int> repository) { const int resultingPage = 2; const int pageSize = 2; const int totalItems = 5; var queryOptions = new PagingOptions<User>(resultingPage, pageSize, "Username"); for (var i = 1; i <= totalItems; i++) { repository.Add(new User { Username = "******" + i, Age = i }); } var result = repository.GetAll(queryOptions).ToList(); result.Count().ShouldEqual(pageSize); queryOptions.TotalItems.ShouldEqual(totalItems); result.First().Username.ShouldEqual("Test User 3"); }
public void PagingOptions_Apply_Will_Set_TotalItems() { var contacts = new List<Contact>(); for (int i = 1; i <= 5; i++) { contacts.Add(new Contact { Name = "Test User " + i }); } const int resultingPage = 2; const int pageSize = 2; var qo = new PagingOptions<Contact>(resultingPage, pageSize, "Name", isDescending: true); qo.Apply(contacts.AsQueryable()); qo.TotalItems.ShouldEqual(5); var qo2 = new PagingOptions<Contact, string>(resultingPage, pageSize, x => x.Name, isDescending: true); qo2.Apply(contacts.AsQueryable()); qo2.TotalItems.ShouldEqual(5); }
public void GetAll_Should_Return_Every_Items_With_Paging(IRepository<Contact, string> repository) { const int resultingPage = 2; const int pageSize = 2; const int totalItems = 5; var queryOptions = new PagingOptions<Contact>(resultingPage, pageSize, "Name"); for (int i = 1; i <= totalItems; i++) { var contact = new Contact { Name = "Test User " + i }; repository.Add(contact); } IEnumerable<Contact> result = repository.GetAll(queryOptions).ToList(); result.Count().ShouldEqual(pageSize); queryOptions.TotalItems.ShouldEqual(totalItems); result.First().Name.ShouldEqual("Test User 3"); }
public override SqlQuery PageQuery(SqlQuery sqlQuery, PagingOptions pagingOptions) { if (sqlQuery == null) { throw new ArgumentNullException("sqlQuery"); } var arguments = new SqlArgument[sqlQuery.Arguments.Count + 2]; Array.Copy(sqlQuery.ArgumentsArray, 0, arguments, 0, sqlQuery.Arguments.Count); arguments[arguments.Length - 2] = new SqlArgument(pagingOptions.Offset, DbType.Int32); arguments[arguments.Length - 1] = new SqlArgument(pagingOptions.Count, DbType.Int32); var stringBuilder = new StringBuilder(sqlQuery.CommandText) .Replace(Environment.NewLine, string.Empty) .Append(" LIMIT ") .Append(this.SqlCharacters.GetParameterName(arguments.Length - 2)) .Append(',') .Append(this.SqlCharacters.GetParameterName(arguments.Length - 1)); return new SqlQuery(stringBuilder.ToString(), arguments); }
public void PagingOptions_Apply_Return_Requested_Page() { var contacts = new List<Contact>(); for (int i = 1; i <= 5; i++) { contacts.Add(new Contact { Name = "Test User " + i }); } const int resultingPage = 2; const int pageSize = 2; var qo = new PagingOptions<Contact>(resultingPage, pageSize, "Name", isDescending: true); IQueryable<Contact> queryable = qo.Apply(contacts.AsQueryable()); queryable.Count().ShouldEqual(2); queryable.First().Name.ShouldEqual("Test User 3"); var qo2 = new PagingOptions<Contact, string>(resultingPage, pageSize, x => x.Name, isDescending: true); queryable = qo2.Apply(contacts.AsQueryable()); queryable.Count().ShouldEqual(2); queryable.First().Name.ShouldEqual("Test User 3"); }
public void FindAll_Should_Return_All_Items_Which_Satisfy_Composite_Specification_With_Paging(ICompoundKeyRepository<User, string, int> repository) { const int resultingPage = 2; const int pageSize = 2; var queryOptions = new PagingOptions<User>(resultingPage, pageSize, "Username"); for (var i = 1; i <= 10; i++) { var contact = new User { Username = "******" + i, Age = i }; repository.Add(contact); } IEnumerable<User> result = repository .FindAll(new Specification<User>(p => p.Username == "Test User 1") .OrElse(new Specification<User>(p => p.Username == "Test User 5") .OrElse(new Specification<User>(p => p.Username == "Test User 8"))), queryOptions); result.Count().ShouldEqual(1); queryOptions.TotalItems.ShouldEqual(3); result.First().Username.ShouldEqual("Test User 8"); }
public void FindAll_Should_Return_All_Items_Which_Satisfy_Composite_Specification_With_Paging_And_Sort_Descending(IRepository<Contact, string> repository) { const int resultingPage = 2; const int pageSize = 2; var queryOptions = new PagingOptions<Contact>(resultingPage, pageSize, "Name", true); for (int i = 1; i <= 10; i++) { var contact = new Contact { Name = "Test User " + i }; repository.Add(contact); } IEnumerable<Contact> result = repository .FindAll(new Specification<Contact>(p => p.Name == "Test User 1") .OrElse(new Specification<Contact>(p => p.Name == "Test User 5") .OrElse(new Specification<Contact>(p => p.Name == "Test User 8"))), queryOptions); result.Count().ShouldEqual(1); queryOptions.TotalItems.ShouldEqual(3); result.First().Name.ShouldEqual("Test User 1"); }
public void Repository_Handles_Pagination() { var repo = new InMemoryRepository<Order, int>(); repo.Add(OrdersToLoad()); // with PagingOptions you give it the pageNumber, number per page, and the sorting options // since the sorting options are the same as described above, I will just do the Expression based approach here var pagingOptions = new PagingOptions<Order, DateTime>(1, 2, x => x.OrderDate, isDescending: true); var pageOneOrders = repo.GetAll(pagingOptions).ToList(); pageOneOrders.Count.ShouldEqual(2); pageOneOrders.First().OrderId.ShouldEqual(1); pagingOptions.TotalItems.ShouldEqual(3); // now we can get the second page of results pagingOptions.PageNumber = 2; var pageTwoOrders = repo.GetAll(pagingOptions).ToList(); pageTwoOrders.Count.ShouldEqual(1); pageTwoOrders.First().OrderId.ShouldEqual(2); pagingOptions.TotalItems.ShouldEqual(3); }
public override SqlQuery PageQuery(SqlQuery sqlQuery, PagingOptions pagingOptions) { if (sqlQuery == null) { throw new ArgumentNullException("sqlQuery"); } var arguments = new SqlArgument[sqlQuery.Arguments.Count + 2]; Array.Copy(sqlQuery.ArgumentsArray, 0, arguments, 0, sqlQuery.Arguments.Count); arguments[arguments.Length - 2] = new SqlArgument(pagingOptions.Offset + 1, DbType.Int32); arguments[arguments.Length - 1] = new SqlArgument(pagingOptions.Offset + pagingOptions.Count, DbType.Int32); var sqlString = SqlString.Parse(sqlQuery.CommandText, Clauses.Select | Clauses.From | Clauses.Where | Clauses.OrderBy); var whereClause = !string.IsNullOrEmpty(sqlString.Where) ? " WHERE " + sqlString.Where : string.Empty; var orderByClause = !string.IsNullOrEmpty(sqlString.OrderBy) ? sqlString.OrderBy : "(SELECT NULL)"; var stringBuilder = new StringBuilder(sqlQuery.CommandText.Length * 2) .AppendFormat(CultureInfo.InvariantCulture, "SELECT * FROM (SELECT {0},ROW_NUMBER() OVER(ORDER BY {1}) AS RowNumber FROM {2}{3}) AS [MicroLitePagedResults]", sqlString.Select, orderByClause, sqlString.From, whereClause) .AppendFormat(CultureInfo.InvariantCulture, " WHERE (RowNumber >= {0} AND RowNumber <= {1})", this.SqlCharacters.GetParameterName(arguments.Length - 2), this.SqlCharacters.GetParameterName(arguments.Length - 1)); return new SqlQuery(stringBuilder.ToString(), arguments); }
public void ExecuteFindAll_With_Paging_Should_Save_TotalItems_In_Cache() { var repos = new InMemoryRepository<Contact>(new StandardCachingStrategy<Contact>()); repos.Add(new Contact { ContactId = 1, Name = "Test1" }); repos.Add(new Contact { ContactId = 2, Name = "Test2" }); repos.Add(new Contact { ContactId = 3, Name = "Test3" }); repos.Add(new Contact { ContactId = 4, Name = "Test4" }); var pagingOptions = new PagingOptions<Contact>(1, 1, "Name"); var items = repos.FindAll(x => x.ContactId >= 2, x => x.Name, pagingOptions); repos.CacheUsed.ShouldBeFalse(); items.Count().ShouldEqual(1); pagingOptions.TotalItems.ShouldEqual(3); // reset paging options so the TotalItems is default pagingOptions = new PagingOptions<Contact>(1, 1, "Name"); items = repos.FindAll(x => x.ContactId >= 2, x => x.Name, pagingOptions); repos.CacheUsed.ShouldBeTrue(); items.Count().ShouldEqual(1); pagingOptions.TotalItems.ShouldEqual(3); }
/// <summary> /// 获取数据列表 /// </summary> /// <param name="paging">分页参数</param> /// <returns>返回数据列表</returns> public virtual WebApiPagingResult<IQueryable<Product_ProductDefinition>> List(PagingOptions paging) { var result = new WebApiPagingResult<IQueryable<Product_ProductDefinition>> { Data = from item in DataContext.Product_ProductDefinition orderby item.SortOrder where item.Deleted == false select item }; return result.AsPaging(paging); }
public ToDoItemController(IToDoItemService service, IOptions <PagingOptions> defaultPagingOptions) { _toDoItemService = service; _defaultPagingOptions = defaultPagingOptions.Value; }
public async Task <IEnumerable <T> > GetAllAsync(PagingOptions pagingOptions, CancellationToken ct, Expression <Func <T, bool> > filter = null, Func <IQueryable <T>, IOrderedQueryable <T> > orderBy = null, string includeProperties = null) { throw new NotImplementedException(); }
public static async Task <Page <T> > GetPage <T>(this IQueryable <T> items, PagingOptions options) where T : class { return(await Pager .GetPageAsync(items, options)); }
public static async Task <Page <TResult> > GetPage <TSource, TResult>(this IQueryable <TSource> items, PagingOptions options, Expression <Func <TSource, TResult> > selector) where TSource : class where TResult : class { return(await Pager.GetPageAsync(items, options, selector)); }
public void FindAll_Should_Return_All_Items_Which_Satisfy_Specification_With_Paging_MagicString(IRepository<Contact, string> repository) { const int resultingPage = 2; const int pageSize = 2; const int totalItems = 10; var queryOptions = new PagingOptions<Contact>(resultingPage, pageSize, "Name"); for (int i = 1; i <= totalItems; i++) { var contact = new Contact { Name = "Test User " + i, ContactTypeId = i }; repository.Add(contact); } // this fails for RavenDb because the ContactId is an int but is being used as the key, so the check on ContactId <= 5 is doing a string comparison and including ContactId = 10 as well // need to look into why this happens and how to get around it var result = repository.FindAll(new Specification<Contact>(p => p.ContactTypeId <= totalItems / 2), queryOptions); result.Count().ShouldEqual(pageSize); queryOptions.TotalItems.ShouldEqual(totalItems / 2); result.First().Name.ShouldEqual("Test User 3"); }
public static IObjectFieldDescriptor UsePaging <TSchemaType, TEntity>( this IObjectFieldDescriptor descriptor, GetCursorPagingProvider?resolvePagingProvider = null, PagingOptions options = default) where TSchemaType : class, IOutputType => UsePaging <TSchemaType>(descriptor, typeof(TEntity), resolvePagingProvider, options);
public async Task <PagedResults <Request> > GetUserRequestsAsync( Guid?userId, PagingOptions pagingOptions, SortOptions <Request, RequestEntity> sortOptions, SearchOptions <Request, RequestEntity> searchOptions, CancellationToken ct) { if (userId == null) { return(null); } IQueryable <RequestEntity> query = from r in _context.Request join ur in _context.User_Request on r.Id equals ur.RequestFK where ur.UserFK == userId select r; var accounts = from ra in _context.Request_Account join a in _context.Account on ra.AccountFK equals a.Id select new { RequestFK = ra.RequestFK, AccountName = a.AccountName }; var brands = from rb in _context.Request_Brand join b in _context.Brand on rb.BrandFK equals b.Id select new { RequestFK = rb.RequestFK, BrandName = b.BrandName }; query = searchOptions.Apply(query); query = sortOptions.Apply(query); var allRequests = await query .ProjectTo <Request>() .ToListAsync(); foreach (var request in allRequests) { foreach (var account in accounts) { if (request.Id == account.RequestFK) { request.AccountName = account.AccountName; } } foreach (var brand in brands) { if (request.Id == brand.RequestFK) { request.BrandName = brand.BrandName; } } } var pagedRequests = allRequests .Skip(pagingOptions.Offset.Value) .Take(pagingOptions.Limit.Value); return(new PagedResults <Request> { Items = pagedRequests, TotalSize = allRequests.Count }); }
public async Task <PagedResults <Request> > GetRequestsAsync( PagingOptions pagingOptions, SortOptions <Request, RequestEntity> sortOptions, SearchOptions <Request, RequestEntity> searchOptions, CancellationToken ct) { IQueryable <RequestEntity> query = _context.Request; query = searchOptions.Apply(query); query = sortOptions.Apply(query); // TODO: rewrite queries and foreach to be more efficient. var accounts = from ra in _context.Request_Account join a in _context.Account on ra.AccountFK equals a.Id select new { RequestFK = ra.RequestFK, AccountName = a.AccountName }; var associates = from ur in _context.User_Request join u in _context.Users on ur.UserFK equals u.Id select new { RequestFK = ur.RequestFK, FirstName = u.FirstName, LastName = u.LastName }; var brands = from rb in _context.Request_Brand join b in _context.Brand on rb.BrandFK equals b.Id select new { RequestFK = rb.RequestFK, BrandName = b.BrandName }; var allRequests = await query .ProjectTo <Request>() .ToListAsync(); foreach (var request in allRequests) { foreach (var account in accounts) { if (request.Id == account.RequestFK) { request.AccountName = account.AccountName; } } foreach (var associate in associates) { if (request.Id == associate.RequestFK) { request.AssociateName = associate.FirstName + " " + associate.LastName; } } foreach (var brand in brands) { if (request.Id == brand.RequestFK) { request.BrandName = brand.BrandName; } } } var pagedRequests = allRequests .Skip(pagingOptions.Offset.Value) .Take(pagingOptions.Limit.Value); return(new PagedResults <Request> { Items = pagedRequests, TotalSize = allRequests.Count }); }
private static PreProcessedCursorPagingHandler <TEntity> CreateHandlerInternal <TEntity>( PagingOptions options) => new PreProcessedCursorPagingHandler <TEntity>(options);
/// <summary> /// 获取数据列表 /// </summary> /// <param name="paging">分页参数</param> /// <returns>返回数据列表</returns> public virtual WebApiPagingResult<IQueryable<Basic_CompanyInfo>> List(PagingOptions paging) { var result = new WebApiPagingResult<IQueryable<Basic_CompanyInfo>> { Data = from item in DataContext.Basic_CompanyInfo orderby item.SortOrder where item.Deleted == false select item }; return result.AsPaging(paging); }
public async Task <Page <Customer> > GetAllAsync(PagingOptions pagingOptions, bool getVehicles = true, SearchVehicleStatus vehicleStatus = SearchVehicleStatus.Any) { return(await GetAsyncByName(string.Empty, pagingOptions, getVehicles, vehicleStatus)); }
public async Task <ActionResult <PaginatedCollectionViewModel <ContractsToCostInvoiceDto> > > GetCostsForSelectedContracts(string company, [FromQuery] string sectionIds, [FromQuery] PagingOptions pagingOptions) { var result = await _invoiceQueries.GetCostsForSelectedContractsAsync(company, sectionIds.Split(',').Select(int.Parse).ToArray()); var response = new PaginatedCollectionViewModel <ContractsToCostInvoiceDto>(pagingOptions.Offset.Value, pagingOptions.Limit.Value, result.ToList(), null); return(Ok(response)); }
public async Task <ActionResult <PaginatedCollectionViewModel <ContractsToWashoutInvoiceDto> > > GetWashoutContracts(string company, [FromQuery] PagingOptions pagingOptions) { var result = await _invoiceQueries.GetWashoutContractsToInvoiceAsync(company, pagingOptions.Offset.Value, pagingOptions.Limit.Value); var response = new PaginatedCollectionViewModel <ContractsToWashoutInvoiceDto>(pagingOptions.Offset.Value, pagingOptions.Limit.Value, result.ToList(), null); return(Ok(response)); }
public WhenCallingForPageForTheSecondPage() { pagingOptions = PagingOptions.ForPage(this.page, this.resultsPerPage); }
public async Task <IActionResult> GetRequestsAsync( [FromQuery] PagingOptions pagingOptions, [FromQuery] SortOptions <Request, RequestEntity> sortOptions, [FromQuery] SearchOptions <Request, RequestEntity> searchOptions, CancellationToken ct) { if (!ModelState.IsValid) { return(BadRequest(new ApiError(ModelState))); } pagingOptions.Offset = pagingOptions.Offset ?? _defaultPagingOptions.Offset; pagingOptions.Limit = pagingOptions.Limit ?? _defaultPagingOptions.Limit; // var collectionLink = Link.ToCollection(nameof(GetRequestsAsync)); // Logic if user is Sales then only return theirs, else return all for Admin and Sign Shop if (User.Identity.IsAuthenticated) { var canSeeAll = await _authzService.AuthorizeAsync( User, "ViewAllRequestsPolicy"); if (canSeeAll.Succeeded) // User is Administrator or Sign Shop { var requests = await _requestService.GetRequestsAsync( pagingOptions, sortOptions, searchOptions, ct); var collection = PagedCollection <Request> .Create <RequestResponse>( Link.ToCollection(nameof(GetRequestsAsync)), requests.Items.ToArray(), requests.TotalSize, pagingOptions); collection.RequestsQuery = FormMetadata.FromResource <Request>( Link.ToForm( nameof(GetRequestsAsync), null, Link.GetMethod, Form.QueryRelation)); return(Ok(collection)); } else // User is Sales (Could technically be any other authenticated user) { // Build collection only with requests for the User var currentUserId = await _userService.GetUserIdAsync(User); var requests = await _requestService.GetUserRequestsAsync( currentUserId, pagingOptions, sortOptions, searchOptions, ct); var collection = PagedCollection <Request> .Create <RequestResponse>( Link.ToCollection(nameof(GetRequestsAsync)), requests.Items.ToArray(), requests.TotalSize, pagingOptions); collection.RequestsQuery = FormMetadata.FromResource <Request>( Link.ToForm( nameof(GetRequestsAsync), null, Link.GetMethod, Form.QueryRelation)); return(Ok(collection)); } } // User is not authenticated. return(NotFound()); }
public WhenCallingSkipTake() { pagingOptions = PagingOptions.SkipTake(this.skip, this.take); }
public QueryableCursorPagingHandler(PagingOptions options) : base(options) { }
public async Task <ActionResult <PaginatedCollectionViewModel <InvoiceMarkingDto> > > GetInvoiceMarkingsForCost(string company, long costId, [FromQuery] PagingOptions pagingOptions, [FromQuery] long?dataVersionId) { IEnumerable <InvoiceMarkingDto> invoiceMarkingsCost; invoiceMarkingsCost = await _invoiceQueries.GetInvoiceMarkingsForCost(company, costId, dataVersionId); var response = new PaginatedCollectionViewModel <InvoiceMarkingDto>(pagingOptions.Offset.Value, pagingOptions.Limit.Value, invoiceMarkingsCost.ToList(), null); return(Ok(response)); }
public Task <FindResults <T> > SearchAsync(IRepositoryQuery systemFilter, string filter = null, string criteria = null, string sort = null, string aggregations = null, PagingOptions paging = null) { var search = NewQuery() .WithSystemFilter(systemFilter) .WithFilter(filter) .WithSearchQuery(criteria, false) .WithAggregations(aggregations) .WithSort(sort) .WithPaging(paging); return(FindAsync(search)); }
public static IInterfaceFieldDescriptor UsePaging <TSchemaType>( this IInterfaceFieldDescriptor descriptor, PagingOptions options = default) where TSchemaType : class, IOutputType => UsePaging(descriptor, typeof(TSchemaType), options);
public async Task <PagedResults <EndpointEntity> > GetEndpointsByOwnerIdAsync(Guid ownerId, PagingOptions pagingOptions, SortOptions <EndpointViewModel, EndpointEntity> sortOptions, SearchOptions <EndpointViewModel, EndpointEntity> searchOptions, CancellationToken ct) { IQueryable <EndpointEntity> query = _context.Endpoints .Where(r => r.Owner.IdentityId == ownerId) .Include(r => r.Owner) .Include(r => r.Client); query = searchOptions.Apply(query); query = sortOptions.Apply(query); var size = await query.CountAsync(ct); var items = await query .Skip(pagingOptions.Offset.Value) .Take(pagingOptions.Limit.Value) .ToArrayAsync(ct); return(new PagedResults <EndpointEntity> { Items = items, TotalSize = size }); }
public static Page <T> GetPage <T>(this IEnumerable <T> items, PagingOptions options) where T : class { return(items .GetPage(options, i => i)); }
public FeedbackController(IFeedbackBusiness feedback, IUserBusiness user, IOptions <PagingOptions> defaultPagingOptionsWrapper) { _feedback = feedback; _user = user; _defaultPagingOptions = defaultPagingOptionsWrapper.Value; }
public static Page <TResult> GetPage <TSource, TResult>(this IEnumerable <TSource> items, PagingOptions options, Expression <Func <TSource, TResult> > selector) where TSource : class where TResult : class { return(Pager .GetPage(items, options, selector)); }
public SearchRequest(int fileReferenceId, int searchId, PagingOptions pagingOptions) { FileReferenceId = fileReferenceId; SearchId = searchId; PagingOptions = pagingOptions; }
public async Task <PagedResults <FishData> > GetFishAsync( PagingOptions pagingOptions, SortOptions <FishData, FishEntity> sortOptions, SearchOptions <FishData, FishEntity> searchOptions) { IQueryable <FishEntity> query = _context.Fish.Include(x => x.SpeciesIllustrationPhoto); query = searchOptions.Apply(query); query = sortOptions.Apply(query); int size = await query.CountAsync(); FishEntity[] items = await query .Skip(pagingOptions.Offset.Value) .Take(pagingOptions.Limit.Value) .ToArrayAsync(); return(new PagedResults <FishData> { Items = items.Select(x => new FishData() { Id = x.Id, FisheryManagement = x.FisheryManagement, Habitat = x.Habitat, HabitatImpacts = x.HabitatImpacts, Location = x.Location, Population = x.Population, PopulationStatus = x.PopulationStatus, ScientificName = x.ScientificName, SpeciesAliases = x.SpeciesAliases, SpeciesIllustrationPhoto = new SpeciesIllustrationPhoto() { Src = (x.SpeciesIllustrationPhoto == null) ? string.Empty : (x.SpeciesIllustrationPhoto.Src ?? string.Empty), Alt = (x.SpeciesIllustrationPhoto == null) ? string.Empty : (x.SpeciesIllustrationPhoto.Alt ?? string.Empty), Title = (x.SpeciesIllustrationPhoto == null) ? string.Empty : (x.SpeciesIllustrationPhoto.Title ?? string.Empty) }, ImageGallery = FillGallery(x.ImageGallery), SpeciesName = x.SpeciesName, Availability = x.Availability, Biology = x.Biology, Bycatch = x.Bycatch, Calories = x.Calories, Cholesterol = x.Cholesterol, Color = x.Color, FatTotal = x.FatTotal, FishingRate = x.FishingRate, Harvest = x.Harvest, HealthBenefits = x.HealthBenefits, PhysicalDescription = x.PhysicalDescription, Protein = x.Protein, Quote = x.Quote, QuoteBackgroundColor = x.QuoteBackgroundColor, SaturatedFattyAcidsTotal = x.SaturatedFattyAcidsTotal, Selenium = x.Selenium, Servings = x.Servings, Sodium = x.Sodium, Source = x.Source, Taste = x.Taste, Texture = x.Texture, Path = x.Path, LastUpdate = x.LastUpdate }), TotalSize = size }); }
public async Task <IEnumerable <TEntity> > AllAsync(int pageIndex, int pageSize) { var pagingOptions = PagingOptions.Create(pageIndex, pageSize); return(await AllAsync(pagingOptions)); }
private static MongoDbOffsetPagingHandler <TEntity> CreateHandlerInternal <TEntity>( PagingOptions options) => new(options);
public void FindAll_Should_Return_All_Items_Which_Satisfy_Specification_With_Paging(ICompoundKeyRepository<User, string, int> repository) { const int resultingPage = 2; const int pageSize = 2; const int totalItems = 10; var queryOptions = new PagingOptions<User, string>(resultingPage, pageSize, m => m.Username); for (var i = 1; i <= totalItems; i++) { var contact = new User { Username = "******" + i, Age = i }; repository.Add(contact); } var result = repository.FindAll(new Specification<User>(p => p.Age <= totalItems / 2), queryOptions); result.Count().ShouldEqual(pageSize); queryOptions.TotalItems.ShouldEqual(totalItems / 2); result.First().Username.ShouldEqual("Test User 3"); }
/// <summary> /// 获取数据列表 /// </summary> /// <param name="paging">分页参数</param> /// <returns>返回数据列表</returns> public WebApiPagingResult<IQueryable<Basic_Announcement>> List(PagingOptions paging) { var result = new WebApiPagingResult<IQueryable<Basic_Announcement>> { Data = from item in DataContext.Basic_Announcement where item.Deleted == false orderby item.CreatedAt descending select item }; return result.AsPaging(paging); }
/// <summary> /// Creates an SqlQuery to page the records which would be returned by the specified SqlQuery based upon the paging options. /// </summary> /// <param name="sqlQuery">The SQL query.</param> /// <param name="pagingOptions">The paging options.</param> /// <returns> /// A <see cref="SqlQuery" /> to return the paged results of the specified query. /// </returns> public abstract SqlQuery PageQuery(SqlQuery sqlQuery, PagingOptions pagingOptions);
public WhenCallingGetHashCode() { this.pagingOptions = PagingOptions.SkipTake(this.offset, this.count); }
public async Task <IEnumerable <TEntity> > FindAsync(Expression <Func <TEntity, bool> > predicate, PagingOptions pagingOptions) { return(await DbContext.Set <TEntity>() .Where(predicate) .Page(pagingOptions) .ToListAsync()); }
public static PagedCollection <T> Create(Link self, T[] items, int size, PagingOptions pagingOptions) => Create <PagedCollection <T> >(self, items, size, pagingOptions);
public async Task <IEnumerable <TEntity> > AllAsync(PagingOptions pagingOptions) { return(await DbContext.Set <TEntity>() .Page(pagingOptions) .ToListAsync()); }
/// <summary> /// 获取数据列表 /// </summary> /// <param name="paging">分页参数</param> /// <param name="ParentId">子节点查询条件</param> /// <returns>返回数据列表</returns> public virtual WebApiPagingResult<IQueryable<Basic_DataDictionary>> SubList(PagingOptions paging, Guid? ParentId) { var result = new WebApiPagingResult<IQueryable<Basic_DataDictionary>> { Data = from item in DataContext.Basic_DataDictionary orderby item.SortOrder where item.Deleted == false && item.ParentId == ParentId select item }; return result.AsPaging(paging); }
public async Task <PagedCollection <PadSeriesReadModel> > ReadAll(PagingOptions paging) { using (var conn = OpenConnection()) { // Pull in the parent records first var series = await conn.QueryAsync <PadSeriesRow, BrandRow, PadSeriesReadModel>( @" select * from pad_series ps join brands b on ps.brand_id = b.id order by b.name limit @Limit offset @Offset; ", (ps, b) => new PadSeriesReadModel( ps.Id, ps.Name, new BrandReadModel( b.Id, b.Name ), ps.PolisherTypes.ToList() ), new { Limit = paging.PageSize, Offset = paging.Offset } ); var seriesLookup = new Dictionary <Guid, PadSeriesReadModel>(series.Select(p => new KeyValuePair <Guid, PadSeriesReadModel>(p.Id, p))); // Now get the rest using (var reader = await conn.QueryMultipleAsync( @" select count(*) from pad_series; select * from pad_sizes where pad_series_id = any(@Series); select pi.* from pad_images pi join pads p on pi.pad_id = p.id where pad_series_id = any(@Series); select p.* from pads p where pad_series_id = any(@Series) group by p.id order by name; select po.* from pad_options po left join pads p on po.pad_id = p.id; select po.id as pad_option_id, pn.* from part_numbers pn join pad_option_part_numbers popn on pn.id = popn.part_number_id join pad_options po on po.id = popn.pad_option_id; " , new { Series = series.Select(s => s.Id).ToArray() // We only want series that we got back. })) { var totalCount = reader.ReadFirst <int>(); var sizes = reader.Read <PadSizeRow>(); foreach (var size in sizes) { PadSeriesReadModel?s; if (seriesLookup.TryGetValue(size.PadSeriesId, out s)) { s.Sizes.Add(new PadSizeReadModel( size.Id, new MeasurementReadModel(size.DiameterAmount, size.DiameterUnit), size.ThicknessAmount != null ? new MeasurementReadModel(size.ThicknessAmount ?? 0, size.ThicknessUnit !) : null ) ); } } var images = reader.Read <(Guid PadId, Guid ImageId)>(); var pads = new Dictionary <Guid, PadReadModel>(); var rawPads = reader.Read(); foreach (var raw in rawPads) { Guid?imageId = images.Where(i => i.PadId == raw.id).FirstOrDefault().ImageId; if (imageId == Guid.Empty) { imageId = null; } var pad = new PadReadModel( raw.id, raw.name, ((PadCategoryBitwise)raw.category).ToList(), raw.material, raw.texture, raw.color, raw.has_center_hole, imageId, new List <PadOptionReadModel>() ); pads.Add(pad.Id, pad); PadSeriesReadModel?s; if (seriesLookup.TryGetValue(raw.pad_series_id, out s)) { s !.Pads.Add(pad); } } var options = reader.Read <PadOptionRow>(); var optionDict = new Dictionary <Guid, PadOptionReadModel>(); foreach (var opt in options) { PadReadModel?pad; if (pads.TryGetValue(opt.PadId, out pad)) { var po = new PadOptionReadModel(opt.Id, opt.PadSizeId); pad.Options.Add(po); optionDict.Add(opt.Id, po); } } var partNumbers = reader.Read <Guid, PartNumberRow, (Guid PadOptionId, PartNumberRow PartNumber)>((id, pn) => (id, pn)); foreach (var partNumber in partNumbers) { PadOptionReadModel?option; if (optionDict.TryGetValue(partNumber.PadOptionId, out option)) { option.PartNumbers.Add(new PartNumberReadModel(partNumber.PartNumber.Id, partNumber.PartNumber.Value, partNumber.PartNumber.Notes)); } } return(new PagedCollection <PadSeriesReadModel>(new Paging(paging, totalCount), seriesLookup.Values)); } } }
public async Task <IEnumerable <TEntity> > FindAsync(Expression <Func <TEntity, bool> > predicate, int pageIndex, int pageSize) { var pagingOptions = PagingOptions.Create(pageIndex, pageSize); return(await FindAsync(predicate, pagingOptions)); }