public RiotRestAPI.MatchDTO LoadMatch(SeedData.MatchListing listing, string matchId)
        {
            RiotRestAPI.MatchDTO match = null;

            if (DoesRawCachedCopyOfMatchExist(listing, matchId))
            {
                match = LoadMatchFromRawFile(listing, matchId);
            }
            else
            {
                string rawResponse = "";
                match = LoadMatchFromAPI(listing, matchId, ref rawResponse);

                // Save the raw response file to speed up future queries
                string prettyJSON = JsonPrettyPrinterPlus.PrettyPrinterExtensions.PrettyPrintJson(rawResponse);

                string[]   rawfilePathParts = new string[] { _rawMatchDataDirectory, listing.region + "-" + matchId + ".json" };
                string     filePath         = System.IO.Path.Combine(rawfilePathParts);
                FileStream fstream          = new FileStream(filePath, FileMode.Create);
                byte[]     data             = Encoding.ASCII.GetBytes(prettyJSON);
                fstream.Write(data, 0, data.Length);
                fstream.Close();
            }

            return(match);
        }
        public bool DoesRawCachedCopyOfMatchExist(SeedData.MatchListing matchListing, string matchId)
        {
            string[] rawfilePathParts = new string[] { _rawMatchDataDirectory, BuildMatchFileName(matchListing, matchId) };
            string   filePath         = System.IO.Path.Combine(rawfilePathParts);

            return(File.Exists(filePath));
        }
        protected RiotRestAPI.MatchDTO LoadMatchFromAPI(SeedData.MatchListing listing, string matchId, ref string rawResponse)
        {
            RiotRestAPI.MatchDTO match = null;

            bool rateLimitHit = true;

            while (rateLimitHit)
            {
                string resource = "/" + listing.region + "/v2.2/match/" + matchId;

                Dictionary <string, string> queryParams = new Dictionary <string, string>();
                queryParams["includeTimeline"] = "true";
                match = _apiConnection.Get <RiotRestAPI.MatchDTO>(resource, queryParams,
                                                                  ref rateLimitHit, ref rawResponse);
                if (match != null)
                {
                    LogProgress("Loaded match " + listing.region + "-" + matchId + " from the API.");
                }
                else if (rateLimitHit)
                {
                    LogProgress("Hit rate limit. Waiting to retry.");
                    System.Threading.Thread.Sleep(RATE_LIMIT_WAIT_IN_MS);
                }
                else
                {
                    LogProgress("Unable to load match: " + listing.region + " - " + matchId);
                }
            }

            return(match);
        }
        static public List <MatchListing> LoadMatchDataFromSourceFiles(string rootDataFileDir)
        {
            List <SeedData.MatchListing> matchIdFiles = new List <SeedData.MatchListing>();

            IEnumerable <String> versionSubDirectories = System.IO.Directory.EnumerateDirectories(rootDataFileDir);

            foreach (string versionDir in versionSubDirectories)
            {
                string version = System.IO.Path.GetFileName(versionDir);

                IEnumerable <string> modeSubDirectories = System.IO.Directory.EnumerateDirectories(versionDir);
                foreach (string modeDir in modeSubDirectories)
                {
                    string mode = System.IO.Path.GetFileName(modeDir);

                    IEnumerable <string> regionFiles = System.IO.Directory.EnumerateFiles(modeDir);
                    foreach (string regionFile in regionFiles)
                    {
                        string region = System.IO.Path.GetFileNameWithoutExtension(regionFile).ToLower();

                        DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(List <double>));
                        object        objResponse = jsonSerializer.ReadObject(File.Open(regionFile, FileMode.Open));
                        List <double> listing     = (List <double>)Convert.ChangeType(objResponse, typeof(List <double>));

                        SeedData.MatchListing matchListingFile = new SeedData.MatchListing();
                        matchListingFile.mode    = mode;
                        matchListingFile.region  = region;
                        matchListingFile.version = version;
                        foreach (double entry in listing)
                        {
                            matchListingFile.MatchIds.Add(entry.ToString());
                        }
                        matchIdFiles.Add(matchListingFile);
                    }
                }
            }

            return(matchIdFiles);
        }
        protected RiotRestAPI.MatchDTO LoadMatchFromRawFile(SeedData.MatchListing matchListing, string matchId)
        {
            RiotRestAPI.MatchDTO match = null;

            string[]   rawfilePathParts = new string[] { _rawMatchDataDirectory, BuildMatchFileName(matchListing, matchId) };
            string     filePath         = System.IO.Path.Combine(rawfilePathParts);
            FileStream fstream          = new FileStream(filePath, FileMode.Open);
            DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(RiotRestAPI.MatchDTO));
            object objResponse = null;

            try
            {
                objResponse = jsonSerializer.ReadObject(fstream);
            }
            catch (System.Xml.XmlException ex)
            {
                LogProgress("XML Exception while parsing match response: " + matchListing.region + "-" + matchId + " - " + ex.Message);
            }
            catch (Exception ex)
            {
                LogProgress("Generic Exception while parsing match response: " + matchListing.region + "-" + matchId + " - " + ex.Message);
            }

            fstream.Close();

            if (objResponse == null)
            {
                LogProgress("Failed to load match " + matchListing.region + "-" + matchId + " from cached data. Deleting file.");
                File.Delete(filePath);
            }
            else
            {
                match = (RiotRestAPI.MatchDTO)Convert.ChangeType(objResponse, typeof(RiotRestAPI.MatchDTO));
                LogProgress("Loaded match " + matchListing.region + "-" + matchId + " from cached data.");
            }

            return(match);
        }
        public static List<MatchListing> LoadMatchDataFromSourceFiles(string rootDataFileDir)
        {
            List<SeedData.MatchListing> matchIdFiles = new List<SeedData.MatchListing>();

            IEnumerable<String> versionSubDirectories = System.IO.Directory.EnumerateDirectories(rootDataFileDir);
            foreach (string versionDir in versionSubDirectories)
            {
                string version = System.IO.Path.GetFileName(versionDir);

                IEnumerable<string> modeSubDirectories = System.IO.Directory.EnumerateDirectories(versionDir);
                foreach (string modeDir in modeSubDirectories)
                {
                    string mode = System.IO.Path.GetFileName(modeDir);

                    IEnumerable<string> regionFiles = System.IO.Directory.EnumerateFiles(modeDir);
                    foreach (string regionFile in regionFiles)
                    {
                        string region = System.IO.Path.GetFileNameWithoutExtension(regionFile).ToLower();

                        DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(List<double>));
                        object objResponse = jsonSerializer.ReadObject(File.Open(regionFile, FileMode.Open));
                        List<double> listing = (List<double>)Convert.ChangeType(objResponse, typeof(List<double>));

                        SeedData.MatchListing matchListingFile = new SeedData.MatchListing();
                        matchListingFile.mode = mode;
                        matchListingFile.region = region;
                        matchListingFile.version = version;
                        foreach (double entry in listing)
                        {
                            matchListingFile.MatchIds.Add(entry.ToString());
                        }
                        matchIdFiles.Add(matchListingFile);
                    }
                }
            }

            return matchIdFiles;
        }
 static private string BuildMatchFileName(SeedData.MatchListing matchListing, string matchId)
 {
     return(matchListing.region + "-" + matchId + ".json");
 }