activemerchant 1.60.0 → 1.61.0

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

@@ -57,7 +57,9 @@ module ActiveMerchant #:nodoc:
         "CHF" => '756',
         "CLP" => '152',
         "COP" => '170',
+        "CRC" => '188',
         "CZK" => '203',
+        "DOP" => '214',
         "EUR" => '978',
         "GBP" => '826',
         "GTQ" => '320',

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

@@ -90,8 +90,30 @@ module ActiveMerchant #:nodoc:
         vault.unstore(identification, options)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+         force_utf8(transcript).
+          gsub(%r((M_id=)[^&]*), '\1[FILTERED]').
+          gsub(%r((M_key=)[^&]*), '\1[FILTERED]').
+          gsub(%r((C_cardnumber=)[^&]*), '\1[FILTERED]').
+          gsub(%r((C_cvv=)[^&]*), '\1[FILTERED]').
+          gsub(%r((<ns1:CARDNUMBER>).+(</ns1:CARDNUMBER>)), '\1[FILTERED]\2').
+          gsub(%r((<ns1:M_ID>).+(</ns1:M_ID>)), '\1[FILTERED]\2').
+          gsub(%r((<ns1:M_KEY>).+(</ns1:M_KEY>)), '\1[FILTERED]\2')
+      end
+
       private
 
+      # use the same method as in pay_conex
+      def force_utf8(string)
+        return nil unless string
+        binary = string.encode("BINARY", invalid: :replace, undef: :replace, replace: "?")   # Needed for Ruby 2.0 since #encode is a no-op if the string is already UTF-8. It's not needed for Ruby 2.1 and up since it's not a no-op there.
+        binary.encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+      end
+
       def add_credit_card(post, credit_card)
         post[:C_name]       = credit_card.name
         post[:C_cardnumber] = credit_card.number

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

@@ -175,6 +175,17 @@ module ActiveMerchant #:nodoc:
       end
 
       private
+      def truncate(value, max_size)
+        return nil unless value
+        return value.to_s if CGI.escape(value.to_s).length <= max_size
+
+        if value.size > max_size
+          truncate(super(value, max_size), max_size)
+        else
+          truncate(value.to_s.chop, max_size)
+        end
+      end
+
       def add_reference(post, identification)
         order_id, transaction_id, authorization, security_key = identification.split(';')
 
@@ -281,6 +292,7 @@ module ActiveMerchant #:nodoc:
       def add_token_details(post, token, options)
         add_token(post, token)
         add_pair(post, :StoreToken, options[:customer])
+        add_pair(post, :CV2, options[:verification_value])
       end
 
       def add_token(post, token)

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

@@ -5,8 +5,8 @@ module ActiveMerchant #:nodoc:
       self.live_url = 'https://api.securionpay.com/'
 
 
-      self.supported_countries = %w(AL AD AT BY BE BG HR CY RE DK EE IS FI FR DE GI GR HU IS IE IT LV LI LT LU
-                                    MK MT MD MC NL NO PL PT RO RU MA RS SK SI ES SE CH UA KI CI RS RS ME)
+      self.supported_countries = %w(AL AD AT BY BE BG HR CY CZ RE DK EE IS FI FR DE GI GR HU IS IE IT IL LV LI LT LU
+                                    MK MT MD MC NL NO PL PT RO RU MA RS SK SI ES SE CH UA GB KI CI ME)
 
       self.default_currency = 'USD'
       self.money_format = :cents

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

@@ -21,7 +21,7 @@ module ActiveMerchant #:nodoc:
         'unchecked' => 'P'
       }
 
-      self.supported_countries = %w(AT AU BE CA CH DE DK ES FI FR GB IE IT LU NL NO SE SG US)
+      self.supported_countries = %w(AT AU BE BR CA CH DE DK ES FI FR GB HK IE IT JP LU MX NL NO NZ PT SE SG US)
       self.default_currency = 'USD'
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club, :maestro]
@@ -51,6 +51,22 @@ module ActiveMerchant #:nodoc:
         "business" => "company",
       }
 
+      MINIMUM_AUTHORIZE_AMOUNTS = {
+        "USD" => 100,
+        "CAD" => 100,
+        "GBP" => 60,
+        "EUR" => 100,
+        "DKK" => 500,
+        "NOK" => 600,
+        "SEK" => 600,
+        "CHF" => 100,
+        "AUD" => 100,
+        "JPY" => 100,
+        "MXN" => 2000,
+        "SGD" => 100,
+        "HKD" => 800
+      }
+
       def initialize(options = {})
         requires!(options, :login)
         @api_key = options[:login]
@@ -117,6 +133,7 @@ module ActiveMerchant #:nodoc:
 
       def void(identification, options = {})
         post = {}
+        post[:metadata] = options[:metadata] if options[:metadata]
         post[:expand] = [:charge]
         commit(:post, "charges/#{CGI.escape(identification)}/refunds", post, options)
       end
@@ -141,7 +158,7 @@ module ActiveMerchant #:nodoc:
 
       def verify(payment, options = {})
         MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(50, payment, options) }
+          r.process { authorize(auth_minimum_amount(options), payment, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
         end
       end
@@ -369,14 +386,13 @@ module ActiveMerchant #:nodoc:
             card[:cvc] = creditcard.verification_value if creditcard.verification_value?
             card[:name] = creditcard.name if creditcard.name
           end
-          post[:card] = card
 
-          if creditcard.is_a?(NetworkTokenizationCreditCard) && creditcard.source == :apple_pay
-            post[:three_d_secure] = {
-              apple_pay:  true,
-              cryptogram: creditcard.payment_cryptogram
-            }
+          if creditcard.is_a?(NetworkTokenizationCreditCard)
+            card[:cryptogram] = creditcard.payment_cryptogram
+            card[:eci] = creditcard.eci
+            card[:tokenization_method] = creditcard.source.to_s
           end
+          post[:card] = card
 
           add_address(post, options)
         elsif creditcard.kind_of?(String)
@@ -600,6 +616,11 @@ module ActiveMerchant #:nodoc:
           card_brand(payment_method) == "check"
         end
       end
+
+      def auth_minimum_amount(options)
+        return 100 unless options[:currency]
+        return MINIMUM_AUTHORIZE_AMOUNTS[options[:currency].upcase] || 100
+      end
     end
   end
 end

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

@@ -0,0 +1,275 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TelrGateway < Gateway
+      self.display_name = "Telr"
+      self.homepage_url = "http://www.telr.com/"
+
+      self.live_url = "https://secure.telr.com/gateway/remote.xml"
+
+      self.supported_countries = ["AE", "IN", "SA"]
+      self.default_currency = "AED"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :maestro, :solo, :jcb]
+
+      CVC_CODE_TRANSLATOR = {
+        'Y' => 'M',
+        'N' => 'N',
+        'X' => 'P',
+        'E' => 'U',
+      }
+
+      AVS_CODE_TRANSLATOR = {
+        'Y' => 'M',
+        'P' => 'A',
+        'N' => 'N',
+        'X' => 'I',
+        'E' => 'R'
+      }
+
+      def initialize(options={})
+        requires!(options, :merchant_id, :api_key)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        commit(:purchase, amount, options[:currency]) do |doc|
+          add_invoice(doc, "sale", amount, payment_method, options)
+          add_payment_method(doc, payment_method, options)
+          add_customer_data(doc, payment_method, options)
+        end
+      end
+
+      def authorize(amount, payment_method, options={})
+        commit(:authorize, amount, options[:currency]) do |doc|
+          add_invoice(doc, "auth", amount, payment_method, options)
+          add_payment_method(doc, payment_method, options)
+          add_customer_data(doc, payment_method, options)
+        end
+      end
+
+      def capture(amount, authorization, options={})
+        commit(:capture) do |doc|
+          add_invoice(doc, "capture", amount, authorization, options)
+        end
+      end
+
+      def void(authorization, options={})
+        _, amount, currency = split_authorization(authorization)
+        commit(:void) do |doc|
+          add_invoice(doc, "void", amount.to_i, authorization, options.merge(currency: currency))
+        end
+      end
+
+      def refund(amount, authorization, options={})
+        commit(:refund) do |doc|
+          add_invoice(doc, "refund", amount, authorization, options)
+        end
+      end
+
+      def verify(credit_card, options={})
+        commit(:verify) do |doc|
+          add_invoice(doc, "verify", 100, credit_card, options)
+          add_payment_method(doc, credit_card, options)
+          add_customer_data(doc, credit_card, options)
+        end
+      end
+
+      def verify_credentials
+        response = void("0")
+        !["01", "04"].include?(response.error_code)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+        gsub(%r((<Number>)[^<]+(<))i, '\1[FILTERED]\2').
+        gsub(%r((<CVV>)[^<]+(<))i, '\1[FILTERED]\2').
+        gsub(%r((<Key>)[^<]+(<))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_invoice(doc, action, money, payment_method, options)
+        doc.tran do
+          doc.type(action)
+          doc.amount(amount(money))
+          doc.currency(options[:currency] || currency(money))
+          doc.cartid(options[:order_id])
+          doc.class_(transaction_class(action, payment_method))
+          doc.description(options[:description] || "Description")
+          doc.test_(test_mode)
+          add_ref(doc, action, payment_method)
+        end
+      end
+
+      def add_payment_method(doc, payment_method, options)
+        return if payment_method.is_a?(String)
+        doc.card do
+          doc.number(payment_method.number)
+          doc.cvv(payment_method.verification_value)
+          doc.expiry do
+            doc.month(format(payment_method.month, :two_digits))
+            doc.year(format(payment_method.year, :four_digits))
+          end
+        end
+      end
+
+      def add_customer_data(doc, payment_method, options)
+        return if payment_method.is_a?(String)
+        doc.billing do
+          doc.name do
+            doc.first(payment_method.first_name)
+            doc.last(payment_method.last_name)
+          end
+          doc.email(options[:email] || "unspecified@email.com")
+          doc.ip(options[:ip]) if options[:ip]
+          doc.address do
+            add_address(doc, options)
+          end
+        end
+      end
+
+      def add_address(doc, options)
+        address = options[:billing_address] || {}
+        doc.country(address[:country] ? lookup_country_code(address[:country]) : "NA")
+        doc.city(address[:city] || "City")
+        doc.line1(address[:address1] || "Address")
+        return unless address
+        doc.line2(address[:address2]) if address[:address2]
+        doc.zip(address[:zip]) if address[:zip]
+        doc.region(address[:state]) if address[:state]
+      end
+
+      def add_ref(doc, action, payment_method)
+        if ["capture", "refund", "void"].include?(action) || payment_method.is_a?(String)
+          doc.ref(split_authorization(payment_method)[0])
+        end
+      end
+
+      def add_authentication(doc)
+        doc.store(@options[:merchant_id])
+        doc.key(@options[:api_key])
+      end
+
+      def lookup_country_code(code)
+        country = Country.find(code) rescue nil
+        country.code(:alpha2)
+      end
+
+      def commit(action, amount=nil, currency=nil)
+        currency = default_currency if currency == nil
+        request = build_xml_request { |doc| yield(doc) }
+        response = ssl_post(live_url, request, headers)
+        parsed = parse(response)
+
+        succeeded = success_from(parsed)
+        Response.new(
+          succeeded,
+          message_from(succeeded, parsed),
+          parsed,
+          authorization: authorization_from(action, parsed, amount, currency),
+          avs_result: avs_result(parsed),
+          cvv_result: cvv_result(parsed),
+          error_code: error_code_from(succeeded, parsed),
+          test: test?
+        )
+      end
+
+      def root_attributes
+        {
+          store: @options[:merchant_id],
+          key: @options[:api_key]
+        }
+      end
+
+      def build_xml_request
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml.remote do |doc|
+
+            add_authentication(doc)
+            yield(doc)
+          end
+        end
+
+        builder.doc.to_xml
+      end
+
+      def test_mode
+        test? ? '1' : '0'
+      end
+
+      def transaction_class(action, payment_method)
+        if payment_method.is_a?(String) && action == "sale"
+          return "cont"
+        else
+          return "moto"
+        end
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.root.xpath("*").each do |node|
+          if (node.elements.size == 0)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              name = "#{childnode.name.downcase}"
+              response[name.to_sym] = childnode.text
+            end
+          end
+        end unless doc.root.nil?
+
+        response
+      end
+
+      def authorization_from(action, response, amount, currency)
+        auth = response[:tranref]
+        auth = [auth, amount, currency].join('|')
+        auth
+      end
+
+      def split_authorization(authorization)
+        authorization.split('|')
+      end
+
+      def success_from(response)
+        response[:status] == "A"
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response[:message]
+        end
+      end
+
+      def error_code_from(succeeded, response)
+        unless succeeded
+          response[:code]
+        end
+      end
+
+      def cvv_result(parsed)
+        CVVResult.new(CVC_CODE_TRANSLATOR[parsed[:cvv]])
+      end
+
+      def avs_result(parsed)
+        AVSResult.new(code: AVS_CODE_TRANSLATOR[parsed[:avs]])
+      end
+
+      def headers
+        {
+          "Content-Type" => "text/xml"
+        }
+      end
+    end
+  end
+end

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

@@ -1,241 +1,23 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant
+  module Billing
     class TnsGateway < Gateway
-      class_attribute :live_na_url, :live_ap_url
+      include MastercardGateway
 
-      self.display_name = 'TNS'
-      self.homepage_url = 'http://www.tnsi.com/'
+      class_attribute :live_na_url, :live_ap_url, :test_na_url, :test_ap_url
 
-      # Testing is partitioned by account.
-      self.live_na_url = 'https://secure.na.tnspayments.com/api/rest/version/22/'
-      self.live_ap_url = 'https://secure.ap.tnspayments.com/api/rest/version/22/'
+      self.live_na_url = 'https://secure.na.tnspayments.com/api/rest/version/36/'
+      self.test_na_url = 'https://secure.na.tnspayments.com/api/rest/version/36/'
 
-      self.supported_countries = %w(AR AU BR FR DE HK MX NZ SG GB US)
+      self.live_ap_url = 'https://secure.ap.tnspayments.com/api/rest/version/36/'
+      self.test_ap_url = 'https://secure.ap.tnspayments.com/api/rest/version/36/'
 
+      self.display_name = 'TNS'
+      self.homepage_url = 'http://www.tnsi.com/'
+      self.supported_countries = %w(AR AU BR FR DE HK MX NZ SG GB US)
       self.default_currency = 'USD'
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :maestro, :laser]
+      self.ssl_version = :TLSv1
 
-      self.ssl_version = :TLSv1_2
-
-      def initialize(options={})
-        requires!(options, :userid, :password)
-
-        options[:region] = 'north_america' unless options[:region]
-
-        super
-      end
-
-      def purchase(amount, payment_method, options={})
-        MultiResponse.run do |r|
-          r.process { authorize(amount, payment_method, options) }
-          r.process { capture(amount, r.authorization, options) }
-        end
-      end
-
-      def authorize(amount, payment_method, options={})
-        post = new_post
-        add_invoice(post, amount, options)
-        add_reference(post, *new_authorization)
-        add_payment_method(post, payment_method)
-        add_customer_data(post, options)
-
-        commit('authorize', post)
-      end
-
-      def capture(amount, authorization, options={})
-        post = new_post
-        add_invoice(post, amount, options, :transaction)
-        add_reference(post, *next_authorization(authorization))
-        add_customer_data(post, options)
-
-        commit('capture', post)
-      end
-
-      def refund(amount, authorization, options={})
-        post = new_post
-        add_invoice(post, amount, options, :transaction)
-        add_reference(post, *next_authorization(authorization))
-        add_customer_data(post, options)
-
-        commit('refund', post)
-      end
-
-      def void(authorization, options={})
-        post = new_post
-        add_reference(post, *next_authorization(authorization), :targetTransactionId)
-
-        commit('void', post)
-      end
-
-      def verify(credit_card, options={})
-        MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(100, credit_card, options) }
-          r.process(:ignore_result) { void(r.authorization, options) }
-        end
-      end
-
-      private
-
-      def new_post
-        {
-          order: {},
-          sourceOfFunds: {
-            provided: {
-              card: {
-              }
-            }
-          },
-          customer: {},
-          billing: {},
-          shipping: {},
-          transaction: {},
-        }
-      end
-
-      def add_invoice(post, amount, options, node=:order)
-        post[node][:amount] = amount(amount)
-        post[node][:currency] = (options[:currency] || currency(amount))
-      end
-
-      def add_reference(post, orderid, transactionid, transaction_reference, reference_key=:reference)
-        post[:orderid] = orderid
-        post[:transactionid] = transactionid
-        post[:transaction][reference_key] = transaction_reference if transaction_reference
-      end
-
-      def add_payment_method(post, payment_method)
-        card = {}
-        card[:expiry] = {}
-        card[:number] = payment_method.number
-        card[:securityCode] = payment_method.verification_value
-        card[:expiry][:year] = format(payment_method.year, :two_digits)
-        card[:expiry][:month] = format(payment_method.month, :two_digits)
-
-        post[:sourceOfFunds][:type] = 'CARD'
-        post[:sourceOfFunds][:provided][:card].merge!(card)
-      end
-
-      def add_customer_data(post, options)
-        billing = {}
-        shipping = {}
-        customer = {}
-        if(billing_address = (options[:billing_address] || options[:address]))
-          billing[:address] = {}
-          billing[:address][:street]        = billing_address[:address1]
-          billing[:address][:street2]       = billing_address[:address2]
-          billing[:address][:city]          = billing_address[:city]
-          billing[:address][:stateProvince] = billing_address[:state]
-          billing[:address][:postcodeZip]   = billing_address[:zip]
-          billing[:address][:country]       = country_code(billing_address[:country])
-          billing[:phone]                   = billing_address[:phone]
-
-          customer[:email]                  = options[:email] if options[:email]
-          customer[:ipAddress]              = options[:ip] if options[:ip]
-        end
-
-        if(shipping_address = options[:shipping_address])
-          shipping[:address] = {}
-          shipping[:address][:street]        = shipping_address[:address1]
-          shipping[:address][:street2]       = shipping_address[:address2]
-          shipping[:address][:city]          = shipping_address[:city]
-          shipping[:address][:stateProvince] = shipping_address[:state]
-          shipping[:address][:postcodeZip]   = shipping_address[:zip]
-          shipping[:address][:shipcountry]   = country_code(shipping_address[:country])
-
-          first_name, last_name = split_names(shipping_address[:name])
-          shipping[:firstName]  = first_name if first_name
-          shipping[:lastName]   = last_name if last_name
-        end
-        post[:billing].merge!(billing)
-        post[:shipping].merge!(shipping)
-        post[:customer].merge!(customer)
-      end
-
-      def country_code(country)
-        if country
-          country = ActiveMerchant::Country.find(country)
-          country.code(:alpha3).value
-        end
-      rescue InvalidCountryCodeError
-      end
-
-      def commit(action, post)
-        url = build_url(post.delete(:orderid), post.delete(:transactionid))
-        headers = {
-          'Authorization' => 'Basic ' + Base64.encode64("merchant.#{@options[:userid]}:#{@options[:password]}").strip.delete("\r\n"),
-          'Content-Type' => 'application/json',
-        }
-        post[:apiOperation] = action.upcase
-        begin
-          raw = parse(ssl_request(:put, url, build_request(post), headers))
-        rescue ResponseError => e
-          raw = parse(e.response.body)
-        end
-        succeeded = success_from(raw['result'])
-        Response.new(
-          succeeded,
-          message_from(succeeded, raw),
-          raw,
-          :authorization => authorization_from(post, raw),
-          :test => test?
-        )
-      end
-
-      def build_url(orderid, transactionid)
-        base_url = @options[:region] == 'asia_pacific' ? live_ap_url : live_na_url
-        "#{base_url}merchant/#{@options[:userid]}/order/#{orderid}/transaction/#{transactionid}"
-      end
-
-      def build_request(post = {})
-        post.to_json
-      end
-
-      def parse(body)
-        JSON.parse(body)
-      end
-
-      def success_from(response)
-        response == 'SUCCESS'
-      end
-
-      def message_from(succeeded, response)
-        if succeeded
-          'Succeeded'
-        else
-          [
-            response['result'],
-            response['response'] && response['response']['gatewayCode'],
-            response['error'] && response['error']['cause'],
-            response['error'] && response['error']['explanation']
-          ].compact.join(' - ')
-        end
-      end
-
-      def authorization_from(request, response)
-        [response['order']['id'], response['transaction']['id']].join('|') if response['order']
-      end
-
-      def split_authorization(authorization)
-        authorization.split('|')
-      end
-
-      def new_authorization
-        # Must be unique within a merchant id.
-        orderid = SecureRandom.uuid
-
-        # Must be unique within an order id.
-        transactionid = '1'
-
-        # New transactions have no previous reference.
-        transaction_reference = nil
-        [orderid, transactionid, transaction_reference]
-      end
-
-      def next_authorization(authorization)
-        orderid, prev_transactionid = split_authorization(authorization)
-        next_transactionid = SecureRandom.uuid
-        [orderid, next_transactionid, prev_transactionid]
-      end
     end
   end
 end