public static PubgSeason GetSeason(PubgRegion region) { PubgSeason season = null; if (region.IsXbox()) { season = StoredItems.OfType <PubgSeason>().FirstOrDefault(p => p.Id.ToLowerInvariant().Contains("xb")); } else if (region.IsPC()) { season = StoredItems.OfType <PubgSeason>().FirstOrDefault(p => !p.Id.ToLowerInvariant().Contains("xb")); } if (season != null) { return(season); } var seasonService = new PubgSeasonService(ApiKey); List <PubgSeason> seasons = new List <PubgSeason>(); if (region.IsPC()) { seasons = seasonService.GetSeasonsPC().ToList(); } else if (region.IsXbox()) { seasons = seasonService.GetSeasonsXbox(region).ToList(); } seasons.ForEach(s => StoredItems.Add(s)); return(seasons.LastOrDefault()); }
public static async Task <PubgPlayer> GetPlayerFromName(string playerName, PubgRegion region) { if (cachedPlayers.ContainsKey(playerName) && DateTime.Now - cachedPlayers[playerName].Item2 < cacheTimeout) { System.Console.WriteLine("Cache hit for player {0}", playerName); return(cachedPlayers[playerName].Item1); } var playerFilter = new GetPubgPlayersRequest() { PlayerNames = new string[] { playerName } }; var pubgPlayers = await _playerService.GetPlayersAsync(region, playerFilter); using (var pubgPlayersEnumerator = pubgPlayers.GetEnumerator()) { if (pubgPlayersEnumerator.MoveNext()) { var pubgPlayer = pubgPlayersEnumerator.Current; cachedPlayers[playerName] = new Tuple <PubgPlayer, DateTime>(pubgPlayer, DateTime.Now); return(pubgPlayer); } } return(null); }
//TODO: Refactor cache so we only store needed info, not entire match object public async Task <PubgMatch> GetMatchAsync(string matchId, PubgRegion region = PubgRegion.PCNorthAmerica) { return(await GetAsync <PubgMatch>(matchId + region, async (t) => { return await pubgApi.GetMatchAsync(matchId, region); })); }
public virtual IEnumerable <PubgTelemetryEvent> GetTelemetry(PubgRegion region, string url) { var collectionJson = HttpRequestor.GetString(url); return(JsonConvert.DeserializeObject <IEnumerable <PubgTelemetryEvent> >(collectionJson, new JsonSerializerSettings { ContractResolver = new TelemetryContractResolver(region.Serialize()) })); }
public async Task <IEnumerable <PubgSeason> > GetSeasonsAsync(PubgRegion region = PubgRegion.PCNorthAmerica) { return(await GetAsync <List <PubgSeason> >("seasons", async (t) => { var retVal = await pubgApi.GetSeasonsAsync(region); return retVal.ToList(); })); }
public async Task <PubgPlayer> GetPlayerByNameAsync(string playerName, PubgRegion region = PubgRegion.PCNorthAmerica) { return(await GetAsync <PlayerCache>(playerName + region, async (t) => { var retVal = await pubgApi.GetPlayerByNameAsync(playerName, region); return (PlayerCache)retVal; })); }
public virtual IEnumerable <PubgPlayer> GetPlayers(PubgRegion region, GetPubgPlayersRequest filter) { var url = RequestBuilder.BuildRequestUrl(string.Format(Api.Players.PlayersEndpoint, region.Serialize()), filter); var apiKey = string.IsNullOrEmpty(filter.ApiKey) ? ApiKey : filter.ApiKey; var collectionJson = HttpRequestor.GetString(url, apiKey); return(JsonConvert.DeserializeObject <IEnumerable <PubgPlayer> >(collectionJson, new JsonApiSerializerSettings())); }
public virtual async Task <IEnumerable <PubgPlayer> > GetPlayersAsync(PubgRegion region, GetPubgPlayersRequest filter, CancellationToken cancellationToken = default(CancellationToken)) { var url = RequestBuilder.BuildRequestUrl(string.Format(Api.Players.PlayersEndpoint, region.Serialize()), filter); var apiKey = string.IsNullOrEmpty(filter.ApiKey) ? ApiKey : filter.ApiKey; var collectionJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey); return(JsonConvert.DeserializeObject <IEnumerable <PubgPlayer> >(collectionJson, new JsonApiSerializerSettings())); }
public async Task <PubgMatchSample> GetMatchSamplesAsync(PubgRegion region, GetSamplesRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var url = RequestBuilder.BuildRequestUrl(string.Format(Api.Samples.SamplesEndpoint, region.Serialize()), request); var apiKey = string.IsNullOrEmpty(request.ApiKey) ? ApiKey : request.ApiKey; var collectionJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey); return(JsonConvert.DeserializeObject <IEnumerable <PubgMatchSample> >(collectionJson, new JsonApiSerializerSettings()).FirstOrDefault()); }
public PubgMatchSample GetMatchSamples(PubgRegion region, GetSamplesRequest request) { var url = RequestBuilder.BuildRequestUrl(string.Format(Api.Samples.SamplesEndpoint, region.Serialize()), request); var apiKey = string.IsNullOrEmpty(request.ApiKey) ? ApiKey : request.ApiKey; var collectionJson = HttpRequestor.GetString(url, apiKey); return(JsonConvert.DeserializeObject <IEnumerable <PubgMatchSample> >(collectionJson, new JsonApiSerializerSettings()).FirstOrDefault()); }
/// <summary> /// Get a list of seasons for the specified region on Xbox /// </summary> /// <param name="platform">The platform you wish to get the seasons for</param> /// <param name="apiKey">Your api key (optional)</param> /// <returns>A list of seasons and their information</returns> /// <exception cref="Pubg.Net.Exceptions.PubgException">Exception thrown on the API side, details included on object</exception> /// <exception cref="Pubg.Net.Exceptions.PubgTooManyRequestsException">You have exceeded your rate limit</exception> /// <exception cref="Pubg.Net.Exceptions.PubgUnauthorizedException">Invalid API Key</exception> public async virtual Task <IEnumerable <PubgSeason> > GetSeasonsXboxAsync(PubgRegion region, string apiKey = null, CancellationToken cancellationToken = default(CancellationToken)) { var url = Api.Seasons.SeasonsXboxEndpoint(region); apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey; var seasonJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey).ConfigureAwait(false); return(JsonConvert.DeserializeObject <IEnumerable <PubgSeason> >(seasonJson, new JsonApiSerializerSettings())); }
public virtual async Task <PubgPlayer> GetPlayerAsync(PubgRegion region, string playerId, string apiKey = null, CancellationToken cancellationToken = default(CancellationToken)) { var url = Api.Players.PlayersEndpoint(region, playerId); apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey; var playerJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey).ConfigureAwait(false); return(JsonConvert.DeserializeObject <PubgPlayer>(playerJson, new JsonApiSerializerSettings())); }
public virtual PubgPlayer GetPlayer(PubgRegion region, string playerId, string apiKey = null) { var url = Api.Players.PlayersEndpoint(region, playerId); apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey; var playerJson = HttpRequestor.GetString(url, apiKey); return(JsonConvert.DeserializeObject <PubgPlayer>(playerJson, new JsonApiSerializerSettings())); }
/// <summary> /// Get a list of seasons for the specified region on Xbox /// </summary> /// <param name="platform">The platform you wish to get the seasons for</param> /// <param name="apiKey">Your api key (optional)</param> /// <returns>A list of seasons and their information</returns> /// <exception cref="Pubg.Net.Exceptions.PubgException">Exception thrown on the API side, details included on object</exception> /// <exception cref="Pubg.Net.Exceptions.PubgTooManyRequestsException">You have exceeded your rate limit</exception> /// <exception cref="Pubg.Net.Exceptions.PubgUnauthorizedException">Invalid API Key</exception> public virtual IEnumerable <PubgSeason> GetSeasonsXbox(PubgRegion region, string apiKey = null) { var url = Api.Seasons.SeasonsXboxEndpoint(region); apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey; var seasonJson = HttpRequestor.GetString(url, apiKey); return(JsonConvert.DeserializeObject <IEnumerable <PubgSeason> >(seasonJson, new JsonApiSerializerSettings())); }
public async virtual Task <PubgPlayerSeason> GetPlayerSeasonAsync(PubgRegion region, string playerId, string seasonId, string apiKey = null, CancellationToken cancellationToken = default(CancellationToken)) { var url = string.Format(Api.Players.PlayerSeasonsEndpoint, region.Serialize(), playerId, seasonId); apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey; var seasonJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey); return(JsonConvert.DeserializeObject <PubgPlayerSeason>(seasonJson, new JsonApiSerializerSettings())); }
public virtual PubgMatch GetMatch(PubgRegion region, string matchId, string apiKey = null) { var url = string.Format(Api.Matches.MatchesEndpoint + "/{1}", region.Serialize(), matchId); apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey; var matchJson = HttpRequestor.GetString(url, apiKey); return(JsonConvert.DeserializeObject <IEnumerable <PubgMatch> >(matchJson, new JsonApiSerializerSettings()).FirstOrDefault()); }
public virtual PubgPlayerSeason GetPlayerSeason(PubgRegion region, string playerId, string seasonId, string apiKey = null) { var url = string.Format(Api.Players.PlayerSeasonsEndpoint, region.Serialize(), playerId, seasonId); apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey; var seasonJson = HttpRequestor.GetString(url, apiKey); return(JsonConvert.DeserializeObject <PubgPlayerSeason>(seasonJson, new JsonApiSerializerSettings())); }
public async virtual Task <PubgMatch> GetMatchAsync(PubgRegion region, string matchId, string apiKey = null, CancellationToken cancellationToken = default(CancellationToken)) { var url = string.Format(Api.Matches.MatchesEndpoint + "/{1}", region.Serialize(), matchId); apiKey = string.IsNullOrEmpty(apiKey) ? ApiKey : apiKey; var matchJson = await HttpRequestor.GetStringAsync(url, cancellationToken, apiKey); return(JsonConvert.DeserializeObject <IEnumerable <PubgMatch> >(matchJson, new JsonApiSerializerSettings()).FirstOrDefault()); }
public async Task <PlayerResponse> GetPlayer(PubgRegion region, string playerId) { var url = new Uri(_baseUri, $"{region.Serialize()}/players/{playerId}"); var data = await SendRequestAsync <PlayerResponse>(url, HttpMethod.Get, _defaultHeaders); if (!data.Success) { throw new Exception($"ERROR: Faild to get player - {data.ErrorCode} - {data.ErrorMessage}"); } return(data.Data); }
public async Task <IActionResult> GetSeasons(PubgRegion region) { try { var seasons = await pubgApi.GetSeasonsAsync(region); return(Ok(seasons)); } catch (Exception e) { return(NotFound("Seasons Not Found For Region")); } }
public async Task <PubgPlayer> GetPlayerByNameAsync(string playerName, PubgRegion region = PubgRegion.PCNorthAmerica) { PubgPlayerService playerService = new PubgPlayerService(); var request = new GetPubgPlayersRequest { PlayerNames = new string[] { playerName } }; var response = await playerService.GetPlayersAsync(region, request); return(response.First()); }
public static PubgMatchSample GetSamples(PubgRegion region) { var samples = StoredItems.OfType<PubgMatchSample>().FirstOrDefault(p => p.ShardId == region.Serialize()); if (samples != null) return samples; var sampleService = new PubgSamplesService(ApiKey); samples = sampleService.GetMatchSamples(region); StoredItems.Add(samples); return samples; }
public static PubgSeason GetSeason(PubgRegion region) { var season = StoredItems.OfType <PubgSeason>().FirstOrDefault(); if (season != null) { return(season); } var seasons = new PubgSeasonService(ApiKey).GetSeasons(region).ToList(); seasons.ForEach(s => StoredItems.Add(s)); return(seasons.FirstOrDefault()); }
public static PubgMatch GetMatch(PubgRegion region) { var match = StoredItems.OfType <PubgMatch>().FirstOrDefault(p => p.ShardId == region.Serialize()); if (match != null) { return(match); } var samples = GetSamples(region); match = new PubgMatchService(ApiKey).GetMatch(region, samples.MatchIds.First()); StoredItems.Add(match); return(match); }
public async Task <FindPlayersResponse> FilterPlayersById(PubgRegion region, params string[] playerIds) { var playersUrl = new Uri(_baseUri, $"{region.Serialize()}/players"); var url = new UriBuilder(playersUrl); var query = HttpUtility.ParseQueryString(url.Query); query["filter[playerIds]"] = string.Join(',', playerIds); url.Query = query.ToString(); var data = await SendRequestAsync <FindPlayersResponse>(url.Uri, HttpMethod.Get, _defaultHeaders); if (!data.Success) { throw new Exception($"ERROR: Faild to find players - {data.ErrorCode} - {data.ErrorMessage}"); } return(data.Data); }
public async Task <IActionResult> GetPlayer(string playerName, PubgRegion region = PubgRegion.PCNorthAmerica) { if (String.IsNullOrEmpty(playerName)) { return(NotFound()); } try { var player = await pubgApi.GetPlayerByNameAsync(playerName, region); return(Ok(player)); } catch (Exception e) { return(NotFound("Player Not Found")); } }
public static PubgPlayer GetPlayer(PubgRegion region) { var player = StoredItems.OfType <PubgPlayer>().FirstOrDefault(p => p.ShardId == region.Serialize()); if (player != null) { return(player); } var playerService = new PubgPlayerService(ApiKey); var playerNames = GetMatch(region).Rosters.SelectMany(r => r.Participants).Select(p => p.Stats.Name).Take(5); var players = playerService.GetPlayers(region, new GetPubgPlayersRequest { PlayerNames = playerNames.ToArray() }); StoredItems.AddRange(players); return(players.FirstOrDefault()); }
public async Task <PlayerStats> FilterStats(string playerName, string seasonId, PubgRegion region = PubgRegion.PCNorthAmerica) { //Wrapping in try catch in case player name or season id is incorrect try { PlayerStats playerStats = new PlayerStats(); //Populate object properties this.playerName = playerName; this.seasonId = seasonId; this.region = region; //Get Player var player = await pubgApi.GetPlayerByNameAsync(playerName); playerId = player.Id; //Get Player Season var playerSeason = await pubgApi.GetPlayerSeasonAsync(playerId, seasonId, region); //Filter Matches var validMatches = await FilterMatches(LoadMatches(playerSeason)); //Compute Stats if (validMatches > 0) { return(BuildStats(playerSeason.GameModeStats, validMatches)); } } catch (NullReferenceException e) { } return(null); }
public static async Task <PubgPlayerSeason> GetPlayerSeason(PubgPlayer player, PubgRegion region, PubgSeason season) { var cacheKey = new PlayerSeasonKey(player.Id, region, season.Id); if (cachedPlayerSeasons.ContainsKey(cacheKey) && DateTime.Now - cachedPlayerSeasons[cacheKey].Item2 < cacheTimeout) { System.Console.WriteLine("Cache hit for player season {0}", player.Name); return(cachedPlayerSeasons[cacheKey].Item1); } var pubgPlayerSeason = await _playerService.GetPlayerSeasonAsync(region, player.Id, season.Id); cachedPlayerSeasons[cacheKey] = new Tuple <PubgPlayerSeason, DateTime>(pubgPlayerSeason, DateTime.Now); return(pubgPlayerSeason); }
public virtual async Task <IEnumerable <PubgTelemetryEvent> > GetTelemetryAsync(PubgRegion region, string url, CancellationToken cancellationToken = default(CancellationToken)) { var collectionJson = await HttpRequestor.GetStringAsync(url, cancellationToken); return(JsonConvert.DeserializeObject <IEnumerable <PubgTelemetryEvent> >(collectionJson)); }