activemerchant 1.94.0 → 1.99.0

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

@@ -33,9 +33,9 @@ module ActiveMerchant #:nodoc:
         '10110' => STANDARD_ERROR_CODE[:incorrect_address],
         '10111' => STANDARD_ERROR_CODE[:incorrect_address],
         '10127' => STANDARD_ERROR_CODE[:card_declined],
-        '10128' => STANDARD_ERROR_CODE[:processing_error],
-        '10132' => STANDARD_ERROR_CODE[:processing_error],
-        '00043' => STANDARD_ERROR_CODE[:call_issuer]
+        '00043' => STANDARD_ERROR_CODE[:call_issuer],
+        '10205' => STANDARD_ERROR_CODE[:card_declined],
+        '10204' => STANDARD_ERROR_CODE[:pickup_card]
       }
 
       def initialize(options = {})
@@ -318,12 +318,15 @@ module ActiveMerchant #:nodoc:
       def commit(action, parameters)
         url = (test? ? self.test_url : self.live_url)
         response = parse(ssl_post(url, post_data(action, parameters)))
-        Response.new(response[:status] == 'Approved', message_from(response), response,
+        approved = response[:status] == 'Approved'
+        error_code = nil
+        error_code = (STANDARD_ERROR_CODE_MAPPING[response[:error_code]] || STANDARD_ERROR_CODE[:processing_error]) unless approved
+        Response.new(approved, message_from(response), response,
           :test           => test?,
           :authorization  => response[:ref_num],
           :cvv_result     => response[:cvv2_result_code],
           :avs_result     => { :code => response[:avs_result_code] },
-          :error_code     => STANDARD_ERROR_CODE_MAPPING[response[:error_code]]
+          :error_code     => error_code
         )
       end
 

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, :elo]
+      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/'
@@ -22,6 +22,8 @@ module ActiveMerchant #:nodoc:
         'maestro'          => 'MAESTRO-SSL',
         'diners_club'      => 'DINERS-SSL',
         'elo'              => 'ELO-SSL',
+        'naranja'          => 'NARANJA-SSL',
+        'cabal'            => 'CABAL-SSL',
         'unknown'          => 'CARD-SSL'
       }
 
@@ -59,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
@@ -74,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) }
@@ -81,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
 
@@ -97,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
@@ -144,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'
@@ -184,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
@@ -224,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)
 
@@ -241,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)
@@ -253,16 +296,14 @@ module ActiveMerchant #:nodoc:
           end
         else
           xml.tag! 'paymentDetails', credit_fund_transfer_attribute(options) do
-            xml.tag! card_code_for(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]
@@ -273,18 +314,37 @@ module ActiveMerchant #:nodoc:
             end
 
             if three_d_secure = options[:three_d_secure]
-              xml.tag! 'info3DSecure' do
-                xml.tag! 'threeDSVersion', three_d_secure[:version]
-                xid_tag = three_d_secure[:version] =~ /^2/ ? 'dsTransactionId' : 'xid'
-                xml.tag! xid_tag, three_d_secure[:xid]
-                xml.tag! 'cavv', three_d_secure[:cavv]
-                xml.tag! 'eci', three_d_secure[:eci]
-              end
+              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)
@@ -321,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]
@@ -332,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
 
@@ -369,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? }
@@ -390,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
@@ -419,14 +491,16 @@ 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?,
           :avs_result => AVSResult.new(code: AVS_CODE_MAP[raw[:avs_result_code_description]]),
@@ -456,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)
@@ -483,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'}

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' },

data/lib/active_merchant/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.94.0
+  version: 1.99.0
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-21 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
@@ -204,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
@@ -349,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
@@ -412,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.