1 files changed, 207 insertions, 0 deletions
diff --git a/lib/sampling/riot_api.rb b/lib/sampling/riot_api.rb
new file mode 100644
index 0000000..bbe9cea
--- /dev/null
+++ b/lib/sampling/riot_api.rb
@@ -0,0 +1,207 @@
+module Sampling
+	class RiotApi
+		protected
+		def self.api_name
+			"prod.api.pvp.net/api/lol"
+		end
+
+		protected
+		def self.api_key
+			ENV["RIOT_API_KEY"]
+		end
+
+		protected
+		def self.region
+			ENV["RIOT_API_REGION"]
+		end
+
+		protected
+		def self.url(request, args={})
+			"https://prod.api.pvp.net/api/lol/#{region}/#{request % args.merge(args){|k,v|url_escape(v)}}?api_key=#{api_key}"
+		end
+
+		protected
+		def self.url_escape(string)
+			URI::escape(string.to_s, /[^a-zA-Z0-9._~!$&'()*+,;=:@-]/)
+		end
+
+		protected
+		def self.standardize(summoner_name)
+			summoner_name.to_s.downcase.gsub(' ', '')
+		end
+
+		protected
+		def self.stats_available
+			["win", "numDeaths", "turretsKilled", "championsKilled", "minionsKilled", "assists"]
+		end
+
+		protected
+		class Job < ThrottledApiRequest
+			def initialize(request, args={})
+					@url = Sampling::RiotApi::url(request, args)
+					limits = [
+						{:unit_time => 10.seconds, :requests_per => 10},
+						{:unit_time => 10.minutes, :requests_per => 500},
+					]
+					super(RiotApi::api_name, limits)
+			end
+
+			def perform
+				response = open(@url)
+				status = response.status
+				data = JSON::parse(response.read)
+
+				# Error codes that RIOT uses:
+				#   "400"=>"Bad request"
+				#   "401"=>"Unauthorized"
+				#   "429"=>"Rate limit exceeded"
+				#   "500"=>"Internal server error"
+				#   "503"=>"Service unavailable"
+				#   "404"=>"Not found"
+				# Should probably handle these better
+				if status[0] != "200"
+					raise "GET #{@url} => #{status.join(" ")}"
+				end
+				return self.handle(data)
+			end
+
+			def handle(data)
+				return true
+			end
+		end
+
+		########################################################################
+
+		##
+		# Return whether or not this sampling method works with the specified game.
+		# Spoiler: It only works with League of Legends (or subclasses of it).
+		public
+		def self.works_with?(game)
+			if api_key.nil? or region.nil?
+				return false
+			end
+			if game.name == "League of Legends"
+				return true
+			end
+			unless game.parent.nil?
+				return works_with?(game.parent)
+			end
+		end
+
+		##
+		# Return whether or not the API can get a given statistic for
+		# a given user.
+		public
+		def self.can_get?(stat)
+			if stats_available.include?(stat)
+				return 2
+			else
+				return 0
+			end
+		end
+
+		##
+		# This sampling method uses remote IDs
+		public
+		def self.uses_remote?
+			return true
+		end
+
+		##
+		# When given a summoner name for a user, figure out the summoner ID.
+		public
+		def self.set_remote_name(user, game, summoner_name)
+			Delayed::Job.enqueue(UsernameJob.new(user, game, summoner_name), :queue => RiotApi::api_name)
+		end
+		protected
+		class UsernameJob < Job
+			def initialize(user, game, summoner_name)
+				@user_id = user.id
+				@game_id = game.id
+				# Escape any funny stuff
+				summoner_names = [summoner_name].map{|name|Sampling::RiotApi::standardize(name.gsub(',',''))}
+				# Generate the request
+				super("v1.3/summoner/by-name/%{summonerNames}", { :summonerNames => summoner_names.join(",") })
+			end
+			def handle(data)
+				user = User.find(@user_id)
+				game = Game.find(@game_id)
+				
+				standardized_summoner_name = data.keys.first
+				remote_data = {
+					:id   => data[standardized_summoner_name]["id"],
+					:name => data[standardized_summoner_name]["name"],
+				}
+
+				user.set_remote_username(game, remote_data)
+			end
+		end	
+
+		##
+		# When given data from RemoteUsername#value, give back a readable name to display.
+		# Here, this is the summoner name.
+		public
+		def self.get_remote_name(data)
+			data["name"]
+		end
+
+		####
+
+		public
+		def initialize(match)
+			@match = match
+		end
+
+		##
+		# Fetch all the statistics for a match.
+		public
+		def start
+			@match.teams.each do |team|
+				team.users.each do |user|
+					#For demo purposes, we are hard coding in a league of legends game id.
+					Delayed::Job.enqueue(FetchStatisticsJob.new(user, @match, @match.stats_from(self.class), 10546), :queue => RiotApi::api_name)
+				end
+			end
+		end
+		protected
+		class FetchStatisticsJob < Job
+			def initialize(user, match, stats, last_game_id)
+				@user_id = user.id
+				@match_id = match.id
+				@stats = stats
+				@last_game_id = last_game_id
+
+				# Get the summoner id
+				summoner = user.get_remote_username(match.tournament_stage.tournament.game)
+				# Generate the request
+				super("v1.3/game/by-summoner/%{summonerId}/recent", { :summonerId => summoner["id"] })
+			end
+			def handle(data)
+				user = User.find(@user_id)
+				match = Match.find(@match_id)
+				if @last_game_id.nil?
+					Delayed::Job.enqueue(FetchStatisticsJob.new(user, match, data["games"][0]["gameId"]), :queue => RiotApi::api_name)
+				else
+					if @last_game_id == data["games"][0]["gameId"]
+						sleep(4.minutes)
+						Delayed::Job.enqueue(FetchStatisticsJob.new(user, match, @last_game_id), :queue => RiotApi::api_name)
+					else
+						@stats.each do |stat|
+							Statistic.create(user: user, match: match, name: stat, value: data["games"][0]["stats"][stat])
+						end
+					end
+				end
+			end
+		end
+
+		public
+		def render_user_interaction(user)
+			return ""
+		end
+
+		public
+		def handle_user_interaction(user)
+			# do nothing
+		end
+	end
+end