swiss-activemerchant 1.0.1

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

@@ -0,0 +1,151 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SwipeCheckoutGateway < Gateway
+      TRANSACTION_APPROVED_MSG = 'Transaction approved'
+      TRANSACTION_DECLINED_MSG = 'Transaction declined'
+
+      self.live_url = 'https://api.swipehq.com'
+      self.test_url = 'https://api.swipehq.com'
+
+      TRANSACTION_API = '/createShopifyTransaction.php'
+
+      self.supported_countries = %w[NZ CA]
+      self.default_currency = 'NZD'
+      self.supported_cardtypes = %i[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(api), params.to_query))
+      end
+
+      def url(api)
+        (test? ? self.test_url : self.live_url) + 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,273 @@
+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 = %w[AE IN SA]
+      self.default_currency = 'AED'
+      self.money_format = :dollars
+      self.supported_cardtypes = %i[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')
+        !%w[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)
+        doc.ref(split_authorization(payment_method)[0]) if %w[capture refund void].include?(action) || payment_method.is_a?(String)
+      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)
+        response[:code] unless succeeded
+      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,23 @@
+module ActiveMerchant
+  module Billing
+    class TnsGateway < Gateway
+      include MastercardGateway
+
+      class_attribute :live_na_url, :live_ap_url, :live_eu_url, :test_na_url, :test_ap_url, :test_eu_url
+
+      VERSION = '52'
+
+      self.live_na_url = "https://secure.na.tnspayments.com/api/rest/version/#{VERSION}/"
+      self.live_ap_url = "https://secure.ap.tnspayments.com/api/rest/version/#{VERSION}/"
+      self.live_eu_url = "https://secure.eu.tnspayments.com/api/rest/version/#{VERSION}/"
+
+      self.test_url = "https://secure.uat.tnspayments.com/api/rest/version/#{VERSION}/"
+
+      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 = %i[visa master american_express discover diners_club jcb maestro]
+    end
+  end
+end

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

@@ -0,0 +1,240 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransFirstGateway < Gateway
+      self.test_url = 'https://ws.cert.transfirst.com'
+      self.live_url = 'https://webservices.primerchants.com'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.homepage_url = 'http://www.transfirst.com/'
+      self.display_name = 'TransFirst'
+
+      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, payment, options = {})
+        post = {}
+
+        add_amount(post, money)
+        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
+
+      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)
+      end
+
+      def add_address(post, options)
+        address = options[:billing_address] || options[:address]
+
+        if address
+          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, :SECCCode, options[:invoice], required: true)
+        add_pair(post, :PONumber, options[:invoice], required: true)
+        add_pair(post, :SaleTaxAmount, amount(options[:tax] || 0))
+        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, 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
+
+      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
+
+      def expdate(credit_card)
+        year  = format(credit_card.year, :two_digits)
+        month = format(credit_card.month, :two_digits)
+
+        "#{month}#{year}"
+      end
+
+      def parse(data)
+        response = {}
+
+        xml = REXML::Document.new(data)
+        root = REXML::XPath.first(xml, '*')
+
+        if root.nil?
+          response[:message] = data.to_s.strip
+        else
+          root.elements.to_a.each do |node|
+            response[node.name.underscore.to_sym] = node.text
+          end
+        end
+
+        response
+      end
+
+      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: 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'
+          DECLINED
+        else
+          response[:message]
+        end
+      end
+
+      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
+      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