ebay-trader 0.9.5

data/examples/get_categories.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+#
+# This example downloads the list of categories from eBay and prints out their names.
+#
+# With no arguments this script will display all category names.
+# To get a list of sub-categories provide a parent category ID as the first argument.
+#
+
+require 'ebay_trader'
+require 'ebay_trader/request'
+
+EbayTrader.configure do |config|
+
+  config.ebay_api_version = 935
+  config.environment      = :sandbox
+  config.ebay_site_id     = 0 # ebay.com
+
+  config.auth_token = ENV['EBAY_API_AUTH_TOKEN_TEST_USER_1']
+
+  config.dev_id  = ENV['EBAY_API_DEV_ID_SANDBOX']
+  config.app_id  = ENV['EBAY_API_APP_ID_SANDBOX']
+  config.cert_id = ENV['EBAY_API_CERT_ID_SANDBOX']
+  config.ru_name = ENV['EBAY_API_RU_NAME_01_SANDBOX']
+end
+
+request = EbayTrader::Request.new('GetCategories') do
+  CategorySiteID 0
+  CategoryParent ARGV.first unless ARGV.empty?
+  DetailLevel 'ReturnAll'
+  LevelLimit 5
+  ViewAllNodes true
+end
+request.errors_and_warnings.each { |error| puts error.long_message } if request.has_errors_or_warnings?
+
+if request.success?
+  category_names = request.response_hash[:category_array][:category].map { |c| c[:category_name] }
+  category_names.each { |name| puts name }
+end

data/examples/more_examples.rb

@@ -0,0 +1,5 @@
+#
+# A more comprehensive list of examples and use cases can be found here:
+#
+#   https://github.com/altabyte/ebay_trader_support
+#

data/lib/ebay_trader.rb

@@ -0,0 +1,45 @@
+require 'ebay_trader/version'
+require 'ebay_trader/configuration'
+
+module EbayTrader
+
+  # Generic runtime error for this gem.
+  #
+  class EbayTraderError < RuntimeError; end
+
+  # The error raised when the HTTP connection times out.
+  #
+  # *Note:* A request can timeout and technically still succeed!
+  # Consider the case when a
+  # {http://developer.ebay.com/DevZone/XML/docs/Reference/ebay/AddFixedPriceItem.html AddFixedPriceItem}
+  # call raises a +EbayTraderTimeoutError+. The item could have been successfully
+  # uploaded, but a network issue delayed the response.
+  # Hence, a +EbayTraderTimeoutError+ does not always imply the call failed.
+  #
+  class EbayTraderTimeoutError < EbayTraderError; end
+
+  class << self
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    # Determine if the {https://github.com/RubyMoney/money Money} gem is installed.
+    # @return [Boolean] +true+ if Money gem can be used by this app.
+    #
+    def is_money_gem_installed?
+      begin
+        return true if defined? Money
+        gem 'money'
+        require 'money' unless defined? Money
+        true
+      rescue Gem::LoadError
+        false
+      end
+    end
+  end
+end

data/lib/ebay_trader/configuration.rb

@@ -0,0 +1,242 @@
+require 'digest'
+require 'uri'
+
+module EbayTrader
+  class Configuration
+
+    # URL for eBay's Trading API *Production* environment.
+    # @see https://ebaydts.com/eBayKBDetails?KBid=429
+    URI_PRODUCTION = 'https://api.ebay.com/ws/api.dll'
+
+    # URL for eBay's Trading API *Sandbox* environment.
+    # @see https://ebaydts.com/eBayKBDetails?KBid=429
+    URI_SANDBOX = 'https://api.sandbox.ebay.com/ws/api.dll'
+
+    DEFAULT_AUTH_TOKEN_KEY = '__DEFAULT__'
+
+    # The Dev ID application key.
+    # @return [String] Application keys Developer ID.
+    attr_accessor :dev_id
+
+    # @return [String] Application keys App ID.
+    attr_accessor :app_id
+
+    # @return [String] Application keys Certificate ID.
+    attr_accessor :cert_id
+
+    # @return [URI] Get the URI for eBay API requests, which will be different for
+    # sandbox and production environments.
+    attr_accessor :uri
+
+    # @return [Fixnum] The default eBay site ID to use in API requests, default is 0.
+    # This can be overridden by including an ebay_site_id value in the list of
+    # arguments to {EbayTrader::Request#initialize}.
+    # @see https://developer.ebay.com/DevZone/merchandising/docs/Concepts/SiteIDToGlobalID.html
+    attr_accessor :ebay_site_id
+
+    # @return [Fixnum] the eBay Trading API version.
+    # @see http://developer.ebay.com/DevZone/XML/docs/ReleaseNotes.html
+    attr_accessor :ebay_api_version
+
+    # @return [String] the eBay RuName for the application.
+    # @see http://developer.ebay.com/DevZone/xml/docs/HowTo/Tokens/GettingTokens.html#step1
+    attr_accessor :ru_name
+
+    # @return [Fixnum] the number of seconds before the HTTP session times out.
+    attr_reader :http_timeout
+
+    # Set the type of object to be used to represent price values, with the default being +:big_decimal+.
+    #
+    # * +*:big_decimal*+ expose price values as +BigDecimal+
+    # * +*:money*+ expose price values as {https://github.com/RubyMoney/money Money} objects, but only if the +Money+ gem is available to your app.
+    # * +*:fixnum*+ expose price values as +Fixnum+
+    # * +*:integer*+ expose price values as +Fixnum+
+    # * +*:float*+ expose price values as +Float+ - not recommended!
+    #
+    # @return [Symbol] :big_decimal, :money, :fixnum or :float
+    attr_accessor :price_type
+
+    # @return [Proc] an optional Proc or Lambda to record application level API request call volume.
+    attr_reader :counter_callback
+
+    # Specify if the SSL certificate should be verified, +true+ by default.
+    # It is recommended that all SSL certificates are verified to prevent
+    # man-in-the-middle type attacks.
+    #
+    # One potential reason for temporarily deactivating verification is when
+    # certificates expire, which they periodically do, and you need to take
+    # emergency steps to keep your service running. In such cases you may
+    # see the following error message:
+    #
+    #     SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed
+    #
+    # @return [Boolean|String] +true+, +false+ or the path to {http://curl.haxx.se/ca/cacert.pem PEM certificate} file.
+    #
+    # @see http://www.rubyinside.com/how-to-cure-nethttps-risky-default-https-behavior-4010.html
+    # @see http://www.rubyinside.com/nethttp-cheat-sheet-2940.html
+    #
+    attr_accessor :ssl_verify
+
+    def initialize
+      self.environment = :sandbox
+      @dev_id = nil
+      @environment = :sandbox
+
+      @dev_id  = nil
+      @app_id  = nil
+      @cert_id = nil
+
+      @ebay_site_id = 0
+      @ebay_api_version = 935   # 2015-Jul-24
+      @http_timeout = 30        # seconds
+
+      @price_type = :big_decimal
+
+      @username_auth_tokens = {}
+
+      @ssl_verify = true
+    end
+
+    # Set the eBay environment to either *:sandbox* or *:production*.
+    # If the value of +env+ is not recognized :sandbox will be assumed.
+    #
+    # @param [Symbol] env :sandbox or :production
+    # @return [Symbol] :sandbox or :production
+    #
+    def environment=(env)
+      @environment = (env.to_s.downcase.strip == 'production') ? :production : :sandbox
+      @uri = URI.parse(production? ? URI_PRODUCTION : URI_SANDBOX)
+      @environment
+    end
+
+    # Determine if this app is targeting eBay's production environment.
+    # @return [Boolean] +true+ if production mode, otherwise +false+.
+    #
+    def production?
+      @environment == :production
+    end
+
+    # Determine if this app is targeting eBay's sandbox environment.
+    # @return [Boolean] +true+ if sandbox mode, otherwise +false+.
+    #
+    def sandbox?
+      !production?
+    end
+
+    # Determine if all {#dev_id}, {#app_id} and {#cert_id} have all been set.
+    # @return [Boolean] +true+ if dev_id, app_id and cert_id have been defined.
+    #
+    def has_keys_set?
+      !(dev_id.nil? || app_id.nil? || cert_id.nil?)
+    end
+
+    # Optionally set a default authentication token to be used in API requests.
+    #
+    # @param [String] auth_token the eBay auth token for the user making requests.
+    #
+    def auth_token=(auth_token)
+      map_auth_token(DEFAULT_AUTH_TOKEN_KEY, auth_token)
+    end
+
+    # Get the default authentication token, or +nil+ if not set.
+    # @return [String] the default auth token.
+    #
+    def auth_token
+      auth_token_for(DEFAULT_AUTH_TOKEN_KEY)
+    end
+
+    # Map an eBay API auth token to an easy to remember +String+ key.
+    # This could be the corresponding eBay username thus making it easier
+    # to select the user auth token from a UI list or command line argument.
+    #
+    # @param [String] key auth_token identifier, typically an eBay username.
+    # @param [String] auth_token an eBay API authentication token.
+    #
+    def map_auth_token(key, auth_token)
+      @username_auth_tokens[secure_auth_token_key(key)] = auth_token
+    end
+
+    # Get the eBay API auth token matching the given +key+, or +nil+ if
+    # not found.
+    #
+    # @return [String] the corresponding auth token, or +nil+.
+    #
+    def auth_token_for(key)
+      @username_auth_tokens[secure_auth_token_key(key)]
+    end
+
+    # Provide a callback to track the number of eBay API calls made.
+    #
+    # As eBay rations the number of API calls you can make in a single day,
+    # typically to 5_000, it is advisable to record the volume of calls submitted.
+    # Here you can provide an application level callback that will be called
+    # during each API {Request}.
+    #
+    # @param [Proc|lambda] callback to be called during each eBay API request call.
+    # @return [Proc]
+    #
+    def counter=(callback)
+      @counter_callback = callback if callback && callback.is_a?(Proc)
+    end
+
+    # Determine if a {#counter_callback} has been set for this application.
+    #
+    # @return [Boolean] +true+ if a counter proc or lambda has been provided.
+    #
+    def has_counter?
+      @counter_callback != nil
+    end
+
+    def dev_id=(id)
+      raise EbayTraderError, 'Dev ID does not appear to be valid' unless application_key_valid?(id)
+      @dev_id = id
+    end
+
+    def app_id=(id)
+      raise EbayTraderError, 'App ID does not appear to be valid' unless application_key_valid?(id)
+      @app_id = id
+    end
+
+    def cert_id=(id)
+      raise EbayTraderError, 'Cert ID does not appear to be valid' unless application_key_valid?(id)
+      @cert_id = id
+    end
+
+    def price_type=(price_type_symbol)
+      case price_type_symbol
+        when :fixnum  then @price_type = :fixnum
+        when :integer then @price_type = :fixnum
+        when :float   then @price_type = :float
+        when :money   then @price_type = EbayTrader.is_money_gem_installed? ? :money : :fixnum
+        else
+          @price_type = :big_decimal
+      end
+      @price_type
+    end
+
+    def ssl_verify=(verify)
+      if verify
+        @ssl_verify = verify.is_a?(String) ? verify : true
+       else
+        @ssl_verify = false
+      end
+    end
+
+    #---------------------------------------------------------------------------
+    private
+
+    # Validate the given {#dev_id}, {#app_id} or {#cert_id}.
+    # These are almost like GUID/UUID values with the exception that the first
+    # block of 8 digits of AppID can be any letters.
+    # @return [Boolean] +true+ if the ID has the correct format.
+    #
+    def application_key_valid?(id)
+      id =~ /[A-Z0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}/i
+    end
+
+    def secure_auth_token_key(key)
+      Digest::MD5.hexdigest(key.to_s.downcase)
+    end
+
+  end
+end

data/lib/ebay_trader/fetch_token.rb

@@ -0,0 +1,45 @@
+require 'active_support/time'
+require 'ebay_trader/request'
+require 'ebay_trader/session_id'
+
+module EbayTrader
+
+  # Fetch an eBay user authentication token using a {SessionID} value.
+  #
+  # @see http://developer.ebay.com/DevZone/XML/docs/Reference/eBay/FetchToken.html
+  # @see http://developer.ebay.com/DevZone/XML/docs/HowTo/Tokens/GettingTokens.html
+  # @see http://developer.ebay.com/DevZone/guides/ebayfeatures/Basics/Tokens-MultipleUsers.html
+  #
+  class FetchToken < Request
+
+    CALL_NAME = 'FetchToken'
+
+    attr_reader :session_id
+
+    # Construct a fetch token eBay API request with the given session ID.
+    # @param [SessionID|String] session_id the session ID.
+    # @param [Hash] args a hash of optional arguments.
+    #
+    def initialize(session_id, args = {})
+      session_id = session_id.id if session_id.is_a?(SessionID)
+      @session_id = session_id.freeze
+      super(CALL_NAME, args) do
+        SessionID session_id
+      end
+    end
+
+    # Get the authentication token.
+    # @return [String] the authentication token.
+    #
+    def auth_token
+      response_hash[:ebay_auth_token]
+    end
+
+    # Get the Time at which the authentication token expires.
+    # @return [Time] the expiry time.
+    #
+    def expiry_time
+      response_hash[:hard_expiration_time]
+    end
+  end
+end

data/lib/ebay_trader/request.rb

@@ -0,0 +1,354 @@
+require 'active_support/gzip'
+require 'net/http'
+require 'ox'
+require 'rexml/document'
+require 'securerandom'
+require 'yaml'
+require 'openssl'
+require 'base64'
+
+require 'ebay_trader'
+require 'ebay_trader/sax_handler'
+require 'ebay_trader/xml_builder'
+
+module EbayTrader
+
+  class Request
+
+    # A Struct wrapper around eBay generated error and warning messages.
+    Error = Struct.new(:error_classification, :severity_code, :error_code, :short_message, :long_message) do
+      def error?;   severity_code == 'Error';   end
+      def warning?; severity_code == 'Warning'; end
+    end
+
+    # eBay Trading API XML Namespace
+    XMLNS = 'urn:ebay:apis:eBLBaseComponents'
+
+    attr_reader :call_name
+    attr_reader :auth_token
+    attr_reader :ebay_site_id
+    attr_reader :message_id
+    attr_reader :response_hash
+    attr_reader :skip_type_casting
+    attr_reader :known_arrays
+    attr_reader :xml_tab_width
+    attr_reader :xml_request
+    attr_reader :xml_response
+    attr_reader :http_timeout
+    attr_reader :http_response_code
+    attr_reader :response_time
+
+    # Construct a new eBay Trading API call.
+    #
+    # @param [String] call_name the name of the API call, for example 'GeteBayOfficialTime'.
+    #
+    # @param [Hash] args optional configuration values for this request.
+    #
+    # @option args [String] :auth_token the eBay Auth Token for the user submitting this request.
+    #                       If not defined the value of {Configuration#auth_token} will be assumed.
+    #
+    # @option args [Fixnum] :ebay_site_id Override the default eBay site ID in {Configuration#ebay_site_id}
+    #
+    # @option args [Fixnum] :http_timeout Override the default value of {Configuration#http_timeout}.
+    #
+    #                       This may be necessary for one-off calls such as
+    #                       {http://developer.ebay.com/DevZone/XML/docs/Reference/ebay/UploadSiteHostedPictures.html UploadSiteHostedPictures}
+    #                       which can take significantly longer.
+    #
+    # @option args [Array [String]] :skip_type_casting An array of the keys for which the values should *not*
+    #                       get automatically type cast.
+    #
+    #                       Take for example the 'BuyerUserID' field. If someone has the username '123456'
+    #                       the auto-type-casting would consider this to be a Fixnum. Adding 'BuyerUserID'
+    #                       to skip_type_casting list will ensure it remains a String.
+    #
+    # @option args [Array [String]] :known_arrays a list of the names of elements that are known to have arrays
+    #                       of values. If defined here {#response_hash} will ensure array values in circumstances
+    #                       where there is only a single child element in the response XML.
+    #
+    #                       It is not necessary to use this feature, but doing so can simplify later stage logic
+    #                       as certain fields are guaranteed to be arrays. As there is no concept of arrays in XML
+    #                       it is not otherwise possible to determine if a field should be an array.
+    #
+    #                       An example case is when building a tree of nested categories. Some categories may only have
+    #                       one child category, but adding 'Category' or :category to this list will ensure the
+    #                       response_hash values is always an array. Hence it will not necessary to check if the elements
+    #                       of a category element is a Hash or an Array of Hashes when recursing through the data.
+    #
+    # @option args [String] :xml_response inject a pre-prepared XML response.
+    #
+    #                       If an XML response is given here the request will not actually be sent to eBay.
+    #                       Using this feature can dramatically speed up testing and also ensure you stay
+    #                       within eBay's 5,000 requests per day throttling rate.
+    #
+    #                       It is also a useful feature for parsing locally cached/archived XML files.
+    #
+    # @option args [Fixnum] :xml_tab_width the number of spaces to indent child elements in the generated XML.
+    #                       The default is 0, meaning the XML is a single line string, but it's
+    #                       nice to have the option of pretty-printing the XML for debugging.
+    #
+    # @yield [xml_builder] a block describing the XML DOM.
+    #
+    # @yieldparam name [XMLBuilder] an XML builder node allowing customization of the request specific details.
+    #
+    # @yieldreturn [XMLBuilder] the same XML builder originally provided by the block.
+    #
+    # @raise [EbayTraderError] if the API call fails.
+    #
+    # @raise [EbayTraderTimeoutError] if the HTTP call times out.
+    #
+    def initialize(call_name, args = {}, &block)
+      time = Time.now
+      @call_name  = call_name.freeze
+
+      auth_token = %w"GetSessionID FetchToken GetTokenStatus RevokeToken".include?(call_name) ?
+                      nil : (args[:auth_token] || EbayTrader.configuration.auth_token)
+      @auth_token = auth_token.freeze
+
+      @ebay_site_id = (args[:ebay_site_id] || EbayTrader.configuration.ebay_site_id).to_i
+      @http_timeout = (args[:http_timeout] || EbayTrader.configuration.http_timeout).to_f
+      @xml_tab_width = (args[:xml_tab_width] || 0).to_i
+
+      @xml_response = args[:xml_response] || ''
+
+      @skip_type_casting = args[:skip_type_casting] || []
+      @skip_type_casting = @skip_type_casting.split if @skip_type_casting.is_a?(String)
+
+      @known_arrays = args[:known_arrays] || []
+      @known_arrays = @known_arrays.split if @known_arrays.is_a?(String)
+      @known_arrays << 'errors'
+
+      @message_id = nil
+      if args.key?(:message_id)
+        @message_id = (args[:message_id] == true) ? SecureRandom.uuid : args[:message_id].to_s
+      end
+
+      @xml_request = '<?xml version="1.0" encoding="utf-8"?>' << "\n"
+      @xml_request << XMLBuilder.new(tab_width: xml_tab_width).root("#{call_name}Request", xmlns: XMLNS) do
+        unless auth_token.blank?
+          RequesterCredentials do
+            eBayAuthToken auth_token.to_s
+          end
+        end
+        instance_eval(&block) if block_given?
+        MessageID message_id unless message_id.nil?
+      end
+
+      @http_response_code = 200
+      submit if xml_response.blank?
+
+      parsed_hash = parse(xml_response)
+      root_key = parsed_hash.keys.first
+      raise EbayTraderError, "Response '#{root_key}' does not match call name" unless root_key.gsub('_', '').eql?("#{call_name}Response".downcase)
+
+      @response_hash = parsed_hash[root_key]
+      @response_hash.freeze
+      @response_time = Time.now - time
+
+      @errors = []
+      deep_find(:errors, []).each do |error|
+        @errors << Error.new(error[:error_classification],
+                             error[:severity_code],
+                             error[:error_code],
+                             error[:short_message],
+                             error[:long_message])
+      end
+    end
+
+    # Determine if this request has been successful.
+    # This should return the opposite of {#failure?}
+    def success?
+      deep_find(:ack, '').downcase.eql?('success')
+    end
+
+    # Determine if this request has failed.
+    # This should return the opposite of {#success?}
+    def failure?
+      deep_find(:ack, '').downcase.eql?('failure')
+    end
+
+    # Determine if this response has partially failed.
+    # This eBay response is somewhat ambiguous, but generally means the request was
+    # processed by eBay, but warnings were generated.
+    def partial_failure?
+      deep_find(:ack, '').downcase.eql?('partialfailure')
+    end
+
+    # Determine if this request has generated any {#errors} or {#warnings}.
+    # @return [Boolean] +true+ if errors or warnings present.
+    def has_errors_or_warnings?
+      has_errors? || has_warnings?
+    end
+
+    # Get an array of all {#errors} and {#warnings}.
+    # @return [Array[Error]] all {#errors} and {#warnings} combined.
+    def errors_and_warnings
+      @errors
+    end
+
+    # Determine if this request has generated any {#errors}, excluding {#warnings}.
+    # @return [Boolean] +true+ if any errors present.
+    def has_errors?
+      errors.count > 0
+    end
+
+    # Get an array of {Error}s, excluding {#warnings}. This will be an empty array if there are no errors.
+    # @return [Array[Error]] which have a severity_code of 'Error'.
+    def errors
+      @errors.select { |error| error.error? }
+    end
+
+    # Determine if this request has generated any {#warnings}.
+    # @return [Boolean] +true+ if warnings present.
+    def has_warnings?
+      warnings.count > 0
+    end
+
+    # Get an array of {Error}s representing warnings. This will be an empty array if there are no errors.
+    # @return [Array[Error]] which have a severity_code of 'Warning'.
+    def warnings
+      @errors.select { |error| error.warning? }
+    end
+
+    # Get the timestamp of the response returned by eBay API.
+    # The timestamp indicates the time when eBay processed the request; it does
+    # not necessarily indicate the current eBay official eBay time.
+    # In particular, calls like
+    # {http://developer.ebay.com/DevZone/XML/docs/Reference/eBay/GetCategories.html GetCategories}
+    # can return a cached response, so the time stamp may not be current.
+    # @return [Time] the response timestamp.
+    #
+    def timestamp
+      deep_find :timestamp
+    end
+
+    # Recursively deep search through the {#response_hash} tree and return the
+    # first value matching the given +path+ of node names.
+    # If +path+ cannot be matched the value of +default+ is returned.
+    # @param [Array [String|Symbol]] path an array of the keys defining the path to the node of interest.
+    # @param [Object] default the value to be returned if +path+ cannot be matched.
+    # @return [Array] the first value found in +path+, or +default+.
+    def deep_find(path, default = nil)
+      @response_hash.deep_find(path, default)
+    end
+
+    # Get a String representation of the response XML with indentation.
+    # @return [String] the response XML.
+    def to_s(indent = xml_tab_width)
+      xml = ''
+      if defined? Ox
+        ox_doc = Ox.parse(xml_response)
+        xml = Ox.dump(ox_doc, indent: indent)
+      else
+        rexml_doc = REXML::Document.new(xml_response)
+        rexml_doc.write(xml, indent)
+      end
+      xml
+    end
+
+    # Get a String representation of the XML data hash in JSON notation.
+    # @return [String] pretty printed JSON.
+    def to_json_s
+      require 'json' unless defined? JSON
+      puts JSON.pretty_generate(JSON.parse(@response_hash.to_json))
+    end
+
+    #-------------------------------------------------------------------------
+    private
+
+    # Post the xml_request to eBay and record the xml_response.
+    def submit
+      raise EbayTraderError, 'Cannot post an eBay API request before application keys have been set' unless EbayTrader.configuration.has_keys_set?
+
+      uri = EbayTrader.configuration.uri
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.read_timeout = http_timeout
+
+      if uri.port == 443
+        # http://www.rubyinside.com/nethttp-cheat-sheet-2940.html
+        http.use_ssl = true
+        verify = EbayTrader.configuration.ssl_verify
+        if verify
+          if verify.is_a?(String)
+            pem = File.read(verify)
+            http.cert = OpenSSL::X509::Certificate.new(pem)
+            http.key = OpenSSL::PKey::RSA.new(pem)
+          end
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+
+      end
+
+      post = Net::HTTP::Post.new(uri.path, headers)
+      post.body = xml_request
+
+      begin
+        response = http.start { |http| http.request(post) }
+      rescue OpenSSL::SSL::SSLError => e
+        # SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed
+        raise EbayTraderError, e
+      rescue Net::ReadTimeout
+        raise EbayTraderTimeoutError, "Failed to complete #{call_name} in #{http_timeout} seconds"
+      rescue Exception => e
+        raise EbayTraderError, e
+      ensure
+        EbayTrader.configuration.counter_callback.call if EbayTrader.configuration.has_counter?
+      end
+
+      @http_response_code = response.code.to_i.freeze
+
+      # If the call was successful it should have a response code starting with '2'
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
+      raise EbayTraderError, "HTTP Response Code: #{http_response_code}" unless http_response_code.between?(200, 299)
+
+      if response['Content-Encoding'] == 'gzip'
+        @xml_response = ActiveSupport::Gzip.decompress(response.body)
+      else
+        @xml_response = response.body
+      end
+    end
+
+    # Parse the given XML using {SaxHandler} and return a nested Hash.
+    # @param [String] xml the XML string to be parsed.
+    # @return [Hash] a Hash corresponding to +xml+.
+    def parse(xml)
+      xml ||= ''
+      xml = StringIO.new(xml) unless xml.respond_to?(:read)
+
+      handler = SaxHandler.new(skip_type_casting: skip_type_casting, known_arrays: known_arrays)
+      Ox.sax_parse(handler, xml, convert_special: true)
+      handler.to_hash
+    end
+
+    #
+    # Get a hash of the default headers to be submitted to eBay API via httparty.
+    # Additional headers can be merged into this hash as follows:
+    # ebay_headers.merge({'X-EBAY-API-CALL-NAME' => 'CallName'})
+    # http://developer.ebay.com/Devzone/XML/docs/WebHelp/InvokingWebServices-Routing_the_Request_(Gateway_URLs).html
+    #
+    def headers
+      headers = {
+          'X-EBAY-API-COMPATIBILITY-LEVEL' => "#{EbayTrader.configuration.ebay_api_version}",
+          'X-EBAY-API-SITEID' => "#{ebay_site_id}",
+          'X-EBAY-API-CALL-NAME' => call_name,
+          'Content-Type' => 'text/xml',
+          'Accept-Encoding' => 'gzip'
+      }
+      xml = xml_request
+      headers.merge!({'Content-Length' => "#{xml.length}"}) if xml && !xml.strip.empty?
+
+      # These values are only required for calls that set up and retrieve a user's authentication token
+      # (these calls are: GetSessionID, FetchToken, GetTokenStatus, and RevokeToken).
+      # In all other calls, these value are ignored..
+      if %w"GetSessionID FetchToken GetTokenStatus RevokeToken".include?(call_name)
+        headers.merge!({'X-EBAY-API-DEV-NAME'  => EbayTrader.configuration.dev_id})
+        headers.merge!({'X-EBAY-API-APP-NAME'  => EbayTrader.configuration.app_id})
+        headers.merge!({'X-EBAY-API-CERT-NAME' => EbayTrader.configuration.cert_id})
+      end
+      headers
+    end
+  end
+end