public RepositoriesTrendingViewModel(IApplicationService applicationService, TrendingRepository trendingRepository)
        {
            ShowRepositoryDescription = applicationService.Account.ShowRepositoryDescriptionInList;

            Title = "Trending";

            var defaultLanguage = LanguageRepository.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 _ =>
            {
                Repositories = null;

                var requests = _times.Select(t =>
                {
                    var language = (SelectedLanguage != null && SelectedLanguage.Slug != null) ? SelectedLanguage.Slug : null;
                    return(new { Time = t, Query = trendingRepository.GetTrendingRepositories(t.Slug, language) });
                }).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.Login, x.Owner.AvatarUrl, x.Description, x.StargazersCount, x.ForksCount, true, gotoRepository));
                    return(new GroupedCollection <RepositoryItemViewModel>(r.Time.Name, new ReactiveList <RepositoryItemViewModel>(transformedRepos)));
                }).ToList();
            });

            this.WhenAnyValue(x => x.SelectedLanguage).Skip(1).Subscribe(_ => LoadCommand.ExecuteIfCan());
        }
Exemplo n.º 2
0
        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);
        }
Exemplo n.º 3
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();

            ConfigureConsul(services);

            var secret = "eBCatxoffIIq6ESdrDZ8LKI3zpxhYkYM";
            var key    = Encoding.ASCII.GetBytes(secret);

            services.AddAuthentication(option =>
            {
                option.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                option.DefaultChallengeScheme    = JwtBearerDefaults.AuthenticationScheme;
            }).AddJwtBearer(options =>
            {
                options.RequireHttpsMetadata      = false;
                options.SaveToken                 = true;
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    IssuerSigningKey         = new SymmetricSecurityKey(key),
                    ValidateIssuerSigningKey = true,
                    ValidateIssuer           = false,
                    ValidateAudience         = false
                };
            });

            services.AddAuthorization();

            services.AddMessagePublishing("TrendingService", builder =>
            {
                builder.WithHandler <NewTopicTweetMessageHandler>("NewTopicTweetMessage");
            });

            var config = new ServerConfig();

            Configuration.Bind(config);

            var trendingContext = new TrendingContext(config.MongoDB);
            var repo            = new TrendingRepository(trendingContext);

            services.AddSingleton <ITrendingRepository>(repo);

            services.AddScoped <ITrendingService, Services.TrendingService>();
        }
        protected override async Task Load(bool forceCacheInvalidation)
        {
            var trendingRepo = new TrendingRepository();
            var repos        = new List <Tuple <string, IList <RepositoryModel> > >();
            var times        = new []
            {
                Tuple.Create("Daily", "daily"),
                Tuple.Create("Weekly", "weekly"),
                Tuple.Create("Monthly", "monthly"),
            };

            foreach (var t in times)
            {
                var repo = await trendingRepo.GetTrendingRepositories(t.Item2, SelectedLanguage.Slug);

                repos.Add(Tuple.Create(t.Item1, repo));
            }

            Repositories = repos;
        }