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