blizzard_api_rb_rb 3.4.2

data/lib/blizzard_api_rb/request.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+##
+# @!macro [new] init_options
+#   @param [Hash] options
+#   @option options [String] :region API Region
+#   @option options [Symbol] :mode API Mode
+
+##
+# @!macro [new] request_options
+#   @param {Hash} options You can specify some options
+#   @option options [String] :locale Overrides the default locale for a single call
+#   @option options [String] :namespace Overrides the default namespace for a single call
+#   @option options [String] :access_token Overrides the access_token for a single call
+#   @option options [Boolean] :ignore_cache If set to true the request will not use the cache
+#   @option options [Integer] :ttl Override the default time (in seconds) a request should be cached
+#   @option options [DateTime] :since Adds the If-modified-since headers. Will always ignore cache when set.
+
+##
+# @!macro [new] response
+#   @return [Hash] API Response. The actual type of the returned object depends on the *format* option
+#   in the configuration module
+
+module BlizzardApi
+  ##
+  # Simplifies the requests to Blizzard APIS
+  class Request
+    include ApiStandards
+
+    # One hour cache
+    CACHE_HOUR = 3600
+    # One day cache
+    CACHE_DAY = 24 * CACHE_HOUR
+    # Three (commercial) months cache
+    CACHE_TRIMESTER = CACHE_DAY * 90
+
+    ##
+    # @!attribute region
+    #   @return [String] Api region
+    attr_accessor :region
+
+    ##
+    # @!attribute mode
+    #   @return [:regular, :extended]
+    attr_accessor :mode
+
+    ##
+    # @!macro init_options
+    def initialize(**options)
+      self.region = options[:region] || BlizzardApi.region
+      # Use the shared access_token, or create one if it doesn't exists. This avoids unnecessary calls to create tokens.
+      create_access_token if BlizzardApi.access_token_expired?
+
+      # Mode
+      @mode = options[:mode] || BlizzardApi.mode
+    end
+
+    require 'net/http'
+    require 'uri'
+    require 'json'
+    require 'redis'
+
+    protected
+
+    def create_access_token
+      return if BlizzardApi.restore_access_token
+
+      uri = URI.parse("https://#{BlizzardApi.region}.battle.net/oauth/token")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      request = Net::HTTP::Post.new(uri.path)
+      request.basic_auth(BlizzardApi.app_id, BlizzardApi.app_secret)
+      request['Content-Type'] = 'application/x-www-form-urlencoded'
+      request.set_form_data grant_type: 'client_credentials'
+
+      response = http.request(request)
+      BlizzardApi.save_access_token(JSON.parse(response.body))
+    end
+
+    def request(url, **options)
+      # Creates the whole url for request
+      parsed_url = URI.parse(url)
+      data = using_cache?(options) ? find_in_cache(parsed_url.to_s) : nil
+
+      # If data was found that means cache is enabled and valid
+      return prepare_response data if data
+
+      response = consume_api parsed_url, **options
+
+      handle_cache_on_response parsed_url, response, **options
+    end
+
+    def handle_cache_on_response(parsed_url, response, **options)
+      case response.code.to_i
+      when 304
+        response_data = nil
+      when 200
+        response_data = response.body
+      else
+        return nil, response
+      end
+
+      save_in_cache parsed_url.to_s, response.body, options[:ttl] || CACHE_DAY if using_cache? options
+      prepare_response response_data, response
+    end
+
+    def api_request(uri, **query_string)
+      # List of request options
+      options_key = %i[ignore_cache ttl format access_token namespace classic classic1x headers since]
+
+      # Separates request options from api fields and options. Any user-defined option will be treated as api field.
+      options = query_string.select { |k, _v| query_string.delete(k) || true if options_key.include? k }
+
+      # Namespace
+      query_string[:namespace] = endpoint_namespace(options) if options.include? :namespace
+
+      # In case uri already have query string parameters joins them with &
+      if query_string.size.positive?
+        query_string = URI.encode_www_form(query_string)
+        uri = uri.include?('?') ? "#{uri}&#{query_string}" : "#{uri}?#{query_string}"
+      end
+
+      request uri, **options
+    end
+
+    private
+
+    ##
+    # Resolves the response based on the mode
+    def prepare_response(data, response = nil)
+      parsed_data = data.nil? ? data : JSON.parse(data, symbolize_names: true)
+
+      return parsed_data unless mode.eql? :extended
+
+      response ||= ApiResponse.new(data)
+
+      [response, parsed_data]
+    end
+
+    ##
+    # @param options [Hash] Request options
+    def using_cache?(options)
+      return false if options.key?(:since)
+
+      !options.fetch(:ignore_cache, false)
+    end
+
+    def http_connection(url)
+      Net::HTTP.new(url.host, url.port).tap do |http|
+        http.use_ssl = true
+        http.keep_alive_timeout = 30
+      end
+    end
+
+    def consume_api(url, **options)
+      # Creates a HTTP connection and request to ensure thread safety
+      request = Net::HTTP::Get.new(url)
+
+      add_headers request, options
+
+      # Executes the request
+      http_connection(url).request(request).tap do |response|
+        if mode.eql?(:regular) && ![200, 304].include?(response.code.to_i)
+          raise BlizzardApi::ApiException.new "Request failed with code '#{response.code}' details: #{response.to_hash}", response.code.to_i
+        end
+      end
+    end
+
+    def add_headers(request, options)
+      # Blizzard API documentation states the preferred way to send the access_token is using Bearer token on header
+      request['Authorization'] = "Bearer #{options.fetch(:access_token, BlizzardApi.access_token)}"
+      # Format If-modified-since option
+      request['If-Modified-Since'] = options[:since].httpdate if options.key? :since
+      options[:headers]&.each { |header, content| request[header] = content }
+    end
+
+    def save_in_cache(resource_url, data, ttl)
+      BlizzardApi.redis_connection.setex resource_url, ttl, data if BlizzardApi.use_cache
+    end
+
+    def find_in_cache(resource_url)
+      return false unless BlizzardApi.use_cache
+
+      BlizzardApi.redis_connection.get resource_url if BlizzardApi.redis_connection.exists? resource_url
+    end
+  end
+end

data/lib/blizzard_api_rb/starcraft/community/account.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module BlizzardApi
+  module Starcraft
+    ##
+    # This class allows access to Starcraft II league data
+    #
+    # @see https://develop.battle.net/documentation/api-reference/starcraft-2-game-data-api
+    #
+    # You can get an instance of this class using the default region as follows:
+    #   api_instance = BlizzardApi::Starcraft.account
+    class Account < Starcraft::Request
+      ##
+      # Returns information about a player account
+      #
+      # @param [Integer] account_id Account ID
+      # @!macro request_options
+      def player(account_id, **options)
+        api_request "#{base_url(:community)}/player/#{account_id}", **{ ttl: CACHE_DAY }.merge(options)
+      end
+    end
+  end
+end

data/lib/blizzard_api_rb/starcraft/community/ladder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module BlizzardApi
+  module Starcraft
+    ##
+    # This class allows access to Starcraft II ladder data
+    #
+    # @see https://develop.battle.net/documentation/api-reference/starcraft-2-game-data-api
+    #
+    # You can get an instance of this class using the default region as follows:
+    #   api_instance = BlizzardApi::Starcraft.ladder
+    class Ladder < Starcraft::Request
+      ##
+      # Grandmaster endpoint
+      #
+      # @!macro sc2_regions
+      # @!macro request_options
+      def grandmaster(region_id, **options)
+        reg = resolve_region(region_id)
+        api_request "#{base_url(:community)}/ladder/grandmaster/#{reg}", **{ ttl: CACHE_DAY }.merge(options)
+      end
+
+      ##
+      # Season endpoint
+      #
+      # @!macro sc2_regions
+      # @!macro request_options
+      def season(region_id, **options)
+        reg = resolve_region(region_id)
+        api_request "#{base_url(:community)}/ladder/season/#{reg}", **{ ttl: CACHE_DAY }.merge(options)
+      end
+    end
+  end
+end

data/lib/blizzard_api_rb/starcraft/community/legacy.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module BlizzardApi
+  module Starcraft
+    ##
+    # This class allows access to Starcraft II legacy data
+    #
+    # @see https://develop.battle.net/documentation/api-reference/starcraft-2-game-data-api
+    #
+    # You can get an instance of this class using the default region as follows:
+    #   api_instance = BlizzardApi::Starcraft.legacy
+    class Legacy < Starcraft::Request
+      ##
+      # Profile data
+      #
+      # @!macro sc2_regions
+      # @param [Integer] realm_id Realm ID
+      # @param [Integer] profile_id Profile ID
+      # @!macro request_options
+      def profile(region_id, realm_id, profile_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}/legacy/profile/#{reg}/#{realm_id}/#{profile_id}", **opts
+      end
+
+      ##
+      # Ladders
+      #
+      # @!macro sc2_regions
+      # @param [Integer] realm_id Realm ID
+      # @param [Integer] profile_id Profile ID
+      # @!macro request_options
+      def ladders(region_id, realm_id, profile_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}/legacy/profile/#{reg}/#{realm_id}/#{profile_id}/ladder ", **opts
+      end
+
+      ##
+      # Match History
+      #
+      # @!macro sc2_regions
+      # @param [Integer] realm_id Realm ID
+      # @param [Integer] profile_id Profile ID
+      # @!macro request_options
+      def match(region_id, realm_id, profile_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}/legacy/profile/#{reg}/#{realm_id}/#{profile_id}/matches", **opts
+      end
+
+      ##
+      # Ladder
+      #
+      # @!macro sc2_regions
+      # @param [Integer] ladder_id Ladder ID
+      # @!macro request_options
+      def ladder(region_id, ladder_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}/legacy/ladder/#{reg}/#{ladder_id}", **opts
+      end
+
+      ##
+      # Achievement data
+      #
+      # @!macro sc2_regions
+      # @!macro request_options
+      def achievements(region_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}/legacy/data/achievements/#{reg}", **opts
+      end
+
+      ##
+      # Rewards data
+      #
+      # @!macro sc2_regions
+      # @!macro request_options
+      def rewards(region_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}/legacy/data/rewards/#{reg}", **opts
+      end
+    end
+  end
+end

data/lib/blizzard_api_rb/starcraft/community/profile.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module BlizzardApi
+  module Starcraft
+    ##
+    # This class allows access to Starcraft II profile data
+    #
+    # @see https://develop.battle.net/documentation/api-reference/starcraft-2-game-data-api
+    #
+    # You can get an instance of this class using the default region as follows:
+    #   api_instance = BlizzardApi::Starcraft.profile
+    class Profile < Starcraft::Request
+      ##
+      # Static profile data
+      #
+      # @!macro sc2_regions
+      # @!macro request_options
+      def static(region_id, **options)
+        reg = resolve_region(region_id)
+        api_request "#{base_url(:community)}/static/profile/#{reg}", **{ ttl: CACHE_DAY }.merge(options)
+      end
+
+      ##
+      # Metadata
+      #
+      # @!macro sc2_regions
+      # @param [Integer] realm_id Realm ID
+      # @param [Integer] profile_id Profile ID
+      # @!macro request_options
+      def metadata(region_id, realm_id, profile_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}/metadata/profile/#{reg}/#{realm_id}/#{profile_id}", **opts
+      end
+
+      ##
+      # Profile data
+      #
+      # @!macro sc2_regions
+      # @param [Integer] realm_id Realm ID
+      # @param [Integer] profile_id Profile ID
+      # @!macro request_options
+      def profile(region_id, realm_id, profile_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}/profile/#{reg}/#{realm_id}/#{profile_id}", **opts
+      end
+
+      ##
+      # Ladder summary
+      #
+      # @!macro sc2_regions
+      # @param [Integer] realm_id Realm ID
+      # @param [Integer] profile_id Profile ID
+      # @!macro request_options
+      def ladder_summary(region_id, realm_id, profile_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}profile/#{reg}/#{realm_id}/#{profile_id}/ladder/summary ", **opts
+      end
+
+      ##
+      # Ladder data
+      #
+      # @!macro sc2_regions
+      # @param [Integer] realm_id Realm ID
+      # @param [Integer] profile_id Profile ID
+      # @!macro request_options
+      def ladder(region_id, realm_id, profile_id, ladder_id, **options)
+        reg = resolve_region(region_id)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:community)}/profile/#{reg}/#{realm_id}/#{profile_id}/ladder/#{ladder_id}", **opts
+      end
+    end
+  end
+end

data/lib/blizzard_api_rb/starcraft/game_data/league.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module BlizzardApi
+  module Starcraft
+    ##
+    # This class allows access to Starcraft II league data
+    #
+    # @see https://develop.battle.net/documentation/api-reference/starcraft-2-game-data-api
+    #
+    # You can get an instance of this class using the default region as follows:
+    #   api_instance = BlizzardApi::Starcraft.league
+    class League < Starcraft::Request
+      ##
+      # Return information about league
+      #
+      # @param [Integer] season_id Season id
+      # @param [Integer] queue_id Queue id
+      # @param [Integer] team_type Team type
+      # @param [Integer] league_id League id
+      # @!macro request_options
+      def get(season_id, queue_id, team_type, league_id, **options)
+        opts = { ttl: CACHE_DAY }.merge(options)
+        api_request "#{base_url(:game_data)}/league/#{season_id}/#{queue_id}/#{team_type}/#{league_id}", **opts
+      end
+    end
+  end
+end

data/lib/blizzard_api_rb/starcraft/request.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+##
+# @!macro [new] sc2_regions
+#   @param {Symbol} region_id One of the valid Starcraft II regions *:US*, *:EU*, *:KO*, and *:TW*
+#   @note This gem do not support nor will support China endpoints
+
+module BlizzardApi
+  module Starcraft
+    ##
+    # Starcraft requests
+    class Request < BlizzardApi::Request
+      # Possible regions for the SC II API (Except China)
+      SC_REGION = { US: 1, EU: 2, KO: 3, TW: 3 }.freeze
+
+      ##
+      # @!macro init_options
+      def initialize(**options)
+        super(**options)
+        @game = 'sc2'
+      end
+
+      private
+
+      ##
+      # Helper method to find a region_id by its symbol
+      def resolve_region(region_arg)
+        return region_arg if region_arg.is_a? Integer
+
+        return SC_REGION[region_arg] if region_arg.is_a? Symbol
+
+        raise ArgumentError, 'Invalid region, please read the documentation'
+      end
+    end
+  end
+end

data/lib/blizzard_api_rb/starcraft.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+##
+# @!macro [new] init_options
+#   @param options [Hash] Initialization options
+#     @option options [String] :region API region
+#     @option options [Symbol] :model API mode (:regular, :extended)
+
+module BlizzardApi
+  # Starcraft II related classes
+  module Starcraft
+    require_relative 'starcraft/request'
+
+    # Starcraft II data api
+    require_relative 'starcraft/game_data/league'
+
+    ##
+    # @!macro init_options
+    # @return {League}
+    def self.league(**options)
+      BlizzardApi::Starcraft::League.new(**options)
+    end
+
+    # Starcraft community api
+    require_relative 'starcraft/community/profile'
+    require_relative 'starcraft/community/ladder'
+    require_relative 'starcraft/community/account'
+    require_relative 'starcraft/community/legacy'
+
+    ##
+    # @!macro init_options
+    # @return {Profile}
+    def self.profile(**options)
+      BlizzardApi::Starcraft::Profile.new(**options)
+    end
+
+    ##
+    # @!macro init_options
+    # @return {Ladder}
+    def self.ladder(**options)
+      BlizzardApi::Starcraft::Ladder.new(**options)
+    end
+
+    ##
+    # @!macro init_options
+    # @return {Account}
+    def self.account(**options)
+      BlizzardApi::Starcraft::Account.new(**options)
+    end
+
+    ##
+    # @return {Legacy}
+    def self.legacy(**options)
+      BlizzardApi::Starcraft::Legacy.new(**options)
+    end
+  end
+end

data/lib/blizzard_api_rb/token_manager.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BlizzardApi
+  ##
+  # Manages the current token and expiration date
+  module TokenManager
+    REDIS_TOKEN_KEY = 'access_token'
+
+    ##
+    # @!attribute access_token
+    #   Current access token.
+    #   @return [String] access_token
+    attr_accessor :access_token
+
+    ##
+    # @!attribute expires_at
+    #   Current access token expiration date.
+    #   @return [String] expires_at
+    attr_accessor :expires_at
+
+    ##
+    # Returns if the current token has expired
+    #
+    # @return [Boolean]
+    def access_token_expired?
+      return true if access_token.nil?
+
+      expires_at < Time.now
+    end
+
+    def restore_access_token
+      return false unless use_cache && cache_access_token
+
+      return false unless redis_connection.exists? REDIS_TOKEN_KEY
+
+      self.access_token = redis_connection.get REDIS_TOKEN_KEY
+      self.expires_at = Time.now + redis_connection.ttl(REDIS_TOKEN_KEY)
+      true
+    end
+
+    def save_access_token(token_data)
+      ttl = token_data['expires_in'].to_i
+      self.expires_at = Time.now + ttl
+      self.access_token = token_data['access_token']
+
+      redis_connection.setex REDIS_TOKEN_KEY, ttl, access_token if use_cache && cache_access_token
+    end
+  end
+end

data/lib/blizzard_api_rb/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module BlizzardApi
+  # Gem version
+  VERSION = '3.4.2'
+end

data/lib/blizzard_api_rb/wow/game_data/achievement.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module BlizzardApi
+  module Wow
+    ##
+    # This class allows access to World of Warcraft achievements
+    #
+    # @see https://develop.battle.net/documentation/api-reference/world-of-warcraft-game-data-api
+    #
+    # You can get an instance of this class using the default region as follows:
+    #   api_instance = BlizzardApi::Wow.achievement
+    class Achievement < Wow::GenericDataEndpoint
+      setup 'achievement', :static, CACHE_TRIMESTER
+
+      ##
+      # Return a list of possible achievement categories.
+      #
+      # @!macro request_options
+      #
+      # @!macro response
+      def categories(**options)
+        api_request "#{endpoint_uri('category')}/index", **default_options.merge(options)
+      end
+
+      ##
+      # Return a achievement category.
+      #
+      # @!macro request_options
+      #
+      # @!macro response
+      def category(id, **options)
+        api_request "#{endpoint_uri('category')}/#{id}", **default_options.merge(options)
+      end
+
+      ##
+      # Fetch media assets for the specified achievement
+      #
+      # @!macro request_options
+      #
+      # @!macro response
+      def media(id, **options)
+        api_request "#{base_url(:media)}/achievement/#{id}", **default_options.merge(options)
+      end
+    end
+  end
+end

data/lib/blizzard_api_rb/wow/game_data/auction.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module BlizzardApi
+  module Wow
+    ##
+    # This class allows access to World of Warcraft auctions
+    #
+    # @see https://develop.battle.net/documentation/world-of-warcraft/game-data-apis
+    #
+    # You can get an instance of this class using the default region as follows:
+    #   api_instance = BlizzardApi::Wow.auction
+    class Auction < Wow::Request
+      ##
+      # Return all auction houses for the specified connected realm. Classic only.
+      #
+      # @param connected_realm_id [Integer] A valid connected realm id
+      # @!macro request_options
+      #
+      # @!macro response
+      def index(connected_realm_id, **options)
+        opts = { ttl: CACHE_HOUR, namespace: :dynamic }.merge(options)
+        api_request "#{base_url(:game_data)}/connected-realm/#{connected_realm_id}/auctions/index", **opts
+      end
+
+      ##
+      # Return all active auctions for the specified connected realm
+      #
+      # @param connected_realm_id [Integer] A valid connected realm id
+      # @!macro request_options
+      # @option options [Boolean] :classic1x If set to true, this method will call the classic era version
+      #
+      # @!macro response
+      def get(connected_realm_id, auction_house_id = nil, **options)
+        opts = { ttl: CACHE_HOUR, namespace: :dynamic }.merge(options)
+
+        unless auction_house_id.nil?
+          return api_request "#{base_url(:game_data)}/connected-realm/#{connected_realm_id}/auctions/#{auction_house_id}", **opts
+        end
+
+        api_request "#{base_url(:game_data)}/connected-realm/#{connected_realm_id}/auctions", **opts
+      end
+
+      def commodities(**options)
+        opts = { ttl: CACHE_HOUR, namespace: :dynamic }.merge(options)
+
+        api_request "#{base_url(:game_data)}/auctions/commodities", **opts
+      end
+    end
+  end
+end