Example #1
0
        public MenuViewModel(
            IApplicationService applicationService = null,
            IAccountsService accountsService       = null)
        {
            _applicationService = applicationService = applicationService ?? Locator.Current.GetService <IApplicationService>();
            accountsService     = accountsService ?? Locator.Current.GetService <IAccountsService>();

            var account = applicationService.Account;

            Avatar   = new Avatar(account.AvatarUrl);
            Username = account.Username;
            var username = Username;

            Title = username;

            var repos = new ReactiveList <PinnedRepository>();

            PinnedRepositories = repos.CreateDerivedCollection(x =>
            {
                var vm = new PinnedRepositoryItemViewModel(x.Name, new Avatar(x.ImageUri));
                vm.DeleteCommand
                .Do(_ => account.PinnedRepositories.RemoveAll(y => y.Id == x.Id))
                .Subscribe(_ => repos.Remove(x));
                vm.GoToCommand
                .Select(_ => new RepositoryViewModel(x.Owner, x.Slug))
                .Subscribe(NavigateTo);
                return(vm);
            });

            RefreshCommand = ReactiveCommand.CreateFromTask(_ =>
            {
                repos.Reset(applicationService.Account.PinnedRepositories);
                return(Task.FromResult(Unit.Default));
            });

            var teams = new ReactiveList <User>();

            Teams = teams.CreateDerivedCollection(x =>
            {
                var viewModel = new TeamItemViewModel(x.Username);
                viewModel.GoToCommand
                .Select(_ => new TeamViewModel(x))
                .Subscribe(NavigateTo);
                return(viewModel);
            });

            TeamEvents = teams.CreateDerivedCollection(x =>
            {
                var viewModel = new TeamItemViewModel(x.Username);
                viewModel.GoToCommand
                .Select(_ => new UserEventsViewModel(x.Username))
                .Subscribe(NavigateTo);
                return(viewModel);
            });

            LoadCommand = ReactiveCommand.CreateFromTask(t =>
            {
                applicationService.Client
                .AllItems(x => x.Teams.GetAll())
                .ToBackground(teams.Reset);

                applicationService.Client.Groups
                .GetGroups(username)
                .ToBackground(groups => Groups.Reset(groups.Select(ToViewModel)));

                return(Task.FromResult(Unit.Default));
            });

            GoToProfileCommand
            .Select(_ => new UserViewModel(username))
            .Subscribe(NavigateTo);

            GoToMyEvents
            .Select(_ => new UserEventsViewModel(username))
            .Subscribe(NavigateTo);

            GoToStarredRepositoriesCommand
            .Select(_ => new RepositoriesStarredViewModel())
            .Subscribe(NavigateTo);

            GoToOwnedRepositoriesCommand
            .Select(_ => new UserRepositoriesViewModel(username))
            .Subscribe(NavigateTo);

            GoToSharedRepositoriesCommand
            .Select(_ => new RepositoriesSharedViewModel())
            .Subscribe(NavigateTo);

            GoToTeamsCommand
            .Select(_ => new TeamsViewModel())
            .Subscribe(NavigateTo);

            GoToSettingsCommand
            .Select(_ => new SettingsViewModel())
            .Subscribe(NavigateTo);

            GoToFeedbackCommand
            .Select(_ => new IssuesViewModel("thedillonb", "codebucket"))
            .Subscribe(NavigateTo);

            GoToGroupsCommand
            .Select(_ => new GroupsViewModel(username))
            .Subscribe(NavigateTo);

            GoToExploreRepositoriesCommand
            .Select(_ => new RepositoriesExploreViewModel())
            .Subscribe(NavigateTo);

            GoToDefaultTopView.Subscribe(_ =>
            {
                var startupViewName = applicationService.Account.DefaultStartupView;
                if (!string.IsNullOrEmpty(startupViewName))
                {
                    var props                       = from p in GetType().GetProperties()
                                           let attr = p.GetCustomAttributes(typeof(PotentialStartupViewAttribute), true)
                                                      where attr.Length == 1
                                                      select new { Property = p, Attribute = attr[0] as PotentialStartupViewAttribute };


                    var match = props.FirstOrDefault(x => string.Equals(startupViewName, x.Attribute.Name));
                    var cmd   = match?.Property.GetValue(this) as ReactiveCommand <Unit, Unit>;
                    if (cmd != null)
                    {
                        cmd.ExecuteNow();
                        return;
                    }
                }

                //Oh no... Look for the last resort DefaultStartupViewAttribute
                var deprop = (from p in GetType().GetProperties()
                              let attr = p.GetCustomAttributes(typeof(DefaultStartupViewAttribute), true)
                                         where attr.Length == 1
                                         select new { Property = p, Attribute = attr[0] as DefaultStartupViewAttribute }).FirstOrDefault();

                //That shouldn't happen...
                var bCmd = deprop?.Property.GetValue(this) as ReactiveCommand <Unit, Unit>;
                if (bCmd != null)
                {
                    bCmd.ExecuteNow();
                }
            });
        }