activemerchant 1.116.0 → 1.121.0

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

@@ -39,6 +39,7 @@ module ActiveMerchant
         add_address(params, options)
         add_amount(params, amount, options)
         add_soft_descriptors(params, options)
+        add_level2_data(params, options)
         add_stored_credentials(params, options)
 
         commit(params, options)
@@ -53,6 +54,7 @@ module ActiveMerchant
         add_address(params, options)
         add_amount(params, amount, options)
         add_soft_descriptors(params, options)
+        add_level2_data(params, options)
         add_stored_credentials(params, options)
 
         commit(params, options)
@@ -77,6 +79,14 @@ module ActiveMerchant
         commit(params, options)
       end
 
+      def credit(amount, payment_method, options = {})
+        params = { transaction_type: 'refund' }
+
+        add_amount(params, amount, options)
+        add_payment_method(params, payment_method, options)
+        commit(params, options)
+      end
+
       def store(payment_method, options = {})
         params = { transaction_type: 'store' }
 
@@ -246,17 +256,42 @@ module ActiveMerchant
         params[:soft_descriptors] = options[:soft_descriptors] if options[:soft_descriptors]
       end
 
+      def add_level2_data(params, options)
+        return unless level2_data = options[:level2]
+
+        params[:level2] = {}
+        params[:level2][:customer_ref] = level2_data[:customer_ref]
+      end
+
       def add_stored_credentials(params, options)
-        if options[:sequence]
+        if options[:sequence] || options[:stored_credential]
           params[:stored_credentials] = {}
-          params[:stored_credentials][:cardbrand_original_transaction_id] = options[:cardbrand_original_transaction_id] if options[:cardbrand_original_transaction_id]
-          params[:stored_credentials][:sequence] = options[:sequence]
-          params[:stored_credentials][:initiator] = options[:initiator] if options[:initiator]
-          params[:stored_credentials][:is_scheduled] = options[:is_scheduled]
+          params[:stored_credentials][:cardbrand_original_transaction_id] = original_transaction_id(options) if original_transaction_id(options)
+          params[:stored_credentials][:initiator] = initiator(options) if initiator(options)
+          params[:stored_credentials][:sequence] = options[:sequence] || sequence(options[:stored_credential][:initial_transaction])
+          params[:stored_credentials][:is_scheduled] = options[:is_scheduled] || is_scheduled(options[:stored_credential][:reason_type])
           params[:stored_credentials][:auth_type_override] = options[:auth_type_override] if options[:auth_type_override]
         end
       end
 
+      def original_transaction_id(options)
+        return options[:cardbrand_original_transaction_id] if options[:cardbrand_original_transaction_id]
+        return options[:stored_credential][:network_transaction_id] if options.dig(:stored_credential, :network_transaction_id)
+      end
+
+      def initiator(options)
+        return options[:initiator] if options[:initiator]
+        return options[:stored_credential][:initiator].upcase if options.dig(:stored_credential, :initiator)
+      end
+
+      def sequence(initial_transaction)
+        initial_transaction ? 'FIRST' : 'SUBSEQUENT'
+      end
+
+      def is_scheduled(reason_type)
+        reason_type == 'recurring' ? 'true' : 'false'
+      end
+
       def commit(params, options)
         url = base_url(options) + endpoint(params)
 
@@ -272,15 +307,16 @@ module ActiveMerchant
           response = json_error(e.response.body)
         end
 
+        success = success_from(response)
         Response.new(
-          success_from(response),
-          handle_message(response, success_from(response)),
+          success,
+          handle_message(response, success),
           response,
           test: test?,
           authorization: authorization_from(params, response),
           avs_result: { code: response['avs'] },
           cvv_result: response['cvv2'],
-          error_code: error_code(response, success_from(response))
+          error_code: success ? nil : error_code_from(response)
         )
       end
 
@@ -334,10 +370,16 @@ module ActiveMerchant
         }
       end
 
-      def error_code(response, success)
-        return if success
+      def error_code_from(response)
+        error_code = nil
+        if response['bank_resp_code'] == '100'
+          return
+        elsif response['bank_resp_code']
+          error_code = response['bank_resp_code']
+        elsif error_code = response['Error'].to_h['messages'].to_a.map { |e| e['code'] }.join(', ')
+        end
 
-        response['Error'].to_h['messages'].to_a.map { |e| e['code'] }.join(', ')
+        error_code
       end
 
       def success_from(response)

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

@@ -86,6 +86,11 @@ module ActiveMerchant #:nodoc:
         refund(money, identification, options)
       end
 
+      def verify(money, payment_source, options = {})
+        request = build_purchase_or_authorization_request(money, payment_source, options)
+        commit(:validate, request)
+      end
+
       # Token Based Billing
       #
       # Instead of storing the credit card details locally, you can store them inside the
@@ -149,7 +154,7 @@ module ActiveMerchant #:nodoc:
           add_credit_card(result, payment_source)
         end
 
-        add_amount(result, money, options)
+        add_amount(result, money, options) if money
         add_invoice(result, options)
         add_address_verification_data(result, options)
         add_optional_elements(result, options)
@@ -229,8 +234,8 @@ module ActiveMerchant #:nodoc:
         address = options[:billing_address] || options[:address]
         return if address.nil?
 
-        xml.add_element('EnableAvsData').text = 1
-        xml.add_element('AvsAction').text = 1
+        xml.add_element('EnableAvsData').text = options[:enable_avs_data] || 1
+        xml.add_element('AvsAction').text = options[:avs_action] || 1
 
         xml.add_element('AvsStreetAddress').text = address[:address1]
         xml.add_element('AvsPostCode').text = address[:zip]
@@ -334,7 +339,7 @@ module ActiveMerchant #:nodoc:
       def authorization_from(action, response)
         case action
         when :validate
-          (response[:billing_id] || response[:dps_billing_id])
+          (response[:billing_id] || response[:dps_billing_id] || response[:dps_txn_ref])
         else
           response[:dps_txn_ref]
         end
@@ -361,7 +366,7 @@ module ActiveMerchant #:nodoc:
       # add a method to response so we can easily get the token
       # for Validate transactions
       def token
-        @params['billing_id'] || @params['dps_billing_id']
+        @params['billing_id'] || @params['dps_billing_id'] || @params['dps_txn_ref']
       end
     end
   end

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

@@ -9,7 +9,7 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = %w[MX EC CO BR CL PE]
       self.default_currency = 'USD'
-      self.supported_cardtypes = %i[visa master american_express diners_club elo alia]
+      self.supported_cardtypes = %i[visa master american_express diners_club elo alia olimpica]
 
       self.homepage_url = 'https://secure.paymentez.com/'
       self.display_name = 'Paymentez'
@@ -175,9 +175,29 @@ module ActiveMerchant #:nodoc:
         extra_params = {}
         extra_params.merge!(options[:extra_params]) if options[:extra_params]
 
+        add_external_mpi_fields(extra_params, options)
+
         post['extra_params'] = extra_params unless extra_params.empty?
       end
 
+      def add_external_mpi_fields(extra_params, options)
+        three_d_secure_options = options[:three_d_secure]
+        return unless three_d_secure_options
+
+        auth_data = {
+          cavv: three_d_secure_options[:cavv],
+          xid: three_d_secure_options[:xid],
+          eci: three_d_secure_options[:eci],
+          version: three_d_secure_options[:version],
+          reference_id: three_d_secure_options[:three_ds_server_trans_id],
+          status: three_d_secure_options[:authentication_response_status] || three_d_secure_options[:directory_response_status]
+        }.compact
+
+        return if auth_data.empty?
+
+        extra_params[:auth_data] = auth_data
+      end
+
       def parse(body)
         JSON.parse(body)
       end

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

@@ -58,7 +58,7 @@ module ActiveMerchant #:nodoc:
         xml = Builder::XmlMarkup.new indent: 2
         xml.tag! transaction_type + 'Req', 'xmlns' => PAYPAL_NAMESPACE do
           xml.tag! transaction_type + 'Request', 'xmlns:n2' => EBAY_NAMESPACE do
-            xml.tag! 'n2:Version', API_VERSION
+            xml.tag! 'n2:Version', api_version(options)
             xml.tag! 'n2:' + transaction_type + 'RequestDetails' do
               xml.tag! 'n2:ReferenceID', reference_id if transaction_type == 'DoReferenceTransaction'
               xml.tag! 'n2:PaymentAction', action
@@ -73,6 +73,12 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def api_version(options)
+        return API_VERSION_3DS2 if options.dig(:three_d_secure, :version) =~ /^2/
+
+        API_VERSION
+      end
+
       def add_credit_card(xml, credit_card, address, options)
         xml.tag! 'n2:CreditCard' do
           xml.tag! 'n2:CreditCardType', credit_card_type(card_brand(credit_card))
@@ -104,10 +110,12 @@ module ActiveMerchant #:nodoc:
         three_d_secure = options[:three_d_secure]
         xml.tag! 'ThreeDSecureRequest' do
           xml.tag! 'MpiVendor3ds', 'Y'
-          xml.tag! 'AuthStatus3ds', three_d_secure[:trans_status] unless three_d_secure[:trans_status].blank?
+          xml.tag! 'AuthStatus3ds', three_d_secure[:authentication_response_status] || three_d_secure[:trans_status] if three_d_secure[:authentication_response_status] || three_d_secure[:trans_status]
           xml.tag! 'Cavv', three_d_secure[:cavv] unless three_d_secure[:cavv].blank?
           xml.tag! 'Eci3ds', three_d_secure[:eci] unless three_d_secure[:eci].blank?
           xml.tag! 'Xid', three_d_secure[:xid] unless three_d_secure[:xid].blank?
+          xml.tag! 'ThreeDSVersion', three_d_secure[:version] unless three_d_secure[:version].blank?
+          xml.tag! 'DSTransactionId', three_d_secure[:ds_transaction_id] unless three_d_secure[:ds_transaction_id].blank?
         end
       end
 

data/lib/active_merchant/billing/gateways/paypal/paypal_common_api.rb

@@ -5,6 +5,7 @@ module ActiveMerchant #:nodoc:
       include Empty
 
       API_VERSION = '124'
+      API_VERSION_3DS2 = '214.0'
 
       URLS = {
         :test => { :certificate => 'https://api.sandbox.paypal.com/2.0/',

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

@@ -250,6 +250,7 @@ module ActiveMerchant #:nodoc:
               xml.tag! 'n2:PaymentType', options[:payment_type] || 'Any'
               add_payment_details(xml, money, currency_code, options)
               xml.tag! 'n2:IPAddress', options[:ip]
+              xml.tag! 'n2:MerchantSessionId', options[:merchant_session_id] if options[:merchant_session_id].present?
             end
           end
         end

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

@@ -0,0 +1,253 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaywayDotComGateway < Gateway
+      self.test_url = 'https://devedgilpayway.net/PaywayWS/Payment/CreditCard'
+      self.live_url = 'https://edgilpayway.com/PaywayWS/Payment/CreditCard'
+
+      self.supported_countries = %w[US CA]
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.money_format = :cents
+
+      self.homepage_url = 'http://www.payway.com'
+      self.display_name = 'Payway Gateway'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '5012' => STANDARD_ERROR_CODE[:card_declined],
+        '5035' => STANDARD_ERROR_CODE[:invalid_number],
+        '5037' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '5045' => STANDARD_ERROR_CODE[:incorrect_zip]
+      }
+
+      # Payway to standard AVSResult codes.
+      AVS_MAPPING = {
+        'N1'  => 'I', #  No address given with order
+        'N2'  => 'I', #  Bill-to address did not pass
+        '““'  => 'R', #  AVS not performed (Blanks returned)
+        'IU'  => 'G', #  AVS not performed by Issuer
+        'ID'  => 'S', #  Issuer does not participate in AVS
+        'IE'  => 'E', #  Edit Error - AVS data is invalid
+        'IS'  => 'R', #  System unavailable or time-out
+        'IB'  => 'B', #  Street address match. Postal code not verified due to incompatible formats (both were sent).
+        'IC'  => 'C', #  Street address and postal code not verified due to incompatible format (both were sent).
+        'IP'  => 'P', #  Postal code match. Street address not verified due to incompatible formats (both were sent).
+        'A1'  => 'K', #  Accountholder name matches
+        'A3'  => 'V', #  Accountholder name, billing address and postal code.
+        'A4'  => 'L', #  Accountholder name and billing postal code match
+        'A7'  => 'O', #  Accountholder name and billing address match
+        'B3'  => 'H', #  Accountholder name incorrect, billing address and postal code match
+        'B4'  => 'F', #  Accountholder name incorrect, billing postal code matches
+        'B7'  => 'T', #  Accountholder name incorrect, billing address matches
+        'B8'  => 'N', #  Accountholder name, billing address and postal code are all incorrect
+        '??'  => 'R', #  A double question mark symbol indicates an unrecognized response from association
+        'I1'  => 'X', #  Zip code +4 and Address Match
+        'I2'  => 'W', #  Zip code +4 Match
+        'I3'  => 'Y', #  Zip code and Address Match
+        'I4'  => 'Z', #  Zip code Match
+        'I5'  => 'M', #  +4 and Address Match
+        'I6'  => 'W', #  +4 Match
+        'I7'  => 'A', #  Address Match
+        'I8'  => 'C', #  No Match
+      }
+
+      PAYWAY_WS_SUCCESS = '5000'
+
+      SCRUB_PATTERNS = [
+        %r(("password\\?":\\?")[^\\]+),
+        %r(("fsv\\?":\\?")\d+),
+        %r(("fsv\\?": \\?")\d+),
+        %r(("accountNumber\\?":\\?")\d+),
+        %r(("accountNumber\\?": \\?")[^\\]+),
+        %r(("Invalid account number: )\d+)
+      ].freeze
+
+      SCRUB_REPLACEMENT = '\1[FILTERED]'
+
+      def initialize(options = {})
+        requires!(options, :login, :password, :company_id, :source_id)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_payment(post, payment, options)
+        add_card_transaction_details(post, money, options)
+        add_address(post, payment, options)
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_payment(post, payment, options)
+        add_card_transaction_details(post, money, options)
+        add_address(post, payment, options)
+
+        commit('authorize', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_transaction_name(post, authorization, options)
+
+        commit('capture', post)
+      end
+
+      def credit(money, payment, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_payment(post, payment, options)
+        add_card_transaction_details(post, money, options)
+        add_address(post, payment, options)
+
+        commit('credit', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_transaction_name(post, authorization, options)
+
+        commit('void', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        SCRUB_PATTERNS.inject(transcript) do |text, pattern|
+          text.gsub(pattern, SCRUB_REPLACEMENT)
+        end
+      end
+
+      private
+
+      def add_common(post, options)
+        post[:userName] = @options[:login]
+        post[:password] = @options[:password]
+        post[:companyId] = @options[:company_id]
+        post[:cardTransaction] = {}
+        post[:cardTransaction][:sourceId] = @options[:source_id]
+      end
+
+      def add_address(post, payment, options)
+        post[:cardAccount] ||= {}
+        address = options[:billing_address] || options[:address] || {}
+        first_name, last_name = split_names(address[:name])
+        full_address = "#{address[:address1]} #{address[:address2]}".strip
+        phone = address[:phone] || address[:phone_number]
+
+        post[:cardAccount][:firstName] = first_name      if first_name
+        post[:cardAccount][:lastName]  = last_name       if last_name
+        post[:cardAccount][:address]   = full_address    if full_address
+        post[:cardAccount][:city]      = address[:city]  if address[:city]
+        post[:cardAccount][:state]     = address[:state] if address[:state]
+        post[:cardAccount][:zip]       = address[:zip]   if address[:zip]
+        post[:cardAccount][:phone]     = phone           if phone
+      end
+
+      def add_card_transaction_details(post, money, options)
+        post[:cardTransaction][:amount] = amount(money)
+        eci_type = options[:eci_type].nil? ? '1' : options[:eci_type]
+        post[:cardTransaction][:eciType] = eci_type
+        post[:cardTransaction][:processorSoftDescriptor] = options[:processor_soft_descriptor] if options[:processor_soft_descriptor]
+        post[:cardTransaction][:tax] = options[:tax] if options[:tax]
+      end
+
+      def add_card_transaction_name(post, identifier, options)
+        post[:cardTransaction][:name] = identifier
+      end
+
+      def add_card_payment(post, payment, options)
+        # credit_card
+        post[:accountInputMode] = 'primaryAccountNumber'
+
+        post[:cardAccount] ||= {}
+        post[:cardAccount][:accountNumber]  = payment.number
+        post[:cardAccount][:fsv]            = payment.verification_value
+        post[:cardAccount][:expirationDate] = expdate(payment)
+        post[:cardAccount][:email]          = options[:email] if options[:email]
+      end
+
+      def expdate(credit_card)
+        year  = format(credit_card.year, :four_digits)
+        month = format(credit_card.month, :two_digits)
+
+        month + year
+      end
+
+      def parse(body)
+        body.blank? ? {} : JSON.parse(body)
+      end
+
+      def commit(action, parameters)
+        parameters[:request] = action
+
+        url = (test? ? test_url : live_url)
+        payload = parameters.to_json unless parameters.nil?
+
+        response =
+          begin
+            parse(ssl_request(:post, url, payload, headers))
+          rescue ResponseError => e
+            return Response.new(false, 'Invalid Login') if e.response.code == '401'
+
+            parse(e.response.body)
+          end
+
+        success = success_from(response)
+        avs_result_code = response['cardTransaction'].nil? || response['cardTransaction']['addressVerificationResults'].nil? ? '' : response['cardTransaction']['addressVerificationResults']
+        avs_result = AVSResult.new(code: AVS_MAPPING[avs_result_code])
+        cvv_result = CVVResult.new(response['cardTransaction']['fraudSecurityResults']) if response['cardTransaction'] && response['cardTransaction']['fraudSecurityResults']
+
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          test: test?,
+          error_code: error_code_from(response),
+          authorization: authorization_from(response),
+          avs_result: avs_result,
+          cvv_result: cvv_result
+        )
+      end
+
+      def success_from(response)
+        response['paywayCode'] == PAYWAY_WS_SUCCESS
+      end
+
+      def error_code_from(response)
+        return '' if success_from(response)
+
+        error = !STANDARD_ERROR_CODE_MAPPING[response['paywayCode']].nil? ? STANDARD_ERROR_CODE_MAPPING[response['paywayCode']] : STANDARD_ERROR_CODE[:processing_error]
+        return error
+      end
+
+      def message_from(success, response)
+        return '' if response['paywayCode'].nil?
+
+        return response['paywayCode'] + '-' + 'success' if success
+
+        response['paywayCode'] + '-' + response['paywayMessage']
+      end
+
+      def authorization_from(response)
+        return '' if !success_from(response) || response['cardTransaction'].nil?
+
+        response['cardTransaction']['name']
+      end
+
+      def headers
+        {
+          'Accept'        => 'application/json',
+          'Content-type'  => 'application/json'
+        }
+      end
+    end
+  end
+end