public void Get_Lpc_Report_Paging_Returns_Data()
{
var pageSize = 30;
var dataSourceResults = new PagedResultModel <LpcReportModel>
{
Results = LpcReportDataSource.GetLpcReportModelList(pageSize),
Page = 1,
Limit = pageSize,
};
var lpcReportsService = new Mock <ILpcReportService>();
lpcReportsService.Setup(x => x.GetLPCReports(It.IsAny <LpcReportRequest>()))
.Returns(dataSourceResults);
var controller = GetLpcReportController(lpcReportsService.Object);
controller.ControllerContext = WebTestHelpers.GetHttpContext();
// Act
var request = new LPCReportRequestModel {
};
var sut = controller.Get(request, pageSize, 1);
// Assert
Assert.NotNull(sut);
Assert.IsType <OkObjectResult>(sut);
var objectResult = sut as OkObjectResult;
Assert.NotNull(objectResult);
Assert.True(objectResult.StatusCode == 200);
}
public PagedResultModel <Client> Get(int pageIndex, int pageSize)
{
if (pageIndex < 0)
{
throw new ArgumentOutOfRangeException("pageIndex", "pageIndex no debe ser menor a cero.");
}
if (pageSize < 0)
{
throw new ArgumentOutOfRangeException("pageSize", "pageIndex no debe ser menor a cero.");
}
var totalItems = clientsRepository.TotalClients();
var totalPages = (long)Math.Floor((decimal)totalItems / pageSize);
var items = clientsRepository.Get(pageIndex, pageSize);
var result = new PagedResultModel <Client>
{
PageIndex = pageIndex,
PageSize = pageSize,
TotalPages = totalPages,
TotalItems = totalItems,
Items = items
};
return(result);
}
public static IQuery <TSource> PagedQuery <TSource>(this IQuery <TSource> source, PagedModel page) where TSource : class, new()
{
PagedResultModel <TSource> result = new PagedResultModel <TSource>();
try
{
if (!string.IsNullOrEmpty(page.sortField))
{
if (page.sortOrder == "ascend")
{
source = source.Order <TSource>(page.sortField, "asc");
}
else
{
source = source.Order <TSource>(page.sortField, "desc");
}
}
}
catch { }
if (page.currentPage != -1)
{
//分页
source = source.Skip((page.currentPage - 1) * page.pageSize).Take(page.pageSize);
}
else
{
source = source.Skip((page.currentPage - 1) * page.pageSize);
}
return(source);
}
public async Task <PagedResultModel <TodoItemModel> > SearchAsync(TodoItemSearchModel model)
{
using (var session = factory.OpenSession()) {
var result = new PagedResultModel <TodoItemModel>();
var query = session.Query <TodoItem>();
// add custom query here;
if (model.Completed.HasValue)
{
var val = model.Completed.Value;
query = query.Where(x => x.Completed == val);
}
if (!string.IsNullOrEmpty(model.UserId))
{
query = query.Where(x => x.User.Id == model.UserId);
}
//
result.Total = await query.LongCountAsync();
result.Data = await query.ProjectTo <TodoItemModel>(mapper.ConfigurationProvider)
.Skip(model.Skip)
.Take(model.Take)
.ToListAsync();
result.Skip = model.Skip;
result.Take = model.Take;
return(result);
}
}
public async Task <IActionResult> Index([FromRoute] int page = 1)
{
PagedResultModel <Post> posts = await _blog.GetPostsPaged(_settings.Value.PostsPerPage, page);
ViewData["Title"] = _manifest.Name;
ViewData["Description"] = _manifest.Description;
ViewData["prev"] = posts.HasPreviousPage ? $"/page/{page - 1}/" : string.Empty;
ViewData["next"] = posts.HasNextPage ? $"/page/{page + 1}/" : string.Empty;
return(View("~/Views/Blog/Index.cshtml", posts));
}
public async Task <IActionResult> Category(string category, int page = 1)
{
PagedResultModel <Post> posts = await _blog.GetPostsPaged(_settings.Value.PostsPerPage, page, category);
ViewData["Title"] = _manifest.Name + " " + category;
ViewData["Description"] = $"Articles posted in the {category} category";
ViewData["prev"] = posts.HasPreviousPage ? $"/category/{category}/{page - 1}/" : string.Empty;
ViewData["next"] = posts.HasNextPage ? $"/category/{category}/{page + 1}/" : string.Empty;
//ViewData["prev"] = $"/blog/category/{category}/{page + 1}/";
//ViewData["next"] = $"/blog/category/{category}/{(page <= 1 ? null : page - 1 + "/")}";
return(View("~/Views/Blog/Index.cshtml", posts));
}
private async Task <PagedResultModel <T> > GetFilteredRecords(FilterModel filterModel, Expression <Func <T, bool> > predicate, params Expression <Func <T, object> >[] includes)
{
PagedResultModel <T> pagedResult = new PagedResultModel <T>();
var skip = (filterModel.PageNumber) * filterModel.PageSize;
Expression <Func <T, bool> > searchFilterExpression = null;
var generalFilterExpression = this.ApplyFilters(predicate);
var sortExpression = GetSortExpression(filterModel.SortMember);
if (filterModel.Filters?.Count > 0)
{
searchFilterExpression = FilterExpression(filterModel.Filters);
pagedResult.TotalRecords = this.dbset.Where(generalFilterExpression).Where(searchFilterExpression).Count();
}
else
{
pagedResult.TotalRecords = (this.dbset.Where(generalFilterExpression)).Count();
}
pagedResult.TotalPages = ((pagedResult.TotalRecords + filterModel.PageSize - 1) / filterModel.PageSize);
IQueryable <T> source;
if (filterModel.Filters?.Count > 0)
{
source = this.dbset.Where(generalFilterExpression).Where(searchFilterExpression);
}
else
{
source = this.dbset.Where(generalFilterExpression);
}
if (includes != null)
{
source = this.Include(source, includes);
}
if (filterModel.SortDescending)
{
pagedResult.Records = await source
.OrderByDescending(sortExpression)
.Skip(skip).Take(filterModel.PageSize).ToListAsync().ConfigureAwait(false);
}
else
{
pagedResult.Records = await source
.OrderBy(sortExpression)
.Skip(skip).Take(filterModel.PageSize).ToListAsync().ConfigureAwait(false);
}
return(pagedResult);
}
public IHttpActionResult Get(int page = 1,
int pageSize = 10)
{
page = page > 0 ? page : 1;
pageSize = pageSize > 0 ? pageSize : 10;
PagedResultDTO <TestResultDTO> pagedResultDTO = _resultService.GetPaged(page, pageSize);
PagedResultModel <TestResultModel> pagedResult = _mapper.Map <PagedResultDTO <TestResultDTO>, PagedResultModel <TestResultModel> >(pagedResultDTO);
return(Ok(pagedResult));
}
public IHttpActionResult Get(string query = "",
int page = 1,
int pageSize = 10)
{
string searchQuery = String.IsNullOrEmpty(query) ? "" : query;
page = page > 0 ? page : 1;
pageSize = pageSize > 0 ? pageSize : 10;
PagedResultDTO <TestDTO> pagedResultDTO = _testService.GetPaged(searchQuery, page, pageSize);
PagedResultModel <TestModel> pagedResult = _mapper.Map <PagedResultDTO <TestDTO>, PagedResultModel <TestModel> >(pagedResultDTO);
return(Ok(pagedResult));
}
private IHttpActionResult CreateActionResultFor(PagedResult <ProductDto> pagedResult)
{
if (pagedResult.IsEmpty())
{
return(StatusCode(HttpStatusCode.NoContent));
}
var models = pagedResult.Result.Select(MapToModel).ToList();
var result = new PagedResultModel <ProductReadModel>(
models,
MappingHelper.MapToModel(pagedResult.PageInfo),
pagedResult.TotalCount);
return(Ok(result));
}
public async Task <IHttpActionResult> Get(
string query = "",
int page = 1,
int pageSize = 10)
{
string searchQuery = String.IsNullOrEmpty(query) ? "" : query;
page = page > 0 ? page : 1;
pageSize = pageSize > 0 ? pageSize : 10;
PagedResultDTO <UserDTO> pagedResultDTO = await _userService.GetPaged(searchQuery, page, pageSize);
PagedResultModel <UserModel> pagedResult = _mapper.Map <PagedResultDTO <UserDTO>, PagedResultModel <UserModel> >(pagedResultDTO);
return(Ok(pagedResult));
}
public async Task <IActionResult> Get([FromQuery] int pageSize = 10, [FromQuery] int pageIndex = 0)
{
var totalItems = await this.catalogContext.BeverageTypes
.LongCountAsync();
var itemsOnPage = await this.catalogContext.BeverageTypes
.OrderBy(c => c.Name)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
var model = new PagedResultModel <BeverageType>(
pageIndex, pageSize, totalItems, itemsOnPage);
return(this.Ok(model));
}
public PagedResultModel <LPCReportModel> GetLPCReports(LPCReportRequest request)
{
var predicate = PredicateBuilder.True <LPCReport>();
if (!string.IsNullOrEmpty(request.Borough))
{
predicate = predicate.And(x => x.Borough == request.Borough);
}
if (!string.IsNullOrEmpty(request.ObjectType))
{
predicate = predicate.And(x => x.ObjectType == request.ObjectType);
}
var sortModel = new SortModel
{
SortColumn = !string.IsNullOrEmpty(request.SortColumn) ? request.SortColumn : null,
SortOrder = !string.IsNullOrEmpty(request.SortOrder) ? request.SortOrder : null
};
var sortingList = new List <SortModel>();
sortingList.Add(sortModel);
int totalCount = _lpcReportRepository.FindBy(predicate).Count();
var results = _lpcReportRepository
.GetPage(predicate, request.PageSize * (request.Page - 1), request.PageSize, sortingList);
var modelData = Mapper.Map <IEnumerable <LPCReport>, IEnumerable <LPCReportModel> >(results).ToList();
var pagedResult = new PagedResultModel <LPCReportModel>
{
Total = totalCount,
Page = request.Page,
Limit = request.PageSize,
Results = modelData,
};
return(pagedResult);
}
public async Task <IActionResult> Get([FromQuery] int pageSize = 10, [FromQuery] int pageIndex = 0, [FromQuery] string ids = null)
{
if (!string.IsNullOrEmpty(ids))
{
return(await this.GetItemsByIds(ids));
}
var totalItems = await this.catalogContext.Beverages
.LongCountAsync();
var itemsOnPage = await this.catalogContext.Beverages
.OrderBy(c => c.Name)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
var model = new PagedResultModel <Beverage>(
pageIndex, pageSize, totalItems, itemsOnPage);
return(this.Ok(model));
}
/// <summary>
/// 分页扩展方法
/// </summary>
/// <typeparam name="TSource">分页返回的data模型</typeparam>
/// <param name="source">szorm查询变量</param>
/// <param name="page">分页参数</param>
/// <returns>分页模型，可直接用于antd</returns>
public static PagedResultModel <TSource> ToPaged <TSource>(this IQuery <TSource> source, PagedModel page) where TSource : class, new()
{
int count = source.Count();
PagedResultModel <TSource> result = new PagedResultModel <TSource>();
try
{
if (!string.IsNullOrEmpty(page.sortField))
{
if (page.sortOrder == "ascend")
{
source = source.Order <TSource>(page.sortField, "asc");
}
else
{
source = source.Order <TSource>(page.sortField, "desc");
}
}
}
catch { }
if (page.currentPage != -1)
{
//分页
source = source.Skip((page.currentPage - 1) * page.pageSize).Take(page.pageSize);
}
else
{
source = source.Skip((page.currentPage - 1) * page.pageSize);
}
result.currentPage = page.currentPage;
result.pageSize = page.pageSize;
result.sortField = page.sortField;
result.sortOrder = page.sortOrder;
result.data = source.ToList();
result.totalCount = count;
return(result);
}
public async Task <PagedResultModel <Post> > GetPostsPaged(int pageSize, int pageNumber = 1, string category = "", bool isAdmin = false)
{
IEnumerable <PostBase> postSummaries = _blobStorageService
.PostCache
.Where(p => category == string.Empty || p.Categories.Contains(category))
.Where(p => p.PubDate <= DateTime.UtcNow && (p.IsPublished || isAdmin))
.OrderByDescending(p => p.PubDate)
.ToArray();
PagedResult <PostBase> pagedResult = new PagedResult <PostBase>(postSummaries, pageSize, pageNumber);
PagedResultModel <Post> result = new PagedResultModel <Post>
{
HasNextPage = pagedResult.HasNextPage,
HasPreviousPage = pagedResult.HasPreviousPage,
NextPageNumber = pagedResult.NextPageNumber,
PreviousPageNumber = pagedResult.PreviousPageNumber,
PageNumber = pagedResult.PageNumber,
PageSize = pagedResult.PageSize,
TotalPages = pagedResult.TotalPages,
TotalItems = pagedResult.TotalItems
};
List <Post> posts = new List <Post>();
foreach (PostBase postBase in pagedResult.Items)
{
posts.Add(await GetPostById(postBase.Id));
}
if (posts.Any(p => p == null))
{
await _blobStorageService.InitializeSummaryCache();
}
result.Items = posts.Where(p => p != null);
return(result);
}
public PagedResultModel <LandmarkModel> GetLandmarks(LandmarkRequest request)
{
var predicate = PredicateBuilder.True <Landmark>();
if (!string.IsNullOrEmpty(request.LPCNumber))
{
predicate = predicate.And(x => x.LP_NUMBER == request.LPCNumber);
}
var sortModel = new SortModel
{
SortColumn = !string.IsNullOrEmpty(request.SortColumn) ? request.SortColumn : null,
SortOrder = !string.IsNullOrEmpty(request.SortOrder) ? request.SortOrder : null
};
var sortingList = new List <SortModel>();
sortingList.Add(sortModel);
int totalCount = _landmarktRepository.FindBy(predicate).Count();
var results = _landmarktRepository
.GetPage(predicate, request.PageSize * (request.Page - 1), request.PageSize, sortingList);
var modelData = Mapper.Map <IEnumerable <Landmark>, IEnumerable <LandmarkModel> >(results).ToList();
var pagedResult = new PagedResultModel <LandmarkModel>
{
Total = totalCount,
Page = request.Page,
Limit = request.PageSize,
Results = modelData,
};
return(pagedResult);
}
