lolxin 0.12.1 → 0.13.0

data/lib/lolxin.rb

@@ -1,22 +1,33 @@
+# dependency
 require 'faraday'
+require 'json'
 
-require 'lolxin/version'
-require 'lolxin/api_version'
-require 'lolxin/client'
-require 'lolxin/region'
+require 'lolxin/helpers/api'
+require 'lolxin/helpers/api_version'
+require 'lolxin/helpers/version'
+require 'lolxin/helpers/region'
+
+require 'lolxin/dto/dto'
+require 'lolxin/dto/champion_dto'
+require 'lolxin/dto/champion_mastery_dto'
+require 'lolxin/dto/game_info_dto'
+require 'lolxin/dto/league_item_dto'
+require 'lolxin/dto/league_list_dto'
+require 'lolxin/dto/league_position_dto'
+require 'lolxin/dto/mini_series_dto'
 
-require 'lolxin/champion'
-require 'lolxin/champion_mastery'
-require 'lolxin/current_game'
-require 'lolxin/featured_games'
-require 'lolxin/game'
-require 'lolxin/league'
-require 'lolxin/lol_static_data'
-require 'lolxin/lol_status'
-require 'lolxin/match'
-require 'lolxin/match_list'
-require 'lolxin/stats'
-require 'lolxin/summoner'
+require 'lolxin/api/champion_mastery'
+require 'lolxin/api/champion'
+require 'lolxin/api/league'
+require 'lolxin/api/lol_static_data'
+require 'lolxin/api/lol_status'
+require 'lolxin/api/match'
+require 'lolxin/api/spectator'
+require 'lolxin/api/summoner'
+require 'lolxin/api/third_party_code'
+#require 'lolxin/api/tournament_stub'
+#require 'lolxin/api/tournament'
+
+require 'lolxin/client'
 
-module Lolxin
-end
+module Lolxin; end

data/lib/lolxin/api/champion.rb

@@ -0,0 +1,24 @@
+module Lolxin
+  class Champion < Api
+    def champions(id = nil)
+      endpoint = "platform/%{version}/champions" % {version: version}
+
+      res = if id.nil?
+              conn.get(endpoint)
+            else
+              conn.get("#{endpoint}/#{id}")
+            end
+
+      return res if res.status != 200
+
+      body = JSON.parse(res.body)
+
+      if champs = body['champions']
+        champs.map { |champ| ChampionDto.new(champ) }
+      else
+        champ = body
+        ChampionDto.new(champ)
+      end
+    end
+  end
+end

data/lib/lolxin/api/champion_mastery.rb

@@ -0,0 +1,38 @@
+module Lolxin
+  class ChampionMastery < Api
+    attr_reader :endpoint
+
+    def initialize(options = {})
+      super
+      @endpoint = "champion-mastery/%{version}" % {version: @version}
+    end
+
+    def by_summoner(summoner_id)
+      url = "#{endpoint}/champion-masteries/by-summoner/#{summoner_id}"
+      res = conn.get(url)
+      return res if res.status != 200
+
+      champion_masteries = JSON.parse(res.body)
+      champion_masteries.map do |champion_mastery|
+        ChampionMasteryDto.new(champion_mastery)
+      end
+    end
+
+    def by_summoner_by_champion(summoner_id, champion_id)
+      url = "#{endpoint}/champion-masteries/by-summoner/#{summoner_id}/by-champion/#{champion_id}"
+      res = conn.get(url)
+      return res if res.status != 200
+
+      champion_mastery = JSON.parse(res.body)
+      ChampionMasteryDto.new(champion_mastery)
+    end
+    alias_method :by_champion, :by_summoner_by_champion
+
+    def scores(summoner_id)
+      res = conn.get("#{endpoint}/scores/by-summoner/#{summoner_id}")
+      return res if res.status != 200
+
+      res.body
+    end
+  end
+end

data/lib/lolxin/api/league.rb

@@ -0,0 +1,39 @@
+module Lolxin
+  class League < Api
+    attr_accessor :endpoint
+
+    def initialize(options = {})
+      super
+      @endpoint = "league/%{version}" % {version: @version}
+    end
+
+    %i(challenger master).each do |league|
+      define_method("#{league}_by_queue".to_sym) do |queue|
+        url = "#{endpoint}/#{league}leagues/by-queue/#{queue}"
+        res = conn.get(url)
+        return res if res.status != 200
+
+        league_list = JSON.parse(res.body)
+        LeagueListDto.new(league_list)
+      end
+    end
+
+    def leagues(league_id)
+      url = "#{endpoint}/leagues/#{league_id}"
+      res = conn.get(url)
+      return res if res.status != 200
+
+      league_lists = JSON.parse(res.body)
+      league_lists.map { |league_list| LeagueListDto.new(league_list) }
+    end
+
+    def positions_by_summoner(summoner_id)
+      url = "#{endpoint}/positions/by-summoner/#{summoner_id}"
+      res = conn.get(url)
+      return res if res.status != 200
+
+      league_positions = JSON.parse(res.body)
+      league_positions.map { |lp| LeaguePositionDto.new(lp) }
+    end
+  end
+end

data/lib/lolxin/api/lol_static_data.rb

@@ -0,0 +1,116 @@
+module Lolxin
+  class LolStaticData < Api
+    attr_accessor :endpoint
+
+    def initialize(options = {})
+      super
+      @endpoint = "static-data/%{version}" % {version: @version}
+    end
+
+    # TODO: get Faraday block to work with optional params
+    def champions(champion_id = nil)
+      url = if champion_id
+                   "#{endpoint}/champions/#{champion_id}"
+                 else
+                   "#{endpoint}/champions"
+                 end
+
+      conn.get(url)
+    end
+
+    def items(item_id = nil)
+      url = if item_id
+              "#{endpoint}/items/#{item_id}"
+            else
+              "#{endpoint}/items"
+            end
+
+      conn.get(url)
+    end
+
+    def language_strings
+      url = "#{endpoint}/language-strings"
+      conn.get(url)
+    end
+
+    def languages
+      url = "#{endpoint}/languages"
+      conn.get(url)
+    end
+
+    def maps
+      url = "#{endpoint}/maps"
+      conn.get(url)
+    end
+
+    def masteries(mastery_id = nil)
+      url = if mastery_id
+              "#{endpoint}/masteries/#{mastery_id}"
+            else
+              "#{endpoint}/masteries"
+            end
+
+      conn.get(url)
+    end
+
+    def profile_icons
+      url = "#{endpoint}/profile-icons"
+      conn.get(url)
+    end
+
+    def realms
+      url = "#{endpoint}/realms"
+      conn.get(url)
+    end
+
+    def reforged_rune_paths(path_id = nil)
+      url = if path_id
+              "#{endpoint}/reforged-rune-paths/#{path_id}"
+            else
+              "#{endpoint}/reforged-rune-paths"
+            end
+
+      conn.get(url)
+    end
+
+    def reforged_runes(reforged_rune_id = nil)
+      url = if reforged_rune_id
+              "#{endpoint}/reforged-runes/#{reforged_rune_id}"
+            else
+              "#{endpoint}/reforged-runes"
+            end
+
+      conn.get(url)
+    end
+
+    def runes(rune_id = nil)
+      url = if rune_id
+              "#{endpoint}/runes/#{rune_id}"
+            else
+              "#{endpoint}/runes"
+            end
+
+      conn.get(url)
+    end
+
+    def summoner_spells(spell_id = nil)
+      url = if spell_id
+              "#{endpoint}/summoner-spells/#{spell_id}"
+            else
+              "#{endpoint}/summoner-spells"
+            end
+
+      conn.get(url)
+    end
+
+    def tarball_links
+      url = "#{endpoint}/tarball-links"
+      conn.get(url)
+    end
+
+    def versions
+      url = "#{endpoint}/versions"
+      conn.get(url)
+    end
+  end
+end

data/lib/lolxin/api/lol_status.rb

@@ -0,0 +1,7 @@
+module Lolxin
+  class LolStatus < Api
+    def shard_data
+      conn.get("status/#{version}/shard-data")
+    end
+  end
+end

data/lib/lolxin/api/match.rb

@@ -0,0 +1,41 @@
+module Lolxin
+  class Match
+    attr_accessor :endpoint
+
+    # TODO: many endpoints to change and many DTOs to add
+    def initialize(options = {})
+      super
+      @endpoint = "match/%{version}" % {version: @version}
+    end
+
+    def matches(match_id)
+      url = "#{endpoint}/matches/#{match_id}"
+      conn.get(url)
+    end
+
+    def by_account(account_id, recent = false)
+      url = if recent
+              "#{endpoint}/matchlists/by-account/#{account_id}/recent"
+            else
+              "#{endpoint}/matchlists/by-account/#{account_id}"
+            end
+
+      conn.get(url)
+    end
+
+    def by_match(match_id)
+      url = "#{endpoint}/timelines/by-match/#{match_id}"
+      conn.get(url)
+    end
+
+    def tournament_code(tournament_code, match_id)
+      url = if tournament_code && match_id
+              "matches/by-tournament-code/#{tournament_code}/ids"
+            else
+              "matches/#{match_id}/by-tournament-code/#{tournament_code}"
+            end
+
+      conn.get(url)
+    end
+  end
+end

data/lib/lolxin/api/spectator.rb

@@ -0,0 +1,180 @@
+module Lolxin
+  class Spectator < Api
+    CurrentGameInfo = FeaturedGameInfo = Struct.new(
+      :game_id,
+      :game_start_time,
+      :platform_id,
+      :game_mode,
+      :map_id,
+      :game_type,
+      :banned_champions,
+      :observers,
+      :participants,
+      :game_length,
+      :game_queue_config_id
+    )
+
+    CurrentGameParticipant = Struct.new(
+      :profile_icon_id,
+      :champion_id,
+      :summoner_name,
+      :runes,
+      :bot,
+      :team_id,
+      :spell2d,
+      :masteries,
+      :spell1d,
+      :summoner_id
+    )
+
+    Rune = Struct.new(
+      :count,
+      :rune_id
+    )
+
+    Mastery = Struct.new(
+      :mastery_id,
+      :rank
+    )
+
+    FeaturedGames = Struct.new(
+      :client_refresh_interval,
+      :game_list
+    )
+
+    BannedChampion = Struct.new(
+      :pick_turn,
+      :champion_id,
+      :team_id
+    )
+
+    Observer = Struct.new(
+      :encryption_key
+    )
+
+    Participant = Struct.new(
+      :profile_icon_id,
+      :champion_id,
+      :summoner_name,
+      :bot,
+      :spell2d,
+      :team_id,
+      :spell1id
+    )
+
+    attr_accessor :endpoint
+
+    def initialize(options = {})
+      super
+      @endpoint = "spectator/%{version}" % {version: @version}
+    end
+
+    def by_summoner(summoner_id)
+      url = "#{endpoint}/active-games/by-summoner/#{summoner_id}"
+      res = conn.get(url)
+      return res if res.status != 200
+
+      current_game = JSON.parse(res.body)
+      build_current_game_info(current_game)
+    end
+
+    def featured_games
+      url = "#{endpoint}/featured-games"
+      res = conn.get(url)
+      return res if res.status != 200
+
+      featured = JSON.parse(res.body)
+      build_featured_games(featured)
+    end
+
+    private
+
+    def build_current_game_info(current_game)
+      CurrentGameInfo.new(
+        current_game['gameId'],
+        current_game['gameStartTime'],
+        current_game['platformId'],
+        current_game['gameMode'],
+        current_game['mapId'],
+        current_game['gameType'],
+        build_banned_champions(current_game['bannedChampions']),
+        build_observer(current_game['observers']),
+        build_current_game_participants(current_game['participants']),
+        current_game['gameLength'],
+        current_game['gameQueueConfigId']
+      )
+    end
+
+    def build_featured_games(featured_games)
+      FeaturedGames.new(
+        featured_games['clientRefreshInterval'],
+        featured_games['gameList'].map { |f| build_featured_game_info(f) }
+      )
+    end
+
+    def build_featured_game_info(feature)
+      FeaturedGameInfo.new(
+        feature['gameId'],
+        feature['gameStartTime'],
+        feature['platformId'],
+        feature['gameMode'],
+        feature['mapId'],
+        feature['gameType'],
+        build_banned_champions(feature['bannedChampions']),
+        build_observer(feature['observer']),
+        build_participants(feature['participants']),
+        feature['gameLength'],
+        feature['gameQueueConfigId']
+      )
+    end
+
+    def build_banned_champions(banned_champions)
+      return [] if banned_champions.nil? or banned_champions.empty?
+
+      banned_champions.map do |banned_champion|
+        BannedChampion.new(
+          banned_champion['pickTurn'],
+          banned_champion['championId'],
+          banned_champion['teamId']
+        )
+      end
+    end
+
+    def build_observer(observer)
+      return nil if observer.nil?
+
+      Observer.new(observer['encryptionKey'])
+    end
+
+    def build_current_game_participants(participants)
+      participants.map do |participant|
+        CurrentGameParticipant.new(
+          participant['profileIconId'],
+          participant['championId'],
+          participant['summonerName'],
+          participant['runes'],
+          participant['bot'],
+          participant['teamId'],
+          participant['spell2d'],
+          participant['masteries'],
+          participant['spell1id'],
+          participant['summonerId']
+        )
+      end
+    end
+
+    def build_participants(participants)
+      participants.map do |participant|
+        Participant.new(
+          participant['profileIconId'],
+          participant['championId'],
+          participant['summonerName'],
+          participant['bot'],
+          participant['spell2d'],
+          participant['teamId'],
+          participant['spell1id']
+        )
+      end
+    end
+  end
+end