Exemple #1
0
        public async Task Fill()
        {
            this.labelTop.Text = "loading...";

            int venueID = FVOConfig.LoadFromKeyChain(App.KeyChain).VenueID;

            var resultsWeb = await App.WebService.GetResultsAtVenue(venueID);

            var results = resultsWeb.Select(r => r.ToResult()).ToList();
            var scores  = await App.WebService.GetScoresAtVenue(venueID);

            bool failedToLoadFromWeb = results == null || scores == null;

            if (failedToLoadFromWeb)
            {
                scores  = App.Repository.GetScores(true);
                results = App.Repository.GetResults(true).ToList();
            }

            var matches = (from score in scores
                           select SnookerMatchScore.FromScore(score.AthleteAID, score)).ToList();
            var breaks = (from result in results
                          select SnookerBreak.FromResult(result)).ToList();

            await new CacheHelper().LoadFromWebserviceIfNecessary_People(App.Cache, results, scores);
            new CacheHelper().LoadNamesFromCache(App.Cache, breaks);
            new CacheHelper().LoadNamesFromCache(App.Cache, matches);

            listOfMatchesControl.Fill(matches);
            listOfBreaksControl.Fill(breaks);

            this.labelTop.Text = failedToLoadFromWeb ? "Failed to load. Internet issues?" : "History";
        }
Exemple #2
0
        public async Task <FullSnookerVenueData> Load(int venueID)
        {
            FullSnookerVenueData data = new FullSnookerVenueData();

            data.VenueID = venueID;

            VenueWebModel venue = await App.WebService.GetVenue(venueID);

            if (venue == null)
            {
                return(null);
            }
            data.Venue = venue;

            App.Cache.Venues.Put(venue);

            var webResults = await App.WebService.GetResultsAtVenue(venueID);

            if (webResults != null)
            {
                var results = (from r in webResults
                               select r.ToResult()).ToList();
                data.Breaks = (from i in results
                               select SnookerBreak.FromResult(i)).ToList();
            }

            var scores = await App.WebService.GetScoresAtVenue(venueID);

            if (scores != null)
            {
                data.Matches = (from i in scores
                                select SnookerMatchScore.FromScore(0, i)).ToList();
            }

            var gameHosts = await App.WebService.GetGameHostsAtVenue(venueID, true);

            if (gameHosts != null)
            {
                data.GameHosts = (from i in gameHosts
                                  orderby i.When descending
                                  select i).ToList();
                data.GameHostsInThePast = (from i in gameHosts
                                           where i.When < DateTime.UtcNow
                                           orderby i.When descending
                                           select i).ToList();
                data.GameHostsInTheFuture = (from i in gameHosts
                                             where i.When >= DateTime.UtcNow
                                             orderby i.When ascending
                                             select i).ToList();
            }

            await loadPeople(data);

            this.putPlaceholdersIfInternetIssues(data);
            return(data);
        }
Exemple #3
0
        // GET: /players/break/id
        public ActionResult Break(int id)
        {
            var result = db.Results.Where(i => i.ResultID == id).Single();
            var person = new PeopleLogic(db).GetBasic(0, result.AthleteID);

            Models.SnookerBreakModel model = new Models.SnookerBreakModel();
            model.Break  = SnookerBreak.FromResult(result);
            model.Player = person;

            return(View("Break", model));
        }
        public async Task <FullSnookerPlayerData> LoadForPlayer(int athleteID)
        {
            FullSnookerPlayerData data = new FullSnookerPlayerData();

            data.AthleteID = athleteID;

            var webResults = await App.WebService.GetResults(data.AthleteID);

            if (webResults != null)
            {
                var results = (from r in webResults
                               select r.ToResult()).ToList();
                data.Breaks = (from i in results
                               select SnookerBreak.FromResult(i)).ToList();
            }
            else
            {
                data.InternetIssues = true;
            }

            var scores = await App.WebService.GetScores(data.AthleteID);

            if (scores != null)
            {
                data.Matches = (from i in scores
                                select SnookerMatchScore.FromScore(data.AthleteID, i)).ToList();
            }
            else
            {
                data.InternetIssues = true;
            }

            await loadOpponents(data);
            await loadVenues(data);

            data.Person = await App.WebService.GetPersonByID(data.AthleteID);

            if (data.Person == null)
            {
                data.InternetIssues = true;
            }

            this.putPlaceholdersIfInternetIssues(data);
            return(data);
        }
        public async Task <FullSnookerPlayerData> LoadForMe()
        {
            DateTime timeBegin = DateTime.Now;

            FullSnookerPlayerData data = new FullSnookerPlayerData();

            data.AthleteID = App.Repository.GetMyAthleteID();

            var results = App.Repository.GetResults(data.AthleteID, false);

            data.Breaks = (from i in results
                           select SnookerBreak.FromResult(i)).ToList();

            var scores = App.Repository.GetScores(false);

            data.Matches = (from i in scores
                            select SnookerMatchScore.FromScore(data.AthleteID, i)).ToList();

            await loadOpponents(data);
            await loadVenues(data);

            data.Person = await App.WebService.GetPersonByID(data.AthleteID);

            if (data.Person == null)
            {
                data.InternetIssues = true;

                var athlete = App.Repository.GetAthlete(data.AthleteID);
                data.Person = new PersonFullWebModel();
                data.Person.CopyFrom(athlete);
            }

            this.putPlaceholdersIfInternetIssues(data);

            if (data.InternetIssues == false && data.Person != null)
            {
                await App.Cache.LoadFromWebserviceIfNecessary_Metro(data.Person.MetroID);
            }

            TraceHelper.TraceTimeSpan(timeBegin, DateTime.Now, "FullSnookerPlayerDataHelper.LoadForMe");
            return(data);
        }