aktivemerchant 2.0.0

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

@@ -0,0 +1,157 @@
+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]
+
+        # groups all names after the first into the last name param
+        post[:first_name], post[:last_name] = address[:name].split(' ', 2)
+        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/tns.rb

@@ -0,0 +1,227 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TnsGateway < Gateway
+      self.display_name = 'TNS'
+      self.homepage_url = 'http://www.tnsi.com/'
+
+      # Testing is partitioned by account.
+      self.live_url = 'https://secure.na.tnspayments.com/api/rest/version/22/'
+
+      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]
+
+      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]       = 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]   = shipping_address[:country]
+
+          last_name, first_middle_names = split_name(shipping_address[:name])
+          shipping[:firstName]  = first_middle_names if first_middle_names
+          shipping[:lastName]   = last_name if last_name
+        end
+        post[:billing].merge!(billing)
+        post[:shipping].merge!(shipping)
+        post[:customer].merge!(customer)
+      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
+        raw = parse(ssl_request(:put, url, build_request(post), headers))
+
+        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
+
+      def split_name(full_name)
+        return nil unless full_name
+        names = full_name.split
+        [names.pop, names.join(' ')]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransFirstGateway < Gateway
+      self.live_url = self.test_url = 'https://webservices.primerchants.com/creditcard.asmx/CCSale'
+
+      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)
+
+      DECLINED = 'The transaction was declined'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        post = {}
+
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)
+        add_address(post, options)
+
+        commit(post)
+      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])
+          add_pair(post, :ZipCode, address[:zip])
+        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, :SaleTaxAmount, amount(options[:tax] || 0))
+        add_pair(post, :PaymentDesc, options[:description], :required => true)
+        add_pair(post, :TaxIndicator, 0)
+      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)
+
+        add_pair(post, :Expiration, expdate(credit_card), :required => true)
+        add_pair(post, :CVV2, credit_card.verification_value)
+      end
+
+      def add_unused_fields(post)
+        UNUSED_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, "//CCSaleDebitResponse")
+
+        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(params)
+        response = parse( ssl_post(self.live_url, post_data(params)) )
+
+        Response.new(response[:status] == "Authorized", message_from(response), response,
+          :test => test?,
+          :authorization => response[:trans_id],
+          :avs_result => { :code => response[:avs_code] },
+          :cvv_result => response[:cvv2_code]
+        )
+      end
+
+      def message_from(response)
+        case response[:message]
+        when 'Call Voice Center'
+          DECLINED
+        else
+          response[:message]
+        end
+      end
+
+      def post_data(params = {})
+        add_unused_fields(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
+    end
+  end
+end
+