activemerchant 1.90.0 → 1.99.0

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

@@ -7,7 +7,7 @@ module ActiveMerchant #:nodoc:
       self.default_currency = 'GBP'
       self.money_format = :cents
       self.supported_countries = %w(HK GB AU AD AR BE BR CA CH CN CO CR CY CZ DE DK ES FI FR GI GR HU IE IN IT JP LI LU MC MT MY MX NL NO NZ PA PE PL PT SE SG SI SM TR UM VA)
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :elo, :naranja, :cabal]
       self.currencies_without_fractions = %w(HUF IDR ISK JPY KRW)
       self.currencies_with_three_decimal_places = %w(BHD KWD OMR RSD TND)
       self.homepage_url = 'http://www.worldpay.com/'
@@ -21,6 +21,30 @@ module ActiveMerchant #:nodoc:
         'jcb'              => 'JCB-SSL',
         'maestro'          => 'MAESTRO-SSL',
         'diners_club'      => 'DINERS-SSL',
+        'elo'              => 'ELO-SSL',
+        'naranja'          => 'NARANJA-SSL',
+        'cabal'            => 'CABAL-SSL',
+        'unknown'          => 'CARD-SSL'
+      }
+
+      AVS_CODE_MAP = {
+        'A' => 'M', # Match
+        'B' => 'P', # Postcode matches, address not verified
+        'C' => 'Z', # Postcode matches, address does not match
+        'D' => 'B', # Address matched; postcode not checked
+        'E' => 'I', # Address and postal code not checked
+        'F' => 'A', # Address matches, postcode does not match
+        'G' => 'C', # Address does not match, postcode not checked
+        'H' => 'I', # Address and postcode not provided
+        'I' => 'C', # Address not checked postcode does not match
+        'J' => 'C', # Address and postcode does not match
+      }
+
+      CVC_CODE_MAP = {
+        'A' => 'M', # CVV matches
+        'B' => 'P', # Not provided
+        'C' => 'P', # Not checked
+        'D' => 'N', # Does not match
       }
 
       def initialize(options = {})
@@ -37,10 +61,12 @@ module ActiveMerchant #:nodoc:
 
       def authorize(money, payment_method, options = {})
         requires!(options, :order_id)
-        authorize_request(money, payment_method, options)
+        payment_details = payment_details_from(payment_method)
+        authorize_request(money, payment_method, payment_details.merge(options))
       end
 
       def capture(money, authorization, options = {})
+        authorization = order_id_from_authorization(authorization.to_s)
         MultiResponse.run do |r|
           r.process { inquire_request(authorization, options, 'AUTHORISED') } unless options[:authorization_validated]
           if r.params
@@ -52,6 +78,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def void(authorization, options = {})
+        authorization = order_id_from_authorization(authorization.to_s)
         MultiResponse.run do |r|
           r.process { inquire_request(authorization, options, 'AUTHORISED') } unless options[:authorization_validated]
           r.process { cancel_request(authorization, options) }
@@ -59,8 +86,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def refund(money, authorization, options = {})
+        authorization = order_id_from_authorization(authorization.to_s)
         response = MultiResponse.run do |r|
-          r.process { inquire_request(authorization, options, 'CAPTURED', 'SETTLED', 'SETTLED_BY_MERCHANT') }
+          r.process { inquire_request(authorization, options, 'CAPTURED', 'SETTLED', 'SETTLED_BY_MERCHANT') } unless options[:authorization_validated]
           r.process { refund_request(money, authorization, options) }
         end
 
@@ -75,16 +103,22 @@ module ActiveMerchant #:nodoc:
       #   and other transactions should be performed on a normal eCom-flagged
       #   merchant ID.
       def credit(money, payment_method, options = {})
-        credit_request(money, payment_method, options.merge(:credit => true))
+        payment_details = payment_details_from(payment_method)
+        credit_request(money, payment_method, payment_details.merge(:credit => true, **options))
       end
 
-      def verify(credit_card, options={})
+      def verify(payment_method, options={})
         MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(100, credit_card, options) }
+          r.process { authorize(100, payment_method, options) }
           r.process(:ignore_result) { void(r.authorization, options.merge(:authorization_validated => true)) }
         end
       end
 
+      def store(credit_card, options={})
+        requires!(options, :customer)
+        store_request(credit_card, options)
+      end
+
       def supports_scrubbing
         true
       end
@@ -122,6 +156,10 @@ module ActiveMerchant #:nodoc:
         commit('credit', build_authorization_request(money, payment_method, options), :ok, 'SENT_FOR_REFUND', options)
       end
 
+      def store_request(credit_card, options)
+        commit('store', build_store_request(credit_card, options), options)
+      end
+
       def build_request
         xml = Builder::XmlMarkup.new :indent => 2
         xml.instruct! :xml, :encoding => 'UTF-8'
@@ -162,13 +200,16 @@ module ActiveMerchant #:nodoc:
                 end
               end
               add_payment_method(xml, money, payment_method, options)
-              add_email(xml, options)
+              add_shopper(xml, options)
               if options[:hcg_additional_data]
                 add_hcg_additional_data(xml, options)
               end
               if options[:instalments]
                 add_instalments_data(xml, options)
               end
+              add_moto_flag(xml, options) if options.dig(:metadata, :manual_entry)
+              add_additional_3ds_data(xml, options) if options[:execute_threed] && options[:three_ds_version] && options[:three_ds_version] =~ /^2/
+              add_3ds_exemption(xml, options) if options[:exemption_type]
             end
           end
         end
@@ -202,6 +243,30 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def build_store_request(credit_card, options)
+        build_request do |xml|
+          xml.tag! 'submit' do
+            xml.tag! 'paymentTokenCreate' do
+              add_authenticated_shopper_id(xml, options)
+              xml.tag! 'createToken'
+              xml.tag! 'paymentInstrument' do
+                xml.tag! 'cardDetails' do
+                  add_card(xml, credit_card, options)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def add_additional_3ds_data(xml, options)
+        xml.tag! 'additional3DSData', 'dfReferenceId' => options[:session_id]
+      end
+
+      def add_3ds_exemption(xml, options)
+        xml.tag! 'exemption', 'type' => options[:exemption_type], 'placement' => options[:exemption_placement] || 'AUTHORISATION'
+      end
+
       def add_amount(xml, money, options)
         currency = options[:currency] || currency(money)
 
@@ -219,7 +284,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_payment_method(xml, amount, payment_method, options)
-        if payment_method.is_a?(String)
+        if options[:payment_type] == :pay_as_order
           if options[:merchant_code]
             xml.tag! 'payAsOrder', 'orderCode' => payment_method, 'merchantCode' => options[:merchant_code] do
               add_amount(xml, amount, options)
@@ -231,29 +296,82 @@ module ActiveMerchant #:nodoc:
           end
         else
           xml.tag! 'paymentDetails', credit_fund_transfer_attribute(options) do
-            xml.tag! CARD_CODES[card_brand(payment_method)] do
-              xml.tag! 'cardNumber', payment_method.number
-              xml.tag! 'expiryDate' do
-                xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
+            if options[:payment_type] == :token
+              xml.tag! 'TOKEN-SSL', 'tokenScope' => options[:token_scope] do
+                xml.tag! 'paymentTokenID', options[:token_id]
+              end
+            else
+              xml.tag! card_code_for(payment_method) do
+                add_card(xml, payment_method, options)
               end
-
-              xml.tag! 'cardHolderName', options[:execute_threed] ? '3D' : payment_method.name
-              xml.tag! 'cvc', payment_method.verification_value
-
-              add_address(xml, (options[:billing_address] || options[:address]))
             end
+            add_stored_credential_options(xml, options)
             if options[:ip] && options[:session_id]
               xml.tag! 'session', 'shopperIPAddress' => options[:ip], 'id' => options[:session_id]
             else
               xml.tag! 'session', 'shopperIPAddress' => options[:ip] if options[:ip]
               xml.tag! 'session', 'id' => options[:session_id] if options[:session_id]
             end
-            add_stored_credential_options(xml, options) if options[:stored_credential_usage]
+
+            if three_d_secure = options[:three_d_secure]
+              add_three_d_secure(three_d_secure, xml)
+            end
+          end
+        end
+      end
+
+      def add_three_d_secure(three_d_secure, xml)
+        xml.tag! 'info3DSecure' do
+          xml.tag! 'threeDSVersion', three_d_secure[:version]
+          if three_d_secure[:version] =~ /^2/
+            xml.tag! 'dsTransactionId', three_d_secure[:ds_transaction_id]
+          else
+            xml.tag! 'xid', three_d_secure[:xid]
           end
+          xml.tag! 'cavv', three_d_secure[:cavv]
+          xml.tag! 'eci', three_d_secure[:eci]
+        end
+      end
+
+      def add_card(xml, payment_method, options)
+        xml.tag! 'cardNumber', payment_method.number
+        xml.tag! 'expiryDate' do
+          xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
         end
+
+        xml.tag! 'cardHolderName', options[:execute_threed] && (options[:three_ds_version] =~ /[^2]/).nil? ? '3D' : payment_method.name
+        xml.tag! 'cvc', payment_method.verification_value
+
+        add_address(xml, (options[:billing_address] || options[:address]))
       end
 
       def add_stored_credential_options(xml, options={})
+        if options[:stored_credential]
+          add_stored_credential_using_normalized_fields(xml, options)
+        else
+          add_stored_credential_using_gateway_specific_fields(xml, options)
+        end
+      end
+
+      def add_stored_credential_using_normalized_fields(xml, options)
+        if options[:stored_credential][:initial_transaction]
+          xml.tag! 'storedCredentials', 'usage' => 'FIRST'
+        else
+          reason = case options[:stored_credential][:reason_type]
+                   when 'installment' then 'INSTALMENT'
+                   when 'recurring' then 'RECURRING'
+                   when 'unscheduled' then 'UNSCHEDULED'
+                   end
+
+          xml.tag! 'storedCredentials', 'usage' => 'USED', 'merchantInitiatedReason' => reason do
+            xml.tag! 'schemeTransactionIdentifier', options[:stored_credential][:network_transaction_id] if options[:stored_credential][:network_transaction_id]
+          end
+        end
+      end
+
+      def add_stored_credential_using_gateway_specific_fields(xml, options)
+        return unless options[:stored_credential_usage]
+
         if options[:stored_credential_initiated_reason]
           xml.tag! 'storedCredentials', 'usage' => options[:stored_credential_usage], 'merchantInitiatedReason' => options[:stored_credential_initiated_reason] do
             xml.tag! 'schemeTransactionIdentifier', options[:stored_credential_transaction_id] if options[:stored_credential_transaction_id]
@@ -263,10 +381,11 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_email(xml, options)
-        return unless options[:execute_threed] || options[:email]
+      def add_shopper(xml, options)
+        return unless options[:execute_threed] || options[:email] || options[:customer]
         xml.tag! 'shopper' do
           xml.tag! 'shopperEmailAddress', options[:email] if  options[:email]
+          add_authenticated_shopper_id(xml, options)
           xml.tag! 'browser' do
             xml.tag! 'acceptHeader', options[:accept_header]
             xml.tag! 'userAgentHeader', options[:user_agent]
@@ -274,6 +393,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_authenticated_shopper_id(xml, options)
+        xml.tag!('authenticatedShopperID', options[:customer]) if options[:customer]
+      end
+
       def add_address(xml, address)
         return unless address
 
@@ -311,6 +434,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_moto_flag(xml, options)
+        xml.tag! 'dynamicInteractionType', 'type' => 'MOTO'
+      end
+
       def address_with_defaults(address)
         address ||= {}
         address.delete_if { |_, v| v.blank? }
@@ -332,14 +459,17 @@ module ActiveMerchant #:nodoc:
       end
 
       def parse_element(raw, node)
+        node_name = node.name.underscore
         node.attributes.each do |k, v|
-          raw["#{node.name.underscore}_#{k.underscore}".to_sym] = v
+          raw["#{node_name}_#{k.underscore}".to_sym] = v
         end
         if node.has_elements?
-          raw[node.name.underscore.to_sym] = true unless node.name.blank?
+          raw[node_name.to_sym] = true unless node.name.blank?
           node.elements.each { |e| parse_element(raw, e) }
+        elsif node.children.count > 1
+          raw[node_name.to_sym] = node.children.join(' ').strip
         else
-          raw[node.name.underscore.to_sym] = node.text unless node.text.nil?
+          raw[node_name.to_sym] = node.text unless node.text.nil?
         end
         raw
       end
@@ -361,16 +491,21 @@ module ActiveMerchant #:nodoc:
         if options[:execute_threed]
           raw[:cookie] = @cookie
           raw[:session_id] = options[:session_id]
+          raw[:is3DSOrder] = true
         end
-        success, message = success_and_message_from(raw, success_criteria)
+        success = success_from(action, raw, success_criteria)
+        message = message_from(success, raw, success_criteria)
 
         Response.new(
           success,
           message,
           raw,
-          :authorization => authorization_from(raw),
+          :authorization => authorization_from(action, raw, options),
           :error_code => error_code_from(success, raw),
-          :test => test?)
+          :test => test?,
+          :avs_result => AVSResult.new(code: AVS_CODE_MAP[raw[:avs_result_code_description]]),
+          :cvv_result => CVVResult.new(CVC_CODE_MAP[raw[:cvc_result_code_description]])
+        )
       rescue ActiveMerchant::ResponseError => e
         if e.response.code.to_s == '401'
           return Response.new(false, 'Invalid credentials', {}, :test => test?)
@@ -395,19 +530,30 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def success_from(action, raw, success_criteria)
+        success_criteria_success?(raw, success_criteria) || action_success?(action, raw)
+      end
+
+      def message_from(success, raw, success_criteria)
+        return 'SUCCESS' if success
+        raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria)
+      end
+
       # success_criteria can be:
       #   - a string or an array of strings (if one of many responses)
       #   - An array of strings if one of many responses could be considered a
       #     success.
-      def success_and_message_from(raw, success_criteria)
-        success = (success_criteria.include?(raw[:last_event]) || raw[:ok].present?)
-        if success
-          message = 'SUCCESS'
+      def success_criteria_success?(raw, success_criteria)
+        success_criteria.include?(raw[:last_event]) || raw[:ok].present?
+      end
+
+      def action_success?(action, raw)
+        case action
+        when 'store'
+          raw[:token].present?
         else
-          message = (raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria))
+          false
         end
-
-        [ success, message ]
       end
 
       def error_code_from(success, raw)
@@ -422,11 +568,64 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def authorization_from(raw)
+      def authorization_from(action, raw, options)
+        order_id = order_id_from(raw)
+
+        case action
+        when 'store'
+          authorization_from_token_details(
+            order_id: order_id,
+            token_id: raw[:payment_token_id],
+            token_scope: 'shopper',
+            customer: options[:customer]
+          )
+        else
+          order_id
+        end
+      end
+
+      def order_id_from(raw)
         pair = raw.detect { |k, v| k.to_s =~ /_order_code$/ }
         (pair ? pair.last : nil)
       end
 
+      def authorization_from_token_details(options={})
+        [options[:order_id], options[:token_id], options[:token_scope], options[:customer]].join('|')
+      end
+
+      def order_id_from_authorization(authorization)
+        token_details_from_authorization(authorization)[:order_id]
+      end
+
+      def token_details_from_authorization(authorization)
+        order_id, token_id, token_scope, customer = authorization.split('|')
+
+        token_details = {}
+        token_details[:order_id] = order_id if order_id.present?
+        token_details[:token_id] = token_id if token_id.present?
+        token_details[:token_scope] = token_scope if token_scope.present?
+        token_details[:customer] = customer if customer.present?
+
+        token_details
+      end
+
+      def payment_details_from(payment_method)
+        payment_details = {}
+        if payment_method.respond_to?(:number)
+          payment_details[:payment_type] = :credit
+        else
+          token_details = token_details_from_authorization(payment_method)
+          payment_details.merge!(token_details)
+          if token_details.has_key?(:token_id)
+            payment_details[:payment_type] = :token
+          else
+            payment_details[:payment_type] = :pay_as_order
+          end
+        end
+
+        payment_details
+      end
+
       def credit_fund_transfer_attribute(options)
         return unless options[:credit]
         {'action' => 'REFUND'}
@@ -442,6 +641,10 @@ module ActiveMerchant #:nodoc:
         return 3 if three_decimal_currency?(currency)
         return 2
       end
+
+      def card_code_for(payment_method)
+        CARD_CODES[card_brand(payment_method)] || CARD_CODES['unknown']
+      end
     end
   end
 end

data/lib/active_merchant/country.rb

@@ -183,6 +183,7 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'KI', name: 'Kiribati', alpha3: 'KIR', numeric: '296' },
       { alpha2: 'KP', name: 'Korea, Democratic People\'s Republic of', alpha3: 'PRK', numeric: '408' },
       { alpha2: 'KR', name: 'Korea, Republic of', alpha3: 'KOR', numeric: '410' },
+      { alpha2: 'XK', name: 'Kosovo', alpha3: 'XKX', numeric: '900' },
       { alpha2: 'KW', name: 'Kuwait', alpha3: 'KWT', numeric: '414' },
       { alpha2: 'KG', name: 'Kyrgyzstan', alpha3: 'KGZ', numeric: '417' },
       { alpha2: 'LA', name: 'Lao People\'s Democratic Republic', alpha3: 'LAO', numeric: '418' },
@@ -245,8 +246,8 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'PR', name: 'Puerto Rico', alpha3: 'PRI', numeric: '630' },
       { alpha2: 'QA', name: 'Qatar', alpha3: 'QAT', numeric: '634' },
       { alpha2: 'RE', name: 'Reunion', alpha3: 'REU', numeric: '638' },
-      { alpha2: 'RO', name: 'Romania', alpha3: 'ROM', numeric: '642' },
       { alpha2: 'RO', name: 'Romania', alpha3: 'ROU', numeric: '642' },
+      { alpha2: 'RO', name: 'Romania', alpha3: 'ROM', numeric: '642' },
       { alpha2: 'RU', name: 'Russian Federation', alpha3: 'RUS', numeric: '643' },
       { alpha2: 'RW', name: 'Rwanda', alpha3: 'RWA', numeric: '646' },
       { alpha2: 'BL', name: 'Saint Barthélemy', alpha3: 'BLM', numeric: '652' },

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.90.0'
+  VERSION = '1.99.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.90.0
+  version: 1.99.0
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-09 00:00:00.000000000 Z
+date: 2019-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -128,6 +128,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Active Merchant is a simple payment abstraction library used in and sponsored
   by Shopify. It is written by Tobias Luetke, Cody Fauser, and contributors. The aim
   of the project is to feel natural to Ruby users and to abstract as many parts as
@@ -162,6 +176,7 @@ files:
 - lib/active_merchant/billing/gateways/authorize_net_cim.rb
 - lib/active_merchant/billing/gateways/axcessms.rb
 - lib/active_merchant/billing/gateways/balanced.rb
+- lib/active_merchant/billing/gateways/bambora_apac.rb
 - lib/active_merchant/billing/gateways/bank_frick.rb
 - lib/active_merchant/billing/gateways/banwire.rb
 - lib/active_merchant/billing/gateways/barclaycard_smartpay.rb
@@ -203,6 +218,7 @@ files:
 - lib/active_merchant/billing/gateways/cyber_source.rb
 - lib/active_merchant/billing/gateways/d_local.rb
 - lib/active_merchant/billing/gateways/data_cash.rb
+- lib/active_merchant/billing/gateways/decidir.rb
 - lib/active_merchant/billing/gateways/dibs.rb
 - lib/active_merchant/billing/gateways/digitzs.rb
 - lib/active_merchant/billing/gateways/ebanx.rb
@@ -348,6 +364,7 @@ files:
 - lib/active_merchant/billing/gateways/so_easy_pay.rb
 - lib/active_merchant/billing/gateways/spreedly_core.rb
 - lib/active_merchant/billing/gateways/stripe.rb
+- lib/active_merchant/billing/gateways/stripe_payment_intents.rb
 - lib/active_merchant/billing/gateways/swipe_checkout.rb
 - lib/active_merchant/billing/gateways/telr.rb
 - lib/active_merchant/billing/gateways/tns.rb
@@ -411,8 +428,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: activemerchant
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Framework and tools for dealing with credit card transactions.