activemerchant 1.90.0 → 1.99.0

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

@@ -0,0 +1,271 @@
+require 'active_support/core_ext/hash/slice'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # This gateway uses the current Stripe {Payment Intents API}[https://stripe.com/docs/api/payment_intents].
+    # For the legacy API, see the Stripe gateway
+    class StripePaymentIntentsGateway < StripeGateway
+
+      self.supported_countries = %w(AT AU BE BR CA CH DE DK EE ES FI FR GB GR HK IE IT JP LT LU LV MX NL NO NZ PL PT SE SG SI SK US)
+
+      ALLOWED_METHOD_STATES = %w[automatic manual].freeze
+      ALLOWED_CANCELLATION_REASONS = %w[duplicate fraudulent requested_by_customer abandoned].freeze
+      CREATE_INTENT_ATTRIBUTES = %i[description statement_descriptor receipt_email save_payment_method]
+      CONFIRM_INTENT_ATTRIBUTES = %i[receipt_email return_url save_payment_method setup_future_usage off_session]
+      UPDATE_INTENT_ATTRIBUTES = %i[description statement_descriptor receipt_email setup_future_usage]
+      DEFAULT_API_VERSION = '2019-05-16'
+
+      def create_intent(money, payment_method, options = {})
+        post = {}
+        add_amount(post, money, options, true)
+        add_capture_method(post, options)
+        add_confirmation_method(post, options)
+        add_customer(post, options)
+        add_payment_method_token(post, payment_method, options)
+        add_metadata(post, options)
+        add_return_url(post, options)
+        add_connected_account(post, options)
+        add_shipping_address(post, options)
+        setup_future_usage(post, options)
+        add_exemption(post, options)
+
+        CREATE_INTENT_ATTRIBUTES.each do |attribute|
+          add_whitelisted_attribute(post, options, attribute)
+        end
+
+        commit(:post, 'payment_intents', post, options)
+      end
+
+      def show_intent(intent_id, options)
+        commit(:get, "payment_intents/#{intent_id}", nil, options)
+      end
+
+      def confirm_intent(intent_id, payment_method, options = {})
+        post = {}
+        add_payment_method_token(post, payment_method, options)
+        CONFIRM_INTENT_ATTRIBUTES.each do |attribute|
+          add_whitelisted_attribute(post, options, attribute)
+        end
+
+        commit(:post, "payment_intents/#{intent_id}/confirm", post, options)
+      end
+
+      def create_payment_method(payment_method, options = {})
+        post = {}
+        post[:type] = 'card'
+        post[:card] = {}
+        post[:card][:number] = payment_method.number
+        post[:card][:exp_month] = payment_method.month
+        post[:card][:exp_year] = payment_method.year
+        post[:card][:cvc] = payment_method.verification_value if payment_method.verification_value
+        add_billing_address(post, options)
+
+        commit(:post, 'payment_methods', post, options)
+      end
+
+      def update_intent(money, intent_id, payment_method, options = {})
+        post = {}
+        post[:amount] = money if money
+
+        add_payment_method_token(post, payment_method, options)
+        add_payment_method_types(post, options)
+        add_customer(post, options)
+        add_metadata(post, options)
+        add_shipping_address(post, options)
+        add_connected_account(post, options)
+
+        UPDATE_INTENT_ATTRIBUTES.each do |attribute|
+          add_whitelisted_attribute(post, options, attribute)
+        end
+
+        commit(:post, "payment_intents/#{intent_id}", post, options)
+      end
+
+      def authorize(money, payment_method, options = {})
+        create_intent(money, payment_method, options.merge!(confirm: true, capture_method: 'manual'))
+      end
+
+      def purchase(money, payment_method, options = {})
+        create_intent(money, payment_method, options.merge!(confirm: true, capture_method: 'automatic'))
+      end
+
+      def capture(money, intent_id, options = {})
+        post = {}
+        post[:amount_to_capture] = money
+        if options[:transfer_amount]
+          post[:transfer_data] = {}
+          post[:transfer_data][:amount] = options[:transfer_amount]
+        end
+        post[:application_fee_amount] = options[:application_fee] if options[:application_fee]
+        commit(:post, "payment_intents/#{intent_id}/capture", post, options)
+      end
+
+      def void(intent_id, options = {})
+        post = {}
+        post[:cancellation_reason] = options[:cancellation_reason] if ALLOWED_CANCELLATION_REASONS.include?(options[:cancellation_reason])
+        commit(:post, "payment_intents/#{intent_id}/cancel", post, options)
+      end
+
+      def refund(money, intent_id, options = {})
+        intent = commit(:get, "payment_intents/#{intent_id}", nil, options)
+        charge_id = intent.params.dig('charges', 'data')[0].dig('id')
+        super(money, charge_id, options)
+      end
+
+      # Note: Not all payment methods are currently supported by the {Payment Methods API}[https://stripe.com/docs/payments/payment-methods]
+      # Current implementation will create a PaymentMethod object if the method is a token or credit card
+      # All other types will default to legacy Stripe store
+      def store(payment_method, options = {})
+        params = {}
+        post = {}
+
+        # If customer option is provided, create a payment method and attach to customer id
+        # Otherwise, create a customer, then attach
+        if payment_method.is_a?(StripePaymentToken) || payment_method.is_a?(ActiveMerchant::Billing::CreditCard)
+          add_payment_method_token(params, payment_method, options)
+          if options[:customer]
+            customer_id = options[:customer]
+          else
+            post[:validate] = options[:validate] unless options[:validate].nil?
+            post[:description] = options[:description] if options[:description]
+            post[:email] = options[:email] if options[:email]
+            customer = commit(:post, 'customers', post, options)
+            customer_id = customer.params['id']
+          end
+          commit(:post, "payment_methods/#{params[:payment_method]}/attach", { customer: customer_id }, options)
+        else
+          super(payment, options)
+        end
+      end
+
+      def unstore(identification, options = {}, deprecated_options = {})
+        if identification.include?('pm_')
+          _, payment_method = identification.split('|')
+          commit(:post, "payment_methods/#{payment_method}/detach", nil, options)
+        else
+          super(identification, options, deprecated_options)
+        end
+      end
+
+      private
+
+      def add_whitelisted_attribute(post, options, attribute)
+        post[attribute] = options[attribute] if options[attribute]
+        post
+      end
+
+      def add_capture_method(post, options)
+        capture_method = options[:capture_method].to_s
+        post[:capture_method] = capture_method if ALLOWED_METHOD_STATES.include?(capture_method)
+        post
+      end
+
+      def add_confirmation_method(post, options)
+        confirmation_method = options[:confirmation_method].to_s
+        post[:confirmation_method] = confirmation_method if ALLOWED_METHOD_STATES.include?(confirmation_method)
+        post
+      end
+
+      def add_customer(post, options)
+        customer = options[:customer].to_s
+        post[:customer] = customer if customer.start_with?('cus_')
+        post
+      end
+
+      def add_return_url(post, options)
+        return unless options[:confirm]
+        post[:confirm] = options[:confirm]
+        post[:return_url] = options[:return_url] if options[:return_url]
+        post
+      end
+
+      def add_payment_method_token(post, payment_method, options)
+        return if payment_method.nil?
+
+        if payment_method.is_a?(ActiveMerchant::Billing::CreditCard)
+          p = create_payment_method(payment_method, options)
+          payment_method = p.params['id']
+        end
+
+        if payment_method.is_a?(StripePaymentToken)
+          post[:payment_method] = payment_method.payment_data['id']
+        elsif payment_method.is_a?(String)
+          if payment_method.include?('|')
+            customer_id, payment_method_id = payment_method.split('|')
+            token = payment_method_id
+            post[:customer] = customer_id
+          else
+            token = payment_method
+          end
+          post[:payment_method] = token
+        end
+      end
+
+      def add_payment_method_types(post, options)
+        payment_method_types = options[:payment_method_types] if options[:payment_method_types]
+        return if payment_method_types.nil?
+
+        post[:payment_method_types] = Array(payment_method_types)
+        post
+      end
+
+      def add_exemption(post, options = {})
+        return unless options[:confirm]
+        post[:payment_method_options] ||= {}
+        post[:payment_method_options][:card] ||= {}
+        post[:payment_method_options][:card][:moto] = true if options[:moto]
+      end
+
+      def setup_future_usage(post, options = {})
+        post[:setup_future_usage] = options[:setup_future_usage] if %w( on_session off_session ).include?(options[:setup_future_usage])
+        post[:off_session] = options[:off_session] if options[:off_session] && options[:confirm] == true
+        post
+      end
+
+      def add_connected_account(post, options = {})
+        return unless options[:transfer_destination]
+        post[:transfer_data] = {}
+        post[:transfer_data][:destination] = options[:transfer_destination]
+        post[:transfer_data][:amount] = options[:transfer_amount] if options[:transfer_amount]
+        post[:on_behalf_of] = options[:on_behalf_of] if options[:on_behalf_of]
+        post[:transfer_group] = options[:transfer_group] if options[:transfer_group]
+        post[:application_fee_amount] = options[:application_fee] if options[:application_fee]
+        post
+      end
+
+      def add_billing_address(post, options = {})
+        return unless billing = options[:billing_address] || options[:address]
+        post[:billing_details] = {}
+        post[:billing_details][:address] = {}
+        post[:billing_details][:address][:city] = billing[:city] if billing[:city]
+        post[:billing_details][:address][:country] = billing[:country] if billing[:country]
+        post[:billing_details][:address][:line1] = billing[:address1] if billing[:address1]
+        post[:billing_details][:address][:line2] = billing[:address2] if billing[:address2]
+        post[:billing_details][:address][:postal_code] = billing[:zip] if billing[:zip]
+        post[:billing_details][:address][:state] = billing[:state] if billing[:state]
+        post[:billing_details][:email] = billing[:email] if billing[:email]
+        post[:billing_details][:name] = billing[:name] if billing[:name]
+        post[:billing_details][:phone] = billing[:phone] if billing[:phone]
+        post
+      end
+
+      def add_shipping_address(post, options = {})
+        return unless shipping = options[:shipping]
+        post[:shipping] = {}
+        post[:shipping][:address] = {}
+        post[:shipping][:address][:line1] = shipping[:address][:line1]
+        post[:shipping][:address][:city] = shipping[:address][:city] if shipping[:address][:city]
+        post[:shipping][:address][:country] = shipping[:address][:country] if shipping[:address][:country]
+        post[:shipping][:address][:line2] = shipping[:address][:line2] if shipping[:address][:line2]
+        post[:shipping][:address][:postal_code] = shipping[:address][:postal_code] if shipping[:address][:postal_code]
+        post[:shipping][:address][:state] = shipping[:address][:state] if shipping[:address][:state]
+
+        post[:shipping][:name] = shipping[:name]
+        post[:shipping][:carrier] = shipping[:carrier] if shipping[:carrier]
+        post[:shipping][:phone] = shipping[:phone] if shipping[:phone]
+        post[:shipping][:tracking_number] = shipping[:tracking_number] if shipping[:tracking_number]
+        post
+      end
+    end
+  end
+end

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

@@ -3,13 +3,18 @@ module ActiveMerchant
     class TnsGateway < Gateway
       include MastercardGateway
 
-      class_attribute :live_na_url, :live_ap_url, :test_na_url, :test_ap_url
+      class_attribute :live_na_url, :live_ap_url, :live_eu_url, :test_na_url, :test_ap_url, :test_eu_url
 
-      self.live_na_url = 'https://secure.na.tnspayments.com/api/rest/version/36/'
-      self.test_na_url = 'https://secure.na.tnspayments.com/api/rest/version/36/'
+      VERSION = '52'
 
-      self.live_ap_url = 'https://secure.ap.tnspayments.com/api/rest/version/36/'
-      self.test_ap_url = 'https://secure.ap.tnspayments.com/api/rest/version/36/'
+      self.live_na_url = "https://secure.na.tnspayments.com/api/rest/version/#{VERSION}/"
+      self.test_na_url = "https://secure.na.tnspayments.com/api/rest/version/#{VERSION}/"
+
+      self.live_ap_url = "https://secure.ap.tnspayments.com/api/rest/version/#{VERSION}/"
+      self.test_ap_url = "https://secure.ap.tnspayments.com/api/rest/version/#{VERSION}/"
+
+      self.live_eu_url = "https://secure.eu.tnspayments.com/api/rest/version/#{VERSION}/"
+      self.test_eu_url = "https://secure.eu.tnspayments.com/api/rest/version/#{VERSION}/"
 
       self.display_name = 'TNS'
       self.homepage_url = 'http://www.tnsi.com/'

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

@@ -532,7 +532,7 @@ module ActiveMerchant #:nodoc:
 
       def add_contact(doc, fullname, options)
         doc['v1'].contact do
-          doc['v1'].fullName fullname
+          doc['v1'].fullName fullname unless fullname.blank?
           doc['v1'].coName options[:company_name] if options[:company_name]
           doc['v1'].title options[:title] if options[:title]
 
@@ -544,7 +544,7 @@ module ActiveMerchant #:nodoc:
               end
             end
             doc['v1'].addrLn1 billing_address[:address1] if billing_address[:address1]
-            doc['v1'].addrLn2 billing_address[:address2] if billing_address[:address2]
+            doc['v1'].addrLn2 billing_address[:address2] unless billing_address[:address2].blank?
             doc['v1'].city billing_address[:city] if billing_address[:city]
             doc['v1'].state billing_address[:state] if billing_address[:state]
             doc['v1'].zipCode billing_address[:zip] if billing_address[:zip]
@@ -557,9 +557,9 @@ module ActiveMerchant #:nodoc:
 
           if (shipping_address = options[:shipping_address])
             doc['v1'].ship do
-              doc['v1'].fullName fullname
+              doc['v1'].fullName fullname unless fullname.blank?
               doc['v1'].addrLn1 shipping_address[:address1] if shipping_address[:address1]
-              doc['v1'].addrLn2 shipping_address[:address2] if shipping_address[:address2]
+              doc['v1'].addrLn2 shipping_address[:address2] unless shipping_address[:address2].blank?
               doc['v1'].city shipping_address[:city] if shipping_address[:city]
               doc['v1'].state shipping_address[:state] if shipping_address[:state]
               doc['v1'].zipCode shipping_address[:zip] if shipping_address[:zip]
@@ -572,7 +572,7 @@ module ActiveMerchant #:nodoc:
 
       def add_name(doc, payment_method)
         doc['v1'].contact do
-          doc['v1'].fullName payment_method.name
+          doc['v1'].fullName payment_method.name unless payment_method.name.blank?
         end
       end
 

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

@@ -104,6 +104,8 @@ module ActiveMerchant #:nodoc:
       TEST_LOGIN = 'TestMerchant'
       TEST_PASSWORD = 'password'
 
+      VOIDABLE_ACTIONS = %w(preauth sale postauth credit)
+
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :discover, :american_express, :diners_club, :jcb]
       self.supported_countries = ['US']
@@ -157,6 +159,8 @@ module ActiveMerchant #:nodoc:
         add_customer_data(parameters, options)
         add_payment_source(parameters, creditcard_or_billing_id)
         add_addresses(parameters, options)
+        add_custom_fields(parameters, options)
+
         commit('preauth', parameters)
       end
 
@@ -172,6 +176,8 @@ module ActiveMerchant #:nodoc:
         add_customer_data(parameters, options)
         add_payment_source(parameters, creditcard_or_billing_id)
         add_addresses(parameters, options)
+        add_custom_fields(parameters, options)
+
         commit('sale', parameters)
       end
 
@@ -179,11 +185,13 @@ module ActiveMerchant #:nodoc:
       # postauth, we preserve active_merchant's nomenclature of capture() for consistency with the rest of the library. To process
       # a postauthorization with TC, you need an amount in cents or a money object, and a TC transid.
       def capture(money, authorization, options = {})
+        transaction_id, _ = split_authorization(authorization)
         parameters = {
           :amount => amount(money),
-          :transid => authorization,
+          :transid => transaction_id,
         }
         add_aggregator(parameters, options)
+        add_custom_fields(parameters, options)
 
         commit('postauth', parameters)
       end
@@ -191,11 +199,15 @@ module ActiveMerchant #:nodoc:
       # refund() allows you to return money to a card that was previously billed. You need to supply the amount, in cents or a money object,
       # that you want to refund, and a TC transid for the transaction that you are refunding.
       def refund(money, identification, options = {})
+        transaction_id, _ = split_authorization(identification)
+
         parameters = {
           :amount => amount(money),
-          :transid => identification
+          :transid => transaction_id
         }
+
         add_aggregator(parameters, options)
+        add_custom_fields(parameters, options)
 
         commit('credit', parameters)
       end
@@ -214,18 +226,26 @@ module ActiveMerchant #:nodoc:
       # TrustCommerce to allow for reversal transactions before you can use this
       # method.
       #
+      # void() is also used to to cancel a capture (postauth), purchase (sale),
+      # or refund (credit) or a before it is sent for settlement.
+      #
       # NOTE: AMEX preauth's cannot be reversed. If you want to clear it more
       # quickly than the automatic expiration (7-10 days), you will have to
       # capture it and then immediately issue a credit for the same amount
       # which should clear the customers credit card with 48 hours according to
       # TC.
       def void(authorization, options = {})
+        transaction_id, original_action = split_authorization(authorization)
+        action = (VOIDABLE_ACTIONS - ['preauth']).include?(original_action) ? 'void' : 'reversal'
+
         parameters = {
-          :transid => authorization,
+          :transid => transaction_id,
         }
+
         add_aggregator(parameters, options)
+        add_custom_fields(parameters, options)
 
-        commit('reversal', parameters)
+        commit(action, parameters)
       end
 
       # recurring() a TrustCommerce account that is activated for Citadel, TrustCommerce's
@@ -284,6 +304,8 @@ module ActiveMerchant #:nodoc:
 
         add_creditcard(parameters, creditcard)
         add_addresses(parameters, options)
+        add_custom_fields(parameters, options)
+
         commit('store', parameters)
       end
 
@@ -294,6 +316,8 @@ module ActiveMerchant #:nodoc:
           :billingid => identification,
         }
 
+        add_custom_fields(parameters, options)
+
         commit('unstore', parameters)
       end
 
@@ -311,6 +335,12 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def add_custom_fields(params, options)
+        options[:custom_fields]&.each do |key, value|
+          params[key.to_sym] = value
+        end
+      end
+
       def add_aggregator(params, options)
         if @options[:aggregator_id] || application_id != Gateway.application_id
           params[:aggregators] = 1
@@ -333,6 +363,7 @@ module ActiveMerchant #:nodoc:
         params[:routing] = check.routing_number
         params[:account] = check.account_number
         params[:savings] = 'y' if check.account_type == 'savings'
+        params[:name] = check.name
       end
 
       def add_creditcard(params, creditcard)
@@ -408,14 +439,14 @@ module ActiveMerchant #:nodoc:
                  TCLink.send(parameters)
                else
                  parse(ssl_post(self.live_url, post_data(parameters)))
-        end
+               end
 
         # to be considered successful, transaction status must be either "approved" or "accepted"
         success = SUCCESS_TYPES.include?(data['status'])
         message = message_from(data)
         Response.new(success, message, data,
           :test => test?,
-          :authorization => data['transid'],
+          :authorization => authorization_from(action, data),
           :cvv_result => data['cvv'],
           :avs_result => { :code => data['avs'] }
         )
@@ -445,6 +476,15 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def authorization_from(action, data)
+        authorization = data['transid']
+        authorization = "#{authorization}|#{action}" if authorization && VOIDABLE_ACTIONS.include?(action)
+        authorization
+      end
+
+      def split_authorization(authorization)
+        authorization&.split('|')
+      end
     end
   end
 end

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

@@ -33,9 +33,9 @@ module ActiveMerchant #:nodoc:
         '10110' => STANDARD_ERROR_CODE[:incorrect_address],
         '10111' => STANDARD_ERROR_CODE[:incorrect_address],
         '10127' => STANDARD_ERROR_CODE[:card_declined],
-        '10128' => STANDARD_ERROR_CODE[:processing_error],
-        '10132' => STANDARD_ERROR_CODE[:processing_error],
-        '00043' => STANDARD_ERROR_CODE[:call_issuer]
+        '00043' => STANDARD_ERROR_CODE[:call_issuer],
+        '10205' => STANDARD_ERROR_CODE[:card_declined],
+        '10204' => STANDARD_ERROR_CODE[:pickup_card]
       }
 
       def initialize(options = {})
@@ -197,14 +197,19 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_invoice(post, options)
-        post[:invoice]      = options[:order_id]
+        post[:invoice]      = options[:invoice]
+        post[:orderid]      = options[:order_id]
         post[:description]  = options[:description]
       end
 
       def add_payment(post, payment, options={})
         if payment.respond_to?(:routing_number)
           post[:checkformat] = options[:check_format] if options[:check_format]
-          post[:accounttype] = options[:account_type] if options[:account_type]
+          if payment.account_type
+            account_type = payment.account_type.to_s.capitalize
+            raise ArgumentError, 'account_type must be checking or savings' unless %w(Checking Savings).include?(account_type)
+            post[:accounttype] = account_type
+          end
           post[:account] = payment.account_number
           post[:routing] = payment.routing_number
           post[:name]    = payment.name unless payment.name.blank?
@@ -258,7 +263,10 @@ module ActiveMerchant #:nodoc:
       # see: https://wiki.usaepay.com/developer/transactionapi#merchant_defined_custom_fields
       def add_custom_fields(post, options)
         return unless options[:custom_fields].is_a?(Hash)
+
         options[:custom_fields].each do |index, custom|
+          raise ArgumentError.new('Cannot specify custom field with index 0') if index.to_s.to_i.zero?
+
           post["custom#{index}"] = custom
         end
       end
@@ -267,7 +275,7 @@ module ActiveMerchant #:nodoc:
       def add_line_items(post, options)
         return unless options[:line_items].is_a?(Array)
         options[:line_items].each_with_index do |line_item, index|
-          %w(product_ref_num sku name description taxable tax_rate tax_amount commodity_code discount_rate discount_amount).each do |key|
+          %w(product_ref_num sku qty name description taxable tax_rate tax_amount commodity_code discount_rate discount_amount).each do |key|
             post["line#{index}#{key.delete('_')}"] = line_item[key.to_sym] if line_item.has_key?(key.to_sym)
           end
 
@@ -310,12 +318,15 @@ module ActiveMerchant #:nodoc:
       def commit(action, parameters)
         url = (test? ? self.test_url : self.live_url)
         response = parse(ssl_post(url, post_data(action, parameters)))
-        Response.new(response[:status] == 'Approved', message_from(response), response,
+        approved = response[:status] == 'Approved'
+        error_code = nil
+        error_code = (STANDARD_ERROR_CODE_MAPPING[response[:error_code]] || STANDARD_ERROR_CODE[:processing_error]) unless approved
+        Response.new(approved, message_from(response), response,
           :test           => test?,
           :authorization  => response[:ref_num],
           :cvv_result     => response[:cvv2_result_code],
           :avs_result     => { :code => response[:avs_result_code] },
-          :error_code     => STANDARD_ERROR_CODE_MAPPING[response[:error_code]]
+          :error_code     => error_code
         )
       end
 

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

@@ -57,7 +57,10 @@ module ActiveMerchant #:nodoc:
         response = commit('cancelDeposit', params, options)
         return response if response.success? || split_authorization(authorization).length == 1 || !options[:force_full_refund_if_unsettled]
 
-        # Attempt RefundSingleTransaction if unsettled
+        # Attempt RefundSingleTransaction if unsettled (and stash the original
+        # response message so it will be included it in the follow-up response
+        # message)
+        options[:error_message] = response.message
         prepare_refund_data(params, authorization, options)
         commit('refund', params, options)
       end
@@ -197,15 +200,24 @@ module ActiveMerchant #:nodoc:
       end
 
       def message_from(response, options, action)
-        if empty?(response['errorMessage']) || response['errorMessage'] == '[ ]'
-          action == 'refund' ? "#{response['data']['DSC_COD_ACCION']}, #{options[:error_message]}" : response['data']['DSC_COD_ACCION']
-        elsif action == 'refund'
-          message = "#{response['errorMessage']}, #{options[:error_message]}"
-          options[:error_message] = response['errorMessage']
-          message
-        else
-          response['errorMessage']
-        end
+        message_from_messages(
+          response['errorMessage'],
+          action_code_description(response),
+          options[:error_message]
+        )
+      end
+
+      def message_from_messages(*args)
+        args.reject { |m| error_message_empty?(m) }.join(' | ')
+      end
+
+      def action_code_description(response)
+        return nil unless response['data']
+        response['data']['DSC_COD_ACCION']
+      end
+
+      def error_message_empty?(error_message)
+        empty?(error_message) || error_message == '[ ]'
       end
 
       def response_error(raw_response, options, action)