activemerchant 1.38.0 → 1.79.2

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

@@ -0,0 +1,156 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SwipeCheckoutGateway < Gateway
+      TRANSACTION_APPROVED_MSG = 'Transaction approved'
+      TRANSACTION_DECLINED_MSG = 'Transaction declined'
+
+      LIVE_URLS = {
+        'NZ' => 'https://api.swipehq.com',
+        'CA' => 'https://api.swipehq.ca'
+      }
+      self.test_url = 'https://api.swipehq.com'
+
+      TRANSACTION_API = '/createShopifyTransaction.php'
+
+      self.supported_countries = %w[ NZ CA ]
+      self.default_currency = 'NZD'
+      self.supported_cardtypes = [:visa, :master]
+      self.homepage_url = 'https://www.swipehq.com/checkout'
+      self.display_name = 'Swipe Checkout'
+      self.money_format = :dollars
+
+      # Swipe Checkout requires the merchant's email and API key for authorization.
+      # This can be found under Settings > API Credentials after logging in to your
+      # Swipe Checkout merchant console at https://merchant.swipehq.[com|ca]
+      #
+      # :region determines which Swipe URL is used, this can be one of "NZ" or "CA".
+      # Currently Swipe Checkout has New Zealand and Canadian domains (swipehq.com
+      # and swipehq.ca respectively). Merchants must use the region that they
+      # signed up in for authentication with their merchant ID and API key to succeed.
+      def initialize(options = {})
+        requires!(options, :login, :api_key, :region)
+        super
+      end
+
+      # Transfers funds immediately.
+      # Note that Swipe Checkout only supports purchase at this stage
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, creditcard, options)
+        add_amount(post, money, options)
+
+        commit('sale', money, post)
+      end
+
+      private
+
+      def add_customer_data(post, creditcard, options)
+        post[:email] = options[:email]
+        post[:ip_address] = options[:ip]
+
+        address = options[:billing_address] || options[:address]
+        return if address.nil?
+
+        post[:company] = address[:company]
+
+        post[:first_name], post[:last_name] = split_names(address[:name])
+        post[:address] = "#{address[:address1]}, #{address[:address2]}"
+        post[:city] = address[:city]
+        post[:country] = address[:country]
+        post[:mobile] = address[:phone]     # API only has a "mobile" field, no "phone"
+      end
+
+      def add_invoice(post, options)
+        # store shopping-cart order ID in Swipe for merchant's records
+        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"
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:card_number] = creditcard.number
+        post[:card_type] = creditcard.brand
+        post[:name_on_card] = "#{creditcard.first_name} #{creditcard.last_name}"
+        post[:card_expiry] = expdate(creditcard)
+        post[:secure_number] = creditcard.verification_value
+      end
+
+      def expdate(creditcard)
+        year  = format(creditcard.year, :two_digits)
+        month = format(creditcard.month, :two_digits)
+
+        "#{month}#{year}"
+      end
+
+      def add_amount(post, money, options)
+        post[:amount] = money.to_s
+
+        post[:currency] = (options[:currency] || currency(money))
+      end
+
+      def commit(action, money, parameters)
+        case action
+        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"]
+
+            if code == 200
+              result = response["data"]["result"]
+              success = (result == 'accepted' || (test? && result == 'test-accepted'))
+
+              Response.new(success,
+                success ?
+                TRANSACTION_APPROVED_MSG :
+                TRANSACTION_DECLINED_MSG,
+                response,
+                :test => test?
+              )
+            else
+              build_error_response(message, response)
+            end
+          rescue ResponseError => e
+            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.' +
+                  " (Full error message: #{e})"
+            build_error_response(msg)
+          end
+        end
+      end
+
+      def call_api(api, params=nil)
+        params ||= {}
+        params[:merchant_id] = @options[:login]
+        params[:api_key] = @options[:api_key]
+
+        # 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))
+      end
+
+      def url(region, api)
+        ((test? ? self.test_url : LIVE_URLS[region]) + api)
+      end
+
+      def build_error_response(message, params={})
+        Response.new(
+          false,
+          message,
+          params,
+          :test => test?
+        )
+      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

@@ -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, :laser]
+
+    end
+  end
+end

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

@@ -1,65 +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(post)
+        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
+
+      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_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_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, 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|
+      def add_unused_fields(action, post)
+        return unless action == :purchase
+
+        UNUSED_CREDIT_CARD_FIELDS.each do |f|
           post[f] = ""
         end
       end
@@ -75,7 +156,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 +169,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,8 +214,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]
 
@@ -120,7 +226,15 @@ module ActiveMerchant #:nodoc:
       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
-