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; }); }