activemerchant 1.79.2 → 1.129.0

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

@@ -24,11 +24,11 @@ module ActiveMerchant
           r.process {
             post = authorization_params(money, credit_card_or_reference, options)
             add_autocapture(post, false)
-            commit(synchronized_path("/payments/#{r.responses.last.params["id"]}/authorize"), post)
+            commit(synchronized_path("/payments/#{r.responses.last.params['id']}/authorize"), post)
           }
           r.process {
             post = capture_params(money, credit_card_or_reference, options)
-            commit(synchronized_path("/payments/#{r.responses.last.params["id"]}/capture"), post)
+            commit(synchronized_path("/payments/#{r.responses.last.params['id']}/capture"), post)
           }
         end
       end
@@ -42,7 +42,7 @@ module ActiveMerchant
           r.process { create_payment(money, options) }
           r.process {
             post = authorization_params(money, credit_card_or_reference, options)
-            commit(synchronized_path("/payments/#{r.responses.last.params["id"]}/authorize"), post)
+            commit(synchronized_path("/payments/#{r.responses.last.params['id']}/authorize"), post)
           }
         end
       end
@@ -68,7 +68,7 @@ module ActiveMerchant
         commit(synchronized_path("/payments/#{identification}/refund"), post)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -78,7 +78,7 @@ module ActiveMerchant
       def store(credit_card, options = {})
         MultiResponse.run do |r|
           r.process { create_store(options) }
-          r.process { authorize_store(r.authorization, credit_card, options)}
+          r.process { authorize_store(r.authorization, credit_card, options) }
         end
       end
 
@@ -99,201 +99,199 @@ 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, options)
+        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
+        post[:invoice_address]  = map_address(options[:billing_address]) if options[:billing_address]
 
-          [:metadata, :branding_id, :variables].each do |field|
-            post[field] = options[field] if options[field]
-          end
+        post[:shipping_address] = map_address(options[:shipping_address]) if options[:shipping_address]
+
+        %i[metadata branding_id variables].each do |field|
+          post[field] = options[field] if options[field]
         end
+      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
+      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 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_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 parse(body)
-          JSON.parse(body)
+        if options[:three_d_secure]
+          post[:card][:cavv] = options.dig(:three_d_secure, :cavv)
+          post[:card][:eci] = options.dig(:three_d_secure, :eci)
+          post[:card][:xav] = options.dig(:three_d_secure, :xid)
         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.delete('#'), 20)
+      end
 
-        def response_error(raw_response)
-          begin
-            parse(raw_response)
-          rescue JSON::ParserError
-            json_error(raw_response)
-          end
-        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

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

@@ -6,7 +6,7 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class QuickpayV4to7Gateway < Gateway
       include QuickpayCommon
-      self.live_url = self.test_url = 'https://secure.quickpay.dk/api'    
+      self.live_url = self.test_url = 'https://secure.quickpay.dk/api'
       APPROVED = '000'
 
       # The login is the QuickpayId
@@ -136,11 +136,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_description(post, options)
-        post[:description] = options[:description] || "Description"
+        post[:description] = options[:description] || 'Description'
       end
 
       def add_testmode(post)
         return if post[:transaction].present?
+
         post[:testmode] = test? ? '1' : '0'
       end
 
@@ -164,9 +165,8 @@ module ActiveMerchant #:nodoc:
         response = parse(ssl_post(self.live_url, post_data(action, params)))
 
         Response.new(successful?(response), message_from(response), response,
-          :test => test?,
-          :authorization => response[:transaction]
-        )
+          test: test?,
+          authorization: response[:transaction])
       end
 
       def successful?(response)
@@ -196,7 +196,7 @@ module ActiveMerchant #:nodoc:
         params[:apikey] = @options[:apikey] if @options[:apikey]
         params[:md5check] = generate_check_hash(action, params)
 
-        params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       def generate_check_hash(action, params)
@@ -219,9 +219,8 @@ module ActiveMerchant #:nodoc:
 
       # Limited to 20 digits max
       def format_order_number(number)
-        number.to_s.gsub(/[^\w]/, '').rjust(4, "0")[0...20]
+        number.to_s.gsub(/[^\w]/, '').rjust(4, '0')[0...20]
       end
     end
   end
 end
-

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

@@ -10,7 +10,7 @@ module ActiveMerchant #:nodoc:
       self.abstract_class = true
 
       def self.new(options = {})
-        options.fetch(:login) { raise ArgumentError.new("Missing required parameter: login") }
+        options.fetch(:login) { raise ArgumentError.new('Missing required parameter: login') }
 
         version = options[:login].to_i < 10000000 ? 10 : 7
         if version <= 7
@@ -19,8 +19,6 @@ module ActiveMerchant #:nodoc:
           QuickpayV10Gateway.new(options)
         end
       end
-
     end
   end
 end
-