public PullRequestViewModel(
ISessionService applicationService,
IMarkdownService markdownService,
IActionMenuFactory actionMenuService,
IAlertDialogFactory alertDialogFactory)
: base(applicationService, markdownService, actionMenuService, alertDialogFactory)
{
this.WhenAnyValue(x => x.Id)
.Subscribe(x => Title = "Pull Request #" + x);
this.WhenAnyValue(x => x.PullRequest.HtmlUrl)
.ToProperty(this, x => x.HtmlUrl, out _htmlUrl);
var canMergeObservable = this.WhenAnyValue(x => x.PullRequest)
.Select(x => x != null && !x.Merged && x.Mergeable.HasValue && x.Mergeable.Value);
_canMerge = canMergeObservable.CombineLatest(
this.WhenAnyValue(x => x.PushAccess), (x, y) => x && y)
.ToProperty(this, x => x.CanMerge);
_commentsCount = this.WhenAnyValue(x => x.Issue.Comments, x => x.Comments.Count, (x, y) => x + y)
.ToProperty(this, x => x.CommentCount);
MergeCommand = ReactiveCommand.CreateAsyncTask(canMergeObservable, async t => {
using (alertDialogFactory.Activate("Merging..."))
{
var req = new MergePullRequest {
Message = MergeComment
};
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));
}
await LoadCommand.ExecuteAsync();
}
});
var canGoToCommits = this.WhenAnyValue(x => x.PullRequest.Commits).Select(x => x > 0);
GoToCommitsCommand = ReactiveCommand.Create(canGoToCommits);
GoToCommitsCommand
.Select(x => this.CreateViewModel <PullRequestCommitsViewModel>())
.Select(x => x.Init(RepositoryOwner, RepositoryName, Id))
.Subscribe(NavigateTo);
var canGoToFiles = this.WhenAnyValue(x => x.PullRequest.ChangedFiles).Select(x => x > 0);
GoToFilesCommand = ReactiveCommand.Create(canGoToFiles);
GoToFilesCommand
.Select(x => this.CreateViewModel <PullRequestFilesViewModel>())
.Select(x => x.Init(RepositoryOwner, RepositoryName, Id, PullRequest.Head.Sha))
.Do(x => x.CommentCreated.Subscribe(AddComment))
.Subscribe(NavigateTo);
}
public RepositoryViewModel(ISessionService applicationService,
IAccountsRepository accountsService, IActionMenuFactory actionMenuService)
{
ApplicationService = applicationService;
_accountsService = accountsService;
var validRepositoryObservable = this.WhenAnyValue(x => x.Repository).Select(x => x != null);
this.WhenAnyValue(x => x.RepositoryName).Subscribe(x => Title = x);
this.WhenAnyValue(x => x.Repository.Owner.AvatarUrl)
.Select(x => new GitHubAvatar(x))
.ToProperty(this, x => x.Avatar, out _avatar);
this.WhenAnyValue(x => x.Repository).Subscribe(x =>
{
Stargazers = (int?)x?.StargazersCount;
Watchers = (int?)x?.SubscribersCount;
});
this.WhenAnyValue(x => x.Repository.Description)
.Select(x => Emojis.FindAndReplace(x))
.ToProperty(this, x => x.Description, out _description);
ToggleStarCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.IsStarred).Select(x => x.HasValue), t => ToggleStar());
ToggleWatchCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.IsWatched, x => x.HasValue), t => ToggleWatch());
GoToOwnerCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository).Select(x => x != null));
GoToOwnerCommand.Select(_ => Repository.Owner).Subscribe(x => {
if (AccountType.Organization.Equals(x.Type))
{
var vm = this.CreateViewModel <OrganizationViewModel>();
vm.Init(RepositoryOwner);
NavigateTo(vm);
}
else
{
var vm = this.CreateViewModel <UserViewModel>();
vm.Init(RepositoryOwner);
NavigateTo(vm);
}
});
PinCommand = ReactiveCommand.Create(validRepositoryObservable);
PinCommand.Subscribe(x => PinRepository());
GoToForkParentCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && x.Fork && x.Parent != null));
GoToForkParentCommand.Subscribe(x =>
{
var vm = this.CreateViewModel <RepositoryViewModel>();
vm.RepositoryOwner = Repository.Parent.Owner.Login;
vm.RepositoryName = Repository.Parent.Name;
vm.Repository = Repository.Parent;
NavigateTo(vm);
});
GoToStargazersCommand = ReactiveCommand.Create();
GoToStargazersCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <RepositoryStargazersViewModel>();
vm.Init(RepositoryOwner, RepositoryName);
NavigateTo(vm);
});
GoToWatchersCommand = ReactiveCommand.Create();
GoToWatchersCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <RepositoryWatchersViewModel>();
vm.Init(RepositoryOwner, RepositoryName);
NavigateTo(vm);
});
GoToEventsCommand = ReactiveCommand.Create();
GoToEventsCommand.Subscribe(_ => {
var vm = this.CreateViewModel <RepositoryEventsViewModel>();
vm.Init(RepositoryOwner, RepositoryName);
NavigateTo(vm);
});
GoToIssuesCommand = ReactiveCommand.Create();
GoToIssuesCommand
.Select(_ => this.CreateViewModel <IssuesViewModel>())
.Select(x => x.Init(RepositoryOwner, RepositoryName))
.Subscribe(NavigateTo);
GoToReadmeCommand = ReactiveCommand.Create();
GoToReadmeCommand
.Select(_ => this.CreateViewModel <ReadmeViewModel>())
.Select(x => x.Init(RepositoryOwner, RepositoryName))
.Subscribe(NavigateTo);
GoToBranchesCommand = ReactiveCommand.Create();
GoToBranchesCommand
.Select(_ => this.CreateViewModel <CommitBranchesViewModel>())
.Select(x => x.Init(RepositoryOwner, RepositoryName))
.Subscribe(NavigateTo);
GoToCommitsCommand = ReactiveCommand.Create();
GoToCommitsCommand.Subscribe(_ =>
{
if (Branches != null && Branches.Count == 1)
{
var vm = this.CreateViewModel <CommitsViewModel>();
var branch = Repository == null ? null : Repository.DefaultBranch;
NavigateTo(vm.Init(RepositoryOwner, RepositoryName, branch));
}
else
{
GoToBranchesCommand.ExecuteIfCan();
}
});
GoToPullRequestsCommand = ReactiveCommand.Create();
GoToPullRequestsCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <PullRequestsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToSourceCommand = ReactiveCommand.Create();
GoToSourceCommand.Subscribe(_ =>
{
var vm = this.CreateViewModel <BranchesAndTagsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToContributors = ReactiveCommand.Create();
GoToContributors.Subscribe(_ =>
{
var vm = this.CreateViewModel <RepositoryContributorsViewModel>();
vm.Init(RepositoryOwner, RepositoryName);
NavigateTo(vm);
});
GoToForksCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = this.CreateViewModel <RepositoryForksViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
GoToReleasesCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = this.CreateViewModel <ReleasesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
NavigateTo(vm);
});
ShareCommand = ReactiveCommand.Create(validRepositoryObservable);
ShareCommand.Subscribe(sender => actionMenuService.ShareUrl(sender, Repository.HtmlUrl));
var canShowMenu = this.WhenAnyValue(x => x.Repository, x => x.IsStarred, x => x.IsWatched)
.Select(x => x.Item1 != null && x.Item2 != null && x.Item3 != null);
ShowMenuCommand = ReactiveCommand.CreateAsyncTask(canShowMenu, sender => {
var menu = actionMenuService.Create();
menu.AddButton(IsPinned ? "Unpin from Slideout Menu" : "Pin to Slideout Menu", PinCommand);
menu.AddButton(IsStarred.Value ? "Unstar This Repo" : "Star This Repo", ToggleStarCommand);
menu.AddButton(IsWatched.Value ? "Unwatch This Repo" : "Watch This Repo", ToggleWatchCommand);
menu.AddButton("Show in GitHub", GoToHtmlUrlCommand);
menu.AddButton("Share", ShareCommand);
return(menu.Show(sender));
});
var gotoWebUrl = new Action <string>(x =>
{
var vm = this.CreateViewModel <WebBrowserViewModel>();
vm.Init(x);
NavigateTo(vm);
});
GoToHtmlUrlCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && !string.IsNullOrEmpty(x.HtmlUrl)));
GoToHtmlUrlCommand.Select(_ => Repository.HtmlUrl).Subscribe(gotoWebUrl);
GoToHomepageCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && !string.IsNullOrEmpty(x.Homepage)));
GoToHomepageCommand.Select(_ => Repository.Homepage).Subscribe(gotoWebUrl);
LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => {
var t1 = applicationService.GitHubClient.Repository.Get(RepositoryOwner, RepositoryName);
applicationService.GitHubClient.Repository.Content.GetReadme(RepositoryOwner, RepositoryName)
.ToBackground(x => Readme = x);
applicationService.GitHubClient.Repository.GetAllBranches(RepositoryOwner, RepositoryName)
.ToBackground(x => Branches = x);
applicationService.GitHubClient.Activity.Watching.CheckWatched(RepositoryOwner, RepositoryName)
.ToBackground(x => IsWatched = x);
applicationService.GitHubClient.Activity.Starring.CheckStarred(RepositoryOwner, RepositoryName)
.ToBackground(x => IsStarred = x);
applicationService.Client.ExecuteAsync(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContributors())
.ToBackground(x => Contributors = x.Data.Count);
// applicationService.GitHubClient.Repository.GetAllLanguages(RepositoryOwner, RepositoryName)
// .ToBackground(x => Languages = x.Count);
applicationService.Client.ExecuteAsync(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetReleases())
.ToBackground(x => Releases = x.Data.Count);
Repository = await t1;
});
}
public RepositoryViewModel(IApplicationService applicationService, IAccountsService accountsService, IActionMenuService actionMenuService)
{
ApplicationService = applicationService;
_accountsService = accountsService;
this.WhenAnyValue(x => x.RepositoryName).Subscribe(x => Title = x);
ToggleStarCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.IsStarred).Select(x => x.HasValue), t => ToggleStar());
ToggleWatchCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.IsWatched, x => x.HasValue), t => ToggleWatch());
GoToOwnerCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository).Select(x => x != null));
GoToOwnerCommand.Select(_ => Repository.Owner).Subscribe(x =>
{
if (string.Equals(x.Type, "organization", StringComparison.OrdinalIgnoreCase))
{
var vm = CreateViewModel <OrganizationViewModel>();
vm.Username = RepositoryOwner;
ShowViewModel(vm);
}
else
{
var vm = CreateViewModel <UserViewModel>();
vm.Username = RepositoryOwner;
ShowViewModel(vm);
}
});
PinCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository).Select(x => x != null));
PinCommand.Subscribe(x => PinRepository());
GoToForkParentCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && x.Fork && x.Parent != null));
GoToForkParentCommand.Subscribe(x =>
{
var vm = CreateViewModel <RepositoryViewModel>();
vm.RepositoryOwner = Repository.Parent.Owner.Login;
vm.RepositoryName = Repository.Parent.Name;
vm.Repository = Repository.Parent;
ShowViewModel(vm);
});
GoToStargazersCommand = ReactiveCommand.Create();
GoToStargazersCommand.Subscribe(_ =>
{
var vm = CreateViewModel <RepositoryStargazersViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToWatchersCommand = ReactiveCommand.Create();
GoToWatchersCommand.Subscribe(_ =>
{
var vm = CreateViewModel <RepositoryWatchersViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToEventsCommand = ReactiveCommand.Create();
GoToEventsCommand.Subscribe(_ =>
{
var vm = CreateViewModel <RepositoryEventsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToIssuesCommand = ReactiveCommand.Create();
GoToIssuesCommand.Subscribe(_ =>
{
var vm = CreateViewModel <IssuesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToReadmeCommand = ReactiveCommand.Create();
GoToReadmeCommand.Subscribe(_ =>
{
var vm = CreateViewModel <ReadmeViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToBranchesCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <CommitBranchesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToCommitsCommand = ReactiveCommand.Create();
GoToCommitsCommand.Subscribe(_ =>
{
if (Branches != null && Branches.Count == 1)
{
var vm = CreateViewModel <ChangesetsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.Branch = Repository == null ? null : Repository.DefaultBranch;
ShowViewModel(vm);
}
else
{
GoToBranchesCommand.ExecuteIfCan();
}
});
GoToPullRequestsCommand = ReactiveCommand.Create();
GoToPullRequestsCommand.Subscribe(_ =>
{
var vm = CreateViewModel <PullRequestsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToSourceCommand = ReactiveCommand.Create();
GoToSourceCommand.Subscribe(_ =>
{
var vm = CreateViewModel <BranchesAndTagsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToContributors = ReactiveCommand.Create();
GoToContributors.Subscribe(_ =>
{
var vm = CreateViewModel <RepositoryContributorsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToForksCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <RepositoryForksViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToReleasesCommand = ReactiveCommand.Create().WithSubscription(_ =>
{
var vm = CreateViewModel <ReleasesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
ShowMenuCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.Repository, x => x.IsStarred, x => x.IsWatched)
.Select(x => x.Item1 != null && x.Item2 != null && x.Item3 != null),
_ =>
{
var menu = actionMenuService.Create(Title);
menu.AddButton(IsPinned ? "Unpin from Slideout Menu" : "Pin to Slideout Menu", PinCommand);
menu.AddButton(IsStarred.Value ? "Unstar This Repo" : "Star This Repo", ToggleStarCommand);
menu.AddButton(IsWatched.Value ? "Unwatch This Repo" : "Watch This Repo", ToggleWatchCommand);
menu.AddButton("Show in GitHub", GoToHtmlUrlCommand);
return(menu.Show());
});
GoToHtmlUrlCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && !string.IsNullOrEmpty(x.HtmlUrl)));
GoToHtmlUrlCommand.Select(_ => Repository.HtmlUrl).Subscribe(this.ShowWebBrowser);
GoToHomepageCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && !string.IsNullOrEmpty(x.Homepage)));
GoToHomepageCommand.Select(_ => Repository.Homepage).Subscribe(this.ShowWebBrowser);
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
{
var forceCacheInvalidation = t as bool?;
var t1 = this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Get(),
forceCacheInvalidation, response => Repository = response.Data);
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetReadme(),
forceCacheInvalidation, response => Readme = response.Data).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetBranches(),
forceCacheInvalidation, response => Branches = response.Data).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].IsWatching(),
forceCacheInvalidation, response => IsWatched = response.Data).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].IsStarred(),
forceCacheInvalidation, response => IsStarred = response.Data).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContributors(),
forceCacheInvalidation, response => Contributors = response.Data.Count).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetLanguages(),
forceCacheInvalidation, response => Languages = response.Data.Count).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetReleases(),
forceCacheInvalidation, response => Releases = response.Data.Count).FireAndForget();
return(t1);
});
}
public RepositoryViewModel(
string username, string repositoryName, Repository repository = null,
IApplicationService applicationService = null, IActionMenuService actionMenuService = null)
{
applicationService = _applicationService = applicationService ?? Locator.Current.GetService <IApplicationService>();
actionMenuService = actionMenuService ?? Locator.Current.GetService <IActionMenuService>();
Repository = repository;
_branches.Changed
.Select(_ => _branches.Count)
.ToProperty(this, x => x.BranchesCount, out _branchesCount);
this.WhenAnyValue(x => x.Repository.Name)
.StartWith(repositoryName)
.Subscribe(x => Title = x);
LoadCommand = ReactiveCommand.CreateFromTask(async _ => {
Repository = await applicationService.Client.Repositories.Get(username, repositoryName);
_applicationService.Client.Repositories.GetWatchers(username, repositoryName)
.ToBackground(x => Watchers = x.Size);
_applicationService.Client.Repositories.GetForks(username, repositoryName)
.ToBackground(x => Forks = x.Size);
_applicationService.Client.Repositories.GetBranches(username, repositoryName)
.ToBackground(x => _branches.Reset(x));
if (!Repository.HasIssues)
{
Issues = 0;
}
else
{
_applicationService.Client.Issues.GetAll(username, repositoryName, limit: 0)
.ToBackground(x => Issues = x.Count);
}
LoadReadme(username, repositoryName).ToBackground();
});
ForkCommand = ReactiveCommand.CreateFromTask(async _ => {
var fork = await applicationService.Client.Repositories.Fork(username, repositoryName);
NavigateTo(new RepositoryViewModel(fork.Owner, fork.Slug));
});
var canGoToFork = this.WhenAnyValue(x => x.Repository)
.Select(x => x?.Parent != null);
GoToForkParentCommand = ReactiveCommand.Create(() => {
var id = RepositoryIdentifier.FromFullName(Repository.Parent.FullName);
NavigateTo(new RepositoryViewModel(id.Owner, id.Name));
}, canGoToFork);
GoToReadmeCommand = ReactiveCommand.Create(
() => NavigateTo(new ReadmeViewModel(username, repositoryName, _readmeFilename)),
this.WhenAnyValue(x => x.HasReadme));
GoToPullRequestsCommand
.Select(_ => new PullRequestsViewModel(username, repositoryName))
.Subscribe(NavigateTo);
GoToWikiCommand = ReactiveCommand.Create(
() => NavigateTo(new WikiViewModel(username, repositoryName)),
this.WhenAnyValue(x => x.Repository.HasWiki));
GoToSourceCommand
.Select(_ => new BranchesAndTagsViewModel(username, repositoryName))
.Subscribe(NavigateTo);
GoToIssuesCommand
.Select(_ => new IssuesViewModel(username, repositoryName))
.Subscribe(NavigateTo);
GoToOwnerCommand
.Select(_ => new UserViewModel(username))
.Subscribe(NavigateTo);
GoToStargazersCommand
.Select(_ => new RepositoryWatchersViewModel(username, repositoryName))
.Subscribe(NavigateTo);
GoToEventsCommand
.Select(_ => new RepositoryEventsViewModel(username, repositoryName))
.Subscribe(NavigateTo);
GoToBranchesCommand
.Select(_ => BranchesViewModel.ForSource(username, repositoryName))
.Subscribe(NavigateTo);
var validWebsite = this.WhenAnyValue(x => x.Repository.Website)
.Select(x => !string.IsNullOrEmpty(x));
GoToWebsiteCommand = ReactiveCommand.Create(
() => NavigateTo(new WebBrowserViewModel(Repository.Website)),
validWebsite);
GoToCommitsCommand
.Subscribe(_ =>
{
if (_branches.Count == 1)
{
NavigateTo(new CommitsViewModel(username, repositoryName, _branches.FirstOrDefault()?.Node));
}
else
{
NavigateTo(BranchesViewModel.ForCommits(username, repositoryName));
}
});
ShowMenuCommand = ReactiveCommand.CreateFromTask(sender =>
{
var menu = actionMenuService.Create();
var isPinned = applicationService
.Account.PinnedRepositories
.Any(x => string.Equals(x.Owner, username, StringComparison.OrdinalIgnoreCase) && string.Equals(x.Slug, repositoryName, StringComparison.OrdinalIgnoreCase));
var pinned = isPinned ? "Unpin from Slideout Menu" : "Pin to Slideout Menu";
menu.AddButton(pinned, _ => PinRepository());
menu.AddButton("Fork Repository", _ => ForkCommand.ExecuteNow());
menu.AddButton("Show in Bitbucket", _ =>
{
var htmlUrl = ("https://bitbucket.org/" + username + "/" + repositoryName).ToLower();
NavigateTo(new WebBrowserViewModel(htmlUrl));
});
return(menu.Show(sender));
});
}
public PullRequestViewModel(IApplicationService applicationService, IMarkdownService markdownService, IShareService shareService)
{
_applicationService = applicationService;
_markdownService = markdownService;
Comments = new ReactiveList <IssueCommentModel>();
Events = new ReactiveList <IssueEventModel>();
MergeCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.PullRequest).Select(x =>
x != null && x.Merged.HasValue && !x.Merged.Value && x.Mergable.HasValue && x.Mergable.Value),
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 = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.PullRequest).Select(x => x != null), 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 = ReactiveCommand.Create();
GoToCommitsCommand.Subscribe(_ =>
{
var vm = CreateViewModel <PullRequestCommitsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
vm.PullRequestId = PullRequestId;
ShowViewModel(vm);
});
GoToFilesCommand = ReactiveCommand.Create();
GoToFilesCommand.Subscribe(_ =>
{
var vm = CreateViewModel <PullRequestFilesViewModel>();
vm.Username = RepositoryOwner;
vm.Repository = RepositoryName;
vm.PullRequestId = PullRequestId;
ShowViewModel(vm);
});
ShareCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.PullRequest).Select(x => x != null && !string.IsNullOrEmpty(x.HtmlUrl)));
ShareCommand.Subscribe(_ => shareService.ShareUrl(PullRequest.HtmlUrl));
GoToEditCommand = ReactiveCommand.Create();
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 = ReactiveCommand.Create(this.WhenAnyValue(x => x.Issue).Select(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 = ReactiveCommand.Create(this.WhenAnyValue(x => x.Issue).Select(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 = ReactiveCommand.Create(this.WhenAnyValue(x => x.Issue).Select(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 = ReactiveCommand.Create();
GoToAddCommentCommand.Subscribe(_ =>
{
var vm = CreateViewModel <CommentViewModel>();
ReactiveUI.Legacy.ReactiveCommandMixins.RegisterAsyncTask(vm.SaveCommand, 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 = ReactiveCommand.CreateAsyncTask(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 RepositoryViewModel(IApplicationService applicationService, IAccountsService accountsService)
{
ApplicationService = applicationService;
_accountsService = accountsService;
ToggleStarCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.IsStarred).Select(x => x.HasValue), t => ToggleStar());
ToggleWatchCommand = ReactiveCommand.CreateAsyncTask(
this.WhenAnyValue(x => x.IsWatched, x => x.HasValue), t => ToggleWatch());
GoToOwnerCommand = ReactiveCommand.Create();
GoToOwnerCommand.Subscribe(_ =>
{
var vm = CreateViewModel <ProfileViewModel>();
vm.Username = RepositoryOwner;
ShowViewModel(vm);
});
PinCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository).Select(x => x != null));
PinCommand.Subscribe(x => PinRepository());
GoToForkParentCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && x.Fork && x.Parent != null));
GoToForkParentCommand.Subscribe(x =>
{
var vm = CreateViewModel <RepositoryViewModel>();
vm.RepositoryOwner = Repository.Parent.Owner.Login;
vm.RepositoryName = Repository.Parent.Name;
vm.Repository = Repository.Parent;
ShowViewModel(vm);
});
GoToStargazersCommand = ReactiveCommand.Create();
GoToStargazersCommand.Subscribe(_ =>
{
var vm = CreateViewModel <RepositoryStargazersViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToWatchersCommand = ReactiveCommand.Create();
GoToWatchersCommand.Subscribe(_ =>
{
var vm = CreateViewModel <RepositoryWatchersViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToEventsCommand = ReactiveCommand.Create();
GoToEventsCommand.Subscribe(_ =>
{
var vm = CreateViewModel <RepositoryEventsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToIssuesCommand = ReactiveCommand.Create();
GoToIssuesCommand.Subscribe(_ =>
{
var vm = CreateViewModel <IssuesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToReadmeCommand = ReactiveCommand.Create();
GoToReadmeCommand.Subscribe(_ =>
{
var vm = CreateViewModel <ReadmeViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToCommitsCommand = ReactiveCommand.Create();
GoToCommitsCommand.Subscribe(_ =>
{
if (Branches != null && Branches.Count == 1)
{
var vm = CreateViewModel <ChangesetsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
}
else
{
var vm = CreateViewModel <ChangesetBranchesViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
}
});
GoToPullRequestsCommand = ReactiveCommand.Create();
GoToPullRequestsCommand.Subscribe(_ =>
{
var vm = CreateViewModel <PullRequestsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToSourceCommand = ReactiveCommand.Create();
GoToSourceCommand.Subscribe(_ =>
{
var vm = CreateViewModel <BranchesAndTagsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
GoToCollaboratorsCommand = ReactiveCommand.Create();
GoToCollaboratorsCommand.Subscribe(_ =>
{
var vm = CreateViewModel <RepositoryCollaboratorsViewModel>();
vm.RepositoryOwner = RepositoryOwner;
vm.RepositoryName = RepositoryName;
ShowViewModel(vm);
});
this.WhenAnyValue(x => x.Repository).Subscribe(x =>
{
if (x == null)
{
RepositorySize = null;
}
else
{
if (x.Size / 1024f < 1)
{
RepositorySize = string.Format("{0:0.##}KB", x.Size);
}
else if ((x.Size / 1024f / 1024f) < 1)
{
RepositorySize = string.Format("{0:0.##}MB", x.Size / 1024f);
}
else
{
RepositorySize = string.Format("{0:0.##}GB", x.Size / 1024f / 1024f);
}
}
});
GoToHtmlUrlCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && !string.IsNullOrEmpty(x.HtmlUrl)));
GoToHtmlUrlCommand.Subscribe(_ => GoToUrlCommand.ExecuteIfCan(Repository.HtmlUrl));
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
{
var forceCacheInvalidation = t as bool?;
var t1 = this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Get(),
forceCacheInvalidation, response => Repository = response.Data);
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetReadme(),
forceCacheInvalidation, response => Readme = response.Data).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetBranches(),
forceCacheInvalidation, response => Branches = response.Data).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].IsWatching(),
forceCacheInvalidation, response => IsWatched = response.Data).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].IsStarred(),
forceCacheInvalidation, response => IsStarred = response.Data).FireAndForget();
this.RequestModel(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetCollaborators(),
forceCacheInvalidation, response => Collaborators = response.Data.Count).FireAndForget();
return(t1);
});
}