activemerchant 1.62.0 → 1.79.2

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

@@ -0,0 +1,276 @@
+require 'base64'
+require 'digest'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaymentezGateway < Gateway #:nodoc:
+      self.test_url = 'https://ccapi-stg.paymentez.com/v2/'
+      self.live_url = 'https://ccapi.paymentez.com/v2/'
+
+      self.supported_countries = %w[MX EC VE CO BR CL]
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express diners_club]
+
+      self.homepage_url = 'https://secure.paymentez.com/'
+      self.display_name = 'Paymentez'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        1 => :processing_error,
+        6 => :card_declined,
+        9 => :card_declined,
+        10 => :processing_error,
+        11 => :card_declined,
+        12 => :config_error,
+        13 => :config_error,
+        19 => :invalid_cvc,
+        20 => :config_error,
+        21 => :card_declined,
+        22 => :card_declined,
+        23 => :card_declined,
+        24 => :card_declined,
+        25 => :card_declined,
+        26 => :card_declined,
+        27 => :card_declined,
+        28 => :card_declined
+      }.freeze
+
+      CARD_MAPPING = {
+        'visa' => 'vi',
+        'master' => 'mc',
+        'american_express' => 'ax',
+        'diners_club' => 'di'
+      }.freeze
+
+      def initialize(options = {})
+        requires!(options, :application_code, :app_key)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_customer_data(post, options)
+        action = payment.is_a?(String) ? 'debit' : 'debit_cc'
+
+        commit_transaction(action, post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_customer_data(post, options)
+
+        commit_transaction('authorize', post)
+      end
+
+      def capture(_money, authorization, _options = {})
+        post = { transaction: { id: authorization } }
+
+        commit_transaction('capture', post)
+      end
+
+      def refund(_money, authorization, options = {})
+        void(authorization, options)
+      end
+
+      def void(authorization, _options = {})
+        post = { transaction: { id: authorization } }
+        commit_transaction('refund', post)
+      end
+
+      def verify(credit_card, options = {})
+        MultiResponse.run do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process { void(r.authorization, options) }
+        end
+      end
+
+      def store(credit_card, options = {})
+        post = {}
+
+        add_customer_data(post, options)
+        add_payment(post, credit_card)
+
+        response = commit_card('add', post)
+        if !response.success? && !(token = extract_previous_card_token(response)).nil?
+          unstore(token, options)
+          response = commit_card('add', post)
+        end
+        response
+      end
+
+      def unstore(identification, options = {})
+        post = { card: { token: identification }, user: { id: options[:user_id] }}
+        commit_card('delete', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript
+          .gsub(%r{(\\?"number\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]')
+          .gsub(%r{(\\?"cvc\\?":)(\\?"[^"]+\\?")}, '\1[FILTERED]')
+          .gsub(%r{(Auth-Token: )([A-Za-z0-9=]+)}, '\1[FILTERED]')
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        requires!(options, :user_id, :email)
+        post[:user] ||= {}
+        post[:user][:id] = options[:user_id]
+        post[:user][:email] = options[:email]
+        post[:user][:ip_address] = options[:ip] if options[:ip]
+        post[:user][:fiscal_number] = options[:fiscal_number] if options[:fiscal_number]
+      end
+
+      def add_invoice(post, money, options)
+        post[:session_id] = options[:session_id] if options[:session_id]
+
+        post[:order] ||= {}
+        post[:order][:amount] = amount(money).to_f
+        post[:order][:vat] = options[:vat] if options[:vat]
+        post[:order][:dev_reference] = options[:dev_reference] if options[:dev_reference]
+        post[:order][:description] = options[:description] if options[:description]
+        post[:order][:discount] = options[:discount] if options[:discount]
+        post[:order][:installments] = options[:installments] if options[:installments]
+        post[:order][:installments_type] = options[:installments_type] if options[:installments_type]
+        post[:order][:taxable_amount] = options[:taxable_amount] if options[:taxable_amount]
+        post[:order][:tax_percentage] = options[:tax_percentage] if options[:tax_percentage]
+      end
+
+      def add_payment(post, payment)
+        post[:card] ||= {}
+        if payment.is_a?(String)
+          post[:card][:token] = payment
+        else
+          post[:card][:number] = payment.number
+          post[:card][:holder_name] = payment.name
+          post[:card][:expiry_month] = payment.month
+          post[:card][:expiry_year] = payment.year
+          post[:card][:cvc] = payment.verification_value
+          post[:card][:type] = CARD_MAPPING[payment.brand]
+        end
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit_raw(object, action, parameters)
+        url = "#{(test? ? test_url : live_url)}#{object}/#{action}"
+
+        begin
+          raw_response = ssl_post(url, post_data(parameters), headers)
+        rescue ResponseError => e
+          raw_response = e.response.body
+        end
+        parse(raw_response)
+      end
+
+      def commit_transaction(action, parameters)
+        response = commit_raw('transaction', action, parameters)
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def commit_card(action, parameters)
+        response = commit_raw('card', action, parameters)
+        Response.new(
+          card_success_from(response),
+          card_message_from(response),
+          response,
+          authorization: card_authorization_from(response),
+          test: test?,
+          error_code: card_error_code_from(response)
+        )
+      end
+
+      def headers
+        {
+          'Auth-Token' => authentication_code,
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      def success_from(response)
+        !response.include?('error') && (response['status'] || response['transaction']['status']) == 'success'
+      end
+
+      def card_success_from(response)
+        return false if response.include?('error')
+        return true if response['message'] == 'card deleted'
+        response['card']['status'] == 'valid'
+      end
+
+      def message_from(response)
+        if !success_from(response) && response['error']
+          response['error'] && response['error']['type']
+        else
+          response['transaction'] && response['transaction']['message']
+        end
+      end
+
+      def card_message_from(response)
+        if !response.include?('error')
+          response['message'] || response['card']['message']
+        else
+          response['error']['type']
+        end
+      end
+
+      def authorization_from(response)
+        response['transaction'] && response['transaction']['id']
+      end
+
+      def card_authorization_from(response)
+        response['card'] && response['card']['token']
+      end
+
+      def extract_previous_card_token(response)
+        match = /Card already added: (\d+)/.match(response.message)
+        match && match[1]
+      end
+
+      def post_data(parameters = {})
+        JSON.dump(parameters)
+      end
+
+      def error_code_from(response)
+        return if success_from(response)
+        if response['transaction']
+          detail = response['transaction']['status_detail']
+          if STANDARD_ERROR_CODE_MAPPING.include?(detail)
+            return STANDARD_ERROR_CODE[STANDARD_ERROR_CODE_MAPPING[detail]]
+          end
+        elsif response['error']
+          return STANDARD_ERROR_CODE[:config_error]
+        end
+        STANDARD_ERROR_CODE[:processing_error]
+      end
+
+      def card_error_code_from(response)
+        STANDARD_ERROR_CODE[:processing_error] unless card_success_from(response)
+      end
+
+      def authentication_code
+        timestamp = Time.new.to_i
+        unique_token = Digest::SHA256.hexdigest("#{@options[:app_key]}#{timestamp}")
+        authentication_string = "#{@options[:application_code]};#{timestamp};#{unique_token}"
+        Base64.encode64(authentication_string).delete("\n")
+      end
+    end
+  end
+end

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

@@ -17,7 +17,7 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def purchase(money, payment_method, options = {})
+      def purchase(money, payment_method, options={})
         action_with_token(:purchase, money, payment_method, options)
       end
 
@@ -48,7 +48,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def store(credit_card, options={})
-        save_card(credit_card)
+        save_card(credit_card, options)
       end
 
       def supports_scrubbing
@@ -74,11 +74,15 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      def add_credit_card(post, credit_card)
+      def add_credit_card(post, credit_card, options)
+        post['account.holder'] = (credit_card.try(:name) || "")
         post['account.number'] = credit_card.number
         post['account.expiry.month'] = sprintf("%.2i", credit_card.month)
         post['account.expiry.year'] = sprintf("%.4i", credit_card.year)
         post['account.verification'] = credit_card.verification_value
+        post['account.email'] = (options[:email] || nil)
+        post['presentation.amount3D'] =  (options[:money] || nil)
+        post['presentation.currency3D'] = (options[:currency] || currency( options[:money]))
       end
 
       def headers
@@ -122,12 +126,13 @@ module ActiveMerchant #:nodoc:
       end
 
       def action_with_token(action, money, payment_method, options)
+        options[:money] = money
         case payment_method
-        when String
-          self.send("#{action}_with_token", money, payment_method, options)
-        else
-          MultiResponse.run do |r|
-            r.process { save_card(payment_method) }
+          when String
+            self.send("#{action}_with_token", money, payment_method, options)
+          else
+            MultiResponse.run do |r|
+            r.process { save_card(payment_method, options) }
             r.process { self.send("#{action}_with_token", money, r.authorization, options) }
           end
         end
@@ -153,10 +158,10 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'preauthorizations', post)
       end
 
-      def save_card(credit_card)
+      def save_card(credit_card, options)
         post = {}
 
-        add_credit_card(post, credit_card)
+        add_credit_card(post, credit_card, options)
         post['channel.id'] = @options[:public_key]
         post['jsonPFunction'] = 'jsonPFunction'
         post['transaction.mode'] = (test? ? 'CONNECTOR_TEST' : 'LIVE')
@@ -219,6 +224,7 @@ module ActiveMerchant #:nodoc:
         20203 => "Reversed due to complaint by buyer",
         20204 => "Payment has been refunded",
         20300 => "Reversal has been canceled",
+        22000 => "Initiation of transaction successful",
 
         30000 => "Transaction still in progress",
         30100 => "Transaction has been accepted",
@@ -258,6 +264,8 @@ module ActiveMerchant #:nodoc:
         40420 => "Problem with address data",
         40500 => "Permission error with acquirer API",
         40510 => "Rate limit reached for acquirer API",
+        42000 => "Initiation of transaction failed",
+        42410 => "Initiation of transaction expired",
 
         50000 => "Problem with back end",
         50001 => "Country blacklisted",

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

@@ -269,7 +269,21 @@ module ActiveMerchant #:nodoc:
         commit 'ManagePendingTransactionStatus', build_manage_pending_transaction_status(transaction_id, action)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<n1:Password>).+(</n1:Password>)), '\1[FILTERED]\2').
+          gsub(%r((<n1:Username>).+(</n1:Username>)), '\1[FILTERED]\2').
+          gsub(%r((<n1:Signature>).+(</n1:Signature>)), '\1[FILTERED]\2').
+          gsub(%r((<n2:CreditCardNumber>).+(</n2:CreditCardNumber)), '\1[FILTERED]\2').
+          gsub(%r((<n2:CVV2>)\d+(</n2:CVV2)), '\1[FILTERED]\2')
+      end
+
       private
+
       def build_request_wrapper(action, options = {})
         xml = Builder::XmlMarkup.new :indent => 2
         xml.tag! action + 'Req', 'xmlns' => PAYPAL_NAMESPACE do

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

@@ -38,18 +38,6 @@ module ActiveMerchant #:nodoc:
         @express ||= PaypalExpressGateway.new(@options)
       end
 
-      def supports_scrubbing?
-        true
-      end
-
-      def scrub(transcript)
-        transcript.
-          gsub(%r((<n1:Password>).+(</n1:Password>)), '\1[FILTERED]\2').
-          gsub(%r((<n1:Username>).+(</n1:Username>)), '\1[FILTERED]\2').
-          gsub(%r((<n2:CreditCardNumber>).+(</n2:CreditCardNumber)), '\1[FILTERED]\2').
-          gsub(%r((<n2:CVV2>)\d+(</n2:CVV2)), '\1[FILTERED]\2')
-      end
-
       private
 
       def define_transaction_type(transaction_arg)

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

@@ -75,7 +75,6 @@ module ActiveMerchant #:nodoc:
         commit(post)
       end
 
-
       def refund(money, authorization, options={})
         post = new_request
         add_amount(post, money, options)
@@ -85,6 +84,20 @@ module ActiveMerchant #:nodoc:
         commit(post)
       end
 
+      def verify(credit_card, options={})
+        authorize(0, credit_card, options)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((pstn_cn=)\d*), '\1[FILTERED]').
+          gsub(%r((pstn_cc=)\d*), '\1[FILTERED]')
+      end
+
       private
 
         def new_request