steam-trade 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d174f053f0d7882ecbb2ec1af0cf9c56e8399d94
-  data.tar.gz: 07d6eefabd7144cc36467186835c7d58d3bff31b
+  metadata.gz: 34bdbd304683a4b23f616f4b8ebfb86f05c6a5f5
+  data.tar.gz: 0af0c76c9407399eaec724220221219bba88382b
 SHA512:
-  metadata.gz: 3337852cc85e4fcf85c65f22b263927c3cb470456b19fbdf285ea7bdb7448c6e6e109e6f7c6de366f603fa53c1bc4118dccfc2879f61b12e185efe1e45c8aa3a
-  data.tar.gz: 3ded4edd8fb64a7c9d097c207670e4744d9e6d913929e1699f7271ec50ac8e6d81fd266f29ab7909063642d40f4f9efa19d64687d69dc3117f8339ec233c6349
+  metadata.gz: c44ba8afd2b5441d8b52b039ef7260473e11a6a23116021073dbd6c260132c8bfe0b856efce97ccc1446bb874c30666c9acd04df9ddba804c7c27b0b790d082f
+  data.tar.gz: f8f65ea446d9a23a221aad67baa992ea0d5805df846ad1ff5920eb972128d7f094d54650637290ad82b6937b2fbf352e70f36494a0534b506ebeeb2a1ba7cb8d

data/README.md

@@ -1,7 +1,8 @@
 # steam-trade
 
-This gem simplifes/allows sending steam trade offers programmatically
+This gem simplifes/allows sending steam trade offers programmatically.
 
+this gem is primarly for trading cards, tho can be used to CS:GO and other games inventories
 ## Installation
 in your commandline :
 
@@ -12,7 +13,7 @@ First you need to require the gem:
 ```ruby
 require 'steam-trade'
 ```
-
+## Logging-in
 then you need to login and optionally set your shared_secret and identity_secret:
 - `shared_secret` is used to generate steam authentication codes so you won't have to write them manually each time you login.
 - `identity_secret` is used to confirm trade offers automatically.
@@ -24,14 +25,42 @@ account = Handler.new('username','password','shared_secret') # share secret is o
 
 
 account.mobile_info('identity_secret')
-#identity_secret is requred
+#identity_secret is required
 
 ```
+## Getting someone's inventory
+#### `normal_get_inventory('steamid','inventoryappid','contextid')`
+- `steamid` is the target's steamid
+- `inventoryappid` is the inventory type you want to load, ex : normal inventory(the one which holds trading cards), it's is 753
+- `contextid` required to make a correct request to steam servers, ex:for normal inventory(the one which holds trading cards), it's is 6
+- if you call `normal_get_inventory()` with no params, it will be default use the current logged-in account `steamid`, `inventoryappid = 753` and `contextid = 6`
+
+```ruby
+require 'steam-trade'
+
+account = Handler.new('username','password','shared_secret')
+account.mobile_info('identity_secret')
+
+my_inventory = normal_get_inventory() #if you are logged in you can call this command with no parameters to get the logged account's inventory
+
+partner_inventory = normal_get_inventory('76561198044170935')
+```
+the returned items from `normal_get_inventory()` are in the form of an array example : `[item1,item2,item3...itemN]`.
+
+each item is a hash which contains information about the item in the form of `{"appid"=>'xxx',"contextid"=>'xxx',"assetid" => 'xxx',"classid"=> 'xxx',......"name"=> 'xxxx',"market_fee_app" => 'xxx',....}`.
+
+`market_fee_app` key gives you the appid of the game's app ( for trading cards), for other items technically `inventoryappid` is the games appid.
+
+`name` key gives you the item name.
+####
 
-then you can send your offer 
+**IMPORTANT**: `normal_get_inventory()` will load the whole target inventory, for each **5k** of items, you are adding **~40MB** to your memory and of course will affect performance of the code and the computer
+## Sending a trade offer
+then you can send your offer
 - `Myarray` is an array which contains hashes of selected items to send in the offer. (currently you must get this alone)
 - `Theirarray` is an array which contains hashes of selected items to receive in the offer. (currently you must get this alone)
 - `trade_offer_link` is the trade link of you partner `ex: https://steamcommunity.com/tradeoffer/new/?partner=410155236&token=H-yK-GFt`
+- `trade_offer_link` can also be a steamID, however using a steamID requires you and your partner to be friends on steam
 - `message` is the comment you want to include in the trade offer
 
 - `Myarray`, `Theirarray`, `trade_offer_link` are required, `message` is optional

data/lib/Badge.rb

@@ -0,0 +1,133 @@
+module BadgeCommands
+
+      def sets_count(steamid = @steamid, use_nonmarketable = true)
+
+
+            if steamid == nil
+                  output "no steamid specified"
+                  return
+            end
+
+            thread = Thread.new(steamid) { |steamid| ##getting name
+                  targetname = ''
+                  begin
+                         data = get_player_summaries(steamid)
+                         data.each { |acc|
+                              if id["steamid"].to_s == steamid.to_s
+                                    targetname = id["personaname"]
+                              end
+                        }
+                  rescue
+                        targetname = ''
+                  end
+            }
+
+            items = normal_get_inventory(steamid)
+            sorted = {}
+            items.each { |asset|
+                  if use_nonmarketable == false
+                        if asset["marketable"] == 0 || asset["tags"][-1]["localized_tag_name"] != "Trading Card" || asset["tags"][-2]["localized_tag_name"] == "Foil"
+                              next
+                        end
+                  else
+                        if  asset["tags"][-1]["localized_tag_name"] != "Trading Card" || asset["tags"][-2]["localized_tag_name"] == "Foil"
+                              next
+                        end
+                  end
+
+                  name = asset["name"].sub(" (Trading Card)", "")
+                  appid = asset["market_fee_app"].to_s
+                  if sorted.has_key?(appid) == true
+                        if sorted[appid].has_key?(name) == true
+                              sorted[appid][name] = sorted[appid][name] + 1
+                        elsif sorted[appid].has_key?(name) == false
+                              sorted[appid][name] = 1
+                        end
+                  elsif sorted.has_key?(appid) == false
+                        sorted[appid] = {}
+                        sorted[appid][name] = 1
+                  end
+            }
+
+            bigdata = JSON.parse(File.read("#{@libdir}/blueprints/byappid.json",:external_encoding => 'utf-8',:internal_encoding => 'utf-8'))
+            counted = {}
+
+            sorted.each { |appid,cards|
+
+
+                  counted[appid] = bigdata[appid].merge(cards)
+            }
+
+            setsowned = {}
+            numberofsets = 0
+            total_non_foil = 0
+
+            counted.each { |appid,cards|
+                  lowest = 9999
+                  cards.each { |cardname, amount|
+                              if amount < lowest then lowest = amount end
+                              total_non_foil =  total_non_foil + amount
+                  }
+                  setsowned[appid] = lowest
+                  numberofsets = numberofsets + lowest
+            }
+
+            persona = thread.value
+            write_badges(counted,setsowned,numberofsets,total_non_foil, use_nonmarketable,persona,steamid)
+            if use_nonmarketable == false
+                  return {'sets' => counted, 'appxsets' => setsowned, 'totalsets' => numberofsets, 'totalcards' => total_non_foil, 'marketable' => false}
+            else
+                   return {'sets' => counted, 'appxsets' => setsowned, 'totalsets' => numberofsets, 'totalcards' => total_non_foil, 'marketable' => true}
+            end
+      end
+
+
+      private
+      def write_badges(hashofcards,eachappidsets,totalsets,total_non_foil,use_nonmarketable,persona,steamid)
+            if persona == ''
+                  filename = steamid
+            else
+                  filename = persona
+            end
+
+            "./#{filename}_badges.txt"
+            titles = JSON.parse(File.read("#{@libdir}/blueprints/appid_title.json",:external_encoding => 'utf-8',:internal_encoding => 'utf-8'))
+            eachappidsets = eachappidsets.sort_by do |k,v|
+              v
+            end
+            eachappidsets.reverse!
+            begin
+                  File.truncate("./#{filename}_badges.txt", 0)
+            rescue
+            end
+
+            File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts "for #{persona}(#{steamid})"}
+            if use_nonmarketable == false
+                  File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts "total non-foil trading cards #{total_non_foil}"}
+                  File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts "only marketable cards are counted"}
+            else
+                  File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts "total non-foil trading cards #{total_non_foil}"}
+                  File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts "all cards counted including non-marketable"}
+            end
+
+
+            File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts "total sets in target account #{totalsets}"}
+            File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts ""}
+            File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts ""}
+
+
+            eachappidsets.each { |appid, sets|
+                  File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts "#{titles[appid]}, sets = #{sets}, appid = #{appid}"}
+                  hashofcards[appid].each { |cardname, owned|
+                        File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts "#{cardname} xxx #{owned}"}
+                  }
+                  File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts ""}
+                  File.open("./#{filename}_badges.txt",'a+:UTF-8') {|f| f.puts ""}
+            }
+
+            output "badges.txt has been created"
+      end
+
+
+
+end

data/lib/Confirmation.rb

@@ -1,8 +1,8 @@
-require 'Guard.rb'
+
 
 
 module ConfirmationCommands
-      include GuardCommands
+
 
 
 
@@ -54,8 +54,7 @@ module ConfirmationCommands
             response = @session.get('https://steamcommunity.com/mobileconf/conf', params, no, headers)
             html = response.content
             if html.include?('Steam Guard Mobile Authenticator is providing incorrect Steam Guard codes.')
-                  puts "invalid steammguard"
-                  exit
+                  raise("identity secret: #{@identity_secret} is incorrect")
             end
             return html
       end
@@ -71,8 +70,7 @@ module ConfirmationCommands
                         return confirmhash
                   end
             }
-            puts "did not find a confirmation"
-            exit
+            raise("Could not find the offer to confirm")
       end
 
       def fetch_confirmation_details_page(hash) ##eigth

data/lib/Guard.rb

@@ -4,13 +4,14 @@ module GuardCommands
 
 
 
-      def fa()
+      def fa(shared_secret = @secret)
+            raise "No shared_secret given" if shared_secret == nil # cause upon initialization @secret = nil
             timestamp = Time.new.to_i
             math = timestamp / 30
             math = math.to_i
             time_buffer =[math].pack('Q>')
 
-            hmac = OpenSSL::HMAC.digest('sha1', Base64.decode64(@secret), time_buffer)
+            hmac = OpenSSL::HMAC.digest('sha1', Base64.decode64(shared_secret), time_buffer)
 
             start = hmac[19].ord & 0xf
             last = start + 4
@@ -29,6 +30,7 @@ module GuardCommands
 
       end
 
+      private
       def generate_confirmation_key(tag_string, time_stamp)
             buffer = [time_stamp].pack('Q>') + tag_string.encode('ascii')
             return Base64.encode64(OpenSSL::HMAC.digest('sha1', Base64.decode64(@identity_secret), buffer))

data/lib/Inventory.rb

@@ -0,0 +1,111 @@
+module InventoryCommands
+
+
+
+
+
+      def normal_get_inventory(steamid = @steamid ,appid = 753,context = 6)
+            if steamid == nil
+                output "no steamid specified"
+                return
+          elsif steamid.to_i == 0 && steamid.include?("?partner=") ##supplied trade link
+                partner_raw = steamid.split('partner=',2)[1].split('&',2)[0]
+                steamid = partner_id_to_steam_id(partner_raw)
+            end
+            
+
+            if @inventory_cache == true
+                  verdict = verify_inventory_cache(steamid)
+                  if verdict != false
+                        return verdict
+                  end
+            end
+
+
+            items = []
+            last_id = 0
+            until last_id == false
+                  received = get_inventory_chunk_normal_way(appid,context,steamid,last_id)
+                  last_id = received['new_last_id']
+                  items = items + received['assets']
+                  output "loaded #{items.length}"
+                  sleep(2) if last_id != false
+            end
+
+            output "total loaded #{items.length} asset"
+            if @inventory_cache == true
+                  File.open("./#{steamid}.inventory", 'w') {|f| f.puts items.to_json}
+            end
+
+            return items
+      end
+
+      private
+      def get_inventory_chunk_normal_way(appid,context,steamid,last_id)
+
+
+                  html = open("https://steamcommunity.com/inventory/#{steamid}/#{appid}/#{context}?start_assetid=#{last_id}&count=5000").read
+
+                  get = JSON.parse(html)
+
+                  if get.keys[3].to_s == "last_assetid"
+
+                          new_last_id = get.values[3].to_s
+
+                  else
+                          new_last_id = false
+
+                  end
+
+                  assets = get["assets"]
+                  descriptions = get["descriptions"]
+
+
+                  descriptions_classids = {} ###sorting descriptions by key value || key is classid of the item's description
+                  descriptions.each {|description|
+                       classidxinstance = description["classid"] + '_' + description["instanceid"] # some items has the same classid but different instane id
+                       descriptions_classids[classidxinstance] = description
+                  }
+
+                  assets.each { |asset| ## merging assets with names
+                       classidxinstane = asset["classid"] + '_' + asset["instanceid"]
+                       asset.replace(asset.merge(descriptions_classids[classidxinstance]))
+                  }
+
+
+                return {'assets' => assets, 'new_last_id' =>new_last_id}
+
+      end
+
+
+
+
+
+      def verify_inventory_cache(steamid)
+            if File.exists?("./#{steamid}.inventory") == false
+                  return false
+            end
+            puts File.mtime("./#{steamid}.inventory").to_s
+            puts Time.now.to_s
+            file_last_time =  Time.parse(File.mtime("./#{steamid}.inventory").to_s)
+            current_time = Time.parse(Time.now.to_s)
+            calcule = current_time - file_last_time
+            puts "difference #{calcule}"
+            if calcule.to_i > @inventory_validity
+                  File.delete("./#{steamid}.inventory")
+                  return false
+            else
+                  output "gonna use cached inventory which is #{calcule} seconds old"
+                  begin
+                        return JSON.parse(File.read("./#{steamid}.inventory",:external_encoding => 'utf-8',:internal_encoding => 'utf-8'))
+                  rescue
+                        File.delete("./#{steamid}.inventory")
+                        return false
+                  end
+            end
+
+      end
+
+
+
+end

data/lib/LoginExecutor.rb

@@ -1,7 +1,7 @@
 module LoginCommands
 
 ########################################################################################
-      def login
+      def login()
             data = pass_stamp()
             encrypted_password = data["password"]
             timestamp = data["timestamp"]
@@ -30,13 +30,11 @@ module LoginCommands
 
                   login = @session.post('https://store.steampowered.com/login/dologin', send )
                   response = JSON::parse(login.body)
-
+                  output "logging-in"
                   if response["success"] == true
                         repeater = true
                   elsif repeater == 3
-                        puts "Could not login"
-                        puts "exiting"
-                       exit
+                        raise "Login failed username: #{@username}, password: #{@password} tried 3 times"
                  else
                        puts "re-trying to login"
                        puts "sleeping for 6 seconds"
@@ -71,7 +69,18 @@ module LoginCommands
 
             cookie = Mechanize::Cookie.new :domain => 'steamcommunity.com', :name =>'sessionid', :value =>steampowered_sessionid, :path => '/'
             @session.cookie_jar << cookie
-            puts "logged-in with steamid: #{@steamid}"
+            @loggedin = true
+            @api_key = Nokogiri::HTML(@session.get("https://steamcommunity.com/dev/apikey").content).css('#bodyContents_ex').css('p').first.text.sub('Key: ','')
+
+            data = get_player_summaries(@steamid)
+            data.each { |element|
+                  if element["steamid"].to_s == @steamid.to_s
+                        @persona = element["personaname"]
+                  end
+            }
+            output "logged in as #{@persona}"
+            output "your steamid is #{@steamid}"
+            output "loaded API_KEY : #{@api_key}"
       end
 ########################################################################################
 

data/lib/Misc.rb

@@ -1,5 +1,17 @@
-module Abilites
+
+module MiscCommands
+
+
+
+
+
       ########################################################################################
+      def set_steamid(steamid)
+            @steamid = steamid
+      end
+
+
+
       def copy_session
             return @session
       end
@@ -37,6 +49,10 @@ module Abilites
 
 
 
+
+
+
+
       private
       def partner_id_to_steam_id(account_id)
             unknown_constant = 17825793 # or 0x1100001 idk wtf is this but ....
@@ -45,6 +61,26 @@ module Abilites
             collect = last_bytes + first_bytes
             return collect.unpack('Q>')[0].to_s
       end
+      def output(message)
+            time = Time.new
+            add = time.strftime("%d-%m-%Y %H:%M:%S")
+            puts "#{time} :: #{message}"
+      end
+
 
 
 end
+
+module Util
+      def self.gem_libdir
+            require_relative 'meta/version.rb'
+            gem_name = 'steam-trade'
+            version = '0.0.5'
+           t = ["#{File.dirname(File.expand_path($0))}/#{Meta::GEM_NAME}.rb",
+                "#{Gem.dir}/gems/#{Meta::GEM_NAME}-#{Meta::VERSION}/lib/#{Meta::GEM_NAME}.rb"]
+               t.each {|i|
+                      return i.gsub("#{Meta::GEM_NAME}.rb", '') if File.readable?(i)
+                }
+               raise "both paths are invalid: #{t}, while getting gemlib directory"
+         end
+end