Example #1
0
        public ExploreViewModel(ISessionService applicationService)
        {
            ShowRepositoryDescription = applicationService.Account.ShowRepositoryDescriptionInList;

            Title = "Explore";

            var gotoRepository = new Action<RepositoryItemViewModel>(x => {
                var vm = this.CreateViewModel<RepositoryViewModel>();
                vm.RepositoryOwner = x.Owner;
                vm.RepositoryName = x.Name;
                NavigateTo(vm);
            });

            var repositories = new ReactiveList<Octokit.Repository>();
            Repositories = repositories.CreateDerivedCollection(x => 
                new RepositoryItemViewModel(x, true, gotoRepository));

            var users = new ReactiveList<Octokit.User>();
            Users = users.CreateDerivedCollection(x => 
                new UserItemViewModel(x.Login, x.AvatarUrl, false, () => {
                    var vm = this.CreateViewModel<UserViewModel>();
                    vm.Init(x.Login);
                    NavigateTo(vm);
                }));

            this.WhenAnyValue(x => x.SearchFilter)
                .DistinctUntilChanged()
                .Subscribe(_ => {
                    SearchText = string.Empty;
                    users.Clear();
                    repositories.Clear();
                });

            var canSearch = this.WhenAnyValue(x => x.SearchText).Select(x => !string.IsNullOrEmpty(x));
            SearchCommand = ReactiveCommand.CreateAsyncTask(canSearch, async t => {
                try
                {
                    users.Clear();
                    repositories.Clear();

                    if (SearchFilter == SearchType.Repositories)
                    {
                        var request = new Octokit.SearchRepositoriesRequest(SearchText);
                        var response = await applicationService.GitHubClient.Search.SearchRepo(request);
                        repositories.Reset(response.Items);
                    }
                    else if (SearchFilter == SearchType.Users)
                    {
                        var request = new Octokit.SearchUsersRequest(SearchText);
                        var response = await applicationService.GitHubClient.Search.SearchUsers(request);
                        users.Reset(response.Items);
                    }
                }
                catch (Exception e)
                {
                    var msg = string.Format("Unable to search for {0}. Please try again.", SearchFilter.Humanize());
                    throw new Exception(msg, e);
                }
            });
        }
        public async void TestSearchRepositories()
        {
            var git = new GitService(GitTestsToken.MinimalPermissions);
            var req = new Octokit.SearchRepositoriesRequest("TestRepo");

            Assert.IsType <Octokit.SearchRepositoryResult>(await git.SearchRepositories(req));
        }
Example #3
0
        public async Task <List <Models.Repository> > SearchRepositories(string term)
        {
            var request = new Octokit.SearchRepositoriesRequest(term);

            request.PerPage = 30;

            var result = await _client.Search.SearchRepo(request);

            return(result.Items.Select(repo => repo.Map()).ToList());
        }
Example #4
0
        public RepositoriesExploreViewModel(IApplicationService applicationService, INetworkActivityService networkActivityService)
        {
            ShowRepositoryDescription = applicationService.Account.ShowRepositoryDescriptionInList;

            Title = "Explore";

            var gotoRepository = new Action <RepositoryItemViewModel>(x =>
            {
                var vm             = CreateViewModel <RepositoryViewModel>();
                vm.RepositoryOwner = x.Owner;
                vm.RepositoryName  = x.Name;
                ShowViewModel(vm);
            });

            var repositories = new ReactiveList <Octokit.Repository>();

            Repositories = repositories.CreateDerivedCollection(x =>
                                                                new RepositoryItemViewModel(x.Name, x.Owner.Login, x.Owner.AvatarUrl,
                                                                                            x.Description, x.StargazersCount, x.ForksCount,
                                                                                            true, gotoRepository));

            SearchCommand = ReactiveCommand.CreateAsyncTask(
                this.WhenAnyValue(x => x.SearchText).Select(x => !string.IsNullOrEmpty(x)),
                async t =>
            {
                repositories.Clear();

                try
                {
                    var request  = new Octokit.SearchRepositoriesRequest(SearchText);
                    var response = await applicationService.GitHubClient.Search.SearchRepo(request);
                    repositories.Reset(response.Items);
                }
                catch (Exception e)
                {
                    throw new Exception("Unable to search for repositories. Please try again.", e);
                }
            });

            SearchCommand.IsExecuting.Skip(1).Subscribe(x =>
            {
                if (x)
                {
                    networkActivityService.PushNetworkActive();
                }
                else
                {
                    networkActivityService.PopNetworkActive();
                }
            });
        }
Example #5
0
        public RepositoriesExploreViewModel(IApplicationService applicationService)
        {
            ShowRepositoryDescription = applicationService.Account.ShowRepositoryDescriptionInList;

            Title = "Explore";

            var gotoRepository = new Action <RepositoryItemViewModel>(x =>
            {
                var vm             = this.CreateViewModel <RepositoryViewModel>();
                vm.RepositoryOwner = x.Owner;
                vm.RepositoryName  = x.Name;
                NavigateTo(vm);
            });

            var repositories = new ReactiveList <Octokit.Repository>();

            Repositories = repositories.CreateDerivedCollection(x =>
                                                                new RepositoryItemViewModel(x, true, gotoRepository));

            SearchCommand = ReactiveCommand.CreateAsyncTask(
                this.WhenAnyValue(x => x.SearchText).Select(x => !string.IsNullOrEmpty(x)),
                async t =>
            {
                repositories.Clear();

                try
                {
                    var request  = new Octokit.SearchRepositoriesRequest(SearchText);
                    var response = await applicationService.GitHubClient.Search.SearchRepo(request);
                    repositories.Reset(response.Items);
                }
                catch (Exception e)
                {
                    throw new Exception("Unable to search for repositories. Please try again.", e);
                }
            });
        }
Example #6
0
        public async void TestSearchRepositories()
        {
            var req = new Octokit.SearchRepositoriesRequest("TestRepo");

            Assert.IsType <Octokit.SearchRepositoryResult>(await minimalGit.SearchRepositories(req));
        }
Example #7
0
        public ExploreViewModel(ISessionService applicationService)
        {
            ShowRepositoryDescription = applicationService.Account.ShowRepositoryDescriptionInList;

            Title = "Explore";

            var gotoRepository = new Action <RepositoryItemViewModel>(x => {
                var vm = this.CreateViewModel <RepositoryViewModel>();
                vm.Init(x.Owner, x.Name, x.Repository);
                NavigateTo(vm);
            });

            var repositories = new ReactiveList <Octokit.Repository>();

            Repositories = repositories.CreateDerivedCollection(x =>
                                                                new RepositoryItemViewModel(x, true, gotoRepository));

            var users = new ReactiveList <Octokit.User>();

            Users = users.CreateDerivedCollection(x =>
                                                  new UserItemViewModel(x.Login, x.AvatarUrl, false, () => {
                var vm = this.CreateViewModel <UserViewModel>();
                vm.Init(x.Login, x);
                NavigateTo(vm);
            }));

            this.WhenAnyValue(x => x.SearchFilter)
            .DistinctUntilChanged()
            .Subscribe(_ => {
                SearchText = string.Empty;
                users.Clear();
                repositories.Clear();
            });

            var canSearch = this.WhenAnyValue(x => x.SearchText).Select(x => !string.IsNullOrEmpty(x));

            SearchCommand = ReactiveCommand.CreateAsyncTask(canSearch, async t => {
                try
                {
                    users.Clear();
                    repositories.Clear();

                    if (SearchFilter == SearchType.Repositories)
                    {
                        var request  = new Octokit.SearchRepositoriesRequest(SearchText);
                        var response = await applicationService.GitHubClient.Search.SearchRepo(request);
                        repositories.Reset(response.Items);
                    }
                    else if (SearchFilter == SearchType.Users)
                    {
                        var request  = new Octokit.SearchUsersRequest(SearchText);
                        var response = await applicationService.GitHubClient.Search.SearchUsers(request);
                        users.Reset(response.Items);
                    }
                }
                catch (Exception e)
                {
                    var msg = string.Format("Unable to search for {0}. Please try again.", SearchFilter.Humanize());
                    throw new Exception(msg, e);
                }
            });
        }