/// <summary>
/// Extracts core grid options from a request query string
/// </summary>
/// <param name="request">The HttpRequest</param>
/// <returns>A populated CoreGridFSPOptions object</returns>
public static CoreGridFSPOptions ExtractCoreGridOptions(this HttpRequest request)
{
var gridOptions = new CoreGridFSPOptions();
var paginationOptions = new PaginationOptions()
{
Count = 1
};
foreach (var param in request.Query)
{
var lkey = param.Key.Trim().ToLower();
if (lkey == "selectedsort")
{
gridOptions.SelectedSort = param.Value;
}
else if (lkey == "currentpage")
{
int page = 1;
int.TryParse(param.Value, out page);
paginationOptions.CurrentPage = page;
}
else if (lkey == "pagesize")
{
int pageSize = 0;
if (int.TryParse(param.Value, out pageSize))
{
paginationOptions.PageSize = pageSize;
}
}
else
{
if (gridOptions.FilterList.ContainsKey(param.Key))
{
gridOptions.FilterList.Add(param.Key, param.Value);
}
else
{
gridOptions.FilterList[param.Key] = param.Value;
}
}
}
gridOptions.PaginationOptions = paginationOptions;
return(gridOptions);
}
public RecipesSearchSpecification(Expression <Func <Recipe, bool> >[] criteria, PaginationOptions paginationOptions, string sort = null, bool sortDesc = false) : base(criteria)
{
AddInclude($"{nameof(Recipe.CategoryRecipe)}.{nameof(CategoryRecipe.Category)}");
ApplyPaging(paginationOptions);
switch (sort)
{
case "name":
AddOrderBy(recipe => recipe.Name, sortDesc);
AddOrderBy(recipe => recipe.CreatedOn);
break;
default:
AddOrderBy(recipe => recipe.Id);
break;
}
}
//Constructor
public CobAdjuntosCobranzaController(ICobAdjuntosCobranzaService cobAdjuntosCobranzaService,
IGeneralCobranzaService generalCobranzaService,
IMapper mapper,
IUriService uriService,
IOptions <PaginationOptions> options,
IOfdTipoDocumentoService ofdTipoDocumentoService,
ILogger <CobAdjuntosCobranzaController> logger,
IAppProductsService appProductsService)
{
_cobAdjuntosCobranzaService = cobAdjuntosCobranzaService;
_generalCobranzaService = generalCobranzaService;
_mapper = mapper;
_uriService = uriService;
_ofdTipoDocumentoService = ofdTipoDocumentoService;
_logger = logger;
_appProductsService = appProductsService;
_paginationOptions = options.Value;
}
public IActionResult Index(PagedListResultViewModel <CareerViewModel> parameters)
{
var pagination = new PaginationOptions();
if (parameters.Page > 0)
{
pagination.Page = parameters.Page;
pagination.PageSize = 10;
}
else
{
pagination.Page = 1;
pagination.PageSize = 10;
}
var resultList = _careerService.GetPagedList(pagination.Page, pagination.PageSize, null).ToViewModel();
return(View(resultList));
}
public JsonList <OrderModel> GetAll(
[FromUri] OrderBatchSearchCriteria searchCriteria,
[FromUri] PaginationOptions options)
{
var sessionEndDate = _orderBatchService.GetNearestSessionEndDate();
var orders = _orderBatchService.GetAllOrdersInSubmittedBatches(sessionEndDate, searchCriteria.DepartmentId, searchCriteria.UserId, searchCriteria.UserName, searchCriteria.OrderType, options, _workContext.User);
var model = new JsonList <OrderModel>();
model.Data = orders.ToModelList <Order, OrderModel>();
model.TotalItems = orders.TotalCount;
model.Metadata = new
{
OrderSession = _orderBatchService.GetNearestOrderSession(sessionEndDate),
TotalValueWithFilter = model.Data.Sum(x => x.Value)
};
return(model);
}
public (Characters data, int pageNr, int charactersCount) QueryPaginated(PaginationOptions paginationOptions)
{
int count = Characters.Count();
int lastPage = 0;
int pageSize = paginationOptions.PageSize < 1 ? 1 : paginationOptions.PageSize;
if (count % pageSize != 0)
{
lastPage = count / pageSize + 1;
}
else
{
lastPage = count / pageSize;
}
int pageNr = lastPage < paginationOptions.PageNumber?lastPage:paginationOptions.PageNumber;
return(
new Characters(
Characters.AsNoTracking().Include(x => x.Friends).Include(x => x.Episodes)
.Skip(pageSize * (pageNr - 1))
.Take(pageSize)
.Select(x => new Character
{
Id = x.Id,
Name = x.Name,
Episodes =
new Episodes(x.Episodes
.Select(y => y.Episode)
.ToArray()),
Friends =
new Friends(x.Friends
.Select(y => new Friend
{
Id = y.FriendId,
Name = y.FriendName
})
.ToArray())
})
.ToArray())
, pageNr, count);
}
/// <summary>
/// Comment pagination for choosen image
/// </summary>
/// <param name="imageId"></param>
/// <param name="page"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public virtual async Task <IPaginationModel <Comment> > GetImageCommentsAsync(long imageId, int?page, int pageSize)
{
if (await imageRepo.GetByIdAsync(imageId) == null)
{
throw new InvalidRequest("Iamge doesnt exist");
}
var countSpec = new CommentSpecification(imageId);
int numberOfInstances = await commentRepo.CountAsync(countSpec);
int currentPage = pgMaker.CheckPageLimits(page, numberOfInstances, pageSize);
int skip = pgMaker.Skip(currentPage, pageSize);
var paginationSpec = new CommentSpecification(imageId, skip, pageSize);
var commentInstances = await commentRepo.ListAsync(paginationSpec);
var options = new PaginationOptions(currentPage, numberOfInstances, pageSize);
return(pgMaker.PreparePaginationModel <Comment>(commentInstances, options));
}
public JsonList <PvLogSummaryModel> SearchLogSummary(
[FromUri] PvLogSearchCriteria criteria,
[FromUri] PaginationOptions options)
{
options = GetPaginationOptions(options);
// If user don't have permission to view others' log; set userid to himself
if (!_workContext.User.HasPermission(UserPermission.ViewUserPvLog))
{
criteria.UserId = _workContext.User.Id;
}
var logs = _pvLogService.SearchLogSummary(criteria, options, _workContext.User);
var data = logs.ToModelList <PvLogSummaryDto, PvLogSummaryModel>().OrderBy(x => ConvertMonthYearToDateTime(x.Month));
return(new JsonList <PvLogSummaryModel>
{
Data = data,
TotalItems = logs.TotalCount
});
}
public ActionResult <PaginatedResults <PersonDto> > Get(int?page, int?count, string query = "")
{
var options = new PaginationOptions();
if (page.HasValue)
{
options.PageNumber = (int)page;
}
if (count.HasValue)
{
options.Count = (int)count;
}
if (!string.IsNullOrWhiteSpace(query))
{
return(_peopleService.GetPeopleByName(query, options));
}
return(_peopleService.GetAll(options));
}
public ActionResult <PaginatedResults <OccupationDto> > GetByName(string name, int?page, int?count)
{
if (string.IsNullOrEmpty(name))
{
return(BadRequest(new { Message = "'name' field is required" }));
}
var options = new PaginationOptions();
if (page.HasValue)
{
options.PageNumber = (int)page;
}
if (count.HasValue)
{
options.Count = (int)count;
}
return(_occupationsService.GetByName(name, options));
}
public IPagedList <Product> Search(ProductListSearchCriteria searchCriteria, PaginationOptions options)
{
var query = _productRepo.TableNoTracking.IncludeTable(x => x.ProductCategory);
// Filter
if (!string.IsNullOrEmpty(searchCriteria.Sku))
{
query = query.Where(x => x.Sku.Contains(searchCriteria.Sku));
}
if (!string.IsNullOrEmpty(searchCriteria.Name))
{
query = query.Where(x => x.Name.Contains(searchCriteria.Name));
}
if (searchCriteria.CategoryId > 0)
{
query = query.Where(x => x.CategoryId == searchCriteria.CategoryId);
}
if (searchCriteria.ActiveOnly)
{
query = query.Where(x => x.IsActive);
}
// Sort
if (string.IsNullOrEmpty(options.Sort))
{
query = query.OrderBy(x => x.Sku);
}
else
{
// HACK: support nested sort
if (options.Sort.Equals("categoryName", StringComparison.OrdinalIgnoreCase))
{
options.Sort = "ProductCategory.Name";
}
query = query.SortBy(options.SortExpression);
}
return(new PagedList <Product>(query, options.PageIndex, options.PageSize));
}
//Constructor
public CobPagosRetencionesController(ICobPagosRetencionesService cobPagosRetencionesService,
ICobGrabacionCobranzasService cobGrabacionCobranzasService,
ICobTransaccionesService cobTransaccionesService,
IMapper mapper,
IUriService uriService,
IOptions <PaginationOptions> options,
IOfdTipoDocumentoService ofdTipoDocumentoService,
ICobValoresRetencionesService cobValoresRetencionesService,
ICobEstadoCuentaService cobEstadoCuentaService,
ITPaTasaBancoCentralServices tPaTasaBancoCentralServices
)
{
_cobPagosRetencionesService = cobPagosRetencionesService;
_cobGrabacionCobranzasService = cobGrabacionCobranzasService;
_cobTransaccionesService = cobTransaccionesService;
_mapper = mapper;
_uriService = uriService;
_cobValoresRetencionesService = cobValoresRetencionesService;
_cobEstadoCuentaService = cobEstadoCuentaService;
_tPaTasaBancoCentralServices = tPaTasaBancoCentralServices;
_paginationOptions = options.Value;
}
public void EnableNextTest()
{
var p = new PaginationOptions();
p.PageSize = 0;
p.CurrentPage = 1;
p.Count = 1500;
Assert.IsFalse(p.EnableNext);
p.CurrentPage = 2;
Assert.IsFalse(p.EnableNext);
p.PageSize = 5;
p.Count = 20;
Assert.IsTrue(p.EnableNext);
p.CurrentPage = 1;
Assert.IsTrue(p.EnableNext);
p.CurrentPage = 4;
Assert.IsFalse(p.EnableNext);
}
public JsonList <AwardModel> GetAll(
[FromUri] AwardSearchCriteria searchCriteria,
[FromUri] PaginationOptions options)
{
options = GetPaginationOptions(options);
var model = new JsonList <AwardModel>();
if (searchCriteria.NoPaging)
{
var allAwards = _awardService.GetAll();
model.Data = allAwards.ToModelList <Award, AwardModel>();
model.TotalItems = allAwards.Count;
}
else
{
var searchData = _awardService.Search(searchCriteria, options, _workContext.User);
model.Data = searchData.ToModelList <Award, AwardModel>();
model.TotalItems = searchData.TotalCount;
}
return(model);
}
public IPagedList <LogEntry> GetLogs(string filter, PaginationOptions options, DateTime?startDate = null, DateTime?endDate = null)
{
var applicationParam = _dataProvider.CreateParameter("Application", "StaffingPurchase", DbType.String);
var whereClauseParam = _dataProvider.CreateParameter("MessageFilter", filter, DbType.String);
var startDateParam = _dataProvider.CreateParameter("StartDate", ConvertToUtc(startDate), DbType.DateTime);
var endDateParam = _dataProvider.CreateParameter("EndDate", ConvertToUtc(endDate, true), DbType.DateTime);
var pageIndexParam = _dataProvider.CreateParameter("PageIndex", options.PageIndex, DbType.Int32);
var pageSizeParam = _dataProvider.CreateParameter("PageSize", options.PageSize, DbType.Int32);
var totalCountParam = _dataProvider.CreateParameter("TotalCount", 0, DbType.Int32, ParameterDirection.Output);
var data = _dbContext.ExecuteStoredProcedureList <LogEntry>("ELMAH_Search", new object[] {
applicationParam,
whereClauseParam,
startDateParam,
endDateParam,
pageIndexParam,
pageSizeParam,
totalCountParam
});
return(new PagedList <LogEntry>(data, options.PageIndex, options.PageSize, (int)totalCountParam.Value));
}
/// <summary>
/// Get all images
/// </summary>
/// <param name="page">current page</param>
/// <param name="pageSize">number of items to show</param>
/// <param name="searchQuery">search items by this criteria</param>
/// <returns>IPaginationModel Instance</returns>
public virtual async Task <IPaginationModel <Image> > GetImagesAsync(int?page, int pageSize, string searchQuery)
{
//Check for unwanted values
int currentPage = page ?? 1;
searchQuery = searchQuery ?? string.Empty;
//Count number of iamge instances in repository
int totalRecords = await imageRepo.CountAsync();
//Check if variable currentPage valid
currentPage = page ?? pgMaker.CheckPageLimits(currentPage, totalRecords, pageSize);
//Get instances
int skip = pgMaker.Skip(currentPage, pageSize);
var instances = await imageRepo.ListPaginationAsync(skip, pageSize);
//Prepare pagination model
var pgOptions = new PaginationOptions(currentPage, totalRecords, pageSize);
return(pgMaker.PreparePaginationModel(instances, pgOptions));
}
private SummaryDiscountProductModel GetDiscountOrders(OrderAdminSearchCriteria searchCriteria,
PaginationOptions paginationOptions)
{
searchCriteria.OrderBatchStatus = OrderBatchStatus.Approved;
var tbl = _orderReportService.SearchSummaryDiscountProduct(_workContext.User, paginationOptions,
searchCriteria);
var dataRows =
tbl.AsEnumerable()
.Skip((paginationOptions.PageIndex - 1) * paginationOptions.PageSize)
.Take(paginationOptions.PageSize);
var model = dataRows.Select(Mapper.Map <DataRow, SummaryDiscountProductRowModel>).ToList();
int summaryTotalAmount = 0;
decimal summaryTotalDiscountedPrice = 0;
decimal summaryTotalPrice = 0;
if (model.Count > 0)
{
summaryTotalAmount = Convert.ToInt32(tbl.Compute("Sum(Quantity)", ""));
summaryTotalDiscountedPrice = Convert.ToDecimal(tbl.Compute("Sum(TotalDiscountedPrice)", ""));
summaryTotalPrice = Convert.ToDecimal(tbl.Compute("Sum(TotalPrice)", ""));
}
var summaryDiscountProductModel = new SummaryDiscountProductModel()
{
Data = model,
SummaryTotalPrice = summaryTotalPrice,
SummaryTotalAmount = summaryTotalAmount,
SummaryTotalDiscountedPrice = summaryTotalDiscountedPrice,
TotalItems = tbl.Rows.Count
};
return(summaryDiscountProductModel);
}
public OrderBatchModel Get(
[FromUri] OrderBatchSearchCriteria searchCriteria,
[FromUri] PaginationOptions options)
{
options = GetPaginationOptions(options);
var orderBatch = _orderBatchService.GetByLocation(searchCriteria.LocationId, searchCriteria.OrderType, _workContext.User);
if (orderBatch == null)
{
return(new OrderBatchModel());
}
OrderBatchModel model = orderBatch.ToModel <OrderBatchModel>();
var orders = _orderBatchService.SearchOrders(orderBatch.Id, searchCriteria.DepartmentId, searchCriteria.UserId, searchCriteria.UserName, options);
model.Orders = orders.ToModelList <Order, OrderModel>();
model.TotalOrders = orders.TotalCount;
model.TotalValueWithFilter = model.Orders.Sum(x => x.Value);
return(model);
}
public IPagedList <Order> GetOrders(PaginationOptions pagingOptions, int userId, DateTime startDate, DateTime endDate, OrderStatus?status)
{
var query = _orderRepository
.TableNoTracking
.IncludeTable(c => c.OrderBatch)
.Where(c => c.UserId == userId && (!status.HasValue || status.Value == (OrderStatus)c.StatusId))
.Where(c => DbFunctions.TruncateTime(c.OrderDate) >= startDate.Date && DbFunctions.TruncateTime(c.OrderDate) <= endDate.Date)
.ToList()
.OrderBy(c => c.Id);
foreach (var order in query)
{
if (order.OrderBatch == null)
{
order.OrderBatch = new OrderBatch
{
StartDate = GetCurrentOrderSessionStartDate(order.OrderDate),
EndDate = GetCurrentOrderSessionEndDate(order.OrderDate)
};
}
}
return(new PagedList <Order>(query.AsQueryable(), pagingOptions.PageIndex, pagingOptions.PageSize));
}
//Constructor
public CobGrabacionCobranzasController(ICobGrabacionCobranzasService cobGrabacionCobranzasService,
IMapper mapper,
IUriService uriService,
IOptions <PaginationOptions> options,
IOfdTipoDocumentoService ofdTipoDocumentoService,
ICobEstadoCuentaService cobEstadoCuentaService,
IMtrClienteService mtrClienteService,
IGeneralCobranzaService generalCobranzaService,
IMtrTipoMonedaService mtrTipoMonedaService,
ICobMatrixMonedaValidaPagoService cobMatrixMonedaValidaPagoService,
IOfdCotizacionService ofdCotizacionService)
{
_cobGrabacionCobranzasService = cobGrabacionCobranzasService;
_mapper = mapper;
_uriService = uriService;
_cobEstadoCuentaService = cobEstadoCuentaService;
_mtrClienteService = mtrClienteService;
_generalCobranzaService = generalCobranzaService;
_mtrTipoMonedaService = mtrTipoMonedaService;
_cobMatrixMonedaValidaPagoService = cobMatrixMonedaValidaPagoService;
_ofdCotizacionService = ofdCotizacionService;
_paginationOptions = options.Value;
}
public async Task <Search> SearchAsync(SearchOptions searchOptions, PaginationOptions pagingOptions = null)
{
var parameterDictionary = new List <KeyValuePair <string, string> >();
if (pagingOptions == null)
{
pagingOptions = new PaginationOptions();
}
parameterDictionary.Add(new KeyValuePair <string, string>("search", searchOptions.ToQuery()));
if (pagingOptions.Limit != 0)
{
parameterDictionary.Add(new KeyValuePair <string, string>("limit", pagingOptions.Limit.ToString()));
}
if (pagingOptions.Skip != 0)
{
parameterDictionary.Add(new KeyValuePair <string, string>("skip", pagingOptions.Skip.ToString()));
}
if (!string.IsNullOrEmpty(ApiKey))
{
parameterDictionary.Add(new KeyValuePair <string, string>("api_key", ApiKey));
}
var requestUri = new Uri($"{SearchApi}?{parameterDictionary.FlattenQueryString()}", UriKind.Relative);
var result = await HTTPClient.GetAsync(requestUri);
//result.EnsureSuccessStatusCode();
var json = await result.Content.ReadAsStringAsync();
return(Search.FromJson(json));
}
public async Task <IActionResult> ListHelpRequests([FromQuery] PaginationOptions paginationOptions, [FromQuery] bool my = false, [FromQuery] bool accepted = false)
{
try
{
if (accepted)
{
return(Ok(await _mediator.Send(new ListAcceptedHelpRequestsQuery()
{
PhoneNumber = PhoneNumber,
Page = paginationOptions.Page,
PageSize = paginationOptions.PageSize
})));
}
if (my)
{
return(Ok(await _mediator.Send(new ListOwnHelpRequestsQuery()
{
PhoneNumber = PhoneNumber,
Page = paginationOptions.Page,
PageSize = paginationOptions.PageSize
})));
}
return(Ok(await _mediator.Send(new ListHelpRequestsQuery()
{
PhoneNumber = PhoneNumber,
Page = paginationOptions.Page,
PageSize = paginationOptions.PageSize
})));
}
catch
{
return(BadRequest());
}
}
/// <summary>
/// Categories pagination
/// </summary>
/// <param name="page">current page</param>
/// <param name="searchQuery">search query</param>
/// <param name="pageSize">pageSize parametar is fixed(user cant change it)
/// in this case so we dont need to check if pagesize is negative</param>
/// <returns>Instnace of IPaginationModel</returns>
public virtual async Task <IPaginationModel <Category> > GetCategoriesAsync(int?page, string searchQuery, int pageSize)
{
//Validate input
int currentPage = page ?? 1;
string search = searchQuery ?? string.Empty;
//Get number of instances from database that containts specific text
var firstSpecification = new CategorySpecification(search);
var numberOfCategories = await repository.CountAsync(firstSpecification);
//Is requested page valid ?
currentPage = maker.CheckPageLimits(currentPage, numberOfCategories, pageSize);
//Get required instances from database
int skip = maker.Skip(currentPage, pageSize);
int take = pageSize;
var secondSpecification = new CategorySpecification(skip, take, search);
var listOfCategories = await repository.ListAsync(secondSpecification);
//Return instance of IPaginationModel
var pgOptions = new PaginationOptions(currentPage, numberOfCategories, pageSize);
return(maker.PreparePaginationModel(listOfCategories, pgOptions));
}
/// <summary>
/// Create an optionally paginated item set.
/// </summary>
/// <param name="items">The set of items. If paging is enabled and total count is not supplied, this set will be paged.</param>
/// <param name="options">Options for pagination. Use PaginationOptions.None if pagination should not be performed.</param>
/// <param name="totalCount">Optionally pass the count of the total set if pagination was already performed.</param>
public ItemSet(IEnumerable <T> items, PaginationOptions options, int?totalCount = null)
{
items.EnsureNotNull(nameof(items));
options.EnsureNotNull(nameof(options));
var allItems = items.ToList();
IsPagingEnabled = options.IsPagingEnabled;
if (IsPagingEnabled)
{
TotalCount = totalCount ?? allItems.Count;
Items = totalCount.HasValue ? allItems : allItems.GetPage(options);
Page = options.Page;
Take = options.Take;
}
else
{
Items = allItems;
TotalCount = allItems.Count;
Page = 1;
Take = Math.Max(1, TotalCount);
}
}
public IActionResult Index(PagedListResultViewModel <UserListViewModel> parameters, string search)
{
Services.Users.DTOs.UserFilter filter = null;
if (!string.IsNullOrWhiteSpace(search))
{
filter = Newtonsoft.Json.JsonConvert.DeserializeObject <Services.Users.DTOs.UserFilter>(search);
}
var pagination = new PaginationOptions();
if (parameters.Page > 0)
{
pagination.Page = parameters.Page;
pagination.PageSize = 10;
}
else
{
pagination.Page = 1;
pagination.PageSize = 10;
}
var result = _userService.GetListDTOPaged(pagination.Page, pagination.PageSize, null, filter).ToViewModel();
return(View(result));
}
public static IQueryable <TModel> ApplyOptions <TModel>(
this IQueryable <TModel> query,
IPaginationOptions options,
int maxItemsPerPage,
out IPaginationOptions appliedOptions)
where TModel : IQueryModel
{
if (options == null)
{
appliedOptions = null;
return(query.Take(maxItemsPerPage));
}
appliedOptions =
new PaginationOptions
{
ItemsPerPage = Math.Max(
Math.Min(options.ItemsPerPage, maxItemsPerPage), 1),
Page = Math.Max(options.Page, 1)
};
return(query.ApplyOptions(appliedOptions));
}
public IPagedList <User> GetAllUsers(PaginationOptions pagingOptions, UserSearchCriteria filter, WorkingUser workingUser, bool includeReferences = false)
{
var users = _userRepository.TableNoTracking;
if (includeReferences)
{
users = users
.IncludeTable(c => c.Department)
.IncludeTable(c => c.Location)
.IncludeTable(c => c.Role);
}
users = users.Where(FilterUsers(filter));
if (filter.RestrictedByRole && !workingUser.IsInRole(UserRole.HRManager, UserRole.HRAdmin))
{
users = users.Where(x => x.LocationId == workingUser.LocationId);
}
users = !string.IsNullOrEmpty(pagingOptions.Sort)
? users.SortBy(pagingOptions.SortExpression)
: users.OrderBy(c => c.Id);
return(new PagedList <User>(users, pagingOptions.PageIndex, pagingOptions.PageSize));
}
public async Task <List <TModel> > GetMultiple(TSearch searchOptions = default(TSearch), PaginationOptions paginationOptions = null)
{
return(_list.Where(t => GetMultiplePredicate(searchOptions)(t)).ToList());
}
public Func <TModel, bool> GetMultiplePredicate(TSearch searchOptions = default(TSearch), PaginationOptions paginationOptions = null)
{
Func <TModel, bool> predicate = model => { return(true); };
if (searchOptions != null)
{
if (!String.IsNullOrEmpty(searchOptions.Id))
{
Func <TModel, bool> prevpredicate = predicate;
predicate = model => { return(model.Id == searchOptions.Id); };
predicate += prevpredicate;
}
}
return(predicate);
}
public CityService(IUnitOfWork unitOfWork, IOptions <PaginationOptions> options)
{
_unitOfWork = unitOfWork;
_paginationOptions = options.Value;
}
/// <summary>
/// Base uri is html encoded by this function, do not pre-process
/// </summary>
/// <param name="baseUri"></param>
/// <param name="currentPage"></param>
/// <param name="maxPages"></param>
/// <returns></returns>
private string GeneratePagination(string baseUri, int pageLevel, int[] currentPage, long[] currentOffset, int maxPages, PaginationOptions options)
{
StringBuilder pagination = new StringBuilder();
bool comma = false;
bool skipped = false;
bool baseAmp = baseUri.Contains("?");
string ampSymbol = "?";
if (baseAmp)
{
ampSymbol = "&";
}
int page = 1;
if (pageLevel < currentPage.Length)
{
page = currentPage[pageLevel];
}
else
{
int[] oldPage = currentPage;
currentPage = new int[pageLevel + 1];
oldPage.CopyTo(currentPage, 0);
currentPage[pageLevel] = page;
}
if (core.IsMobile)
{
if (maxPages > 1)
{
// Previous
if (page > 1)
{
pagination.Append(string.Format("<a href=\"{0}p={1}\" data-role=\"button\" data-inline=\"true\">«</a>",
HttpUtility.HtmlEncode(baseUri + ampSymbol), page - 1));
}
else
{
pagination.Append("<a href=\"#\" class=\"ui-disabled\" data-role=\"button\" data-inline=\"true\">«</a>");
}
// First
pagination.Append(string.Format("<a href=\"{0}p={1}\" data-role=\"button\" data-inline=\"true\">{1}</a>",
HttpUtility.HtmlEncode(baseUri + ampSymbol), 1));
if (maxPages > 1)
{
// Select box
// Last
pagination.Append(string.Format("<a href=\"{0}p={1}\" data-role=\"button\" data-inline=\"true\">{1}</a>",
HttpUtility.HtmlEncode(baseUri + ampSymbol), maxPages));
}
// Next
if (page < maxPages)
{
pagination.Append(string.Format("<a href=\"{0}p={1}\" data-role=\"button\" data-inline=\"true\">»</a>",
HttpUtility.HtmlEncode(baseUri + ampSymbol), page + 1));
}
else
{
pagination.Append("<a href=\"#\" class=\"ui-disabled\" data-role=\"button\" data-inline=\"true\">»</a>");
}
}
}
else
{
if ((options & PaginationOptions.Normal) == PaginationOptions.Normal)
{
if (page > 2 || ((!AllFirstPage(pageLevel, currentPage)) && page > 1 && currentPage.Length > 1))
{
pagination.Append(string.Format("<a href=\"{0}{1}\">« Prev</a>",
HttpUtility.HtmlEncode(baseUri + ampSymbol), BuildPageAndOffset(pageLevel, currentPage, currentOffset, page - 1)));
comma = true;
}
else if (page > 1)
{
pagination.Append(string.Format("<a href=\"{0}\">« Prev</a>",
HttpUtility.HtmlEncode(baseUri)));
comma = true;
}
}
int firstCount = 3;
if ((options & PaginationOptions.Minimal) == PaginationOptions.Minimal)
{
firstCount = 1;
}
for (int i = 1; i <= maxPages; i++)
{
if (i != page)
{
if (i == 1)
{
if (comma)
{
pagination.Append(", ");
}
else
{
comma = true;
}
pagination.Append(string.Format("<a href=\"{0}\">{1}</a>",
HttpUtility.HtmlEncode(baseUri), i));
}
else
{
if ((i > firstCount && i < page - (firstCount - 1)) || (i < maxPages - 2 && i > page + 2))
{
skipped = true;
continue;
}
if (comma)
{
pagination.Append(", ");
}
else
{
comma = true;
}
if (skipped)
{
pagination.Append("... ");
skipped = false;
}
pagination.Append(string.Format("<a href=\"{0}{1}\">{2}</a>",
HttpUtility.HtmlEncode(baseUri + ampSymbol), BuildPageAndOffset(pageLevel, currentPage, currentOffset, i), i));
}
}
else // current page
{
if (comma)
{
pagination.Append(", ");
}
else
{
comma = true;
}
pagination.Append(string.Format("<strong>{0}</strong>",
i));
}
}
if ((options & PaginationOptions.Normal) == PaginationOptions.Normal)
{
if (page < maxPages)
{
pagination.Append(", ");
pagination.Append(string.Format("<a href=\"{0}{1}\">Next »</a>",
HttpUtility.HtmlEncode(baseUri + ampSymbol), BuildPageAndOffset(pageLevel, currentPage, currentOffset, page + 1)));
}
}
}
return pagination.ToString();
}
