Exemplo n.º 1
0
        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);
                }
            });
        }
Exemplo n.º 2
0
        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);
                }
            });
        }
Exemplo n.º 3
0
        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);
            });
        }
Exemplo n.º 4
0
        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();
            });
        }
Exemplo n.º 5
0
        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);
            });
        }
Exemplo n.º 6
0
        /// <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);
        }
Exemplo n.º 7
0
 public void RemoveAllItems(bool updateUI = true)
 {
     //Refactore
     InternalItems.Clear();
 }