activemerchant 1.87.0 → 1.88.0

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

@@ -408,8 +408,8 @@ module ActiveMerchant #:nodoc:
 
       def add_signature(parameters)
         if @options[:signature].blank?
-           ActiveMerchant.deprecated(OGONE_NO_SIGNATURE_DEPRECATION_MESSAGE) unless(@options[:signature_encryptor] == 'none')
-           return
+          ActiveMerchant.deprecated(OGONE_NO_SIGNATURE_DEPRECATION_MESSAGE) unless(@options[:signature_encryptor] == 'none')
+          return
         end
 
         add_pair parameters, 'SHASign', calculate_signature(parameters, @options[:signature_encryptor], @options[:signature])

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

@@ -247,15 +247,15 @@ module ActiveMerchant #:nodoc:
         message = response['message'] if response['code'] == 'invalid_card'
         case message
         when /brand not supported/
-            STANDARD_ERROR_CODE[:invalid_number]
+          STANDARD_ERROR_CODE[:invalid_number]
         when /number is invalid/
-            STANDARD_ERROR_CODE[:incorrect_number]
+          STANDARD_ERROR_CODE[:incorrect_number]
         when /expiration date cannot be in the past/
-            STANDARD_ERROR_CODE[:expired_card]
+          STANDARD_ERROR_CODE[:expired_card]
         when /expiration \w+ is invalid/
-            STANDARD_ERROR_CODE[:invalid_expiry_date]
+          STANDARD_ERROR_CODE[:invalid_expiry_date]
         else
-            STANDARD_ERROR_CODE[:processing_error]
+          STANDARD_ERROR_CODE[:processing_error]
         end
       end
 

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

@@ -189,7 +189,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_authentication(post)
-          post[:authentication] = { entityId: @options[:entity_id], password: @options[:password], userId: @options[:user_id]}
+        post[:authentication] = { entityId: @options[:entity_id], password: @options[:password], userId: @options[:user_id]}
       end
 
       def add_customer_data(post, payment, options)

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

@@ -129,12 +129,12 @@ module ActiveMerchant #:nodoc:
         options[:money] = money
         case payment_method
         when String
-            self.send("#{action}_with_token", money, payment_method, options)
+          self.send("#{action}_with_token", money, payment_method, options)
         else
-            MultiResponse.run do |r|
-              r.process { save_card(payment_method, options) }
-              r.process { self.send("#{action}_with_token", money, r.authorization, options) }
-            end
+          MultiResponse.run do |r|
+            r.process { save_card(payment_method, options) }
+            r.process { self.send("#{action}_with_token", money, r.authorization, options) }
+          end
         end
       end
 

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

@@ -108,7 +108,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def build_response(success, message, response, options = {})
-         Response.new(success, message, response, options)
+        Response.new(success, message, response, options)
       end
     end
   end

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

@@ -100,101 +100,101 @@ module ActiveMerchant #:nodoc:
 
       private
 
-        def new_request
-          {
-            :pi    => @options[:paystation_id], # paystation account id
-            :gi    => @options[:gateway_id],    # paystation gateway id
-            '2p'   => 't',                      # two-party transaction type
-            :nr    => 't',                      # -- redirect??
-            :df    => 'yymm'                    # date format: optional sometimes, required others
-          }
-        end
-
-        def add_customer_data(post, options)
-          post[:mc] = options[:customer]
-        end
+      def new_request
+        {
+          :pi    => @options[:paystation_id], # paystation account id
+          :gi    => @options[:gateway_id],    # paystation gateway id
+          '2p'   => 't',                      # two-party transaction type
+          :nr    => 't',                      # -- redirect??
+          :df    => 'yymm'                    # date format: optional sometimes, required others
+        }
+      end
 
-        def add_invoice(post, options)
-          post[:ms] = generate_unique_id
-          post[:mo] = options[:description]
-          post[:mr] = options[:order_id]
-        end
+      def add_customer_data(post, options)
+        post[:mc] = options[:customer]
+      end
 
-        def add_credit_card(post, credit_card)
-          post[:cn] = credit_card.number
-          post[:ct] = credit_card.brand
-          post[:ex] = format_date(credit_card.month, credit_card.year)
-          post[:cc] = credit_card.verification_value if credit_card.verification_value?
-        end
+      def add_invoice(post, options)
+        post[:ms] = generate_unique_id
+        post[:mo] = options[:description]
+        post[:mr] = options[:order_id]
+      end
 
-        def add_token(post, token)
-          post[:fp] = 't'    # turn on "future payments" - what paystation calls Token Billing
-          post[:ft] = token
-        end
+      def add_credit_card(post, credit_card)
+        post[:cn] = credit_card.number
+        post[:ct] = credit_card.brand
+        post[:ex] = format_date(credit_card.month, credit_card.year)
+        post[:cc] = credit_card.verification_value if credit_card.verification_value?
+      end
 
-        def store_credit_card(post, options)
-          post[:fp] = 't'                                # turn on "future payments" - what paystation calls Token Billing
-          post[:fs] = 't'                                # tells paystation to store right now, not bill
-          post[:ft] = options[:token] if options[:token] # specify a token to use that, or let Paystation generate one
-        end
+      def add_token(post, token)
+        post[:fp] = 't'    # turn on "future payments" - what paystation calls Token Billing
+        post[:ft] = token
+      end
 
-        def add_authorize_flag(post, options)
-          post[:pa] = 't' # tells Paystation that this is a pre-auth authorisation payment (account must be in pre-auth mode)
-        end
+      def store_credit_card(post, options)
+        post[:fp] = 't'                                # turn on "future payments" - what paystation calls Token Billing
+        post[:fs] = 't'                                # tells paystation to store right now, not bill
+        post[:ft] = options[:token] if options[:token] # specify a token to use that, or let Paystation generate one
+      end
 
-        def add_refund_specific_fields(post, authorization)
-          post[:rc] = 't'
-          post[:rt] = authorization
-        end
+      def add_authorize_flag(post, options)
+        post[:pa] = 't' # tells Paystation that this is a pre-auth authorisation payment (account must be in pre-auth mode)
+      end
 
-        def add_authorization_token(post, auth_token, verification_value = nil)
-          post[:cp] = 't' # Capture Payment flag – tells Paystation this transaction should be treated as a capture payment
-          post[:cx] = auth_token
-          post[:cc] = verification_value
-        end
+      def add_refund_specific_fields(post, authorization)
+        post[:rc] = 't'
+        post[:rt] = authorization
+      end
 
-        def add_amount(post, money, options)
-          post[:am] = amount(money)
-          post[:cu] = options[:currency] || currency(money)
-        end
+      def add_authorization_token(post, auth_token, verification_value = nil)
+        post[:cp] = 't' # Capture Payment flag – tells Paystation this transaction should be treated as a capture payment
+        post[:cx] = auth_token
+        post[:cc] = verification_value
+      end
 
-        def parse(xml_response)
-          response = {}
+      def add_amount(post, money, options)
+        post[:am] = amount(money)
+        post[:cu] = options[:currency] || currency(money)
+      end
 
-          xml = REXML::Document.new(xml_response)
+      def parse(xml_response)
+        response = {}
 
-          xml.elements.each("#{xml.root.name}/*") do |element|
-            response[element.name.underscore.to_sym] = element.text
-          end
+        xml = REXML::Document.new(xml_response)
 
-          response
+        xml.elements.each("#{xml.root.name}/*") do |element|
+          response[element.name.underscore.to_sym] = element.text
         end
 
-        def commit(post)
-          post[:tm] = 'T' if test?
-          pstn_prefix_params = post.collect { |key, value| "pstn_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+        response
+      end
 
-          data     = ssl_post(self.live_url, "#{pstn_prefix_params}&paystation=_empty")
-          response = parse(data)
-          message  = message_from(response)
+      def commit(post)
+        post[:tm] = 'T' if test?
+        pstn_prefix_params = post.collect { |key, value| "pstn_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
 
-          PaystationResponse.new(success?(response), message, response,
-            :test          => (response[:tm]&.casecmp('t')&.zero?),
-            :authorization => response[:paystation_transaction_id]
-          )
-        end
+        data     = ssl_post(self.live_url, "#{pstn_prefix_params}&paystation=_empty")
+        response = parse(data)
+        message  = message_from(response)
 
-        def success?(response)
-          (response[:ec] == SUCCESSFUL_RESPONSE_CODE) || (response[:ec] == SUCCESSFUL_FUTURE_PAYMENT)
-        end
+        PaystationResponse.new(success?(response), message, response,
+          :test          => (response[:tm]&.casecmp('t')&.zero?),
+          :authorization => response[:paystation_transaction_id]
+        )
+      end
 
-        def message_from(response)
-          response[:em]
-        end
+      def success?(response)
+        (response[:ec] == SUCCESSFUL_RESPONSE_CODE) || (response[:ec] == SUCCESSFUL_FUTURE_PAYMENT)
+      end
 
-        def format_date(month, year)
-          "#{format(year, :two_digits)}#{format(month, :two_digits)}"
-        end
+      def message_from(response)
+        response[:em]
+      end
+
+      def format_date(month, year)
+        "#{format(year, :two_digits)}#{format(month, :two_digits)}"
+      end
 
     end
 

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

@@ -365,7 +365,7 @@ module ActiveMerchant #:nodoc:
         when 'verify_credentials'
           response['code'] == 'SUCCESS'
         when 'refund', 'void'
-        response['code'] == 'SUCCESS' && response['transactionResponse'] && (response['transactionResponse']['state'] == 'PENDING' || response['transactionResponse']['state'] == 'APPROVED')
+          response['code'] == 'SUCCESS' && response['transactionResponse'] && (response['transactionResponse']['state'] == 'PENDING' || response['transactionResponse']['state'] == 'APPROVED')
         else
           response['code'] == 'SUCCESS' && response['transactionResponse'] && (response['transactionResponse']['state'] == 'APPROVED')
         end

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

@@ -252,9 +252,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def success?(response)
-      return FRAUD_WARNING_CODES.concat(['0']).include?(response['errors'].first['code']) if response['errors']
+        return FRAUD_WARNING_CODES.concat(['0']).include?(response['errors'].first['code']) if response['errors']
 
-      !['DECLINED', 'CANCELLED'].include?(response['status'])
+        !['DECLINED', 'CANCELLED'].include?(response['status'])
       end
 
       def message_from(response)

data/lib/active_merchant/billing/gateways/quickpay/quickpay_v10.rb

@@ -99,197 +99,197 @@ module ActiveMerchant
 
       private
 
-        def authorization_params(money, credit_card_or_reference, options = {})
-          post = {}
-
-          add_amount(post, money, options)
-          add_credit_card_or_reference(post, credit_card_or_reference)
-          add_additional_params(:authorize, post, options)
+      def authorization_params(money, credit_card_or_reference, options = {})
+        post = {}
 
-          post
-        end
+        add_amount(post, money, options)
+        add_credit_card_or_reference(post, credit_card_or_reference)
+        add_additional_params(:authorize, post, options)
 
-        def capture_params(money, credit_card, options = {})
-          post = {}
+        post
+      end
 
-          add_amount(post, money, options)
-          add_additional_params(:capture, post, options)
+      def capture_params(money, credit_card, options = {})
+        post = {}
 
-          post
-        end
+        add_amount(post, money, options)
+        add_additional_params(:capture, post, options)
 
-        def create_store(options = {})
-          post = {}
-          commit('/cards', post)
-        end
+        post
+      end
 
-        def authorize_store(identification, credit_card, options = {})
-          post = {}
+      def create_store(options = {})
+        post = {}
+        commit('/cards', post)
+      end
 
-          add_credit_card_or_reference(post, credit_card, options)
-          commit(synchronized_path("/cards/#{identification}/authorize"), post)
-        end
+      def authorize_store(identification, credit_card, options = {})
+        post = {}
 
-        def create_token(identification, options)
-          post = {}
-          commit(synchronized_path("/cards/#{identification}/tokens"), post)
-        end
+        add_credit_card_or_reference(post, credit_card, options)
+        commit(synchronized_path("/cards/#{identification}/authorize"), post)
+      end
 
-        def create_payment(money, options = {})
-          post = {}
-          add_currency(post, money, options)
-          add_invoice(post, options)
-          commit('/payments', post)
-        end
+      def create_token(identification, options)
+        post = {}
+        commit(synchronized_path("/cards/#{identification}/tokens"), post)
+      end
 
-        def commit(action, params = {})
-          success = false
-          begin
-            response = parse(ssl_post(self.live_url + action, params.to_json, headers))
-            success = successful?(response)
-          rescue ResponseError => e
-            response = response_error(e.response.body)
-          rescue JSON::ParserError
-            response = json_error(response)
-          end
+      def create_payment(money, options = {})
+        post = {}
+        add_currency(post, money, options)
+        add_invoice(post, options)
+        commit('/payments', post)
+      end
 
-          Response.new(success, message_from(success, response), response,
-            :test => test?,
-            :authorization => authorization_from(response)
-          )
+      def commit(action, params = {})
+        success = false
+        begin
+          response = parse(ssl_post(self.live_url + action, params.to_json, headers))
+          success = successful?(response)
+        rescue ResponseError => e
+          response = response_error(e.response.body)
+        rescue JSON::ParserError
+          response = json_error(response)
         end
 
-        def authorization_from(response)
-          if response['token']
-            response['token'].to_s
-          else
-             response['id'].to_s
-          end
-        end
+        Response.new(success, message_from(success, response), response,
+          :test => test?,
+          :authorization => authorization_from(response)
+        )
+      end
 
-        def add_currency(post, money, options)
-          post[:currency] = options[:currency] || currency(money)
+      def authorization_from(response)
+        if response['token']
+          response['token'].to_s
+        else
+          response['id'].to_s
         end
+      end
 
-        def add_amount(post, money, options)
-          post[:amount] = options[:amount] || amount(money)
-        end
+      def add_currency(post, money, options)
+        post[:currency] = options[:currency] || currency(money)
+      end
 
-        def add_autocapture(post, value)
-          post[:auto_capture] = value
-        end
+      def add_amount(post, money, options)
+        post[:amount] = options[:amount] || amount(money)
+      end
 
-        def add_order_id(post, options)
-          requires!(options, :order_id)
-          post[:order_id] = format_order_id(options[:order_id])
-        end
+      def add_autocapture(post, value)
+        post[:auto_capture] = value
+      end
 
-        def add_invoice(post, options)
-          add_order_id(post, options)
+      def add_order_id(post, options)
+        requires!(options, :order_id)
+        post[:order_id] = format_order_id(options[:order_id])
+      end
 
-          if options[:billing_address]
-            post[:invoice_address]  = map_address(options[:billing_address])
-          end
+      def add_invoice(post, options)
+        add_order_id(post, options)
 
-          if options[:shipping_address]
-            post[:shipping_address] = map_address(options[:shipping_address])
-          end
+        if options[:billing_address]
+          post[:invoice_address]  = map_address(options[:billing_address])
+        end
 
-          [:metadata, :branding_id, :variables].each do |field|
-            post[field] = options[field] if options[field]
-          end
+        if options[:shipping_address]
+          post[:shipping_address] = map_address(options[:shipping_address])
         end
 
-        def add_additional_params(action, post, options = {})
-          MD5_CHECK_FIELDS[API_VERSION][action].each do |key|
-            key       = key.to_sym
-            post[key] = options[key] if options[key]
-          end
+        [:metadata, :branding_id, :variables].each do |field|
+          post[field] = options[field] if options[field]
         end
+      end
 
-        def add_credit_card_or_reference(post, credit_card_or_reference, options = {})
-          post[:card]             ||= {}
-          if credit_card_or_reference.is_a?(String)
-            post[:card][:token] = credit_card_or_reference
-          else
-            post[:card][:number]     = credit_card_or_reference.number
-            post[:card][:cvd]        = credit_card_or_reference.verification_value
-            post[:card][:expiration] = expdate(credit_card_or_reference)
-            post[:card][:issued_to]  = credit_card_or_reference.name
-          end
+      def add_additional_params(action, post, options = {})
+        MD5_CHECK_FIELDS[API_VERSION][action].each do |key|
+          key       = key.to_sym
+          post[key] = options[key] if options[key]
         end
+      end
 
-        def parse(body)
-          JSON.parse(body)
+      def add_credit_card_or_reference(post, credit_card_or_reference, options = {})
+        post[:card]             ||= {}
+        if credit_card_or_reference.is_a?(String)
+          post[:card][:token] = credit_card_or_reference
+        else
+          post[:card][:number]     = credit_card_or_reference.number
+          post[:card][:cvd]        = credit_card_or_reference.verification_value
+          post[:card][:expiration] = expdate(credit_card_or_reference)
+          post[:card][:issued_to]  = credit_card_or_reference.name
         end
+      end
 
-        def successful?(response)
-          has_error    = response['errors']
-          invalid_code = invalid_operation_code?(response)
+      def parse(body)
+        JSON.parse(body)
+      end
 
-          !(has_error || invalid_code)
-        end
+      def successful?(response)
+        has_error    = response['errors']
+        invalid_code = invalid_operation_code?(response)
 
-        def message_from(success, response)
-          success ? 'OK' : (response['message'] || invalid_operation_message(response) || 'Unknown error - please contact QuickPay')
-        end
+        !(has_error || invalid_code)
+      end
 
-        def invalid_operation_code?(response)
-          if response['operations']
-            operation = response['operations'].last
-            operation && operation['qp_status_code'] != '20000'
-          end
-        end
+      def message_from(success, response)
+        success ? 'OK' : (response['message'] || invalid_operation_message(response) || 'Unknown error - please contact QuickPay')
+      end
 
-        def invalid_operation_message(response)
-          response['operations'] && response['operations'].last['qp_status_msg']
+      def invalid_operation_code?(response)
+        if response['operations']
+          operation = response['operations'].last
+          operation && operation['qp_status_code'] != '20000'
         end
+      end
 
-        def map_address(address)
-          return {} if address.nil?
-          requires!(address, :name, :address1, :city, :zip, :country)
-          country = Country.find(address[:country])
-          mapped = {
-            :name         => address[:name],
-            :street       => address[:address1],
-            :city         => address[:city],
-            :region       => address[:address2],
-            :zip_code     => address[:zip],
-            :country_code => country.code(:alpha3).value
-          }
-          mapped
-        end
+      def invalid_operation_message(response)
+        response['operations'] && response['operations'].last['qp_status_msg']
+      end
 
-        def format_order_id(order_id)
-          truncate(order_id.to_s.gsub(/#/, ''), 20)
-        end
+      def map_address(address)
+        return {} if address.nil?
+        requires!(address, :name, :address1, :city, :zip, :country)
+        country = Country.find(address[:country])
+        mapped = {
+          :name         => address[:name],
+          :street       => address[:address1],
+          :city         => address[:city],
+          :region       => address[:address2],
+          :zip_code     => address[:zip],
+          :country_code => country.code(:alpha3).value
+        }
+        mapped
+      end
 
-        def headers
-          auth = Base64.strict_encode64(":#{@options[:api_key]}")
-          {
-            'Authorization'  => 'Basic ' + auth,
-            'User-Agent'     => "Quickpay-v#{API_VERSION} ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
-            'Accept'         => 'application/json',
-            'Accept-Version' => "v#{API_VERSION}",
-            'Content-Type'   => 'application/json'
-          }
-        end
+      def format_order_id(order_id)
+        truncate(order_id.to_s.gsub(/#/, ''), 20)
+      end
 
-        def response_error(raw_response)
-          parse(raw_response)
-        rescue JSON::ParserError
-          json_error(raw_response)
-        end
+      def headers
+        auth = Base64.strict_encode64(":#{@options[:api_key]}")
+        {
+          'Authorization'  => 'Basic ' + auth,
+          'User-Agent'     => "Quickpay-v#{API_VERSION} ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          'Accept'         => 'application/json',
+          'Accept-Version' => "v#{API_VERSION}",
+          'Content-Type'   => 'application/json'
+        }
+      end
 
-        def json_error(raw_response)
-          msg = 'Invalid response received from the Quickpay API.'
-          msg += "  (The raw response returned by the API was #{raw_response.inspect})"
-          { 'message' => msg }
-        end
+      def response_error(raw_response)
+        parse(raw_response)
+      rescue JSON::ParserError
+        json_error(raw_response)
+      end
 
-        def synchronized_path(path)
-          "#{path}?synchronized"
-        end
+      def json_error(raw_response)
+        msg = 'Invalid response received from the Quickpay API.'
+        msg += "  (The raw response returned by the API was #{raw_response.inspect})"
+        { 'message' => msg }
+      end
+
+      def synchronized_path(path)
+        "#{path}?synchronized"
+      end
     end
   end
 end