activemerchant 1.42.6 → 1.90.0

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

@@ -6,10 +6,7 @@ module ActiveMerchant #:nodoc:
       TRANSACTION_APPROVED_MSG = 'Transaction approved'
       TRANSACTION_DECLINED_MSG = 'Transaction declined'
 
-      LIVE_URLS = {
-        'NZ' => 'https://api.swipehq.com',
-        'CA' => 'https://api.swipehq.ca'
-      }
+      self.live_url = 'https://api.swipehq.com'
       self.test_url = 'https://api.swipehq.com'
 
       TRANSACTION_API = '/createShopifyTransaction.php'
@@ -57,8 +54,7 @@ module ActiveMerchant #:nodoc:
 
         post[:company] = address[:company]
 
-        # groups all names after the first into the last name param
-        post[:first_name], post[:last_name] = address[:name].split(' ', 2)
+        post[:first_name], post[:last_name] = split_names(address[:name])
         post[:address] = "#{address[:address1]}, #{address[:address2]}"
         post[:city] = address[:city]
         post[:country] = address[:country]
@@ -70,7 +66,7 @@ module ActiveMerchant #:nodoc:
         post[:td_user_data] = options[:order_id] if options[:order_id]
         post[:td_item] = options[:description] if options[:description]
         post[:td_description] = options[:description] if options[:description]
-        post[:item_quantity] = "1"
+        post[:item_quantity] = '1'
       end
 
       def add_creditcard(post, creditcard)
@@ -96,16 +92,16 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, money, parameters)
         case action
-        when "sale"
+        when 'sale'
           begin
             response = call_api(TRANSACTION_API, parameters)
 
             # response code and message params should always be present
-            code = response["response_code"]
-            message = response["message"]
+            code = response['response_code']
+            message = response['message']
 
             if code == 200
-              result = response["data"]["result"]
+              result = response['data']['result']
               success = (result == 'accepted' || (test? && result == 'test-accepted'))
 
               Response.new(success,
@@ -119,11 +115,10 @@ module ActiveMerchant #:nodoc:
               build_error_response(message, response)
             end
           rescue ResponseError => e
-            raw_response = e.response.body
             build_error_response("ssl_post() with url #{url} raised ResponseError: #{e}")
           rescue JSON::ParserError => e
-            msg = 'Invalid response received from the Swipe Checkout API. ' +
-                  'Please contact support@optimizerhq.com if you continue to receive this message.' +
+            msg = 'Invalid response received from the Swipe Checkout API. ' \
+                  'Please contact support@optimizerhq.com if you continue to receive this message.' \
                   " (Full error message: #{e})"
             build_error_response(msg)
           end
@@ -137,11 +132,11 @@ module ActiveMerchant #:nodoc:
 
         # ssl_post() returns the response body as a string on success,
         # or raises a ResponseError exception on failure
-        JSON.parse(ssl_post(url(@options[:region], api), params.to_query))
+        JSON.parse(ssl_post(url(api), params.to_query))
       end
 
-      def url(region, api)
-        ((test? ? self.test_url : LIVE_URLS[region]) + api)
+      def url(api)
+        (test? ? self.test_url : self.live_url) + api
       end
 
       def build_error_response(message, params={})
@@ -155,4 +150,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-

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

@@ -0,0 +1,274 @@
+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, :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
+
+        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

@@ -0,0 +1,22 @@
+module ActiveMerchant
+  module Billing
+    class TnsGateway < Gateway
+      include MastercardGateway
+
+      class_attribute :live_na_url, :live_ap_url, :test_na_url, :test_ap_url
+
+      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]
+
+    end
+  end
+end

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

@@ -1,66 +1,146 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class TransFirstGateway < Gateway
-      self.live_url = self.test_url = 'https://webservices.primerchants.com/creditcard.asmx/CCSale'
+      self.test_url = 'https://ws.cert.transfirst.com'
+      self.live_url = 'https://webservices.primerchants.com'
 
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       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'
 
+      ACTIONS = {
+        purchase: 'CCSale',
+        purchase_echeck: 'ACHDebit',
+        refund: 'CreditCardCredit',
+        refund_echeck: 'ACHVoidTransaction',
+        void: 'CreditCardAutoRefundorVoid',
+      }
+
+      ENDPOINTS = {
+        purchase: 'creditcard.asmx',
+        purchase_echeck: 'checkverifyws/checkverifyws.asmx',
+        refund: 'creditcard.asmx',
+        refund_echeck: 'checkverifyws/checkverifyws.asmx',
+        void: 'creditcard.asmx'
+      }
+
       def initialize(options = {})
         requires!(options, :login, :password)
         super
       end
 
-      def purchase(money, credit_card, options = {})
+      def purchase(money, payment, options = {})
         post = {}
 
         add_amount(post, money)
-        add_invoice(post, options)
-        add_credit_card(post, credit_card)
+        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_pair(post, :TransID, transaction_id)
+        add_pair(post, :RefID, options[:order_id], required: true)
+
+        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
 
-        commit(post)
+      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)
-        add_pair(post, :Amount, amount(money), :required => true)
+        add_pair(post, :Amount, amount(money), required: true)
       end
 
       def add_address(post, options)
         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, :PONumber, options[:invoice], :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
+
+      def add_payment(post, payment)
+        if payment.is_a?(Check)
+          add_echeck(post, payment)
+        else
+          add_credit_card(post, payment)
+        end
       end
 
-      def add_credit_card(post, credit_card)
-        add_pair(post, :CardHolderName, credit_card.name, :required => true)
-        add_pair(post, :CardNumber, credit_card.number, :required => true)
+      def add_credit_card(post, payment)
+        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, 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, 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
 
-        add_pair(post, :Expiration, expdate(credit_card), :required => true)
-        add_pair(post, :CVV2, credit_card.verification_value)
+      def add_or_use_default(payment_data, default_value)
+        return payment_data.capitalize if payment_data
+        return default_value
       end
 
-      def add_unused_fields(post)
-        UNUSED_FIELDS.each do |f|
-          post[f] = ""
+      def add_unused_fields(action, post)
+        return unless action == :purchase
+
+        UNUSED_CREDIT_CARD_FIELDS.each do |f|
+          post[f] = ''
         end
       end
 
@@ -75,7 +155,7 @@ module ActiveMerchant #:nodoc:
         response = {}
 
         xml = REXML::Document.new(data)
-        root = REXML::XPath.first(xml, "//CCSaleDebitResponse")
+        root = REXML::XPath.first(xml, '*')
 
         if root.nil?
           response[:message] = data.to_s.strip
@@ -88,17 +168,42 @@ module ActiveMerchant #:nodoc:
         response
       end
 
-      def commit(params)
-        response = parse( ssl_post(self.live_url, post_data(params)) )
-
-        Response.new(response[:status] == "Authorized", message_from(response), response,
+      def commit(action, params)
+        response = parse(ssl_post(url(action), post_data(action, params)))
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
           :test => test?,
-          :authorization => response[:trans_id],
+          :authorization => authorization_from(response),
           :avs_result => { :code => response[:avs_code] },
           :cvv_result => response[:cvv2_code]
         )
       end
 
+      def authorization_from(response)
+        if response[:status] == 'APPROVED'
+          "#{response[:trans_id]}|check"
+        else
+          "#{response[:trans_id]}|creditcard"
+        end
+      end
+
+      def success_from(response)
+        case response[:status]
+        when 'Authorized'
+          true
+        when 'Voided'
+          true
+        when 'APPROVED'
+          true
+        when 'VOIDED'
+          true
+        else
+          false
+        end
+      end
+
       def message_from(response)
         case response[:message]
         when 'Call Voice Center'
@@ -108,19 +213,27 @@ 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]
 
-        request = params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request = params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
         request
       end
 
       def add_pair(post, key, value, options = {})
         post[key] = value if !value.blank? || options[:required]
       end
+
+      def url(action)
+        base_url = test? ? test_url : live_url
+        "#{base_url}/#{ENDPOINTS[action]}/#{ACTIONS[action]}"
+      end
+
+      def split_authorization(authorization)
+        authorization.split('|')
+      end
     end
   end
 end
-