activemerchant 1.105.0 → 1.107.4

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

@@ -283,10 +283,10 @@ module ActiveMerchant #:nodoc:
       def response_from(raw_response, authorization_field)
         parsed = parse(raw_response)
         options = {
-          :authorization => parsed[authorization_field],
-          :test => (parsed[:on_test_gateway] == 'true'),
-          :avs_result => { :code => parsed[:response_avs_code] },
-          :cvv_result => parsed[:response_cvv_code]
+          authorization: parsed[authorization_field],
+          test: (parsed[:on_test_gateway] == 'true'),
+          avs_result: { code: parsed[:response_avs_code] },
+          cvv_result: parsed[:response_cvv_code]
         }
 
         Response.new(parsed[:succeeded] == 'true', parsed[:message] || parsed[:error], parsed, options)

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

@@ -80,6 +80,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorize(money, payment, options = {})
+        if ach?(payment)
+          direct_bank_error = 'Direct bank account transactions are not supported for authorize.'
+          return Response.new(false, direct_bank_error)
+        end
+
         MultiResponse.run do |r|
           if payment.is_a?(ApplePayPaymentToken)
             r.process { tokenize_apple_pay_token(payment) }
@@ -419,7 +424,7 @@ module ActiveMerchant #:nodoc:
 
       def add_external_account(post, card_params, payment)
         external_account = {}
-        external_account[:object] ='card'
+        external_account[:object] = 'card'
         external_account[:currency] = (options[:currency] || currency(payment)).downcase
         post[:external_account] = external_account.merge(card_params[:card])
       end
@@ -612,7 +617,7 @@ module ActiveMerchant #:nodoc:
           'User-Agent' => "Stripe/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
           'Stripe-Version' => api_version(options),
           'X-Stripe-Client-User-Agent' => stripe_client_user_agent(options),
-          'X-Stripe-Client-User-Metadata' => {:ip => options[:ip]}.to_json
+          'X-Stripe-Client-User-Metadata' => {ip: options[:ip]}.to_json
         }
         headers['Idempotency-Key'] = idempotency_key if idempotency_key
         headers['Stripe-Account'] = options[:stripe_account] if options[:stripe_account]
@@ -647,7 +652,7 @@ module ActiveMerchant #:nodoc:
         add_expand_parameters(parameters, options) if parameters
         response = api_request(method, url, parameters, options)
         response['webhook_id'] = options[:webhook_id] if options[:webhook_id]
-        success = success_from(response)
+        success = success_from(response, options)
 
         card = card_from_response(response)
         avs_code = AVS_CODE_TRANSLATOR["line1: #{card["address_line1_check"]}, zip: #{card["address_zip_check"]}"]
@@ -656,12 +661,12 @@ module ActiveMerchant #:nodoc:
         Response.new(success,
           message_from(success, response),
           response,
-          :test => response_is_test?(response),
-          :authorization => authorization_from(success, url, method, response),
-          :avs_result => { :code => avs_code },
-          :cvv_result => cvc_code,
-          :emv_authorization => emv_authorization_from_response(response),
-          :error_code => success ? nil : error_code_from(response)
+          test: response_is_test?(response),
+          authorization: authorization_from(success, url, method, response),
+          avs_result: { code: avs_code },
+          cvv_result: cvc_code,
+          emv_authorization: emv_authorization_from_response(response),
+          error_code: success ? nil : error_code_from(response)
         )
       end
 
@@ -681,7 +686,7 @@ module ActiveMerchant #:nodoc:
         success ? 'Transaction approved' : response.fetch('error', {'message' => 'No error details'})['message']
       end
 
-      def success_from(response)
+      def success_from(response, options)
         !response.key?('error') && response['status'] != 'failed'
       end
 

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

@@ -20,7 +20,9 @@ module ActiveMerchant #:nodoc:
         add_capture_method(post, options)
         add_confirmation_method(post, options)
         add_customer(post, options)
-        add_payment_method_token(post, payment_method, options)
+        payment_method = add_payment_method_token(post, payment_method, options)
+        return payment_method if payment_method.is_a?(ActiveMerchant::Billing::Response)
+
         add_metadata(post, options)
         add_return_url(post, options)
         add_connected_account(post, options)
@@ -41,11 +43,12 @@ module ActiveMerchant #:nodoc:
 
       def confirm_intent(intent_id, payment_method, options = {})
         post = {}
-        add_payment_method_token(post, payment_method, options)
+        payment_method = add_payment_method_token(post, payment_method, options)
+        return payment_method if payment_method.is_a?(ActiveMerchant::Billing::Response)
+
         CONFIRM_INTENT_ATTRIBUTES.each do |attribute|
           add_whitelisted_attribute(post, options, attribute)
         end
-
         commit(:post, "payment_intents/#{intent_id}/confirm", post, options)
       end
 
@@ -58,7 +61,7 @@ module ActiveMerchant #:nodoc:
         post[:card][:exp_year] = payment_method.year
         post[:card][:cvc] = payment_method.verification_value if payment_method.verification_value
         add_billing_address(post, options)
-
+        options = format_idempotency_key(options, 'pm')
         commit(:post, 'payment_methods', post, options)
       end
 
@@ -66,7 +69,9 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_amount(post, money, options)
 
-        add_payment_method_token(post, payment_method, options)
+        payment_method = add_payment_method_token(post, payment_method, options)
+        return payment_method if payment_method.is_a?(ActiveMerchant::Billing::Response)
+
         add_payment_method_types(post, options)
         add_customer(post, options)
         add_metadata(post, options)
@@ -76,7 +81,6 @@ module ActiveMerchant #:nodoc:
         UPDATE_INTENT_ATTRIBUTES.each do |attribute|
           add_whitelisted_attribute(post, options, attribute)
         end
-
         commit(:post, "payment_intents/#{intent_id}", post, options)
       end
 
@@ -97,6 +101,7 @@ module ActiveMerchant #:nodoc:
           post[:transfer_data][:amount] = options[:transfer_amount]
         end
         post[:application_fee_amount] = options[:application_fee] if options[:application_fee]
+        options = format_idempotency_key(options, 'capture')
         commit(:post, "payment_intents/#{intent_id}/capture", post, options)
       end
 
@@ -107,8 +112,22 @@ module ActiveMerchant #:nodoc:
       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')
+        if intent_id.include?('pi_')
+          intent = api_request(:get, "payment_intents/#{intent_id}", nil, options)
+
+          return Response.new(false, intent['error']['message'], intent) if intent['error']
+
+          charge_id = intent.try(:[], 'charges').try(:[], 'data').try(:[], 0).try(:[], 'id')
+
+          if charge_id.nil?
+            error_message = "No associated charge for #{intent['id']}"
+            error_message <<  "; payment_intent has a status of #{intent['status']}" if intent.try(:[], 'status') && intent.try(:[], 'status') != 'succeeded'
+            return Response.new(false, error_message, intent)
+          end
+        else
+          charge_id = intent_id
+        end
+
         super(money, charge_id, options)
       end
 
@@ -122,16 +141,20 @@ module ActiveMerchant #:nodoc:
         # 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)
+          payment_method = add_payment_method_token(params, payment_method, options)
+          return payment_method if payment_method.is_a?(ActiveMerchant::Billing::Response)
+
           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]
+            options = format_idempotency_key(options, 'customer')
             customer = commit(:post, 'customers', post, options)
             customer_id = customer.params['id']
           end
+          options = format_idempotency_key(options, 'attach')
           commit(:post, "payment_methods/#{params[:payment_method]}/attach", { customer: customer_id }, options)
         else
           super(payment_method, options)
@@ -190,6 +213,8 @@ module ActiveMerchant #:nodoc:
 
         if payment_method.is_a?(ActiveMerchant::Billing::CreditCard)
           p = create_payment_method(payment_method, options)
+          return p unless p.success?
+
           payment_method = p.params['id']
         end
 
@@ -264,6 +289,22 @@ module ActiveMerchant #:nodoc:
         post[:shipping][:tracking_number] = shipping[:tracking_number] if shipping[:tracking_number]
         post
       end
+
+      def format_idempotency_key(options, suffix)
+        return options unless options[:idempotency_key]
+
+        options.merge(idempotency_key: "#{options[:idempotency_key]}-#{suffix}")
+      end
+
+      def success_from(response, options)
+        if response['status'] == 'requires_action' && !options[:execute_threed]
+          response['error'] = {}
+          response['error']['message'] = 'Received unexpected 3DS authentication response. Use the execute_threed option to initiate a proper 3DS flow.'
+          return false
+        end
+
+        super(response, options)
+      end
     end
   end
 end

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

@@ -109,7 +109,7 @@ module ActiveMerchant #:nodoc:
                 TRANSACTION_APPROVED_MSG :
                 TRANSACTION_DECLINED_MSG,
                 response,
-                :test => test?
+                test: test?
               )
             else
               build_error_response(message, response)
@@ -144,7 +144,7 @@ module ActiveMerchant #:nodoc:
           false,
           message,
           params,
-          :test => test?
+          test: test?
         )
       end
     end

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

@@ -175,10 +175,10 @@ module ActiveMerchant #:nodoc:
           success_from(response),
           message_from(response),
           response,
-          :test => test?,
-          :authorization => authorization_from(response),
-          :avs_result => { :code => response[:avs_code] },
-          :cvv_result => response[:cvv2_code]
+          test: test?,
+          authorization: authorization_from(response),
+          avs_result: { code: response[:avs_code] },
+          cvv_result: response[:cvv2_code]
         )
       end
 

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

@@ -151,7 +151,7 @@ module ActiveMerchant #:nodoc:
 
       def authorize(money, creditcard_or_billing_id, options = {})
         parameters = {
-          :amount => amount(money),
+          amount: amount(money),
         }
 
         add_order_id(parameters, options)
@@ -168,7 +168,7 @@ module ActiveMerchant #:nodoc:
       # to process a purchase are an amount in cents or a money object and a creditcard object or billingid string.
       def purchase(money, creditcard_or_billing_id, options = {})
         parameters = {
-          :amount => amount(money),
+          amount: amount(money),
         }
 
         add_order_id(parameters, options)
@@ -187,8 +187,8 @@ module ActiveMerchant #:nodoc:
       def capture(money, authorization, options = {})
         transaction_id, _ = split_authorization(authorization)
         parameters = {
-          :amount => amount(money),
-          :transid => transaction_id,
+          amount: amount(money),
+          transid: transaction_id,
         }
         add_aggregator(parameters, options)
         add_custom_fields(parameters, options)
@@ -202,8 +202,8 @@ module ActiveMerchant #:nodoc:
         transaction_id, _ = split_authorization(identification)
 
         parameters = {
-          :amount => amount(money),
-          :transid => transaction_id
+          amount: amount(money),
+          transid: transaction_id
         }
 
         add_aggregator(parameters, options)
@@ -239,7 +239,7 @@ module ActiveMerchant #:nodoc:
         action = (VOIDABLE_ACTIONS - ['preauth']).include?(original_action) ? 'void' : 'reversal'
 
         parameters = {
-          :transid => transaction_id,
+          transid: transaction_id,
         }
 
         add_aggregator(parameters, options)
@@ -281,11 +281,11 @@ module ActiveMerchant #:nodoc:
           end
 
         parameters = {
-          :amount => amount(money),
-          :cycle => cycle,
-          :verify => options[:verify] || 'y',
-          :billingid => options[:billingid] || nil,
-          :payments => options[:payments] || nil,
+          amount: amount(money),
+          cycle: cycle,
+          verify: options[:verify] || 'y',
+          billingid: options[:billingid] || nil,
+          payments: options[:payments] || nil,
         }
 
         add_creditcard(parameters, creditcard)
@@ -299,8 +299,8 @@ module ActiveMerchant #:nodoc:
 
       def store(creditcard, options = {})
         parameters = {
-          :verify => options[:verify] || 'y',
-          :billingid => options[:billingid] || options[:billing_id] || nil,
+          verify: options[:verify] || 'y',
+          billingid: options[:billingid] || options[:billing_id] || nil,
         }
 
         add_creditcard(parameters, creditcard)
@@ -314,7 +314,7 @@ module ActiveMerchant #:nodoc:
       # unstore() the information will be removed and a Response object will be returned indicating the success of the action.
       def unstore(identification, options = {})
         parameters = {
-          :billingid => identification,
+          billingid: identification,
         }
 
         add_custom_fields(parameters, options)
@@ -444,10 +444,10 @@ module ActiveMerchant #:nodoc:
         success = SUCCESS_TYPES.include?(data['status'])
         message = message_from(data)
         Response.new(success, message, data,
-          :test => test?,
-          :authorization => authorization_from(action, data),
-          :cvv_result => data['cvv'],
-          :avs_result => { :code => data['avs'] }
+          test: test?,
+          authorization: authorization_from(action, data),
+          cvv_result: data['cvv'],
+          avs_result: { code: data['avs'] }
         )
       end
 

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

@@ -78,29 +78,29 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'USA ePay Advanced SOAP Interface'
 
       CUSTOMER_PROFILE_OPTIONS = {
-        :id => [:string, 'CustomerID'], # merchant assigned number
-        :notes => [:string, 'Notes'],
-        :data => [:string, 'CustomData'],
-        :url => [:string, 'URL']
+        id: [:string, 'CustomerID'], # merchant assigned number
+        notes: [:string, 'Notes'],
+        data: [:string, 'CustomData'],
+        url: [:string, 'URL']
       } #:nodoc:
 
       CUSTOMER_RECURRING_BILLING_OPTIONS = {
-        :enabled => [:boolean, 'Enabled'],
-        :schedule => [:string, 'Schedule'],
-        :number_left => [:integer, 'NumLeft'],
-        :currency => [:string, 'Currency'],
-        :description => [:string, 'Description'],
-        :order_id => [:string, 'OrderID'],
-        :user => [:string, 'User'],
-        :source => [:string, 'Source'],
-        :send_receipt => [:boolean, 'SendReceipt'],
-        :receipt_note => [:string, 'ReceiptNote']
+        enabled: [:boolean, 'Enabled'],
+        schedule: [:string, 'Schedule'],
+        number_left: [:integer, 'NumLeft'],
+        currency: [:string, 'Currency'],
+        description: [:string, 'Description'],
+        order_id: [:string, 'OrderID'],
+        user: [:string, 'User'],
+        source: [:string, 'Source'],
+        send_receipt: [:boolean, 'SendReceipt'],
+        receipt_note: [:string, 'ReceiptNote']
       } #:nodoc:
 
       CUSTOMER_POINT_OF_SALE_OPTIONS = {
-        :price_tier => [:string, 'PriceTier'],
-        :tax_class => [:string, 'TaxClass'],
-        :lookup_code => [:string, 'LookupCode']
+        price_tier: [:string, 'PriceTier'],
+        tax_class: [:string, 'TaxClass'],
+        lookup_code: [:string, 'LookupCode']
       } #:nodoc:
 
       CUSTOMER_OPTIONS = [
@@ -110,23 +110,23 @@ module ActiveMerchant #:nodoc:
       ].inject(:merge) #:nodoc:
 
       COMMON_ADDRESS_OPTIONS = {
-        :first_name => [:string, 'FirstName'],
-        :last_name => [:string, 'LastName'],
-        :city => [:string, 'City'],
-        :state => [:string, 'State'],
-        :zip => [:string, 'Zip'],
-        :country => [:string, 'Country'],
-        :phone => [:string, 'Phone'],
-        :email => [:string, 'Email'],
-        :fax => [:string, 'Fax'],
-        :company => [:string, 'Company']
+        first_name: [:string, 'FirstName'],
+        last_name: [:string, 'LastName'],
+        city: [:string, 'City'],
+        state: [:string, 'State'],
+        zip: [:string, 'Zip'],
+        country: [:string, 'Country'],
+        phone: [:string, 'Phone'],
+        email: [:string, 'Email'],
+        fax: [:string, 'Fax'],
+        company: [:string, 'Company']
       } #:nodoc:
 
       ADDRESS_OPTIONS = [
         COMMON_ADDRESS_OPTIONS,
         {
-          :address1 => [:string, 'Street'],
-          :address2 => [:string, 'Street2'],
+          address1: [:string, 'Street'],
+          address2: [:string, 'Street2'],
         }
       ].inject(:merge) #:nodoc
 
@@ -135,98 +135,98 @@ module ActiveMerchant #:nodoc:
         CUSTOMER_RECURRING_BILLING_OPTIONS,
         COMMON_ADDRESS_OPTIONS,
         {
-          :address1 => [:string, 'Address'],
-          :address2 => [:string, 'Address2'],
+          address1: [:string, 'Address'],
+          address2: [:string, 'Address2'],
         },
         {
-          :card_number => [:string, 'CardNumber'],
-          :card_exp => [:string, 'CardExp'],
-          :account => [:string, 'Account'],
-          :routing => [:string, 'Routing'],
-          :check_format => [:string, 'CheckFormat'],
-          :record_type => [:string, 'RecordType'],
+          card_number: [:string, 'CardNumber'],
+          card_exp: [:string, 'CardExp'],
+          account: [:string, 'Account'],
+          routing: [:string, 'Routing'],
+          check_format: [:string, 'CheckFormat'],
+          record_type: [:string, 'RecordType'],
         }
       ].inject(:merge) #:nodoc
 
       CUSTOMER_TRANSACTION_REQUEST_OPTIONS = {
-        :command => [:string, 'Command'],
-        :ignore_duplicate => [:boolean, 'IgnoreDuplicate'],
-        :client_ip => [:string, 'ClientIP'],
-        :customer_receipt => [:boolean, 'CustReceipt'],
-        :customer_email => [:boolean, 'CustReceiptEmail'],
-        :customer_template => [:boolean, 'CustReceiptName'],
-        :merchant_receipt => [:boolean, 'MerchReceipt'],
-        :merchant_email => [:boolean, 'MerchReceiptEmail'],
-        :merchant_template => [:boolean, 'MerchReceiptName'],
-        :recurring => [:boolean, 'isRecurring'],
-        :verification_value => [:string, 'CardCode'],
-        :software => [:string, 'Software']
+        command: [:string, 'Command'],
+        ignore_duplicate: [:boolean, 'IgnoreDuplicate'],
+        client_ip: [:string, 'ClientIP'],
+        customer_receipt: [:boolean, 'CustReceipt'],
+        customer_email: [:boolean, 'CustReceiptEmail'],
+        customer_template: [:boolean, 'CustReceiptName'],
+        merchant_receipt: [:boolean, 'MerchReceipt'],
+        merchant_email: [:boolean, 'MerchReceiptEmail'],
+        merchant_template: [:boolean, 'MerchReceiptName'],
+        recurring: [:boolean, 'isRecurring'],
+        verification_value: [:string, 'CardCode'],
+        software: [:string, 'Software']
       } #:nodoc:
 
       TRANSACTION_REQUEST_OBJECT_OPTIONS = {
-        :command => [:string, 'Command'],
-        :ignore_duplicate => [:boolean, 'IgnoreDuplicate'],
-        :authorization_code => [:string, 'AuthCode'],
-        :reference_number => [:string, 'RefNum'],
-        :account_holder => [:string, 'AccountHolder'],
-        :client_ip => [:string, 'ClientIP'],
-        :customer_id => [:string, 'CustomerID'],
-        :customer_receipt => [:boolean, 'CustReceipt'],
-        :customer_template => [:boolean, 'CustReceiptName'],
-        :software => [:string, 'Software']
+        command: [:string, 'Command'],
+        ignore_duplicate: [:boolean, 'IgnoreDuplicate'],
+        authorization_code: [:string, 'AuthCode'],
+        reference_number: [:string, 'RefNum'],
+        account_holder: [:string, 'AccountHolder'],
+        client_ip: [:string, 'ClientIP'],
+        customer_id: [:string, 'CustomerID'],
+        customer_receipt: [:boolean, 'CustReceipt'],
+        customer_template: [:boolean, 'CustReceiptName'],
+        software: [:string, 'Software']
       } #:nodoc:
 
       TRANSACTION_DETAIL_OPTIONS = {
-        :invoice  => [:string, 'Invoice'],
-        :po_number => [:string, 'PONum'],
-        :order_id => [:string, 'OrderID'],
-        :clerk => [:string, 'Clerk'],
-        :terminal  => [:string, 'Terminal'],
-        :table => [:string, 'Table'],
-        :description => [:string, 'Description'],
-        :comments => [:string, 'Comments'],
-        :allow_partial_auth => [:boolean, 'AllowPartialAuth'],
-        :currency => [:string, 'Currency'],
-        :non_tax => [:boolean, 'NonTax'],
+        invoice: [:string, 'Invoice'],
+        po_number: [:string, 'PONum'],
+        order_id: [:string, 'OrderID'],
+        clerk: [:string, 'Clerk'],
+        terminal: [:string, 'Terminal'],
+        table: [:string, 'Table'],
+        description: [:string, 'Description'],
+        comments: [:string, 'Comments'],
+        allow_partial_auth: [:boolean, 'AllowPartialAuth'],
+        currency: [:string, 'Currency'],
+        non_tax: [:boolean, 'NonTax'],
       } #:nodoc:
 
       TRANSACTION_DETAIL_MONEY_OPTIONS = {
-        :amount => [:double, 'Amount'],
-        :tax => [:double, 'Tax'],
-        :tip => [:double, 'Tip'],
-        :non_tax => [:boolean, 'NonTax'],
-        :shipping => [:double, 'Shipping'],
-        :discount => [:double, 'Discount'],
-        :subtotal => [:double, 'Subtotal']
+        amount: [:double, 'Amount'],
+        tax: [:double, 'Tax'],
+        tip: [:double, 'Tip'],
+        non_tax: [:boolean, 'NonTax'],
+        shipping: [:double, 'Shipping'],
+        discount: [:double, 'Discount'],
+        subtotal: [:double, 'Subtotal']
       } #:nodoc:
 
       CREDIT_CARD_DATA_OPTIONS = {
-        :magnetic_stripe => [:string, 'MagStripe'],
-        :dukpt => [:string, 'DUKPT'],
-        :signature => [:string, 'Signature'],
-        :terminal_type => [:string, 'TermType'],
-        :magnetic_support => [:string, 'MagSupport'],
-        :xid => [:string, 'XID'],
-        :cavv => [:string, 'CAVV'],
-        :eci => [:integer, 'ECI'],
-        :internal_card_authorization => [:boolean, 'InternalCardAuth'],
-        :pares => [:string, 'Pares']
+        magnetic_stripe: [:string, 'MagStripe'],
+        dukpt: [:string, 'DUKPT'],
+        signature: [:string, 'Signature'],
+        terminal_type: [:string, 'TermType'],
+        magnetic_support: [:string, 'MagSupport'],
+        xid: [:string, 'XID'],
+        cavv: [:string, 'CAVV'],
+        eci: [:integer, 'ECI'],
+        internal_card_authorization: [:boolean, 'InternalCardAuth'],
+        pares: [:string, 'Pares']
       } #:nodoc:
 
       CHECK_DATA_OPTIONS = {
-        :drivers_license => [:string, 'DriversLicense'],
-        :drivers_license_state => [:string, 'DriversLicenseState'],
-        :record_type => [:string, 'RecordType'],
-        :aux_on_us => [:string, 'AuxOnUS'],
-        :epc_code => [:string, 'EpcCode'],
-        :front_image => [:string, 'FrontImage'],
-        :back_image => [:string, 'BackImage']
+        drivers_license: [:string, 'DriversLicense'],
+        drivers_license_state: [:string, 'DriversLicenseState'],
+        record_type: [:string, 'RecordType'],
+        aux_on_us: [:string, 'AuxOnUS'],
+        epc_code: [:string, 'EpcCode'],
+        front_image: [:string, 'FrontImage'],
+        back_image: [:string, 'BackImage']
       } #:nodoc:
 
       RECURRING_BILLING_OPTIONS = {
-        :schedule => [:string, 'Schedule'],
-        :number_left => [:integer, 'NumLeft'],
-        :enabled => [:boolean, 'Enabled']
+        schedule: [:string, 'Schedule'],
+        number_left: [:integer, 'NumLeft'],
+        enabled: [:boolean, 'Enabled']
       } #:nodoc:
 
       AVS_RESULTS = {
@@ -290,7 +290,7 @@ module ActiveMerchant #:nodoc:
       # Note: See run_transaction for additional options.
       #
       def purchase(money, creditcard, options={})
-        run_sale(options.merge!(:amount => money, :payment_method => creditcard))
+        run_sale(options.merge!(amount: money, payment_method: creditcard))
       end
 
       # Authorize an amount on a credit card or account.
@@ -298,7 +298,7 @@ module ActiveMerchant #:nodoc:
       # Note: See run_transaction for additional options.
       #
       def authorize(money, creditcard, options={})
-        run_auth_only(options.merge!(:amount => money, :payment_method => creditcard))
+        run_auth_only(options.merge!(amount: money, payment_method: creditcard))
       end
 
       # Capture an authorized transaction.
@@ -306,7 +306,7 @@ module ActiveMerchant #:nodoc:
       # Note: See run_transaction for additional options.
       #
       def capture(money, identification, options={})
-        capture_transaction(options.merge!(:amount => money, :reference_number => identification))
+        capture_transaction(options.merge!(amount: money, reference_number: identification))
       end
 
       # Void a previous transaction that has not been settled.
@@ -314,7 +314,7 @@ module ActiveMerchant #:nodoc:
       # Note: See run_transaction for additional options.
       #
       def void(identification, options={})
-        void_transaction(options.merge!(:reference_number => identification))
+        void_transaction(options.merge!(reference_number: identification))
       end
 
       # Refund a previous transaction.
@@ -322,7 +322,7 @@ module ActiveMerchant #:nodoc:
       # Note: See run_transaction for additional options.
       #
       def refund(money, identification, options={})
-        refund_transaction(options.merge!(:amount => money, :reference_number => identification))
+        refund_transaction(options.merge!(amount: money, reference_number: identification))
       end
 
       def credit(money, identification, options={})
@@ -1031,7 +1031,7 @@ module ActiveMerchant #:nodoc:
       # Build soap header, etc.
       def build_request(action, options = {})
         soap = Builder::XmlMarkup.new
-        soap.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
+        soap.instruct!(:xml, version: '1.0', encoding: 'utf-8')
         soap.tag! 'SOAP-ENV:Envelope',
           'xmlns:SOAP-ENV' => 'http://schemas.xmlsoap.org/soap/envelope/',
           'xmlns:ns1' => 'urn:usaepay',
@@ -1310,7 +1310,7 @@ module ActiveMerchant #:nodoc:
         if options[:payment_methods]
           length = options[:payment_methods].length
           soap.PaymentMethods 'SOAP-ENC:arrayType' => "ns1:PaymentMethod[#{length}]",
-                              'xsi:type' =>'ns1:PaymentMethodArray' do
+                              'xsi:type' => 'ns1:PaymentMethodArray' do
             build_customer_payment_methods soap, options
           end
         end
@@ -1536,15 +1536,15 @@ module ActiveMerchant #:nodoc:
           success,
           message,
           response_params,
-          :test => test?,
-          :authorization => authorization,
-          :avs_result => avs_from(avs),
-          :cvv_result => cvv
+          test: test?,
+          authorization: authorization,
+          avs_result: avs_from(avs),
+          cvv_result: cvv
         )
       end
 
       def avs_from(avs)
-        avs_params = { :code => avs }
+        avs_params = { code: avs }
         avs_params[:message] = AVS_CUSTOM_MESSAGES[avs] if AVS_CUSTOM_MESSAGES.key?(avs)
         avs_params
       end
@@ -1552,7 +1552,7 @@ module ActiveMerchant #:nodoc:
       def parse(action, soap)
         xml = REXML::Document.new(soap)
         root = REXML::XPath.first(xml, '//SOAP-ENV:Body')
-        response = root ? parse_element(root[0]) : { :response => soap }
+        response = root ? parse_element(root[0]) : { response: soap }
 
         success, message, authorization, avs, cvv = false, FAILURE_MESSAGE, nil, nil, nil