activemerchant 1.79.2 → 1.129.0

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

@@ -6,17 +6,14 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners]
+      self.supported_cardtypes = %i[visa master american_express discover diners]
 
       self.homepage_url = 'http://payments.intuit.com'
       self.display_name = 'QuickBooks Payments'
-      ENDPOINT =  "/quickbooks/v4/payments/charges"
-      OAUTH_ENDPOINTS = {
-        site: 'https://oauth.intuit.com',
-        request_token_path: '/oauth/v1/get_request_token',
-        authorize_url: 'https://appcenter.intuit.com/Connect/Begin',
-        access_token_path: '/oauth/v1/get_access_token'
-      }
+      BASE = '/quickbooks/v4/payments'
+      ENDPOINT = "#{BASE}/charges"
+      VOID_ENDPOINT = "#{BASE}/txn-requests"
+      REFRESH_URI = 'https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer'
 
       # https://developer.intuit.com/docs/0150_payments/0300_developer_guides/error_handling
 
@@ -45,13 +42,21 @@ module ActiveMerchant #:nodoc:
         'PMT-5001' => STANDARD_ERROR_CODE[:card_declined],      # Merchant does not support given payment method
 
         # System Error
-        'PMT-6000' => STANDARD_ERROR_CODE[:processing_error],   # A temporary Issue prevented this request from being processed.
+        'PMT-6000' => STANDARD_ERROR_CODE[:processing_error], # A temporary Issue prevented this request from being processed.
       }
 
-      FRAUD_WARNING_CODES = ['PMT-1000','PMT-1001','PMT-1002','PMT-1003']
+      FRAUD_WARNING_CODES = ['PMT-1000', 'PMT-1001', 'PMT-1002', 'PMT-1003']
 
       def initialize(options = {})
-        requires!(options, :consumer_key, :consumer_secret, :access_token, :token_secret, :realm)
+        # Quickbooks is deprecating OAuth 1.0 on December 17, 2019.
+        # OAuth 2.0 requires a client_id, client_secret, access_token, and refresh_token
+        # To maintain backwards compatibility, check for the presence of a refresh_token (only specified for OAuth 2.0)
+        # When present, validate that all OAuth 2.0 options are present
+        if options[:refresh_token]
+          requires!(options, :client_id, :client_secret, :access_token, :refresh_token)
+        else
+          requires!(options, :consumer_key, :consumer_secret, :access_token, :token_secret, :realm)
+        end
         @options = options
         super
       end
@@ -60,41 +65,58 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_amount(post, money, options)
         add_charge_data(post, payment, options)
-        post[:capture] = "true"
+        post[:capture] = 'true'
 
-        commit(ENDPOINT, post)
+        response = commit(ENDPOINT, post)
+        check_token_response(response, ENDPOINT, post, options)
       end
 
       def authorize(money, payment, options = {})
         post = {}
         add_amount(post, money, options)
         add_charge_data(post, payment, options)
-        post[:capture] = "false"
+        post[:capture] = 'false'
 
-        commit(ENDPOINT, post)
+        response = commit(ENDPOINT, post)
+        check_token_response(response, ENDPOINT, post, options)
       end
 
       def capture(money, authorization, options = {})
         post = {}
-        capture_uri = "#{ENDPOINT}/#{CGI.escape(authorization)}/capture"
+        authorization, = split_authorization(authorization)
         post[:amount] = localized_amount(money, currency(money))
         add_context(post, options)
 
-        commit(capture_uri, post)
+        response = commit(capture_uri(authorization), post)
+        check_token_response(response, capture_uri(authorization), post, options)
       end
 
       def refund(money, authorization, options = {})
         post = {}
         post[:amount] = localized_amount(money, currency(money))
         add_context(post, options)
+        authorization, = split_authorization(authorization)
 
-        commit(refund_uri(authorization), post)
+        response = commit(refund_uri(authorization), post)
+        check_token_response(response, refund_uri(authorization), post, options)
+      end
+
+      def void(authorization, options = {})
+        _, request_id = split_authorization(authorization)
+
+        response = commit(void_uri(request_id))
+        check_token_response(response, void_uri(request_id), {}, options)
       end
 
       def verify(credit_card, options = {})
         authorize(1.00, credit_card, options)
       end
 
+      def refresh
+        response = refresh_access_token
+        response_object(response)
+      end
+
       def supports_scrubbing?
         true
       end
@@ -107,7 +129,12 @@ module ActiveMerchant #:nodoc:
           gsub(%r((oauth_signature=\")[a-zA-Z%0-9]+), '\1[FILTERED]').
           gsub(%r((oauth_token=\")\w+), '\1[FILTERED]').
           gsub(%r((number\D+)\d{16}), '\1[FILTERED]').
-          gsub(%r((cvc\D+)\d{3}), '\1[FILTERED]')
+          gsub(%r((cvc\D+)\d{3}), '\1[FILTERED]').
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((access_token\\?":\\?")[\w\-\.]+)i, '\1[FILTERED]').
+          gsub(%r((refresh_token\\?":\\?")\w+), '\1[FILTERED]').
+          gsub(%r((refresh_token=)\w+), '\1[FILTERED]').
+          gsub(%r((Authorization: Bearer )[\w\-\.]+)i, '\1[FILTERED]\2')
       end
 
       private
@@ -118,14 +145,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_address(post, options)
-        return unless post[:card] && post[:card].kind_of?(Hash)
+        return unless post[:card]&.kind_of?(Hash)
 
         card_address = {}
         if address = options[:billing_address] || options[:address]
           card_address[:streetAddress] = address[:address1]
           card_address[:city] = address[:city]
-          card_address[:region] = address[:state] || address[:region]
-          card_address[:country] = address[:country]
+          region = address[:state] || address[:region]
+          card_address[:region] = region if region.present?
+          card_address[:country] = address[:country] if address[:country].present?
           card_address[:postalCode] = address[:zip] if address[:zip]
         end
         post[:card][:address] = card_address
@@ -145,7 +173,7 @@ module ActiveMerchant #:nodoc:
       def add_creditcard(post, creditcard, options = {})
         card = {}
         card[:number] = creditcard.number
-        card[:expMonth] = "%02d" % creditcard.month
+        card[:expMonth] = '%02d' % creditcard.month
         card[:expYear] = creditcard.year
         card[:cvc] = creditcard.verification_value if creditcard.verification_value?
         card[:name] = creditcard.name if creditcard.name
@@ -170,30 +198,30 @@ module ActiveMerchant #:nodoc:
         # The QuickBooks API returns HTTP 4xx on failed transactions, which causes a
         # ResponseError raise, so we have to inspect the response and discern between
         # a legitimate HTTP error and an actual gateway transactional error.
-        response = begin
-          case method
-          when :post
-            ssl_post(endpoint, post_data(body), headers(:post, endpoint))
-          when :get
-            ssl_request(:get, endpoint, nil, headers(:get, endpoint))
-          else
-            raise ArgumentError, "Invalid HTTP method: #{method}. Valid methods are :post and :get"
+        headers = {}
+        response =
+          begin
+            headers = headers(method, endpoint)
+            method == :post ? ssl_post(endpoint, post_data(body), headers) : ssl_request(:get, endpoint, nil, headers)
+          rescue ResponseError => e
+            extract_response_body_or_raise(e)
           end
-        rescue ResponseError => e
-          extract_response_body_or_raise(e)
-        end
 
-        response_object(response)
+        response_object(response, headers)
       end
 
-      def response_object(raw_response)
+      def response_object(raw_response, headers = {})
         parsed_response = parse(raw_response)
 
+        # Include access_token and refresh_token in params for OAuth 2.0
+        parsed_response['access_token'] = @options[:access_token] if @options[:refresh_token]
+        parsed_response['refresh_token'] = @options[:refresh_token] if @options[:refresh_token]
+
         Response.new(
           success?(parsed_response),
           message_from(parsed_response),
           parsed_response,
-          authorization: authorization_from(parsed_response),
+          authorization: authorization_from(parsed_response, headers),
           test: test?,
           cvv_result: cvv_code_from(parsed_response),
           error_code: errors_from(parsed_response),
@@ -210,7 +238,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def headers(method, uri)
-        raise ArgumentError, "Invalid HTTP method: #{method}. Valid methods are :post and :get" unless [:post, :get].include?(method)
+        return oauth_v2_headers if @options[:refresh_token]
+
+        raise ArgumentError, "Invalid HTTP method: #{method}. Valid methods are :post and :get" unless %i[post get].include?(method)
+
         request_uri = URI.parse(uri)
 
         # Following the guidelines from http://nouncer.com/oauth/authentication.html
@@ -218,31 +249,70 @@ module ActiveMerchant #:nodoc:
           oauth_nonce: generate_unique_id,
           oauth_timestamp: Time.now.to_i.to_s,
           oauth_signature_method: 'HMAC-SHA1',
-          oauth_version: "1.0",
+          oauth_version: '1.0',
           oauth_consumer_key: @options[:consumer_key],
           oauth_token: @options[:access_token]
         }
 
         # prepare components for signature
-        oauth_signature_base_string = [method.to_s.upcase, request_uri.to_s, oauth_parameters.to_param].map{|v| CGI.escape(v) }.join('&')
-        oauth_signing_key = [@options[:consumer_secret], @options[:token_secret]].map{|v| CGI.escape(v)}.join('&')
+        oauth_signature_base_string = [method.to_s.upcase, request_uri.to_s, oauth_parameters.to_param].map { |v| CGI.escape(v) }.join('&')
+        oauth_signing_key = [@options[:consumer_secret], @options[:token_secret]].map { |v| CGI.escape(v) }.join('&')
         hmac_signature = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha1'), oauth_signing_key, oauth_signature_base_string)
 
         # append signature to required OAuth parameters
-        oauth_parameters[:oauth_signature] = CGI.escape(Base64.encode64(hmac_signature).chomp.gsub(/\n/, ''))
+        oauth_parameters[:oauth_signature] = CGI.escape(Base64.encode64(hmac_signature).chomp.delete("\n"))
 
         # prepare Authorization header string
-        oauth_parameters = Hash[oauth_parameters.sort_by {|k, _| k}]
+        oauth_parameters = Hash[oauth_parameters.sort_by { |k, _| k }]
         oauth_headers = ["OAuth realm=\"#{@options[:realm]}\""]
-        oauth_headers += oauth_parameters.map {|k, v| "#{k}=\"#{v}\""}
+        oauth_headers += oauth_parameters.map { |k, v| "#{k}=\"#{v}\"" }
+
+        {
+          'Content-type' => 'application/json',
+          'Request-Id' => generate_unique_id,
+          'Authorization' => oauth_headers.join(', ')
+        }
+      end
 
+      def oauth_v2_headers
         {
-          "Content-type" => "application/json",
-          "Request-Id" => generate_unique_id,
-          "Authorization" => oauth_headers.join(', ')
+          'Content-Type'      => 'application/json',
+          'Request-Id'        => generate_unique_id,
+          'Accept'            => 'application/json',
+          'Authorization'     => "Bearer #{@options[:access_token]}"
         }
       end
 
+      def check_token_response(response, endpoint, body = {}, options = {})
+        return response unless @options[:refresh_token]
+        return response unless options[:allow_refresh]
+        return response unless response.params['code'] == 'AuthenticationFailed'
+
+        refresh_access_token
+        commit(endpoint, body)
+      end
+
+      def refresh_access_token
+        post = {}
+        post[:grant_type] = 'refresh_token'
+        post[:refresh_token] = @options[:refresh_token]
+        data = post.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+
+        basic_auth = Base64.strict_encode64("#{@options[:client_id]}:#{@options[:client_secret]}")
+        headers = {
+          'Content-Type'      => 'application/x-www-form-urlencoded',
+          'Accept'            => 'application/json',
+          'Authorization'     => "Basic #{basic_auth}"
+        }
+
+        response = ssl_post(REFRESH_URI, data, headers)
+        json_response = JSON.parse(response)
+
+        @options[:access_token] = json_response['access_token'] if json_response['access_token']
+        @options[:refresh_token] = json_response['refresh_token'] if json_response['refresh_token']
+        response
+      end
+
       def cvv_code_from(response)
         if response['errors'].present?
           FRAUD_WARNING_CODES.include?(response['errors'].first['code']) ? 'I' : ''
@@ -252,21 +322,30 @@ module ActiveMerchant #:nodoc:
       end
 
       def success?(response)
-      return FRAUD_WARNING_CODES.concat(['0']).include?(response['errors'].first['code']) if response['errors']
-        
-      !['DECLINED', 'CANCELLED'].include?(response['status'])
+        return FRAUD_WARNING_CODES.concat(['0']).include?(response['errors'].first['code']) if response['errors']
+
+        !%w[DECLINED CANCELLED].include?(response['status']) && !%w[AuthenticationFailed AuthorizationFailed].include?(response['code'])
       end
 
       def message_from(response)
-        response['errors'].present? ? response["errors"].map {|error_hash| error_hash["message"] }.join(" ") : response['status']
+        response['errors'].present? ? response['errors'].map { |error_hash| error_hash['message'] }.join(' ') : response['status']
       end
 
       def errors_from(response)
-        response['errors'].present? ? STANDARD_ERROR_CODE_MAPPING[response["errors"].first["code"]] : ""
+        if %w[AuthenticationFailed AuthorizationFailed].include?(response['code'])
+          response['code']
+        else
+          response['errors'].present? ? STANDARD_ERROR_CODE_MAPPING[response['errors'].first['code']] : ''
+        end
+      end
+
+      def authorization_from(response, headers = {})
+        [response['id'], headers['Request-Id']].join('|')
       end
 
-      def authorization_from(response)
-        response['id']
+      def split_authorization(authorization)
+        authorization, request_id = authorization.split('|')
+        [authorization, request_id]
       end
 
       def fraud_review_status_from(response)
@@ -283,7 +362,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def refund_uri(authorization)
-        "#{ENDPOINT}/#{CGI.escape(authorization)}/refunds"
+        "#{ENDPOINT}/#{CGI.escape(authorization.to_s)}/refunds"
+      end
+
+      def capture_uri(authorization)
+        "#{ENDPOINT}/#{CGI.escape(authorization.to_s)}/capture"
+      end
+
+      def void_uri(request_id)
+        "#{VOID_ENDPOINT}/#{CGI.escape(request_id.to_s)}/void"
       end
     end
   end

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

@@ -1,156 +1,154 @@
-
 module QuickpayCommon
-
   MD5_CHECK_FIELDS = {
     3 => {
-      :authorize => %w(protocol msgtype merchant ordernumber amount
-                       currency autocapture cardnumber expirationdate
-                       cvd cardtypelock testmode),
+      authorize: %w(protocol msgtype merchant ordernumber amount
+                    currency autocapture cardnumber expirationdate
+                    cvd cardtypelock testmode),
 
-      :capture   => %w(protocol msgtype merchant amount finalize transaction),
+      capture: %w(protocol msgtype merchant amount finalize transaction),
 
-      :cancel    => %w(protocol msgtype merchant transaction),
+      cancel: %w(protocol msgtype merchant transaction),
 
-      :refund    => %w(protocol msgtype merchant amount transaction),
+      refund: %w(protocol msgtype merchant amount transaction),
 
-      :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
-                       expirationdate cvd cardtypelock description testmode),
+      subscribe: %w(protocol msgtype merchant ordernumber cardnumber
+                    expirationdate cvd cardtypelock description testmode),
 
-      :recurring => %w(protocol msgtype merchant ordernumber amount
-                       currency autocapture transaction),
+      recurring: %w(protocol msgtype merchant ordernumber amount
+                    currency autocapture transaction),
 
-      :status    => %w(protocol msgtype merchant transaction),
+      status: %w(protocol msgtype merchant transaction),
 
-      :chstatus  => %w(protocol msgtype merchant)
+      chstatus: %w(protocol msgtype merchant)
     },
 
     4 => {
-      :authorize => %w(protocol msgtype merchant ordernumber amount
-                       currency autocapture cardnumber expirationdate cvd
-                       cardtypelock testmode fraud_remote_addr
-                       fraud_http_accept fraud_http_accept_language
-                       fraud_http_accept_encoding fraud_http_accept_charset
-                       fraud_http_referer fraud_http_user_agent apikey),
+      authorize: %w(protocol msgtype merchant ordernumber amount
+                    currency autocapture cardnumber expirationdate cvd
+                    cardtypelock testmode fraud_remote_addr
+                    fraud_http_accept fraud_http_accept_language
+                    fraud_http_accept_encoding fraud_http_accept_charset
+                    fraud_http_referer fraud_http_user_agent apikey),
 
-      :capture   => %w(protocol msgtype merchant amount finalize transaction apikey),
+      capture: %w(protocol msgtype merchant amount finalize transaction apikey),
 
-      :cancel    => %w(protocol msgtype merchant transaction apikey),
+      cancel: %w(protocol msgtype merchant transaction apikey),
 
-      :refund    => %w(protocol msgtype merchant amount transaction apikey),
+      refund: %w(protocol msgtype merchant amount transaction apikey),
 
-      :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
-                       expirationdate cvd cardtypelock description testmode
-                       fraud_remote_addr fraud_http_accept fraud_http_accept_language
-                       fraud_http_accept_encoding fraud_http_accept_charset
-                       fraud_http_referer fraud_http_user_agent apikey),
+      subscribe: %w(protocol msgtype merchant ordernumber cardnumber
+                    expirationdate cvd cardtypelock description testmode
+                    fraud_remote_addr fraud_http_accept fraud_http_accept_language
+                    fraud_http_accept_encoding fraud_http_accept_charset
+                    fraud_http_referer fraud_http_user_agent apikey),
 
-      :recurring => %w(protocol msgtype merchant ordernumber amount currency
-                       autocapture transaction apikey),
+      recurring: %w(protocol msgtype merchant ordernumber amount currency
+                    autocapture transaction apikey),
 
-      :status    => %w(protocol msgtype merchant transaction apikey),
+      status: %w(protocol msgtype merchant transaction apikey),
 
-      :chstatus  => %w(protocol msgtype merchant apikey)
+      chstatus: %w(protocol msgtype merchant apikey)
     },
 
     5 => {
-      :authorize => %w(protocol msgtype merchant ordernumber amount
-                       currency autocapture cardnumber expirationdate cvd
-                       cardtypelock testmode fraud_remote_addr
-                       fraud_http_accept fraud_http_accept_language
-                       fraud_http_accept_encoding fraud_http_accept_charset
-                       fraud_http_referer fraud_http_user_agent apikey),
+      authorize: %w(protocol msgtype merchant ordernumber amount
+                    currency autocapture cardnumber expirationdate cvd
+                    cardtypelock testmode fraud_remote_addr
+                    fraud_http_accept fraud_http_accept_language
+                    fraud_http_accept_encoding fraud_http_accept_charset
+                    fraud_http_referer fraud_http_user_agent apikey),
 
-      :capture   => %w(protocol msgtype merchant amount finalize transaction apikey),
+      capture: %w(protocol msgtype merchant amount finalize transaction apikey),
 
-      :cancel    => %w(protocol msgtype merchant transaction apikey),
+      cancel: %w(protocol msgtype merchant transaction apikey),
 
-      :refund    => %w(protocol msgtype merchant amount transaction apikey),
+      refund: %w(protocol msgtype merchant amount transaction apikey),
 
-      :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
-                       expirationdate cvd cardtypelock description testmode
-                       fraud_remote_addr fraud_http_accept fraud_http_accept_language
-                       fraud_http_accept_encoding fraud_http_accept_charset
-                       fraud_http_referer fraud_http_user_agent apikey),
+      subscribe: %w(protocol msgtype merchant ordernumber cardnumber
+                    expirationdate cvd cardtypelock description testmode
+                    fraud_remote_addr fraud_http_accept fraud_http_accept_language
+                    fraud_http_accept_encoding fraud_http_accept_charset
+                    fraud_http_referer fraud_http_user_agent apikey),
 
-      :recurring => %w(protocol msgtype merchant ordernumber amount currency
-                       autocapture transaction apikey),
+      recurring: %w(protocol msgtype merchant ordernumber amount currency
+                    autocapture transaction apikey),
 
-      :status    => %w(protocol msgtype merchant transaction apikey),
+      status: %w(protocol msgtype merchant transaction apikey),
 
-      :chstatus  => %w(protocol msgtype merchant apikey)
+      chstatus: %w(protocol msgtype merchant apikey)
     },
 
     6 => {
-      :authorize => %w(protocol msgtype merchant ordernumber amount
-                       currency autocapture cardnumber expirationdate cvd
-                       cardtypelock testmode fraud_remote_addr
-                       fraud_http_accept fraud_http_accept_language
-                       fraud_http_accept_encoding fraud_http_accept_charset
-                       fraud_http_referer fraud_http_user_agent apikey),
+      authorize: %w(protocol msgtype merchant ordernumber amount
+                    currency autocapture cardnumber expirationdate cvd
+                    cardtypelock testmode fraud_remote_addr
+                    fraud_http_accept fraud_http_accept_language
+                    fraud_http_accept_encoding fraud_http_accept_charset
+                    fraud_http_referer fraud_http_user_agent apikey),
 
-      :capture   => %w(protocol msgtype merchant amount finalize transaction
-                       apikey),
+      capture: %w(protocol msgtype merchant amount finalize transaction
+                  apikey),
 
-      :cancel    => %w(protocol msgtype merchant transaction apikey),
+      cancel: %w(protocol msgtype merchant transaction apikey),
 
-      :refund    => %w(protocol msgtype merchant amount transaction apikey),
+      refund: %w(protocol msgtype merchant amount transaction apikey),
 
-      :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
-                       expirationdate cvd cardtypelock description testmode
-                       fraud_remote_addr fraud_http_accept fraud_http_accept_language
-                       fraud_http_accept_encoding fraud_http_accept_charset
-                       fraud_http_referer fraud_http_user_agent apikey),
+      subscribe: %w(protocol msgtype merchant ordernumber cardnumber
+                    expirationdate cvd cardtypelock description testmode
+                    fraud_remote_addr fraud_http_accept fraud_http_accept_language
+                    fraud_http_accept_encoding fraud_http_accept_charset
+                    fraud_http_referer fraud_http_user_agent apikey),
 
-      :recurring => %w(protocol msgtype merchant ordernumber amount currency
-                       autocapture transaction apikey),
+      recurring: %w(protocol msgtype merchant ordernumber amount currency
+                    autocapture transaction apikey),
 
-      :status    => %w(protocol msgtype merchant transaction apikey),
+      status: %w(protocol msgtype merchant transaction apikey),
 
-      :chstatus  => %w(protocol msgtype merchant apikey)
+      chstatus: %w(protocol msgtype merchant apikey)
     },
 
     7 => {
-      :authorize => %w(protocol msgtype merchant ordernumber amount
-                       currency autocapture cardnumber expirationdate cvd
-                       acquirers cardtypelock testmode fraud_remote_addr
-                       fraud_http_accept fraud_http_accept_language
-                       fraud_http_accept_encoding fraud_http_accept_charset
-                       fraud_http_referer fraud_http_user_agent apikey),
+      authorize: %w(protocol msgtype merchant ordernumber amount
+                    currency autocapture cardnumber expirationdate cvd
+                    acquirers cardtypelock testmode fraud_remote_addr
+                    fraud_http_accept fraud_http_accept_language
+                    fraud_http_accept_encoding fraud_http_accept_charset
+                    fraud_http_referer fraud_http_user_agent apikey),
 
-      :capture   => %w(protocol msgtype merchant amount finalize transaction
-                       apikey),
+      capture: %w(protocol msgtype merchant amount finalize transaction
+                  apikey),
 
-      :cancel    => %w(protocol msgtype merchant transaction apikey),
+      cancel: %w(protocol msgtype merchant transaction apikey),
 
-      :refund    => %w(protocol msgtype merchant amount transaction apikey),
+      refund: %w(protocol msgtype merchant amount transaction apikey),
 
-      :subscribe => %w(protocol msgtype merchant ordernumber amount currency
-                       cardnumber expirationdate cvd acquirers cardtypelock
-                       description testmode fraud_remote_addr fraud_http_accept
-                       fraud_http_accept_language fraud_http_accept_encoding
-                       fraud_http_accept_charset fraud_http_referer
-                       fraud_http_user_agent apikey),
+      subscribe: %w(protocol msgtype merchant ordernumber amount currency
+                    cardnumber expirationdate cvd acquirers cardtypelock
+                    description testmode fraud_remote_addr fraud_http_accept
+                    fraud_http_accept_language fraud_http_accept_encoding
+                    fraud_http_accept_charset fraud_http_referer
+                    fraud_http_user_agent apikey),
 
-      :recurring => %w(protocol msgtype merchant ordernumber amount currency
-                       autocapture transaction apikey),
+      recurring: %w(protocol msgtype merchant ordernumber amount currency
+                    autocapture transaction apikey),
 
-      :status    => %w(protocol msgtype merchant transaction apikey),
+      status: %w(protocol msgtype merchant transaction apikey),
 
-      :chstatus  => %w(protocol msgtype merchant apikey)
+      chstatus: %w(protocol msgtype merchant apikey)
     },
-    
+
     10 => {
-      :authorize => %w(mobile_number acquirer autofee customer_id extras 
-                       zero_auth customer_ip),
-      :capture   => %w( extras ),
-      :cancel    => %w( extras ),
-      :refund    => %w( extras ),
-      :subscribe => %w( variables branding_id),
-      :authorize_subscription => %w( mobile_number acquirer customer_ip),
-      :recurring => %w(auto_capture autofee zero_auth)
+      authorize: %w(mobile_number acquirer autofee customer_id extras
+                    zero_auth customer_ip),
+      capture: %w(extras),
+      cancel: %w(extras),
+      refund: %w(extras),
+      subscribe: %w(variables branding_id),
+      authorize_subscription: %w(mobile_number acquirer customer_ip),
+      recurring: %w(auto_capture autofee zero_auth)
     }
   }
-  
+
   RESPONSE_CODES = {
     200 => 'OK',
     201 => 'Created',
@@ -165,24 +163,22 @@ module QuickpayCommon
     409 => 'Conflict',
     500 => 'Internal Server Error'
   }
-  
+
   def self.included(base)
     base.default_currency = 'DKK'
     base.money_format = :cents
-    
-    base.supported_cardtypes = [:dankort, :forbrugsforeningen, :visa, :master, 
-                                :american_express, :diners_club, :jcb, :maestro]
-    base.supported_countries = ['DE', 'DK', 'ES', 'FI', 'FR', 'FO', 'GB', 'IS', 'NO', 'SE']
+
+    base.supported_countries = %w[DE DK ES FI FR FO GB IS NO SE]
+    base.supported_cardtypes = %i[dankort forbrugsforeningen visa master
+                                  american_express diners_club jcb maestro]
     base.homepage_url = 'http://quickpay.net/'
     base.display_name = 'QuickPay'
-
   end
-    
+
   def expdate(credit_card)
     year  = format(credit_card.year, :two_digits)
     month = format(credit_card.month, :two_digits)
 
     "#{year}#{month}"
   end
-
 end