rockauto_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eff8195831ca08f029eb1128c3fbdc9a8bc5c6441a41d3eba61b2279add15d46
+  data.tar.gz: e961fb95855b0e0d7433ae5c9122ae3a755763e4a5ad99ce22bc0966759ebd9b
+SHA512:
+  metadata.gz: e5b8f220ea632303e38d8a34a9ef4bddc5481b2d2c618bc73de1bd286af05cfe8e6ad0fddf621c311cb175b38735a1bb7f04ba0edb3a192a015dbc574622a8d4
+  data.tar.gz: '078556f85c37110c00410c72602a46757c6e8d0fb344f74f1f3d8c14d3e5f0ad6a6870715d6ced9e3c060fe56d6dae593d41460b921aec8e3e64e8362d36ac2c'

data/lib/rockauto_api/cache.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RockautoApi
+  class Cache
+    def initialize(store: nil)
+      @store = store
+      @memory = {}
+    end
+
+    def fetch(key, ttl: 3600)
+      if @store
+        @store.fetch(key, expires_in: ttl) { yield }
+      else
+        @memory[key] ||= yield
+      end
+    end
+
+    def delete(key)
+      if @store
+        @store.delete(key)
+      else
+        @memory.delete(key)
+      end
+    end
+
+    def clear
+      if @store
+        @store.clear
+      else
+        @memory.clear
+      end
+    end
+  end
+end

data/lib/rockauto_api/client.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RockautoApi
+  class Client
+    CATALOG_API_URL = "https://www.rockauto.com/catalog/catalogapi.php"
+    PARTSEARCH_URL = "https://www.rockauto.com/en/partsearch/"
+    ORDERSTATUS_URL = "https://www.rockauto.com/orderstatus/"
+    BASE_URL = "https://www.rockauto.com"
+
+    MOBILE_HEADERS = {
+      "User-Agent" => "Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1",
+      "Accept" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "Accept-Language" => "en-US,en;q=0.9",
+      "Sec-Fetch-Site" => "same-origin",
+      "Sec-Fetch-Mode" => "navigate",
+      "Sec-Fetch-Dest" => "document"
+    }.freeze
+
+    DESKTOP_HEADERS = {
+      "User-Agent" => "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36",
+      "Accept" => "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+      "Accept-Language" => "en-US,en;q=0.9",
+      "Sec-Ch-Ua" => '"Chromium";v="139", "Not;A=Brand";v="99"',
+      "Sec-Fetch-Site" => "same-origin",
+      "Sec-Fetch-Mode" => "navigate",
+      "Sec-Fetch-Dest" => "document"
+    }.freeze
+
+    INITIAL_COOKIES = {
+      "idlist" => "0",
+      "mkt_US" => "true",
+      "mkt_CA" => "false",
+      "mkt_MX" => "false",
+      "year_2005" => "true",
+      "ck" => "1"
+    }.freeze
+
+    attr_reader :cache, :authenticated
+
+    def initialize(mobile: nil, cache: nil)
+      mobile = RockautoApi.configuration&.default_mobile if mobile.nil?
+      headers = mobile ? MOBILE_HEADERS : DESKTOP_HEADERS
+
+      @conn = Faraday.new(url: BASE_URL) do |f|
+        f.request :url_encoded
+        f.use :cookie_jar
+        f.adapter Faraday.default_adapter
+        f.options.timeout = RockautoApi.configuration&.request_timeout || 30
+        headers.each { |k, v| f.headers[k] = v }
+      end
+
+      set_initial_cookies
+      @cache = cache || RockautoApi.configuration&.cache || RockautoApi::Cache.new
+      @session_initialized = false
+      @nck_token = nil
+      @jnck_token = nil
+      @authenticated = false
+    end
+
+    def set_initial_cookies
+      INITIAL_COOKIES.each do |name, value|
+        @conn.headers["Cookie"] = "#{@conn.headers['Cookie']}; #{name}=#{value}" unless @conn.headers["Cookie"].to_s.include?("#{name}=")
+      end
+    end
+
+    def init_session!
+      return if @session_initialized
+
+      resp = @conn.get("/")
+      @nck_token = Parsers::HtmlHelpers.extract_javascript_variable(resp.body, "_nck")
+      @jnck_token = @nck_token ? CGI.escape(@nck_token) : nil
+      @session_initialized = true
+    end
+
+    def call_catalog_api(function, payload)
+      init_session!
+
+      data = {
+        "func" => function,
+        "payload" => payload.is_a?(String) ? payload : payload.to_json,
+        "api_json_request" => "1",
+        "sctchecked" => "1",
+        "scbeenloaded" => "false",
+        "curCartGroupID" => ""
+      }
+      data["_jnck"] = @jnck_token if @jnck_token
+
+      resp = Faraday.new(url: BASE_URL) do |f|
+        f.request :url_encoded
+        f.use :cookie_jar
+        f.adapter Faraday.default_adapter
+        f.options.timeout = RockautoApi.configuration&.request_timeout || 30
+        f.headers["X-Requested-With"] = "XMLHttpRequest"
+        f.headers["Content-Type"] = "application/x-www-form-urlencoded; charset=UTF-8"
+        f.headers["User-Agent"] = MOBILE_HEADERS["User-Agent"]
+        f.headers["Referer"] = "#{BASE_URL}/"
+        @conn.headers["Cookie"].to_s.split(";").each do |cookie|
+          name, val = cookie.strip.split("=", 2)
+          f.headers["Cookie"] = "#{f.headers['Cookie']}; #{name}=#{val}" if name && val
+        end
+      end.post("catalog/catalogapi.php", data)
+
+      JSON.parse(resp.body)
+    rescue Faraday::Error => e
+      raise NetworkError, "API request failed: #{e.message}"
+    end
+
+    def post_with_csrf(url, form_data)
+      page_resp = @conn.get(url)
+      nck = Parsers::HtmlHelpers.extract_csrf_token(page_resp.body)
+      form_data["_nck"] = nck if nck
+      resp = @conn.post(url, form_data)
+      resp.body
+    end
+
+    def simulate_navigation_context(make: nil, year: nil)
+      return unless make || year
+
+      if make
+        @conn.headers["Referer"] = "#{BASE_URL}/en/catalog/"
+      end
+
+      if year
+        @conn.headers["Cookie"] = "#{@conn.headers['Cookie']}; year_#{year}=true"
+      end
+
+      if make
+        payload = {
+          "jsn" => {
+            "make" => make,
+            "nodetype" => "make",
+            "loaded" => false,
+            "expand_after_load" => true,
+            "fetching" => true,
+            "max_group_index" => 363,
+            "mkt_US" => true,
+            "mkt_CA" => false,
+            "mkt_MX" => false
+          }
+        }
+        call_catalog_api("navnode_fetch", payload)
+      end
+    end
+
+    def get(path)
+      resp = @conn.get(path)
+      resp.body
+    rescue Faraday::Error => e
+      raise NetworkError, "GET #{path} failed: #{e.message}"
+    end
+
+    def post(path, body = nil)
+      resp = @conn.post(path, body)
+      resp.body
+    rescue Faraday::Error => e
+      raise NetworkError, "POST #{path} failed: #{e.message}"
+    end
+
+    include Endpoints::Vehicles
+    include Endpoints::PartCategories
+    include Endpoints::PartSearch
+    include Endpoints::Fitment
+    include Endpoints::Tools
+    include Endpoints::Orders
+    include Endpoints::Account
+  end
+end

data/lib/rockauto_api/configuration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RockautoApi
+  class Configuration
+    attr_accessor :default_mobile, :cache, :request_timeout, :user_agent, :credentials
+
+    def initialize
+      @default_mobile = true
+      @cache = nil
+      @request_timeout = 30
+      @user_agent = nil
+      @credentials = nil
+    end
+
+    def email
+      credentials&.fetch(:email, nil)
+    end
+
+    def password
+      credentials&.fetch(:password, nil)
+    end
+  end
+end

data/lib/rockauto_api/endpoints/account.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module RockautoApi
+  module Endpoints
+    module Account
+      LOGIN_URL = "https://www.rockauto.com/catalog/catalogapi.php"
+      PROFILE_URL = "/en/profile/"
+      ORDER_HISTORY_URL = "/en/orderhistory/"
+
+      def login(email, password)
+        payload = {
+          "jsn" => {
+            "email" => email,
+            "password" => password,
+            "keep_me_logged_in" => false
+          }
+        }
+
+        response = call_catalog_api("login", payload)
+        @authenticated = response["success"] == true || response.dig("response", "success") == true
+        @authenticated
+      rescue NetworkError
+        @authenticated = false
+      end
+
+      def logout
+        response = call_catalog_api("logout", {})
+        @authenticated = false
+        true
+      rescue StandardError
+        @authenticated = false
+        true
+      end
+
+      def authenticated?
+        @authenticated
+      end
+
+      def get_saved_addresses
+        require_authentication!
+        html = get(PROFILE_URL)
+        doc = Nokogiri::HTML(html)
+
+        addresses = doc.css("table tr").map { |row|
+          cells = row.css("td").map { |c| c.text.strip }
+          next nil if cells.size < 5
+
+          Models::SavedAddress.new(
+            name: cells[0],
+            full_name: cells[1],
+            address_line1: cells[2],
+            city: cells[3],
+            state: cells[4],
+            postal_code: cells[5],
+            country: cells[6] || "US",
+            phone: cells[7]
+          )
+        }.compact
+
+        Models::SavedAddressesResult.new(
+          addresses: addresses,
+          count: addresses.size,
+          has_default: addresses.any? { |a| a.name&.downcase&.include?("default") }
+        )
+      end
+
+      def get_saved_vehicles
+        require_authentication!
+        html = get(PROFILE_URL)
+        doc = Nokogiri::HTML(html)
+
+        vehicles = doc.css("a[href*='carcode']").map { |a|
+          href = a["href"]
+          text = a.text.strip
+          match = href&.match(/carcode=(\d+)/)
+
+          parts = text.split(" ")
+          year = parts[0].to_i
+
+          Models::SavedVehicle.new(
+            year: year,
+            make: parts[1] || "",
+            model: parts[2] || "",
+            engine: parts[3..]&.join(" "),
+            carcode: match&.captures&.first,
+            display_name: text,
+            catalog_url: Parsers::HtmlHelpers.make_absolute_url(href)
+          )
+        }.compact
+
+        Models::SavedVehiclesResult.new(
+          vehicles: vehicles,
+          count: vehicles.size
+        )
+      end
+
+      def get_account_activity
+        addresses = get_saved_addresses
+        vehicles = get_saved_vehicles
+
+        Models::AccountActivityResult.new(
+          saved_addresses: addresses,
+          saved_vehicles: vehicles,
+          order_history: nil,
+          has_discount_codes: false,
+          has_store_credit: false,
+          has_alerts: false
+        )
+      end
+
+      def get_order_history(filter_params = {})
+        require_authentication!
+        html = get(ORDER_HISTORY_URL)
+        doc = Nokogiri::HTML(html)
+
+        orders = doc.css("table tr").map { |row|
+          cells = row.css("td").map { |c| c.text.strip }
+          next nil if cells.size < 3
+          next nil if cells[0].match?(/\A\s*(?:Order|Date|Status)\s*\z/i)
+
+          Models::OrderHistoryItem.new(
+            order_number: cells[0] || "",
+            date: cells[1],
+            status: cells[2],
+            total: cells[3],
+            vehicle: cells[4],
+            order_url: nil
+          )
+        }.compact
+
+        Models::OrderHistoryResult.new(
+          orders: orders,
+          count: orders.size,
+          filter_applied: filter_params.empty? ? nil : filter_params.to_s,
+          search_time: Time.now.iso8601
+        )
+      end
+
+      def add_external_order(email_or_phone, order_number)
+        require_authentication!
+        form_data = {
+          "email" => email_or_phone.include?("@") ? email_or_phone : "",
+          "phone" => email_or_phone.include?("@") ? "" : email_or_phone,
+          "order_number" => order_number
+        }
+        post_with_csrf("/en/orderhistory/addorder/", form_data)
+        true
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def require_authentication!
+        raise AuthenticationError, "Not authenticated. Call login(email, password) first." unless @authenticated
+      end
+    end
+  end
+end

data/lib/rockauto_api/endpoints/fitment.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RockautoApi
+  module Endpoints
+    module Fitment
+      def get_fitment_for_part(listing_data)
+        return default_result("", "") unless listing_data.is_a?(Hash) && !listing_data.empty?
+
+        car_data = listing_data["car"] || listing_data[:car] || {}
+        supp_data = listing_data["supplemental"] || listing_data[:supplemental] || {}
+
+        part_number = supp_data["partnumber"] || supp_data[:partnumber] || ""
+        brand = supp_data["catalogname"] || supp_data[:catalogname] || ""
+
+        cache_key = "rockauto:fitment:#{part_number}:#{brand}"
+
+        cache.fetch(cache_key, ttl: 604800) do
+          payload = {
+            "partData" => {
+              "groupindex" => listing_data["groupindex"] || listing_data[:groupindex] || "0",
+              "listing_data_essential" => {
+                "groupindex" => listing_data["groupindex"] || listing_data[:groupindex] || "0",
+                "carcode" => car_data["carcode"] || car_data[:carcode] || 0,
+                "parttype" => car_data["parttype"] || car_data[:parttype] || "",
+                "partkey" => car_data["partkey"] || car_data[:partkey] || ""
+              },
+              "listing_data_supplemental" => {
+                "partnumber" => part_number,
+                "catalogname" => brand,
+                "belongstolisting" => "2",
+                "sortgroup" => 0,
+                "sortgrouptext" => "",
+                "paramdesc" => "",
+                "showhide" => {}
+              },
+              "OptKey" => listing_data["optkey"] || listing_data[:optkey] || ""
+            }
+          }
+
+          response = call_catalog_api("getbuyersguide", payload)
+          html = response.dig("buyersguidepieces", "body")
+
+          Parsers::FitmentParser.parse(html, part_number: part_number, brand: brand)
+        end
+      rescue NetworkError, ParseError
+        default_result(part_number, brand)
+      end
+
+      private
+
+      def default_result(part_number, brand)
+        Models::BuyersGuideResult.new(
+          part_number: part_number,
+          brand: brand,
+          fitments: [],
+          count: 0
+        )
+      end
+    end
+  end
+end

data/lib/rockauto_api/endpoints/orders.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RockautoApi
+  module Endpoints
+    module Orders
+      def lookup_order_status(email_or_phone, order_number)
+        form_data = {
+          "email" => email_or_phone.include?("@") ? email_or_phone : "",
+          "phone" => email_or_phone.include?("@") ? "" : email_or_phone,
+          "order_number" => order_number
+        }
+
+        html = post_with_csrf("/orderstatus/", form_data)
+        parsed = Parsers::OrderParser.parse(html)
+
+        if parsed[:order_number]
+          Models::OrderStatusResult.new(
+            success: true,
+            order: Models::OrderStatus.new(**parsed),
+            error: nil
+          )
+        else
+          Models::OrderStatusResult.new(
+            success: false,
+            order: nil,
+            error: Models::OrderStatusError.new(
+              error_type: "not_found",
+              message: "Order not found",
+              order_number: order_number,
+              suggestions: ["Check the order number", "Try searching by email instead"]
+            )
+          )
+        end
+      end
+
+      def request_order_list(method, contact)
+        case method.to_s
+        when "email"
+          post_with_csrf("/orderstatus/", { "send_email" => "1", "email" => contact })
+        when "sms"
+          post_with_csrf("/orderstatus/", { "send_sms" => "1", "phone" => contact })
+        else
+          false
+        end
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/rockauto_api/endpoints/part_categories.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RockautoApi
+  module Endpoints
+    module PartCategories
+      def get_part_categories(make, year, model, carcode)
+        payload = {
+          "jsn" => {
+            "make" => make,
+            "year" => year.to_s,
+            "model" => model,
+            "carcode" => carcode,
+            "nodetype" => "model",
+            "loaded" => false,
+            "expand_after_load" => true,
+            "fetching" => true,
+            "max_group_index" => 0,
+            "mkt_US" => true,
+            "mkt_CA" => false,
+            "mkt_MX" => false
+          }
+        }
+
+        response = call_catalog_api("navnode_fetch", payload)
+        html = response.dig("html_fill_sections", "navchildren[]") || ""
+
+        categories = parse_categories_from_html(html)
+
+        Models::VehiclePartCategories.new(
+          make: make,
+          year: year,
+          model: model,
+          carcode: carcode,
+          categories: categories,
+          count: categories.size
+        )
+      end
+
+      def get_parts_by_category(make, year, model, carcode, category_group_name)
+        categories_result = get_part_categories(make, year, model, carcode)
+        category = categories_result.categories.find { |c| c.group_name == category_group_name }
+
+        return Models::VehiclePartsResult.new(
+          make: make, year: year, model: model, carcode: carcode,
+          category: category_group_name, parts: [], count: 0
+        ) unless category&.href
+
+        html = get(category.href)
+        doc = Nokogiri::HTML(html)
+        parts = parse_parts_from_table(doc)
+
+        Models::VehiclePartsResult.new(
+          make: make, year: year, model: model, carcode: carcode,
+          category: category_group_name, parts: parts, count: parts.size
+        )
+      end
+
+      private
+
+      def parse_categories_from_html(html)
+        doc = Nokogiri::HTML(html)
+        doc.css("a").map { |a|
+          text = a.text.strip
+          href = a["href"]
+          next nil if text.empty? || href.nil?
+          Models::PartCategory.new(
+            name: text,
+            group_name: text,
+            href: Parsers::HtmlHelpers.make_absolute_url(href)
+          )
+        }.compact
+      end
+
+      def parse_parts_from_table(doc)
+        doc.css("table tr").map { |row|
+          cells = row.css("td")
+          next nil if cells.size < 3
+          Parsers::PartExtractor.extract_from_row(row)
+        }.compact
+      end
+    end
+  end
+end