public LoginViewModel(INetworkActivityService networkActivity) { LoginCommand = ReactiveCommand.CreateAsyncTask(async t => { var account = new Account(); var connection = new Octokit.Connection(new Octokit.ProductHeaderValue("RepoStumble")); var client = new Octokit.OauthClient(connection); var token = await client.CreateAccessToken(new Octokit.OauthTokenRequest(ClientId, ClientSecret, LoginCode)); connection.Credentials = new Octokit.Credentials(token.AccessToken); var githubClient = new Octokit.GitHubClient(connection); var info = await githubClient.User.Current(); account.AvatarUrl = info.AvatarUrl; account.Username = info.Login; account.Fullname = info.Name; account.OAuth = token.AccessToken; account.Save(); DismissCommand.ExecuteIfCan(); }); LoginCommand.IsExecuting.Skip(1).Where(x => x).Subscribe(x => networkActivity.PushNetworkActive()); LoginCommand.IsExecuting.Skip(1).Where(x => !x).Subscribe(x => networkActivity.PopNetworkActive()); }
public ShowcaseViewModel(INetworkActivityService networkActivity, ShowcaseRepository showcaseRepository) { Title = "Showcase"; GoToRepositoryCommand = ReactiveCommand.Create(); GoToRepositoryCommand.OfType <Octokit.Repository>().Subscribe(x => { var vm = CreateViewModel <RepositoryViewModel>(); vm.RepositoryIdentifier = new BaseRepositoryViewModel.RepositoryIdentifierModel(x.Owner.Login, x.Name); ShowViewModel(vm); }); var repositories = new ReactiveList <Octokit.Repository>(); Repositories = repositories; LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var showcaseRepos = await showcaseRepository.GetShowcaseRepositories(ShowcaseSlug); Title = showcaseRepos.Name; Showcase = new Showcase { Slug = showcaseRepos.Slug, Description = showcaseRepos.Description, Name = showcaseRepos.Name }; repositories.Reset(showcaseRepos.Repositories); }); LoadCommand.TriggerNetworkActivity(networkActivity); }
public LanguagesViewModel(IJsonSerializationService jsonSerializationService, INetworkActivityService networkActivity) { var languages = new ReactiveList<LanguageModel>(); Languages = languages.CreateDerivedCollection( x => new LanguageItemViewModel(x.Name, x.Slug), x => x.Name.StartsWith(SearchKeyword ?? string.Empty, StringComparison.OrdinalIgnoreCase), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); Languages .Changed.Select(_ => Unit.Default) .Merge(this.WhenAnyValue(x => x.SelectedLanguage).Select(_ => Unit.Default)) .Select(_ => SelectedLanguage) .Where(x => x != null) .Subscribe(x => { foreach (var l in Languages) l.Selected = l.Slug == x.Slug; }); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var trendingData = await BlobCache.LocalMachine.DownloadUrl(LanguagesUrl, absoluteExpiration: DateTimeOffset.Now.AddDays(1)); var langs = jsonSerializationService.Deserialize<List<LanguageModel>>(System.Text.Encoding.UTF8.GetString(trendingData)); langs.Insert(0, DefaultLanguage); languages.Reset(langs); }); LoadCommand.TriggerNetworkActivity(networkActivity); LoadCommand.ExecuteIfCan(); }
public UpgradesView(IFeaturesService featuresService, INetworkActivityService networkActivityService, IAlertDialogService alertDialogService) : base(style: MonoTouch.UIKit.UITableViewStyle.Plain) { _featuresService = featuresService; _networkActivityService = networkActivityService; _alertDialogService = alertDialogService; }
public static IDisposable TriggerNetworkActivity(this IReactiveCommand @this, INetworkActivityService networkActivity) { return @this.IsExecuting.Skip(1).Subscribe(x => { if (x) networkActivity.PushNetworkActive(); else networkActivity.PopNetworkActive(); }); }
public RepositoriesTrendingViewModel(IApplicationService applicationService, IJsonHttpClientService jsonHttpClient, INetworkActivityService networkActivityService) { _applicationService = applicationService; _jsonHttpClient = jsonHttpClient; Title = "Trending"; var defaultLanguage = LanguagesViewModel.DefaultLanguage; SelectedLanguage = new LanguageItemViewModel(defaultLanguage.Name, defaultLanguage.Slug); GoToLanguages = ReactiveCommand.Create().WithSubscription(_ => { var vm = CreateViewModel <LanguagesViewModel>(); vm.SelectedLanguage = SelectedLanguage; vm.WhenAnyValue(x => x.SelectedLanguage).Skip(1).Subscribe(x => { SelectedLanguage = x; vm.DismissCommand.ExecuteIfCan(); }); ShowViewModel(vm); }); var gotoRepository = new Action <RepositoryItemViewModel>(x => { var vm = CreateViewModel <RepositoryViewModel>(); vm.RepositoryOwner = x.Owner; vm.RepositoryName = x.Name; ShowViewModel(vm); }); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => { var requests = _times.Select(t => { var query = "?since=" + t.Slug; if (SelectedLanguage != null && SelectedLanguage.Slug != null) { query += string.Format("&language={0}", SelectedLanguage.Slug); } return(new { Time = t, Query = _jsonHttpClient.Get <List <TrendingRepositoryModel> >(TrendingUrl + query) }); }).ToArray(); await Task.WhenAll(requests.Select(x => x.Query)); Repositories = requests.Select(r => { var transformedRepos = r.Query.Result.Select(x => new RepositoryItemViewModel(x.Name, x.Owner, x.AvatarUrl, x.Description, x.Stars, x.Forks, true, gotoRepository)); return(new GroupedCollection <RepositoryItemViewModel>(r.Time.Name, new ReactiveList <RepositoryItemViewModel>(transformedRepos))); }).ToList(); }); LoadCommand.TriggerNetworkActivity(networkActivityService); this.WhenAnyValue(x => x.SelectedLanguage).Subscribe(_ => LoadCommand.ExecuteIfCan()); }
public LoginView(IAlertDialogService alertDialogService, INetworkActivityService networkActivityService) : base(networkActivityService) { _alertDialogService = alertDialogService; NavigationItem.RightBarButtonItem = new UIBarButtonItem(UIBarButtonSystemItem.Action, (s, e) => ViewModel.ShowLoginOptionsCommand.ExecuteIfCan()); this.WhenViewModel(x => x.Title).IsNotNull().Subscribe(x => Title = x); this.WhenViewModel(x => x.LoginUrl).IsNotNull().Subscribe(LoadRequest); }
protected ReactiveWebViewController(INetworkActivityService networkActivityService) { _networkActivityService = networkActivityService; Web = new UIWebView { ScalesPageToFit = true }; Web.LoadFinished += OnLoadFinished; Web.LoadStarted += OnLoadStarted; Web.LoadError += OnLoadError; Web.ShouldStartLoad = (w, r, n) => ShouldStartLoad(r, n); }
public RepositoriesTrendingViewModel(IApplicationService applicationService, IJsonHttpClientService jsonHttpClient, INetworkActivityService networkActivityService) { _applicationService = applicationService; _jsonHttpClient = jsonHttpClient; var defaultLanguage = LanguagesViewModel.DefaultLanguage; SelectedLanguage = new LanguageItemViewModel(defaultLanguage.Name, defaultLanguage.Slug); GoToLanguages = ReactiveCommand.Create().WithSubscription(_ => { var vm = CreateViewModel<LanguagesViewModel>(); vm.SelectedLanguage = SelectedLanguage; vm.WhenAnyValue(x => x.SelectedLanguage).Skip(1).Subscribe(x => { SelectedLanguage = x; vm.DismissCommand.ExecuteIfCan(); }); ShowViewModel(vm); }); var gotoRepository = new Action<RepositoryItemViewModel>(x => { var vm = CreateViewModel<RepositoryViewModel>(); vm.RepositoryOwner = x.Owner; vm.RepositoryName = x.Name; ShowViewModel(vm); }); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => { var requests = _times.Select(t => { var query = "?since=" + t.Slug; if (SelectedLanguage != null && SelectedLanguage.Slug != null) query += string.Format("&language={0}", SelectedLanguage.Slug); return new { Time = t, Query = _jsonHttpClient.Get<List<TrendingRepositoryModel>>(TrendingUrl + query) }; }).ToArray(); await Task.WhenAll(requests.Select(x => x.Query)); Repositories = requests.Select(r => { var transformedRepos = r.Query.Result.Select(x => new RepositoryItemViewModel(x.Name, x.Owner, x.AvatarUrl, x.Description, x.Stars, x.Forks, true, gotoRepository)); return new GroupedCollection<RepositoryItemViewModel>(r.Time.Name, new ReactiveList<RepositoryItemViewModel>(transformedRepos)); }).ToList(); }); LoadCommand.TriggerNetworkActivity(networkActivityService); this.WhenAnyValue(x => x.SelectedLanguage).Subscribe(_ => LoadCommand.ExecuteIfCan()); }
public ReadmeView(INetworkActivityService networkActivityService) : base(networkActivityService) { Web.ScalesPageToFit = true; this.WhenViewModel(x => x.ContentText).IsNotNull().Subscribe(x => LoadContent(new ReadmeRazorView { Model = x }.GenerateString())); this.WhenViewModel(x => x.ShowMenuCommand).Subscribe(x => NavigationItem.RightBarButtonItem = x.ToBarButtonItem(UIBarButtonSystemItem.Action)); }
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(); } }); }
public GistFileView(INetworkActivityService networkActivityService) : base(networkActivityService) { this.WhenViewModel(x => x.GistFile).IsNotNull().Subscribe(x => NavigationItem.RightBarButtonItem = ViewModel.ShowMenuCommand.ToBarButtonItem(UIBarButtonSystemItem.Action)); this.WhenViewModel(x => x.OpenWithCommand) .Switch() .Subscribe(_ => { UIDocumentInteractionController ctrl = UIDocumentInteractionController.FromUrl(new NSUrl(ViewModel.SourceItem.FileUri.AbsoluteUri)); ctrl.Delegate = new UIDocumentInteractionControllerDelegate(); ctrl.PresentOpenInMenu(this.View.Frame, this.View, true); }); }
public RepositoriesExploreViewModel(IApplicationService applicationService, INetworkActivityService networkActivityService) { _applicationService = applicationService; var gotoRepository = new Action <RepositoryItemViewModel>(x => { var vm = CreateViewModel <RepositoryViewModel>(); vm.RepositoryOwner = x.Owner; vm.RepositoryName = x.Name; ShowViewModel(vm); }); var repositories = new ReactiveList <RepositorySearchModel.RepositoryModel>(); 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 => { try { var request = applicationService.Client.Repositories.SearchRepositories(new[] { SearchText }, new string[] { }); request.UseCache = false; var response = await applicationService.Client.ExecuteAsync(request); repositories.Reset(response.Data.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(); } }); }
public TrendingViewModel(INetworkActivityService networkActivity, TrendingRepository trendingRepository) { SelectedLanguage = _defaultLanguage; var repositories = new ReactiveList <TrendingRepositoryViewModel>(); Repositories = repositories.CreateDerivedCollection(x => x); GoToRepositoryCommand = ReactiveCommand.Create(); GoToRepositoryCommand.OfType <Octokit.Repository>().Subscribe(x => { var vm = CreateViewModel <RepositoryViewModel>(); vm.RepositoryIdentifier = new BaseRepositoryViewModel.RepositoryIdentifierModel(x.Owner.Login, x.Name); ShowViewModel(vm); }); GoToLanguages = ReactiveCommand.Create(); GoToLanguages.Subscribe(_ => { var vm = CreateViewModel <LanguagesViewModel>(); vm.ExtraLanguages.Add(_defaultLanguage); vm.SelectedLanguage = SelectedLanguage; vm.WhenAnyValue(x => x.SelectedLanguage).Skip(1).Subscribe(x => { SelectedLanguage = x; vm.DismissCommand.ExecuteIfCan(); }); ShowViewModel(vm); }); this.WhenAnyValue(x => x.SelectedLanguage).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan()); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => { var tempRepos = new List <TrendingRepositoryViewModel>(); foreach (var t in _times) { var language = SelectedLanguage == null ? null : SelectedLanguage.Slug; var repos = await trendingRepository.GetTrendingRepositories(t.Slug, language); tempRepos.AddRange(repos.Select(x => new TrendingRepositoryViewModel { Repository = x, Time = t.Name })); } repositories.Reset(tempRepos); }); LoadCommand.TriggerNetworkActivity(networkActivity); }
public UpgradeView(INetworkActivityService networkActivityService) { _featuresService = Locator.Current.GetService<IFeaturesService>(); _inAppPurchaseService = Locator.Current.GetService<IInAppPurchaseService>(); _web = new UIWebView { ScalesPageToFit = true, AutoresizingMask = UIViewAutoresizing.All }; _web.LoadFinished += (sender, e) => networkActivityService.PopNetworkActive(); _web.LoadStarted += (sender, e) => networkActivityService.PushNetworkActive(); _web.LoadError += (sender, e) => networkActivityService.PopNetworkActive(); _web.ShouldStartLoad = (w, r, n) => ShouldStartLoad(r, n); _activityView = new UIActivityIndicatorView { Color = Theme.PrimaryNavigationBarColor, AutoresizingMask = UIViewAutoresizing.FlexibleWidth, }; }
public TrendingViewModel(INetworkActivityService networkActivity, TrendingRepository trendingRepository) { SelectedLanguage = _defaultLanguage; var repositories = new ReactiveList<TrendingRepositoryViewModel>(); Repositories = repositories.CreateDerivedCollection(x => x); GoToRepositoryCommand = ReactiveCommand.Create(); GoToRepositoryCommand.OfType<Octokit.Repository>().Subscribe(x => { var vm = CreateViewModel<RepositoryViewModel>(); vm.RepositoryIdentifier = new BaseRepositoryViewModel.RepositoryIdentifierModel(x.Owner.Login, x.Name); ShowViewModel(vm); }); GoToLanguages = ReactiveCommand.Create(); GoToLanguages.Subscribe(_ => { var vm = CreateViewModel<LanguagesViewModel>(); vm.ExtraLanguages.Add(_defaultLanguage); vm.SelectedLanguage = SelectedLanguage; vm.WhenAnyValue(x => x.SelectedLanguage).Skip(1).Subscribe(x => { SelectedLanguage = x; vm.DismissCommand.ExecuteIfCan(); }); ShowViewModel(vm); }); this.WhenAnyValue(x => x.SelectedLanguage).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan()); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => { var tempRepos = new List<TrendingRepositoryViewModel>(); foreach (var t in _times) { var language = SelectedLanguage == null ? null : SelectedLanguage.Slug; var repos = await trendingRepository.GetTrendingRepositories(t.Slug, language); tempRepos.AddRange(repos.Select(x => new TrendingRepositoryViewModel { Repository = x, Time = t.Name } )); } repositories.Reset(tempRepos); }); LoadCommand.TriggerNetworkActivity(networkActivity); }
public LanguagesViewModel(INetworkActivityService networkActivity, LanguageRepository languageRepository) { ExtraLanguages = new List<Language>(); Languages = _languages.CreateDerivedCollection( x => x, x => x.Name.StartsWith(SearchKeyword ?? string.Empty, StringComparison.OrdinalIgnoreCase), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var langs = await languageRepository.GetLanguages(); langs.InsertRange(0, ExtraLanguages); _languages.Reset(langs); }); LoadCommand.TriggerNetworkActivity(networkActivity); }
public ShowcasesViewModel(INetworkActivityService networkActivity, ShowcaseRepository showcaseRepository) { GoToShowcaseCommand = ReactiveCommand.Create(); GoToShowcaseCommand.OfType<Showcase>().Subscribe(x => { var vm = CreateViewModel<ShowcaseViewModel>(); vm.ShowcaseSlug = x.Slug; vm.Title = x.Name; ShowViewModel(vm); }); var showcases = new ReactiveList<Showcase>(); Showcases = showcases; LoadCommand = ReactiveCommand.CreateAsyncTask(async t => showcases.Reset(await showcaseRepository.GetShowcases())); LoadCommand.TriggerNetworkActivity(networkActivity); }
public ReleaseView(INetworkActivityService networkActivityService) : base(networkActivityService) { Web.ScalesPageToFit = true; this.WhenViewModel(x => x.ShowMenuCommand) .Subscribe(x => NavigationItem.RightBarButtonItem = x.ToBarButtonItem(UIBarButtonSystemItem.Action)); this.WhenViewModel(x => x.ContentText).IsNotNull().Subscribe(contentText => { var model = new ReleaseRazorViewModel { Body = contentText, Release = ViewModel.ReleaseModel }; LoadContent(new ReleaseRazorView { Model = model }.GenerateString()); }); }
public LanguagesViewModel(INetworkActivityService networkActivity, LanguageRepository languageRepository) { ExtraLanguages = new List <Language>(); Languages = _languages.CreateDerivedCollection( x => x, x => x.Name.StartsWith(SearchKeyword ?? string.Empty, StringComparison.OrdinalIgnoreCase), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var langs = await languageRepository.GetLanguages(); langs.InsertRange(0, ExtraLanguages); _languages.Reset(langs); }); LoadCommand.TriggerNetworkActivity(networkActivity); }
public ShowcasesViewModel(INetworkActivityService networkActivity, ShowcaseRepository showcaseRepository) { GoToShowcaseCommand = ReactiveCommand.Create(); GoToShowcaseCommand.OfType <Showcase>().Subscribe(x => { var vm = CreateViewModel <ShowcaseViewModel>(); vm.ShowcaseSlug = x.Slug; vm.Title = x.Name; ShowViewModel(vm); }); var showcases = new ReactiveList <Showcase>(); Showcases = showcases; LoadCommand = ReactiveCommand.CreateAsyncTask(async t => showcases.Reset(await showcaseRepository.GetShowcases())); LoadCommand.TriggerNetworkActivity(networkActivity); }
public RepositoriesExploreViewModel(IApplicationService applicationService, INetworkActivityService networkActivityService) { _applicationService = applicationService; var gotoRepository = new Action<RepositoryItemViewModel>(x => { var vm = CreateViewModel<RepositoryViewModel>(); vm.RepositoryOwner = x.Owner; vm.RepositoryName = x.Name; ShowViewModel(vm); }); var repositories = new ReactiveList<RepositorySearchModel.RepositoryModel>(); 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 => { try { var request = applicationService.Client.Repositories.SearchRepositories(new[] { SearchText }, new string[] { }); request.UseCache = false; var response = await applicationService.Client.ExecuteAsync(request); repositories.Reset(response.Data.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(); }); }
public PullRequestDiffViewController( string username, string repository, int pullRequestId, string path, string patch, string commit, IApplicationService applicationService = null, INetworkActivityService networkActivityService = null, IMarkdownService markdownService = null) : base(false) { _applicationService = applicationService ?? Locator.Current.GetService <IApplicationService>(); _networkActivityService = networkActivityService ?? Locator.Current.GetService <INetworkActivityService>(); _markdownService = markdownService ?? Locator.Current.GetService <IMarkdownService>(); _username = username; _repository = repository; _pullRequestId = pullRequestId; _path = path; _patch = patch; _commit = commit; Title = string.IsNullOrEmpty(_path) ? "Diff" : System.IO.Path.GetFileName(_path); var loadComments = ReactiveCommand.CreateFromTask( _ => _applicationService.GitHubClient.PullRequest.ReviewComment.GetAll(_username, _repository, _pullRequestId)); loadComments .ThrownExceptions .Select(error => new UserError("Unable to load comments.", error)) .SelectMany(Interactions.Errors.Handle) .Subscribe(); loadComments .Subscribe(comments => _comments.Reset(comments)); var loadAll = ReactiveCommand.CreateCombined(new[] { loadComments }); Appearing .Take(1) .Select(_ => Unit.Default) .InvokeReactiveCommand(loadAll); }
public ShowcaseViewModel(INetworkActivityService networkActivity, ShowcaseRepository showcaseRepository) { Title = "Showcase"; GoToRepositoryCommand = ReactiveCommand.Create(); GoToRepositoryCommand.OfType<Octokit.Repository>().Subscribe(x => { var vm = CreateViewModel<RepositoryViewModel>(); vm.RepositoryIdentifier = new BaseRepositoryViewModel.RepositoryIdentifierModel(x.Owner.Login, x.Name); ShowViewModel(vm); }); var repositories = new ReactiveList<Octokit.Repository>(); Repositories = repositories; LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var showcaseRepos = await showcaseRepository.GetShowcaseRepositories(ShowcaseSlug); Title = showcaseRepos.Name; Showcase = new Showcase {Slug = showcaseRepos.Slug, Description = showcaseRepos.Description, Name = showcaseRepos.Name}; repositories.Reset(showcaseRepos.Repositories); }); LoadCommand.TriggerNetworkActivity(networkActivity); }
public RepositoriesExploreViewModel(IApplicationService applicationService, INetworkActivityService networkActivityService) { _applicationService = applicationService; Repositories = new ReactiveCollection<RepositorySearchModel.RepositoryModel>(); SearchCommand = new ReactiveCommand(this.WhenAnyValue(x => x.SearchText, x => !string.IsNullOrEmpty(x))); SearchCommand.IsExecuting.Skip(1).Subscribe(x => { if (x) networkActivityService.PushNetworkActive(); else networkActivityService.PopNetworkActive(); }); SearchCommand.RegisterAsyncTask(async t => { try { var request = applicationService.Client.Repositories.SearchRepositories(new[] { SearchText }, new string[] { }); request.UseCache = false; var response = await applicationService.Client.ExecuteAsync(request); Repositories.Reset(response.Data.Items); } catch (Exception e) { throw new Exception("Unable to search for repositories. Please try again.", e); } }); GoToRepositoryCommand = new ReactiveCommand(); GoToRepositoryCommand.OfType<RepositorySearchModel.RepositoryModel>().Subscribe(x => { var vm = CreateViewModel<RepositoryViewModel>(); vm.RepositoryOwner = x.Owner.Login; vm.RepositoryName = x.Name; ShowViewModel(vm); }); }
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 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 static IDisposable ActivateNetwork(this INetworkActivityService @this) { @this.PushNetworkActive(); return(Disposable.Create(@this.PopNetworkActive)); }
public OctokitNetworkClient(IHttpClient httpClient, INetworkActivityService networkActivity) { _httpClient = httpClient; _networkActivity = networkActivity; }
public ProfileViewModel(IApplicationService applicationService, INetworkActivityService networkActivity, IFeaturesService featuresService) { StumbleHistory = new ReactiveList <StumbledRepository>(); GoToInterestsCommand = ReactiveCommand.Create(); Username = applicationService.Account.Username; Action updateStumbled = () => { var stumbledRepositories = applicationService.Account.StumbledRepositories.Count(); Interests = applicationService.Account.Interests.Count(); Likes = applicationService.Account.StumbledRepositories.LikedRepositories(); Dislikes = applicationService.Account.StumbledRepositories.DislikedRepositories(); HasMoreHistory = stumbledRepositories > 30; if (stumbledRepositories != StumbledRepositories) { StumbledRepositories = stumbledRepositories; StumbleHistory.Reset(applicationService.Account.StumbledRepositories.Query.OrderByDescending(x => x.CreatedAt).Take(30)); } }; this.WhenActivated(d => { if (applicationService.Account != null) { updateStumbled(); d(applicationService.RepositoryAdded .Buffer(TimeSpan.FromSeconds(5)) .Where(x => x.Count > 0) .ObserveOn(SynchronizationContext.Current) .Subscribe(x => updateStumbled())); } CanPurchase = !featuresService.ProEditionEnabled; }); GoToRepositoryCommand = ReactiveCommand.Create(); GoToRepositoryCommand.OfType <StumbledRepository>().Subscribe(x => { var vm = CreateViewModel <RepositoryViewModel>(); vm.RepositoryIdentifier = new BaseRepositoryViewModel.RepositoryIdentifierModel(x.Owner, x.Name); ShowViewModel(vm); }); GoToPurchaseCommand = ReactiveCommand.Create(); GoToPurchaseCommand.Subscribe(_ => CreateAndShowViewModel <PurchaseProViewModel>()); GoToHistoryCommand = ReactiveCommand.Create(); GoToHistoryCommand.Subscribe(_ => CreateAndShowViewModel <HistoryViewModel>()); GoToLikesCommand = ReactiveCommand.Create(); GoToLikesCommand.Subscribe(_ => CreateAndShowViewModel <LikedRepositoriesViewModel>()); GoToDislikesCommand = ReactiveCommand.Create(); GoToDislikesCommand.Subscribe(_ => CreateAndShowViewModel <DislikedRepositoriesViewModel>()); GoToSettingsCommand = ReactiveCommand.Create(); GoToSettingsCommand.Subscribe(_ => CreateAndShowViewModel <SettingsViewModel>()); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { User = await applicationService.Client.User.Current(); }); LoadCommand.TriggerNetworkActivity(networkActivity); }
public UpgradeViewController() { _featuresService = Locator.Current.GetService<IFeaturesService>(); _networkActivityService = Locator.Current.GetService<INetworkActivityService>(); _inAppPurchaseService = Locator.Current.GetService<IInAppPurchaseService>(); }
public SourceView(INetworkActivityService networkActivityService) : base(networkActivityService) { }
public RepositoryViewModel(IApplicationService applicationService, INetworkActivityService networkActivity) : base(applicationService, networkActivity) { }
protected BaseRepositoryViewModel(IApplicationService applicationService, INetworkActivityService networkActivity) { LikeCommand = ReactiveCommand.Create(); LikeCommand.Subscribe(_ => { if (StumbledRepository == null) { var repo = CreateStumbledRepository(); repo.Liked = true; applicationService.Account.StumbledRepositories.Insert(repo); StumbledRepository = repo; } else { StumbledRepository.Liked = true; StumbledRepository.Description = Repository.Description; StumbledRepository.Forks = Repository.ForksCount; StumbledRepository.Stars = Repository.WatchersCount; StumbledRepository.ImageUrl = Repository.Owner.AvatarUrl; applicationService.Account.StumbledRepositories.Update(StumbledRepository); } if (applicationService.Account.SyncWithGitHub) { applicationService.Client.Activity.Starring.StarRepo(Repository.Owner.Login, Repository.Name); } Liked = true; }); DislikeCommand = ReactiveCommand.Create(); DislikeCommand.Subscribe(_ => { if (StumbledRepository == null) { var repo = CreateStumbledRepository(); repo.Liked = false; applicationService.Account.StumbledRepositories.Insert(repo); StumbledRepository = repo; } else { StumbledRepository.Liked = false; StumbledRepository.Description = Repository.Description; StumbledRepository.Forks = Repository.ForksCount; StumbledRepository.Stars = Repository.WatchersCount; StumbledRepository.ImageUrl = Repository.Owner.AvatarUrl; applicationService.Account.StumbledRepositories.Update(StumbledRepository); } if (applicationService.Account.SyncWithGitHub) { applicationService.Client.Activity.Starring.RemoveStarFromRepo(Repository.Owner.Login, Repository.Name); } Liked = false; }); this.WhenAnyValue(x => x.RepositoryIdentifier) .Where(x => x != null) .Subscribe(x => { StumbledRepository = applicationService.Account.StumbledRepositories.FindByFullname(x.Owner, x.Name); }); this.WhenAnyValue(x => x.StumbledRepository) .Where(x => x != null) .Subscribe(x => Liked = x.Liked); GoToGitHubCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository).Select(x => x != null)); GoToGitHubCommand.Subscribe(_ => GoToUrlCommand.ExecuteIfCan(Repository.HtmlUrl)); LoadCommand = ReactiveCommand.CreateAsyncTask(this.WhenAnyValue(x => x.RepositoryIdentifier).Select(x => x != null), async t => { Repository = (await applicationService.Client.Repository.Get(RepositoryIdentifier.Owner, RepositoryIdentifier.Name)); ContributorCount = (await applicationService.Client.Repository.GetAllContributors(RepositoryIdentifier.Owner, RepositoryIdentifier.Name)).Count; try { Readme = await applicationService.Client.Repository.GetReadmeHtml(RepositoryIdentifier.Owner, RepositoryIdentifier.Name); } catch (Exception e) { Readme = "<center>There is no readme for this repository :(</center>"; Debug.WriteLine(e.Message + " for " + RepositoryIdentifier.Owner + "/" + RepositoryIdentifier.Name); } }); LoadCommand.TriggerNetworkActivity(networkActivity); }
public ProfileViewModel(IApplicationService applicationService, INetworkActivityService networkActivity, IFeaturesService featuresService) { StumbleHistory = new ReactiveList<StumbledRepository>(); GoToInterestsCommand = ReactiveCommand.Create(); Username = applicationService.Account.Username; Action updateStumbled = () => { var stumbledRepositories = applicationService.Account.StumbledRepositories.Count(); Interests = applicationService.Account.Interests.Count(); Likes = applicationService.Account.StumbledRepositories.LikedRepositories(); Dislikes = applicationService.Account.StumbledRepositories.DislikedRepositories(); HasMoreHistory = stumbledRepositories > 30; if (stumbledRepositories != StumbledRepositories) { StumbledRepositories = stumbledRepositories; StumbleHistory.Reset(applicationService.Account.StumbledRepositories.Query.OrderByDescending(x => x.CreatedAt).Take(30)); } }; this.WhenActivated(d => { if (applicationService.Account != null) { updateStumbled(); d(applicationService.RepositoryAdded .Buffer(TimeSpan.FromSeconds(5)) .Where(x => x.Count > 0) .ObserveOn(SynchronizationContext.Current) .Subscribe(x => updateStumbled())); } CanPurchase = !featuresService.ProEditionEnabled; }); GoToRepositoryCommand = ReactiveCommand.Create(); GoToRepositoryCommand.OfType<StumbledRepository>().Subscribe(x => { var vm = CreateViewModel<RepositoryViewModel>(); vm.RepositoryIdentifier = new BaseRepositoryViewModel.RepositoryIdentifierModel(x.Owner, x.Name); ShowViewModel(vm); }); GoToPurchaseCommand = ReactiveCommand.Create(); GoToPurchaseCommand.Subscribe(_ => CreateAndShowViewModel<PurchaseProViewModel>()); GoToHistoryCommand = ReactiveCommand.Create(); GoToHistoryCommand.Subscribe(_ => CreateAndShowViewModel<HistoryViewModel>()); GoToLikesCommand = ReactiveCommand.Create(); GoToLikesCommand.Subscribe(_ => CreateAndShowViewModel<LikedRepositoriesViewModel>()); GoToDislikesCommand = ReactiveCommand.Create(); GoToDislikesCommand.Subscribe(_ => CreateAndShowViewModel<DislikedRepositoriesViewModel>()); GoToSettingsCommand = ReactiveCommand.Create(); GoToSettingsCommand.Subscribe(_ => CreateAndShowViewModel<SettingsViewModel>()); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { User = await applicationService.Client.User.Current(); }); LoadCommand.TriggerNetworkActivity(networkActivity); }
public ChangesetDiffView(INetworkActivityService networkActivityService) : base(networkActivityService) { }
public UpgradesView(IFeaturesService featuresService, INetworkActivityService networkActivityService, IAlertDialogFactory alertDialogService) { _featuresService = featuresService; _networkActivityService = networkActivityService; _alertDialogService = alertDialogService; }
public LanguagesViewModel(IJsonSerializationService jsonSerializationService, INetworkActivityService networkActivity) { var languages = new ReactiveList <LanguageModel>(); Languages = languages.CreateDerivedCollection( x => new LanguageItemViewModel(x.Name, x.Slug), x => x.Name.StartsWith(SearchKeyword ?? string.Empty, StringComparison.OrdinalIgnoreCase), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); Languages .Changed.Select(_ => Unit.Default) .Merge(this.WhenAnyValue(x => x.SelectedLanguage).Select(_ => Unit.Default)) .Select(_ => SelectedLanguage) .Where(x => x != null) .Subscribe(x => { foreach (var l in Languages) { l.Selected = l.Slug == x.Slug; } }); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var trendingData = await BlobCache.LocalMachine.DownloadUrl(LanguagesUrl, absoluteExpiration: DateTimeOffset.Now.AddDays(1)); var langs = jsonSerializationService.Deserialize <List <LanguageModel> >(System.Text.Encoding.UTF8.GetString(trendingData)); langs.Insert(0, DefaultLanguage); languages.Reset(langs); }); }
public InAppPurchaseNetworkDecorator(IInAppPurchaseService inAppPurcahseService, INetworkActivityService networkActivity) { _inAppPurcahseService = inAppPurcahseService; _networkActivity = networkActivity; }
protected BaseRepositoryViewModel(IApplicationService applicationService, INetworkActivityService networkActivity) { LikeCommand = ReactiveCommand.Create(); LikeCommand.Subscribe(_ => { if (StumbledRepository == null) { var repo = CreateStumbledRepository(); repo.Liked = true; applicationService.Account.StumbledRepositories.Insert(repo); StumbledRepository = repo; } else { StumbledRepository.Liked = true; StumbledRepository.Description = Repository.Description; StumbledRepository.Forks = Repository.ForksCount; StumbledRepository.Stars = Repository.StargazersCount; StumbledRepository.ImageUrl = Repository.Owner.AvatarUrl; applicationService.Account.StumbledRepositories.Update(StumbledRepository); } if (applicationService.Account.SyncWithGitHub) applicationService.Client.Activity.Starring.StarRepo(Repository.Owner.Login, Repository.Name); Liked = true; }); DislikeCommand = ReactiveCommand.Create(); DislikeCommand.Subscribe(_ => { if (StumbledRepository == null) { var repo = CreateStumbledRepository(); repo.Liked = false; applicationService.Account.StumbledRepositories.Insert(repo); StumbledRepository = repo; } else { StumbledRepository.Liked = false; StumbledRepository.Description = Repository.Description; StumbledRepository.Forks = Repository.ForksCount; StumbledRepository.Stars = Repository.StargazersCount; StumbledRepository.ImageUrl = Repository.Owner.AvatarUrl; applicationService.Account.StumbledRepositories.Update(StumbledRepository); } if (applicationService.Account.SyncWithGitHub) applicationService.Client.Activity.Starring.RemoveStarFromRepo(Repository.Owner.Login, Repository.Name); Liked = false; }); this.WhenAnyValue(x => x.RepositoryIdentifier) .Where(x => x != null) .Subscribe(x => { StumbledRepository = applicationService.Account.StumbledRepositories.FindByFullname(x.Owner, x.Name); }); this.WhenAnyValue(x => x.StumbledRepository) .Where(x => x != null) .Subscribe(x => Liked = x.Liked); GoToGitHubCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository).Select(x => x != null)); GoToGitHubCommand.Subscribe(_ => GoToUrlCommand.ExecuteIfCan(Repository.HtmlUrl)); LoadCommand = ReactiveCommand.CreateAsyncTask(this.WhenAnyValue(x => x.RepositoryIdentifier).Select(x => x != null), async t => { Repository = (await applicationService.Client.Repository.Get(RepositoryIdentifier.Owner, RepositoryIdentifier.Name)); ContributorCount = (await applicationService.Client.Repository.GetAllContributors(RepositoryIdentifier.Owner, RepositoryIdentifier.Name)).Count; try { Readme = await applicationService.Client.Repository.Content.GetReadmeHtml(RepositoryIdentifier.Owner, RepositoryIdentifier.Name); } catch (Exception e) { Readme = "<center>There is no readme for this repository :(</center>"; Debug.WriteLine(e.Message + " for " + RepositoryIdentifier.Owner + "/" + RepositoryIdentifier.Name); } }); LoadCommand.TriggerNetworkActivity(networkActivity); }
protected FileSourceView(INetworkActivityService networkActivityService) : base(networkActivityService) { }
public StumbledRepositoryViewModel(IApplicationService applicationService, INetworkActivityService networkActivity) : base(applicationService, networkActivity) { }
public WebBrowserView(INetworkActivityService networkActivityService) : this(true, true) { _networkActivityService = networkActivityService; }
public static IDisposable TriggerNetworkActivity(this IReactiveCommand @this, INetworkActivityService networkActivity) { return(@this.IsExecuting.Skip(1).Subscribe(x => { if (x) { networkActivity.PushNetworkActive(); } else { networkActivity.PopNetworkActive(); } })); }
public UpgradeViewController() { _featuresService = Locator.Current.GetService <IFeaturesService>(); _networkActivityService = Locator.Current.GetService <INetworkActivityService>(); _inAppPurchaseService = Locator.Current.GetService <IInAppPurchaseService>(); }