activemerchant 1.42.6 → 1.90.0

data/lib/active_merchant/billing/gateway.rb

@@ -10,19 +10,16 @@ module ActiveMerchant #:nodoc:
     #
     # The standard list of gateway functions that most concrete gateway subclasses implement is:
     #
-    # * <tt>purchase(money, creditcard, options = {})</tt>
-    # * <tt>authorize(money, creditcard, options = {})</tt>
+    # * <tt>purchase(money, credit_card, options = {})</tt>
+    # * <tt>authorize(money, credit_card, options = {})</tt>
     # * <tt>capture(money, authorization, options = {})</tt>
     # * <tt>void(identification, options = {})</tt>
-    # * <tt>credit(money, identification, options = {})</tt>
-    #
-    # Some gateways include features for recurring billing
-    #
-    # * <tt>recurring(money, creditcard, options = {})</tt>
+    # * <tt>refund(money, identification, options = {})</tt>
+    # * <tt>verify(credit_card, options = {})</tt>
     #
     # Some gateways also support features for storing credit cards:
     #
-    # * <tt>store(creditcard, options = {})</tt>
+    # * <tt>store(credit_card, options = {})</tt>
     # * <tt>unstore(identification, options = {})</tt>
     #
     # === Gateway Options
@@ -51,19 +48,55 @@ module ActiveMerchant #:nodoc:
     # * <tt>:zip</tt> - The zip or postal code of the customer.
     # * <tt>:phone</tt> - The phone number of the customer.
     #
-    # == Implmenting new gateways
+    # == Implementing new gateways
     #
-    # See the {ActiveMerchant Guide to Contributing}[https://github.com/Shopify/active_merchant/wiki/Contributing]
+    # See the {ActiveMerchant Guide to Contributing}[https://github.com/activemerchant/active_merchant/wiki/Contributing]
     #
     class Gateway
       include PostsData
-      include RequiresParameters
       include CreditCardFormatting
-      include Utils
 
-      DEBIT_CARDS = [ :switch, :solo ]
-      CURRENCIES_WITHOUT_FRACTIONS = [ 'BIF', 'BYR', 'CLP', 'CVE', 'DJF', 'GNF', 'HUF', 'ISK', 'JPY', 'KMF', 'KRW', 'PYG', 'RWF', 'TWD', 'UGX', 'VND', 'VUV', 'XAF', 'XOF', 'XPF' ]
-      CREDIT_DEPRECATION_MESSAGE = "Support for using credit to refund existing transactions is deprecated and will be removed from a future release of ActiveMerchant. Please use the refund method instead."
+      CREDIT_DEPRECATION_MESSAGE = 'Support for using credit to refund existing transactions is deprecated and will be removed from a future release of ActiveMerchant. Please use the refund method instead.'
+      RECURRING_DEPRECATION_MESSAGE = 'Recurring functionality in ActiveMerchant is deprecated and will be removed in a future version. Please contact the ActiveMerchant maintainers if you have an interest in taking ownership of a separate gem that continues support for it.'
+
+      # == Standardized Error Codes
+      #
+      # :incorrect_number - Card number does not comply with ISO/IEC 7812 numbering standard
+      # :invalid_number - Card number was not matched by processor
+      # :invalid_expiry_date - Expiry date does not match correct formatting
+      # :invalid_cvc - Security codes does not match correct format (3-4 digits)
+      # :expired_card - Card number is expired
+      # :incorrect_cvc - Security code was not matched by the processor
+      # :incorrect_zip - Zip code is not in correct format
+      # :incorrect_address - Billing address info was not matched by the processor
+      # :incorrect_pin - Card PIN is incorrect
+      # :card_declined - Card number declined by processor
+      # :processing_error - Processor error
+      # :call_issuer - Transaction requires voice authentication, call issuer
+      # :pickup_card - Issuer requests that you pickup the card from merchant
+      # :test_mode_live_card - Card was declined. Request was in test mode, but used a non test card.
+      # :unsupported_feature - Transaction failed due to gateway or merchant
+      #                        configuration not supporting a feature used, such
+      #                        as network tokenization.
+
+      STANDARD_ERROR_CODE = {
+        :incorrect_number => 'incorrect_number',
+        :invalid_number => 'invalid_number',
+        :invalid_expiry_date => 'invalid_expiry_date',
+        :invalid_cvc => 'invalid_cvc',
+        :expired_card => 'expired_card',
+        :incorrect_cvc => 'incorrect_cvc',
+        :incorrect_zip => 'incorrect_zip',
+        :incorrect_address => 'incorrect_address',
+        :incorrect_pin => 'incorrect_pin',
+        :card_declined => 'card_declined',
+        :processing_error => 'processing_error',
+        :call_issuer => 'call_issuer',
+        :pickup_card => 'pick_up_card',
+        :config_error => 'config_error',
+        :test_mode_live_card => 'test_mode_live_card',
+        :unsupported_feature => 'unsupported_feature',
+      }
 
       cattr_reader :implementations
       @@implementations = []
@@ -73,6 +106,10 @@ module ActiveMerchant #:nodoc:
         @@implementations << subclass
       end
 
+      def generate_unique_id
+        SecureRandom.hex(16)
+      end
+
       # The format of the amounts used by the gateway
       # :dollars => '12.50'
       # :cents => '1250'
@@ -82,14 +119,14 @@ module ActiveMerchant #:nodoc:
       # The default currency for the transactions if no currency is provided
       class_attribute :default_currency
 
-      # The countries of merchants the gateway supports
-      class_attribute :supported_countries
-      self.supported_countries = []
-
       # The supported card types for the gateway
       class_attribute :supported_cardtypes
       self.supported_cardtypes = []
 
+      class_attribute :currencies_without_fractions, :currencies_with_three_decimal_places
+      self.currencies_without_fractions = %w(BIF BYR CLP CVE DJF GNF ISK JPY KMF KRW PYG RWF UGX VND VUV XAF XOF XPF)
+      self.currencies_with_three_decimal_places = %w()
+
       class_attribute :homepage_url
       class_attribute :display_name
 
@@ -101,8 +138,8 @@ module ActiveMerchant #:nodoc:
 
       # The application making the calls to the gateway
       # Useful for things like the PayPal build notation (BN) id fields
-      superclass_delegating_accessor :application_id
-      self.application_id = 'ActiveMerchant'
+      class_attribute :application_id, instance_writer: false
+      self.application_id = nil
 
       attr_reader :options
 
@@ -116,6 +153,23 @@ module ActiveMerchant #:nodoc:
         result.to_s.downcase
       end
 
+      def self.supported_countries=(country_codes)
+        country_codes.each do |country_code|
+          unless ActiveMerchant::Country.find(country_code)
+            raise ActiveMerchant::InvalidCountryCodeError, "No country could be found for the country #{country_code}"
+          end
+        end
+        @supported_countries = country_codes.dup
+      end
+
+      def self.supported_countries
+        @supported_countries ||= []
+      end
+
+      def supported_countries
+        self.class.supported_countries
+      end
+
       def card_brand(source)
         self.class.card_brand(source)
       end
@@ -133,6 +187,51 @@ module ActiveMerchant #:nodoc:
         (@options.has_key?(:test) ? @options[:test] : Base.test?)
       end
 
+      # Does this gateway know how to scrub sensitive information out of HTTP transcripts?
+      def supports_scrubbing?
+        false
+      end
+
+      def scrub(transcript)
+        raise 'This gateway does not support scrubbing.'
+      end
+
+      def supports_network_tokenization?
+        false
+      end
+
+      protected # :nodoc: all
+
+      def normalize(field)
+        case field
+        when 'true'   then true
+        when 'false'  then false
+        when ''       then nil
+        when 'null'   then nil
+        else field
+        end
+      end
+
+      def user_agent
+        @@ua ||= JSON.dump({
+          :bindings_version => ActiveMerchant::VERSION,
+          :lang => 'ruby',
+          :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+          :platform => RUBY_PLATFORM,
+          :publisher => 'active_merchant'
+        })
+      end
+
+      def strip_invalid_xml_chars(xml)
+        begin
+          REXML::Document.new(xml)
+        rescue REXML::ParseException
+          xml = xml.gsub(/&(?!(?:[a-z]+|#[0-9]+|x[a-zA-Z0-9]+);)/, '&amp;')
+        end
+
+        xml
+      end
+
       private # :nodoc: all
 
       def name
@@ -142,10 +241,10 @@ module ActiveMerchant #:nodoc:
       def amount(money)
         return nil if money.nil?
         cents = if money.respond_to?(:cents)
-          deprecated "Support for Money objects is deprecated and will be removed from a future release of ActiveMerchant. Please use an Integer value in cents"
-          money.cents
-        else
-          money
+                  ActiveMerchant.deprecated 'Support for Money objects is deprecated and will be removed from a future release of ActiveMerchant. Please use an Integer value in cents'
+                  money.cents
+                else
+                  money
         end
 
         if money.is_a?(String)
@@ -155,33 +254,66 @@ module ActiveMerchant #:nodoc:
         if self.money_format == :cents
           cents.to_s
         else
-          sprintf("%.2f", cents.to_f / 100)
+          sprintf('%.2f', cents.to_f / 100)
         end
       end
 
+      def non_fractional_currency?(currency)
+        self.currencies_without_fractions.include?(currency.to_s)
+      end
+
+      def three_decimal_currency?(currency)
+        self.currencies_with_three_decimal_places.include?(currency.to_s)
+      end
+
       def localized_amount(money, currency)
         amount = amount(money)
 
-        return amount unless non_fractional_currency?(currency)
-
-        if self.money_format == :cents
-          sprintf("%.0f", amount.to_f / 100)
-        else
-          amount.split('.').first
+        return amount unless non_fractional_currency?(currency) || three_decimal_currency?(currency)
+        if non_fractional_currency?(currency)
+          if self.money_format == :cents
+            sprintf('%.0f', amount.to_f / 100)
+          else
+            amount.split('.').first
+          end
+        elsif three_decimal_currency?(currency)
+          if self.money_format == :cents
+            amount.to_s
+          else
+            sprintf('%.3f', (amount.to_f / 10))
+          end
         end
       end
 
-      def non_fractional_currency?(currency)
-        CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s)
-      end
-
       def currency(money)
         money.respond_to?(:currency) ? money.currency : self.default_currency
       end
 
-      def requires_start_date_or_issue_number?(credit_card)
-        return false if card_brand(credit_card).blank?
-        DEBIT_CARDS.include?(card_brand(credit_card).to_sym)
+      def truncate(value, max_size)
+        return nil unless value
+        value.to_s[0, max_size]
+      end
+
+      def split_names(full_name)
+        names = (full_name || '').split
+        return [nil, nil] if names.size == 0
+
+        last_name  = names.pop
+        first_name = names.join(' ')
+        [first_name, last_name]
+      end
+
+      def requires!(hash, *params)
+        params.each do |param|
+          if param.is_a?(Array)
+            raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first)
+
+            valid_options = param[1..-1]
+            raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:words_connector => 'or')}") unless valid_options.include?(hash[param.first])
+          else
+            raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,380 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class AdyenGateway < Gateway
+
+      # we recommend setting up merchant-specific endpoints.
+      # https://docs.adyen.com/developers/api-manual#apiendpoints
+      self.test_url = 'https://pal-test.adyen.com/pal/servlet/Payment/v18'
+      self.live_url = 'https://pal-live.adyen.com/pal/servlet/Payment/v18'
+
+      self.supported_countries = ['AT', 'AU', 'BE', 'BG', 'BR', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GB', 'GI', 'GR', 'HK', 'HU', 'IE', 'IS', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'MX', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SG', 'SK', 'SI', 'US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb, :dankort, :maestro,  :discover]
+
+      self.money_format = :cents
+
+      self.homepage_url = 'https://www.adyen.com/'
+      self.display_name = 'Adyen'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '101' => STANDARD_ERROR_CODE[:incorrect_number],
+        '103' => STANDARD_ERROR_CODE[:invalid_cvc],
+        '131' => STANDARD_ERROR_CODE[:incorrect_address],
+        '132' => STANDARD_ERROR_CODE[:incorrect_address],
+        '133' => STANDARD_ERROR_CODE[:incorrect_address],
+        '134' => STANDARD_ERROR_CODE[:incorrect_address],
+        '135' => STANDARD_ERROR_CODE[:incorrect_address],
+      }
+
+      def initialize(options={})
+        requires!(options, :username, :password, :merchant_account)
+        @username, @password, @merchant_account = options.values_at(:username, :password, :merchant_account)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        if options[:execute_threed]
+          authorize(money, payment, options)
+        else
+          MultiResponse.run do |r|
+            r.process { authorize(money, payment, options) }
+            r.process { capture(money, r.authorization, options) }
+          end
+        end
+      end
+
+      def authorize(money, payment, options={})
+        requires!(options, :order_id)
+        post = init_post(options)
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_extra_data(post, payment, options)
+        add_shopper_interaction(post, payment, options)
+        add_address(post, options)
+        add_installments(post, options) if options[:installments]
+        add_3ds(post, options) if options[:execute_threed]
+        commit('authorise', post)
+      end
+
+      def capture(money, authorization, options={})
+        post = init_post(options)
+        add_invoice_for_modification(post, money, options)
+        add_reference(post, authorization, options)
+        commit('capture', post)
+      end
+
+      def refund(money, authorization, options={})
+        post = init_post(options)
+        add_invoice_for_modification(post, money, options)
+        add_original_reference(post, authorization, options)
+        commit('refund', post)
+      end
+
+      def void(authorization, options={})
+        post = init_post(options)
+        add_reference(post, authorization, options)
+        commit('cancel', post)
+      end
+
+      def store(credit_card, options={})
+        requires!(options, :order_id)
+        post = init_post(options)
+        add_invoice(post, 0, options)
+        add_payment(post, credit_card)
+        add_extra_data(post, credit_card, options)
+        add_recurring_contract(post, options)
+        add_address(post, options)
+        commit('authorise', post)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(0, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r(("number\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cvc\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cavv\\?":\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      AVS_MAPPING = {
+        '0'  => 'R',  # Unknown
+        '1'  => 'A',	# Address matches, postal code doesn't
+        '2'  => 'N',	# Neither postal code nor address match
+        '3'  => 'R',	# AVS unavailable
+        '4'  => 'E',	# AVS not supported for this card type
+        '5'  => 'U',	# No AVS data provided
+        '6'  => 'Z',	# Postal code matches, address doesn't match
+        '7'  => 'D',	# Both postal code and address match
+        '8'  => 'U',	# Address not checked, postal code unknown
+        '9'  => 'B',	# Address matches, postal code unknown
+        '10' => 'N',	# Address doesn't match, postal code unknown
+        '11' => 'U',	# Postal code not checked, address unknown
+        '12' => 'B',	# Address matches, postal code not checked
+        '13' => 'U',	# Address doesn't match, postal code not checked
+        '14' => 'P',	# Postal code matches, address unknown
+        '15' => 'P',	# Postal code matches, address not checked
+        '16' => 'N',	# Postal code doesn't match, address unknown
+        '17' => 'U',  # Postal code doesn't match, address not checked
+        '18' => 'I'	  # Neither postal code nor address were checked
+      }
+
+      CVC_MAPPING = {
+        '0' => 'P', # Unknown
+        '1' => 'M', # Matches
+        '2' => 'N', # Does not match
+        '3' => 'P', # Not checked
+        '4' => 'S', # No CVC/CVV provided, but was required
+        '5' => 'U', # Issuer not certifed by CVC/CVV
+        '6' => 'P'  # No CVC/CVV provided
+      }
+
+      NETWORK_TOKENIZATION_CARD_SOURCE = {
+        'apple_pay' => 'applepay',
+        'android_pay' => 'androidpay',
+        'google_pay' => 'paywithgoogle'
+      }
+
+      def add_extra_data(post, payment, options)
+        post[:shopperEmail] = options[:shopper_email] if options[:shopper_email]
+        post[:shopperIP] = options[:shopper_ip] if options[:shopper_ip]
+        post[:shopperReference] = options[:shopper_reference] if options[:shopper_reference]
+        post[:fraudOffset] = options[:fraud_offset] if options[:fraud_offset]
+        post[:selectedBrand] = options[:selected_brand] if options[:selected_brand]
+        post[:selectedBrand] ||= NETWORK_TOKENIZATION_CARD_SOURCE[payment.source.to_s] if payment.is_a?(NetworkTokenizationCreditCard)
+        post[:deliveryDate] = options[:delivery_date] if options[:delivery_date]
+        post[:merchantOrderReference] = options[:merchant_order_reference] if options[:merchant_order_reference]
+        post[:additionalData] ||= {}
+        post[:additionalData][:overwriteBrand] = normalize(options[:overwrite_brand]) if options[:overwrite_brand]
+        post[:additionalData][:customRoutingFlag] = options[:custom_routing_flag] if options[:custom_routing_flag]
+        post[:additionalData]['paymentdatasource.type'] = NETWORK_TOKENIZATION_CARD_SOURCE[payment.source.to_s] if payment.is_a?(NetworkTokenizationCreditCard)
+        add_risk_data(post, options)
+      end
+
+      def add_risk_data(post, options)
+        risk_data = {}
+        risk_data.merge!(options[:risk_data]) if options[:risk_data]
+
+        post[:additionalData][:riskData] = risk_data unless risk_data.empty?
+      end
+
+      def add_shopper_interaction(post, payment, options={})
+        if (payment.respond_to?(:verification_value) && payment.verification_value) || payment.is_a?(NetworkTokenizationCreditCard)
+          shopper_interaction = 'Ecommerce'
+        else
+          shopper_interaction = 'ContAuth'
+        end
+
+        post[:shopperInteraction] = options[:shopper_interaction] || shopper_interaction
+      end
+
+      def add_address(post, options)
+        return unless post[:card]&.kind_of?(Hash)
+        if (address = options[:billing_address] || options[:address]) && address[:country]
+          post[:card][:billingAddress] = {}
+          post[:card][:billingAddress][:street] = address[:address1] || 'N/A'
+          post[:card][:billingAddress][:houseNumberOrName] = address[:address2] || 'N/A'
+          post[:card][:billingAddress][:postalCode] = address[:zip] if address[:zip]
+          post[:card][:billingAddress][:city] = address[:city] || 'N/A'
+          post[:card][:billingAddress][:stateOrProvince] = address[:state] if address[:state]
+          post[:card][:billingAddress][:country] = address[:country] if address[:country]
+        end
+      end
+
+      def add_invoice(post, money, options)
+        amount = {
+          value: amount(money),
+          currency: options[:currency] || currency(money)
+        }
+        post[:amount] = amount
+        post[:recurringProcessingModel] = options[:recurring_processing_model] if options[:recurring_processing_model]
+      end
+
+      def add_invoice_for_modification(post, money, options)
+        amount = {
+          value: amount(money),
+          currency: options[:currency] || currency(money)
+        }
+        post[:modificationAmount] = amount
+      end
+
+      def add_payment(post, payment)
+        if payment.is_a?(String)
+          _, _, recurring_detail_reference = payment.split('#')
+          post[:selectedRecurringDetailReference] = recurring_detail_reference
+          add_recurring_contract(post, options)
+        else
+          add_mpi_data_for_network_tokenization_card(post, payment) if payment.is_a?(NetworkTokenizationCreditCard)
+          add_card(post, payment)
+        end
+      end
+
+      def add_card(post, credit_card)
+        card = {
+          expiryMonth: credit_card.month,
+          expiryYear: credit_card.year,
+          holderName: credit_card.name,
+          number: credit_card.number,
+          cvc: credit_card.verification_value
+        }
+
+        card.delete_if { |k, v| v.blank? }
+        card[:holderName] ||= 'Not Provided' if credit_card.is_a?(NetworkTokenizationCreditCard)
+        requires!(card, :expiryMonth, :expiryYear, :holderName, :number)
+        post[:card] = card
+      end
+
+      def add_reference(post, authorization, options = {})
+        _, psp_reference, _ = authorization.split('#')
+        post[:originalReference] = single_reference(authorization) || psp_reference
+      end
+
+      def add_original_reference(post, authorization, options = {})
+        original_psp_reference, _, _ = authorization.split('#')
+        post[:originalReference] = single_reference(authorization) || original_psp_reference
+      end
+
+      def add_mpi_data_for_network_tokenization_card(post, payment)
+        post[:mpiData] = {}
+        post[:mpiData][:authenticationResponse] = 'Y'
+        post[:mpiData][:cavv] = payment.payment_cryptogram
+        post[:mpiData][:directoryResponse] = 'Y'
+        post[:mpiData][:eci] = payment.eci || '07'
+      end
+
+      def single_reference(authorization)
+        authorization if !authorization.include?('#')
+      end
+
+      def add_recurring_contract(post, options = {})
+        recurring = {
+          contract: 'RECURRING'
+        }
+
+        post[:recurring] = recurring
+      end
+
+      def add_installments(post, options)
+        post[:installments] = {
+          value: options[:installments]
+        }
+      end
+
+      def add_3ds(post, options)
+        post[:additionalData] = { executeThreeD: 'true' }
+        post[:browserInfo] = { userAgent: options[:user_agent], acceptHeader: options[:accept_header] }
+      end
+
+      def parse(body)
+        return {} if body.blank?
+        JSON.parse(body)
+      end
+
+      def commit(action, parameters)
+        begin
+          raw_response = ssl_post("#{url}/#{action}", post_data(action, parameters), request_headers)
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = parse(raw_response)
+        end
+        success = success_from(action, response)
+        Response.new(
+          success,
+          message_from(action, response),
+          response,
+          authorization: authorization_from(action, parameters, response),
+          test: test?,
+          error_code: success ? nil : error_code_from(response),
+          avs_result: AVSResult.new(:code => avs_code_from(response)),
+          cvv_result: CVVResult.new(cvv_result_from(response))
+        )
+      end
+
+      def avs_code_from(response)
+        AVS_MAPPING[response['additionalData']['avsResult'][0..1].strip] if response.dig('additionalData', 'avsResult')
+      end
+
+      def cvv_result_from(response)
+        CVC_MAPPING[response['additionalData']['cvcResult'][0]] if response.dig('additionalData', 'cvcResult')
+      end
+
+      def url
+        if test?
+          test_url
+        elsif @options[:subdomain]
+          "https://#{@options[:subdomain]}-pal-live.adyenpayments.com/pal/servlet/Payment/v18"
+        else
+          live_url
+        end
+      end
+
+      def basic_auth
+        Base64.strict_encode64("#{@username}:#{@password}")
+      end
+
+      def request_headers
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Basic #{basic_auth}"
+        }
+      end
+
+      def success_from(action, response)
+        case action.to_s
+        when 'authorise', 'authorise3d'
+          ['Authorised', 'Received', 'RedirectShopper'].include?(response['resultCode'])
+        when 'capture', 'refund', 'cancel'
+          response['response'] == "[#{action}-received]"
+        else
+          false
+        end
+      end
+
+      def message_from(action, response)
+        return authorize_message_from(response) if action.to_s == 'authorise'
+        response['response'] || response['message']
+      end
+
+      def authorize_message_from(response)
+        if response['refusalReason'] && response['additionalData'] && response['additionalData']['refusalReasonRaw']
+          "#{response['refusalReason']} | #{response['additionalData']['refusalReasonRaw']}"
+        else
+          response['refusalReason'] || response['resultCode'] || response['message']
+        end
+      end
+
+      def authorization_from(action, parameters, response)
+        return nil if response['pspReference'].nil?
+        recurring = response['additionalData']['recurring.recurringDetailReference'] if response['additionalData']
+        "#{parameters[:originalReference]}##{response['pspReference']}##{recurring}"
+      end
+
+      def init_post(options = {})
+        post = {}
+        post[:merchantAccount] = options[:merchant_account] || @merchant_account
+        post[:reference] = options[:order_id] if options[:order_id]
+        post
+      end
+
+      def post_data(action, parameters = {})
+        JSON.generate(parameters)
+      end
+
+      def error_code_from(response)
+        STANDARD_ERROR_CODE_MAPPING[response['errorCode']]
+      end
+    end
+  end
+end