public RepositoryExploreViewModel(ISessionService applicationService)
{
ShowRepositoryDescription = applicationService.Account.ShowRepositoryDescriptionInList;
Title = "Explore Repositories";
var gotoRepository = new Action <RepositoryItemViewModel>(x => {
var vm = this.CreateViewModel <RepositoryViewModel>();
vm.Init(x.Owner, x.Name, x.Repository);
NavigateTo(vm);
});
Items = InternalItems.CreateDerivedCollection(x =>
new RepositoryItemViewModel(x, true, gotoRepository));
var canSearch = this.WhenAnyValue(x => x.SearchKeyword).Select(x => !string.IsNullOrEmpty(x));
SearchCommand = ReactiveCommand.CreateAsyncTask(canSearch, async t => {
try
{
InternalItems.Clear();
var request = new SearchRepositoriesRequest(SearchKeyword);
var response = await applicationService.GitHubClient.Search.SearchRepo(request);
InternalItems.Reset(response.Items);
}
catch (Exception e)
{
var msg = string.Format("Unable to search for {0}. Please try again.", SearchKeyword.Humanize());
throw new Exception(msg, e);
}
});
}
public UserExploreViewModel(ISessionService applicationService)
{
Title = "Explore Users";
Items = InternalItems.CreateDerivedCollection(x =>
new UserItemViewModel(x.Login, x.AvatarUrl, false, () => {
var vm = this.CreateViewModel <UserViewModel>();
vm.Init(x.Login, x);
NavigateTo(vm);
}));
var canSearch = this.WhenAnyValue(x => x.SearchKeyword).Select(x => !string.IsNullOrEmpty(x));
SearchCommand = ReactiveCommand.CreateAsyncTask(canSearch, async t => {
try
{
InternalItems.Clear();
var request = new SearchUsersRequest(SearchKeyword);
var response = await applicationService.GitHubClient.Search.SearchUsers(request);
InternalItems.Reset(response.Items);
}
catch (Exception e)
{
var msg = string.Format("Unable to search for {0}. Please try again.", SearchKeyword.Humanize());
throw new Exception(msg, e);
}
});
}
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 => {
InternalItems.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 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 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);
});
}
/// <inheritdoc />
public Task ExpandAsync()
{
if (InternalItems == null)
{
throw new InvalidOperationException("InternalItems is nukk");
}
InternalItems.Clear();
var count = VisualTreeHelper.GetChildrenCount(Visual);
for (int i = 0; i < count; i++)
{
InternalItems.Add(new VisualTreeNode {
Visual = VisualTreeHelper.GetChild(Visual, i) as Visual, TransformToSource = this.TransformToSource
});
}
IsExpanded = true;
return(Task.CompletedTask);
}
public void RemoveAllItems(bool updateUI = true)
{
//Refactore
InternalItems.Clear();
}
