activemerchant 1.119.0 → 1.124.0

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

@@ -0,0 +1,376 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaysafeGateway < Gateway
+      self.test_url = 'https://api.test.paysafe.com'
+      self.live_url = 'https://api.paysafe.com'
+
+      self.supported_countries = %w(AL AT BE BA BG CA HR CY CZ DK EE FI FR DE GR HU IS IE IT LV LI LT LU MT ME NL MK NO PL PT RO RS SK SI ES SE CH TR GB US)
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://www.paysafe.com/'
+      self.display_name = 'Paysafe'
+
+      def initialize(options = {})
+        requires!(options, :username, :password, :account_id)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_billing_address(post, options)
+        add_merchant_details(post, options)
+        add_airline_travel_details(post, options)
+        add_customer_data(post, payment, options) unless payment.is_a?(String)
+        add_three_d_secure(post, payment, options) if options[:three_d_secure]
+        add_split_pay_details(post, options)
+        post[:settleWithAuth] = true
+
+        commit(:post, 'auths', post, options)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_billing_address(post, options)
+        add_merchant_details(post, options)
+        add_customer_data(post, payment, options) unless payment.is_a?(String)
+        add_three_d_secure(post, payment, options) if options[:three_d_secure]
+
+        commit(:post, 'auths', post, options)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_invoice(post, money, options)
+
+        commit(:post, "auths/#{authorization}/settlements", post, options)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        add_invoice(post, money, options)
+
+        commit(:post, "settlements/#{authorization}/refunds", post, options)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        money = options[:amount]
+        add_invoice(post, money, options)
+
+        commit(:post, "auths/#{authorization}/voidauths", post, options)
+      end
+
+      def credit(money, payment, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+
+        commit(:post, 'standalonecredits', post, options)
+      end
+
+      # This is a '$0 auth' done at a specific verification endpoint at the gateway
+      def verify(payment, options = {})
+        post = {}
+        add_payment(post, payment)
+        add_billing_address(post, options)
+        add_customer_data(post, payment, options) unless payment.is_a?(String)
+
+        commit(:post, 'verifications', post, options)
+      end
+
+      def store(payment, options = {})
+        post = {}
+        add_payment(post, payment)
+        add_address_for_vaulting(post, options)
+        add_profile_data(post, payment, options)
+        add_store_data(post, payment, options)
+
+        commit(:post, 'profiles', post, options)
+      end
+
+      def redact(pm_profile_id)
+        commit_for_redact(:delete, "profiles/#{pm_profile_id}", nil, nil)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )[a-zA-Z0-9:_]+), '\1[FILTERED]').
+          gsub(%r(("cardNum\\?":\\?")\d+), '\1[FILTERED]').
+          gsub(%r(("cvv\\?":\\?")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      # Customer data can be included in transactions where the payment method is a credit card
+      # but should not be sent when the payment method is a token
+      def add_customer_data(post, creditcard, options)
+        post[:profile] = {}
+        post[:profile][:firstName] = creditcard.first_name
+        post[:profile][:lastName] = creditcard.last_name
+        post[:profile][:email] = options[:email] if options[:email]
+        post[:customerIp] = options[:ip] if options[:ip]
+      end
+
+      def add_billing_address(post, options)
+        return unless address = options[:billing_address] || options[:address]
+
+        post[:billingDetails] = {}
+        post[:billingDetails][:street] = address[:address1]
+        post[:billingDetails][:city] = address[:city]
+        post[:billingDetails][:state] = address[:state]
+        post[:billingDetails][:country] = address[:country]
+        post[:billingDetails][:zip] = address[:zip]
+        post[:billingDetails][:phone] = address[:phone]
+      end
+
+      # The add_address_for_vaulting method is applicable to the store method, as the APIs address
+      # object is formatted differently from the standard transaction billing address
+      def add_address_for_vaulting(post, options)
+        return unless address = options[:billing_address] || options[:address]
+
+        post[:card][:billingAddress] = {}
+        post[:card][:billingAddress][:street] = address[:address1]
+        post[:card][:billingAddress][:street2] = address[:address2]
+        post[:card][:billingAddress][:city] = address[:city]
+        post[:card][:billingAddress][:zip] = address[:zip]
+        post[:card][:billingAddress][:country] = address[:country]
+        post[:card][:billingAddress][:state] = address[:state] if address[:state]
+      end
+
+      # This data is specific to creating a profile at the gateway's vault level
+      def add_profile_data(post, payment, options)
+        post[:firstName] = payment.first_name
+        post[:lastName] = payment.last_name
+        post[:dateOfBirth] = {}
+        post[:dateOfBirth][:year] = options[:date_of_birth][:year]
+        post[:dateOfBirth][:month] = options[:date_of_birth][:month]
+        post[:dateOfBirth][:day] = options[:date_of_birth][:day]
+        post[:email] = options[:email] if options[:email]
+        post[:ip] = options[:ip] if options[:ip]
+
+        if options[:phone]
+          post[:phone] = options[:phone]
+        elsif address = options[:billing_address] || options[:address]
+          post[:phone] = address[:phone] if address[:phone]
+        end
+      end
+
+      def add_store_data(post, payment, options)
+        post[:merchantCustomerId] = options[:customer_id] || SecureRandom.hex(12)
+        post[:locale] = options[:locale] || 'en_US'
+        post[:card][:holderName] = payment.name
+      end
+
+      # Paysafe expects minor units so we are not calling amount method on money parameter
+      def add_invoice(post, money, options)
+        post[:amount] = money
+      end
+
+      def add_payment(post, payment)
+        if payment.is_a?(String)
+          post[:card] = {}
+          post[:card][:paymentToken] = payment
+        else
+          post[:card] = { cardExpiry: {} }
+          post[:card][:cardNum] = payment.number
+          post[:card][:cardExpiry][:month] = payment.month
+          post[:card][:cardExpiry][:year] = payment.year
+          post[:card][:cvv] = payment.verification_value
+        end
+      end
+
+      def add_merchant_details(post, options)
+        return unless options[:merchant_descriptor]
+
+        post[:merchantDescriptor] = {}
+        post[:merchantDescriptor][:dynamicDescriptor] = options[:merchant_descriptor][:dynamic_descriptor] if options[:merchant_descriptor][:dynamic_descriptor]
+        post[:merchantDescriptor][:phone] = options[:merchant_descriptor][:phone] if options[:merchant_descriptor][:phone]
+      end
+
+      def add_three_d_secure(post, payment, options)
+        three_d_secure = options[:three_d_secure]
+
+        post[:authentication] = {}
+        post[:authentication][:eci] = three_d_secure[:eci]
+        post[:authentication][:cavv] = three_d_secure[:cavv]
+        post[:authentication][:xid] = three_d_secure[:xid] if three_d_secure[:xid]
+        post[:authentication][:threeDSecureVersion] = three_d_secure[:version]
+        post[:authentication][:directoryServerTransactionId] = three_d_secure[:ds_transaction_id] unless payment.is_a?(String) || payment.brand != 'mastercard'
+      end
+
+      def add_airline_travel_details(post, options)
+        return unless options[:airline_travel_details]
+
+        post[:airlineTravelDetails] = {}
+        post[:airlineTravelDetails][:passengerName] = options[:airline_travel_details][:passenger_name] if options[:airline_travel_details][:passenger_name]
+        post[:airlineTravelDetails][:departureDate] = options[:airline_travel_details][:departure_date] if options[:airline_travel_details][:departure_date]
+        post[:airlineTravelDetails][:origin] = options[:airline_travel_details][:origin] if options[:airline_travel_details][:origin]
+        post[:airlineTravelDetails][:computerizedReservationSystem] = options[:airline_travel_details][:computerized_reservation_system] if options[:airline_travel_details][:computerized_reservation_system]
+        post[:airlineTravelDetails][:customerReferenceNumber] = options[:airline_travel_details][:customer_reference_number] if options[:airline_travel_details][:customer_reference_number]
+
+        add_ticket_details(post, options)
+        add_travel_agency_details(post, options)
+        add_trip_legs(post, options)
+      end
+
+      def add_ticket_details(post, options)
+        return unless ticket = options[:airline_travel_details][:ticket]
+
+        post[:airlineTravelDetails][:ticket] = {}
+        post[:airlineTravelDetails][:ticket][:ticketNumber] = ticket[:ticket_number] if ticket[:ticket_number]
+        post[:airlineTravelDetails][:ticket][:isRestrictedTicket] = ticket[:is_restricted_ticket] if ticket[:is_restricted_ticket]
+      end
+
+      def add_travel_agency_details(post, options)
+        return unless agency = options[:airline_travel_details][:travel_agency]
+
+        post[:airlineTravelDetails][:travelAgency] = {}
+        post[:airlineTravelDetails][:travelAgency][:name] = agency[:name] if agency[:name]
+        post[:airlineTravelDetails][:travelAgency][:code] = agency[:code] if agency[:code]
+      end
+
+      def add_trip_legs(post, options)
+        return unless trip_legs = options[:airline_travel_details][:trip_legs]
+
+        trip_legs_hash = {}
+        trip_legs.each.with_index(1) do |leg, i|
+          my_leg = "leg#{i}".to_sym
+          details = add_leg_details(my_leg, leg[1])
+
+          trip_legs_hash[my_leg] = details
+        end
+        post[:airlineTravelDetails][:tripLegs] = trip_legs_hash
+      end
+
+      def add_leg_details(obj, leg)
+        details = {}
+        add_flight_details(details, obj, leg)
+        details[:serviceClass] = leg[:service_class] if leg[:service_class]
+        details[:isStopOverAllowed] = leg[:is_stop_over_allowed] if leg[:is_stop_over_allowed]
+        details[:destination] = leg[:destination] if leg[:destination]
+        details[:fareBasis] = leg[:fare_basis] if leg[:fare_basis]
+        details[:departureDate] = leg[:departure_date] if leg[:departure_date]
+
+        details
+      end
+
+      def add_flight_details(details, obj, leg)
+        details[:flight] = {}
+        details[:flight][:carrierCode] = leg[:flight][:carrier_code] if leg[:flight][:carrier_code]
+        details[:flight][:flightNumber] = leg[:flight][:flight_number] if leg[:flight][:flight_number]
+      end
+
+      def add_split_pay_details(post, options)
+        return unless options[:split_pay]
+
+        split_pay = []
+        options[:split_pay].each do |pmnt|
+          split = {}
+
+          split[:linkedAccount] = pmnt[:linked_account]
+          split[:amount] = pmnt[:amount].to_i if pmnt[:amount]
+          split[:percent] = pmnt[:percent].to_i if pmnt[:percent]
+
+          split_pay << split
+        end
+        post[:splitpay] = split_pay
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(method, action, parameters, options)
+        url = url(action)
+        raw_response = ssl_request(method, url, post_data(parameters, options), headers)
+        response = parse(raw_response)
+        success = success_from(response)
+
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          authorization: authorization_from(action, response),
+          avs_result: AVSResult.new(code: response['avsResponse']),
+          cvv_result: CVVResult.new(response['cvvVerification']),
+          test: test?,
+          error_code: success ? nil : error_code_from(response)
+        )
+      end
+
+      def commit_for_redact(method, action, parameters, options)
+        url = url(action)
+        response = raw_ssl_request(method, url, post_data(parameters, options), headers)
+        success = true if response.code == '200'
+
+        Response.new(
+          success,
+          message: response.message
+        )
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Basic #{Base64.strict_encode64(@options[:api_key].to_s)}"
+        }
+      end
+
+      def url(action, options = {})
+        base_url = (test? ? test_url : live_url)
+
+        if action.include? 'profiles'
+          "#{base_url}/customervault/v1/#{action}"
+        else
+          "#{base_url}/cardpayments/v1/accounts/#{@options[:account_id]}/#{action}"
+        end
+      end
+
+      def success_from(response)
+        return false if response['status'] == 'FAILED' || response['error']
+
+        true
+      end
+
+      def message_from(success, response)
+        return response['status'] unless response['error']
+
+        "Error(s)- code:#{response['error']['code']}, message:#{response['error']['message']}"
+      end
+
+      def authorization_from(action, response)
+        if action == 'profiles'
+          response['cards'].first['paymentToken']
+        else
+          response['id']
+        end
+      end
+
+      def post_data(parameters = {}, options = {})
+        return unless parameters.present?
+
+        parameters[:merchantRefNum] = options[:merchant_ref_num] || SecureRandom.hex(16).to_s
+
+        parameters.to_json
+      end
+
+      def error_code_from(response)
+        return unless response['error']
+
+        response['error']['code']
+      end
+
+      def handle_response(response)
+        response.body
+      end
+    end
+  end
+end

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

@@ -208,7 +208,7 @@ module ActiveMerchant #:nodoc:
           buyer[:merchantBuyerId] = buyer_hash[:merchant_buyer_id]
           buyer[:cnpj] = buyer_hash[:cnpj] if @options[:payment_country] == 'BR'
           buyer[:emailAddress] = buyer_hash[:email]
-          buyer[:contactPhone] = (options[:billing_address][:phone] if options[:billing_address]) || (options[:shipping_address][:phone] if options[:shipping_address]) || ''
+          buyer[:contactPhone] = (options[:billing_address][:phone] if options[:billing_address]) || (options[:shipping_address][:phone_number] if options[:shipping_address]) || ''
           buyer[:shippingAddress] = shipping_address_fields(options) if options[:shipping_address]
         else
           buyer[:fullName] = payment_method.name.strip
@@ -217,7 +217,7 @@ module ActiveMerchant #:nodoc:
           buyer[:merchantBuyerId] = options[:merchant_buyer_id]
           buyer[:cnpj] = options[:cnpj] if @options[:payment_country] == 'BR'
           buyer[:emailAddress] = options[:email]
-          buyer[:contactPhone] = (options[:billing_address][:phone] if options[:billing_address]) || (options[:shipping_address][:phone] if options[:shipping_address]) || ''
+          buyer[:contactPhone] = (options[:billing_address][:phone] if options[:billing_address]) || (options[:shipping_address][:phone_number] if options[:shipping_address]) || ''
           buyer[:shippingAddress] = shipping_address_fields(options) if options[:shipping_address]
         end
         post[:transaction][:order][:buyer] = buyer
@@ -233,7 +233,7 @@ module ActiveMerchant #:nodoc:
         shipping_address[:state] = address[:state]
         shipping_address[:country] = address[:country]
         shipping_address[:postalCode] = address[:zip]
-        shipping_address[:phone] = address[:phone]
+        shipping_address[:phone] = address[:phone_number]
         shipping_address
       end
 

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

@@ -0,0 +1,253 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaywayDotComGateway < Gateway
+      self.test_url = 'https://devedgilpayway.net/PaywayWS/Payment/CreditCard'
+      self.live_url = 'https://edgilpayway.com/PaywayWS/Payment/CreditCard'
+
+      self.supported_countries = %w[US CA]
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.money_format = :cents
+
+      self.homepage_url = 'http://www.payway.com'
+      self.display_name = 'Payway Gateway'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '5012' => STANDARD_ERROR_CODE[:card_declined],
+        '5035' => STANDARD_ERROR_CODE[:invalid_number],
+        '5037' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '5045' => STANDARD_ERROR_CODE[:incorrect_zip]
+      }
+
+      # Payway to standard AVSResult codes.
+      AVS_MAPPING = {
+        'N1'  => 'I', #  No address given with order
+        'N2'  => 'I', #  Bill-to address did not pass
+        '““'  => 'R', #  AVS not performed (Blanks returned)
+        'IU'  => 'G', #  AVS not performed by Issuer
+        'ID'  => 'S', #  Issuer does not participate in AVS
+        'IE'  => 'E', #  Edit Error - AVS data is invalid
+        'IS'  => 'R', #  System unavailable or time-out
+        'IB'  => 'B', #  Street address match. Postal code not verified due to incompatible formats (both were sent).
+        'IC'  => 'C', #  Street address and postal code not verified due to incompatible format (both were sent).
+        'IP'  => 'P', #  Postal code match. Street address not verified due to incompatible formats (both were sent).
+        'A1'  => 'K', #  Accountholder name matches
+        'A3'  => 'V', #  Accountholder name, billing address and postal code.
+        'A4'  => 'L', #  Accountholder name and billing postal code match
+        'A7'  => 'O', #  Accountholder name and billing address match
+        'B3'  => 'H', #  Accountholder name incorrect, billing address and postal code match
+        'B4'  => 'F', #  Accountholder name incorrect, billing postal code matches
+        'B7'  => 'T', #  Accountholder name incorrect, billing address matches
+        'B8'  => 'N', #  Accountholder name, billing address and postal code are all incorrect
+        '??'  => 'R', #  A double question mark symbol indicates an unrecognized response from association
+        'I1'  => 'X', #  Zip code +4 and Address Match
+        'I2'  => 'W', #  Zip code +4 Match
+        'I3'  => 'Y', #  Zip code and Address Match
+        'I4'  => 'Z', #  Zip code Match
+        'I5'  => 'M', #  +4 and Address Match
+        'I6'  => 'W', #  +4 Match
+        'I7'  => 'A', #  Address Match
+        'I8'  => 'C', #  No Match
+      }
+
+      PAYWAY_WS_SUCCESS = '5000'
+
+      SCRUB_PATTERNS = [
+        %r(("password\\?":\\?")[^\\]+),
+        %r(("fsv\\?":\\?")\d+),
+        %r(("fsv\\?": \\?")\d+),
+        %r(("accountNumber\\?":\\?")\d+),
+        %r(("accountNumber\\?": \\?")[^\\]+),
+        %r(("Invalid account number: )\d+)
+      ].freeze
+
+      SCRUB_REPLACEMENT = '\1[FILTERED]'
+
+      def initialize(options = {})
+        requires!(options, :login, :password, :company_id, :source_id)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_payment(post, payment, options)
+        add_card_transaction_details(post, money, options)
+        add_address(post, payment, options)
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_payment(post, payment, options)
+        add_card_transaction_details(post, money, options)
+        add_address(post, payment, options)
+
+        commit('authorize', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_transaction_name(post, authorization, options)
+
+        commit('capture', post)
+      end
+
+      def credit(money, payment, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_payment(post, payment, options)
+        add_card_transaction_details(post, money, options)
+        add_address(post, payment, options)
+
+        commit('credit', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_transaction_name(post, authorization, options)
+
+        commit('void', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        SCRUB_PATTERNS.inject(transcript) do |text, pattern|
+          text.gsub(pattern, SCRUB_REPLACEMENT)
+        end
+      end
+
+      private
+
+      def add_common(post, options)
+        post[:userName] = @options[:login]
+        post[:password] = @options[:password]
+        post[:companyId] = @options[:company_id]
+        post[:cardTransaction] = {}
+        post[:cardTransaction][:sourceId] = @options[:source_id]
+      end
+
+      def add_address(post, payment, options)
+        post[:cardAccount] ||= {}
+        address = options[:billing_address] || options[:address] || {}
+        first_name, last_name = split_names(address[:name])
+        full_address = "#{address[:address1]} #{address[:address2]}".strip
+        phone = address[:phone] || address[:phone_number]
+
+        post[:cardAccount][:firstName] = first_name      if first_name
+        post[:cardAccount][:lastName]  = last_name       if last_name
+        post[:cardAccount][:address]   = full_address    if full_address
+        post[:cardAccount][:city]      = address[:city]  if address[:city]
+        post[:cardAccount][:state]     = address[:state] if address[:state]
+        post[:cardAccount][:zip]       = address[:zip]   if address[:zip]
+        post[:cardAccount][:phone]     = phone           if phone
+      end
+
+      def add_card_transaction_details(post, money, options)
+        post[:cardTransaction][:amount] = amount(money)
+        eci_type = options[:eci_type].nil? ? '1' : options[:eci_type]
+        post[:cardTransaction][:eciType] = eci_type
+        post[:cardTransaction][:processorSoftDescriptor] = options[:processor_soft_descriptor] if options[:processor_soft_descriptor]
+        post[:cardTransaction][:tax] = options[:tax] if options[:tax]
+      end
+
+      def add_card_transaction_name(post, identifier, options)
+        post[:cardTransaction][:name] = identifier
+      end
+
+      def add_card_payment(post, payment, options)
+        # credit_card
+        post[:accountInputMode] = 'primaryAccountNumber'
+
+        post[:cardAccount] ||= {}
+        post[:cardAccount][:accountNumber]  = payment.number
+        post[:cardAccount][:fsv]            = payment.verification_value
+        post[:cardAccount][:expirationDate] = expdate(payment)
+        post[:cardAccount][:email]          = options[:email] if options[:email]
+      end
+
+      def expdate(credit_card)
+        year  = format(credit_card.year, :four_digits)
+        month = format(credit_card.month, :two_digits)
+
+        month + year
+      end
+
+      def parse(body)
+        body.blank? ? {} : JSON.parse(body)
+      end
+
+      def commit(action, parameters)
+        parameters[:request] = action
+
+        url = (test? ? test_url : live_url)
+        payload = parameters.to_json unless parameters.nil?
+
+        response =
+          begin
+            parse(ssl_request(:post, url, payload, headers))
+          rescue ResponseError => e
+            return Response.new(false, 'Invalid Login') if e.response.code == '401'
+
+            parse(e.response.body)
+          end
+
+        success = success_from(response)
+        avs_result_code = response['cardTransaction'].nil? || response['cardTransaction']['addressVerificationResults'].nil? ? '' : response['cardTransaction']['addressVerificationResults']
+        avs_result = AVSResult.new(code: AVS_MAPPING[avs_result_code])
+        cvv_result = CVVResult.new(response['cardTransaction']['fraudSecurityResults']) if response['cardTransaction'] && response['cardTransaction']['fraudSecurityResults']
+
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          test: test?,
+          error_code: error_code_from(response),
+          authorization: authorization_from(response),
+          avs_result: avs_result,
+          cvv_result: cvv_result
+        )
+      end
+
+      def success_from(response)
+        response['paywayCode'] == PAYWAY_WS_SUCCESS
+      end
+
+      def error_code_from(response)
+        return '' if success_from(response)
+
+        error = !STANDARD_ERROR_CODE_MAPPING[response['paywayCode']].nil? ? STANDARD_ERROR_CODE_MAPPING[response['paywayCode']] : STANDARD_ERROR_CODE[:processing_error]
+        return error
+      end
+
+      def message_from(success, response)
+        return '' if response['paywayCode'].nil?
+
+        return response['paywayCode'] + '-' + 'success' if success
+
+        response['paywayCode'] + '-' + response['paywayMessage']
+      end
+
+      def authorization_from(response)
+        return '' if !success_from(response) || response['cardTransaction'].nil?
+
+        response['cardTransaction']['name']
+      end
+
+      def headers
+        {
+          'Accept'        => 'application/json',
+          'Content-type'  => 'application/json'
+        }
+      end
+    end
+  end
+end