activemerchant 1.56.0 → 1.66.0

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,232 +1,23 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant
+  module Billing
     class TnsGateway < Gateway
-      self.display_name = 'TNS'
-      self.homepage_url = 'http://www.tnsi.com/'
+      include MastercardGateway
 
-      # Testing is partitioned by account.
-      self.live_url = 'https://secure.na.tnspayments.com/api/rest/version/22/'
+      class_attribute :live_na_url, :live_ap_url, :test_na_url, :test_ap_url
 
-      self.supported_countries = %w(AR AU BR FR DE HK MX NZ SG GB US)
+      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.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
 
-      def initialize(options={})
-        requires!(options, :userid, :password)
-        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)
-        "#{live_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

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

@@ -9,7 +9,7 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'http://www.transfirst.com/'
       self.display_name = 'TransFirst'
 
-      UNUSED_FIELDS = %w(ECIValue UserId CAVVData TrackData POSInd EComInd MerchZIP MerchCustPNum MCC InstallmentNum InstallmentOf POSEntryMode POSConditionCode AuthCharInd CardCertData)
+      UNUSED_CREDIT_CARD_FIELDS = %w(UserId TrackData MerchZIP MerchCustPNum MCC InstallmentNum InstallmentOf POSInd POSEntryMode POSConditionCode EComInd AuthCharInd CardCertData CAVVData)
 
       DECLINED = 'The transaction was declined'
 
@@ -38,30 +38,46 @@ module ActiveMerchant #:nodoc:
         post = {}
 
         add_amount(post, money)
-        add_invoice(post, options)
         add_payment(post, payment)
         add_address(post, options)
+        add_invoice(post, options) if payment.credit_card?
+        add_pair(post, :RefID, options[:order_id], required: true)
 
         commit((payment.is_a?(Check) ? :purchase_echeck : :purchase), post)
       end
 
       def refund(money, authorization, options={})
         post = {}
+
         transaction_id, payment_type = split_authorization(authorization)
         add_amount(post, money)
-        add_invoice(post, options)
         add_pair(post, :TransID, transaction_id)
+
         commit((payment_type == "check" ? :refund_echeck : :refund), post)
       end
 
       def void(authorization, options={})
         post = {}
+
         transaction_id, _ = split_authorization(authorization)
         add_pair(post, :TransID, transaction_id)
 
         commit(:void, post)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((&?RegKey=)\w*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?CardNumber=)\d*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?CVV2=)\d*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?TransRoute=)\d*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?BankAccountNo=)\d*(&?)), '\1[FILTERED]\2')
+      end
+
       private
 
       def add_amount(post, money)
@@ -72,18 +88,20 @@ module ActiveMerchant #:nodoc:
         address = options[:billing_address] || options[:address]
 
         if address
-          add_pair(post, :Address, address[:address1])
-          add_pair(post, :ZipCode, address[:zip])
+          add_pair(post, :Address, address[:address1], required: true)
+          add_pair(post, :ZipCode, address[:zip], required: true)
+        else
+          add_pair(post, :Address, "", required: true)
+          add_pair(post, :ZipCode, "", required: true)
         end
       end
 
       def add_invoice(post, options)
-        add_pair(post, :RefID, options[:order_id], required: true)
         add_pair(post, :SECCCode, options[:invoice], required: true)
         add_pair(post, :PONumber, options[:invoice], required: true)
         add_pair(post, :SaleTaxAmount, amount(options[:tax] || 0))
-        add_pair(post, :PaymentDesc, options[:description], required: true)
         add_pair(post, :TaxIndicator, 0)
+        add_pair(post, :PaymentDesc, options[:description] || "", required: true)
         add_pair(post, :CompanyName, options[:company_name] || "", required: true)
       end
 
@@ -99,21 +117,28 @@ module ActiveMerchant #:nodoc:
         add_pair(post, :CardHolderName, payment.name, required: true)
         add_pair(post, :CardNumber, payment.number, required: true)
         add_pair(post, :Expiration, expdate(payment), required: true)
-        add_pair(post, :CVV2, payment.verification_value)
+        add_pair(post, :CVV2, payment.verification_value, required: true)
       end
 
       def add_echeck(post, payment)
         add_pair(post, :TransRoute, payment.routing_number, required: true)
         add_pair(post, :BankAccountNo, payment.account_number, required: true)
-        add_pair(post, :BankAccountType, payment.account_type.capitalize, required: true)
-        add_pair(post, :CheckType, payment.account_holder_type.capitalize, required: true)
+        add_pair(post, :BankAccountType, add_or_use_default(payment.account_type, "Checking"), required: true)
+        add_pair(post, :CheckType, add_or_use_default(payment.account_holder_type, "Personal"), required: true)
         add_pair(post, :Name, payment.name, required: true)
         add_pair(post, :ProcessDate, Time.now.strftime("%m%d%y"), required: true)
         add_pair(post, :Description, "", required: true)
       end
 
-      def add_unused_fields(post)
-        UNUSED_FIELDS.each do |f|
+      def add_or_use_default(payment_data, default_value)
+        return payment_data.capitalize if payment_data
+        return default_value
+      end
+
+      def add_unused_fields(action, post)
+        return unless action == :purchase
+
+        UNUSED_CREDIT_CARD_FIELDS.each do |f|
           post[f] = ""
         end
       end
@@ -143,7 +168,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, params)
-        response = parse(ssl_post(url(action), post_data(params)))
+        response = parse(ssl_post(url(action), post_data(action, params)))
 
         Response.new(
           success_from(response),
@@ -188,8 +213,8 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def post_data(params = {})
-        add_unused_fields(params)
+      def post_data(action, params = {})
+        add_unused_fields(action, params)
         params[:MerchantID] = @options[:login]
         params[:RegKey] = @options[:password]
 
@@ -212,4 +237,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-