public static IEnumerable <IssueData> SortIssues(IssueSortOrder sortOrder, IEnumerable <IssueData> issues)
{
switch (sortOrder)
{
case IssueSortOrder.Default:
return(issues.OrderByDescending(x => x, new DefaultSortComparer()).ThenByDescending(x => x.Created));
case IssueSortOrder.CreatedDescending:
return(issues.OrderByDescending(x => x.Created));
case IssueSortOrder.CreatedAscending:
return(issues.OrderBy(x => x.Created));
case IssueSortOrder.VotesAscending:
return(issues.OrderBy(x => x.Votes).ThenByDescending(x => x.Created));
case IssueSortOrder.VotesDescending:
return(issues.OrderByDescending(x => x.Votes).ThenByDescending(x => x.Created));
case IssueSortOrder.UserAscending:
return(issues.OrderBy(x => x.User).ThenByDescending(x => x.Created));
case IssueSortOrder.UserDescending:
return(issues.OrderByDescending(x => x.User).ThenByDescending(x => x.Created));
case IssueSortOrder.PriorityAscending:
return(issues.OrderBy(x => x.Priority).ThenByDescending(x => x.Created));
case IssueSortOrder.PriorityDescending:
return(issues.OrderByDescending(x => x.Priority).ThenByDescending(x => x.Created));
default:
return(issues);
}
}
public static Task <Issue[]> GetIssuesAsync(int skip, int take, IssueSortOrder sortOrder, IssueFilter filter)
{
return(Task.Run(() => {
var issues = SortIssues(sortOrder, AllIssues.Value);
if (filter != null)
{
issues = FilterIssues(filter, issues);
}
return issues.Skip(skip).Take(take).Select(x => x.Clone()).ToArray();
}));
}
public async static Task <IssueData[]> GetIssuesAsync(int skip, int take, IssueSortOrder sortOrder, IssueFilter filter)
{
await Task.Delay(300).ConfigureAwait(false);
var issues = SortIssues(sortOrder, AllIssues.Value);
if (filter != null)
{
issues = FilterIssues(filter, issues);
}
return(issues.Skip(skip).Take(take).Select(x => x.Clone()).ToArray());
}
public IssueData[] GetIssues(int page, int pageSize, IssueSortOrder sortOrder, IssueFilter filter)
{
CheckAccess();
Thread.Sleep(300);
var issues = SortIssues(sortOrder, AllIssues.Value);
if (filter != null)
{
issues = FilterIssues(filter, issues);
}
return(issues.Skip(page * pageSize).Take(pageSize).ToArray());
}
async Task <FetchRowsResult> FetchRowsAsync(FetchRowsAsyncEventArgs e)
{
IssueSortOrder sortOrder = IssuesHelper.GetIssueSortOrder(e);
IssueFilter filter = IssuesHelper.MakeIssueFilter(e.Filter);
const int pageSize = 30;
var issues = await IssuesService.GetIssuesAsync(
page : e.Skip / pageSize,
pageSize : pageSize,
sortOrder : sortOrder,
filter : filter);
return(new FetchRowsResult(issues, hasMoreRows: issues.Length == pageSize));
}
static async Task <FetchRowsResult> FetchRowsAsync(FetchPageAsyncEventArgs e)
{
IssueSortOrder sortOrder = GetIssueSortOrder(e);
IssueFilter filter = MakeIssueFilter(e.Filter);
var issues = await IssuesService.GetIssuesAsync(
page : e.Skip / e.Take,
pageSize : e.Take,
sortOrder : sortOrder,
filter : filter);
return(new FetchRowsResult(issues, hasMoreRows: issues.Length == e.Take));
}
static async Task <FetchRowsResult> FetchRowsAsync(FetchRowsAsyncEventArgs e)
{
IssueSortOrder sortOrder = GetIssueSortOrder(e);
IssueFilter filter = MakeIssueFilter(e.Filter);
int take = e.Take ?? 30;
var issues = await IssuesService.GetIssuesAsync(
skip : e.Skip,
take : take,
sortOrder : sortOrder,
filter : filter);
return(new FetchRowsResult(issues, hasMoreRows: issues.Length == take));
}
static async Task <FetchRowsResult> FetchRowsAsync(FetchPageAsyncEventArgs e)
{
IssueSortOrder sortOrder = GetIssueSortOrder(e);
var issuesFetchResult = await IssuesService.GetIssuesAsync(
skipToken : e.SkipToken,
pageSize : e.Take,
sortOrder : sortOrder);
return(new FetchRowsResult(
issuesFetchResult.Issues,
hasMoreRows: issuesFetchResult.Issues.Length == e.Take,
nextSkipToken: issuesFetchResult.NextSkipToken));
}
static FetchRowsResult FetchRows(FetchPageEventArgs e)
{
IssueSortOrder sortOrder = GetIssueSortOrder(e);
IssueFilter filter = MakeIssueFilter(e.Filter);
var issuesContext = (IssuesContext)e.Source;
const int pageSize = 30;
var issues = issuesContext.GetIssues(
page: e.Skip / pageSize,
pageSize: pageSize,
sortOrder: sortOrder,
filter: filter);
return(new FetchRowsResult(issues, hasMoreRows: issues.Length == pageSize));
}
static void CheckRestrictions(IssueSortOrder sortOrder, IssueFilter filter)
{
if (filter == null)
{
return;
}
if ((sortOrder == IssueSortOrder.Hot || sortOrder == IssueSortOrder.Week) &&
(filter.CreatedFrom != null || filter.CreatedTo != null || filter.MaxVotes != null || filter.MinVotes != null))
{
throw new InvalidOperationException("Restrictions violation");
}
if ((filter.MaxVotes != null || filter.MinVotes != null) &&
!(sortOrder == IssueSortOrder.VotesAscending || sortOrder == IssueSortOrder.VotesDescending))
{
throw new InvalidOperationException("Restrictions violation");
}
}
static IEnumerable <Issue> SortIssues(IssueSortOrder sortOrder, IEnumerable <Issue> issues)
{
switch (sortOrder)
{
case IssueSortOrder.Default:
return(issues);//.OrderByDescending(x => x, new DefaultSortComparer()).ThenByDescending(x => x.Created);
case IssueSortOrder.CreatedDescending:
return(issues.OrderByDescending(x => x.Created));
case IssueSortOrder.VotesAscending:
return(issues.OrderBy(x => x.Votes).ThenByDescending(x => x.Created));
case IssueSortOrder.VotesDescending:
return(issues.OrderByDescending(x => x.Votes).ThenByDescending(x => x.Created));
default:
throw new InvalidOperationException();
}
}
static IEnumerable <IssueData> SortIssues(IssueSortOrder sortOrder, IEnumerable <IssueData> issues)
{
switch (sortOrder)
{
case IssueSortOrder.Default:
return(issues
.Where(x => x.Created > DateTime.Today.AddDays(-2) && x.Votes > 70)
.OrderByDescending(x => x.Created));
case IssueSortOrder.Hot:
return(issues
.Where(x => x.Created > DateTime.Today.AddDays(-2) && x.Votes > 70)
.OrderByDescending(x => x.Votes)
.ThenByDescending(x => x.Created));
case IssueSortOrder.Week:
return(issues
.Where(x => x.Created > DateTime.Today.AddDays(-7) && x.Votes > 90)
.OrderByDescending(x => x.Votes)
.ThenByDescending(x => x.Created));
case IssueSortOrder.CreatedAscending:
return(issues.OrderBy(x => x.Created));
case IssueSortOrder.CreatedDescending:
return(issues.OrderByDescending(x => x.Created));
case IssueSortOrder.VotesAscending:
return(issues
.OrderBy(x => x.Votes)
.ThenByDescending(x => x.Created));
case IssueSortOrder.VotesDescending:
return(issues
.OrderByDescending(x => x.Votes)
.ThenByDescending(x => x.Created));
default:
throw new InvalidOperationException();
}
}
public async static Task <IssueData[]> GetIssuesAsync(int page, int pageSize, IssueSortOrder sortOrder, IssueFilter filter)
{
return(await Task.Run(() => {
var issues = IssuesHelper.SortIssues(sortOrder, AllIssues.Value);
if (filter != null)
{
issues = IssuesHelper.FilterIssues(filter, issues);
}
issues = issues.Skip(page *pageSize).Take(pageSize);
return issues.ToArray();
}));
}
public async static Task <IssuesFetchResult> GetIssuesAsync(object skipToken, int pageSize, IssueSortOrder sortOrder)
{
await Task.Delay(300).ConfigureAwait(false);
IEnumerable <IssueData> issues = AllIssues.Value;
var createdValue = skipToken != null ? ((SkipToken)skipToken).CreatedValue : default(DateTime?);
if (sortOrder == IssueSortOrder.CreatedAscending)
{
issues = issues
.OrderBy(x => x.Created)
.Where(x => createdValue != null ? x.Created > createdValue : true);
}
else
{
issues = issues
.OrderByDescending(x => x.Created)
.Where(x => createdValue != null ? x.Created < createdValue : true);
}
var rows = issues.Take(pageSize).ToArray();
var nextSkipToken = rows.Any() ? new SkipToken(rows.Last().Created) : null;
return(new IssuesFetchResult(rows, nextSkipToken));
}
public async static Task <IssueData[]> GetIssuesAsync(int page, int pageSize, IssueSortOrder sortOrder, IssueFilter filter)
{
await Task.Delay(300);
var issues = SortIssues(sortOrder, AllIssues.Value);
if (filter != null)
{
issues = FilterIssues(filter, issues);
}
return(issues.Skip(page * pageSize).Take(pageSize).ToArray());
}
