Exemple #1
0
        public MenuViewModel(ISessionService sessionService, IAccountsRepository accountsService)
        {
            _sessionService = sessionService;

            this.WhenAnyValue(x => x.Account)
            .Select(x => new GitHubAvatar(x.AvatarUrl))
            .ToProperty(this, x => x.Avatar, out _avatar);

            GoToNotificationsCommand = ReactiveCommand.Create().WithSubscription(_ => {
                var vm = this.CreateViewModel <NotificationsViewModel>();
                vm.NotificationCount.Subscribe(x => Notifications = x);
                NavigateTo(vm);
            });

            GoToAccountsCommand = ReactiveCommand.Create().WithSubscription(_ =>
                                                                            NavigateTo(this.CreateViewModel <AccountsViewModel>()));

            GoToProfileCommand = ReactiveCommand.Create();
            GoToProfileCommand
            .Select(_ => this.CreateViewModel <UserViewModel>())
            .Select(x => x.Init(Account.Username))
            .Subscribe(NavigateTo);

            GoToMyIssuesCommand = ReactiveCommand.Create().WithSubscription(_ =>
                                                                            NavigateTo(this.CreateViewModel <MyIssuesViewModel>()));

            GoToRepositoryCommand = ReactiveCommand.Create();
            GoToRepositoryCommand.OfType <RepositoryIdentifier>()
            .Select(x => this.CreateViewModel <RepositoryViewModel>().Init(x.Owner, x.Name))
            .Subscribe(NavigateTo);

            GoToSettingsCommand = ReactiveCommand.Create().WithSubscription(_ =>
                                                                            NavigateTo(this.CreateViewModel <SettingsViewModel>()));

            GoToNewsCommand = ReactiveCommand.Create().WithSubscription(_ =>
                                                                        NavigateTo(this.CreateViewModel <NewsViewModel>()));

            GoToOrganizationsCommand = ReactiveCommand.Create();
            GoToOrganizationsCommand
            .Select(_ => this.CreateViewModel <OrganizationsViewModel>())
            .Select(x => x.Init(Account.Username))
            .Subscribe(NavigateTo);

            GoToTrendingRepositoriesCommand = ReactiveCommand.Create().WithSubscription(_ =>
                                                                                        NavigateTo(this.CreateViewModel <RepositoriesTrendingViewModel>()));

            GoToExploreRepositoriesCommand = ReactiveCommand.Create().WithSubscription(_ =>
                                                                                       NavigateTo(this.CreateViewModel <ExploreViewModel>()));

            GoToOrganizationEventsCommand = ReactiveCommand.Create();
            GoToOrganizationEventsCommand
            .OfType <Octokit.Organization>()
            .Select(x => this.CreateViewModel <UserEventsViewModel>().Init(x.Login))
            .Subscribe(NavigateTo);

            GoToOrganizationCommand = ReactiveCommand.Create();
            GoToOrganizationCommand
            .OfType <Octokit.Organization>()
            .Select(x => this.CreateViewModel <OrganizationViewModel>().Init(x.Login))
            .Subscribe(NavigateTo);

            GoToOwnedRepositoriesCommand = ReactiveCommand.Create();
            GoToOwnedRepositoriesCommand
            .Select(_ => this.CreateViewModel <UserRepositoriesViewModel>())
            .Select(x => x.Init(Account.Username))
            .Subscribe(NavigateTo);

            GoToStarredRepositoriesCommand = ReactiveCommand.Create().WithSubscription(
                _ => NavigateTo(this.CreateViewModel <RepositoriesStarredViewModel>()));

            GoToWatchedRepositoriesCommand = ReactiveCommand.Create().WithSubscription(
                _ => NavigateTo(this.CreateViewModel <RepositoriesWatchedViewModel>()));

            GoToPublicGistsCommand = ReactiveCommand.Create().WithSubscription(
                _ => NavigateTo(this.CreateViewModel <PublicGistsViewModel>()));

            GoToStarredGistsCommand = ReactiveCommand.Create().WithSubscription(
                _ => NavigateTo(this.CreateViewModel <StarredGistsViewModel>()));

            GoToMyGistsCommand = ReactiveCommand.Create();
            GoToMyGistsCommand
            .Select(_ => this.CreateViewModel <UserGistsViewModel>())
            .Select(x => x.Init(Account.Username))
            .Subscribe(NavigateTo);

            GoToMyEvents = ReactiveCommand.Create();
            GoToMyEvents
            .Select(_ => this.CreateViewModel <UserEventsViewModel>())
            .Select(x => x.Init(Account.Username))
            .Subscribe(NavigateTo);

            GoToFeedbackCommand = ReactiveCommand.Create();
            GoToFeedbackCommand.Subscribe(_ => {
                var vm = sessionService.Account.IsEnterprise
                    ? (IBaseViewModel)this.CreateViewModel <EnterpriseSupportViewModel>()
                    : this.CreateViewModel <SupportViewModel>();
                NavigateTo(vm);
            });

            DeletePinnedRepositoryCommand = ReactiveCommand.Create();

            DeletePinnedRepositoryCommand.OfType <PinnedRepository>()
            .Subscribe(x => {
                sessionService.Account.PinnnedRepositories.Remove(x);
                accountsService.Update(sessionService.Account);
            });

            ActivateCommand = ReactiveCommand.Create();
            ActivateCommand.Subscribe(x => {
                var startupViewModel            = sessionService.StartupViewModel;
                sessionService.StartupViewModel = null;
                if (startupViewModel != null)
                {
                    NavigateTo(startupViewModel);
                }
                else
                {
                    GoToDefaultTopView.ExecuteIfCan();
                }
            });

            LoadCommand = ReactiveCommand.CreateAsyncTask(_ => {
//                var notifications = sessionService.GitHubClient.Notification.GetAllForCurrent();
//                notifications.ToBackground(x => Notifications = x.Count);
////
//                var organizations = sessionService.GitHubClient.Organization.GetAllForCurrent();
//                organizations.ToBackground(x => Organizations = x);
//
//                return Task.WhenAll(notifications, organizations);

                return(Task.FromResult(Unit.Default));
            });
        }
        public MenuViewModel(IApplicationService applicationService, IAccountsService accountsService)
            : base(accountsService)
        {
            _applicationService = applicationService;

            GoToNotificationsCommand = ReactiveCommand.Create();
            GoToNotificationsCommand.Subscribe(_ =>
            {
                var vm = CreateViewModel <NotificationsViewModel>();
                ShowViewModel(vm);
            });

            GoToAccountsCommand = ReactiveCommand.Create();
            GoToAccountsCommand.Subscribe(_ => CreateAndShowViewModel <AccountsViewModel>());

            GoToProfileCommand = ReactiveCommand.Create();
            GoToProfileCommand.Subscribe(_ =>
            {
                var vm      = CreateViewModel <ProfileViewModel>();
                vm.Username = Account.Username;
                ShowViewModel(vm);
            });

            GoToMyIssuesCommand = ReactiveCommand.Create();
            GoToMyIssuesCommand.Subscribe(_ => CreateAndShowViewModel <MyIssuesViewModel>());

            GoToUpgradesCommand = ReactiveCommand.Create();
            GoToUpgradesCommand.Subscribe(_ => CreateAndShowViewModel <UpgradesViewModel>());

            GoToAboutCommand = ReactiveCommand.Create();
            GoToAboutCommand.Subscribe(_ => CreateAndShowViewModel <AboutViewModel>());

            GoToRepositoryCommand = ReactiveCommand.Create();
            GoToRepositoryCommand.OfType <RepositoryIdentifier>().Subscribe(x =>
            {
                var vm             = CreateViewModel <RepositoryViewModel>();
                vm.RepositoryOwner = x.Owner;
                vm.RepositoryName  = x.Name;
                ShowViewModel(vm);
            });

            GoToSettingsCommand = ReactiveCommand.Create();
            GoToSettingsCommand.Subscribe(_ => CreateAndShowViewModel <SettingsViewModel>());

            GoToNewsCommand = ReactiveCommand.Create();
            GoToNewsCommand.Subscribe(_ => CreateAndShowViewModel <NewsViewModel>());

            GoToOrganizationsCommand = ReactiveCommand.Create();
            GoToOrganizationsCommand.Subscribe(_ =>
            {
                var vm      = CreateViewModel <OrganizationsViewModel>();
                vm.Username = Account.Username;
                ShowViewModel(vm);
            });

            GoToTrendingRepositoriesCommand = ReactiveCommand.Create();
            GoToTrendingRepositoriesCommand.Subscribe(_ => CreateAndShowViewModel <RepositoriesTrendingViewModel>());

            GoToExploreRepositoriesCommand = ReactiveCommand.Create();
            GoToExploreRepositoriesCommand.Subscribe(_ => CreateAndShowViewModel <RepositoriesExploreViewModel>());

            GoToOrganizationEventsCommand = ReactiveCommand.Create();
            GoToOrganizationEventsCommand.OfType <string>().Subscribe(name =>
            {
                var vm      = CreateViewModel <UserEventsViewModel>();
                vm.Username = name;
                ShowViewModel(vm);
            });

            GoToOrganizationCommand = ReactiveCommand.Create();
            GoToOrganizationCommand.OfType <string>().Subscribe(name =>
            {
                var vm  = CreateViewModel <OrganizationViewModel>();
                vm.Name = name;
                ShowViewModel(vm);
            });

            GoToOwnedRepositoriesCommand = ReactiveCommand.Create();
            GoToOwnedRepositoriesCommand.Subscribe(_ =>
            {
                var vm      = CreateViewModel <UserRepositoriesViewModel>();
                vm.Username = Account.Username;
                ShowViewModel(vm);
            });

            GoToStarredRepositoriesCommand = ReactiveCommand.Create();
            GoToStarredRepositoriesCommand.Subscribe(_ => CreateAndShowViewModel <RepositoriesStarredViewModel>());

            GoToPublicGistsCommand = ReactiveCommand.Create();
            GoToPublicGistsCommand.Subscribe(_ => CreateAndShowViewModel <PublicGistsViewModel>());

            GoToStarredGistsCommand = ReactiveCommand.Create();
            GoToStarredGistsCommand.Subscribe(_ => CreateAndShowViewModel <StarredGistsViewModel>());

            GoToMyGistsCommand = ReactiveCommand.Create();
            GoToMyGistsCommand.Subscribe(_ =>
            {
                var vm      = CreateViewModel <UserGistsViewModel>();
                vm.Username = Account.Username;
                ShowViewModel(vm);
            });

            GoToMyEvents = ReactiveCommand.Create();
            GoToMyEvents.Subscribe(_ =>
            {
                var vm      = CreateViewModel <UserEventsViewModel>();
                vm.Username = Account.Username;
                ShowViewModel(vm);
            });

            var loadCommand = ReactiveCommand.Create();

            loadCommand.Subscribe(_ =>
            {
                var notificationRequest = applicationService.Client.Notifications.GetAll();
                notificationRequest.RequestFromCache = false;
                notificationRequest.CheckIfModified  = false;

                applicationService.Client.ExecuteAsync(notificationRequest)
                .ContinueWith(t => Notifications = t.Result.Data.Count, TaskScheduler.FromCurrentSynchronizationContext());

                applicationService.Client.ExecuteAsync(applicationService.Client.AuthenticatedUser.GetOrganizations())
                .ContinueWith(t => Organizations = t.Result.Data.Select(y => y.Login).ToList(), TaskScheduler.FromCurrentSynchronizationContext());
            });
            LoadCommand = loadCommand;
        }