backpack_tf 0.8.4 → 1.0.0.rc1

data/lib/backpack_tf/market_price.rb

@@ -0,0 +1,25 @@
+require 'backpack_tf/market_price/interface'
+require 'backpack_tf/market_price/response'
+
+module BackpackTF
+  # Ruby representations of a JSON response to IGetMarketPrices
+  class MarketPrice
+    include Helpers
+
+    attr_reader :last_updated
+    attr_reader :quantity
+    attr_reader :value
+
+    # @param name [String] The name of the item.
+    # @param attr [Hash] Attributes for the item.
+    # @return [MarketPrice] A new MarketPrice object.
+    def initialize(name, attr)
+      attr = hash_keys_to_sym(attr)
+
+      @name         = name.to_s
+      @last_updated = attr[:last_updated]
+      @quantity     = attr[:quantity]
+      @value        = attr[:value]
+    end
+  end
+end

data/lib/backpack_tf/price/interface.rb

@@ -0,0 +1,19 @@
+module BackpackTF
+  module Price
+    # Access the IGetPrices interface
+    class Interface < BackpackTF::Interface
+      class << self
+        attr_reader :raw, :since
+      end
+
+      @name = :IGetPrices
+      @version = 4
+
+      def self.defaults(options)
+        @raw = options[:raw] || nil
+        @since = options[:since] || nil
+        super(options)
+      end
+    end
+  end
+end

data/lib/backpack_tf/price/item.rb

@@ -0,0 +1,85 @@
+module BackpackTF
+  module Price
+    # This lives inside the `@items` hash of BackpackTF::Price::Response
+    class Item
+      # @return [String] the name of item
+      attr_reader :item_name
+      # @return [Fixnum] an index number as per TF2's Item Schema
+      attr_reader :defindex
+      # @return [Hash<Fixnum, ItemPrice>] pricing information for a given item
+      attr_reader :prices
+
+      def initialize(item_name, attr)
+        @item_name = item_name
+        @defindex  = process_defindex(attr['defindex'])
+        @prices    = generate_prices_hash(attr)
+      end
+
+      private
+
+      def process_defindex(arr)
+        return nil if arr.length == 0
+        return arr[0] if arr.length == 1
+        arr
+      end
+
+      def generate_prices_hash(input_hash)
+        prices = input_hash['prices']
+
+        prices.each_with_object({}) do |(quality_idx), prices_acc|
+          tradables = prices[quality_idx]
+
+          tradables.each_key do |tradability|
+            craftables = tradables[tradability]
+
+            craftables.each_key do |craftability|
+              price_indices = craftables[craftability]
+
+              price_indices.each_key do |price_idx|
+                item_price_data = price_indices[price_idx]
+                key_str = keyname(quality_idx, tradability, craftability, price_idx)
+
+                if price_idx == '0'
+                  build_item_price(prices_acc, key_str, item_price_data)
+                elsif quality_idx == '5'
+                  build_unusual_item_price(prices_acc, key_str, item_price_data, price_idx)
+                else
+                  build_crate_price(prices_acc, key_str, item_price_data, price_idx)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def quality_index_to_name(index)
+        ItemPrice.qualities[index.to_i]
+      end
+
+      def keyname(quality_idx, tradability, craftability, price_idx = '0')
+        quality = quality_index_to_name(quality_idx)
+        key_str = "#{quality}_#{tradability}_#{craftability}"
+        key_str << "_##{price_idx}" unless price_idx == '0'
+        key_str
+      end
+
+      def build_item_price(accumulation, key_str, attr)
+        item_price = ItemPrice.new(key_str, attr)
+        accumulation[key_str] = item_price
+        accumulation
+      end
+
+      def build_unusual_item_price(accumulation, key_str, attr, price_idx)
+        item_price = ItemPrice.new(key_str, attr, price_idx)
+        accumulation[item_price.effect] = item_price
+        accumulation
+      end
+
+      def build_crate_price(accumulation, key_str, attr, price_idx)
+        item_price = ItemPrice.new(key_str, attr, price_idx)
+        accumulation[key_str] = item_price
+        accumulation
+      end
+    end
+  end
+end

data/lib/backpack_tf/price/item_price.rb

@@ -0,0 +1,113 @@
+module BackpackTF
+  module Price
+    # Price for an individual item.
+    #   This lives inside the `@prices` hash of a BackpackTF::Item object.
+    class ItemPrice
+      KEYNAME_DELIMITER = '_'.freeze
+
+      class << self
+        # @return [Array<Symbol>] maps quality integers to quality names
+        #   see: https://wiki.teamfortress.com/wiki/WebAPI/GetSchema#Result_Data
+        attr_reader :qualities
+        # @return [Array<Symbol>] possible values for tradable
+        attr_reader :tradabilities
+        # @return [Array<Symbol>] possible values for craftable
+        attr_reader :craftabilities
+      end
+
+      @qualities = [
+        :Normal,
+        :Genuine,
+        nil,
+        :Vintage,
+        nil,
+        :Unusual,
+        :Unique,
+        :Community,
+        :Valve,
+        :"Self-Made",
+        nil,
+        :Strange,
+        nil,
+        :Haunted,
+        :"Collector's"
+      ]
+      @tradabilities  = [:Tradable, :'Non-Tradable']
+      @craftabilities = [:Craftable, :'Non-Craftable']
+
+      def self.quality_name_to_index(quality)
+        qualities.index(quality.to_sym) unless quality.nil?
+      end
+
+      # @return [String] item quality
+      attr_reader :quality
+      # @return [Symbol] either :Tradable or :'Non-Tradable'
+      attr_reader :tradability
+      # @return [Symbol] either :Craftable or :'Non-Craftable'
+      attr_reader :craftability
+      # @return [NilClass or Fixnum] May signify crate series or unusual effect
+      attr_reader :priceindex
+      # @return [Symbol] The currency of the item's price
+      attr_reader :currency
+      # @return [Float] The value of the item in said currency
+      attr_reader :value
+      # @return [Float] The item's upper value in said currency.
+      #   Only set if the item has a price range
+      attr_reader :value_high
+      # @return [Float] The item's value in the lowest currency w/o rounding.
+      #   If raw is set to 2, this is the lower value if a high value exists.
+      #   Otherwise, this is the average between the high and low value.
+      #   Requires raw to be enabled.
+      attr_reader :value_raw
+      # @return [Float] The item's value in the lowest currency w/o rounding.
+      #   Requires for 'raw' to be enabled & set to 2.
+      attr_reader :value_high_raw
+      # @return [Fixnum] A timestamp of when the price was last updated
+      attr_reader :last_update
+      # @return [Fixnum] A relative difference between the former price & the
+      #   current price. If 0, assume new price.
+      attr_reader :difference
+      # @return [String] Which particle effect, if any
+      attr_reader :effect
+
+      # @param key [Array], describes the quality, tradability & craftability
+      #   of an item. For example: ['Unique', 'Tradable', 'Craftable']
+      #   It is directly related to the path you would take to find
+      #   the price from the `@prices` attribute of that item.
+      # @param attr [Hash], collection of attributes for the price
+      # @param priceindex [nil, Fixnum, Array], not needed unless the item is
+      #   Unusual, a Crate, a Strangifier, a Chemistry set or has dual qualities
+      def initialize(key, attr, priceindex = nil)
+        key = split_key(key)
+
+        @quality        = key[0].to_sym
+        @tradability    = key[1].to_sym
+        @craftability   = key[2].to_sym
+        @currency       = currency_or_nil(attr)
+        @value          = attr['value']
+        @value_high     = attr['value_high']
+        @value_raw      = attr['value_raw']
+        @value_high_raw = attr['value_high_raw']
+        @last_update    = attr['last_update']
+        @difference     = attr['difference']
+        @priceindex     = priceindex
+        @effect         = pick_particle_effect(priceindex)
+      end
+
+      private
+
+      def split_key(key)
+        key.split(KEYNAME_DELIMITER)
+      end
+
+      def currency_or_nil(attr)
+        curr = attr.fetch('currency', nil)
+        curr.to_sym unless curr.nil?
+      end
+
+      def pick_particle_effect(priceindex)
+        ParticleEffect.list[priceindex.to_i]
+      end
+    end
+  end
+end

data/lib/backpack_tf/price/particle_effect.rb

@@ -0,0 +1,27 @@
+module BackpackTF
+  module Price
+    # For ItemPrice objects with attached particle effects
+    class ParticleEffect
+      class << self
+        # @return [Hash] possible particle effects for an item
+        attr_reader :list
+      end
+
+      @key = 'attribute_controlled_attached_particles'
+      @file = './lib/backpack_tf/assets/particle_effects.json'
+
+      def self.read_stored_effects_info
+        file = File.open(@file).read
+        effects = JSON.parse(file)[@key]
+
+        effects.each_with_object({}) do |effect, hash|
+          id = effect['id']
+          name = effect['name']
+          hash[id] = name
+        end
+      end
+
+      @list = read_stored_effects_info
+    end
+  end
+end

data/lib/backpack_tf/price/response.rb

@@ -0,0 +1,38 @@
+module BackpackTF
+  module Price
+    # Process reponses from IGetPrices
+    class Response < BackpackTF::Response
+      @response = nil
+      @items = nil
+
+      def self.raw_usd_value
+        @response['raw_usd_value']
+      end
+
+      def self.usd_currency
+        @response['usd_currency']
+      end
+
+      def self.usd_currency_index
+        @response['usd_currency_index']
+      end
+
+      def self.items
+        @items ||= generate_items
+      end
+
+      def self.generate_items
+        @response['items'].each_with_object({}) do |(name), items|
+          defindex = @response['items'][name]['defindex'][0]
+
+          if defindex.nil? || defindex < 0
+            # ignore this item
+          else
+            items[name] = Item.new(name, @response['items'][name])
+          end
+          items
+        end
+      end
+    end
+  end
+end

data/lib/backpack_tf/price.rb

@@ -1,84 +1,12 @@
-module BackpackTF
-
-  # ruby representations of a JSON response to
-  # `IGetPrices`['response']
-  class Price < Response
-
-    INTERFACE = :IGetPrices
-    @interface = INTERFACE
-    @response = nil
-    @items = nil
-
-    ############################
-    # CLASS METHODS
-    ############################
-
-    def self.response
-      @response = superclass.responses[to_sym]
-    end
-
-    def self.items opt = nil
-      if @items.nil?
-        @items = generate_items
-      else
-        @items
-      end
-    end
-
-    def self.generate_items
-      @response[:items].inject({}) do |items, (name)|
-        defindex = @response[:items][name]['defindex'][0]
-
-        if defindex.nil? || defindex < 0
-          items
-        else
-          items[name] = Item.new(name, @response[:items][name])
-          items
-        end
-      end
-    end
-
-    def self.find_item_by_name item_name, opt = nil
-
-      items if @items.nil?
-
-      if @items[item_name].nil?
-        raise KeyError, "item with the name #{item_name} was not found"
-      else
-        if opt.nil?
-          @items[item_name]
-        elsif @items[item_name].respond_to? opt
-          @items[item_name].public_send(opt)
-        else
-          raise KeyError, "the item, #{item_name} does not have that attribute"
-        end
-      end
-    end
-
-    def self.random_item opt = nil
-
-      items if @items.nil?
-
-      case opt
-      when :prices, :price
-        @items[@items.keys.sample].prices
-      else
-        @items.keys.sample
-      end
-    end
-
-    ############################
-    # INSTANCE METHODS
-    ############################
-
-    def initialize
-      msg = "This class is meant to receive the JSON response from the #{self.class.interface} interface."
-      msg << "It holds a Hash array of prices of items, but not is meant to be instantiated."
-      msg << "See the Item class if you are interested in an item."
-      msg << "However, information on items should be stored in the @items property of #{self.class}."
-      raise RuntimeError, msg
-    end
+require 'backpack_tf/price/interface'
+require 'backpack_tf/price/response'
+require 'backpack_tf/price/item'
+require 'backpack_tf/price/item_price'
+require 'backpack_tf/price/particle_effect'
 
+module BackpackTF
+  # Ruby representations of a JSON response to IGetPrices
+  module Price
+    include Helpers
   end
-
 end

data/lib/backpack_tf/price_history/interface.rb

@@ -0,0 +1,22 @@
+module BackpackTF
+  class PriceHistory
+    # Access the IGetPriceHistory interface
+    class Interface < BackpackTF::Interface
+      class << self
+        attr_reader :item, :quality, :tradable, :craftable, :priceindex
+      end
+
+      @name = :IGetPriceHistory
+      @version = 1
+
+      def self.defaults(options)
+        @item = options[:item] || nil
+        @quality = options[:quality] || nil
+        @tradable = options[:tradable] || nil
+        @craftable = options[:craftable] || nil
+        @priceindex = options[:priceindex] || nil
+        super(options)
+      end
+    end
+  end
+end

data/lib/backpack_tf/price_history/response.rb

@@ -0,0 +1,15 @@
+module BackpackTF
+  class PriceHistory
+    # Process reponses from IGetPriceHistory
+    class Response < BackpackTF::Response
+      @response = nil
+      @history = []
+
+      def self.history
+        @history = @response['history'].map do |attr|
+          BackpackTF::PriceHistory.new(attr)
+        end
+      end
+    end
+  end
+end

data/lib/backpack_tf/price_history.rb

@@ -0,0 +1,25 @@
+require 'backpack_tf/price_history/interface'
+require 'backpack_tf/price_history/response'
+
+module BackpackTF
+  # Ruby representations of a JSON response to IGetPriceHistory
+  class PriceHistory
+    include Helpers
+
+    attr_reader :value
+    attr_reader :value_high
+    attr_reader :currency
+    attr_reader :timestamp
+
+    # @param attr [Hash] Attributes for the price history object
+    # @return [PriceHistory] A new PriceHistory object.
+    def initialize(attr)
+      attr = hash_keys_to_sym(attr)
+
+      @value      = attr[:value]
+      @value_high = attr[:value_high]
+      @currency   = attr[:currency]
+      @timestamp  = attr[:timestamp]
+    end
+  end
+end

data/lib/backpack_tf/response.rb

@@ -1,67 +1,20 @@
 module BackpackTF
+  # Base class for processing a response from a BackpackTF API
   class Response
-
-    ############################
-    # CLASS METHODS
-    ############################
-
-    @responses = {}
-
-    def self.interface; @interface; end
-
-    def self.to_sym
-      self.name.to_sym
-    end
-
-    def self.responses key_val = nil
-      unless key_val.nil?
-        key_val = { key_val => nil } unless key_val.class == Hash
-        key = key_val.keys.first
-        val = key_val.values.first
-
-        if val.nil?
-          @responses[key]
-        elsif key == :reset && val == :confirm
-          @responses = {}
-        else
-          @responses[key] = hash_keys_to_sym(val)
-        end
-
-      end
-
-      @responses
+    class << self
+      attr_accessor :response
     end
 
-    def self.response
+    def self.success
+      @response['success']
     end
 
-    # checks the data type of the keys of a Hash object
-    # if the key is a String, then changes it to a Symbol
-    # otherwise, leaves it as is
-    def self.hash_keys_to_sym hash
-      hash.each_pair.inject({}) do |new_hash, (key, val)|
-        unless key.class == String
-          new_hash[key] = val
-        else
-          new_hash[key.to_sym] = val
-        end
-        new_hash
-      end
+    def self.message
+      @response['message']
     end
 
-    ############################
-    # PRIVATE INSTANCE METHODS
-    ############################
-    private
-    def check_attr_keys attr
-      raise TypeError, 'pass in a Hash object' unless attr.class == Hash 
-
-      unless attr.keys.all? { |k| k.class == String }
-        raise TypeError, 'all keys must be String object'
-      end
-
-      self.class.hash_keys_to_sym(attr)
+    def self.current_time
+      @response['current_time']
     end
-
   end
 end

data/lib/backpack_tf/special_item/interface.rb

@@ -0,0 +1,9 @@
+module BackpackTF
+  class SpecialItem
+    # Access the IGetSpecialItems interface
+    class Interface < BackpackTF::Interface
+      @name = :IGetSpecialItems
+      @version = 1
+    end
+  end
+end

data/lib/backpack_tf/special_item/response.rb

@@ -0,0 +1,16 @@
+module BackpackTF
+  class SpecialItem
+    # Process reponses from IGetSpecialItems
+    class Response < BackpackTF::Response
+      @response = nil
+      @items = {}
+
+      def self.items
+        @items = @response['items'].each_with_object({}) do |item, hash|
+          name = item['name']
+          hash[name] = BackpackTF::SpecialItem.new(name, item)
+        end
+      end
+    end
+  end
+end

data/lib/backpack_tf/special_item.rb

@@ -1,23 +1,10 @@
-module BackpackTF
-  class SpecialItem < Response
-    INTERFACE = :IGetSpecialItems
-    @interface = INTERFACE
-    @response = nil
-    @@items = {}
-
-    def self.response
-      @response = superclass.responses[to_sym]
-    end
+require 'backpack_tf/special_item/interface'
+require 'backpack_tf/special_item/response'
 
-    def self.items
-      return @response if @response.nil?
-      @@items = response[:items].inject({}) do |hash, item|
-        #item = hash_keys_to_sym(item)
-        name = item['name']
-        hash[name] = new(name, item)
-        hash
-      end
-    end
+module BackpackTF
+  # Ruby representations of a JSON response to IGetSpecialItems
+  class SpecialItem
+    include Helpers
 
     attr_reader :name
     attr_reader :item_name
@@ -35,8 +22,11 @@ module BackpackTF
     attr_reader :image_url_large_orig
     attr_reader :appid
 
-    def initialize name, attr
-      attr = check_attr_keys(attr)
+    # @param name [String] Name of the SpecialItem.
+    # @param attr [Hash] Attributes.
+    # @return [SpecialItem] A new SpecialItem object.
+    def initialize(name, attr)
+      attr = hash_keys_to_sym(attr)
 
       @name                 = name
       @item_name            = attr[:item_name]

data/lib/backpack_tf/user/interface.rb

@@ -0,0 +1,18 @@
+module BackpackTF
+  class User
+    # Access the IGetUsers interface
+    class Interface < BackpackTF::Interface
+      class << self
+        attr_reader :steamids
+      end
+
+      @name = :IGetUsers
+      @version = 3
+
+      def self.defaults(options = {})
+        @steamids = options[:steamids] || nil
+        super(options)
+      end
+    end
+  end
+end

data/lib/backpack_tf/user/response.rb

@@ -0,0 +1,16 @@
+module BackpackTF
+  class User
+    # Process reponses from IGetUsers
+    class Response < BackpackTF::Response
+      @response = nil
+      @players = {}
+
+      def self.players
+        hash = response['players'].each_with_object({}) do |(id, attr), h|
+          h[id] = BackpackTF::User.new(attr)
+        end
+        @players = hash
+      end
+    end
+  end
+end