restiny 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2ff82944ba14279df69b4c5e8d151a4d0b18c5176273af3ed68142327473993
-  data.tar.gz: a214d550713959f482943f2120d491a91227f46599ab5f5da46e55abed7174be
+  metadata.gz: 9ad23e571d4f6b91fc296e0578074983f8d6883518ffe94743a6003bbf20dfd0
+  data.tar.gz: 6aba22d2cfb3a8bc2f8c93d0a11ccfef63a55eaa8aaec008a3b769710d4b3ff5
 SHA512:
-  metadata.gz: 269e932d167058936ac4ccc092493b72da71026dbf5947467367671e2a64421496f0f9d40b99962eb1f1dc416754734ed241dfaaee53440ea03bee610efdb2d2
-  data.tar.gz: def65d2d7fc397ca3e833a6eec1b922d78639d7c800f763f4e15740a9bde08d8e2e36e5db020dd9654594575c11b1f1c078d3d57f0b9f1eb1bbaf2197e70729a
+  metadata.gz: e600c2e4a0552420404dd6aa11692613e65cd6ee7efddc7a5200f8750569e39f259d5156b25fb8baca7175f7575b870794827213548e74877c7faeea23c18e75
+  data.tar.gz: 2e319308c54b1e793862400bc5ff362d0570924edf372d1f07a1f06766210e031dda2c79b7db8d171588d8dc8b849c482f6bb4d0ca86902e7d739bd6c831a410

data/lib/restiny/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Restiny
+  class Error < StandardError; end
+  class RequestError < Error; end
+    class InvalidParamsError < RequestError; end
+    class RateLimitedError < RequestError
+    end
+
+  class ResponseError < Error; end
+  class NetworkError < Error
+    attr_accessor :status_code
+
+    def initialize(message, status_code = nil)
+      @status_code = status_code
+      super(message)
+    end
+  end
+end

data/lib/restiny/manifest.rb

@@ -1,5 +1,4 @@
 # frozen_string/literal: true
-
 require 'down'
 require 'json'
 require 'sqlite3'
@@ -8,73 +7,91 @@ require 'zip'
 module Restiny
   class Manifest
     TABLES = {
-      'DestinyAchievementDefinition': { item: 'achievement', items: 'achievements' },
-      'DestinyActivityDefinition': { item: 'activity', items: 'activities' },
-      'DestinyActivityGraphDefinition': { item: 'activity_graph', items: 'activity_graphs' },
-      'DestinyActivityModeDefinition': { item: 'activity_modes', items: 'activity_modes' },
-      'DestinyActivityModifierDefinition': { item: 'activity_modifier', items: 'activity_modifiers' },
-      'DestinyActivityTypeDefinition': { item: 'activity_type', items: 'activity_types' },
-      'DestinyArtifactDefinition': { item: 'artifact', items: 'artifacts' },
-      'DestinyBondDefinition': { item: 'bond', items: 'bonds' },
-      'DestinyBreakerTypeDefinition': { item: 'breaker_type', items: 'breaker_types' },
-      'DestinyChecklistDefinition': { item: 'checklist', items: 'checklists' },
-      'DestinyClassDefinition': { item: 'class', items: 'classes' },
-      'DestinyCollectibleDefinition': { item: 'collectible', items: 'collectibles' },
-      'DestinyDamageTypeDefinition': { item: 'damage_type', items: 'damage_types' },
-      'DestinyDestinationDefinition': { item: 'destination', items: 'destinations' },
-      'DestinyEnergyTypeDefinition': { item: 'energy_type', items: 'energy_types' },
-      'DestinyEquipmentSlotDefinition': { item: 'eqiupment_slot', items: 'equipment_slots' },
-      'DestinyEventCardDefinition': { item: 'event_card', items: 'event_cards' },
-      'DestinyFactionDefinition': { item: 'faction', items: 'factions' },
-      'DestinyGenderDefinition': { item: 'gender', items: 'genders' },
-      'DestinyHistoricalStatsDefinition': { item: 'historical_stat', items: 'historical_stats' },
-      'DestinyInventoryBucketDefinition': { item: 'inventory_bucket', items: 'inventory_buckets' },
-      'DestinyInventoryItemDefinition': { item: 'inventory_item', items: 'inventory_items' },
-      'DestinyItemCategoryDefinition': { item: 'item_category', items: 'item_categories' },
-      'DestinyItemTierTypeDefinition': { item: 'item_tier_type', items: 'item_tier_types' },
-      'DestinyLocationDefinition': { item: 'location', items: 'locations' },
-      'DestinyLoreDefinition': { item: 'lore', items: 'lore_entries' },
-      'DestinyMaterialRequirementSetDefinition': { item: 'material_requirement_set', items: 'material_requirement_sets' },
-      'DestinyMedalTierDefinition': { item: 'medal_tier', items: 'medal_tiers' },
-      'DestinyMetricDefinition': { item: 'metric', items: 'metrics' },
-      'DestinyMilestoneDefinition': { item: 'milestone', items: 'milestones' },
-      'DestinyObjectiveDefinition': { item: 'objective', items: 'objectives' },
-      'DestinyPlaceDefinition': { item: 'place', items: 'places' },
-      'DestinyPlugSetDefinition': { item: 'plug_set', items: 'plug_sets' },
-      'DestinyPowerCapDefinition': { item: 'power_cap', items: 'power_caps' },
-      'DestinyPresentationNodeDefinition': { item: 'presentation_node', items: 'presentation_nodes' },
-      'DestinyProgressionDefinition': { item: 'progression', items: 'progression_data' },
-      'DestinyProgressionLevelRequirementDefinition': { item: 'progression_level_requirement', items: 'progression_level_requirements' },
-      'DestinyRaceDefinition': { item: 'race', items: 'races' },
-      'DestinyRecordDefinition': { item: 'record', items: 'records' },
-      'DestinyReportReasonCategoryDefinition': { item: 'report_reason_category', items: 'report_reason_categories' },
-      'DestinyRewardSourceDefinition': { item: 'reward_source', items: 'reward_sources' },
-      'DestinySackRewardItemListDefinition': { item: 'sack_reward_item_list', items: 'sack_reward_item_lists' },
-      'DestinySandboxPatternDefinition': { item: 'sandbox_pattern', items: 'sandbox_patterns' },
-      'DestinySandboxPerkDefinition': { item: 'sandbox_perk', items: 'sandbox_perks' },
-      'DestinySeasonDefinition': { item: 'season', items: 'seasons' },
-      'DestinySeasonPassDefinition': { item: 'season_pass', items: 'season_passes' },
-      'DestinySocketCategoryDefinition': { item: 'socket_category', items: 'socket_categories' },
-      'DestinySocketTypeDefinition': { item: 'socket_type', items: 'socket_types' },
-      'DestinyStatDefinition': { item: 'stat', items: 'stats' },
-      'DestinyStatGroupDefinition': { item: 'stat_group', items: 'stat_groups' },
-      'DestinyTalentGridDefinition': { item: 'talent_grid', items: 'talent_grids' },
-      'DestinyTraitCategoryDefinition': { item: 'trait_category', items: 'trait_categories' },
-      'DestinyTraitDefinition': { item: 'trait', items: 'traits' },
-      'DestinyUnlockDefinition': { item: 'unlock', items: 'unlocks' },
-      'DestinyVendorDefinition': { item: 'vendor', items: 'vendors' },
-      'DestinyVendorGroupDefinition': { item: 'vendor_group', items: 'vendor_groups' }
+      'Achievement': { item: 'achievement', items: 'achievements' },
+      'Activity': { item: 'activity', items: 'activities' },
+      'ActivityGraph': { item: 'activity_graph', items: 'activity_graphs' },
+      'ActivityMode': { item: 'activity_modes', 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: 'class', items: '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' },
+      'TraitCategory': { item: 'trait_category', items: 'trait_categories' },
+      'Trait': { item: 'trait', items: 'traits' },
+      'Unlock': { item: 'unlock', items: 'unlocks' },
+      'Vendor': { item: 'vendor', items: 'vendors' },
+      'VendorGroup': { item: 'vendor_group', items: 'vendor_groups' }
     }
 
     attr_reader :file_path
 
     TABLES.each do |table_name, method_names|
-      define_method method_names[:item] do |id|
-        query_table(table_name, id: id)[0]
+      full_table_name = "Destiny#{table_name}Definition"
+
+      define_method method_names[:item] do |hash|
+        query = "SELECT json FROM #{full_table_name} WHERE json_extract(json, '$.hash')=?"
+
+        result = perform_query(query, [hash])
+        result = JSON.parse(result[0]['json']) unless result.nil?
       end
 
-      define_method method_names[:items] do |limit: nil|
-        query_table(table_name, limit: limit)
+      define_method method_names[:items] do |limit: nil, filter_empty: false, &block|
+        query = "SELECT json_extract(json, '$.hash') AS hash, json_extract(json, '$.displayProperties.name') AS name 
+                 FROM #{full_table_name} "
+
+        query << "WHERE json_extract(json, '$.displayProperties.name') IS NOT NULL " if filter_empty
+        query << "ORDER BY json_extract(json, '$.index')"
+
+        bindings = []
+
+        if limit
+          query << " LIMIT ?"
+          bindings << limit
+        end
+
+        perform_query(query, bindings)
       end
     end
 
@@ -85,14 +102,16 @@ module Restiny
       Zip::File.open(zipped_file) { |file| file.first.extract(manifest_path) }
 
       self.new(manifest_path)
-    rescue Down::Error
-      raise "Unable to download the manifest from Bungie"
-    rescue Zip::Error
-      raise "Unable to unzip the manifest file"
+    rescue Down::ResponseError => error
+      raise Restiny::NetworkError.new("Unable to download the manifest file", error.response.code)
+    rescue Zip::Error => error
+      raise Restiny::Error.new("Unable to unzip the manifest file (#{e})")
     end
 
     def initialize(file_path)
-      raise "You must provide the file path for the manifest file" if file_path.empty?
+      if file_path.empty? || !File.exist?(file_path) || !File.file?(file_path)
+        raise Restiny::InvalidParamsError.new("You must provide a valid path for the manifest file")
+      end
 
       @database = SQLite3::Database.new(file_path, results_as_hash: true)
       @file_path = file_path
@@ -100,40 +119,10 @@ module Restiny
 
     private
 
-    def self.clean_row_keys(row_hash)
-      OpenStruct.new.tap do |output|
-        row_hash.each_pair do |key, value|
-          key = key.gsub(/(\B[A-Z])/, '_\1') if key =~ /\B[A-Z]/
-          output[key.downcase] = if value.is_a?(Hash)
-                                   clean_row_keys(value)
-                                 else
-                                   value
-                                 end
-        end
-      end
-    end
-
-    def query_table(table_name, id: nil, limit: nil)
-      query = "SELECT json FROM #{table_name}"
-      bindings = []
-
-      if id
-        query << " WHERE id=?"
-        bindings << id
-      end
-
-      query << " ORDER BY json_extract(json, '$.index')" unless id
-
-      if limit
-        query << " LIMIT ?"
-        bindings << limit
-      end
-
-      @database.execute(query, bindings).map do |row|
-        Manifest::clean_row_keys(JSON.parse(row['json'])) unless row['json'].nil?
-      end
+    def perform_query(query, bindings, &block)
+      @database.execute(query, bindings)
     rescue SQLite3::Exception => e
-      raise "Error while querying the manifest (#{e})"
+      raise Restiny::RequestError.new("Error while querying the manifest (#{e})")
     end
   end
 end

data/lib/restiny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Restiny
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

data/lib/restiny.rb

@@ -4,8 +4,216 @@ $LOAD_PATH.unshift(__dir__)
 
 require 'restiny/version'
 require 'restiny/constants'
-require 'restiny/client'
+require 'restiny/errors'
 require 'restiny/manifest'
 require 'restiny/user'
 require 'restiny/membership'
 require 'restiny/character'
+
+require 'faraday'
+require 'faraday/follow_redirects'
+require 'securerandom'
+
+module Restiny
+  extend self
+
+  BUNGIE_URL = "https://www.bungie.net"
+  API_BASE_URL = BUNGIE_URL + "/platform"
+
+  attr_accessor :api_key, :oauth_state, :oauth_client_id, :access_token, :refresh_token, :manifest
+
+  # OAuth methods
+
+  def authorise_url(redirect_url = nil, state = nil)
+    check_oauth_client_id
+
+    @oauth_state = state || SecureRandom.hex(15)
+
+    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
+  end
+
+  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[:redirect_url] = redirect_url unless redirect_url.nil?
+
+    post('/platform/app/oauth/token/', params, "Content-Type" => "application/x-www-form-urlencoded")
+  end
+
+  def request_refresh_token
+  end
+
+  # Manifest methods
+
+  def download_manifest(locale = 'en')
+    response = get("/platform/Destiny2/Manifest/")
+
+    manifest_path = response.dig('Response', 'mobileWorldContentPaths', locale)
+    raise Restiny::ResponseError.new("Unable to determine manifest URL") if manifest_path.nil?
+
+    Manifest.download(BUNGIE_URL + manifest_path)
+  end
+
+  # Profile methods
+
+  def get_profile(membership_id, membership_type, components = [])
+    raise Restiny::InvalidParamsError.new("You must provide at least one component") if components.empty?
+
+    component_query = components.join(",")
+    response = get("/platform/Destiny2/#{membership_type}/Profile/#{membership_id}?components=#{component_query}")
+
+    {}.tap do |output|
+      components.each do |component|
+        case component.downcase
+        when 'characters'
+          output[:characters] = parse_profile_characters_response(response)
+        end
+      end
+    end
+  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?
+
+    response = get("/platform/User/GetMembershipsById/#{membership_id}/#{membership_type}/")
+    results = response.dig('Response')
+
+    return nil if results.nil?
+
+    Restiny::User.new(
+      display_name: results['bungieNetUser']['cachedBungieGlobalDisplayName'],
+      display_name_code: results['bungieNetUser']['cachedBungieGlobalDisplayNameCode'],
+      memberships: results['destinyMemberships']
+    )
+  end
+
+  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
+    }
+
+    response = post("/platform/Destiny2/SearchDestinyPlayerByBungieName/#{membership_type}/", params)
+    result = response.dig('Response')
+
+    return nil if result.nil?
+
+    Restiny::User.new(
+      display_name: result[0]['bungieGlobalDisplayName'],
+      display_name_code: result[0]['bungieGlobalDisplayNameCode'],
+      memberships: result
+    )
+  end
+
+  def search_users(name, page = 0)
+    response = post("/platform/User/Search/GlobalName/#{page}", displayNamePrefix: name)
+    search_results = response.dig('Response', 'searchResults')
+    return [] if search_results.nil?
+
+    search_results.map do |user|
+      Restiny::User.new(
+        display_name: user['bungieGlobalDisplayName'],
+        display_name_code: user['bungieGlobalDisplayNameCode'],
+        memberships: user['destinyMemberships']
+      )
+    end
+  end
+
+  private
+
+  def get(endpoint_url, params = {}, headers = {})
+    make_api_request(:get, endpoint_url, params, headers)
+  end
+
+  def post(endpoint_url, body, headers = {})
+    make_api_request(:post, endpoint_url, body, headers)
+  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
+
+    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.body
+  rescue Faraday::Error => error
+    message = if error.response_body && error.response_headers['content-type'] =~ /application\/json;/i
+      JSON.parse(error.response_body)['Message']
+    else
+      error.message
+    end
+
+    case error
+    when Faraday::ClientError, Faraday::ServerError, Faraday::ConnectionFailed
+      raise Restiny::NetworkError.new(message, error.response_status)
+    else
+    end
+  end
+
+  def parse_profile_characters_response(response)
+    characters = response.dig('Response', 'characters', 'data')
+    return [] if characters.nil?
+
+    result = []
+
+    [].tap do |result|
+      characters.each_value do |character|
+        result << Restiny::Character.new(
+          id: character['characterId'],
+          session_playtime: character['minutesPlayedThisSession'],
+          total_playtime: character['minutesPlayedTotal'],
+          light_level: character['light'],
+          stats: [],
+          emblem: [],
+          progression: character['progression']
+        )
+      end
+    end
+  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
+  end
+
+  def default_headers
+    {
+      '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
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restiny
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Bogan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-19 00:00:00.000000000 Z
+date: 2023-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A gem for interacting with Bungie's Destiny API.
 email:
 - d+restiny@waferbaby.com
@@ -117,8 +131,8 @@ extra_rdoc_files: []
 files:
 - lib/restiny.rb
 - lib/restiny/character.rb
-- lib/restiny/client.rb
 - lib/restiny/constants.rb
+- lib/restiny/errors.rb
 - lib/restiny/manifest.rb
 - lib/restiny/membership.rb
 - lib/restiny/user.rb

data/lib/restiny/client.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-require 'faraday/follow_redirects'
-
-module Restiny
-  class Client
-    BUNGIE_URL = "https://www.bungie.net"
-    API_BASE_URL = BUNGIE_URL + "/Platform"
-
-    attr_accessor :api_key, :manifest
-
-    def initialize(api_key)
-      @api_key = api_key
-    end
-
-    # Manifest methods
-
-    def download_manifest(locale = 'en')
-      response = get("/Destiny2/Manifest/")
-
-      manifest_path = response.body.dig('Response', 'mobileWorldContentPaths', locale)
-      raise "Unable to determine manifest URL" if manifest_path.nil?
-
-      Manifest.download(BUNGIE_URL + manifest_path)
-    end
-
-    # Profile methods
-
-    def get_profile(membership_id, membership_type, components = [])
-      raise "You must provide at least one component" if components.empty?
-
-      component_query = components.join(",")
-      response = get("/Destiny2/#{membership_type}/Profile/#{membership_id}?components=#{component_query}")
-
-      {}.tap do |output|
-        components.each do |component|
-          case component.downcase
-          when 'characters'
-            output[:characters] = parse_profile_characters_response(response)
-          end
-        end
-      end
-    end
-
-    # Account methods
-
-    def get_user_by_bungie_name(full_display_name, membership_type = PLATFORM_ALL)
-      display_name, display_name_code = full_display_name.split('#')
-      raise "You must provide a valid Bungie name" if display_name.nil? || display_name_code.nil?
-
-      params = {
-        displayName: display_name,
-        displayNameCode: display_name_code
-      }
-
-      response = post("/Destiny2/SearchDestinyPlayerByBungieName/#{membership_type}/", params)
-      result = response.body.dig('Response')
-
-      return [] if result.nil?
-
-      Restiny::User.new(
-        display_name: result[0]['bungieGlobalDisplayName'],
-        display_name_code: result[0]['bungieGlobalDisplayNameCode'],
-        memberships: result
-      )
-    end
-
-    def search_users(name, page = 0)
-      params = { displayNamePrefix: name }
-      response = post("/User/Search/GlobalName/#{page}", params).body
-      return [] if response.nil?
-
-      search_results = response.dig('Response', 'searchResults')
-      return [] if search_results.nil?
-
-      search_results.map do |user|
-        Restiny::User.new(
-          display_name: user['bungieGlobalDisplayName'],
-          display_name_code: user['bungieGlobalDisplayNameCode'],
-          memberships: user['destinyMemberships']
-        )
-      end
-    end
-
-    def get(endpoint_url, params = {})
-      connection.get(API_BASE_URL + endpoint_url, params)
-    end
-
-    def post(endpoint_url, body, headers = {})
-      connection.post(API_BASE_URL + endpoint_url, body, headers) 
-    end
-
-    private
-
-    def parse_profile_characters_response(response)
-      characters = response.body.dig('Response', 'characters', 'data')
-      return [] if characters.nil?
-
-      result = []
-
-      [].tap do |result|
-        characters.each_value do |character|
-          result << Restiny::Character.new(
-            id: character['characterId'],
-            session_playtime: character['minutesPlayedThisSession'],
-            total_playtime: character['minutesPlayedTotal'],
-            light_level: character['light'],
-            stats: [],
-            emblem: [],
-            progression: character['progression']
-          )
-        end
-      end
-    end
-
-    def default_headers
-      {
-        'User-Agent': "restiny v#{Restiny::VERSION}",
-        'X-API-KEY': @api_key
-      }
-    end
-
-    def connection
-      @connection ||= Faraday.new(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
-end