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);
}
