public void PagedQuery_Execute() { var pagedQuery = new PagedQuery<int, UberProductSpec, Product, ProductDto>( LinqProvider(), new StaticAutoMapperWrapper()).AsPaged(); var sw = new Stopwatch(); sw.Start(); var res = pagedQuery.Ask(new UberProductSpec() {Price = 3500}); sw.Stop(); Assert.Equal(100500, res.First().Price); Assert.Equal(1, res.TotalCount); Assert.True(sw.ElapsedMilliseconds < 150, $"Elapsed Miliseconds: {sw.ElapsedMilliseconds}"); }
public void PagedQuery_Execute() { var pagedQuery = new PagedQuery <int, UberProductSpec, Product, ProductDto>( LinqProvider(), new StaticAutoMapperWrapper()).AsPaged(); var sw = new Stopwatch(); sw.Start(); var res = pagedQuery.Ask(new UberProductSpec() { Price = 3500 }); sw.Stop(); Assert.Equal(100500, res.First().Price); Assert.Equal(1, res.TotalCount); Assert.True(sw.ElapsedMilliseconds < 150, $"Elapsed Miliseconds: {sw.ElapsedMilliseconds}"); }
public async Task <PagedList <TDto> > GetPaginatedList <TDto>(PagedQuery query, Expression <Func <TEntity, TDto> > projection) where TDto : class { Expression <Func <TEntity, bool> > allConditions = (entity) => !entity.IsDeleted; Expression <Func <TEntity, bool> > conditions = (entity) => !entity.IsDeleted && entity.IsEnabled; var filterConditions = Builders <TEntity> .Filter.Where(query.All?allConditions : conditions); var count = (int)await _entities.CountDocumentsAsync(filterConditions); var entities = await _entities .Find(filterConditions) .Project(projection) .Sort(new BsonDocument(query.Sort, query.Order)) .Skip(query.PageSize * (query.Page - 1)) .Limit(query.PageSize) .ToListAsync(); return(entities.ToPagedList(count)); }
public async Task <HttpResponseMessage> GetChildren(int id, [ModelBinder(typeof(PagedQueryModelBinder))] PagedQuery query) { if (!await AuthorizationService.AuthorizeAsync(ClaimsPrincipal, new ContentResourceAccess(id), AuthorizationPolicies.ContentRead)) { return(Request.CreateResponse(HttpStatusCode.Unauthorized)); } var items = Services.ContentService.GetPagedChildren(id, query.Page - 1, query.PageSize, out var total, filter: query.Query); var pages = ContentControllerHelper.GetTotalPages(total, query.PageSize); var mapped = Mapper.Map <IEnumerable <ContentRepresentation> >(items).ToList(); var result = new ContentPagedListRepresentation(mapped, total, pages, query.Page, query.PageSize, LinkTemplates.Content.PagedChildren, new { id = id }); FilterAllowedOutgoingContent(result); return(Request.CreateResponse(HttpStatusCode.OK, result)); }
protected async Task RefreshSubscriptions(CancellationToken cancellationToken) { var query = new PagedQuery() { CurrentPage = 1 }; var posIdentifiers = new HashSet <Guid>(); bool addedAtLeastOne; do { addedAtLeastOne = false; var posPage = await _posService.BrowsePointsOfSale(query); if (posPage.Items is null) { break; } foreach (var pos in posPage.Items) { if (posIdentifiers.Add(pos.Id)) { addedAtLeastOne = true; } } } while (addedAtLeastOne); var subscriptions = posIdentifiers.Select(_posTopicClassifier.GetStatsTopic); _logger.LogInformation($"Updating subscriptions to {posIdentifiers.Count} points of sale"); try { await _client.SubscribeAsync(subscriptions.Select(topic => new TopicFilterBuilder().WithTopic(topic).Build())); } catch (Exception e) { _logger.LogError(e, "Could not update subscriptions"); } }
public PagedResult <Contracts.Company.Company> Get(PagedQuery pagedQuery) { using (var db = new RAAPMasterEntities()) { var totalItems = db.Companies.Count(); return(new PagedResult <Contracts.Company.Company> { CurrentPage = pagedQuery.Page, TotalItems = totalItems, TotalPages = pagedQuery.CalculatePages(totalItems), Items = db.Companies.AsQueryable() .OrderByDirection(LinqHelper.OrderByDataContract <Company>(pagedQuery.OrderByKey), pagedQuery.IsDescending) .Skip(pagedQuery.ItemsToSkip) .Take(pagedQuery.PageSize) .Select(x => x.ToContract()) .ToArray() }); } }
public Contracts.Common.PagedResult <Contracts.Risk.RiskType> GetRiskTypes(PagedQuery pagedQuery) { using (var db = new RAAPEntities(GetConnectionString())) { var totalItems = db.RiskTypes.Count(); return(new PagedResult <Contracts.Risk.RiskType> { CurrentPage = pagedQuery.Page, TotalItems = totalItems, TotalPages = pagedQuery.CalculatePages(totalItems), Items = db.RiskTypes.AsQueryable() .OrderByDirection(LinqHelper.OrderByDataContract <RiskType>(pagedQuery.OrderByKey), pagedQuery.IsDescending) .Skip(pagedQuery.ItemsToSkip) .Take(pagedQuery.PageSize) .Select(x => x.ToContract()) .ToArray() }); } }
public HttpResponseMessage Search( [System.Web.Http.ModelBinding.ModelBinder(typeof(PagedQueryModelBinder))] PagedQuery query) { if (query.Query.IsNullOrWhiteSpace()) { throw new HttpResponseException(HttpStatusCode.NotFound); } //TODO: This would be more efficient if we went straight to the ExamineManager and used it's built in Skip method // but then we have to write our own model mappers and don't have time for that right now. var result = Umbraco.ContentQuery.TypedSearch(SearchProvider.CreateSearchCriteria().RawQuery(query.Query), _searchProvider).ToArray(); var paged = result.Skip(ContentControllerHelper.GetSkipSize(query.Page - 1, query.PageSize)).Take(query.PageSize); var items = AutoMapper.Mapper.Map <IEnumerable <PublishedContentRepresentation> >(paged).ToList(); var representation = new PublishedContentPagedListRepresentation(items, result.Length, 1, query.Page - 1, query.PageSize, LinkTemplates.PublishedContent.Search, new { query = query.Query, pageSize = query.PageSize }); return(Request.CreateResponse(HttpStatusCode.OK, representation)); }
public Paged <Wuyiju.Model.ProductBought> GetBoughtPaged(PagedQuery <Wuyiju.Model.Order.Query> query) { StringBuilder sql = new StringBuilder(@"SELECT o.*,p.name AS pname,p.price as ppricce,p.sales,p.pay_status,p.type FROM ec_order o INNER JOIN ec_product AS p ON o.product_id=p.id where 1 = 1 "); DynamicParameters param = new DynamicParameters(); sql.AndEquals("o.uid", "uid"); sql.AndEquals("o.pay_statu", "pay_status"); //sql.Append(" and ( t.name like '%PC%' ) "); if (query.Filter != null) { param.AddDynamicParams(query.Filter); } IList <OrderRule> order = new List <OrderRule>(); order.Add(new OrderRule { Column = "v.add_time", dir = "desc" }); return(db.GetPaged <Wuyiju.Model.ProductBought>(sql, param, query.PageStart, query.PageSize, query.Draw, order)); }
public void PagedQueryTest() { Setup(); CleanUp(); Setup(); Expect.IsTrue(_testDatabases.Count > 0); string name = MethodBase.GetCurrentMethod().Name; _testDatabases.Each(db => { TestTableCollection testTables = CreateTestTableEntries(name, db); testTables = TestTable.Where(c => c.Name.StartsWith(name), db); Expect.AreEqual(8, testTables.Count, "There should have been 8 records but there were {0}"._Format(testTables.Count)); PagedQuery <TestTableColumns, TestTable> q = new PagedQuery <TestTableColumns, TestTable>(new TestTableColumns().Id, testTables.Query, db); q.LoadMeta(); Expect.IsGreaterThan(q.PageCount, 0, "Page count should have been greater than 0"); OutLineFormat("Page count was {0} for {1}", ConsoleColor.Cyan, q.PageCount, db.GetType().Name); CheckExpectations(q); }); }
public async Task Get_Paginated_Role_List_With_PageSize_Test(int pageSize) { // Arrange var pagedQuery = new PagedQuery { PageSize = pageSize }; _mockRolerService.Setup(s => s.GetPaginatedList(It.IsAny <PagedQuery>())).ReturnsAsync(() => _roles.ToPagedList(_roles.Count)); // Assert var pagedList = await _mockRolerService.Object.GetPaginatedList(pagedQuery); Assert.NotNull(pagedList); Assert.NotNull(pagedList.Items); Assert.True(pagedList.Items.IsNotEmpty()); Assert.True(pagedList.Items.ToList().Count <= pagedQuery.PageSize); Assert.Equal(pagedList.Count, _roles.Count); // Act _mockRolerService.Verify((s) => s.GetPaginatedList(pagedQuery)); }
public PagedResult <Contracts.User.User> Get(PagedQuery pagedQuery, int companyId) { using (var db = new RAAPMasterEntities()) { var query = db.Users.Where(u => u.CompanyId == companyId); var totalItems = query.Count(); return(new PagedResult <Contracts.User.User> { CurrentPage = pagedQuery.Page, TotalItems = totalItems, TotalPages = pagedQuery.CalculatePages(totalItems), Items = query.AsQueryable() .OrderByDirection(LinqHelper.OrderByDataContract <User>(pagedQuery.OrderByKey), pagedQuery.IsDescending) .Skip(pagedQuery.ItemsToSkip) .Take(pagedQuery.PageSize) .Select(x => x.ToContract(false)) .ToArray() }); } }
public async Task GivenMultiplesAssetsHaveBeenCreatedWithASimilarAddress_WhenWeSearch_ThenTheAssetsAreOrderedBySchemeIdDesc() { //arrange using (var trans = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await CreateAssetRegisterVersions(2); //act var query = new PagedQuery { PageSize = 2, Page = 1 }; //act var assets = await _classUnderTest.Search(query, CancellationToken.None).ConfigureAwait(false); //assert Assert.Greater(assets.Results.ElementAt(0).Id, assets.Results.ElementAt(1).Id); trans.Dispose(); } }
public HttpResponseMessage GetChildren(int id, [System.Web.Http.ModelBinding.ModelBinder(typeof(PagedQueryModelBinder))] PagedQuery query) { var content = Umbraco.TypedContent(id); if (content == null) { return(Request.CreateResponse(HttpStatusCode.NotFound)); } PcrFactory.Create(content, Request.RequestUri); var resolved = (string.IsNullOrEmpty(query.Query)) ? content.Children().ToArray() : content.Children(query.Query.Split(',')).ToArray(); var total = resolved.Length; var pages = (total + query.PageSize - 1) / query.PageSize; var items = AutoMapper.Mapper.Map <IEnumerable <PublishedContentRepresentation> >(resolved.Skip(ContentControllerHelper.GetSkipSize(query.Page - 1, query.PageSize)).Take(query.PageSize)).ToList(); var result = new PublishedContentPagedListRepresentation(items, total, pages, query.Page - 1, query.PageSize, LinkTemplates.PublishedContent.PagedChildren, new { id = id }); return(Request.CreateResponse(HttpStatusCode.OK, result)); }
private async Task <PagedResult <T> > GetPagedListAsyncInternal <T>(PagedQuery pagedQuery, Expression <Func <T, bool> > predicate) where T : QueryModel { var options = CreateFeedOptions(pagedQuery.MaxItemCount); if (!string.IsNullOrEmpty(pagedQuery.ContinuationToken)) { options.RequestContinuation = pagedQuery.ContinuationToken; } var query = _client.CreateDocumentQuery <T>(GetCollectionUri(), options) .Where(x => x.Type == typeof(T).Name); if (predicate != null) { query = query.Where(predicate); } var results = await query.AsDocumentQuery().ExecuteNextAsync <T>(); var count = await QueryCountAsyncInternal <T>(); return(new PagedResult <T>(results.ToList().AsReadOnly(), count, results.ResponseContinuation)); }
public Paged <Wuyiju.Model.DepositRecharge> GetPaged(PagedQuery <Wuyiju.Model.DepositRecharge.Query> query) { StringBuilder sql = new StringBuilder(@"select * from ec_deposit_recharge where 1 = 1 "); sql.AndEquals("User_Id").AndEquals("status"); DynamicParameters param = new DynamicParameters(); if (query.Filter != null) { param.AddDynamicParams(query.Filter); } IList <OrderRule> order = new List <OrderRule>(); order.Add(new OrderRule { Column = "add_time", dir = "desc" }); return(db.GetPaged <Wuyiju.Model.DepositRecharge>(sql, param, query.PageStart, query.PageSize, query.Draw, order)); }
private HttpResponseMessage GetChildren(Func <IPublishedContent> getContent, PagedQuery query, int depth) { var content = getContent(); if (content == null) { return(Request.CreateResponse(HttpStatusCode.NotFound)); } PcrFactory.Create(content, Request.RequestUri); var resolved = (string.IsNullOrEmpty(query.Query)) ? content.Children().ToArray() : content.Children(query.Query.Split(',')).ToArray(); var total = resolved.Length; var pages = (total + query.PageSize - 1) / query.PageSize; var items = AutoMapper.Mapper.Map <IEnumerable <PublishedContentRepresentation> >(resolved .Skip(ContentControllerHelper.GetSkipSize(query.Page - 1, query.PageSize)) .Take(query.PageSize), options => options.Items["prop::depth"] = depth).ToList(); var result = new PublishedContentPagedListRepresentation(items, total, pages, query.Page, query.PageSize, LinkTemplates.PublishedContent.PagedChildren, new { id = content.GetKey() }); return(Request.CreateResponse(HttpStatusCode.OK, result)); }
public void PagedQueryFiltering_WhenSpecyfyingMultipleFilteringCriteria_ThenDataAndCountQueriesDontContainWhereClauseWithAllOfThemConnectedByAndOperator() { int?intFilter = 10; var stringFilter = "Value"; var startDate = new DateTime(2000, 10, 20); var endDate = new DateTime(2010, 10, 20); PagedQuery <Data> query = BuildPagedQuery(b => b .Where("Column1", Is.EqualTo(intFilter)) .Search("ColumnX", (int?)null) .Search("Column2", intFilter) .Where("Column3", Is.InRange(startDate, endDate)) .Where("Column4", Is.Like(stringFilter))); ShouldContainWhere(query, "WHERE Column1 = @p1 AND Column2 = @p2 AND Column3 >= @p3 AND Column3 < @p4 AND Column4 LIKE @p5"); ParameterValueShouldBe(query, "p1", intFilter); ParameterValueShouldBe(query, "p2", intFilter); ParameterValueShouldBe(query, "p3", startDate); ParameterValueShouldBe(query, "p4", endDate); ParameterValueShouldBe(query, "p5", '%' + stringFilter + '%'); }
public Paged <Wuyiju.Model.Order> GetOrieridPage(PagedQuery <Wuyiju.Model.Order.Query> query) { StringBuilder sql = new StringBuilder(@" SELECT o.*,p.name AS product_name,p.subname as sub_name,p.url, m.name As buy_name,m.mobile As buy_phone,m.realname As buy_realname,n.name As sell_name,n.mobile As sell_phone,n.realname As sell_realname FROM ec_order o INNER JOIN ec_product AS p ON o.product_id=p.id inner join ec_user As m on o.uid=m.id left join ec_user As n on p.seller_id =n.id inner join ec_admin z on z.id=p.admin_id or z.id=p.guanlian_id where 1 = 1"); DynamicParameters param = new DynamicParameters(); //sql.AndEquals("p.admin_id", "admin_id"); //sql.AndEquals("z.guanlian_id", "guanlian_id"); sql.AndBetween("o.add_time", "StartTime", "EndTime"); sql.AndEquals("o.status", "status"); sql.AndEquals("o.pay_statu", "pay_status"); sql.AndEquals("z.parent_id", "parent_id"); sql.AndEquals("o.del", "del"); if (query.Filter.Guanlian_Id != null) { sql.Append(" and (p.admin_id = @guanlian_id or p.guanlian_id = @guanlian_id) group by o.id"); } else { sql.Append(" group by o.id"); } if (query.Filter != null) { param.AddDynamicParams(query.Filter); } IList <OrderRule> order = new List <OrderRule>(); order.Add(new OrderRule { Column = "v.add_time", dir = "desc" }); return(db.GetPaged <Wuyiju.Model.Order>(sql, param, query.PageStart, query.PageSize, query.Draw, order)); }
public HttpResponseMessage GetQuery( [System.Web.Http.ModelBinding.ModelBinder(typeof(PagedQueryModelBinder))] PagedQuery query, int id, int depth = PublishedContentMapper.DefaultDepth) { var rootQuery = ""; if (id > 0) { //TODO: Change to xpath id() query, see https://github.com/umbraco/Umbraco-CMS/pull/1831 rootQuery = $"//*[@id='{id}']"; } var skip = (query.Page - 1) * query.PageSize; var take = query.PageSize; var result = new IPublishedContent[0]; try { result = Umbraco.TypedContentAtXPath(rootQuery + query.Query).ToArray(); } catch (Exception) { //in case the xpath query fails - do nothing as we will return a empty array instead } var key = Umbraco.TypedContent(id)?.GetKey(); var paged = result.Skip((int)skip).Take(take); var pages = (result.Length + query.PageSize - 1) / query.PageSize; var items = AutoMapper.Mapper.Map <IEnumerable <PublishedContentRepresentation> >(paged, options => options.Items["prop::depth"] = depth).ToList(); var representation = new PublishedContentPagedListRepresentation(items, result.Length, pages, query.Page, query.PageSize, LinkTemplates.PublishedContent.Query, new { id = key, query = query.Query, pageSize = query.PageSize }); return(Request.CreateResponse(HttpStatusCode.OK, representation)); }
public PagedResult <Contracts.AttributeCategory.AttributeCategory> Get(PagedQuery pagedQuery, string attributeTypeId) { using (var db = new RAAPEntities(GetConnectionString())) { var query = db.AttributeCategories.Where(a => a.AttributeTypeId == attributeTypeId); var totalItems = query.Count(); return(new PagedResult <Contracts.AttributeCategory.AttributeCategory>() { CurrentPage = pagedQuery.Page, TotalItems = totalItems, TotalPages = pagedQuery.CalculatePages(totalItems), Items = query .OrderByDirection(LinqHelper.OrderByDataContract <AttributeCategory>(pagedQuery.OrderByKey), pagedQuery.IsDescending) .Skip(pagedQuery.ItemsToSkip) .Take(pagedQuery.PageSize) .Select(x => x.ToContract()) .ToArray() }); } }
public PagedResult <Contracts.Attribute.Attribute> GetChilds(PagedQuery pagedQuery, int parentAttributeId) { using (var db = new RAAPEntities(GetConnectionString())) { var query = db.AttributeLinks.Where(al => al.ParentAttributeId == parentAttributeId).Select(al => al.Attribute); var totalItems = query.Count(); return(new PagedResult <Contracts.Attribute.Attribute>() { CurrentPage = pagedQuery.Page, TotalItems = totalItems, TotalPages = pagedQuery.CalculatePages(totalItems), Items = query .OrderByDirection(LinqHelper.OrderByDataContract <Database.Attribute>(pagedQuery.OrderByKey), pagedQuery.IsDescending) .Skip(pagedQuery.ItemsToSkip) .Take(pagedQuery.PageSize) .Select(x => x.ToContract()) .ToArray() }); } }
/// <inheritdoc /> protected override bool PerformBindModel(IDictionary <string, string> queryStrings, HttpActionContext actionContext, ModelBindingContext bindingContext) { var result = base.PerformBindModel(queryStrings, actionContext, bindingContext); if (!result) { return(false); } var model = (PagedRequest)bindingContext.Model; var queryStructure = new PagedQuery { Page = model.Page, PageSize = model.PageSize }; if (queryStrings.TryGetValue("query", out var qsVal)) { queryStructure.Query = qsVal; } bindingContext.Model = queryStructure; return(true); }
public async Task <IActionResult> Index(PagedQuery input) { var queryResult = await _dbContext.Clients .Include(x => x.AllowedGrantTypes) .Include(x => x.RedirectUris) .Include(x => x.PostLogoutRedirectUris) .Include(x => x.AllowedScopes) .Include(x => x.ClientSecrets) .Include(x => x.Claims) .Include(x => x.IdentityProviderRestrictions) .Include(x => x.AllowedCorsOrigins) .Include(x => x.Properties) .AsNoTracking().Select(x => new ListClientItemViewModel { Id = x.Id, ClientId = x.ClientId, ClientName = x.ClientName, AllowedScopes = string.Join(" ", x.AllowedScopes.Select(s => s.Scope)), AllowedGrantTypes = string.Join(" ", x.AllowedGrantTypes.Select(t => t.GrantType)) }) .ToPagedListAsync(input.GetPage(), input.GetSize()); return(View(queryResult)); }
public void PagedQueryPaging_WhenPagingIsSpecified_ThenDataQueryContainsOffsetClauseAndCountQueryDoesnt() { PagedQuery <Data> query = GetQueryBuilder() .Select("Column1") .From("Table") .SortBy("Column1") .BuildPagedQuery <Data>(new SearchCriteria { PageSize = 20, PageNumber = 1 }); Assert.IsTrue(query.DataQuery.Contains("OFFSET 0 ROWS FETCH NEXT 20 ROWS ONLY")); Assert.IsTrue(!query.CountQuery.Contains("OFFSET")); PagedQuery <Data> query2 = GetQueryBuilder() .Select("Column1") .From("Table") .SortBy("Column1") .BuildPagedQuery <Data>(new SearchCriteria { PageSize = 1, PageNumber = 20 }); query2.DataQuery.ShouldContain("OFFSET 19 ROWS FETCH NEXT 1 ROWS ONLY"); query2.CountQuery.ShouldNotContain("OFFSET"); }
public async Task <PagedQuery <ClientDTO> > SearchClient(SearchDTO searchDTO) { var query = from client in Clients .Include(c => c.ClientSecrets) .Include(c => c.AllowedCorsOrigins) .Include(c => c.AllowedGrantTypes) .Include(c => c.AllowedScopes) .Include(c => c.Claims) .Include(c => c.PostLogoutRedirectUris) .Include(c => c.RedirectUris) .Include(c => c.IdentityProviderRestrictions) orderby client.ClientName select client; if (!string.IsNullOrWhiteSpace(searchDTO.Search)) { query = from client in query where client.ClientName.Contains(searchDTO.Search) || client.ClientId.Contains(searchDTO.Search) orderby client.ClientName select client; } int total = query.Count(); var clients = await query.Skip(searchDTO.Start).Take(searchDTO.Count).ToArrayAsync(); var result = new PagedQuery <ClientDTO> { Start = searchDTO.Start, Count = searchDTO.Count, Total = total, Items = clients.Select(i => i.ToDTO()), Search = searchDTO.Search }; return(result); }
public PagedResponse <TicketAbbreviatedDTO> FindPage(string userId, PagedQuery pageQuery, FilterAndOrderQuery filterAndOrderQuery) { var res = new PagedResponse <TicketAbbreviatedDTO>(); var size = pageQuery.PageSize == null ? 3 : (int)pageQuery.PageSize; var num = pageQuery.PageNum == null ? 3 : (int)pageQuery.PageNum; var ticketQuery = _ticketRepository.GetBasicQuery(); ticketQuery = ticketQuery.Where( t => t.Project.ProjectUsersReq.Where( pur => (pur.UserAssigned.Id.Equals(Guid.Parse(userId)) || pur.Sender.Id.Equals(Guid.Parse(userId))) && pur.Accepted).ToList().Count > 0 ); //p => p.ProjectUsersReq.Where(pur => pur.UserAssigned.Id.Equals(Guid.Parse(id)) || pur.Sender.Id.Equals(Guid.Parse(id))).ToList().Count > 0 if (filterAndOrderQuery != null && filterAndOrderQuery.Filters != null) { Console.WriteLine("recognised the filters"); if (filterAndOrderQuery.Filters.Count() > 0) { ticketQuery = ticketQuery.Where(t => t.Title.Contains(filterAndOrderQuery.Filters.First().Value)); } ticketQuery = ticketQuery.OrderBy(t => t.Title); } var tickets = ticketQuery.Page(num, size).Include(t => t.Status).ToList(); res.Success = true; res.EntitiesDTO = _mapper.Map <ICollection <Ticket>, ICollection <TicketAbbreviatedDTO> >(tickets); return(res); }
public PagedResponse <ProjectAbbreviatedDTO> FindPage(string id, PagedQuery pagedQuery, FilterAndOrderQuery filterAndOrder) { var res = new PagedResponse <ProjectAbbreviatedDTO>(); var size = pagedQuery.PageSize == null ? 3 : (int)pagedQuery.PageSize; var num = pagedQuery.PageNum == null ? 3 : (int)pagedQuery.PageNum; var projectsQuery = _projectRepository.GetBasicQuery(); Console.WriteLine(filterAndOrder.Filters is null); projectsQuery = projectsQuery.Where( p => p.ProjectUsersReq.Where(pur => (pur.UserAssigned.Id.Equals(Guid.Parse(id)) || pur.Sender.Id.Equals(Guid.Parse(id))) && pur.Accepted).ToList().Count > 0); if (filterAndOrder != null && filterAndOrder.Filters != null) { Console.WriteLine("recognised the filters"); foreach (var filter in filterAndOrder.Filters) { projectsQuery = projectsQuery .ApplyFilterOption(filter.ConvertTStringToProjectFilterOption(), filter.Value); } projectsQuery = projectsQuery .ApplySortingOptions(filterAndOrder.OrderBy.ConvertTStringToProjectOrderOption()); } var projects = projectsQuery.Page(num, size).ToList(); res.Success = true; res.EntitiesDTO = _mapper.Map <ICollection <Project>, ICollection <ProjectAbbreviatedDTO> >(projects); return(res); }
public async Task <IActionResult> FindUserPermissionAsync(Guid userId, PagedQuery query) { var user = await _userManager.Users.FirstOrDefaultAsync(u => u.Id == userId); if (user == null) { return(new ApiResult(ApiResultType.Error, "用户不存在或已经删除")); } var queryResult = await _dbContext.UserRoles.Where(ur => ur.UserId == userId) .Join(_dbContext.Roles, userRole => userRole.RoleId, role => role.Id, (userRole, role) => new { RoleId = role.Id, RoleName = role.Name }) .Join(_dbContext.RolePermissions, role => role.RoleId, rolePermission => rolePermission.RoleId, (role, rolePermission) => new { role.RoleId, role.RoleName, rolePermission.PermissionId }) .Join(_dbContext.Permissions, rolePermission => rolePermission.PermissionId, permission => permission.Id, (rolePermission, permission) => new { rolePermission.RoleId, rolePermission.RoleName, rolePermission.PermissionId, permission.Name, permission.Description }).PagedQueryAsync(query); return(new ApiResult(queryResult)); }
protected bool Equals(PagedQuery other) { return Page == other.Page && PageSize == other.PageSize; }
public void TestDbContext_PagedQuery_Ask() { var pagedQuery = new PagedQuery<int, UberProductSpec, Product, ProductDto>( new TestDbContext(), new StaticAutoMapperWrapper()).AsPaged(); var optimizedQUery = new OptimizedQuery(); var sw = new Stopwatch(); sw.Start(); var specs = new List<UberProductSpec>(); for (var i = 0; i < 50000; i++) { specs.Add(new UberProductSpec(1, 1) {Price = i}); } var res = specs.Select(x => pagedQuery.Ask(x)).ToArray(); sw.Stop(); //Assert.Equal(99900, res.First().Price); //Assert.Equal(964, res.TotalCount); Assert.True(sw.ElapsedMilliseconds < 300, $"Elapsed Miliseconds: {sw.ElapsedMilliseconds}"); }
public async Task <IActionResult> GetAllLogs( [FromQuery] PagedQuery <LogFilter> pagedQuery, CancellationToken token) => Ok(await _mediator.Send(new GetLogsQuery(pagedQuery), token));
/// <summary> /// 获得数据列表 /// </summary> public Paged <Wuyiju.Model.Paylog> GetPaged(PagedQuery <Wuyiju.Model.Paylog.Query> query) { return(dao.GetPaged(query)); }
private async Task<HttpResponseMessage> Query(PagedQuery query) { var innerResponse = (await _myObjectService.QueryMyObjects(query.AsServiceRequest())); var resultModel = Mapper.Map < PagedResultModel<MyObjectModel>>(innerResponse.Result); if (innerResponse.Success && resultModel != null) { //set next/previous links for restful friendliness if (query.Page > 1 && resultModel.PageCount > 1) resultModel.PreviousPage = ToFullUri(Url.Route("DefaultApi", new { Page = query.Page - 1, PageSize = query.PageSize })); if (query.Page < resultModel.PageCount) //using 1-based paging resultModel.NextPage = ToFullUri(Url.Route("DefaultApi", new { Page = query.Page + 1, PageSize = query.PageSize })); } var toReturn = innerResponse.ToApiServiceResponse(resultModel); return Request.CreateResponse(GetStatusCodeForResponse(toReturn), toReturn); }