activemerchant 1.63.0 → 1.64.0

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

@@ -46,7 +46,7 @@ module ActiveMerchant #:nodoc:
 
       def refund(money, authorization, options={})
         post = nestable_hash
-        add_amount(post, money, options={})
+        add_amount(post, money, options)
         add_refund_customer_data(post, options)
         commit(:refund, post, authorization)
       end
@@ -99,7 +99,7 @@ module ActiveMerchant #:nodoc:
         }
       end
 
-      def add_amount(post, money, options)
+      def add_amount(post, money, options={})
         post["amountOfMoney"] = {
           "amount" => amount(money),
           "currencyCode" => options[:currency] || currency(money)

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

@@ -0,0 +1,217 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class KushkiGateway < Gateway
+      self.display_name = "Kushki"
+      self.homepage_url = "https://www.kushkipagos.com"
+
+      self.test_url = "https://api-uat.kushkipagos.com/v1/"
+      self.live_url = "https://api.kushkipagos.com/v1/"
+
+      self.supported_countries = ["CO", "EC"]
+      self.default_currency = "USD"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club]
+
+      def initialize(options={})
+        requires!(options, :public_merchant_id, :private_merchant_id)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        MultiResponse.run() do |r|
+          r.process { tokenize(amount, payment_method, options) }
+          r.process { charge(amount, r.authorization, options) }
+        end
+      end
+
+      def void(authorization, options={})
+        action = "void"
+
+        post = {}
+        post[:ticketNumber] = authorization
+
+        commit(action, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Private-Merchant-Id: )\d+), '\1[FILTERED]').
+          gsub(%r((\"card\\\":{\\\"number\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"cvv\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def tokenize(amount, payment_method, options)
+        action = "tokenize"
+
+        post = {}
+        add_invoice(action, post, amount, options)
+        add_payment_method(post, payment_method, options)
+
+        commit(action, post)
+      end
+
+      def charge(amount, authorization, options)
+        action = "charge"
+
+        post = {}
+        add_reference(post, authorization, options)
+        add_invoice(action, post, amount, options)
+
+        commit(action, post)
+      end
+
+      def add_invoice(action, post, money, options)
+        if action == "tokenize"
+          post[:totalAmount] = amount(money).to_f
+          post[:currency] = options[:currency] || currency(money)
+          post[:isDeferred] = false
+        else
+          sum = {}
+          sum[:currency] = options[:currency] || currency(money)
+          add_amount_defaults(sum, money, options)
+          add_amount_by_country(sum, options)
+          post[:amount] = sum
+        end
+      end
+
+      def add_amount_defaults(sum, money, options)
+        sum[:subtotalIva] = amount(money).to_f
+        sum[:iva] = 0
+        sum[:subtotalIva0] = 0
+
+        if sum[:currency] == "COP"
+          extra_taxes = {}
+          extra_taxes[:propina] = 0
+          extra_taxes[:tasaAeroportuaria] = 0
+          extra_taxes[:agenciaDeViaje] = 0
+          extra_taxes[:iac] = 0
+          sum[:extraTaxes] = extra_taxes
+        else
+          sum[:ice] = 0
+        end
+      end
+
+      def add_amount_by_country(sum, options)
+        if amount = options[:amount]
+          sum[:subtotalIva] = amount[:subtotal_iva].to_f if amount[:subtotal_iva]
+          sum[:iva] = amount[:iva].to_f if amount[:iva]
+          sum[:subtotalIva0] = amount[:subtotal_iva_0].to_f if amount[:subtotal_iva_0]
+          sum[:ice] = amount[:ice].to_f if amount[:ice]
+          if extra_taxes = amount[:extra_taxes] && sum[:currency] == "COP"
+            sum[:extraTaxes][:propina] = extra_taxes[:propina].to_f if extra_taxes[:propina]
+            sum[:extraTaxes][:tasaAeroportuaria] = extra_taxes[:tasa_aeroportuaria].to_f if extra_taxes[:tasa_aeroportuaria]
+            sum[:extraTaxes][:agenciaDeViaje] = extra_taxes[:agencia_de_viaje].to_f if extra_taxes[:agencia_de_viaje]
+            sum[:extraTaxes][:iac] = extra_taxes[:iac].to_f if extra_taxes[:iac]
+          end
+        end
+      end
+
+      def add_payment_method(post, payment_method, options)
+        card = {}
+        card[:number] = payment_method.number
+        card[:cvv] = payment_method.verification_value
+        card[:expiryMonth] = format(payment_method.month, :two_digits)
+        card[:expiryYear] = format(payment_method.year, :two_digits)
+        card[:name] = payment_method.name
+        post[:card] = card
+      end
+
+      def add_reference(post, authorization, options)
+        post[:token] = authorization
+      end
+
+      ENDPOINT = {
+        "tokenize" => "tokens",
+        "charge" => "charges",
+        "void" => "charges"
+      }
+
+      def commit(action, params)
+        response = begin
+          parse(ssl_invoke(action, params))
+        rescue ResponseError => e
+          parse(e.response.body)
+        end
+
+        success = success_from(response)
+
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          authorization: success ? authorization_from(response) : nil,
+          error_code: success ? nil : error_from(response),
+          test: test?
+        )
+      end
+
+      def ssl_invoke(action, params)
+        if action == "void"
+          ssl_request(:delete, url(action, params), nil, headers(action))
+        else
+          ssl_post(url(action, params), post_data(params), headers(action))
+        end
+      end
+
+      def headers(action)
+        hfields = {}
+        hfields["Public-Merchant-Id"] = @options[:public_merchant_id] if action == "tokenize"
+        hfields["Private-Merchant-Id"] = @options[:private_merchant_id] unless action == "tokenize"
+        hfields["Content-Type"] = "application/json"
+        hfields
+      end
+
+      def post_data(params)
+        params.to_json
+      end
+
+      def url(action, params)
+        base_url = test? ? test_url : live_url
+
+        if action == "void"
+          base_url + ENDPOINT[action] + "/" + params[:ticketNumber]
+        else
+          base_url + ENDPOINT[action]
+        end
+      end
+
+      def parse(body)
+        begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          message = "Invalid JSON response received from KushkiGateway. Please contact KushkiGateway if you continue to receive this message."
+          message += " (The raw response returned by the API was #{body.inspect})"
+          {
+            "message" => message
+          }
+        end
+      end
+
+      def success_from(response)
+        return true if response["token"] || response["ticketNumber"]
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response["message"]
+        end
+      end
+
+      def authorization_from(response)
+        response["token"] || response["ticketNumber"]
+      end
+
+      def error_from(response)
+        response["code"]
+      end
+    end
+  end
+end

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

@@ -143,9 +143,9 @@ module ActiveMerchant #:nodoc:
           :pem => LinkpointGateway.pem_file
         }.update(options)
 
-        @options[:pem].strip!
-
         raise ArgumentError, "You need to pass in your pem file using the :pem parameter or set it globally using ActiveMerchant::Billing::LinkpointGateway.pem_file = File.read( File.dirname(__FILE__) + '/../mycert.pem' ) or similar" if @options[:pem].blank?
+
+        @options[:pem].strip!
       end
 
       # Send a purchase request with periodic options

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

@@ -14,18 +14,20 @@ module ActiveMerchant #:nodoc:
       self.live_url = self.test_url = API_URL
 
       # Currency supported by Omise
-      # * Thai Baht with Satang, i.e. 9000 => 90 THB
+      # * Thai Baht with Satang, 50000 (THB500.00)
+      # * Japanese Yen, 500 (JPY500)
       self.default_currency = 'THB'
       self.money_format     = :cents
 
       #Country supported by Omise
       # * Thailand
-      self.supported_countries = %w( TH )
+      self.supported_countries = %w( TH JP )
 
       # Credit cards supported by Omise
       # * VISA
       # * MasterCard
-      self.supported_cardtypes = [:visa, :master]
+      # * JCB
+      self.supported_cardtypes = [:visa, :master, :jcb]
 
       # Omise main page
       self.homepage_url = 'https://www.omise.co/'
@@ -39,8 +41,10 @@ module ActiveMerchant #:nodoc:
       #
       # ==== Options
       #
-      # * <tt>:public_key</tt> -- Omise's public key (REQUIRED).
-      # * <tt>:secret_key</tt> -- Omise's secret key (REQUIRED).
+      # * <tt>:public_key</tt>  -- Omise's public key  (REQUIRED).
+      # * <tt>:secret_key</tt>  -- Omise's secret key  (REQUIRED).
+      # * <tt>:api_version</tt> -- Omise's API Version (OPTIONAL), default version is '2014-07-27'
+      #                            See version at page https://dashboard.omise.co/api-version/edit
 
       def initialize(options={})
         requires!(options, :public_key, :secret_key)

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/payu_latam.rb

@@ -65,7 +65,7 @@ module ActiveMerchant #:nodoc:
         commit('void', post)
       end
 
-      def refund(authorization, options={})
+      def refund(amount, authorization, options={})
         post = {}
 
         add_credentials(post, 'SUBMIT_TRANSACTION')
@@ -321,6 +321,8 @@ module ActiveMerchant #:nodoc:
           response["code"] == "SUCCESS" && response["creditCardToken"] && response["creditCardToken"]["creditCardTokenId"].present?
         when 'verify_credentials'
           response["code"] == "SUCCESS"
+        when 'refund'
+        response["code"] == "SUCCESS" && response["transactionResponse"] && (response["transactionResponse"]["state"] == "PENDING" || response["transactionResponse"]["state"] == "APPROVED")
         else
           response["code"] == "SUCCESS" && response["transactionResponse"] && (response["transactionResponse"]["state"] == "APPROVED")
         end

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

@@ -1,6 +1,8 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class SageGateway < Gateway
+      include Empty
+
       self.display_name = 'http://www.sagepayments.com'
       self.homepage_url = 'Sage Payment Solutions'
       self.live_url = 'https://www.sagepayments.net/cgi-bin'
@@ -204,8 +206,8 @@ module ActiveMerchant #:nodoc:
 
       def add_invoice(post, options)
         post[:T_ordernum] = (options[:order_id] || generate_unique_id).slice(0, 20)
-        post[:T_tax] = amount(options[:tax]) unless options[:tax].blank?
-        post[:T_shipping] = amount(options[:shipping]) unless options[:shipping].blank?
+        post[:T_tax] = amount(options[:tax]) unless empty?(options[:tax])
+        post[:T_shipping] = amount(options[:shipping]) unless empty?(options[:shipping])
       end
 
       def add_reference(post, reference)
@@ -226,7 +228,7 @@ module ActiveMerchant #:nodoc:
 
         post[:C_address]    = billing_address[:address1]
         post[:C_city]       = billing_address[:city]
-        post[:C_state]      = billing_address[:state]
+        post[:C_state]      = empty?(billing_address[:state]) ? "Outside of US" : billing_address[:state]
         post[:C_zip]        = billing_address[:zip]
         post[:C_country]    = billing_address[:country]
         post[:C_telephone]  = billing_address[:phone]

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

@@ -71,7 +71,6 @@ module ActiveMerchant #:nodoc:
         requires!(options, :login)
         @api_key = options[:login]
         @fee_refund_api_key = options[:fee_refund_login]
-
         super
       end
 
@@ -159,6 +158,7 @@ module ActiveMerchant #:nodoc:
       def verify(payment, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(auth_minimum_amount(options), payment, options) }
+          options[:idempotency_key] = nil
           r.process(:ignore_result) { void(r.authorization, options) }
         end
       end

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

@@ -248,7 +248,6 @@ module ActiveMerchant #:nodoc:
         request = build_xml_transaction_request do |doc|
           add_amount(doc, amount)
           add_original_transaction_data(doc, transaction_id)
-          add_order_number(doc, options)
         end
 
         commit(:refund, request)
@@ -338,8 +337,8 @@ module ActiveMerchant #:nodoc:
           response,
           error_code: error_code_from(succeeded, response),
           authorization: authorization_from(action, response),
-          avs_result: AVSResult.new(code: response["AVSCode"]),
-          cvv_result: CVVResult.new(response["CVV2Response"]),
+          avs_result: AVSResult.new(code: response["avsRslt"]),
+          cvv_result: CVVResult.new(response["secRslt"]),
           test: test?
         )
       end