activemerchant 1.133.0 → 1.137.0

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

@@ -0,0 +1,347 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FlexChargeGateway < Gateway
+      self.test_url = 'https://api-sandbox.flex-charge.com/v1/'
+      self.live_url = 'https://api.flex-charge.com/v1/'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.money_format = :cents
+      self.homepage_url = 'https://www.flex-charge.com/'
+      self.display_name = 'FlexCharge'
+
+      ENDPOINTS_MAPPING = {
+        authenticate: 'oauth2/token',
+        purchase: 'evaluate',
+        sync: 'outcome',
+        refund: 'orders/%s/refund',
+        store: 'tokenize',
+        inquire: 'orders/%s',
+        capture: 'capture',
+        void: 'orders/%s/cancel'
+      }
+
+      SUCCESS_MESSAGES = %w(APPROVED CHALLENGE SUBMITTED SUCCESS PROCESSING CAPTUREREQUIRED).freeze
+
+      def initialize(options = {})
+        requires!(options, :app_key, :app_secret, :site_id, :mid)
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        post = { transactionType: options.fetch(:transactionType, 'Purchase') }
+
+        add_merchant_data(post, options)
+        add_base_data(post, options)
+        add_invoice(post, money, credit_card, options)
+        add_mit_data(post, options)
+        add_payment_method(post, credit_card, address(options), options)
+        add_address(post, credit_card, address(options), :billingInformation)
+        add_address(post, credit_card, options[:shipping_address], :shippingInformation)
+        add_customer_data(post, options)
+        add_three_ds(post, options)
+        add_metadata(post, options)
+
+        commit(:purchase, post)
+      end
+
+      def authorize(money, credit_card, options = {})
+        options[:transactionType] = 'Authorization'
+        purchase(money, credit_card, options)
+      end
+
+      def capture(money, authorization, options = {})
+        order_id, currency = authorization.split('#')
+        post = {
+          idempotencyKey: options[:idempotency_key] || SecureRandom.uuid,
+          orderId: order_id,
+          amount: money,
+          currency: currency
+        }
+
+        commit(:capture, post, authorization)
+      end
+
+      def refund(money, authorization, options = {})
+        order_id, _currency = authorization.split('#')
+        self.money_format = :dollars
+        commit(:refund, { amountToRefund: localized_amount(money, 2).to_f }, order_id)
+      end
+
+      def void(authorization, options = {})
+        order_id, _currency = authorization.split('#')
+        commit(:void, {}, order_id)
+      end
+
+      def store(credit_card, options = {})
+        first_name, last_name = names_from_address(address(options), credit_card)
+
+        post = {
+          payment_method: {
+            credit_card: {
+              first_name: first_name,
+              last_name: last_name,
+              month: credit_card.month,
+              year: credit_card.year,
+              number: credit_card.number,
+              verification_value: credit_card.verification_value
+            }.compact
+          }
+        }
+        commit(:store, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Bearer )[a-zA-Z0-9._-]+)i, '\1[FILTERED]').
+          gsub(%r(("AppKey\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("AppSecret\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("accessToken\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("mid\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("siteId\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("environment\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("number\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cardNumber\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("verification_value\\?":\\?")\d+), '\1[FILTERED]')
+      end
+
+      def inquire(authorization, options = {})
+        order_id, _currency = authorization.split('#')
+        commit(:inquire, {}, order_id, :get)
+      end
+
+      def add_metadata(post, options)
+        post[:Source] = 'Spreedly'
+        post[:ExtraData] = options[:extra_data] if options[:extra_data].present?
+      end
+
+      private
+
+      def address(options)
+        options[:billing_address] || options[:address] || {}
+      end
+
+      def add_three_ds(post, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post[:threeDSecure] = {
+          threeDsVersion: three_d_secure[:version],
+          EcommerceIndicator: three_d_secure[:eci],
+          authenticationValue: three_d_secure[:cavv],
+          directoryServerTransactionId:  three_d_secure[:ds_transaction_id],
+          xid: three_d_secure[:xid],
+          authenticationValueAlgorithm: three_d_secure[:cavv_algorithm],
+          directoryResponseStatus: three_d_secure[:directory_response_status],
+          authenticationResponseStatus: three_d_secure[:authentication_response_status],
+          enrolled: three_d_secure[:enrolled]
+        }
+      end
+
+      def add_merchant_data(post, options)
+        post[:siteId] = @options[:site_id]
+        post[:mid] = @options[:mid]
+      end
+
+      def add_base_data(post, options)
+        post[:isDeclined] = cast_bool(options[:is_declined])
+        post[:orderId] = options[:order_id]
+        post[:idempotencyKey] = options[:idempotency_key] || SecureRandom.uuid
+        post[:senseKey] = options[:sense_key]
+      end
+
+      def add_mit_data(post, options)
+        return if options[:is_mit].nil?
+
+        post[:isMIT] = cast_bool(options[:is_mit])
+        post[:isRecurring] = cast_bool(options[:is_recurring])
+        post[:expiryDateUtc] = options[:mit_expiry_date_utc]
+      end
+
+      def add_customer_data(post, options)
+        post[:payer] = { email: options[:email] || 'NA', phone: phone_from(options) }.compact
+      end
+
+      def add_address(post, payment, address, address_type)
+        return unless address.present?
+
+        first_name, last_name = names_from_address(address, payment)
+
+        post[address_type] = {
+          firstName: first_name,
+          lastName: last_name,
+          country: address[:country],
+          phone: address[:phone],
+          countryCode: address[:country],
+          addressLine1: address[:address1],
+          state: address[:state],
+          city: address[:city],
+          zipCode: address[:zip]
+        }.compact
+      end
+
+      def add_invoice(post, money, credit_card, options)
+        post[:transaction] = {
+          id: options[:order_id],
+          dynamicDescriptor: options[:description],
+          timestamp: Time.now.utc.iso8601,
+          timezoneUtcOffset: options[:timezone_utc_offset],
+          amount: money,
+          currency: (options[:currency] || currency(money)),
+          responseCode: options[:response_code],
+          responseCodeSource: options[:response_code_source] || '',
+          avsResultCode: options[:avs_result_code],
+          cvvResultCode: options[:cvv_result_code],
+          cavvResultCode: options[:cavv_result_code],
+          cardNotPresent: credit_card.is_a?(String) ? false : credit_card.verification_value.blank?
+        }.compact
+      end
+
+      def add_payment_method(post, credit_card, address, options)
+        payment_method = case credit_card
+                         when String
+                           { Token: true, cardNumber: credit_card }
+                         when CreditCard
+                           if credit_card.number
+                             {
+                               holderName: credit_card.name,
+                               cardType: 'CREDIT',
+                               cardBrand: credit_card.brand&.upcase,
+                               cardCountry: address[:country],
+                               expirationMonth: credit_card.month,
+                               expirationYear: credit_card.year,
+                               cardBinNumber: credit_card.number[0..5],
+                               cardLast4Digits: credit_card.number[-4..-1],
+                               cardNumber: credit_card.number,
+                               Token: false
+                             }
+                           else
+                             {}
+                           end
+                         end
+        post[:paymentMethod] = payment_method.compact
+      end
+
+      def names_from_address(address, payment_method)
+        split_names(address[:name]).tap do |names|
+          names[0] = payment_method&.first_name unless names[0].present? || payment_method.is_a?(String)
+          names[1] = payment_method&.last_name unless names[1].present? || payment_method.is_a?(String)
+        end
+      end
+
+      def phone_from(options)
+        options[:phone] || options.dig(:billing_address, :phone_number)
+      end
+
+      def access_token_valid?
+        @options[:access_token].present? && @options.fetch(:token_expires, 0) > DateTime.now.strftime('%Q').to_i
+      end
+
+      def fetch_access_token
+        params = { AppKey: @options[:app_key], AppSecret: @options[:app_secret] }
+        response = parse(ssl_post(url(:authenticate), params.to_json, headers))
+
+        @options[:access_token] = response[:accessToken]
+        @options[:token_expires] = response[:expires]
+        @options[:new_credentials] = true
+
+        Response.new(
+          response[:accessToken].present?,
+          message_from(response),
+          response,
+          test: test?,
+          error_code: response[:statusCode]
+        )
+      rescue ResponseError => e
+        raise OAuthResponseError.new(e)
+      end
+
+      def url(action, id = nil)
+        "#{test? ? test_url : live_url}#{ENDPOINTS_MAPPING[action] % id}"
+      end
+
+      def headers
+        { 'Content-Type' => 'application/json' }.tap do |headers|
+          headers['Authorization'] = "Bearer #{@options[:access_token]}" if @options[:access_token]
+        end
+      end
+
+      def parse(body)
+        body = '{}' if body.blank?
+
+        JSON.parse(body).with_indifferent_access
+      rescue JSON::ParserError
+        {
+          errors: body,
+          status: 'Unable to parse JSON response'
+        }.with_indifferent_access
+      end
+
+      def commit(action, post, authorization = nil, method = :post)
+        MultiResponse.run do |r|
+          r.process { fetch_access_token } unless access_token_valid?
+          r.process do
+            api_request(action, post, authorization, method).tap do |response|
+              response.params.merge!(@options.slice(:access_token, :token_expires)) if @options[:new_credentials]
+            end
+          end
+        end
+      end
+
+      def api_request(action, post, authorization = nil, method = :post)
+        response = parse ssl_request(method, url(action, authorization), post.to_json, headers)
+
+        Response.new(
+          success_from(action, response),
+          message_from(response),
+          response,
+          authorization: authorization_from(action, response, post),
+          test: test?,
+          error_code: error_code_from(action, response)
+        )
+      rescue ResponseError => e
+        response = parse(e.response.body)
+        # if current access_token is invalid then clean it
+        if e.response.code == '401'
+          @options[:access_token] = ''
+          @options[:new_credentials] = true
+        end
+        Response.new(false, message_from(response), response, test: test?)
+      end
+
+      def success_from(action, response)
+        case action
+        when :store then response.dig(:transaction, :payment_method, :token).present?
+        when :inquire then response[:id].present? && SUCCESS_MESSAGES.include?(response[:statusName])
+        when :void then response.empty?
+        else
+          response[:success] && SUCCESS_MESSAGES.include?(response[:status])
+        end
+      end
+
+      def message_from(response)
+        response[:title] || response[:responseMessage] || response[:statusName] || response[:status]
+      end
+
+      def authorization_from(action, response, options)
+        if action == :store
+          response.dig(:transaction, :payment_method, :token)
+        elsif success_from(action, response)
+          [response[:orderId], options[:currency] || default_currency].compact.join('#')
+        end
+      end
+
+      def error_code_from(action, response)
+        (response[:statusName] || response[:status]) unless success_from(action, response)
+      end
+
+      def cast_bool(value)
+        ![false, 0, '', '0', 'f', 'F', 'false', 'FALSE'].include?(value)
+      end
+    end
+  end
+end

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

@@ -219,11 +219,13 @@ module ActiveMerchant #:nodoc:
 
         success = success?(response)
 
-        Response.new(success,
+        Response.new(
+          success,
           success ? 'Approved' : "Declined (Reason: #{response[:reason_code]} - #{response[:error_msg]} - #{response[:sys_err_msg]})",
           response,
           test: test?,
-          authorization: response[:order_id])
+          authorization: response[:order_id]
+        )
       end
 
       def parse(body)

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

@@ -5,19 +5,19 @@ module ActiveMerchant #:nodoc:
       class_attribute :ogone_direct_test
       class_attribute :ogone_direct_live
 
-      self.display_name = 'GlobalCollect'
+      self.display_name = 'Worldline (formerly GlobalCollect)'
       self.homepage_url = 'http://www.globalcollect.com/'
 
       self.test_url = 'https://eu.sandbox.api-ingenico.com'
-      self.preproduction_url = 'https://world.preprod.api-ingenico.com'
-      self.live_url = 'https://world.api-ingenico.com'
+      self.preproduction_url = 'https://api.preprod.connect.worldline-solutions.com'
+      self.live_url = 'https://api.connect.worldline-solutions.com'
       self.ogone_direct_test = 'https://payment.preprod.direct.worldline-solutions.com'
       self.ogone_direct_live = 'https://payment.direct.worldline-solutions.com'
 
       self.supported_countries = %w[AD AE AG AI AL AM AO AR AS AT AU AW AX AZ BA BB BD BE BF BG BH BI BJ BL BM BN BO BQ BR BS BT BW BY BZ CA CC CD CF CH CI CK CL CM CN CO CR CU CV CW CX CY CZ DE DJ DK DM DO DZ EC EE EG ER ES ET FI FJ FK FM FO FR GA GB GD GE GF GH GI GL GM GN GP GQ GR GS GT GU GW GY HK HN HR HT HU ID IE IL IM IN IS IT JM JO JP KE KG KH KI KM KN KR KW KY KZ LA LB LC LI LK LR LS LT LU LV MA MC MD ME MF MG MH MK MM MN MO MP MQ MR MS MT MU MV MW MX MY MZ NA NC NE NG NI NL NO NP NR NU NZ OM PA PE PF PG PH PL PN PS PT PW QA RE RO RS RU RW SA SB SC SE SG SH SI SJ SK SL SM SN SR ST SV SZ TC TD TG TH TJ TL TM TN TO TR TT TV TW TZ UA UG US UY UZ VC VE VG VI VN WF WS ZA ZM ZW]
       self.default_currency = 'USD'
       self.money_format = :cents
-      self.supported_cardtypes = %i[visa master american_express discover naranja cabal]
+      self.supported_cardtypes = %i[visa master american_express discover naranja cabal tuya]
 
       def initialize(options = {})
         requires!(options, :merchant_id, :api_key_id, :secret_api_key)
@@ -40,6 +40,7 @@ module ActiveMerchant #:nodoc:
         add_creator_info(post, options)
         add_fraud_fields(post, options)
         add_external_cardholder_authentication_data(post, options)
+        add_threeds_exemption_data(post, options)
         commit(:post, :authorize, post, options: options)
       end
 
@@ -101,8 +102,8 @@ module ActiveMerchant #:nodoc:
         'diners_club' => '132',
         'cabal' => '135',
         'naranja' => '136',
-        'apple_pay': '302',
-        'google_pay': '320'
+        apple_pay: '302',
+        google_pay: '320'
       }
 
       def add_order(post, money, options, capture: false)
@@ -138,6 +139,7 @@ module ActiveMerchant #:nodoc:
         airline_data['isThirdParty'] = options[:airline_data][:is_third_party] if options[:airline_data][:is_third_party]
         airline_data['issueDate'] = options[:airline_data][:issue_date] if options[:airline_data][:issue_date]
         airline_data['merchantCustomerId'] = options[:airline_data][:merchant_customer_id] if options[:airline_data][:merchant_customer_id]
+        airline_data['agentNumericCode'] = options[:airline_data][:agent_numeric_code] if options[:airline_data][:agent_numeric_code]
         airline_data['flightLegs'] = add_flight_legs(airline_options)
         airline_data['passengers'] = add_passengers(airline_options)
 
@@ -275,7 +277,7 @@ module ActiveMerchant #:nodoc:
         if payment.is_a?(NetworkTokenizationCreditCard)
           add_mobile_credit_card(post, payment, options, specifics_inputs, expirydate)
         elsif payment.is_a?(CreditCard)
-          options[:google_pay_pan_only] ? add_mobile_credit_card(post, payment, options, specifics_inputs, expirydate) : add_credit_card(post, payment, specifics_inputs, expirydate)
+          add_credit_card(post, payment, specifics_inputs, expirydate)
         end
       end
 
@@ -291,31 +293,32 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_mobile_credit_card(post, payment, options, specifics_inputs, expirydate)
-        specifics_inputs['paymentProductId'] = options[:google_pay_pan_only] ? BRAND_MAP[:google_pay] : BRAND_MAP[payment.source]
+        specifics_inputs['paymentProductId'] = BRAND_MAP[payment.source]
         post['mobilePaymentMethodSpecificInput'] = specifics_inputs
-        add_decrypted_payment_data(post, payment, options, expirydate)
+
+        if options[:use_encrypted_payment_data]
+          post['mobilePaymentMethodSpecificInput']['encryptedPaymentData'] = payment.payment_data
+        else
+          add_decrypted_payment_data(post, payment, options, expirydate)
+        end
       end
 
       def add_decrypted_payment_data(post, payment, options, expirydate)
-        if payment.is_a?(NetworkTokenizationCreditCard) && payment.payment_cryptogram
-          data = {
-            'cardholderName' => payment.name,
-            'cryptogram' => payment.payment_cryptogram,
-            'eci' => payment.eci,
-            'expiryDate' => expirydate,
-            'dpan' => payment.number
-          }
-          data['paymentMethod'] = 'TOKENIZED_CARD' if payment.source == :google_pay
-        # else case when google payment is an ONLY_PAN, doesn't have cryptogram or eci.
-        elsif options[:google_pay_pan_only]
-          data = {
-            'cardholderName' => payment.name,
-            'expiryDate' => expirydate,
-            'pan' => payment.number,
-            'paymentMethod' => 'CARD'
-          }
-        end
-        post['mobilePaymentMethodSpecificInput']['decryptedPaymentData'] = data if data
+        data_type = payment.source == :apple_pay ? 'decrypted' : 'encrypted'
+        data = case payment.source
+               when :apple_pay
+                 {
+                   'cardholderName' => payment.name,
+                   'cryptogram' => payment.payment_cryptogram,
+                   'eci' => payment.eci,
+                   'expiryDate' => expirydate,
+                   'dpan' => payment.number
+                 }
+               when :google_pay
+                 payment.payment_data
+               end
+
+        post['mobilePaymentMethodSpecificInput']["#{data_type}PaymentData"] = data if data
       end
 
       def add_customer_data(post, options, payment = nil)
@@ -326,8 +329,8 @@ module ActiveMerchant #:nodoc:
         post['order']['customer']['merchantCustomerId'] = options[:customer] if options[:customer]
         post['order']['customer']['companyInformation']['name'] = options[:company] if options[:company]
         post['order']['customer']['contactDetails']['emailAddress'] = options[:email] if options[:email]
-        if address = options[:billing_address] || options[:address]
-          post['order']['customer']['contactDetails']['phoneNumber'] = address[:phone] if address[:phone]
+        if address = options[:billing_address] || options[:address] && (address[:phone])
+          post['order']['customer']['contactDetails']['phoneNumber'] = address[:phone]
         end
       end
 
@@ -337,8 +340,8 @@ module ActiveMerchant #:nodoc:
             'countryCode' => address[:country]
           }
           post['customer']['contactDetails']['emailAddress'] = options[:email] if options[:email]
-          if address = options[:billing_address] || options[:address]
-            post['customer']['contactDetails']['phoneNumber'] = address[:phone] if address[:phone]
+          if address = options[:billing_address] || options[:address] && (address[:phone])
+            post['customer']['contactDetails']['phoneNumber'] = address[:phone]
           end
         end
       end
@@ -347,7 +350,8 @@ module ActiveMerchant #:nodoc:
         shipping_address = options[:shipping_address]
         if billing_address = options[:billing_address] || options[:address]
           post['order']['customer']['billingAddress'] = {
-            'street' => truncate(billing_address[:address1], 50),
+            'street' => truncate(split_address(billing_address[:address1])[1], 50),
+            'houseNumber' => split_address(billing_address[:address1])[0],
             'additionalInfo' => truncate(billing_address[:address2], 50),
             'zip' => billing_address[:zip],
             'city' => billing_address[:city],
@@ -357,7 +361,8 @@ module ActiveMerchant #:nodoc:
         end
         if shipping_address
           post['order']['customer']['shippingAddress'] = {
-            'street' => truncate(shipping_address[:address1], 50),
+            'street' => truncate(split_address(shipping_address[:address1])[1], 50),
+            'houseNumber' => split_address(shipping_address[:address1])[0],
             'additionalInfo' => truncate(shipping_address[:address2], 50),
             'zip' => shipping_address[:zip],
             'city' => shipping_address[:city],
@@ -374,7 +379,6 @@ module ActiveMerchant #:nodoc:
       def add_fraud_fields(post, options)
         fraud_fields = {}
         fraud_fields.merge!(options[:fraud_fields]) if options[:fraud_fields]
-        fraud_fields[:customerIpAddress] = options[:ip] if options[:ip]
 
         post['fraudFields'] = fraud_fields unless fraud_fields.empty?
       end
@@ -403,6 +407,12 @@ module ActiveMerchant #:nodoc:
         post['cardPaymentMethodSpecificInput']['threeDSecure']['externalCardholderAuthenticationData'] = authentication_data unless authentication_data.empty?
       end
 
+      def add_threeds_exemption_data(post, options)
+        return unless options[:three_ds_exemption_type]
+
+        post['cardPaymentMethodSpecificInput']['transactionChannel'] = 'MOTO' if options[:three_ds_exemption_type] == 'moto'
+      end
+
       def add_number_of_installments(post, options)
         post['order']['additionalInput']['numberOfInstallments'] = options[:number_of_installments] if options[:number_of_installments]
       end
@@ -512,8 +522,6 @@ module ActiveMerchant #:nodoc:
       def success_from(action, response)
         return false if response['errorId'] || response['error_message']
 
-        return %w(CAPTURED CAPTURE_REQUESTED).include?(response.dig('payment', 'status')) if response.dig('payment', 'paymentOutput', 'paymentMethod') == 'mobile'
-
         case action
         when :authorize
           response.dig('payment', 'statusOutput', 'isAuthorized')