/
IssueServiceViewModel.cs
103 lines (96 loc) · 3.85 KB
/
IssueServiceViewModel.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
using DevExpress.Mvvm;
using DevExpress.Mvvm.DataAnnotations;
using DevExpress.Xpf.Data;
using DevExpress.Mvvm.Xpf;
using System;
using System.ComponentModel;
using System.Linq;
using System.Threading.Tasks;
namespace InfiniteAsyncSourceMVVMSample {
public class IssueServiceViewModel : ViewModelBase {
public UserData[] Users {
get { return GetValue<UserData[]>(); }
private set { SetValue(value); }
}
public IssueServiceViewModel() {
AssignUsers();
}
async void AssignUsers() {
Users = await IssuesService.GetUsersAsync();
}
[Command]
public void FetchIssues(FetchRowsAsyncArgs args) {
args.Result = GetIssuesAsync(args);
}
async Task<FetchRowsResult> GetIssuesAsync(FetchRowsAsyncArgs args) {
var take = args.Take ?? 30;
var issues = await IssuesService.GetIssuesAsync(
skip: args.Skip,
take: take,
sortOrder: GetIssueSortOrder(args.SortOrder),
filter: (IssueFilter)args.Filter);
return new FetchRowsResult(issues, hasMoreRows: issues.Length == take);
}
static IssueSortOrder GetIssueSortOrder(SortDefinition[] sortOrder) {
if(sortOrder.Length > 0) {
var sort = sortOrder.Single();
if(sort.PropertyName == "Created") {
if(sort.Direction != ListSortDirection.Descending)
throw new InvalidOperationException();
return IssueSortOrder.CreatedDescending;
}
if(sort.PropertyName == "Votes") {
return sort.Direction == ListSortDirection.Ascending
? IssueSortOrder.VotesAscending
: IssueSortOrder.VotesDescending;
}
}
return IssueSortOrder.Default;
}
[Command]
public void GetTotalSummaries(GetSummariesAsyncArgs args) {
args.Result = GetTotalSummariesAsync(args);
}
static async Task<object[]> GetTotalSummariesAsync(GetSummariesAsyncArgs e) {
var summaryValues = await IssuesService.GetSummariesAsync((IssueFilter)e.Filter);
return e.Summaries.Select(x => {
if(x.SummaryType == SummaryType.Count)
return (object)summaryValues.Count;
if(x.SummaryType == SummaryType.Max && x.PropertyName == "Created")
return summaryValues.LastCreated;
throw new InvalidOperationException();
}).ToArray();
}
[Command]
public void GetUniqueValues(GetUniqueValuesAsyncArgs args) {
if(args.PropertyName == "Priority") {
var values = Enum.GetValues(typeof(Priority)).Cast<object>().ToArray();
args.Result = Task.FromResult(values);
} else {
throw new InvalidOperationException();
}
}
[Command]
public void UpdateIssue(RowValidationArgs args) {
if(args.IsNewItem) {
args.ResultAsync = AddNewIssueAsync((IssueData)args.Item);
} else {
args.ResultAsync = UpdateIssueAsync((IssueData)args.Item);
}
}
static async Task<ValidationErrorInfo> UpdateIssueAsync(IssueData issue) {
await IssuesService.UpdateRowAsync(issue);
return null;
}
static async Task<ValidationErrorInfo> AddNewIssueAsync(IssueData issue) {
await IssuesService.AddNewRowAsync(issue);
return null;
}
[Command]
public void DeleteIssues(ValidateRowDeletionArgs args) {
foreach(IssueData item in args.Items) {
IssuesService.DeleteRowAsync(item).Wait();
}
}
}
}