activemerchant 1.47.0 → 1.48.0

data/lib/active_merchant/billing/gateways/netbilling.rb

@@ -1,5 +1,15 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
+    # To perform PCI Compliant Repeat Billing
+    #
+    #   Ensure that PCI Compliant Repeat Billing is enabled on your merchant account:
+    #    "Enable PCI Compliant Repeat Billing, Up-selling and Cross-selling" in Step 6 of the Credit Cards setup page
+    #
+    #  Instead of passing a credit_card to authorize or purchase, pass the transaction id (res.authorization)
+    #  of a past Netbilling transaction
+    #
+    # To store billing information without performing an operation, use the 'store' method
+    # which invokes the tran_type 'Q' (Quasi) operation and returns a transaction id to use in future Repeat Billing operations
     class NetbillingGateway < Gateway
       self.live_url = self.test_url = 'https://secure.netbilling.com:1402/gw/sas/direct3.1'
 
@@ -9,7 +19,8 @@ module ActiveMerchant #:nodoc:
         :refund        => 'R',
         :credit        => 'C',
         :capture       => 'D',
-        :void          => 'U'
+        :void          => 'U',
+        :quasi         => 'Q'
       }
 
       SUCCESS_CODES = [ '1', 'T' ]
@@ -27,23 +38,23 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def authorize(money, credit_card, options = {})
+      def authorize(money, payment_source, options = {})
         post = {}
         add_amount(post, money)
         add_invoice(post, options)
-        add_credit_card(post, credit_card)
-        add_address(post, credit_card, options)
+        add_payment_source(post, payment_source)
+        add_address(post, payment_source, options)
         add_customer_data(post, options)
 
         commit(:authorization, post)
       end
 
-      def purchase(money, credit_card, options = {})
+      def purchase(money, payment_source, options = {})
         post = {}
         add_amount(post, money)
         add_invoice(post, options)
-        add_credit_card(post, credit_card)
-        add_address(post, credit_card, options)
+        add_payment_source(post, payment_source)
+        add_address(post, payment_source, options)
         add_customer_data(post, options)
 
         commit(:purchase, post)
@@ -79,6 +90,16 @@ module ActiveMerchant #:nodoc:
         commit(:void, post)
       end
 
+      def store(credit_card, options = {})
+        post = {}
+        add_amount(post, 0)
+        add_payment_source(post, credit_card)
+        add_address(post, credit_card, options)
+        add_customer_data(post, options)
+
+        commit(:quasi, post)
+      end
+
       def test?
         (@options[:login] == TEST_LOGIN || super)
       end
@@ -125,6 +146,18 @@ module ActiveMerchant #:nodoc:
         post[:description] = options[:description]
       end
 
+      def add_payment_source(params, source)
+        if source.is_a?(String)
+          add_transaction_id(params, source)
+        else
+          add_credit_card(params, source)
+        end
+      end
+
+      def add_transaction_id(post, transaction_id)
+        post[:card_number] = 'CS:' + transaction_id
+      end
+
       def add_credit_card(post, credit_card)
         post[:bill_name1] = credit_card.first_name
         post[:bill_name2] = credit_card.last_name

data/lib/active_merchant/billing/gateways/orbital.rb

@@ -324,12 +324,12 @@ module ActiveMerchant #:nodoc:
           avs_supported = AVS_SUPPORTED_COUNTRIES.include?(address[:country].to_s)
 
           if avs_supported
-            xml.tag! :AVSzip,       (address[:zip] ? address[:zip].to_s[0..9] : nil)
-            xml.tag! :AVSaddress1,  (address[:address1] ? address[:address1][0..29] : nil)
-            xml.tag! :AVSaddress2,  (address[:address2] ? address[:address2][0..29] : nil)
-            xml.tag! :AVScity,      (address[:city] ? address[:city][0..19] : nil)
-            xml.tag! :AVSstate,     address[:state]
-            xml.tag! :AVSphoneNum,  (address[:phone] ? address[:phone].scan(/\d/).join.to_s[0..13] : nil)
+            xml.tag! :AVSzip,      byte_limit(format_address_field(address[:zip]), 10)
+            xml.tag! :AVSaddress1, byte_limit(format_address_field(address[:address1]), 30)
+            xml.tag! :AVSaddress2, byte_limit(format_address_field(address[:address2]), 30)
+            xml.tag! :AVScity,     byte_limit(format_address_field(address[:city]), 20)
+            xml.tag! :AVSstate,    byte_limit(format_address_field(address[:state]), 2)
+            xml.tag! :AVSphoneNum, (address[:phone] ? address[:phone].scan(/\d/).join.to_s[0..13] : nil)
           end
           # can't look in billing address?
           xml.tag! :AVSname, ((creditcard && creditcard.name) ? creditcard.name[0..29] : nil)
@@ -342,29 +342,33 @@ module ActiveMerchant #:nodoc:
 
       def add_destination_address(xml, address)
         if address[:dest_zip]
-          xml.tag! :AVSDestzip,      (address[:dest_zip] ? address[:dest_zip].to_s[0..9] : nil)
-          xml.tag! :AVSDestaddress1, (address[:dest_address1] ? address[:dest_address1][0..29] : nil)
-          xml.tag! :AVSDestaddress2, (address[:dest_address2] ? address[:dest_address2][0..29] : nil)
-          xml.tag! :AVSDestcity,     (address[:dest_city] ? address[:dest_city][0..19] : nil)
-          xml.tag! :AVSDeststate,    address[:dest_state]
+          avs_supported = AVS_SUPPORTED_COUNTRIES.include?(address[:dest_country].to_s)
+
+          xml.tag! :AVSDestzip,      byte_limit(format_address_field(address[:dest_zip]), 10)
+          xml.tag! :AVSDestaddress1, byte_limit(format_address_field(address[:dest_address1]), 30)
+          xml.tag! :AVSDestaddress2, byte_limit(format_address_field(address[:dest_address2]), 30)
+          xml.tag! :AVSDestcity,     byte_limit(format_address_field(address[:dest_city]), 20)
+          xml.tag! :AVSDeststate,    byte_limit(format_address_field(address[:dest_state]), 2)
           xml.tag! :AVSDestphoneNum, (address[:dest_phone] ? address[:dest_phone].scan(/\d/).join.to_s[0..13] : nil)
 
-          xml.tag! :AVSDestname,        (address[:dest_name] ? address[:dest_name][0..29] : nil)
-          xml.tag! :AVSDestcountryCode, address[:dest_country]
+          xml.tag! :AVSDestname,        byte_limit(address[:dest_name], 30)
+          xml.tag! :AVSDestcountryCode, (avs_supported ? address[:dest_country] : '')
         end
       end
 
       # For Profile requests
       def add_customer_address(xml, options)
         if(address = (options[:billing_address] || options[:address]))
-          xml.tag! :CustomerAddress1, (address[:address1] ? address[:address1][0..29] : nil)
-          xml.tag! :CustomerAddress2, (address[:address2] ? address[:address2][0..29] : nil)
-          xml.tag! :CustomerCity, (address[:city] ? address[:city][0..19] : nil)
-          xml.tag! :CustomerState, address[:state]
-          xml.tag! :CustomerZIP, (address[:zip] ? address[:zip].to_s[0..9] : nil)
-          xml.tag! :CustomerEmail, address[:email].to_s[0..49] if address[:email]
+          avs_supported = AVS_SUPPORTED_COUNTRIES.include?(address[:country].to_s)
+
+          xml.tag! :CustomerAddress1, byte_limit(format_address_field(address[:address1]), 30)
+          xml.tag! :CustomerAddress2, byte_limit(format_address_field(address[:address2]), 30)
+          xml.tag! :CustomerCity, byte_limit(format_address_field(address[:city]), 20)
+          xml.tag! :CustomerState, byte_limit(format_address_field(address[:state]), 2)
+          xml.tag! :CustomerZIP, byte_limit(format_address_field(address[:zip]), 10)
+          xml.tag! :CustomerEmail, byte_limit(address[:email], 50) if address[:email]
           xml.tag! :CustomerPhone, (address[:phone] ? address[:phone].scan(/\d/).join.to_s : nil)
-          xml.tag! :CustomerCountryCode, (address[:country] ? address[:country][0..1] : nil)
+          xml.tag! :CustomerCountryCode, (avs_supported ? address[:country] : '')
         end
       end
 
@@ -630,12 +634,32 @@ module ActiveMerchant #:nodoc:
       # 2. - , $ @ & and a space character, though the space character cannot be the leading character
       # 3. PINless Debit transactions can only use uppercase and lowercase alpha (A-Z, a-z) and numeric (0-9)
       def format_order_id(order_id)
-        illegal_characters = /[^,$@\- \w]/
+        illegal_characters = /[^,$@&\- \w]/
         order_id = order_id.to_s.gsub(/\./, '-')
         order_id.gsub!(illegal_characters, '')
+        order_id.lstrip!
         order_id[0...22]
       end
 
+      # Address-related fields cannot contain % | ^ \ /
+      # Returns the value with these characters removed, or nil
+      def format_address_field(value)
+        value.gsub(/[%\|\^\\\/]/, '') if value.respond_to?(:gsub)
+      end
+
+      # Field lengths should be limited by byte count instead of character count
+      # Returns the truncated value or nil
+      def byte_limit(value, byte_length)
+        limited_value = ""
+
+        value.to_s.each_char do |c|
+          break if((limited_value.bytesize + c.bytesize) > byte_length)
+          limited_value << c
+        end
+
+        limited_value
+      end
+
       def build_customer_request_xml(creditcard, options = {})
         xml = xml_envelope
         xml.tag! :Request do

data/lib/active_merchant/billing/gateways/pay_conex.rb

@@ -0,0 +1,246 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayConexGateway < Gateway
+      include Empty
+
+      self.test_url = "https://cert.payconex.net/api/qsapi/3.8/"
+      self.live_url = "https://secure.payconex.net/api/qsapi/3.8/"
+
+      self.supported_countries = %w(US CA)
+      self.default_currency = "USD"
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+
+      self.homepage_url = "http://www.bluefincommerce.com/"
+      self.display_name = "PayConex"
+
+      def initialize(options={})
+        requires!(options, :account_id, :api_accesskey)
+        super
+      end
+
+      def purchase(money, payment_method, options={})
+        post = {}
+        add_auth_purchase_params(post, money, payment_method, options)
+        commit("SALE", post)
+      end
+
+      def authorize(money, payment_method, options={})
+        post = {}
+        add_auth_purchase_params(post, money, payment_method, options)
+        commit("AUTHORIZATION", post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        add_reference_params(post, authorization, options)
+        add_amount(post, money, options)
+        commit("CAPTURE", post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_reference_params(post, authorization, options)
+        add_amount(post, money, options)
+        commit("REFUND", post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_reference_params(post, authorization, options)
+        commit("REVERSAL", post)
+      end
+
+      def credit(money, payment_method, options={})
+        if payment_method.is_a?(String)
+          raise ArgumentError, "Reference credits are not supported. Please supply the original credit card or use the #refund method."
+        end
+
+        post = {}
+        add_auth_purchase_params(post, money, payment_method, options)
+        commit("CREDIT", post)
+      end
+
+      def verify(payment_method, options={})
+        authorize(0, payment_method, options)
+      end
+
+      def store(payment_method, options={})
+        post = {}
+        add_credentials(post)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+        add_common_options(post, options)
+        commit("STORE", post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        force_utf8(transcript).
+          gsub(%r((api_accesskey=)\w+), '\1[FILTERED]').
+          gsub(%r((card_number=)\w+), '\1[FILTERED]').
+          gsub(%r((card_verification=)\w+), '\1[FILTERED]')
+      end
+
+      private
+
+      def force_utf8(string)
+        return nil unless string
+        binary = string.encode("BINARY", invalid: :replace, undef: :replace, replace: "?")   # Needed for Ruby 2.0 since #encode is a no-op if the string is already UTF-8. It's not needed for Ruby 2.1 and up since it's not a no-op there.
+        binary.encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+      end
+
+      def add_credentials(post)
+        post[:account_id] = @options[:account_id]
+        post[:api_accesskey] = @options[:api_accesskey]
+      end
+
+      def add_auth_purchase_params(post, money, payment_method, options)
+        add_credentials(post)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+        add_common_options(post, options)
+        add_amount(post, money, options)
+        add_if_present(post, :email, options[:email])
+      end
+
+      def add_reference_params(post, authorization, options)
+        add_credentials(post)
+        add_common_options(post, options)
+        add_token_id(post, authorization)
+      end
+
+      def add_amount(post, money, options)
+        post[:transaction_amount] = amount(money)
+        currency_code = (options[:currency] || currency(money))
+        add_if_present(post, :currency, currency_code)
+      end
+
+      def add_payment_method(post, payment_method)
+        case payment_method
+        when String
+          add_token_payment_method(post, payment_method)
+        when Check
+          add_check(post, payment_method)
+        else
+          if payment_method.respond_to?(:track_data) && payment_method.track_data.present?
+            add_card_present_payment_method(post, payment_method)
+          else
+            add_credit_card(post, payment_method)
+          end
+        end
+      end
+
+      def add_credit_card(post, payment_method)
+        post[:tender_type] = "CARD"
+        post[:card_number] = payment_method.number
+        post[:card_expiration] = expdate(payment_method)
+        post[:card_verification] = payment_method.verification_value
+        post[:first_name] = payment_method.first_name
+        post[:last_name] = payment_method.last_name
+      end
+
+      def add_token_payment_method(post, payment_method)
+        post[:tender_type] = "CARD"
+        post[:token_id] = payment_method
+        post[:reissue] = true
+      end
+
+      def add_card_present_payment_method(post, payment_method)
+        post[:tender_type] = "CARD"
+        post[:card_tracks] = payment_method.track_data
+      end
+
+      def add_check(post, payment_method)
+        post[:tender_type] = "ACH"
+        post[:first_name] = payment_method.first_name
+        post[:last_name] = payment_method.last_name
+        post[:bank_account_number] = payment_method.account_number
+        post[:bank_routing_number] = payment_method.routing_number
+        post[:check_number] = payment_method.number
+        add_if_present(post, :ach_account_type, payment_method.account_type)
+      end
+
+      def add_address(post, options)
+        address = options[:billing_address]
+        return unless address
+
+        add_if_present(post, :street_address1, address[:address1])
+        add_if_present(post, :street_address2, address[:address2])
+        add_if_present(post, :city, address[:city])
+        add_if_present(post, :state, address[:state])
+        add_if_present(post, :zip, address[:zip])
+        add_if_present(post, :country, address[:country])
+        add_if_present(post, :phone, address[:phone])
+      end
+
+      def add_common_options(post, options)
+        add_if_present(post, :transaction_description, options[:description])
+        add_if_present(post, :custom_id, options[:custom_id])
+        add_if_present(post, :custom_data, options[:custom_data])
+        add_if_present(post, :ip_address, options[:ip])
+        add_if_present(post, :payment_type, options[:payment_type])
+        add_if_present(post, :cashier, options[:cashier])
+
+        post[:disable_cvv] = options[:disable_cvv] unless options[:disable_cvv].nil?
+        post[:response_format] = 'JSON'
+      end
+
+      def add_if_present(post, key, value)
+        post[key] = value unless empty?(value)
+      end
+
+      def add_token_id(post, authorization)
+        post[:token_id] = authorization
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, params)
+        raw_response = ssl_post(url, post_data(action, params))
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: response["transaction_id"],
+          :avs_result => AVSResult.new(code: response["avs_response"]),
+          :cvv_result => CVVResult.new(response["cvv2_response"]),
+          test: test?
+        )
+
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def success_from(response)
+        response["transaction_approved"] || !response["error"]
+      end
+
+      def message_from(response)
+        success_from(response) ? response["authorization_message"] : response["error_message"]
+      end
+
+      def post_data(action, params)
+        params[:transaction_type] = action
+        params.map {|k, v| "#{k}=#{CGI.escape(v.to_s)}"}.join('&')
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from PayConex. Please contact PayConex if you continue to receive this message."
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/pay_hub.rb

@@ -0,0 +1,213 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayHubGateway < Gateway
+      self.live_url = 'https://checkout.payhub.com/transaction/api'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.payhub.com/'
+      self.display_name = 'PayHub'
+
+      CVV_CODE_TRANSLATOR = {
+        'M' => 'CVV matches',
+        'N' => 'CVV does not match',
+        'P' => 'CVV not processed',
+        'S' => 'CVV should have been present',
+        'U' => 'CVV request unable to be processed by issuer'
+      }
+
+      AVS_CODE_TRANSLATOR = {
+        '0' =>  "Approved, Address verification was not requested.",
+        'A' =>  "Approved, Address matches only.",
+        'B' =>  "Address Match. Street Address math for international transaction Postal Code not verified because of incompatible formats (Acquirer sent both street address and Postal Code)",
+        'C' =>  "Serv Unavailable. Street address and Postal Code not verified for international transaction because of incompatible formats (Acquirer sent both street and Postal Code).",
+        'D' =>  "Exact Match, Street Address and Postal Code match for international transaction.",
+        'F' =>  "Exact Match, Street Address and Postal Code match. Applies to UK only.",
+        'G' =>  "Ver Unavailable, Non-U.S. Issuer does not participate.",
+        'I' =>  "Ver Unavailable, Address information not verified for international transaction",
+        'M' =>  "Exact Match, Street Address and Postal Code match for international transaction",
+        'N' =>  "No - Address and ZIP Code does not match",
+        'P' =>  "Zip Match, Postal Codes match for international transaction Street address not verified because of incompatible formats (Acquirer sent both street address and Postal Code).",
+        'R' =>  "Retry - Issuer system unavailable",
+        'S' =>  "Serv Unavailable, Service not supported",
+        'U' =>  "Ver Unavailable, Address unavailable.",
+        'W' =>  "ZIP match - Nine character numeric ZIP match only.",
+        'X' =>  "Exact match, Address and nine-character ZIP match.",
+        'Y' =>  "Exact Match, Address and five character ZIP match.",
+        'Z' =>  "Zip Match, Five character numeric ZIP match only.",
+        '1' =>  "Cardholder name and ZIP match AMEX only.",
+        '2' =>  "Cardholder name, address, and ZIP match AMEX only.",
+        '3' =>  "Cardholder name and address match AMEX only.",
+        '4' =>  "Cardholder name match AMEX only.",
+        '5' =>  "Cardholder name incorrect, ZIP match AMEX only.",
+        '6' =>  "Cardholder name incorrect, address and ZIP match AMEX only.",
+        '7' =>  "Cardholder name incorrect, address match AMEX only.",
+        '8' =>  "Cardholder, all do not match AMEX only."
+      }
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '14' => STANDARD_ERROR_CODE[:invalid_number],
+        '80' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '82' => STANDARD_ERROR_CODE[:invalid_cvc],
+        '54' => STANDARD_ERROR_CODE[:expired_card],
+        '51' => STANDARD_ERROR_CODE[:card_declined],
+        '05' => STANDARD_ERROR_CODE[:card_declined],
+        '61' => STANDARD_ERROR_CODE[:card_declined],
+        '62' => STANDARD_ERROR_CODE[:card_declined],
+        '65' => STANDARD_ERROR_CODE[:card_declined],
+        '93' => STANDARD_ERROR_CODE[:card_declined],
+        '01' => STANDARD_ERROR_CODE[:call_issuer],
+        '02' => STANDARD_ERROR_CODE[:call_issuer],
+        '04' => STANDARD_ERROR_CODE[:pickup_card],
+        '07' => STANDARD_ERROR_CODE[:pickup_card],
+        '41' => STANDARD_ERROR_CODE[:pickup_card],
+        '43' => STANDARD_ERROR_CODE[:pickup_card]
+      }
+
+      def initialize(options={})
+        requires!(options, :orgid, :username, :password, :tid)
+
+        super
+      end
+
+      def authorize(amount, creditcard, options = {})
+        post = setup_post('auth')
+        add_creditcard(post, creditcard)
+        add_amount(post, amount)
+        add_address(post, (options[:address] || options[:billing_address]))
+        add_customer_data(post, options)
+
+        commit(post)
+      end
+
+      def purchase(amount, creditcard, options={})
+        post = setup_post('sale')
+        add_creditcard(post, creditcard)
+        add_amount(post, amount)
+        add_address(post, (options[:address] || options[:billing_address]))
+        add_customer_data(post, options)
+
+        commit(post)
+      end
+
+      def refund(amount, trans_id, options={})
+        # Attempt a void in case the transaction is unsettled
+        post = setup_post('void')
+        add_reference(post, trans_id)
+        response = commit(post)
+        return response if response.success?
+
+        post = setup_post('refund')
+        add_reference(post, trans_id)
+        commit(post)
+      end
+
+      def capture(amount, trans_id, options = {})
+        post = setup_post('capture')
+
+        add_reference(post, trans_id)
+        add_amount(post, amount)
+
+        commit(post)
+      end
+
+      # No void, as PayHub's void does not work on authorizations
+
+      def verify(creditcard, options={})
+        authorize(100, creditcard, options)
+      end
+
+      private
+
+      def setup_post(action)
+        post = {}
+        post[:orgid] = @options[:orgid]
+        post[:tid] = @options[:tid]
+        post[:username] = @options[:username]
+        post[:password] = @options[:password]
+        post[:mode] = (test? ? 'demo' : 'live')
+        post[:trans_type] = action
+        post
+      end
+
+      def add_reference(post, trans_id)
+        post[:trans_id] = trans_id
+      end
+
+      def add_customer_data(post, options = {})
+        post[:first_name] = options[:first_name]
+        post[:last_name] = options[:last_name]
+        post[:phone] = options[:phone]
+        post[:email] = options[:email]
+      end
+
+      def add_address(post, address)
+        return unless address
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:zip] = address[:zip]
+        post[:state] = address[:state]
+        post[:city] = address[:city]
+      end
+
+      def add_amount(post, amount)
+        post[:amount] =  amount(amount)
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:cc] = creditcard.number
+        post[:month] = creditcard.month.to_s
+        post[:year] = creditcard.year.to_s
+        post[:cvv] = creditcard.verification_value
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(post)
+        success = false
+
+        begin
+          raw_response = ssl_post(live_url, post.to_json, {'Content-Type' => 'application/json'} )
+          response = parse(raw_response)
+          success = (response['RESPONSE_CODE'] == "00")
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = response_error(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+
+        Response.new(success,
+          response_message(response),
+          response,
+          test: test?,
+          avs_result: {code: response['AVS_RESULT_CODE']},
+          cvv_result: response['VERIFICATION_RESULT_CODE'],
+          error_code: (success ? nil : STANDARD_ERROR_CODE_MAPPING[response['RESPONSE_CODE']]),
+          authorization: response['TRANSACTION_ID']
+        )
+      end
+
+      def response_error(raw_response)
+        parse(raw_response)
+      rescue JSON::ParserError
+        json_error(raw_response)
+      end
+
+      def json_error(raw_response)
+        {
+          error_message: 'Invalid response received from the Payhub API.  Please contact wecare@payhub.com if you continue to receive this message.' +
+            '  (The raw response returned by the API was #{raw_response.inspect})'
+        }
+      end
+
+      def response_message(response)
+        (response['RESPONSE_TEXT'] || response["RESPONSE_CODE"] || response[:error_message])
+      end
+    end
+  end
+end