protected BaseRepositoriesViewModel(IApplicationService applicationService, string filterKey = "RepositoryController") { ApplicationService = applicationService; ShowRepositoryOwner = true; Title = "Repositories"; var gotoRepository = new Action <RepositoryItemViewModel>(x => { var vm = CreateViewModel <RepositoryViewModel>(); vm.RepositoryOwner = x.Owner; vm.RepositoryName = x.Name; ShowViewModel(vm); }); Repositories = RepositoryCollection.CreateDerivedCollection( x => new RepositoryItemViewModel(x.Name, x.Owner.Login, x.Owner.AvatarUrl, ShowRepositoryDescription ? x.Description : string.Empty, x.StargazersCount, x.ForksCount, ShowRepositoryOwner, gotoRepository), filter: x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); //Filter = applicationService.Account.Filters.GetFilter<RepositoriesFilterModel>(filterKey); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan()); // _repositories.FilteringFunction = x => Repositories.Filter.Ascending ? x.OrderBy(y => y.Name) : x.OrderByDescending(y => y.Name); // _repositories.GroupingFunction = CreateGroupedItems; }
public PullRequestsViewModel(ISessionService sessionService) { _sessionService = sessionService; Title = "Pull Requests"; Items = InternalItems.CreateDerivedCollection(x => { var vm = new PullRequestItemViewModel(x); vm.GoToCommand.Subscribe(_ => { var prViewModel = this.CreateViewModel <PullRequestViewModel>(); prViewModel.Init(RepositoryOwner, RepositoryName, x.Number, x); NavigateTo(prViewModel); prViewModel.WhenAnyValue(y => y.Issue.State) .DistinctUntilChanged() .Skip(1) .Subscribe(y => LoadCommand.ExecuteIfCan()); }); return(vm); }, filter: x => x.Title.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { InternalItems.Reset(await RetrievePullRequests()); }); this.WhenAnyValue(x => x.SelectedFilter).Skip(1).Subscribe(_ => { InternalItems.Clear(); LoadCommand.ExecuteIfCan(); }); }
public PullRequestsViewModel(IApplicationService applicationService) { Title = "Pull Requests"; var pullRequests = new ReactiveList <PullRequestModel>(); PullRequests = pullRequests.CreateDerivedCollection( x => new PullRequestItemViewModel(x, () => { var vm = CreateViewModel <PullRequestViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.Id = (int)x.Number; //vm.PullRequest = x.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); }), filter: x => x.Title.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(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?)); }); this.WhenAnyValue(x => x.SelectedFilter).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan()); }
public IssuesViewModel(ISessionService sessionService) : base(sessionService) { _sessionService = sessionService; Filter = new IssuesFilterModel(); Title = "Issues"; GoToNewIssueCommand = ReactiveCommand.Create(); GoToNewIssueCommand.Subscribe(_ => { var vm = this.CreateViewModel <IssueAddViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.SaveCommand.Subscribe(x => LoadCommand.ExecuteIfCan()); NavigateTo(vm); }); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(filter => { InternalItems.Clear(); LoadCommand.ExecuteIfCan(); //CustomFilterEnabled = !(filter == _closedFilter || filter == _openFilter); }); GoToFilterCommand = ReactiveCommand.Create(); GoToFilterCommand.Subscribe(_ => { var vm = this.CreateViewModel <RepositoryIssuesFilterViewModel>(); vm.Init(RepositoryOwner, RepositoryName, Filter); vm.SaveCommand.Subscribe(filter => { Filter = filter; FilterSelection = IssueFilterSelection.Custom; }); NavigateTo(vm); }); }
public MyIssuesViewModel(ISessionService sessionService) : base(sessionService) { _sessionService = sessionService; Title = "My Issues"; Filter = MyIssuesFilterModel.CreateOpenFilter(); _selectedFilter = this.WhenAnyValue(x => x.Filter) .Select(x => { if (x == null || _openFilter.Equals(x)) { return(0); } return(_closedFilter.Equals(x) ? 1 : -1); }) .ToProperty(this, x => x.SelectedFilter); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(filter => { IssuesBacking.Clear(); LoadCommand.ExecuteIfCan(); CustomFilterEnabled = !(filter == _closedFilter || filter == _openFilter); }); GoToFilterCommand = ReactiveCommand.Create(); GoToFilterCommand.Subscribe(_ => { var vm = this.CreateViewModel <MyIssuesFilterViewModel>(); vm.Init(Filter); vm.SaveCommand.Subscribe(filter => Filter = filter); NavigateTo(vm); }); }
public NotificationsViewModel(IApplicationService applicationService) { _applicationService = applicationService; Title = "Notifications"; ReadSelectedCommand = ReactiveCommand.Create().WithSubscription(_ => { if (GroupedNotifications.SelectMany(x => x.Notifications).All(x => !x.IsSelected)) { applicationService.Client.ExecuteAsync(applicationService.Client.Notifications.MarkAsRead()).ToBackground(); _notifications.Clear(); } else { var selected = GroupedNotifications.SelectMany(x => x.Notifications) .Where(x => x.IsSelected && x.Notification.Unread).ToList(); var tasks = selected .Select(t => _applicationService.GitHubClient.Notification.MarkAsRead(int.Parse(t.Id))); Task.WhenAll(tasks).ToBackground(); foreach (var s in selected) { _notifications.Remove(s.Notification); } } }); _notifications.Changed.Select(_ => Unit.Default) .Merge(_notifications.ItemChanged.Select(_ => Unit.Default)) .Subscribe(_ => { GroupedNotifications = _notifications.GroupBy(x => x.Repository.FullName).Select(x => { var items = x.Select(y => new NotificationItemViewModel(y, GoToNotification)); var notifications = new ReactiveList <NotificationItemViewModel>(items); return(new NotificationGroupViewModel(x.Key, notifications)); }).ToList(); }); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => { var all = ActiveFilter == AllFilter; var participating = ActiveFilter == ParticipatingFilter; var req = new Octokit.NotificationsRequest { All = all, Participating = participating, Since = DateTimeOffset.MinValue }; var notifictions = await applicationService.GitHubClient.Notification.GetAllForCurrent(req); _notifications.Reset(notifictions); }); this.WhenAnyValue(x => x.ActiveFilter).Subscribe(x => { _notifications.Clear(); LoadCommand.ExecuteIfCan(); }); }
public BranchesAndTagsViewModel(IApplicationService applicationService) { var branches = new ReactiveList <BranchModel>(); Branches = branches.CreateDerivedCollection(x => x, x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); var tags = new ReactiveList <TagModel>(); Tags = tags.CreateDerivedCollection(x => x, x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); GoToSourceCommand = ReactiveCommand.Create(); GoToSourceCommand.OfType <BranchModel>().Subscribe(x => { var vm = CreateViewModel <SourceTreeViewModel>(); vm.Username = RepositoryOwner; vm.Repository = RepositoryName; vm.Branch = x.Name; vm.TrueBranch = true; ShowViewModel(vm); }); GoToSourceCommand.OfType <TagModel>().Subscribe(x => { var vm = CreateViewModel <SourceTreeViewModel>(); vm.Username = RepositoryOwner; vm.Repository = RepositoryName; vm.Branch = x.Commit.Sha; ShowViewModel(vm); }); this.WhenAnyValue(x => x.SelectedFilter).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan()); LoadCommand = ReactiveCommand.CreateAsyncTask(t => { if (SelectedFilter == ShowIndex.Branches) { var request = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetBranches(); return(branches.LoadAll <BranchModel>(request)); } else { var request = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetTags(); return(tags.LoadAll <TagModel>(request)); } }); }
public IssuesViewModel(IApplicationService applicationService) { _applicationService = applicationService; _mineFilter = IssuesFilterModel.CreateMineFilter(applicationService.Account.Username); Filter = _openFilter; Title = "Issues"; _filterSelection = this.WhenAnyValue(x => x.Filter) .Select(x => { if (x == null || _openFilter.Equals(x)) { return(IssueFilterSelection.Open); } if (_closedFilter.Equals(x)) { return(IssueFilterSelection.Closed); } if (_mineFilter.Equals(x)) { return(IssueFilterSelection.Mine); } return(IssueFilterSelection.Custom); }) .ToProperty(this, x => x.FilterSelection); GoToNewIssueCommand = ReactiveCommand.Create(); GoToNewIssueCommand.Subscribe(_ => { var vm = this.CreateViewModel <IssueAddViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.CreatedIssue.IsNotNull().Subscribe(IssuesBacking.Add); NavigateTo(vm); }); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(_ => { IssuesBacking.Clear(); LoadCommand.ExecuteIfCan(); }); GoToCustomFilterCommand = ReactiveCommand.Create(); }
public BranchesAndTagsViewModel(ISessionService applicationService) { var branches = new ReactiveList <Octokit.Branch>(); Branches = branches.CreateDerivedCollection( x => new BranchItemViewModel(x.Name, () => { var vm = this.CreateViewModel <SourceTreeViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.Branch = x.Name; vm.TrueBranch = true; NavigateTo(vm); }), filter: x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); var tags = new ReactiveList <Octokit.RepositoryTag>(); Tags = tags.CreateDerivedCollection( x => new TagItemViewModel(x.Name, () => { var vm = this.CreateViewModel <SourceTreeViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.Branch = x.Commit.Sha; NavigateTo(vm); }), filter: x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { if (SelectedFilter == ShowIndex.Branches) { branches.Reset(await applicationService.GitHubClient.Repository.GetAllBranches(RepositoryOwner, RepositoryName)); } else { tags.Reset(await applicationService.GitHubClient.Repository.GetAllTags(RepositoryOwner, RepositoryName)); } }); this.WhenAnyValue(x => x.SelectedFilter).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan()); }
public PullRequestsViewModel(IApplicationService applicationService) { ApplicationService = applicationService; PullRequests = new ReactiveList <PullRequest>(); LoadCommand.RegisterAsyncTask(_ => Load()); this.WhenAnyValue(x => x.SelectedView).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan()); GoToPullRequestCommand = new ReactiveCommand(); GoToPullRequestCommand.OfType <PullRequest>().Subscribe(x => { var vm = CreateViewModel <PullRequestViewModel>(); vm.ProjectKey = ProjectKey; vm.RepositorySlug = RepositorySlug; vm.PullRequestId = x.Id; ShowViewModel(vm); }); }
protected RepositoriesViewModel(IApplicationService applicationService, string filterKey = "RepositoryController") { ApplicationService = applicationService; Repositories = new ReactiveList <RepositoryModel>(); //Filter = applicationService.Account.Filters.GetFilter<RepositoriesFilterModel>(filterKey); GoToRepositoryCommand = ReactiveCommand.Create(); GoToRepositoryCommand.OfType <RepositoryModel>().Subscribe(x => { var vm = CreateViewModel <RepositoryViewModel>(); vm.RepositoryOwner = x.Owner.Login; vm.RepositoryName = x.Name; ShowViewModel(vm); }); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan()); // _repositories.FilteringFunction = x => Repositories.Filter.Ascending ? x.OrderBy(y => y.Name) : x.OrderByDescending(y => y.Name); // _repositories.GroupingFunction = CreateGroupedItems; }
public MyIssuesViewModel(IApplicationService applicationService) { _applicationService = applicationService; Title = "My Issues"; Filter = MyIssuesFilterModel.CreateOpenFilter(); _selectedFilter = this.WhenAnyValue(x => x.Filter) .Select(x => { if (x == null || _openFilter.Equals(x)) { return(0); } return(_closedFilter.Equals(x) ? 1 : -1); }) .ToProperty(this, x => x.SelectedFilter); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(_ => { IssuesBacking.Clear(); LoadCommand.ExecuteIfCan(); }); }
public StumbleViewModel(IApplicationService applicationService, INetworkActivityService networkActivity, IFeaturesService featuresService, IDefaultValueService defaultValues) : base(applicationService, networkActivity) { this._applicationService = applicationService; var localStumbleCount = 0; GoToPurchaseCommand = ReactiveCommand.Create(); GoToPurchaseCommand.Subscribe(_ => CreateAndShowViewModel <PurchaseProViewModel>()); StumbleCommand = ReactiveCommand.CreateAsyncTask(LoadCommand.IsExecuting.Select(x => !x), x => StumbleRepository()); StumbleCommand.Subscribe(x => { if (!featuresService.ProEditionEnabled) { var stumbleTimes = defaultValues.Get <nint>(StumbleKey) + 1; defaultValues.Set(StumbleKey, stumbleTimes); if (localStumbleCount > 0 && stumbleTimes % 50 == 0) { GoToPurchaseCommand.ExecuteIfCan(); } } localStumbleCount++; Reset(); RepositoryIdentifier = new RepositoryIdentifierModel(x.Repository.Owner, x.Repository.Name); LoadCommand.ExecuteIfCan(); }); StumbleCommand.TriggerNetworkActivity(networkActivity); DislikeCommand.Subscribe(_ => StumbleCommand.ExecuteIfCan()); LikeCommand.Subscribe(_ => StumbleCommand.ExecuteIfCan()); }
public NotificationsViewModel(ISessionService applicationService) { _applicationService = applicationService; Title = "Notifications"; _showEditButton = this.WhenAnyValue(x => x.ActiveFilter) .Select(x => x != AllFilter) .ToProperty(this, x => x.ShowEditButton); var groupedNotifications = new ReactiveList <NotificationGroupViewModel>(); GroupedNotifications = groupedNotifications; Notifications = _notifications.CreateDerivedCollection(y => new NotificationItemViewModel(y, GoToNotification, DeleteNotification)); Notifications.Changed.Where(x => x.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Reset) .Select(_ => Notifications) .Subscribe(notifications => groupedNotifications.Reset(notifications.GroupBy(x => x.Notification.Repository.FullName).Select(x => { var items = notifications.CreateDerivedCollection(y => y, filter: y => y.Notification.Repository.FullName == x.Key); return(new NotificationGroupViewModel(x.Key, items)); }))); _anyItemsSelected = Notifications.Changed .SelectMany(x => Notifications) .Select(x => x.WhenAnyValue(y => y.IsSelected)) .Merge() .Select(x => Notifications.Select(y => y.IsSelected).Any(y => y)) .ToProperty(this, x => x.IsAnyItemsSelected); ReadSelectedCommand = ReactiveCommand.Create().WithSubscription(_ => { if (GroupedNotifications.SelectMany(x => x.Notifications).All(x => !x.IsSelected)) { var request = new Octokit.MarkAsReadRequest { LastReadAt = DateTimeOffset.Now }; applicationService.GitHubClient.Notification.MarkAsRead(request).ToBackground(); _notifications.Clear(); } else { var selected = GroupedNotifications.SelectMany(x => x.Notifications) .Where(x => x.IsSelected && x.Notification.Unread).ToList(); var tasks = selected .Select(t => _applicationService.GitHubClient.Notification.MarkAsRead(int.Parse(t.Id))); Task.WhenAll(tasks).ToBackground(); _notifications.RemoveAll(selected.Select(y => y.Notification)); } }); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => { var all = ActiveFilter == AllFilter; var participating = ActiveFilter == ParticipatingFilter; var req = new Octokit.NotificationsRequest { All = all, Participating = participating, Since = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(365)) }; _notifications.Reset(await applicationService.GitHubClient.Notification.GetAllForCurrent(req)); }); _notifications.CountChanged .Where(_ => ActiveFilter == UnreadFilter) .Subscribe(_notificationCount.OnNext); this.WhenAnyValue(x => x.ActiveFilter).Skip(1).Subscribe(x => { _notifications.Clear(); LoadCommand.ExecuteIfCan(); }); }
public NotificationsViewModel(IApplicationService applicationService) { _applicationService = applicationService; Title = "Notifications"; var whenNotificationsChange = _notifications.Changed.Select(_ => Unit.Default) .Merge(_notifications.ItemChanged.Select(_ => Unit.Default)); _groupedNotifications = whenNotificationsChange.Select(_ => _notifications.GroupBy(x => x.Repository.FullName) .Select(x => new NotificationGroupViewModel(x.Key, new ReactiveList <NotificationModel>(x), __ => { }))) .ToProperty(this, t => t.GroupedNotifications); LoadCommand = ReactiveCommand.CreateAsyncTask(t => { var req = applicationService.Client.Notifications.GetAll(all: Filter.All, participating: Filter.Participating); return(this.RequestModel(req, t as bool?, response => _notifications.Reset(response.Data))); }); GoToNotificationCommand = ReactiveCommand.Create(); GoToNotificationCommand.OfType <NotificationModel>().Subscribe(GoToNotification); var canReadAll = _notifications.CountChanged.Select(x => x > 0).CombineLatest( this.WhenAnyValue(x => x.ShownIndex).Select(x => x != 2), (x, y) => x & y); ReadAllCommand = ReactiveCommand.CreateAsyncTask(canReadAll, async t => { try { if (!_notifications.Any()) { return; } await applicationService.Client.ExecuteAsync(applicationService.Client.Notifications.MarkAsRead()); _notifications.Clear(); } catch (Exception e) { throw new Exception("Unable to mark all notifications as read. Please try again.", e); } }); ReadRepositoriesCommand = ReactiveCommand.CreateAsyncTask(async t => { try { var repo = t as string; if (repo == null) { return; } var repoId = new RepositoryIdentifier(repo); await applicationService.Client.ExecuteAsync(applicationService.Client.Notifications.MarkRepoAsRead(repoId.Owner, repoId.Name)); _notifications.RemoveAll(_notifications.Where(x => string.Equals(x.Repository.FullName, repo, StringComparison.OrdinalIgnoreCase)).ToList()); } catch (Exception e) { throw new Exception("Unable to mark repositories' notifications as read. Please try again.", e); } }); this.WhenAnyValue(x => x.ShownIndex).Subscribe(x => { switch (x) { case 0: Filter = NotificationsFilterModel.CreateUnreadFilter(); break; case 1: Filter = NotificationsFilterModel.CreateParticipatingFilter(); break; default: Filter = NotificationsFilterModel.CreateAllFilter(); break; } }); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(x => LoadCommand.ExecuteIfCan()); }
public GistViewModel(IApplicationService applicationService, IActionMenuFactory actionMenuService, IAlertDialogFactory alertDialogFactory) { Comments = new ReactiveList <GistCommentModel>(); Title = "Gist"; this.WhenAnyValue(x => x.Gist).Where(x => x != null && x.Files != null && x.Files.Count > 0) .Select(x => x.Files.First().Key).Subscribe(x => Title = x); ShareCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Gist).Select(x => x != null)); ShareCommand.Subscribe(_ => actionMenuService.ShareUrl(new Uri(Gist.HtmlUrl))); ToggleStarCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.IsStarred).Select(x => x.HasValue), 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 = ReactiveCommand.CreateAsyncTask(async t => { var data = await applicationService.Client.ExecuteAsync(applicationService.Client.Gists[Id].ForkGist()); var forkedGist = data.Data; var vm = this.CreateViewModel <GistViewModel>(); vm.Id = forkedGist.Id; vm.Gist = forkedGist; NavigateTo(vm); }); ForkCommand.IsExecuting.Subscribe(x => { if (x) { alertDialogFactory.Show("Forking..."); } else { alertDialogFactory.Hide(); } }); GoToEditCommand = ReactiveCommand.Create(); GoToHtmlUrlCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Gist).Select(x => x != null && !string.IsNullOrEmpty(x.HtmlUrl))); GoToHtmlUrlCommand.Select(_ => Gist.HtmlUrl).Subscribe(x => { var vm = this.CreateViewModel <WebBrowserViewModel>(); vm.Url = x; NavigateTo(vm); }); GoToFileSourceCommand = ReactiveCommand.Create(); GoToFileSourceCommand.OfType <GistFileModel>().Subscribe(x => { var vm = this.CreateViewModel <GistFileViewModel>(); vm.Id = Id; vm.GistFile = x; vm.Filename = x.Filename; NavigateTo(vm); }); GoToOwnerCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Gist).Select(x => x != null && x.Owner != null)); GoToOwnerCommand.Subscribe(x => { var vm = this.CreateViewModel <UserViewModel>(); vm.Username = Gist.Owner.Login; NavigateTo(vm); }); AddCommentCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel <GistCommentViewModel>(); vm.Id = Id; vm.SaveCommand.Subscribe(x => LoadCommand.ExecuteIfCan()); NavigateTo(vm); }); ShowMenuCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.Gist).Select(x => x != null), _ => { var menu = actionMenuService.Create(Title); if (Gist.Owner != null && string.Equals(applicationService.Account.Username, Gist.Owner.Login, StringComparison.OrdinalIgnoreCase)) { menu.AddButton("Edit", GoToEditCommand); } else { menu.AddButton("Fork", ForkCommand); } menu.AddButton("Share", ShareCommand); menu.AddButton("Show in GitHub", GoToHtmlUrlCommand); return(menu.Show()); }); LoadCommand = ReactiveCommand.CreateAsyncTask(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); Comments.SimpleCollectionLoad(applicationService.Client.Gists[Id].GetComments(), forceCacheInvalidation); return(t1); }); }
public PullRequestViewModel(IApplicationService applicationService, IMarkdownService markdownService, IActionMenuService actionMenuService) { _applicationService = applicationService; _markdownService = markdownService; GoToUrlCommand = this.CreateUrlCommand(); Comments = new ReactiveList <Octokit.IssueComment>(); Events = new ReactiveList <Octokit.IssueEvent>(); this.WhenAnyValue(x => x.Id).Subscribe(x => Title = "Pull Request #" + x); _canMerge = this.WhenAnyValue(x => x.PullRequest) .Select(x => x != null && !x.Merged) .ToProperty(this, x => x.CanMerge); var canMergeObservable = this.WhenAnyValue(x => x.PullRequest).Select(x => x != null && !x.Merged && x.Mergeable.HasValue && x.Mergeable.Value); MergeCommand = ReactiveCommand.CreateAsyncTask(canMergeObservable, async t => { var req = new Octokit.MergePullRequest(null); var response = await _applicationService.GitHubClient.PullRequest.Merge(RepositoryOwner, RepositoryName, Id, req); if (!response.Merged) { throw new Exception(string.Format("Unable to merge pull request: {0}", response.Message)); } LoadCommand.ExecuteIfCan(); }); ToggleStateCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.PullRequest).Select(x => x != null), async t => { var newState = PullRequest.State == Octokit.ItemState.Open ? Octokit.ItemState.Closed : Octokit.ItemState.Open; try { var req = new Octokit.PullRequestUpdate { State = newState }; PullRequest = await _applicationService.GitHubClient.PullRequest.Update(RepositoryOwner, RepositoryName, Id, req); } catch (Exception e) { throw new Exception("Unable to " + (newState == Octokit.ItemState.Closed ? "close" : "open") + " the item. " + e.Message, e); } }); GoToHtmlUrlCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.PullRequest).Select(x => x != null)); GoToHtmlUrlCommand.Select(_ => PullRequest.HtmlUrl).Subscribe(this.ShowWebBrowser); GoToCommitsCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = CreateViewModel <PullRequestCommitsViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.PullRequestId = Id; ShowViewModel(vm); }); GoToFilesCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = CreateViewModel <PullRequestFilesViewModel>(); vm.Username = RepositoryOwner; vm.Repository = RepositoryName; vm.PullRequestId = Id; ShowViewModel(vm); }); // // ShareCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.PullRequest).Select(x => x != null && !string.IsNullOrEmpty(x.HtmlUrl))) // .WithSubscription(_ => shareService.ShareUrl(PullRequest.HtmlUrl)); GoToEditCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = CreateViewModel <IssueEditViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.Id = Id; //vm.Issue = Issue; // vm.WhenAnyValue(x => x.Issue).Skip(1).Subscribe(x => Issue = x); ShowViewModel(vm); }); GoToLabelsCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Issue).Select(x => x != null)).WithSubscription(_ => { var vm = CreateViewModel <IssueLabelsViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.IssueId = Id; 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 = ReactiveCommand.Create(this.WhenAnyValue(x => x.Issue).Select(x => x != null)).WithSubscription(_ => { var vm = CreateViewModel <IssueMilestonesViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.IssueId = Id; 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 = ReactiveCommand.Create(this.WhenAnyValue(x => x.Issue).Select(x => x != null)).WithSubscription(_ => { var vm = CreateViewModel <IssueAssignedToViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.IssueId = Id; 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 = ReactiveCommand.Create().WithSubscription(_ => { var vm = CreateViewModel <IssueCommentViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.Id = Id; vm.CommentAdded.Subscribe(Comments.Add); ShowViewModel(vm); }); ShowMenuCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.PullRequest).Select(x => x != null), _ => { var menu = actionMenuService.Create(Title); menu.AddButton("Edit", GoToEditCommand); menu.AddButton(PullRequest.State == Octokit.ItemState.Closed ? "Open" : "Close", ToggleStateCommand); menu.AddButton("Comment", GoToAddCommentCommand); menu.AddButton("Share", ShareCommand); menu.AddButton("Show in GitHub", GoToHtmlUrlCommand); return(menu.Show()); }); _markdownDescription = this.WhenAnyValue(x => x.PullRequest).IsNotNull() .Select(x => _markdownService.Convert(x.Body)) .ToProperty(this, x => x.MarkdownDescription); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => { var pullRequest = _applicationService.GitHubClient.PullRequest.Get(RepositoryOwner, RepositoryName, Id); var comments = _applicationService.GitHubClient.PullRequest.Comment.GetAll(RepositoryOwner, RepositoryName, Id); var events = _applicationService.GitHubClient.Issue.Events.GetForIssue(RepositoryOwner, RepositoryName, Id); var issue = _applicationService.GitHubClient.Issue.Get(RepositoryOwner, RepositoryName, Id); await Task.WhenAll(pullRequest, issue, comments, events); PullRequest = pullRequest.Result; Issue = issue.Result; }); }
public NotificationsViewModel(IApplicationService applicationService) { _applicationService = applicationService; _notifications = new ReactiveList <NotificationModel>(); Notifications = _notifications.CreateDerivedCollection(x => x); LoadCommand = ReactiveCommand.CreateAsyncTask(t => { var req = applicationService.Client.Notifications.GetAll(all: Filter.All, participating: Filter.Participating); return(this.RequestModel(req, t as bool?, response => _notifications.Reset(response.Data))); }); GoToNotificationCommand = ReactiveCommand.Create(); GoToNotificationCommand.OfType <NotificationModel>().Subscribe(GoToNotification); ReadAllCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.ShownIndex).Select(x => x != 2), async t => { try { if (!Notifications.Any()) { return; } await applicationService.Client.ExecuteAsync(applicationService.Client.Notifications.MarkAsRead()); _notifications.Clear(); } catch (Exception e) { throw new Exception("Unable to mark all notifications as read. Please try again.", e); } }); ReadRepositoriesCommand = ReactiveCommand.CreateAsyncTask(async t => { try { var repo = t as string; if (repo == null) { return; } var repoId = new RepositoryIdentifier(repo); await applicationService.Client.ExecuteAsync(applicationService.Client.Notifications.MarkRepoAsRead(repoId.Owner, repoId.Name)); _notifications.RemoveAll(Notifications.Where(x => string.Equals(x.Repository.FullName, repo, StringComparison.OrdinalIgnoreCase)).ToList()); } catch (Exception e) { throw new Exception("Unable to mark repositories' notifications as read. Please try again.", e); } }); this.WhenAnyValue(x => x.ShownIndex).Subscribe(x => { switch (x) { case 0: Filter = NotificationsFilterModel.CreateUnreadFilter(); break; case 1: Filter = NotificationsFilterModel.CreateParticipatingFilter(); break; default: Filter = NotificationsFilterModel.CreateAllFilter(); break; } }); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(x => LoadCommand.ExecuteIfCan()); }
public SourceTreeViewModel(IApplicationService applicationService) { Branch = "master"; Path = string.Empty; var content = new ReactiveList <ContentModel>(); Content = content.CreateDerivedCollection( x => CreateSourceItemViewModel(x), filter: x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); _canAddFile = this.WhenAnyValue(x => x.TrueBranch, y => y.PushAccess) .Select(x => x.Item1 && x.Item2.HasValue && x.Item2.Value) .ToProperty(this, x => x.CanAddFile); this.WhenAnyValue(x => x.Path, y => y.RepositoryName, (x, y) => new { Path = x, Repo = y }) .Subscribe(x => { if (string.IsNullOrEmpty(x.Path)) { Title = string.IsNullOrEmpty(x.Repo) ? "Source" : x.Repo; } else { var split = x.Path.TrimEnd('/').Split('/'); Title = split[split.Length - 1]; } }); GoToAddFileCommand = ReactiveCommand.Create( this.WhenAnyValue(x => x.PushAccess, x => x.TrueBranch) .Select(x => x.Item1.HasValue && x.Item1.Value && x.Item2)) .WithSubscription(_ => { var vm = this.CreateViewModel <CreateFileViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.Branch = Branch; vm.Path = Path; vm.SaveCommand.Subscribe(z => LoadCommand.ExecuteIfCan()); NavigateTo(vm); }); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => { if (!PushAccess.HasValue) { applicationService.GitHubClient.Repository.Get(RepositoryOwner, RepositoryName) .ToBackground(x => PushAccess = x.Permissions.Push); } var path = Path; if (string.Equals(path, "/", StringComparison.OrdinalIgnoreCase)) { path = string.Empty; } var request = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContent(Path, Branch); var data = new List <ContentModel>(); var response = await applicationService.Client.ExecuteAsync(request); data.AddRange(response.Data); while (response.More != null) { response = await applicationService.Client.ExecuteAsync(response.More); data.AddRange(response.Data); } content.Reset(data.OrderBy(y => y.Type).ThenBy(y => y.Name)); }); }
public PullRequestViewModel( IApplicationService applicationService, IMarkdownService markdownService, IActionMenuFactory actionMenuService) : base(applicationService, markdownService) { this.WhenAnyValue(x => x.Id) .Subscribe(x => Title = "Pull Request #" + x); _canMerge = this.WhenAnyValue(x => x.PullRequest) .Select(x => x != null && !x.Merged) .ToProperty(this, x => x.CanMerge); var canMergeObservable = this.WhenAnyValue(x => x.PullRequest).Select(x => x != null && !x.Merged && x.Mergeable.HasValue && x.Mergeable.Value); MergeCommand = ReactiveCommand.CreateAsyncTask(canMergeObservable, async t => { var req = new Octokit.MergePullRequest(null); var response = await applicationService.GitHubClient.PullRequest.Merge(RepositoryOwner, RepositoryName, Id, req); if (!response.Merged) { throw new Exception(string.Format("Unable to merge pull request: {0}", response.Message)); } LoadCommand.ExecuteIfCan(); }); // ToggleStateCommand = ReactiveCommand.CreateAsyncTask( // this.WhenAnyValue(x => x.PullRequest).Select(x => x != null), // async t => // { // var newState = PullRequest.State == Octokit.ItemState.Open ? Octokit.ItemState.Closed : Octokit.ItemState.Open; // // try // { // var req = new Octokit.PullRequestUpdate { State = newState }; // PullRequest = await applicationService.GitHubClient.PullRequest.Update(RepositoryOwner, RepositoryName, Id, req); // } // catch (Exception e) // { // throw new Exception("Unable to " + (newState == Octokit.ItemState.Closed ? "close" : "open") + " the item. " + e.Message, e); // } // }); GoToHtmlUrlCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.PullRequest).Select(x => x != null)); GoToHtmlUrlCommand.Select(_ => PullRequest.HtmlUrl).Subscribe(GoToUrlCommand.ExecuteIfCan); GoToCommitsCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel <PullRequestCommitsViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.PullRequestId = Id; NavigateTo(vm); }); GoToFilesCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel <PullRequestFilesViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.PullRequestId = Id; NavigateTo(vm); }); ShareCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.PullRequest).Select(x => x != null)); ShareCommand.Subscribe(_ => actionMenuService.ShareUrl(PullRequest.HtmlUrl)); GoToEditCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel <IssueEditViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.Id = Id; //vm.Issue = Issue; // vm.WhenAnyValue(x => x.Issue).Skip(1).Subscribe(x => Issue = x); NavigateTo(vm); }); ShowMenuCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.PullRequest).Select(x => x != null), _ => { var menu = actionMenuService.Create(Title); menu.AddButton("Edit", GoToEditCommand); menu.AddButton(PullRequest.State == Octokit.ItemState.Closed ? "Open" : "Close", ToggleStateCommand); menu.AddButton("Comment", GoToAddCommentCommand); menu.AddButton("Share", ShareCommand); menu.AddButton("Show in GitHub", GoToHtmlUrlCommand); return(menu.Show()); }); }