public DynamicPaginator(DocumentFile activeDocument, Paginator Paginator, Site site)
: base(null)
{
this.ActiveDocument = activeDocument;
this.Paginator = Paginator;
this.Site = site;
}
private static void DisplayResults(IEnumerable<Product> result, int itemsOnPage)
{
Paginator<Product> paginator = new Paginator<Product>(result, itemsOnPage);
if (paginator.PageCount > 0)
{
int currentPage = 0;
int selectedPage = 1;
string input;
bool quit = false;
Console.WriteLine(" Id Name Price Quant. Disc,% Total");
Console.WriteLine(new string('-', Console.WindowWidth - 1));
int currentLineCursor = Console.CursorTop;
int inputLineCursor = 0;
while (!quit)
{
if (currentPage != selectedPage)
{
currentPage = selectedPage;
Console.SetCursorPosition(0, currentLineCursor);
App.PrintResults(paginator.GetPage(currentPage), itemsOnPage);
Console.WriteLine("\nPage {0} of {1}", currentPage, paginator.PageCount);
inputLineCursor = Console.CursorTop;
}
Console.SetCursorPosition(0, inputLineCursor);
Console.WriteLine(new string(' ', Console.WindowWidth - 1)); // Clean the input area
Console.SetCursorPosition(0, inputLineCursor);
Console.Write("Enter the page number or 'q' to quit: ");
input = Console.ReadLine();
if (!input.Equals("q"))
{
if (!int.TryParse(input, out selectedPage)
|| selectedPage < 0
|| selectedPage > paginator.PageCount)
{
selectedPage = currentPage;
StandartMessage.DisplayError(
string.Format("Wrong input. Enter the number of a page (from {0} to {1})",
1, paginator.PageCount));
}
}
else
{
quit = true;
}
}
}
else
{
Console.WriteLine("No product found.");
Console.WriteLine("\nPress any key to continue...");
Console.ReadKey();
}
}
public void HasNotPages()
{
string hql = "from Foo where Name = '-N123'";
PaginableRowsCounterQuery<Foo> pag =
new PaginableRowsCounterQuery<Foo>(LastOpenedSession, new DetachedQuery(hql));
Paginator<Foo> ptor = new Paginator<Foo>(3, pag);
Assert.AreEqual(false, ptor.HasPages);
Assert.AreEqual(false, ptor.HasPrevious);
Assert.AreEqual(false, ptor.HasNext);
Assert.AreEqual(0, ptor.RowsCount.Value);
//throw ArgumentOutOfRangeException
IList<Foo> lpage = ptor.GetPage(1);
}
public void AutoCalcPages()
{
Paginator<NoFoo> ptor =
new Paginator<NoFoo>(3, new NoFooPaginable(LastOpenedSession, new DetachedNamedQuery("NoFoo.All")), true);
// check init state
Assert.AreEqual(1, ptor.FirstPageNumber);
Assert.AreEqual(5, ptor.LastPageNumber);
Assert.AreEqual(1, ptor.CurrentPageNumber);
Assert.IsTrue(ptor.HasNext);
Assert.IsFalse(ptor.HasPrevious);
IList<NoFoo> lpage = ptor.GetLastPage();
Assert.AreEqual(3, lpage.Count);
Assert.AreEqual(5, ptor.CurrentPageNumber);
Assert.IsFalse(ptor.HasNext);
Assert.IsTrue(ptor.HasPrevious);
// Partial last page
ptor =
new Paginator<NoFoo>(10, new NoFooPaginable(LastOpenedSession, new DetachedNamedQuery("NoFoo.All")),
true);
Assert.AreEqual(2, ptor.LastPageNumber);
}
public ActionResult Index(SearchViewModel searchModel)
{
WinterGearRepository gearRepository = new WinterGearRepository(_dataSettings);
IEnumerable <WinterGear> gearItems;
using (gearRepository)
{
gearItems = gearRepository.SelectAll() as IList <WinterGear>;
}
if (!string.IsNullOrWhiteSpace(searchModel.SearchCriteria))
{
gearItems = gearItems.Where(item => item.Name.ToUpper().Contains(searchModel.SearchCriteria.ToUpper()));
}
if (!string.IsNullOrWhiteSpace(searchModel.GearTypeFilter))
{
gearItems = gearItems.Where(item => item.GearType == searchModel.GearTypeFilter);
}
switch (searchModel.SortOrder)
{
case "name":
// order names ascending
gearItems = gearItems.OrderBy(i => i.Name);
break;
case "condition":
// order condition descending
gearItems = gearItems.OrderByDescending(i => i.Condition);
break;
case "weight":
// order weight ascending
gearItems = gearItems.OrderBy(i => i.Weight);
break;
case "gearType":
// order gearType ascending
gearItems = gearItems.OrderBy(i => i.GearType);
break;
default:
// order id ascending
gearItems = gearItems.OrderBy(i => i.Id);
break;
}
if (searchModel.FlipOrder)
{
gearItems = gearItems.Reverse();
}
int pageNumber = (searchModel.PageNumber ?? 1);
int itemsPerPage = (searchModel.PageSize ?? 10);
IPaginator <WinterGear> paginator = new Paginator <WinterGear>(gearItems, itemsPerPage, pageNumber);
ViewBag.paginator = paginator;
ViewBag.sortOrder = searchModel.SortOrder;
ViewBag.flipOrder = searchModel.FlipOrder;
ViewBag.gearTypes = listOfGearTypes();
ViewBag.gearTypeFilter = searchModel.GearTypeFilter;
ViewBag.searchCriteria = searchModel.SearchCriteria;
ViewBag.isSearch = true;
return(View(paginator.GetItems()));
}
public void WithValidData_ReturnTotalCount()
{
var stu = new Paginator(100, 10);
Assert.AreEqual(100, stu.TotalCount);
}
public void CreateFromEnumerable() => Paginator.Create(intEnumerable);
public void CreateStable() => Paginator.CreateStable(intArray);
private async Task Search()
{
if (string.IsNullOrWhiteSpace(SearchText) && !IsAuthorSearch)
{
ModelState.AddModelError(nameof(SearchText), LanguageProvider.Errors[GetLanguage(), "MISSING_REQUIRED_FIELD"]);
return;
}
var connectionTask = Context.GetDbConnectionAsync();
var searchableForumsTask = GetUnrestrictedForums(ForumId);
await Task.WhenAll(connectionTask, searchableForumsTask);
var connection = await connectionTask;
var searchableForums = await searchableForumsTask;
var searchTask = connection.QueryAsync <PostDto>(
@"WITH ranks AS (
SELECT DISTINCT u.user_id,
COALESCE(r1.rank_id, r2.rank_id) AS rank_id,
COALESCE(r1.rank_title, r2.rank_title) AS rank_title
FROM phpbb_users u
JOIN phpbb_groups g ON u.group_id = g.group_id
LEFT JOIN phpbb_ranks r1 ON u.user_rank = r1.rank_id
LEFT JOIN phpbb_ranks r2 ON g.group_rank = r2.rank_id
)
SELECT p.forum_id,
p.topic_id,
p.post_id,
p.post_subject,
p.post_text,
case when p.poster_id = @ANONYMOUS_USER_ID
then p.post_username
else a.username
end as author_name,
p.poster_id as author_id,
p.bbcode_uid,
p.post_time,
a.user_colour as author_color,
a.user_avatar as author_avatar,
p.post_edit_count,
p.post_edit_reason,
p.post_edit_time,
e.username as post_edit_user,
r.rank_title as author_rank,
p.poster_ip as ip
FROM phpbb_posts p
JOIN phpbb_users a ON p.poster_id = a.user_id
LEFT JOIN phpbb_users e ON p.post_edit_user = e.user_id
LEFT JOIN ranks r ON a.user_id = r.user_id
WHERE p.forum_id IN @searchableForums
AND (@topicId = 0 OR @topicId = p.topic_id)
AND (@authorId = 0 OR @authorId = p.poster_id)
AND (@searchText IS NULL OR MATCH(p.post_text) AGAINST(@searchText IN BOOLEAN MODE))
UNION
SELECT p.forum_id,
p.topic_id,
p.post_id,
p.post_subject,
p.post_text,
case when p.poster_id = @ANONYMOUS_USER_ID
then p.post_username
else a.username
end as author_name,
p.poster_id as author_id,
p.bbcode_uid,
p.post_time,
a.user_colour as author_color,
a.user_avatar as author_avatar,
p.post_edit_count,
p.post_edit_reason,
p.post_edit_time,
e.username as post_edit_user,
r.rank_title as author_rank,
p.poster_ip as ip
FROM phpbb_posts p
JOIN phpbb_users a ON p.poster_id = a.user_id
LEFT JOIN phpbb_users e ON p.post_edit_user = e.user_id
LEFT JOIN ranks r ON a.user_id = r.user_id
WHERE p.forum_id IN @searchableForums
AND (@topicId = 0 OR @topicId = p.topic_id)
AND (@authorId = 0 OR @authorId = p.poster_id)
AND (@searchText IS NULL OR MATCH(p.post_subject) AGAINST(@searchText IN BOOLEAN MODE))
ORDER BY post_time DESC
LIMIT @skip, 14;",
new
{
Constants.ANONYMOUS_USER_ID,
topicId = TopicId ?? 0,
AuthorId,
searchText = string.IsNullOrWhiteSpace(SearchText) ? null : HttpUtility.UrlDecode(SearchText),
skip = (PageNum - 1) * Constants.DEFAULT_PAGE_SIZE,
searchableForums
});
var countTask = connection.ExecuteScalarAsync <int>(
@"WITH search_stmt AS (
SELECT p.post_id
FROM phpbb_posts p
WHERE p.forum_id IN @searchableForums
AND (@topicId = 0 OR @topicId = p.topic_id)
AND (@authorId = 0 OR @authorId = p.poster_id)
AND (@searchText IS NULL OR MATCH(p.post_text) AGAINST(@searchText IN BOOLEAN MODE))
UNION
SELECT p.post_id
FROM phpbb_posts p
WHERE p.forum_id IN @searchableForums
AND (@topicId = 0 OR @topicId = p.topic_id)
AND (@authorId = 0 OR @authorId = p.poster_id)
AND (@searchText IS NULL OR MATCH(p.post_subject) AGAINST(@searchText IN BOOLEAN MODE))
)
SELECT count(1) as total_count
FROM search_stmt;",
new
{
topicId = TopicId ?? 0,
AuthorId,
searchText = string.IsNullOrWhiteSpace(SearchText) ? null : HttpUtility.UrlDecode(SearchText),
searchableForums
});
await Task.WhenAll(searchTask, countTask);
Posts = (await searchTask).AsList();
TotalResults = await countTask;
Attachments = await(
from a in Context.PhpbbAttachments.AsNoTracking()
where Posts.Select(p => p.PostId).Contains(a.PostMsgId)
select a).ToListAsync();
Paginator = new Paginator(count: TotalResults.Value, pageNum: PageNum, link: GetSearchLinkForPage(PageNum + 1), topicId: null);
}
public MoveToCommandImpl(Paginator paginator)
{
_Paginator = paginator;
}
public void GetPage()
{
CopyArray();
Paginator.CreateDirect(intArrayCopy).GetPage(0, 100);
}
// Do printing to a set of bitmaps using the XPS/WPF path. This is used for testing support.
public System.Windows.Media.Imaging.BitmapSource[] PrintXpsBitmaps(float dpi)
{
// Set up and position everything.
printingToBitmaps = true;
printPreviewInProgress = false;
SetupPrinting();
if (totalPages <= 0)
return new System.Windows.Media.Imaging.BitmapSource[0];
PrintEventArgs printArgs = new PrintEventArgs();
List<System.Windows.Media.Imaging.BitmapSource> bitmapList = new List<System.Windows.Media.Imaging.BitmapSource>();
BeginPrint(this, printArgs);
float paperWidth = pageSettings.PaperSize.Width, paperHeight = pageSettings.PaperSize.Height;
if (pageSettings.Landscape) {
float temp = paperWidth; paperWidth = paperHeight; paperHeight = temp;
}
var paginator = new Paginator(this, 0, new SizeF(paperWidth, paperHeight), pageSettings.Margins, dpi, false);
for (int pageNumber = 0; pageNumber < paginator.PageCount; ++pageNumber) {
DocumentPage docPage = paginator.GetPage(pageNumber);
paperWidth = (float)PointsToHundreths(docPage.Size.Width);
paperHeight = (float)PointsToHundreths(docPage.Size.Height);
var bitmapNew = new System.Windows.Media.Imaging.RenderTargetBitmap(
(int) Math.Round(paperWidth * dpi / 100F),
(int) Math.Round(paperHeight * dpi / 100F),
dpi, dpi, System.Windows.Media.PixelFormats.Pbgra32);
bitmapNew.Render(docPage.Visual);
bitmapNew.Freeze();
bitmapList.Add(bitmapNew);
}
EndPrint(this, printArgs);
return bitmapList.ToArray();
}
public async Task <List <TrackingModel> > GetTrackingsAsync(Paginator paginator)
{
return(await _trackingRepository.GetTrackingsAsync(paginator));
}
/// <summary>
/// Generates a paginator for the current MVC view
/// </summary>
/// <param name="html">The HTML.</param>
/// <param name="currentPage">The current page.</param>
/// <param name="totalPages">The total pages.</param>
/// <param name="routeValues">The route values.</param>
/// <returns>HTML paginator markup</returns>
public static IHtmlString Paginator(this HtmlHelper html, int currentPage, int totalPages, object routeValues)
{
var paginator = new Paginator(html.ViewContext, currentPage, totalPages, routeValues);
return(paginator.Generate());
}
// GET: Albums
public async Task <IActionResult> Index(AlbumSearchViewModel searchModel)
{
int?emphasisHeaderNum = null;
IEnumerable <Album> albums = await _context.Albums.ToListAsync();
// get current user
ApplicationUser currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
if (currentUser == null)
{
throw new Exception("No current user.");
}
// filter by current owner
albums = albums.Where(s => s.ArtistId == currentUser.Id);
// search criteria
if (!string.IsNullOrWhiteSpace(searchModel.SearchCriteria))
{
albums = albums.Where(item => item.Name.ToUpper().Contains(searchModel.SearchCriteria.ToUpper()));
}
// date filtering
// start date
if (!string.IsNullOrEmpty(searchModel.StartDate))
{
DateTime startDate = DateTime.Parse(searchModel.StartDate);
albums = albums.Where(item => item.ReleaseDate.Value.CompareTo(startDate) >= 0);
}
// end date
if (!string.IsNullOrEmpty(searchModel.EndDate))
{
DateTime endDate = DateTime.Parse(searchModel.EndDate);
albums = albums.Where(item => item.ReleaseDate.Value.CompareTo(endDate) <= 0);
}
// sort order
switch (searchModel.SortOrder)
{
case "album-name":
albums = albums.OrderBy(s => s.Name);
emphasisHeaderNum = 0;
break;
case "artist":
albums = albums.OrderBy(s => s.ArtistName);
emphasisHeaderNum = 1;
break;
// case "album-name":
// albums = albums.OrderBy(s => {
// if (s.Album != null) return s.Album.Name;
// else return "Unknown Album";
// });
// emphasisHeaderNum = 2;
// break;
case "release-date":
albums = albums.OrderBy(s => {
if (s.ReleaseDate != null)
{
return(s.ReleaseDate.Value.ToString());
}
else
{
return("");
}
});
emphasisHeaderNum = 2;
break;
default:
albums = albums.OrderBy(s => s.Id);
break;
}
// flip order
if (searchModel.FlipOrder)
{
albums = albums.Reverse();
}
// pagination
int pageNumber = (searchModel.PageNumber ?? 1);
int pageSize = (searchModel.PageSize ?? 10);
IPaginator <Album> paginator = new Paginator <Album>(albums, pageSize, pageNumber);
ViewData["paginator"] = paginator;
ViewData["searchSettings"] = searchModel;
ViewData["emphasisHeaderNum"] = emphasisHeaderNum;
// send the paginated items to the view
return(View(paginator.GetItems()));
}
/// <summary> /// 获取答案列表 /// </summary> /// <param name="pager"></param> /// <returns></returns> public abstract Task <Resp> GetListAsync(Paginator pager);
public async Task <Resp> GetDetailAsync(int questionId, Paginator page)
{
if (!int.TryParse(page["currentUserId"], out int currentUserId))
{
currentUserId = 0;
}
await using var db = new YGBContext();
DB.Tables.Question question = await db.Questions.Include(q => q.Asker)
.ThenInclude(asker => asker.Avatar)
.Include(q => q.QuestionComments)
.FirstOrDefaultAsync(q => q.Id == questionId);
if (question is null)
{
return(Resp.Fault(Resp.NONE, Question.QUESTION_NO_EXIST));
}
// 被删除的答案无法查看
if (question.State == (int)Question.QuestionState.Delete)
{
return(Resp.Fault(Resp.NONE, "该提问暂时无法查看"));
}
// 如果不是本人，则不能看启用之外的提问
if (currentUserId != question.Asker.Id)
{
if (question.State != (int)Question.QuestionState.Enabled)
{
return(Resp.Fault(Resp.NONE, "该提问暂时无法查看"));
}
}
Answers.Hub answerHub = new Answers.Hub();
// 获取第一页的答案分页
Answers.List.AnswerList answers = answerHub.GetAnswers(Answers.Hub.AnswerSource.Question);
(page.List, page.TotalRows) = await answers.GetAnswersAsync(questionId, page.Index, page.Size, Answers.Answer.AnswerState.Enabled);
Results.QuestionDetailForClient detail = new Results.QuestionDetailForClient
{
Id = question.Id,
Title = question.Title,
Description = question.Description,
Tags = question.Tags.Split(',', '，'),
Votes = question.Votes,
Views = question.Views,
Actived = question.Actived.ToStandardString(),
CreateDate = question.CreateDate.ToStandardString(),
State = Share.KeyValue <int, string> .Create(question.State, question.State.GetDescription <Question.QuestionState>()),
User = new Clients.Results.UserIntro
{
Id = question.Asker.Id,
Account = question.Asker.Name,
Avatar = question.Asker.Avatar.Thumbnail
},
Page = page,
Comments = question.QuestionComments.Take(5).Select(c => c.Content).ToArray(),
IsSelf = question.AskerId == currentUserId
};
question.Views++;
question.Actived = DateTimeOffset.Now;
await db.SaveChangesAsync();
return(Resp.Success(detail, ""));
}
public void SimplePaginator()
{
// with "AutoCalcPages mode" DISABLED
Paginator<NoFoo> ptor =
new Paginator<NoFoo>(3, new NoFooPaginable(LastOpenedSession, new DetachedNamedQuery("NoFoo.All")));
// check init state
Assert.AreEqual(1, ptor.FirstPageNumber);
Assert.IsFalse(ptor.LastPageNumber.HasValue);
Assert.IsFalse(ptor.CurrentPageNumber.HasValue);
Assert.IsTrue(ptor.HasNext);
Assert.IsFalse(ptor.HasPrevious);
IList<NoFoo> lpage = ptor.GetFirstPage();
Assert.AreEqual(3, lpage.Count);
Assert.AreEqual(1, ptor.CurrentPageNumber);
// check lastPage sill unavailable
Assert.IsFalse(ptor.LastPageNumber.HasValue);
}
public async Task <IActionResult> Pages()
{
var count = await _context.Questions.CountAsync();
return(Ok(Paginator.Pages(count)));
}
public void WithSelfCounter()
{
DetachedQuery dq = new DetachedQuery("from Foo f where f.Name like :p1");
dq.SetString("p1", "%1_");
IPaginable<Foo> fp = new PaginableRowsCounterQuery<Foo>(LastOpenedSession, dq);
Paginator<Foo> ptor = new Paginator<Foo>(2, fp);
Assert.IsTrue(ptor.AutoCalcPages);
Assert.AreEqual(3, ptor.LastPageNumber);
// check page 2
IList<Foo> lpage = ptor.GetPage(2);
Assert.AreEqual(2, lpage.Count);
Assert.AreEqual(2, ptor.CurrentPageNumber);
Assert.AreEqual("N12", lpage[0].Name);
Assert.AreEqual("N13", lpage[1].Name);
}
public bool RemovePaginator(Paginator paginator) => _paginators.Remove(paginator);
public PrintDocumentHandler()
{
Control = new Paginator {
Handler = this
};
}
//
// GET: /Calle/
public ActionResult Index(int pageIndex = 0, int pageSize = 10, string quickFilter = "")
{
var calles = (quickFilter == "") ? this._calleService.GetCalles() : this._calleService.BuscarCalles(quickFilter);
var Paginator = new Paginator<Core.Models.Calle>(calles, pageIndex, pageSize);
if (quickFilter != "")
Paginator.RouteQuery = new Dictionary<string, object>() {
{"quickFilter", quickFilter}
};
Paginator.BaseUrl = Url.RouteUrl(this.RouteData.Values);
this.ViewBag.QuickFilter = quickFilter;
return View("Index", Paginator);
}
public static async Task <ValidationResult> Validate(string baseUrl, string id, APIValidatorSettings settings = null)
{
settings = settings ?? new APIValidatorSettings();
if (string.IsNullOrEmpty(baseUrl))
{
return(new ValidationResult()
{
Error = "Invalid base URL"
});
}
if (!Uri.TryCreate(baseUrl, UriKind.Absolute, out _))
{
return(new ValidationResult()
{
Error = "Invalid base URL"
});
}
WebServiceReader webServiceReader = new WebServiceReader(settings);
var result = new ValidationResult();
try
{
var paginator = new Paginator();
var paginationResults = await paginator.GetServices(baseUrl, id, webServiceReader, settings);
result.IsUp = true;
result.IsServiceFound = paginationResults.Items.Count > 0;
if (paginationResults.Items.Count == 0)
{
result.HasPagination = false;
}
if (!paginationResults.HasAllowOrigin)
{
result.Warnings.Add("The 'Access-Control-Allow-Origin: *' response header is missing this limits how the API can be read.");
}
result.HasDetailPage = (paginationResults.MissingDetailIDs.Count != paginationResults.Items.Count || paginationResults.Items.Count == 0);
result.MissingPaginationMetaData = paginationResults.MissingPaginationMetaData;
result.HasInvalidTotalPages = paginationResults.HasInvalidTotalPages;
if (paginationResults.Items.Count > 0)
{
var items = paginationResults.Items;
result.RandomServiceIdentifier = items.ElementAt(rand.Next(items.Count)).id;
}
ResourceReader resourceReader = new ResourceReader();
List <string> resourceNames = await resourceReader.GetResourceNames().ConfigureAwait(false);
List <IFeatureTest> featureTests = new List <IFeatureTest>();
Dictionary <string, Resource> allRequired = GetFields(await resourceReader.GetResources().ConfigureAwait(false));
foreach (var item in paginationResults.Items)
{
ValidateItems(item, resourceNames, allRequired);
featureTests = FindFeatureTests(item, resourceNames, featureTests, allRequired);
}
foreach (KeyValuePair <string, Resource> kvp in allRequired)
{
result.AddResourceCount(kvp.Value);
if (!kvp.Value.Exists)
{
continue;
}
foreach (Field field in kvp.Value.Fields)
{
if (field.IsRequired && field.Count == 0)
{
result.MissingRequiredFields.Add(kvp.Key + "." + field.Name);
}
if (field.IsUnique && field.Values.Distinct().Count() != field.Values.Count())
{
result.InvalidUniqueFields.Add(kvp.Key + "." + field.Name);
}
if (!field.IsValidFormat())
{
result.InvalidFormats.Add(kvp.Key + "." + field.Name + " should be in " + field.Format + " format");
}
if (!field.IsValidDataType())
{
result.InvalidDataTypes.Add(kvp.Key + "." + field.Name + " should be in the " + field.DataType + " data type");
}
if (!field.IsValidEnum())
{
result.InvalidValues.Add(kvp.Key + "." + field.Name + " should be one of the following values " + string.Join(", ", field.AllowedValues));
}
}
}
result.Level2Results = await RunLevel2Tests(baseUrl, result, featureTests, webServiceReader);
}
catch (ServiceDirectoryException e)
{
result.Error = e.Message;
result.SetException(e);
}
catch (Exception e)
{
result.Error = e.Message;
result.SetException(e);
}
try
{
result.PerformFinalReview();
return(result);
}
catch (Exception e)
{
result.Error = e.Message;
result.SetException(e);
return(result);
}
}
public void Pagination_Check10of100_MustReturnValidPageAndRowCounts()
{
// prepare 100 ints
List<int> theList = new List<int>();
for (int i = 0; i < 100; i++)
{
theList.Add(i);
}
var p = new Paginator<int>(theList);
p.RowCount = 10;
p.PageNumber = 1;
Assert.AreEqual(p.TotalPages, 10); // should be 10 because 100 / 10 = 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // Rowcount should be 10 in this test
Assert.AreEqual(p.Rows[0], 0);
// go to next page
p.PageNumber = 2;
Assert.AreEqual(p.TotalPages, 10); // should still be 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // should still be 10 in this test
Assert.AreEqual(p.Rows[0], 10);
// go to next page
p.PageNumber = 3;
Assert.AreEqual(p.TotalPages, 10); // should still be 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // should still be 10 in this test
Assert.AreEqual(p.Rows[0], 20);
// go to next page
p.PageNumber = 4;
Assert.AreEqual(p.TotalPages, 10); // should still be 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // should still be 10 in this test
Assert.AreEqual(p.Rows[0], 30);
// go to next page
p.PageNumber = 5;
Assert.AreEqual(p.TotalPages, 10); // should still be 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // should still be 10 in this test
Assert.AreEqual(p.Rows[0], 40);
// go to next page
p.PageNumber = 6;
Assert.AreEqual(p.TotalPages, 10); // should still be 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // should still be 10 in this test
Assert.AreEqual(p.Rows[0], 50);
// go to next page
p.PageNumber = 7;
Assert.AreEqual(p.TotalPages, 10); // should still be 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // should still be 10 in this test
Assert.AreEqual(p.Rows[0], 60);
// go to next page
p.PageNumber = 8;
Assert.AreEqual(p.TotalPages, 10); // should still be 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // should still be 10 in this test
Assert.AreEqual(p.Rows[0], 70);
// go to next page
p.PageNumber = 9;
Assert.AreEqual(p.TotalPages, 10); // should still be 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // should still be 10 in this test
Assert.AreEqual(p.Rows[0], 80);
// go to next page
p.PageNumber = 10;
Assert.AreEqual(p.TotalPages, 10); // should still be 10
Assert.AreEqual(p.TotalRows, 100); // should still be 100
Assert.AreEqual(p.RowCount, p.Rows.Count); // should still be 10 in this test
Assert.AreEqual(p.Rows[0], 90);
}
public void CreateFromArray() => Paginator.Create(intArray);
public void NullChecks()
{
string[] nullArray = null, validArray = Array.Empty <string>();
Comparer <string> nullComparer = null, validComparer = Comparer <string> .Default;
Func <string, string> nullKeySelector = null, validKeySelector = x => x;
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(nullArray, 0, 0));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(nullArray, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(validArray, nullComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(nullArray, 0, 0, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(validArray, 0, 0, nullComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(nullArray, validArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(validArray, nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(nullArray, validArray, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(validArray, nullArray, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirect(validArray, validArray, nullComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirectNoNulls(nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirectNoNulls(nullArray, 0, 0));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirectNoNulls(nullArray, validArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateDirectNoNulls(validArray, nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(nullArray, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(validArray, nullComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(nullArray, validArray));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(validArray, nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(nullArray, validArray, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(validArray, nullArray, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(validArray, validArray, nullComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(nullArray, validKeySelector));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(validArray, nullKeySelector));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(nullArray, validKeySelector, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(validArray, nullKeySelector, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.Create(validArray, validKeySelector, nullComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateNoNulls(nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateNoNulls(nullArray, validArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateNoNulls(validArray, nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateNoNulls(nullArray, validKeySelector));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateNoNulls(validArray, nullKeySelector));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(nullArray, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(validArray, nullComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(nullArray, validArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(validArray, nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(nullArray, validArray, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(validArray, nullArray, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(validArray, validArray, nullComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(nullArray, validKeySelector));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(validArray, nullKeySelector));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(nullArray, validKeySelector, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(validArray, nullKeySelector, validComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStable(validArray, validKeySelector, nullComparer));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStableNoNulls(nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStableNoNulls(nullArray, validArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStableNoNulls(validArray, nullArray));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStableNoNulls(nullArray, validKeySelector));
Assert.Throws <ArgumentNullException>(() => Paginator.CreateStableNoNulls(validArray, nullKeySelector));
}
public void CreateDirect() => Paginator.CreateDirect(intArray);
private void ProcessFile(string outputDirectory, Page page, Page previous, Page next, bool skipFileOnError, string relativePath = "")
{
if (string.IsNullOrWhiteSpace(relativePath))
{
relativePath = MapToOutputPath(page.File);
}
page.OutputFile = Path.Combine(outputDirectory, relativePath);
var extension = Path.GetExtension(page.File);
if (extension.IsImageFormat())
{
CreateOutputDirectory(page.OutputFile);
CopyFileIfSourceNewer(page.File, page.OutputFile, true);
return;
}
if (page is NonProcessedPage)
{
CreateOutputDirectory(page.OutputFile);
CopyFileIfSourceNewer(page.File, page.OutputFile, true);
return;
}
if (extension.IsMarkdownFile() || extension.IsRazorFile())
{
page.OutputFile = page.OutputFile.Replace(extension, ".html");
}
var pageContext = PageContext.FromPage(Context, page, outputDirectory, page.OutputFile);
pageContext.Previous = previous;
pageContext.Next = next;
var pageContexts = new List <PageContext> {
pageContext
};
object paginateObj;
if (page.Bag.TryGetValue("paginate", out paginateObj))
{
var paginate = Convert.ToInt32(paginateObj);
var totalPages = (int)Math.Ceiling(Context.Posts.Count / Convert.ToDouble(paginateObj));
var paginator = new Paginator(Context, totalPages, paginate, 1);
pageContext.Paginator = paginator;
var paginateLink = "/page/:page/index.html";
if (page.Bag.ContainsKey("paginate_link"))
{
paginateLink = Convert.ToString(page.Bag["paginate_link"]);
}
var prevLink = page.Url;
for (var i = 2; i <= totalPages; i++)
{
var newPaginator = new Paginator(Context, totalPages, paginate, i)
{
PreviousPageUrl = prevLink
};
var link = paginateLink.Replace(":page", Convert.ToString(i));
paginator.NextPageUrl = link;
paginator = newPaginator;
prevLink = link;
var path = Path.Combine(outputDirectory, link.ToRelativeFile());
if (path.EndsWith(FileSystem.Path.DirectorySeparatorChar.ToString()))
{
path = Path.Combine(path, "index.html");
}
var context = new PageContext(pageContext)
{
Paginator = newPaginator, OutputPath = path
};
context.Bag["url"] = link;
pageContexts.Add(context);
}
}
foreach (var context in pageContexts)
{
var metadata = page.Bag;
var failed = false;
var excerptSeparator = context.Bag.ContainsKey("excerpt_separator")
? context.Bag["excerpt_separator"].ToString()
: Context.ExcerptSeparator;
try
{
context.Content = RenderContent(page.File, RenderTemplate(context.Content, context));
context.FullContent = context.Content;
context.Bag["excerpt"] = GetContentExcerpt(context.Content, excerptSeparator);
}
catch (Exception ex)
{
if (!skipFileOnError)
{
var message = string.Format("Failed to process {0}, see inner exception for more details", context.OutputPath);
throw new PageProcessingException(message, ex);
}
Console.WriteLine(@"Failed to process {0}: {1}", context.OutputPath, ex);
continue;
}
while (metadata.ContainsKey("layout"))
{
var layout = metadata["layout"];
if ((string)layout == "nil" || layout == null)
{
break;
}
string path;
if (metadata.ContainsKey("layout_is_path") &&
"true".Equals(metadata["layout_is_path"].ToString(), StringComparison.InvariantCultureIgnoreCase)
)
{
path = layout.ToString();
}
else
{
path = FindLayoutPath(layout.ToString());
}
if (path == null)
{
break;
}
try
{
metadata = ProcessTemplate(context, path);
}
catch (Exception ex)
{
if (!skipFileOnError)
{
var message = string.Format("Failed to process layout {0} for {1}, see inner exception for more details", layout, context.OutputPath);
throw new PageProcessingException(message, ex);
}
Console.WriteLine(@"Failed to process layout {0} for {1} because '{2}'. Skipping file", layout, context.OutputPath, ex.Message);
failed = true;
break;
}
}
if (failed)
{
continue;
}
CreateOutputDirectory(context.OutputPath);
FileSystem.File.WriteAllText(context.OutputPath, context.FullContent);
}
}
/// <summary>
/// <see cref="AsyncRequest.Cancel"/>
/// </summary>
internal override void Cancel()
{
Paginator.OnGetPageCompleted(new GetPageCompletedEventArgs(null, PageNumber, null, true, UserState));
}
public virtual void setPaginator(Paginator paginator)
{
this.paginator = paginator;
}
public async Task <IEnumerable <CustomerUserDto> > GetCustomersWithPagination([FromBody] PaginationTransferObject paginationTransfer)
{
var res = Paginator.GetPageInterval(paginationTransfer);
return(await _customerUnitOfWork.CustomerRepository.GetCustomersPaged(res.From, res.To, paginationTransfer.PageSize));
}
/// <summary>
/// Construct previous and next links for collections pagination.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="paginator"></param>
/// <returns></returns>
private object CreateNavigationLinks(HttpControllerContext controllerContext, Paginator <T> paginator)
{
var action = controllerContext.RouteData.Values["action"].ToString();
var controller = controllerContext.RouteData.Values["controller"].ToString();
return(new
{
First = this.Url.Link(
action,
new
{
Controller = controller,
Action = action,
offset = paginator.First.Offset,
limit = paginator.First.Limit
}
),
Prev = this.Url.Link(
action,
new
{
Controller = controller,
Action = action,
offset = paginator.Previous.Offset,
limit = paginator.Previous.Limit
}
),
Next = this.Url.Link(
action,
new
{
Controller = controller,
Action = action,
offset = paginator.Next.Offset,
limit = paginator.Next.Limit
}
),
Last = this.Url.Link(
action,
new
{
Controller = controller,
Action = action,
offset = paginator.Last.Offset,
limit = paginator.Last.Limit
}
)
});
}
public void WithValidDataAtIndexNine_ReturnGetFirstItemIndex()
{
var stu = new Paginator(99, 10);
Assert.AreEqual(90, stu.GetFirstItemIndex(9));
}
public void PageMoving()
{
Paginator<NoFoo> ptor =
new Paginator<NoFoo>(3, new NoFooPaginable(LastOpenedSession, new DetachedNamedQuery("NoFoo.All")), true);
IList<NoFoo> entities = ptor.GetFirstPage();
Assert.AreEqual(3, entities.Count);
Assert.AreEqual(1, ptor.CurrentPageNumber);
entities = ptor.GetNextPage();
Assert.AreEqual(3, entities.Count);
Assert.AreEqual(2, ptor.CurrentPageNumber);
Assert.AreEqual("N3", entities[0].Name);
Assert.AreEqual("N4", entities[1].Name);
Assert.AreEqual("N5", entities[2].Name);
entities = ptor.GetPage(4);
Assert.AreEqual(3, entities.Count);
Assert.AreEqual(4, ptor.CurrentPageNumber);
Assert.AreEqual("N9", entities[0].Name);
Assert.AreEqual("N10", entities[1].Name);
Assert.AreEqual("N11", entities[2].Name);
entities = ptor.GetPreviousPage();
Assert.AreEqual(3, entities.Count);
Assert.AreEqual(3, ptor.CurrentPageNumber);
Assert.AreEqual("N6", entities[0].Name);
Assert.AreEqual("N7", entities[1].Name);
Assert.AreEqual("N8", entities[2].Name);
}
public void WithCounter()
{
Paginator<NoFoo> ptor =
new Paginator<NoFoo>(5, new NoFooPaginable(LastOpenedSession, new DetachedNamedQuery("NoFoo.All")),
new NamedQueryRowsCounter("NoFoo.Count.All"));
Assert.AreEqual(3, ptor.LastPageNumber);
}
/// <summary> /// Создания объекта пагинации всех статей /// </summary> /// <param name="pageNumber">страница</param> /// <param name="pageSize">количество элементов на страницу</param> private Paginator <DtoSearchresultPost> GetPostsPaginator(int pageNumber, int pageSize) => Paginator <DtoSearchresultPost> .ToList(GetPostsCash(), pageNumber, pageSize);
public GetTradeHistoryRequest(string market, string orderId)
{
this.market = market;
this.orderId = orderId;
this.paginator = null;
}
public void PrintUsingXps(bool showProgressDialog)
{
if (showProgressDialog)
controller.ShowProgressDialog(true);
try {
// Set up and position everything.
SetupPrinting();
PrintQueue printQueue = GetPrintQueue(pageSettings.PrinterSettings.PrinterName);
do {
PrintTicket printTicket = GetPrintTicket(printQueue, pageSettings);
Margins margins = pageSettings.Margins;
BeginPrint(this, new PrintEventArgs());
printQueue.CurrentJobSettings.Description = documentTitle;
XpsDocumentWriter documentWriter = PrintQueue.CreateXpsDocumentWriter(printQueue);
Paginator paginator = new Paginator(this, currentPage, new SizeF(pageSettings.PaperSize.Width, pageSettings.PaperSize.Height), margins, GetDPI(printTicket), showProgressDialog);
documentWriter.Write(paginator, printTicket);
currentPage += paginator.PageCount;
EndPrint(this, new PrintEventArgs());
// If we didn't print all the pages, then we must have been doing a pause
// between pages.
if (currentPage < totalPages) {
string pauseMessage;
bool pause = PausePrintingAfterPage(currentPage - 1, out pauseMessage);
Debug.Assert(pause);
if (!controller.OkCancelMessage(pauseMessage, true))
break;
}
} while (currentPage < totalPages);
}
finally {
if (showProgressDialog)
controller.EndProgressDialog();
}
}
public void HasPages()
{
string hql = "from Foo where Name = 'N1'";
PaginableRowsCounterQuery<Foo> pag =
new PaginableRowsCounterQuery<Foo>(LastOpenedSession, new DetachedQuery(hql));
Paginator<Foo> ptor = new Paginator<Foo>(3, pag);
Assert.AreEqual(true, ptor.HasPages);
Assert.AreEqual(1, ptor.RowsCount);
Assert.AreEqual(false, ptor.HasPrevious);
Assert.AreEqual(false, ptor.HasNext);
IList<Foo> lpage = ptor.GetPage(1);
Assert.AreEqual(1, lpage.Count);
}
public GetTradeHistoryRequest(string market, string orderId, Paginator paginator)
{
this.market = market;
this.orderId = orderId;
this.paginator = paginator;
}
internal static async Task <PagedResults <T> > PaginateAsync <T>(this IQueryable <T> collection, Paginator paginator)
{
var count = await collection.CountAsync().ConfigureAwait(false);
if (count == 0)
{
return(new PagedResults <T>());
}
if (paginator == null)
{
paginator = new Paginator();
}
var totalPages = (int)Math.Ceiling((decimal)count / paginator.PageSize);
var result = await collection
.Skip((paginator.CurrentPage - 1) *paginator.PageSize)
.Take(paginator.PageSize)
.ToListAsync()
.ConfigureAwait(false);
return(new PagedResults <T>(result, paginator.CurrentPage, paginator.PageSize, totalPages, count));
}
public _UserSummaryPartialModel(IEnumerable <PhpbbUsers> userList, IEnumerable <PhpbbGroups> groupList, IEnumerable <PhpbbRanks> rankList, string dateFormat, string language, Paginator paginator, string backLink, string forwardLink)
{
UserList = userList;
DateFormat = dateFormat;
GroupList = groupList;
RankList = rankList;
Language = language;
UpperPagination = new _PaginationControlsPartialModel(paginator: paginator, allowPaginationChange: false, back: backLink, forward: forwardLink, includeEasyNavigation: false, language: language);
LowerPagination = new _PaginationControlsPartialModel(paginator: paginator, allowPaginationChange: false, back: backLink, forward: forwardLink, includeEasyNavigation: true, language: language);
}
