skinbaron_api_client 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fa0a22e643ff91bf554b575f82934242e59dd3d4861b8bf44bd363e23ee6d07
-  data.tar.gz: 38c437e8f44500428073f310d9917cd34cf5f39fcd2a06850e08bedf8564e5b7
+  metadata.gz: 3a5bc7a27a2b8ed17712e35dc276d278dac29708f10c00083a1efb67c486816c
+  data.tar.gz: 3e0d1e16da1488cdcd09e437e456477c060fb25e2066a49b4a1c273ee8a883ff
 SHA512:
-  metadata.gz: 2520d780ce93dc9f2f2b159feb44d10c06501b958a47e3c5ccefdc5eec7599d5a3fb800fff504768c734af74ba52c89407dd6ea3b155f487278d9c6a01c5c9b0
-  data.tar.gz: 7ebfbf5c2d8a2237ab5ea1b27c24a42faa265be0fbb6025a49b06d09fc04babe4b403e4fbc976fd3fb83bcf2f5c9ca8760f4a24e1f8cf6518e9c71753ff9444e
+  metadata.gz: a11aba6be419470ce1c00bb17e69f810251a5acde612e44fbb6b8fee988d57fb39d3caf9b58ac986915833e2e30981f0b01669142bbdb896d4f2048a4c7c4378
+  data.tar.gz: f16a2ffa2d93823df50af4cacbe0c47fbbe6dae019c6d37fb823403fe94643f1db893ecb12f19393d43b32c69aa2c96c1b1870fb7c0aeee0a5567c76403dfaf0

data/CHANGELOG.md

@@ -2,11 +2,30 @@
 
 ## [Unreleased]
 
+## [0.2.0] - 2024-12-26
+
+- Added support for querying multiple items in one request
+- By setting `pages` to -1, ALL available results are fetched instead of default 50
+- Added search options:
+  - `pages`: Number of pages to fetch
+  - `request_delay`: Delay in seconds between requests (when multiple pages are requested)
+  - `min_price`: Minimum price to filter results by
+  - `max_price`: Maximum price to filter results by
+  - `min_wear`: Minimum wear to filter results by (0.00 to 1.00)
+  - `max_wear`: Maximum wear to filter results by (0.00 to 1.00)
+  - `stattrak`: Boolean to filter results by stattrak (Omit -> all, true -> only StatTrak, false -> only non-StatTrak)
+  - `souvenir`: Boolean to filter results by souvenir (Omit -> all, true -> only Souvenir, false -> only non-Souvenir)
+  - `stackable`: Boolean to filter results by stackable (Omit -> all, true -> only Stackable, false -> only non-Stackable)
+  - `tradelocked`: Boolean to filter results by trade-lock (Omit -> all, true -> only Trade-Locked, false -> only non-Trade-Locked)
+  - `items_per_page`: Number of items per page (Default is 50 which is also the max)
+  - `after_saleid`: ID to start the search after a specific sale
+- Documented debug mode in README
+
+## [0.1.0] - 2024-12-25
+
 - Initial release with basic SkinBaron API functionality:
   - Implemented endpoints:
     - `search`: Get CS2 items from the marketplace
   - Error handling for API responses
   - Request/Response logging
   - Support for CS2 (appid: 730)
-
-## [0.1.0] - 2024-12-22

data/README.md

@@ -16,7 +16,7 @@ Then in your Ruby code:
 require 'skinbaron_api_client'
 
 skinbaron = SkinbaronApiClient::Client.new(api_key: "YOUR_API_KEY")
-results = skinbaron.search(item: "AK-47 | Redline")
+results = skinbaron.search(items: "AK-47 | Redline")
 
 puts results
 ```
@@ -73,13 +73,56 @@ skinbaron = SkinbaronApiClient::Client.new(
 )
 ```
 
-### Search Items
+### Search Items -> `Hash[]`
 
-Search for items on the SkinBaron marketplace:
+Search for items on the SkinBaron marketplace.
+Search will always return an `Array` of listing `Hashes`.
 
 ```ruby
 # Search for a specific item
-response = skinbaron.search(item: "AK-47 | Redline")
+response = skinbaron.search(items: "AK-47 | Redline")
+
+# Search for multiple items
+response = skinbaron.search(items: ["AK-47 | Redline", "M4A4 | Urban DDPAT"])
+```
+
+#### Search Options
+
+All given options are passed to the Skinbaron API as query parameters.
+You can pass any of the following options:
+
+Required:
+
+- `items`: Either a String or an Array of Strings. Only include the weapon name and skin name (e.g. no Factory New, no StatTrak, no Souvenir, etc.)
+
+Optional:
+
+- `pages`: Number of pages to search.
+  - Use -1 to get ALL results of the search. Otherwise, Skinbaron will only return 50 results per page.
+  - This works by making multiple requests to the API and combining the results.
+  - To prevent rate limiting, when multiple pages are requested, a default 3-second delay is enforced between requests
+  - Includes duplicate checking to ensure reliable pagination
+  - Default is 1 page if not specified
+
+- `min_price`: Minimum price of the items.
+- `max_price`: Maximum price of the items.
+- `min_wear`: Minimum wear/float value of the items. (0.00 to 1.00)
+- `max_wear`: Maximum wear/float value of the items. (0.00 to 1.00)
+- `stattrak`: Boolean to filter by StatTrak. (Omit -> all, true -> only StatTrak, false -> only non-StatTrak)
+- `souvenir`: Boolean to filter by Souvenir. (Omit -> all, true -> only Souvenir, false -> only non-Souvenir)
+- `stackable`: Boolean to filter by Stackable. (Omit -> all, true -> only Stackable, false -> only non-Stackable)
+- `tradelocked`: Boolean to filter by Trade-Locked. (Omit -> all, true -> only Trade-Locked, false -> only non-Trade-Locked)
+- `items_per_page`: Number of items per page. (Default is 50 which is also the max. Use only if you want to decrease the number of results per page)
+- `after_saleid`: ID to start the search after a specific sale.
+- `request_delay`: Delay in seconds between requests. (Default is 3 seconds)
+
+Example Requests:
+
+```ruby
+skinbaron.search(items: "AK-47 | Redline", pages: -1)
+skinbaron.search(items: "AWP | Dragon Lore", pages: -1, min_price: 100, max_price: 1000)
+skinbaron.search(items: "P250 | Night", pages: -1, min_wear: 0.00, max_wear: 0.05)
+skinbaron.search(items: "M4A4 | Urban DDPAT", pages: 1, items_per_page: 10) # will only return 10 listings (the 10 newest i believe. not sure tho)
 ```
 
 ### Error Handling
@@ -104,6 +147,14 @@ Logs can be configured during client initialization using:
 - `request_log_path` - Specific file for request logs
 - `error_log_path` - Specific file for error logs
 
+### Debugging
+
+To output requests and responses to the console, set the `debug` option to `true` in the client initialization:
+
+```ruby
+skinbaron = SkinbaronApiClient::Client.new(api_key: "YOUR_API_KEY", debug: true)
+```
+
 ## Requirements
 
 - Ruby >= 3.0.0

data/lib/skinbaron_api_client/client.rb

@@ -31,8 +31,9 @@ module SkinbaronApiClient
       end
     end
 
-    def search(item:)
-      @search_endpoint.call(item: item)
+    def search(items:, **options)
+      items = Array(items)
+      @search_endpoint.call(items: items, **options) || []
     end
 
     private
@@ -46,7 +47,7 @@ module SkinbaronApiClient
     end
 
     def setup_endpoints
-      @search_endpoint = Endpoints::Search.new(self)
+      @search_endpoint = Endpoints::Search.new(self, @config)
     end
 
     def setup_logger

data/lib/skinbaron_api_client/endpoints/search.rb

@@ -1,22 +1,89 @@
 module SkinbaronApiClient
   module Endpoints
     class Search
-      attr_reader :skinbaron_client
+      DEFAULT_REQUEST_DELAY = 3 # seconds
+      attr_reader :skinbaron_client, :config, :last_request_time
+      attr_accessor :request_delay
 
-      def initialize(skinbaron_client)
+      def initialize(skinbaron_client, config)
         @skinbaron_client = skinbaron_client
+        @config = config
+        @last_request_time = nil
       end
 
-      def call(item:)
-        body = @skinbaron_client.config.base_body.merge({ "search_item": item })
-        response = @skinbaron_client.http_client.post(endpoint: "Search", body: body)
+      # if pages is < 1, fetch all pages (one page is max 50 listings by default)
+      def call(items:, **options)
+        base_body = @skinbaron_client.config.base_body
+        body = build_request_body(base_body, items, options)
+        target_pages = options[:pages] || 1
+        fetch_all = target_pages < 1
 
-        return nil unless response[:status].success?
+        listings = []
+        seen_ids = Set.new
+        last_saleid = nil
+        current_page = 0
 
-        JSON.parse(response[:body])
+        loop do
+          enforce_request_delay(delay_seconds: options[:request_delay] || DEFAULT_REQUEST_DELAY)
+          body["after_saleid"] = last_saleid if last_saleid
+
+          puts "REQUEST IS BEING MADE" if @config.debug
+          response = @skinbaron_client.http_client.post(endpoint: "Search", body: body)
+          @last_request_time = Time.now
+
+          response_body = JSON.parse(response[:body])
+          current_page_listings = response_body["sales"]
+
+          break if current_page_listings.empty?
+
+          # if any of the current page listings id is in seen_ids, raise error
+          raise Error, "pagination failed" if current_page_listings.any? { |listing| seen_ids.include?(listing["id"]) }
+
+          current_page_listings.each do |listing|
+            seen_ids.add(listing["id"])
+            listings << listing
+          end
+
+          last_saleid = current_page_listings.last["id"]
+          current_page += 1
+          break if !fetch_all && current_page >= target_pages
+        end
+
+        listings
       rescue JSON::ParserError => e
         logger.error("Failed to parse search response", error: e.message)
-        nil
+        raise e
+      end
+
+      private
+
+      def enforce_request_delay(delay_seconds:)
+        return unless @last_request_time
+
+        elapsed = Time.now - @last_request_time
+        remaining_delay = delay_seconds - elapsed
+
+        return unless remaining_delay.positive?
+
+        sleep(remaining_delay)
+      end
+
+      def build_request_body(base_body, items, options)
+        items_query = items.join(";")
+        base_body.merge({
+                          "search_item" => items_query
+                        }).tap do |body|
+          body["min"] = options[:min_price] if options.key?(:min_price)
+          body["max"] = options[:max_price] if options.key?(:max_price)
+          body["minwear"] = options[:min_wear] if options.key?(:min_wear)
+          body["maxwear"] = options[:max_wear] if options.key?(:max_wear)
+          body["stattrak"] = options[:stattrak] if options.key?(:stattrak)
+          body["souvenir"] = options[:souvenir] if options.key?(:souvenir)
+          body["stackable"] = options[:stackable] if options.key?(:stackable)
+          body["tradelocked"] = options[:tradelocked] if options.key?(:tradelocked)
+          body["items_per_page"] = options[:items_per_page] if options.key?(:items_per_page)
+          body["after_saleid"] = options[:after_saleid] if options.key?(:after_saleid)
+        end
       end
     end
   end

data/lib/skinbaron_api_client/http_client.rb

@@ -35,7 +35,7 @@ module SkinbaronApiClient
                             type: "RESPONSE",
                             url: url,
                             status: http_response.status.to_s,
-                            body: http_response.body.to_s
+                            body: http_response
                           })
 
       {

data/lib/skinbaron_api_client/logger.rb

@@ -49,10 +49,14 @@ module SkinbaronApiClient
         @request_logger.info("\n\n#{"=" * 80}")
         @request_logger.info(JSON.pretty_generate(log_data))
       when "RESPONSE"
+        log_data[:body] = JSON.parse(log_data[:body])
         @request_logger.info("\n#{"-" * 80}")
         @request_logger.info(JSON.pretty_generate(log_data))
         @request_logger.info("#{"=" * 80}\n")
       end
+    rescue JSON::ParserError => e
+      @logger.error("LOGGER: failed to parse search response", error: e.message)
+      @logger.error("LOGGER: Response: #{JSON.pretty_generate(log_data)}")
     end
 
     LEVELS.each do |level|

data/lib/skinbaron_api_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SkinbaronApiClient
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/logs/errors.log

@@ -1,24 +1 @@
-I, [2024-12-25T19:36:09.018283 #74992]  INFO -- : {
-  "timestamp": "2024-12-25 19:36:09 +0100",
-  "level": "error",
-  "message": "Authentication failed",
-  "metadata": {
-    "body": "{\"wrong or unauthenticated request\"}"
-  }
-}
-I, [2024-12-25T19:38:09.427416 #75213]  INFO -- : {
-  "timestamp": "2024-12-25 19:38:09 +0100",
-  "level": "error",
-  "message": "Authentication failed",
-  "metadata": {
-    "body": "{\"wrong or unauthenticated request\"}"
-  }
-}
-I, [2024-12-25T19:40:13.146024 #75656]  INFO -- : {
-  "timestamp": "2024-12-25 19:40:13 +0100",
-  "level": "error",
-  "message": "Authentication failed",
-  "metadata": {
-    "body": "{\"wrong or unauthenticated request\"}"
-  }
-}
+# Logfile created on 2024-12-26 17:10:31 +0100 by logger.rb/v1.6.4