bungie_sdk 0.1.1

data/lib/bungie_sdk/agent.rb

@@ -0,0 +1,166 @@
+# typed: true
+
+module BungieSdk
+  # Class for authentication token-related exceptions
+  class TokenException < StandardError; end
+
+  # Struct used internally to represent Bungie API Responses.
+  class ApiResponse < T::Struct
+    prop :body, Hash
+    prop :headers, Hash
+    prop :status, Integer
+  end
+
+  # Base class for all BungieSdk resources. Handles creating and running
+  # Typhoeus requests, authentication and auth token management, and
+  # basic methods for building endpoints.
+  class ApiAgent
+    extend T::Sig
+    attr_accessor :data
+
+    BASE_URI  = 'https://www.bungie.net'.freeze
+
+    sig { params(api_data: T.nilable(Hash)).void }
+    def initialize(api_data=nil)
+      @data = api_data
+    end
+
+    # Runs the given `Typhoeus::Request`, checks for expected errors, and
+    # handles refreshing or creating an authentication token for authenticated
+    # requests.
+    sig { params(request: Typhoeus::Request).returns(ApiResponse) }
+    def run(request)
+      retries = 0
+
+      begin
+        request.run if request.response.nil? || retries == 1
+
+        api_response = process_response(request.response)
+        @body        = api_response.body
+        @headers     = api_response.headers
+        @code        = api_response.status
+        if @body['ErrorStatus'] == 'WebAuthRequired'
+          TokenManager.instance.web_auth
+          throw TokenException
+        elsif request.response.options[:return_code] == :couldnt_connect
+          TokenManager.instance.refresh_token
+          throw TokenException
+        end
+
+        api_response
+      rescue TokenException
+        if retries.zero?
+          retries += 1
+
+          options           = request.original_options
+          options[:headers] = auth_headers
+          request           = Typhoeus::Request.new(
+            request.base_url,
+            **options
+          )
+          retry
+        else
+          throw TokenException.new('Invalid OAuth token')
+        end
+      end
+    end
+
+    # Returns a Typhoeus GET request with the given configuration
+    sig do
+      params(path: String, params: T.nilable(Hash), body: T.nilable(Hash))
+        .returns(Typhoeus::Request)
+    end
+    def get(path, params: nil, body: nil)
+      request(:get, path, params: params, body: body)
+    end
+
+    # Returns a Typhoeus PUT request with the given configuration
+    sig do
+      params(path: String, params: T.nilable(Hash), body: T.nilable(Hash))
+        .returns(Typhoeus::Request)
+    end
+    def put(path, params: nil, body: nil)
+      request(:put, path, params: params, body: body)
+    end
+
+    # Returns a Typhoeus POST request with the given configuration
+    sig do
+      params(path: String, params: T.nilable(Hash), body: T.nilable(Hash))
+        .returns(Typhoeus::Request)
+    end
+    def post(path, params: nil, body: nil)
+      request(:post, path, params: params, body: body)
+    end
+
+    # Returns a Typhoeus DELETE request with the given configuration
+    sig do
+      params(path: String, params: T.nilable(Hash), body: T.nilable(Hash))
+        .returns(Typhoeus::Request)
+    end
+    def delete(path, params: nil, body: nil)
+      request(:delete, path, params: params, body: body)
+    end
+
+    # Returns a Typhoeus request with the given configuration
+    sig do
+      params(method: T.any(String, Symbol),
+             path:   String,
+             params: T.nilable(Hash),
+             body:   T.nilable(Hash))
+        .returns(Typhoeus::Request)
+    end
+    def request(method, path, params: nil, body: nil)
+      Typhoeus::Request.new(
+        "#{BASE_URI}#{path}",
+        followlocation: true,
+        method:         method.to_sym,
+        params:         params,
+        body:           body,
+        headers:        auth_headers
+      )
+    end
+
+    private
+    sig { params(response: Typhoeus::Response).returns(ApiResponse) }
+    def process_response(response)
+      response_headers = response.headers.to_h
+      response_code    = response.code
+      response_body    = JSON.parse(response.body)['Response']
+
+      ApiResponse.new(body: response_body, headers: response_headers, status: response_code)
+    end
+
+    sig { params(manifest_type: String, id: T.any(String, Integer)).returns(Typhoeus::Request) }
+    def entity_definition(manifest_type, id)
+      get(manifest_url(manifest_type, id))
+    end
+
+    sig { params(id: T.any(String, Integer)).returns(Typhoeus::Request) }
+    def item_definition(id)
+      entity_definition('DestinyInventoryItemDefinition', id)
+    end
+
+    sig { params(id: T.any(String, Integer)).returns(Typhoeus::Request) }
+    def vendor_definition(id)
+      entity_definition('DestinyVendorDefinition', id)
+    end
+
+    sig { returns(String) }
+    def destiny_url
+      '/Platform/Destiny2'
+    end
+
+    sig { params(manifest_type: String, id: T.any(String, Integer)).returns(String) }
+    def manifest_url(manifest_type, id)
+      "#{destiny_url}/Manifest/#{manifest_type}/#{id}"
+    end
+
+    sig { returns(Hash) }
+    def auth_headers
+      {
+        'Authorization' => "Bearer #{TokenManager.instance.token.token}",
+        'X-API-KEY'     => TokenManager.instance.api_key
+      }
+    end
+  end
+end

data/lib/bungie_sdk/character.rb

@@ -0,0 +1,82 @@
+# typed: true
+
+module BungieSdk::Destiny2
+  # Class representing characters in Destiny 2
+  class Character < ApiAgent
+
+    # Character hash
+    sig { returns String }
+    def id
+      data['characterId']
+    end
+
+    # Destiny2 Membership Type
+    sig { returns Integer }
+    def membership_type
+      data['membershipType']
+    end
+
+    # Destiny2 Membership Id
+    sig { returns String }
+    def membership_id
+      data['membershipId']
+    end
+
+    # Returns `Vendor`s associated with this character.
+    # - `can_purchase`: filters for vendors with purchasable items.
+    # - `enabled`: filters for vendors that are enabled.
+    # - `components`: a list of components to be returned with this API request.
+    # The result of this request is memoized, so a new `Character` object will need to
+    # be created to retrieve new results.
+    sig do
+      params(can_purchase: T::Boolean,
+             enabled:      T::Boolean,
+             components:   T::Array[T.any(Integer, String)])
+        .returns(T::Array[Vendor])
+    end
+    def vendors(can_purchase: true,
+                enabled:      true,
+                components:   [DestinyComponentType.Vendors, DestinyComponentType.VendorSales])
+      return @vendors unless @vendors.nil?
+
+      vendor_data = run(get("#{character_url}/Vendors",
+                            params: { components: components.join(',') })).body
+
+      vendor_ids = [vendor_data['vendors']['data'].keys, vendor_data['sales']['data'].keys]
+        .flatten
+        .uniq
+
+      vendor_hashes = vendor_ids.map do |id|
+        {
+          'vendorData' => vendor_data['vendors']['data'][id],
+          'sales'      => vendor_data['sales']['data'][id]
+        }
+      end.select do |vendor|
+        if vendor['vendorData'].nil?
+          false
+        else
+          vendor['vendorData']['canPurchase'] == can_purchase &&
+            vendor['vendorData']['enabled'] == enabled
+        end
+      end
+
+      hydra    = Typhoeus::Hydra.new
+      response = vendor_hashes.map do |hash|
+        vendor = Vendor.new(hash)
+        hydra.queue vendor.definition_request
+
+        vendor
+      end
+
+      hydra.run
+
+      @vendors = response
+    end
+
+    private
+    sig { returns String }
+    def character_url
+      "#{destiny_url}/#{membership_type}/Profile/#{membership_id}/Character/#{id}"
+    end
+  end
+end

data/lib/bungie_sdk/client.rb

@@ -0,0 +1,72 @@
+# typed: true
+
+module BungieSdk
+  # Base class for the BungieSdk. All workflows should start with a `Client`.
+  #
+  # This class currently expects the user to authenticate with OAuth in order to
+  # access private API endpoints. This will be changed in the future to allow users
+  # to not provide an authentication token if they only wish to access public Bungie
+  # API endpoints. Bungie Applications can be created [here](https://www.bungie.net/en/Application).
+  #
+  # The authentication workflow for this SDK allows for a couple of different options.
+  # First, if you already have a valid `OAuth2::AccessToken` for your Bungie Application,
+  # you can provide that to the `token` parameter on creation of this class and this
+  # application will handle refreshing the token when need be. If you do not already
+  # have an access token, you can provide your Bungie Application's client id and client secret
+  # to their respective arguments in this class's constructor and this application will
+  # handle authentication with those credentials. Optionally, if you would like to save your access
+  # token to your local filesystem, provide a path for that file in the `token_filepath` parameter.
+  # If a filepath is provided in `token_filepath` but no access token is supplied through `token`, then
+  # this application will attempt to read that token from file and use it for authentication. This
+  # is recommended as it will reduce the number of times you need to authenticate this app in your
+  # web browser. If `token_filepath` is supplied, `token` is not, and there is no existing token
+  # stored in the file at `token_filepath`, then this application will require the user to
+  # authenticate through their web browser and then save that information to file.
+  class Client < ApiAgent
+    # Client Constructor.
+    # - `token`: Optional; `OAuth2::Access` token for your Bungie Application
+    # - `token_filepath`: Optional; Path to read/write your Bungie Application's access token.
+    # - `api_key`: Bungie API key for your Bungie Application.
+    # - `client_id`: Bungie client id for your Bungie Application.
+    # - `client_secret`: Bungie client secret for your Bungie Application.
+    # - `redirect_uri`: OAuth2 redirect uri for your Bungie Application. Must match your Bungie
+    # Appliation's redirect uri configuration.
+    sig do
+      params(token:          T.nilable(T.any(OAuth2::AccessToken, String)),
+             token_filepath: T.nilable(String),
+             api_key:        T.nilable(String),
+             client_id:      T.nilable(String),
+             client_secret:  T.nilable(String),
+             redirect_uri:   String)
+        .void
+    end
+    def initialize(token:          nil,
+                   token_filepath: nil,
+                   api_key:        ENV['BUNGIE_API_KEY'],
+                   client_id:      ENV['BUNGIE_CLIENT_ID'],
+                   client_secret:  ENV['BUNGIE_CLIENT_SECRET'],
+                   redirect_uri:   ENV['BUNGIE_REDIRECT_URI'] || 'http://localhost:8080/oauth/callback')
+      super(nil)
+      unless TokenManager.instance.initialized?
+        TokenManager.instance.setup_token(token,
+                                          token_filepath,
+                                          api_key,
+                                          client_id,
+                                          client_secret,
+                                          redirect_uri)
+      end
+    end
+
+    # Returns memberships associated with the current user's Bungie account.
+    sig { returns Hash }
+    def memberships
+      @memberships ||= run(get('/Platform/User/GetMembershipsForCurrentUser')).body
+    end
+
+    # Returns Destiny Memberships associated with the current user's Bungie account.
+    sig { returns T::Array[Destiny2::Membership] }
+    def destiny_memberships
+      memberships['destinyMemberships'].map {|data| Destiny2::Membership.new(data) }
+    end
+  end
+end

data/lib/bungie_sdk/item.rb

@@ -0,0 +1,83 @@
+# typed: true
+
+module BungieSdk::Destiny2
+  # Represents Destiny 2 items
+  class Item < ApiAgent
+    # Returns `Typhoeus::Request` for this item's definition.
+    sig { returns Typhoeus::Request }
+    def definition_request
+      request = item_definition(id)
+      request.on_success do |response|
+        response           = process_response(response)
+        data['definition'] = response.body
+      end
+
+      request
+    end
+
+    # This item's definition.
+    sig { returns Hash }
+    def definition
+      if data['definition'].nil?
+        definition_request.run
+      end
+
+      data['definition']
+    end
+
+    # Item costs.
+    sig { returns T::Array[Hash] }
+    def costs
+      data['costs']
+    end
+
+    # Item hash
+    sig { returns Integer }
+    def id
+      data['itemHash']
+    end
+
+    # Item name
+    sig { returns String }
+    def name
+      definition['displayProperties']['name']
+    end
+
+    # Item type
+    sig { returns String }
+    def type
+      definition['itemTypeDisplayName']
+    end
+
+    # Item type and tier
+    sig { returns String }
+    def type_and_tier
+      definition['itemTypeAndTierDisplayName']
+    end
+
+    # Tests if this item is an instance item.
+    sig { returns T::Boolean }
+    def instance_item?
+      definition['inventory']['isInstanceItem']
+    end
+
+    # This item's sockets.
+    sig { returns T::Array[Hash] }
+    def sockets
+      item_sockets = definition['sockets']
+      item_sockets.nil? ? [] : item_sockets['socketEntries']
+    end
+
+    # A list of the ids for this item's sockets.
+    sig { returns T::Array[String] }
+    def socket_ids
+      return [] if sockets.empty?
+
+      ids = sockets.map do |socket|
+        [socket['singleInitialItemHash'], socket['reusablePlugItems'].map {|s| s['plugItemHash'] }]
+      end
+
+      ids.flatten.uniq.map(&:to_s)
+    end
+  end
+end

data/lib/bungie_sdk/membership.rb

@@ -0,0 +1,30 @@
+# typed: true
+module BungieSdk::Destiny2
+  # Represents a Destiny 2 Membership
+  class Membership < ApiAgent
+    # Membership type
+    sig { returns Integer }
+    def type
+      data['membershipType']
+    end
+
+    # Membership id
+    sig { returns String }
+    def id
+      data['membershipId']
+    end
+
+    # Profile associated with this membership
+    # - `components`: DestinyComponentType to be supplied to this API endpoint.
+    sig { params(components: T::Array[T.any(Integer, String)]).returns(Profile) }
+    def profile(components: [DestinyComponentType.Profiles])
+      Profile.new(run(get(profile_url, params: { components: components.join(',') })).body)
+    end
+
+    private
+    sig { returns String }
+    def profile_url
+      "#{destiny_url}/#{type}/Profile/#{id}"
+    end
+  end
+end

data/lib/bungie_sdk/profile.rb

@@ -0,0 +1,36 @@
+# typed: true
+module BungieSdk::Destiny2
+  # Represents a Destiny2 profile
+  class Profile < ApiAgent
+    # Returns the characters associated with this profile.
+    # - `components`: DestinyComponentType to be supplied to this API endpoint.
+    sig do
+      params(components: T::Array[T.any(Integer, String)])
+        .returns(T::Array[Character])
+    end
+    def characters(components: [DestinyComponentType.Characters])
+      characters = run(get(profile_url, params: { components: components.join(',') })).body
+      characters['characters']['data'].map do |_, character|
+        Character.new(character)
+      end
+    end
+
+    # Profile's membership id
+    sig { returns String }
+    def membership_id
+      data['profile']['data']['userInfo']['membershipId']
+    end
+
+    # Profile's membership type
+    sig { returns Integer }
+    def membership_type
+      data['profile']['data']['userInfo']['membershipType']
+    end
+
+    private
+    sig { returns String }
+    def profile_url
+      "#{destiny_url}/#{membership_type}/Profile/#{membership_id}"
+    end
+  end
+end

data/lib/bungie_sdk/token_manager.rb

@@ -0,0 +1,136 @@
+# typed: true
+require 'singleton'
+
+# OAuth2 token manager singleton class for the BungieSdk
+class BungieSdk::TokenManager
+  extend T::Sig
+  include Singleton
+
+  attr_reader :token, :api_key
+
+  AUTH_URL  = '/en/Oauth/Authorize'.freeze
+  TOKEN_URL = '/Platform/App/Oauth/Token'.freeze
+  BASE_URI  = 'https://www.bungie.net'.freeze
+
+  # Setup method for the token manager. Must be called before any
+  # API requests are made.
+  sig do
+    params(user_token:    T.nilable(T.any(OAuth2::AccessToken, String)),
+           token_path:    T.nilable(String),
+           api_key:       T.nilable(String),
+           client_id:     T.nilable(String),
+           client_secret: T.nilable(String),
+           redirect_uri:  String)
+      .void
+  end
+  def setup_token(user_token,
+                  token_path,
+                  api_key,
+                  client_id,
+                  client_secret,
+                  redirect_uri)
+    @token_path    = token_path
+    @api_key       = api_key
+    @client_id     = client_id
+    @client_secret = client_secret
+    @redirect_uri  = redirect_uri
+
+    if !@token_path.nil?
+      load_token(@token_path)
+    elsif !user_token.nil?
+      @token = user_token
+    else
+      web_auth
+    end
+  end
+
+  # Tests if this manager has been initialized with an OAuth2 token
+  sig { returns T::Boolean }
+  def initialized?
+    !@token.nil?
+  end
+
+  # Loads the OAuth2 access token from file. If that file does not exist,
+  # the token is generated through browser based authentication.
+  # - `filepath`: location of token file
+  sig { params(filepath: String).returns(OAuth2::AccessToken) }
+  def load_token(filepath)
+    if @token.nil?
+      @token = if File.exist?(filepath)
+                 load_token_data
+               else
+                 web_auth
+               end
+    end
+
+    if @token.expired?
+      @token = @token.refresh!
+      save_token_data(@token)
+    end
+
+    @token
+  end
+
+  # Creates an authentication token using the user's web browser.
+  sig { returns OAuth2::AccessToken }
+  def web_auth
+    client   = oauth_client
+    auth_url = client.auth_code.authorize_url(redirect_uri: @redirect_uri)
+    puts auth_url
+    Launchy.open(auth_url) rescue nil
+    puts 'Please go to this url, accept the authorization request, '\
+         'and copy the code parameter from the url into this program:'
+    code       = gets.chomp
+    auth_token = client.auth_code.get_token(code)
+    save_token_data(auth_token)
+
+    @token = auth_token
+  end
+
+  # Refreshes the manager's token.
+  sig { returns OAuth2::AccessToken }
+  def refresh_token
+    @token = @token.refresh!
+  end
+
+  # Loads token data from file
+  sig { returns OAuth2::AccessToken }
+  def load_token_data
+    JSON.parse(File.read(@token_path)).yield_self do |token_data|
+      OAuth2::AccessToken.new(
+        oauth_client,
+        token_data['token'],
+        refresh_token: token_data['refresh_token'],
+        expires_at:    token_data['expires_at']
+      )
+    end
+  end
+
+  # Returns a configured OAuth2 client
+  sig { returns OAuth2::Client }
+  def oauth_client
+    OAuth2::Client.new(
+      @client_id,
+      @client_secret,
+      site:          BASE_URI,
+      authorize_url: AUTH_URL,
+      token_url:     TOKEN_URL
+    )
+  end
+
+  # Writes the given auth token to disk
+  # - `auth_token`: token to be saved.
+  sig { params(auth_token: OAuth2::AccessToken).void }
+  def save_token_data(auth_token)
+    if @token_path
+      File.write(
+        @token_path,
+        JSON.generate({
+          'token'         => auth_token.token,
+          'refresh_token' => auth_token.refresh_token,
+          'expires_at'    => auth_token.expires_at
+        })
+      )
+    end
+  end
+end

data/lib/bungie_sdk/vendor.rb

@@ -0,0 +1,64 @@
+# typed: true
+
+module BungieSdk::Destiny2
+  # Represents vendors in Destiny 2
+  class Vendor < ApiAgent
+    # Vendor id
+    sig { returns Integer }
+    def id
+      data['vendorData']['vendorHash']
+    end
+
+    # Vendor name
+    sig { returns String }
+    def name
+      definition['displayProperties']['name'] rescue ''
+    end
+
+    # Vendor sales
+    sig { returns T::Array[Hash] }
+    def sales
+      data['sales']['saleItems'].values
+    end
+
+    # Request for vendor's definition
+    sig { returns Typhoeus::Request }
+    def definition_request
+      request = vendor_definition(data['vendorData']['vendorHash'])
+      request.on_success do |response|
+        response           = process_response(response)
+        data['definition'] = response.body
+      end
+
+      request
+    end
+
+    # Vendor definition
+    sig { returns Hash }
+    def definition
+      if data['definition'].nil?
+        definition_request.run
+      end
+
+      data['definition']
+    end
+
+    # Vendor items
+    sig { returns T::Array[Item] }
+    def items
+      return @items unless @items.nil?
+
+      hydra        = Typhoeus::Hydra.new
+      vendor_items = sales.map do |sale|
+        item = Item.new(sale)
+        hydra.queue item.definition_request
+
+        item
+      end
+
+      hydra.run
+
+      @items = vendor_items.reject {|item| item.data['definition'].nil? }
+    end
+  end
+end

data/lib/bungie_sdk/version.rb

@@ -0,0 +1,4 @@
+# typed: strict
+module BungieSdk
+  VERSION = '0.1.1'
+end