restiny 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b64ce91b4d100a18724e027008c5f22feaea7749e99ed3903f881cdf57dd514e
-  data.tar.gz: 4494857bb6bcc684b92fa8215eebbaad2f1406d4236cb8be4e22f956eb98d8e6
+  metadata.gz: 865963597c492b37f7aedac0bcf200bf7e10cce108c1b14489cd21c2ccad4ece
+  data.tar.gz: fe4a007164b081c203c82082c169aa27e8e9764d5bfc6dfd1efe4fb66c05429e
 SHA512:
-  metadata.gz: af7e65d052b3860b97fee42d8c38430e61aed8ab2e6e0435ff25ab74aa27433aebbf6e5267bd13b800d53559e9a6d99a3cc2e9e08972d1fbb8c5097d10bdc484
-  data.tar.gz: 96d3dff6141def2d34948409525a9d66a80c3c4ed394c922fe44eb20b9026b59486eea93dec3962d94438fcb7ff641821ce091aeeebf3ef1bb9617569856de44
+  metadata.gz: 0ec8eb535c734d258806e3c990d175b7aa9a7706ff3cca36e5dca0d8f6647bc5bd4a0ef1fa97427b9fc83bca46445d70a03632e1fd5479e20f72647a3a252e0d
+  data.tar.gz: 83498d058cef2500cb75f43a0b14abdb8672c4f43a7c1a118c4ff5602c3d6f1bc705acc8df2e132d6bde9a8e342f1d942620747a6aa0e5c59052bae31aa0f6a9

data/lib/restiny/constants.rb

@@ -10,10 +10,17 @@ module Restiny
   end
 
   module ComponentType
-    PROFILES = "Profiles"
-    PROFILE_INVENTORIES = "ProfileInventories"
     CHARACTERS = "Characters"
+    CHARACTER_EQUIPMENT = "CharacterEquipment"
     CHARACTER_INVENTORIES = "CharacterInventories"
+    CHARACTER_LOADOUTS = "CharacterLoadouts"
+    PROFILES = "Profiles"
+    PROFILE_INVENTORIES = "ProfileInventories"
+    ITEM_INSTANCES = "ItemInstances"
+    ITEM_SOCKETS = "ItemSockets"
+    ITEM_COMMON_DATA = "ItemCommonData"
+    ITEM_PLUG_STATES = "ItemPlugStates"
+    ITEM_REUSABLE_PLUGS = "ItemReusablePlugs"
   end
 
   module ItemLocation
@@ -34,8 +41,3 @@ module Restiny
     EXOTIC = 6
   end
 end
-
-COMPONENT_TYPE_PROFILES = "Profiles"
-COMPONENT_TYPE_PROFILE_INVENTORIES = "ProfileInventories"
-COMPONENT_TYPE_CHARACTERS = "Characters"
-COMPONENT_TYPE_CHARACTER_INVENTORIES = "CharacterInventories"

data/lib/restiny/errors.rb

@@ -2,17 +2,21 @@
 
 module Restiny
   class Error < StandardError
-    def initialize(message, details = nil)
-      @details = details
+    def initialize(message, status = nil)
+      @status = status
       super(message)
     end
   end
 
-  class RequestError < Error; end
+  class RequestError < Error
+  end
 
-  class InvalidParamsError < RequestError; end
+  class InvalidParamsError < RequestError
+  end
 
-  class RateLimitedError < RequestError; end
+  class RateLimitedError < RequestError
+  end
 
-  class ResponseError < Error; end
+  class ResponseError < Error
+  end
 end

data/lib/restiny/manifest.rb

@@ -6,75 +6,84 @@ require "zip"
 
 module Restiny
   class Manifest
-    TABLES = {
-      Achievement: {item: "achievement", items: "achievements"},
-      Activity: {item: "activity", items: "activities"},
-      ActivityGraph: {item: "activity_graph", items: "activity_graphs"},
-      ActivityMode: {item: "activity_mode", items: "activity_modes"},
-      ActivityModifier: {item: "activity_modifier", items: "activity_modifiers"},
-      ActivityType: {item: "activity_type", items: "activity_types"},
-      Artifact: {item: "artifact", items: "artifacts"},
-      Bond: {item: "bond", items: "bonds"},
-      BreakerType: {item: "breaker_type", items: "breaker_types"},
-      Checklist: {item: "checklist", items: "checklists"},
-      Class: {item: "guardian_class", items: "guardian_classes"},
-      Collectible: {item: "collectible", items: "collectibles"},
-      DamageType: {item: "damage_type", items: "damage_types"},
-      Destination: {item: "destination", items: "destinations"},
-      EnergyType: {item: "energy_type", items: "energy_types"},
-      EquipmentSlot: {item: "equipment_slot", items: "equipment_slots"},
-      EventCard: {item: "event_card", items: "event_cards"},
-      Faction: {item: "faction", items: "factions"},
-      Gender: {item: "gender", items: "genders"},
-      HistoricalStats: {item: "historical_stat", items: "historical_stats"},
-      InventoryBucket: {item: "inventory_bucket", items: "inventory_buckets"},
-      InventoryItem: {item: "inventory_item", items: "inventory_items"},
-      ItemCategory: {item: "item_category", items: "item_categories"},
-      ItemTierType: {item: "item_tier_type", items: "item_tier_types"},
-      Location: {item: "location", items: "locations"},
-      Lore: {item: "lore", items: "lore_entries"},
-      MaterialRequirementSet: {item: "material_requirement_set", items: "material_requirement_sets"},
-      MedalTier: {item: "medal_tier", items: "medal_tiers"},
-      Metric: {item: "metric", items: "metrics"},
-      Milestone: {item: "milestone", items: "milestones"},
-      Objective: {item: "objective", items: "objectives"},
-      Place: {item: "place", items: "places"},
-      PlugSet: {item: "plug_set", items: "plug_sets"},
-      PowerCap: {item: "power_cap", items: "power_caps"},
-      PresentationNode: {item: "presentation_node", items: "presentation_nodes"},
-      Progression: {item: "progression", items: "progression_data"},
-      ProgressionLevelRequirement: {item: "progression_level_requirement", items: "progression_level_requirements"},
-      Race: {item: "race", items: "races"},
-      Record: {item: "record", items: "records"},
-      ReportReasonCategory: {item: "report_reason_category", items: "report_reason_categories"},
-      RewardSource: {item: "reward_source", items: "reward_sources"},
-      SackRewardItemList: {item: "sack_reward_item_list", items: "sack_reward_item_lists"},
-      SandboxPattern: {item: "sandbox_pattern", items: "sandbox_patterns"},
-      SandboxPerk: {item: "sandbox_perk", items: "sandbox_perks"},
-      Season: {item: "season", items: "seasons"},
-      SeasonPass: {item: "season_pass", items: "season_passes"},
-      SocketCategory: {item: "socket_category", items: "socket_categories"},
-      SocketType: {item: "socket_type", items: "socket_types"},
-      Stat: {item: "stat", items: "stats"},
-      StatGroup: {item: "stat_group", items: "stat_groups"},
-      TalentGrid: {item: "talent_grid", items: "talent_grids"},
-      Trait: {item: "trait", items: "traits"},
-      Unlock: {item: "unlock", items: "unlocks"},
-      Vendor: {item: "vendor", items: "vendors"},
-      VendorGroup: {item: "vendor_group", items: "vendor_groups"}
+    ENTITIES = {
+      Achievement: %w[achievement achievements],
+      Activity: %w[activity activities],
+      ActivityGraph: %w[activity_graph activity_graphs],
+      ActivityMode: %w[activity_mode activity_modes],
+      ActivityModifier: %w[activity_modifier activity_modifiers],
+      ActivityType: %w[activity_type activity_types],
+      Artifact: %w[artifact artifacts],
+      Bond: %w[bonds bonds],
+      BreakerType: %w[breaker_type breaker_types],
+      Checklist: %w[checklist checklists],
+      Class: %w[guardian_class guardian_classes],
+      Collectible: %w[collectible collectibles],
+      DamageType: %w[damage_type damage_types],
+      Destination: %w[destination destinations],
+      EnergyType: %w[energy_type energy_types],
+      EquipmentSlot: %w[equipment_slot equipment_slots],
+      EventCard: %w[event_card event_cards],
+      Faction: %w[faction factions],
+      Gender: %w[guardian_gender guardian_genders],
+      GuardianRank: %w[guardian_rank guardian_ranks],
+      GuardianRankConstants: %w[guardian_rank_constant guardian_rank_constants],
+      HistoricalStats: %w[historical_stat historical_stats],
+      InventoryBucket: %w[inventory_bucket inventory_buckets],
+      InventoryItem: %w[inventory_item inventory_items],
+      ItemCategory: %w[item_category item_categories],
+      ItemTierType: %w[item_tier_type item_tier_types],
+      LoadoutColor: %w[loadout_color loadout_colors],
+      LoadoutConstants: %w[loadout_constant loadout_constants],
+      LoadoutIcon: %w[loadout_icon loadout_icons],
+      LoadoutName: %w[loadout_name loadout_names],
+      Location: %w[location locations],
+      Lore: %w[lore_entry lore_entries],
+      MaterialRequirementSet: %w[material_requirement_set material_requirement_sets],
+      MedalTier: %w[medal_tier medal_tiers],
+      Metric: %w[metric metrics],
+      Milestone: %w[milestone milestones],
+      Objective: %w[objective objectives],
+      Place: %w[place places],
+      PlugSet: %w[plug_set plug_sets],
+      PowerCap: %w[power_cap power_caps],
+      PresentationNode: %w[presentation_node presentation_nodes],
+      Progression: %w[progression progressions],
+      ProgressionLevelRequirement: %w[progression_level_requirement progression_level_requirements],
+      Race: %w[guardian_race guardian_races],
+      Record: %w[record records],
+      ReportReasonCategory: %w[report_reason_category report_reason_categories],
+      RewardSource: %w[reward_source reward_sources],
+      SackRewardItemList: %w[sack_reward_item_list sack_reward_item_lists],
+      SandboxPattern: %w[sandbox_pattern sandbox_patterns],
+      SandboxPerk: %w[sandbox_perk sandbox_perks],
+      Season: %w[season seasons],
+      SeasonPass: %w[season_pass season_passes],
+      SocialCommendation: %w[commendation commendations],
+      SocialCommendationNode: %w[commendation_node commendation_nodes],
+      SocketCategory: %w[socket_category socket_categories],
+      SocketType: %w[socket_type socket_types],
+      Stat: %w[stat stats],
+      StatGroup: %w[stat_group stat_groups],
+      TalentGrid: %w[talent_grid talent_grids],
+      Trait: %w[trait traits],
+      Unlock: %w[unlock unlocks],
+      Vendor: %w[vendor vendors],
+      VendorGroup: %w[vendor_group vendor_groups]
     }
 
     attr_reader :file_path
 
-    TABLES.each do |table_name, method_names|
-      full_table_name = "Destiny#{table_name}Definition"
+    ENTITIES.each do |entity, method_names|
+      full_table_name = "Destiny#{entity}Definition"
+      single_method_name, plural_method_name = method_names
 
-      define_method method_names[:item] do |hash|
-        fetch_item(full_table_name, hash)
+      define_method single_method_name do |id|
+        fetch_item(full_table_name, id)
       end
 
-      define_method method_names[:items] do |options = {}|
-        fetch_items(full_table_name, options)
+      define_method plural_method_name do |limit = nil|
+        fetch_items(full_table_name, limit)
       end
     end
 
@@ -102,9 +111,14 @@ module Restiny
 
     private
 
-    def fetch_item(table_name, hash)
+    def get_entity_names
+      query = "SELECT name from sqlite_schema WHERE name LIKE 'Destiny%'"
+      @database.execute(query).map { |row| row["name"].gsub(/(Destiny|Definition)/, "") }
+    end
+
+    def fetch_item(table_name, id)
       query = "SELECT json FROM #{table_name} WHERE json_extract(json, '$.hash')=?"
-      result = @database.execute(query, hash)
+      result = @database.execute(query, id)
 
       return nil if result.nil? || result.count < 1 || !result[0].include?("json")
 
@@ -113,33 +127,28 @@ module Restiny
       raise Restiny::RequestError.new("Error while fetching item (#{e})")
     end
 
-    def fetch_items(table_name, options = {})
+    def fetch_items(table_name, limit = nil)
       bindings = []
 
-      query = "SELECT json FROM #{table_name} "
-      query << "WHERE json_extract(json, '$.displayProperties.name') != '' " if options[:filter_empty]
-      query << "ORDER BY json_extract(json, '$.index')"
+      query = "SELECT json FROM #{table_name} ORDER BY json_extract(json, '$.index')"
 
-      if options[:limit]
+      if limit
         query << " LIMIT ?"
-        bindings << options[:limit]
+        bindings << limit
       end
 
-      result = []
+      items = []
 
       @database.execute(query, bindings) do |row|
         item = JSON.parse(row["json"])
+        yield item if block_given?
 
-        if block_given?
-          yield item
-        else
-          result << item
-        end
+        items << item
       end
 
-      result unless block_given?
+      items unless block_given?
     rescue SQLite3::Exception => e
-      raise Restiny::RequestError.new("Error while fetching item (#{e})")
+      raise Restiny::RequestError.new("Error while fetching items (#{e})")
     end
   end
 end

data/lib/restiny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Restiny
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/restiny.rb

@@ -26,12 +26,7 @@ module Restiny
 
     @oauth_state = state || SecureRandom.hex(15)
 
-    params = {
-      response_type: "code",
-      client_id: @oauth_client_id,
-      state: @oauth_state
-    }
-
+    params = { response_type: "code", client_id: @oauth_client_id, state: @oauth_state }
     params[:redirect_url] = redirect_url unless redirect_url.nil?
 
     connection.build_url(BUNGIE_URL + "/en/oauth/authorize", params).to_s
@@ -40,23 +35,23 @@ module Restiny
   def request_access_token(code, redirect_url = nil)
     check_oauth_client_id
 
-    params = {
-      code: code,
-      grant_type: "authorization_code",
-      client_id: @oauth_client_id
-    }
-
+    params = { code: code, grant_type: "authorization_code", client_id: @oauth_client_id }
     params[:redirect_url] = redirect_url unless redirect_url.nil?
 
-    post("/platform/app/oauth/token/", params, "Content-Type" => "application/x-www-form-urlencoded")
+    make_api_request(
+      :post,
+      "app/oauth/token/",
+      params,
+      "Content-Type" => "application/x-www-form-urlencoded"
+    )
   end
 
   # Manifest methods
 
   def download_manifest(locale = "en")
-    response = get("/platform/Destiny2/Manifest/")
+    response = get("Destiny2/Manifest/")
 
-    manifest_path = response.dig("Response", "mobileWorldContentPaths", locale)
+    manifest_path = response.dig("mobileWorldContentPaths", locale)
     raise Restiny::ResponseError.new("Unable to determine manifest URL") if manifest_path.nil?
 
     Manifest.download(BUNGIE_URL + manifest_path)
@@ -65,92 +60,98 @@ module Restiny
   # Profile methods
 
   def get_profile(membership_id, membership_type, components = [])
-    raise Restiny::InvalidParamsError.new("You must provide at least one component") if components.empty?
-    get("/platform/Destiny2/#{membership_type}/Profile/#{membership_id}?components=#{components.join(",")}")
+    if components.empty?
+      raise Restiny::InvalidParamsError.new("Please provide at least one component")
+    end
+
+    get("Destiny2/#{membership_type}/Profile/#{membership_id}?components=#{components.join(",")}")
   end
 
   # Account methods
 
-  def get_user_by_membership_id(membership_id, membership_type = PLATFORM_ALL)
-    raise Restiny::InvalidParamsError.new("You must provide a valid membership ID") if membership_id.nil?
-    get("/platform/User/GetMembershipsById/#{membership_id}/#{membership_type}/")
+  def get_user_by_membership_id(membership_id, membership_type = Platform::ALL)
+    raise Restiny::InvalidParamsError.new("Please provide a membership ID") if membership_id.nil?
+
+    get("User/GetMembershipsById/#{membership_id}/#{membership_type}/")
   end
 
-  def get_user_by_bungie_name(full_display_name, membership_type = PLATFORM_ALL)
+  def get_user_by_bungie_name(full_display_name, membership_type = Platform::ALL)
     display_name, display_name_code = full_display_name.split("#")
-    raise Restiny::InvalidParamsError.new("You must provide a valid Bungie name") if display_name.nil? || display_name_code.nil?
-
-    params = {
-      displayName: display_name,
-      displayNameCode: display_name_code
-    }
+    if display_name.nil? || display_name_code.nil?
+      raise Restiny::InvalidParamsError.new("You must provide a valid Bungie name")
+    end
 
-    post("/platform/Destiny2/SearchDestinyPlayerByBungieName/#{membership_type}/", params)
+    post(
+      "Destiny2/SearchDestinyPlayerByBungieName/#{membership_type}/",
+      { displayName: display_name, displayNameCode: display_name_code }
+    )
   end
 
   def search_users(name, page = 0)
-    post("/platform/User/Search/GlobalName/#{page}", displayNamePrefix: name)
+    post("User/Search/GlobalName/#{page}", displayNamePrefix: name)
   end
 
   private
 
   def get(endpoint_url, params = {}, headers = {})
-    make_api_request(:get, endpoint_url, params, headers)
+    make_api_request(:get, endpoint_url, params, headers).dig("Response")
   end
 
   def post(endpoint_url, body, headers = {})
-    make_api_request(:post, endpoint_url, body, headers)
+    make_api_request(:post, endpoint_url, body, headers).dig("Response")
   end
 
   def make_api_request(type, url, params, headers = {})
-    raise Restiny::InvalidParamsError.new("You need to set an API key (Restiny.api_key = XXX)") unless @api_key
+    raise Restiny::InvalidParamsError.new("You need to set an API key") unless @api_key
 
     headers[:authorization] = "Bearer #{@oauth_token}" if @oauth_token
 
-    response = case type
-    when :get
-      connection.get(url, params, headers)
-    when :post
-      connection.post(url, params, headers)
-    end
+    response =
+      case type
+      when :get
+        connection.get(url, params, headers)
+      when :post
+        connection.post(url, params, headers)
+      end
 
-    response.body&.dig("Response")
+    response.body
   rescue Faraday::Error => error
-    message = if error.response_body && error.response_headers["content-type"] =~ /application\/json;/i
-      error_response = JSON.parse(error.response_body)
-      "#{error_response["error_description"]} (#{error_response["error"]})"
-    else
-      error.message
+    begin
+      error_body = JSON.parse(error.response_body)
+      status, message = error_body["ErrorStatus"], error_body["Message"]
+    rescue JSON::ParserError
+      status, message = error.response_status, error.message
     end
 
-    case error
-    when Faraday::ClientError
-      raise Restiny::RequestError.new(message, error.response_status)
-    when Faraday::ServerError
-      raise Restiny::ResponseError.new(message, error.response_status)
-    else
-      raise Restiny::Error.new(message)
-    end
+    klass =
+      case error
+      when Faraday::ClientError
+        Restiny::RequestError
+      when Faraday::ServerError
+        Restiny::ResponseError
+      else
+        Restiny::Error
+      end
+
+    raise klass.new(message, status)
   end
 
   def check_oauth_client_id
-    raise Restiny::RequestError.new("You need to set an OAuth client ID (Restiny.oauth_client_id = XXX)") unless @oauth_client_id
+    raise Restiny::RequestError.new("You need to set an OAuth client ID") unless @oauth_client_id
   end
 
   def default_headers
-    {
-      "User-Agent": "restiny v#{Restiny::VERSION}",
-      "X-API-KEY": @api_key
-    }
+    { "User-Agent": "restiny v#{Restiny::VERSION}", "X-API-KEY": @api_key }
   end
 
   def connection
-    @connection ||= Faraday.new(url: API_BASE_URL, headers: default_headers) do |faraday|
-      faraday.request :json
-      faraday.request :url_encoded
-      faraday.response :json
-      faraday.response :follow_redirects
-      faraday.response :raise_error
-    end
+    @connection ||=
+      Faraday.new(url: API_BASE_URL, headers: default_headers) do |faraday|
+        faraday.request :json
+        faraday.request :url_encoded
+        faraday.response :json
+        faraday.response :follow_redirects
+        faraday.response :raise_error
+      end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restiny
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Daniel Bogan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-26 00:00:00.000000000 Z
+date: 2023-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday