public PullRequestFilesViewModel(IApplicationService applicationService)
{
Files = new ReactiveCollection<CommitModel.CommitFileModel>
{
GroupFunc = y =>
{
var filename = "/" + y.Filename;
return filename.Substring(0, filename.LastIndexOf("/", StringComparison.Ordinal) + 1);
}
};
GoToSourceCommand = new ReactiveCommand();
GoToSourceCommand.OfType<CommitModel.CommitFileModel>().Subscribe(x =>
{
var vm = CreateViewModel<SourceViewModel>();
// vm.Name = x.Filename.Substring(x.Filename.LastIndexOf("/", StringComparison.Ordinal) + 1);
// vm.Path = x.Filename;
// vm.GitUrl = x.ContentsUrl;
// vm.ForceBinary = x.Patch == null;
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(t =>
Files.SimpleCollectionLoad(
applicationService.Client.Users[Username].Repositories[Repository].PullRequests[PullRequestId]
.GetFiles(), t as bool?));
}
public IssueMilestonesViewModel(IApplicationService applicationService)
{
Milestones = new ReactiveCollection<MilestoneModel>();
SelectMilestoneCommand = new ReactiveCommand();
SelectMilestoneCommand.RegisterAsyncTask(async t =>
{
var milestone = t as MilestoneModel;
if (milestone != null)
SelectedMilestone = milestone;
if (SaveOnSelect)
{
try
{
int? milestoneNumber = null;
if (SelectedMilestone != null) milestoneNumber = SelectedMilestone.Number;
var updateReq = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId].UpdateMilestone(milestoneNumber);
await applicationService.Client.ExecuteAsync(updateReq);
}
catch (Exception e)
{
throw new Exception("Unable to to save milestone! Please try again.", e);
}
}
DismissCommand.ExecuteIfCan();
});
LoadCommand.RegisterAsyncTask(t =>
Milestones.SimpleCollectionLoad(
applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Milestones.GetAll(),
t as bool?));
}
public IssueAssignedToViewModel(IApplicationService applicationService)
{
_applicationService = applicationService;
Users = new ReactiveCollection<BasicUserModel>();
SelectUserCommand = new ReactiveCommand();
SelectUserCommand.RegisterAsyncTask(async t =>
{
var selectedUser = t as BasicUserModel;
if (selectedUser != null)
SelectedUser = selectedUser;
if (SaveOnSelect)
{
var assignee = SelectedUser != null ? SelectedUser.Login : null;
var updateReq = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId].UpdateAssignee(assignee);
await _applicationService.Client.ExecuteAsync(updateReq);
}
DismissCommand.ExecuteIfCan();
});
LoadCommand.RegisterAsyncTask(t =>
Users.SimpleCollectionLoad(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetAssignees(), t as bool?));
}
public PullRequestsViewModel(IApplicationService applicationService)
{
PullRequests = new ReactiveCollection<PullRequestModel>();
GoToPullRequestCommand = new ReactiveCommand();
GoToPullRequestCommand.OfType<PullRequestModel>().Subscribe(pullRequest =>
{
var vm = CreateViewModel<PullRequestViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.PullRequestId = pullRequest.Number;
vm.PullRequest = pullRequest;
vm.WhenAnyValue(x => x.PullRequest).Skip(1).Subscribe(x =>
{
var index = PullRequests.IndexOf(pullRequest);
if (index < 0) return;
PullRequests[index] = x;
PullRequests.Reset();
});
ShowViewModel(vm);
});
this.WhenAnyValue(x => x.SelectedFilter).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan());
LoadCommand.RegisterAsyncTask(t =>
{
var state = SelectedFilter == 0 ? "open" : "closed";
var request = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].PullRequests.GetAll(state: state);
return PullRequests.SimpleCollectionLoad(request, t as bool?);
});
}
public TeamsViewModel(IApplicationService applicationService)
{
Teams = new ReactiveCollection<TeamShortModel>();
GoToTeamCommand = new ReactiveCommand();
GoToTeamCommand.OfType<TeamShortModel>().Subscribe(x =>
{
var vm = CreateViewModel<TeamMembersViewModel>();
vm.Id = x.Id;
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(x =>
Teams.SimpleCollectionLoad(applicationService.Client.Organizations[OrganizationName].GetTeams(), x as bool?));
}
protected GistsViewModel()
{
Gists = new ReactiveCollection<GistModel>();
GoToGistCommand = new ReactiveCommand();
GoToGistCommand.OfType<GistModel>().Subscribe(x =>
{
var vm = CreateViewModel<GistViewModel>();
vm.Id = x.Id;
vm.Gist = x;
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(t => Gists.SimpleCollectionLoad(CreateRequest(), t as bool?));
}
public OrganizationsViewModel(IApplicationService applicationService)
{
Organizations = new ReactiveCollection<BasicUserModel>();
GoToOrganizationCommand = new ReactiveCommand();
GoToOrganizationCommand.OfType<BasicUserModel>().Subscribe(x =>
{
var vm = CreateViewModel<OrganizationViewModel>();
vm.Name = x.Login;
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(t =>
Organizations.SimpleCollectionLoad(applicationService.Client.Users[Username].GetOrganizations(),
t as bool?));
}
protected CommitsViewModel()
{
Commits = new ReactiveCollection<CommitModel>();
GoToChangesetCommand = new ReactiveCommand();
GoToChangesetCommand.OfType<CommitModel>().Subscribe(x =>
{
var vm = CreateViewModel<ChangesetViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.Node = x.Sha;
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(x => Commits.SimpleCollectionLoad(GetRequest(), x as bool?));
}
public ChangesetBranchesViewModel(IApplicationService applicationService)
{
Branches = new ReactiveCollection<BranchModel>();
GoToBranchCommand = new ReactiveCommand();
GoToBranchCommand.OfType<BranchModel>().Subscribe(x =>
{
var vm = CreateViewModel<ChangesetsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(t =>
Branches.SimpleCollectionLoad(
applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetBranches(), t as bool?));
}
public IssueLabelsViewModel(IApplicationService applicationService)
{
Labels = new ReactiveCollection<LabelModel>();
SelectedLabels = new ReactiveList<LabelModel>();
SelectLabelsCommand = new ReactiveCommand();
SelectLabelsCommand.RegisterAsyncTask(async t =>
{
var selectedLabels = t as IEnumerable<LabelModel>;
if (selectedLabels != null)
SelectedLabels.Reset(selectedLabels);
//If nothing has changed, dont do anything...
if (OriginalLabels != null && OriginalLabels.Count() == SelectedLabels.Count() &&
OriginalLabels.Intersect(SelectedLabels).Count() == SelectedLabels.Count())
{
DismissCommand.ExecuteIfCan();
return;
}
if (SaveOnSelect)
{
try
{
var labels = (SelectedLabels != null && SelectedLabels.Count > 0)
? SelectedLabels.Select(y => y.Name).ToArray() : null;
var updateReq =
applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId]
.UpdateLabels(labels);
await applicationService.Client.ExecuteAsync(updateReq);
}
catch (Exception e)
{
throw new Exception("Unable to save labels! Please try again.", e);
}
}
DismissCommand.ExecuteIfCan();
});
LoadCommand.RegisterAsyncTask(t =>
Labels.SimpleCollectionLoad(
applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Labels.GetAll(),
t as bool?));
}
public SourceTreeViewModel(IApplicationService applicationService)
{
Filter = applicationService.Account.Filters.GetFilter<SourceFilterModel>("SourceViewModel");
Content = new ReactiveCollection<ContentModel>();
GoToSubmoduleCommand = new ReactiveCommand();
GoToSubmoduleCommand.OfType<ContentModel>().Subscribe(x =>
{
var nameAndSlug = x.GitUrl.Substring(x.GitUrl.IndexOf("/repos/", StringComparison.OrdinalIgnoreCase) + 7);
var repoId = new RepositoryIdentifier(nameAndSlug.Substring(0, nameAndSlug.IndexOf("/git", StringComparison.OrdinalIgnoreCase)));
var vm = CreateViewModel<SourceTreeViewModel>();
vm.Username = repoId.Owner;
vm.Repository = repoId.Name;
vm.Branch = x.Sha;
ShowViewModel(vm);
});
GoToSourceCommand = new ReactiveCommand();
GoToSourceCommand.OfType<ContentModel>().Subscribe(x =>
{
var otherFiles = Content
.Where(y => string.Equals(y.Type, "file", StringComparison.OrdinalIgnoreCase))
.Where(y => y.Size.HasValue && y.Size.Value > 0)
.Select(y => new SourceViewModel.SourceItemModel
{
Name = y.Name,
Path = y.Path,
HtmlUrl = y.HtmlUrl,
GitUrl = y.GitUrl
}).ToArray();
var navObject = new SourceViewModel.NavObject
{
Branch = Branch,
Username = Username,
Repository = Repository,
TrueBranch = TrueBranch,
Items = otherFiles,
CurrentItemIndex = Array.FindIndex(otherFiles, f => string.Equals(f.GitUrl, x.GitUrl, StringComparison.OrdinalIgnoreCase))
};
var vm = CreateViewModel<SourceViewModel>(navObject);
ShowViewModel(vm);
});
GoToSourceTreeCommand = new ReactiveCommand();
GoToSourceTreeCommand.OfType<ContentModel>().Subscribe(x =>
{
var vm = CreateViewModel<SourceTreeViewModel>();
vm.Username = Username;
vm.Branch = Branch;
vm.Repository = Repository;
vm.TrueBranch = TrueBranch;
vm.Path = x.Path;
ShowViewModel(vm);
});
this.WhenAnyValue(x => x.Filter).Subscribe(filter =>
{
if (filter == null)
{
Content.OrderFunc = null;
}
else
{
Content.OrderFunc = x =>
{
switch (filter.OrderBy)
{
case SourceFilterModel.Order.FoldersThenFiles:
x = x.OrderBy(y => y.Type).ThenBy(y => y.Name);
break;
default:
x = x.OrderBy(y => y.Name);
break;
}
return filter.Ascending ? x : x.Reverse();
};
}
});
LoadCommand.RegisterAsyncTask(t =>
Content.SimpleCollectionLoad(
applicationService.Client.Users[Username].Repositories[Repository].GetContent(
Path ?? string.Empty, Branch ?? "master"), t as bool?));
}
public GistViewModel(IApplicationService applicationService, IShareService shareService)
{
_applicationService = applicationService;
Comments = new ReactiveCollection<GistCommentModel>();
ShareCommand = new ReactiveCommand(this.WhenAnyValue(x => x.Gist, x => x != null));
ShareCommand.Subscribe(_ => shareService.ShareUrl(Gist.HtmlUrl));
ToggleStarCommand = new ReactiveCommand(this.WhenAnyValue(x => x.IsStarred, x => x.HasValue));
ToggleStarCommand.RegisterAsyncTask(async t =>
{
try
{
if (!IsStarred.HasValue) return;
var request = IsStarred.Value ? _applicationService.Client.Gists[Id].Unstar() : _applicationService.Client.Gists[Id].Star();
await _applicationService.Client.ExecuteAsync(request);
IsStarred = !IsStarred.Value;
}
catch (Exception e)
{
throw new Exception("Unable to start gist. Please try again.", e);
}
});
ForkCommand = new ReactiveCommand();
ForkCommand.RegisterAsyncTask(async t =>
{
var data =
await _applicationService.Client.ExecuteAsync(_applicationService.Client.Gists[Id].ForkGist());
var forkedGist = data.Data;
var vm = CreateViewModel<GistViewModel>();
vm.Id = forkedGist.Id;
vm.Gist = forkedGist;
ShowViewModel(vm);
});
GoToViewableFileCommand = new ReactiveCommand();
GoToViewableFileCommand.OfType<GistFileModel>().Subscribe(x =>
{
var vm = CreateViewModel<GistViewableFileViewModel>();
vm.GistFile = x;
ShowViewModel(vm);
});
GoToHtmlUrlCommand = new ReactiveCommand(this.WhenAnyValue(x => x.Gist, x => x != null && !string.IsNullOrEmpty(x.HtmlUrl)));
GoToHtmlUrlCommand.Subscribe(_ => GoToUrlCommand.ExecuteIfCan(Gist.HtmlUrl));
GoToFileSourceCommand = new ReactiveCommand();
GoToFileSourceCommand.OfType<GistFileModel>().Subscribe(x =>
{
var vm = CreateViewModel<GistFileViewModel>();
vm.Id = Id;
vm.GistFile = x;
vm.Filename = x.Filename;
ShowViewModel(vm);
});
GoToUserCommand = new ReactiveCommand(this.WhenAnyValue(x => x.Gist, x => x != null));
GoToUserCommand.Subscribe(x =>
{
var vm = CreateViewModel<ProfileViewModel>();
vm.Username = Gist.Owner.Login;
ShowViewModel(vm);
});
GoToForksCommand = new ReactiveCommand();
LoadCommand.RegisterAsyncTask(t =>
{
var forceCacheInvalidation = t as bool?;
var t1 = this.RequestModel(_applicationService.Client.Gists[Id].Get(), forceCacheInvalidation, response => Gist = response.Data);
this.RequestModel(_applicationService.Client.Gists[Id].IsGistStarred(), forceCacheInvalidation, response => IsStarred = response.Data).FireAndForget();
Comments.SimpleCollectionLoad(_applicationService.Client.Gists[Id].GetComments(), forceCacheInvalidation).FireAndForget();
return t1;
});
}
public IssueViewModel(IApplicationService applicationService, IShareService shareService)
{
_applicationService = applicationService;
Comments = new ReactiveCollection<IssueCommentModel>();
Events = new ReactiveCollection<IssueEventModel>();
var issuePresenceObservable = this.WhenAnyValue(x => x.Issue, x => x != null);
ShareCommand = new ReactiveCommand(this.WhenAnyValue(x => x.Issue, x => x != null && !string.IsNullOrEmpty(x.HtmlUrl)));
ShareCommand.Subscribe(_ => shareService.ShareUrl(Issue.HtmlUrl));
AddCommentCommand = new ReactiveCommand();
AddCommentCommand.Subscribe(_ =>
{
var vm = CreateViewModel<CommentViewModel>();
vm.SaveCommand.RegisterAsyncTask(async t =>
{
var issue = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId];
var comment = await _applicationService.Client.ExecuteAsync(issue.CreateComment(vm.Comment));
Comments.Add(comment.Data);
vm.DismissCommand.ExecuteIfCan();
});
ShowViewModel(vm);
});
ToggleStateCommand = new ReactiveCommand(issuePresenceObservable);
ToggleStateCommand.RegisterAsyncTask(async t =>
{
var close = string.Equals(Issue.State, "open", StringComparison.OrdinalIgnoreCase);
try
{
var issue = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[Issue.Number];
var data = await _applicationService.Client.ExecuteAsync(issue.UpdateState(close ? "closed" : "open"));
Issue = data.Data;
}
catch (Exception e)
{
throw new Exception("Unable to " + (close ? "close" : "open") + " the item. " + e.Message, e);
}
});
GoToEditCommand = new ReactiveCommand(issuePresenceObservable);
GoToEditCommand.Subscribe(_ =>
{
var vm = CreateViewModel<IssueEditViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.Id = IssueId;
vm.Issue = Issue;
vm.WhenAnyValue(x => x.Issue).Skip(1).Subscribe(x => Issue = x);
ShowViewModel(vm);
});
GoToAssigneeCommand = new ReactiveCommand(issuePresenceObservable);
GoToAssigneeCommand.Subscribe(_ =>
{
var vm = CreateViewModel<IssueAssignedToViewModel>();
vm.SaveOnSelect = true;
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.IssueId = IssueId;
vm.SelectedUser = Issue.Assignee;
vm.WhenAnyValue(x => x.SelectedUser).Subscribe(x =>
{
Issue.Assignee = x;
this.RaisePropertyChanged("Issue");
});
ShowViewModel(vm);
});
GoToLabelsCommand = new ReactiveCommand(issuePresenceObservable);
GoToLabelsCommand.Subscribe(_ =>
{
var vm = CreateViewModel<IssueLabelsViewModel>();
vm.SaveOnSelect = true;
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.IssueId = IssueId;
vm.SelectedLabels.Reset(Issue.Labels);
vm.WhenAnyValue(x => x.SelectedLabels).Subscribe(x =>
{
Issue.Labels = x.ToList();
this.RaisePropertyChanged("Issue");
});
ShowViewModel(vm);
});
GoToMilestoneCommand = new ReactiveCommand(issuePresenceObservable);
GoToMilestoneCommand.Subscribe(_ =>
{
var vm = CreateViewModel<IssueMilestonesViewModel>();
vm.SaveOnSelect = true;
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.IssueId = IssueId;
vm.SelectedMilestone = Issue.Milestone;
vm.WhenAnyValue(x => x.SelectedMilestone).Subscribe(x =>
{
Issue.Milestone = x;
this.RaisePropertyChanged("Issue");
});
ShowViewModel(vm);
});
LoadCommand.RegisterAsyncTask(t =>
{
var forceCacheInvalidation = t as bool?;
var issue = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId];
var t1 = this.RequestModel(issue.Get(), forceCacheInvalidation, response => Issue = response.Data);
Comments.SimpleCollectionLoad(issue.GetComments(), forceCacheInvalidation).FireAndForget();
Events.SimpleCollectionLoad(issue.GetEvents(), forceCacheInvalidation).FireAndForget();
return t1;
});
}
public PullRequestViewModel(IApplicationService applicationService, IMarkdownService markdownService, IShareService shareService)
{
_applicationService = applicationService;
_markdownService = markdownService;
Comments = new ReactiveCollection<IssueCommentModel>();
Events = new ReactiveCollection<IssueEventModel>();
MergeCommand = new ReactiveCommand(this.WhenAnyValue(x => x.PullRequest, x =>
x != null && x.Merged.HasValue && !x.Merged.Value && x.Mergable.HasValue && x.Mergable.Value));
MergeCommand.RegisterAsyncTask(async t =>
{
try
{
var response = await _applicationService.Client.ExecuteAsync(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].PullRequests[PullRequestId].Merge());
if (!response.Data.Merged)
throw new Exception(response.Data.Message);
var pullRequest = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].PullRequests[PullRequestId].Get();
await this.RequestModel(pullRequest, true, r => PullRequest = r.Data);
}
catch (Exception e)
{
throw new Exception("Unable to Merge: " + e.Message, e);
}
});
ToggleStateCommand = new ReactiveCommand(this.WhenAnyValue(x => x.PullRequest, x => x != null));
ToggleStateCommand.RegisterAsyncTask(async t =>
{
var close = string.Equals(PullRequest.State, "open", StringComparison.OrdinalIgnoreCase);
try
{
var data = await _applicationService.Client.ExecuteAsync(
_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].PullRequests[PullRequestId].UpdateState(close ? "closed" : "open"));
PullRequest = data.Data;
}
catch (Exception e)
{
throw new Exception("Unable to " + (close ? "close" : "open") + " the item. " + e.Message, e);
}
});
GoToCommitsCommand = new ReactiveCommand();
GoToCommitsCommand.Subscribe(_ =>
{
var vm = CreateViewModel<PullRequestCommitsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.PullRequestId = PullRequestId;
ShowViewModel(vm);
});
GoToFilesCommand = new ReactiveCommand();
GoToFilesCommand.Subscribe(_ =>
{
var vm = CreateViewModel<PullRequestFilesViewModel>();
vm.Username = RepositoryOwner;
vm.Repository = RepositoryName;
vm.PullRequestId = PullRequestId;
ShowViewModel(vm);
});
ShareCommand = new ReactiveCommand(this.WhenAnyValue(x => x.PullRequest, x => x != null && !string.IsNullOrEmpty(x.HtmlUrl)));
ShareCommand.Subscribe(_ => shareService.ShareUrl(PullRequest.HtmlUrl));
GoToEditCommand = new ReactiveCommand();
GoToEditCommand.Subscribe(_ =>
{
var vm = CreateViewModel<IssueEditViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.Id = PullRequestId;
vm.Issue = Issue;
vm.WhenAnyValue(x => x.Issue).Skip(1).Subscribe(x => Issue = x);
ShowViewModel(vm);
});
GoToLabelsCommand = new ReactiveCommand(this.WhenAnyValue(x => x.Issue, x => x != null));
GoToLabelsCommand.Subscribe(_ =>
{
var vm = CreateViewModel<IssueLabelsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.IssueId = PullRequestId;
vm.SaveOnSelect = true;
vm.SelectedLabels.Reset(Issue.Labels);
vm.WhenAnyValue(x => x.Labels).Skip(1).Subscribe(x =>
{
Issue.Labels = x.ToList();
this.RaisePropertyChanged("Issue");
});
ShowViewModel(vm);
});
GoToMilestoneCommand = new ReactiveCommand(this.WhenAnyValue(x => x.Issue, x => x != null));
GoToMilestoneCommand.Subscribe(_ =>
{
var vm = CreateViewModel<IssueMilestonesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.IssueId = PullRequestId;
vm.SaveOnSelect = true;
vm.SelectedMilestone = Issue.Milestone;
vm.WhenAnyValue(x => x.SelectedMilestone).Skip(1).Subscribe(x =>
{
Issue.Milestone = x;
this.RaisePropertyChanged("Issue");
});
ShowViewModel(vm);
});
GoToAssigneeCommand = new ReactiveCommand(this.WhenAnyValue(x => x.Issue, x => x != null));
GoToAssigneeCommand.Subscribe(_ =>
{
var vm = CreateViewModel<IssueAssignedToViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.IssueId = PullRequestId;
vm.SaveOnSelect = true;
vm.SelectedUser = Issue.Assignee;
vm.WhenAnyValue(x => x.SelectedUser).Skip(1).Subscribe(x =>
{
Issue.Assignee = x;
this.RaisePropertyChanged("Issue");
});
ShowViewModel(vm);
});
GoToAddCommentCommand = new ReactiveCommand();
GoToAddCommentCommand.Subscribe(_ =>
{
var vm = CreateViewModel<CommentViewModel>();
vm.SaveCommand.RegisterAsyncTask(async t =>
{
var req =
_applicationService.Client.Users[RepositoryOwner]
.Repositories[RepositoryName].Issues[PullRequestId].CreateComment(vm.Comment);
var comment = await _applicationService.Client.ExecuteAsync(req);
Comments.Add(comment.Data);
vm.DismissCommand.ExecuteIfCan();
});
});
LoadCommand.RegisterAsyncTask(t =>
{
var forceCacheInvalidation = t as bool?;
var pullRequest = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].PullRequests[PullRequestId].Get();
var t1 = this.RequestModel(pullRequest, forceCacheInvalidation, response => PullRequest = response.Data);
Events.SimpleCollectionLoad(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[PullRequestId].GetEvents(), forceCacheInvalidation).FireAndForget();
Comments.SimpleCollectionLoad(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[PullRequestId].GetComments(), forceCacheInvalidation).FireAndForget();
this.RequestModel(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[PullRequestId].Get(), forceCacheInvalidation, response => Issue = response.Data).FireAndForget();
return t1;
});
}
public ChangesetViewModel(IApplicationService applicationService)
{
_applicationService = applicationService;
Comments = new ReactiveCollection<CommentModel>();
GoToHtmlUrlCommand = new ReactiveCommand(this.WhenAnyValue(x => x.Commit, x => x != null));
GoToHtmlUrlCommand.Select(x => Commit).Subscribe(GoToUrlCommand.ExecuteIfCan);
GoToRepositoryCommand = new ReactiveCommand();
GoToRepositoryCommand.Subscribe(_ =>
{
var vm = CreateViewModel<RepositoryViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToFileCommand = new ReactiveCommand();
GoToFileCommand.OfType<CommitModel.CommitFileModel>().Subscribe(x =>
{
if (x.Patch == null)
{
var vm = CreateViewModel<SourceViewModel>();
// vm.GitUrl = x.ContentsUrl;
// vm.HtmlUrl = x.BlobUrl;
// vm.Name = x.Filename;
// vm.Path = x.Filename;
// vm.ForceBinary = true;
ShowViewModel(vm);
}
else
{
var vm = CreateViewModel<ChangesetDiffViewModel>();
vm.Username = RepositoryOwner;
vm.Repository = RepositoryName;
vm.Branch = Commit.Sha;
vm.HtmlUrl = x.BlobUrl;
ShowViewModel(vm);
}
});
LoadCommand.RegisterAsyncTask(t =>
{
var forceCacheInvalidation = t as bool?;
var t1 = this.RequestModel(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Commits[Node].Get(), forceCacheInvalidation, response => Commit = response.Data);
Comments.SimpleCollectionLoad(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Commits[Node].Comments.GetAll(), forceCacheInvalidation).FireAndForget();
return t1;
});
}