activemerchant 1.100.0 → 1.133.0

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

@@ -8,7 +8,7 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = %w(CA PR US)
       self.default_currency = 'USD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+      self.supported_cardtypes = %i[visa master american_express discover diners_club jcb]
 
       self.homepage_url = 'https://www.globalpaymentsinc.com'
       self.display_name = 'Global Transport'
@@ -20,12 +20,12 @@ module ActiveMerchant #:nodoc:
       #           :global_password  - Your Global password
       #           :term_type        - 3 character field assigned by Global Transport after
       #                             - your application is certified.
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :global_user_name, :global_password, :term_type)
         super
       end
 
-      def purchase(money, payment_method, options={})
+      def purchase(money, payment_method, options = {})
         post = {}
         add_invoice(post, money, options)
         add_payment_method(post, payment_method)
@@ -34,7 +34,7 @@ module ActiveMerchant #:nodoc:
         commit('Sale', post, options)
       end
 
-      def authorize(money, payment_method, options={})
+      def authorize(money, payment_method, options = {})
         post = {}
         add_invoice(post, money, options)
         add_payment_method(post, payment_method)
@@ -43,7 +43,7 @@ module ActiveMerchant #:nodoc:
         commit('Auth', post, options)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
         add_invoice(post, money, options)
         add_auth(post, authorization)
@@ -51,7 +51,7 @@ module ActiveMerchant #:nodoc:
         commit('Force', post, options)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
         add_invoice(post, money, options)
         add_auth(post, authorization)
@@ -59,14 +59,14 @@ module ActiveMerchant #:nodoc:
         commit('Return', post, options)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         add_auth(post, authorization)
 
         commit('Void', post, options)
       end
 
-      def verify(payment_method, options={})
+      def verify(payment_method, options = {})
         post = {}
         add_payment_method(post, payment_method)
         add_address(post, options)
@@ -188,7 +188,6 @@ module ActiveMerchant #:nodoc:
           ExtData: ''
         }
       end
-
     end
   end
 end

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

@@ -12,14 +12,14 @@ module ActiveMerchant #:nodoc:
       self.supported_countries = ['IN']
       self.default_currency = 'INR'
       self.money_format = :dollars
-      self.supported_cardtypes = [:visa, :master, :discover, :diners_club]
+      self.supported_cardtypes = %i[visa master discover diners_club]
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :login, :password)
         super
       end
 
-      def purchase(amount, payment_method, options={})
+      def purchase(amount, payment_method, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_payment_method(post, payment_method)
@@ -28,7 +28,7 @@ module ActiveMerchant #:nodoc:
         commit('purchase', post)
       end
 
-      def authorize(amount, payment_method, options={})
+      def authorize(amount, payment_method, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_payment_method(post, payment_method)
@@ -37,7 +37,7 @@ module ActiveMerchant #:nodoc:
         commit('authorize', post)
       end
 
-      def capture(amount, authorization, options={})
+      def capture(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_reference(post, authorization)
@@ -46,7 +46,7 @@ module ActiveMerchant #:nodoc:
         commit('capture', post)
       end
 
-      def refund(amount, authorization, options={})
+      def refund(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_reference(post, authorization)
@@ -57,7 +57,7 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      CURRENCY_CODES = Hash.new { |h, k| raise ArgumentError.new("Unsupported currency for HDFC: #{k}") }
+      CURRENCY_CODES = Hash.new { |_h, k| raise ArgumentError.new("Unsupported currency for HDFC: #{k}") }
       CURRENCY_CODES['AED'] = '784'
       CURRENCY_CODES['AUD'] = '036'
       CURRENCY_CODES['CAD'] = '124'
@@ -81,14 +81,14 @@ module ActiveMerchant #:nodoc:
         post[:udf2] = escape(options[:email]) if options[:email]
         if address = (options[:billing_address] || options[:address])
           post[:udf3] = escape(address[:phone]) if address[:phone]
-          post[:udf4] = escape(<<EOA)
-#{address[:name]}
-#{address[:company]}
-#{address[:address1]}
-#{address[:address2]}
-#{address[:city]} #{address[:state]} #{address[:zip]}
-#{address[:country]}
-EOA
+          post[:udf4] = escape(<<~ADDRESS)
+            #{address[:name]}
+            #{address[:company]}
+            #{address[:address1]}
+            #{address[:address2]}
+            #{address[:city]} #{address[:state]} #{address[:zip]}
+            #{address[:country]}
+          ADDRESS
         end
       end
 
@@ -134,7 +134,7 @@ EOA
         'purchase' => '1',
         'refund' => '2',
         'authorize' => '4',
-        'capture' => '5',
+        'capture' => '5'
       }
 
       def commit(action, post)
@@ -149,13 +149,13 @@ EOA
           succeeded,
           message_from(succeeded, raw),
           raw,
-          :authorization => authorization_from(post, raw),
-          :test => test?
+          authorization: authorization_from(post, raw),
+          test: test?
         )
       end
 
       def build_request(post)
-        xml = Builder::XmlMarkup.new :indent => 2
+        xml = Builder::XmlMarkup.new indent: 2
         xml.instruct!
         post.each do |field, value|
           xml.tag!(field, value)
@@ -194,11 +194,10 @@ EOA
         [tranid, member]
       end
 
-      def escape(string, max_length=250)
+      def escape(string, max_length = 250)
         return '' unless string
-        if max_length
-          string = string[0...max_length]
-        end
+
+        string = string[0...max_length] if max_length
         string.gsub(/[^A-Za-z0-9 \-_@\.\n]/, '')
       end
     end

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

@@ -8,7 +8,7 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jbc, :diners_club]
+      self.supported_cardtypes = %i[visa master american_express discover jbc diners_club]
 
       self.homepage_url = 'http://developer.heartlandpaymentsystems.com/SecureSubmit/'
       self.display_name = 'Heartland Payment Systems'
@@ -21,65 +21,81 @@ module ActiveMerchant #:nodoc:
         visa:             'Visa 3DSecure',
         american_express: 'AMEX 3DSecure',
         discover:         'Discover 3DSecure',
+        android_pay:      'GooglePayApp',
+        google_pay:       'GooglePayApp'
       }
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :secret_api_key)
         super
       end
 
-      def authorize(money, card_or_token, options={})
+      def authorize(money, card_or_token, options = {})
         commit('CreditAuth') do |xml|
           add_amount(xml, money)
           add_allow_dup(xml)
-          add_customer_data(xml, card_or_token, options)
+          add_card_or_token_customer_data(xml, card_or_token, options)
           add_details(xml, options)
           add_descriptor_name(xml, options)
-          add_payment(xml, card_or_token, options)
+          add_card_or_token_payment(xml, card_or_token, options)
           add_three_d_secure(xml, card_or_token, options)
+          add_stored_credentials(xml, options)
         end
       end
 
-      def capture(money, transaction_id, options={})
-        commit('CreditAddToBatch') do |xml|
+      def capture(money, transaction_id, options = {})
+        commit('CreditAddToBatch', transaction_id) do |xml|
           add_amount(xml, money)
           add_reference(xml, transaction_id)
         end
       end
 
-      def purchase(money, card_or_token, options={})
-        commit('CreditSale') do |xml|
+      def purchase(money, payment_method, options = {})
+        if payment_method.is_a?(Check)
+          commit_check_sale(money, payment_method, options)
+        elsif options.dig(:stored_credential, :reason_type) == 'recurring'
+          commit_recurring_billing_sale(money, payment_method, options)
+        else
+          commit_credit_sale(money, payment_method, options)
+        end
+      end
+
+      def refund(money, transaction_id, options = {})
+        commit('CreditReturn') do |xml|
           add_amount(xml, money)
           add_allow_dup(xml)
-          add_customer_data(xml, card_or_token, options)
+          add_reference(xml, transaction_id)
+          add_card_or_token_customer_data(xml, transaction_id, options)
           add_details(xml, options)
-          add_descriptor_name(xml, options)
-          add_payment(xml, card_or_token, options)
-          add_three_d_secure(xml, card_or_token, options)
         end
       end
 
-      def refund(money, transaction_id, options={})
+      def credit(money, payment_method, options = {})
         commit('CreditReturn') do |xml|
           add_amount(xml, money)
           add_allow_dup(xml)
-          add_reference(xml, transaction_id)
-          add_customer_data(xml, transaction_id, options)
+          add_card_or_token_payment(xml, payment_method, options)
           add_details(xml, options)
         end
       end
 
-      def verify(card_or_token, options={})
+      def verify(card_or_token, options = {})
         commit('CreditAccountVerify') do |xml|
-          add_customer_data(xml, card_or_token, options)
+          add_card_or_token_customer_data(xml, card_or_token, options)
           add_descriptor_name(xml, options)
-          add_payment(xml, card_or_token, options)
+          add_card_or_token_payment(xml, card_or_token, options)
         end
       end
 
-      def void(transaction_id, options={})
-        commit('CreditVoid') do |xml|
-          add_reference(xml, transaction_id)
+      def void(transaction_id, options = {})
+        if options[:check_void]
+          commit('CheckVoid') do |xml|
+            add_reference(xml, transaction_id)
+          end
+        else
+          commit('CreditVoid') do |xml|
+            add_reference(xml, transaction_id)
+          end
         end
       end
 
@@ -92,20 +108,60 @@ module ActiveMerchant #:nodoc:
           gsub(%r((<hps:CardNbr>)[^<]*(<\/hps:CardNbr>))i, '\1[FILTERED]\2').
           gsub(%r((<hps:CVV2>)[^<]*(<\/hps:CVV2>))i, '\1[FILTERED]\2').
           gsub(%r((<hps:SecretAPIKey>)[^<]*(<\/hps:SecretAPIKey>))i, '\1[FILTERED]\2').
-          gsub(%r((<hps:PaymentData>)[^<]*(<\/hps:PaymentData>))i, '\1[FILTERED]\2')
+          gsub(%r((<hps:PaymentData>)[^<]*(<\/hps:PaymentData>))i, '\1[FILTERED]\2').
+          gsub(%r((<hps:RoutingNumber>)[^<]*(<\/hps:RoutingNumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<hps:AccountNumber>)[^<]*(<\/hps:AccountNumber>))i, '\1[FILTERED]\2')
       end
 
       private
 
+      def commit_check_sale(money, check, options)
+        commit('CheckSale') do |xml|
+          add_check_payment(xml, check, options)
+          add_amount(xml, money)
+          add_sec_code(xml, options)
+          add_check_customer_data(xml, check, options)
+          add_details(xml, options)
+        end
+      end
+
+      def commit_credit_sale(money, card_or_token, options)
+        commit('CreditSale') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_card_or_token_customer_data(xml, card_or_token, options)
+          add_details(xml, options)
+          add_descriptor_name(xml, options)
+          add_card_or_token_payment(xml, card_or_token, options)
+          add_three_d_secure(xml, card_or_token, options)
+          add_stored_credentials(xml, options)
+        end
+      end
+
+      def commit_recurring_billing_sale(money, card_or_token, options)
+        commit('RecurringBilling') do |xml|
+          add_amount(xml, money)
+          add_allow_dup(xml)
+          add_card_or_token_customer_data(xml, card_or_token, options)
+          add_details(xml, options)
+          add_descriptor_name(xml, options)
+          add_card_or_token_payment(xml, card_or_token, options)
+          add_three_d_secure(xml, card_or_token, options)
+          add_stored_credentials(xml, options)
+          add_stored_credentials_for_recurring_billing(xml, options)
+        end
+      end
+
       def add_reference(xml, transaction_id)
-        xml.hps :GatewayTxnId, transaction_id
+        reference = transaction_id.to_s.include?('|') ? transaction_id.split('|').first : transaction_id
+        xml.hps :GatewayTxnId, reference
       end
 
       def add_amount(xml, money)
         xml.hps :Amt, amount(money) if money
       end
 
-      def add_customer_data(xml, credit_card, options)
+      def add_card_or_token_customer_data(xml, credit_card, options)
         xml.hps :CardHolderData do
           if credit_card.respond_to?(:number)
             xml.hps :CardHolderFirstName, credit_card.first_name if credit_card.first_name
@@ -115,20 +171,28 @@ module ActiveMerchant #:nodoc:
           xml.hps :CardHolderEmail, options[:email] if options[:email]
           xml.hps :CardHolderPhone, options[:phone] if options[:phone]
 
-          if(billing_address = (options[:billing_address] || options[:address]))
+          if (billing_address = (options[:billing_address] || options[:address]))
             xml.hps :CardHolderAddr, billing_address[:address1] if billing_address[:address1]
             xml.hps :CardHolderCity, billing_address[:city] if billing_address[:city]
             xml.hps :CardHolderState, billing_address[:state] if billing_address[:state]
-            xml.hps :CardHolderZip, billing_address[:zip] if billing_address[:zip]
+            xml.hps :CardHolderZip, alphanumeric_zip(billing_address[:zip]) if billing_address[:zip]
           end
         end
       end
 
-      def add_payment(xml, card_or_token, options)
+      def add_check_customer_data(xml, check, options)
+        xml.hps :ConsumerInfo do
+          xml.hps :FirstName, check.first_name
+          xml.hps :LastName, check.last_name
+          xml.hps :CheckName, options[:company_name] if options[:company_name]
+        end
+      end
+
+      def add_card_or_token_payment(xml, card_or_token, options)
         xml.hps :CardData do
           if card_or_token.respond_to?(:number)
             if card_or_token.track_data
-              xml.tag!('hps:TrackData', 'method'=>'swipe') do
+              xml.tag!('hps:TrackData', 'method' => 'swipe') do
                 xml.text! card_or_token.track_data
               end
               if options[:encryption_type]
@@ -159,14 +223,29 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_check_payment(xml, check, options)
+        xml.hps :CheckAction, 'SALE'
+        xml.hps :AccountInfo do
+          xml.hps :RoutingNumber, check.routing_number
+          xml.hps :AccountNumber, check.account_number
+          xml.hps :CheckNumber, check.number
+          xml.hps :AccountType, check.account_type&.upcase
+        end
+        xml.hps :CheckType, check.account_holder_type&.upcase
+      end
+
       def add_details(xml, options)
         xml.hps :AdditionalTxnFields do
           xml.hps :Description, options[:description] if options[:description]
-          xml.hps :InvoiceNbr, options[:order_id] if options[:order_id]
+          xml.hps :InvoiceNbr, options[:order_id][0..59] if options[:order_id]
           xml.hps :CustomerID, options[:customer_id] if options[:customer_id]
         end
       end
 
+      def add_sec_code(xml, options)
+        xml.hps :SECCode, options[:sec_code] || 'WEB'
+      end
+
       def add_allow_dup(xml)
         xml.hps :AllowDup, 'Y'
       end
@@ -181,7 +260,7 @@ module ActiveMerchant #:nodoc:
             source: card_or_token.source,
             cavv: card_or_token.payment_cryptogram,
             eci: card_or_token.eci,
-            xid: card_or_token.transaction_id,
+            xid: card_or_token.transaction_id
           })
         elsif options[:three_d_secure]
           options[:three_d_secure][:source] ||= card_brand(card_or_token)
@@ -204,8 +283,41 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      # We do not currently support installments on this gateway.
+      # The HPS gateway treats recurring transactions as a seperate transaction type
+      def add_stored_credentials(xml, options)
+        return unless options[:stored_credential]
+
+        xml.hps :CardOnFileData do
+          if options[:stored_credential][:initiator] == 'customer'
+            xml.hps :CardOnFile, 'C'
+          elsif options[:stored_credential][:initiator] == 'merchant'
+            xml.hps :CardOnFile, 'M'
+          else
+            return
+          end
+
+          if options[:stored_credential][:network_transaction_id]
+            xml.hps :CardBrandTxnId, options[:stored_credential][:network_transaction_id]
+          else
+            return
+          end
+        end
+      end
+
+      def add_stored_credentials_for_recurring_billing(xml, options)
+        xml.hps :RecurringData do
+          if options[:stored_credential][:reason_type] = 'recurring'
+            xml.hps :OneTime, 'N'
+          else
+            xml.hps :OneTime, 'Y'
+          end
+        end
+      end
+
       def strip_leading_zero(value)
         return value unless value[0] == '0'
+
         value[1, 1]
       end
 
@@ -213,8 +325,8 @@ module ActiveMerchant #:nodoc:
         xml = Builder::XmlMarkup.new(encoding: 'UTF-8')
         xml.instruct!(:xml, encoding: 'UTF-8')
         xml.SOAP :Envelope, {
-            'xmlns:SOAP' => 'http://schemas.xmlsoap.org/soap/envelope/',
-            'xmlns:hps' => 'http://Hps.Exchange.PosGateway'
+          'xmlns:SOAP' => 'http://schemas.xmlsoap.org/soap/envelope/',
+          'xmlns:hps' => 'http://Hps.Exchange.PosGateway'
         } do
           xml.SOAP :Body do
             xml.hps :PosRequest do
@@ -248,7 +360,7 @@ module ActiveMerchant #:nodoc:
 
         doc = Nokogiri::XML(raw)
         doc.remove_namespaces!
-        if(header = doc.xpath('//Header').first)
+        if (header = doc.xpath('//Header').first)
           header.elements.each do |node|
             if node.elements.size == 0
               response[node.name] = node.text
@@ -259,33 +371,34 @@ module ActiveMerchant #:nodoc:
             end
           end
         end
-        if(transaction = doc.xpath('//Transaction/*[1]').first)
+        if (transaction = doc.xpath('//Transaction/*[1]').first)
           transaction.elements.each do |node|
             response[node.name] = node.text
           end
         end
-        if(fault = doc.xpath('//Fault/Reason/Text').first)
+        if (fault = doc.xpath('//Fault/Reason/Text').first)
           response['Fault'] = fault.text
         end
 
         response
       end
 
-      def commit(action, &request)
+      def commit(action, reference = nil, &request)
         data = build_request(action, &request)
 
-        response = begin
-          parse(ssl_post((test? ? test_url : live_url), data, 'Content-Type' => 'text/xml'))
-        rescue ResponseError => e
-          parse(e.response.body)
-        end
+        response =
+          begin
+            parse(ssl_post((test? ? test_url : live_url), data, 'Content-Type' => 'text/xml'))
+          rescue ResponseError => e
+            parse(e.response.body)
+          end
 
         ActiveMerchant::Billing::Response.new(
           successful?(response),
           message_from(response),
           response,
           test: test?,
-          authorization: authorization_from(response),
+          authorization: authorization_from(response, reference),
           avs_result: {
             code: response['AVSRsltCode'],
             message: response['AVSRsltText']
@@ -294,28 +407,31 @@ module ActiveMerchant #:nodoc:
         )
       end
 
+      SUCCESSFUL_RESPONSE_CODES = %w(0 00 85)
       def successful?(response)
         (
           (response['GatewayRspCode'] == '0') &&
-          ((response['RspCode'] || '00') == '00' || response['RspCode'] == '85')
+          ((SUCCESSFUL_RESPONSE_CODES.include? response['RspCode']) || !response['RspCode'])
         )
       end
 
       def message_from(response)
-        if(response['Fault'])
+        if response['Fault']
           response['Fault']
-        elsif(response['GatewayRspCode'] == '0')
-          if(response['RspCode'] != '00' && response['RspCode'] != '85')
-            issuer_message(response['RspCode'])
-          else
+        elsif response['GatewayRspCode'] == '0'
+          if SUCCESSFUL_RESPONSE_CODES.include? response['RspCode']
             response['GatewayRspMsg']
+          else
+            issuer_message(response['RspCode'])
           end
         else
           (GATEWAY_MESSAGES[response['GatewayRspCode']] || response['GatewayRspMsg'])
         end
       end
 
-      def authorization_from(response)
+      def authorization_from(response, reference)
+        return [reference, response['GatewayTxnId']].join('|') if reference
+
         response['GatewayTxnId']
       end
 
@@ -323,6 +439,10 @@ module ActiveMerchant #:nodoc:
         @options[:secret_api_key]&.include?('_cert_')
       end
 
+      def alphanumeric_zip(zip)
+        zip.gsub(/[^0-9a-z]/i, '')
+      end
+
       ISSUER_MESSAGES = {
         '13' => 'Must be greater than or equal 0.',
         '14' => 'The card number is incorrect.',
@@ -336,6 +456,7 @@ module ActiveMerchant #:nodoc:
         return 'The card was declined.' if %w(02 03 04 05 41 43 44 51 56 61 62 63 65 78).include?(code)
         return 'An error occurred while processing the card.' if %w(06 07 12 15 19 12 52 53 57 58 76 77 91 96 EC).include?(code)
         return "The card's security code is incorrect." if %w(EB N7).include?(code)
+
         ISSUER_MESSAGES[code]
       end