johnideal-activemerchant 1.4.4

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

@@ -0,0 +1,230 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    
+    # In NZ DPS supports ANZ, Westpac, National Bank, ASB and BNZ. 
+    # In Australia DPS supports ANZ, NAB, Westpac, CBA, St George and Bank of South Australia. 
+    # The Maybank in Malaysia is supported and the Citibank for Singapore.
+    class PaymentExpressGateway < Gateway
+      self.default_currency = 'NZD'
+      # PS supports all major credit cards; Visa, Mastercard, Amex, Diners, BankCard & JCB. 
+      # Various white label cards can be accepted as well; Farmers, AirNZCard and Elders etc. 
+      # Please note that not all acquirers and Eftpos networks can support some of these card types.
+      # VISA, Mastercard, Diners Club and Farmers cards are supported
+      #
+      # However, regular accounts with DPS only support VISA and Mastercard
+      self.supported_cardtypes = [ :visa, :master, :american_express, :diners_club, :jcb ]
+      
+      self.supported_countries = [ 'AU', 'MY', 'NZ', 'SG', 'ZA', 'GB', 'US' ]
+      
+      self.homepage_url = 'http://www.paymentexpress.com/'
+      self.display_name = 'PaymentExpress'
+      
+      URL = 'https://www.paymentexpress.com/pxpost.aspx'
+      
+      APPROVED = '1'
+      
+      TRANSACTIONS = {
+        :purchase       => 'Purchase',
+        :credit         => 'Refund',
+        :authorization  => 'Auth',
+        :capture        => 'Complete',
+        :validate       => 'Validate'
+      }
+      
+      # We require the DPS gateway username and password when the object is created.
+      def initialize(options = {})
+        # A DPS username and password must exist 
+        requires!(options, :login, :password)
+        # Make the options an instance variable
+        @options = options
+        super
+      end
+      
+      # Funds are transferred immediately.
+      def purchase(money, payment_source, options = {})
+        request = build_purchase_or_authorization_request(money, payment_source, options)
+        commit(:purchase, request)      
+      end
+      
+      # NOTE: Perhaps in options we allow a transaction note to be inserted
+      # Verifies that funds are available for the requested card and amount and reserves the specified amount.
+      # See: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Authcomplete
+      def authorize(money, payment_source, options = {})
+        request = build_purchase_or_authorization_request(money, payment_source, options)
+        commit(:authorization, request)
+      end
+      
+      # Transfer pre-authorized funds immediately
+      # See: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Authcomplete
+      def capture(money, identification, options = {})
+        request = build_capture_or_credit_request(money, identification, options)                                            
+        commit(:capture, request)
+      end
+      
+      # Refund funds to the card holder
+      def credit(money, identification, options = {})
+        requires!(options, :description)
+        
+        request = build_capture_or_credit_request(money, identification, options)                                            
+        commit(:credit, request)
+      end
+      
+      # token based billing
+      
+      # initiates a "Validate" transcation to store card data on payment express servers
+      # returns a "token" that can be used to rebill this card
+      # see: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Tokenbilling
+      # PaymentExpress does not support unstoring a stored card.
+      def store(credit_card, options = {})
+        request  = build_token_request(credit_card, options)
+        commit(:validate, request)
+      end
+      
+      private
+      
+      def build_purchase_or_authorization_request(money, payment_source, options)
+        result = new_transaction      
+
+        if payment_source.is_a?(String)
+          add_billing_token(result, payment_source)
+        else
+          add_credit_card(result, payment_source)
+        end
+        
+        add_amount(result, money, options)
+        add_invoice(result, options)
+        add_address_verification_data(result, options)
+        result
+      end
+      
+      def build_capture_or_credit_request(money, identification, options)
+        result = new_transaction
+      
+        add_amount(result, money, options)
+        add_invoice(result, options)
+        add_reference(result, identification)
+        result
+      end
+      
+      def build_token_request(credit_card, options)
+        result = new_transaction
+        add_credit_card(result, credit_card)
+        add_amount(result, 100, options) #need to make an auth request for $1
+        add_token_request(result, options)
+        result
+      end
+      
+      def add_credentials(xml)
+        xml.add_element("PostUsername").text = @options[:login]
+        xml.add_element("PostPassword").text = @options[:password]
+      end
+      
+      def add_reference(xml, identification)
+        xml.add_element("DpsTxnRef").text = identification
+      end
+      
+      def add_credit_card(xml, credit_card)
+        xml.add_element("CardHolderName").text = credit_card.name
+        xml.add_element("CardNumber").text = credit_card.number
+        xml.add_element("DateExpiry").text = format_date(credit_card.month, credit_card.year)
+        
+        if credit_card.verification_value?
+          xml.add_element("Cvc2").text = credit_card.verification_value
+        end
+        
+        if requires_start_date_or_issue_number?(credit_card)
+          xml.add_element("DateStart").text = format_date(credit_card.start_month, credit_card.start_year) unless credit_card.start_month.blank? || credit_card.start_year.blank?
+          xml.add_element("IssueNumber").text = credit_card.issue_number unless credit_card.issue_number.blank?
+        end
+      end
+      
+      def add_billing_token(xml, token) 
+        xml.add_element("DpsBillingId").text = token
+      end
+      
+      def add_token_request(xml, options)
+        xml.add_element("BillingId").text = options[:billing_id] if options[:billing_id]
+        xml.add_element("EnableAddBillCard").text = 1
+      end
+      
+      def add_amount(xml, money, options)
+        xml.add_element("Amount").text = amount(money)
+        xml.add_element("InputCurrency").text = options[:currency] || currency(money)
+      end
+      
+      def add_transaction_type(xml, action)
+        xml.add_element("TxnType").text = TRANSACTIONS[action]
+      end
+      
+      def add_invoice(xml, options)
+        xml.add_element("TxnId").text = options[:order_id].to_s.slice(0, 16) unless options[:order_id].blank?
+        xml.add_element("MerchantReference").text = options[:description] unless options[:description].blank?
+      end
+      
+      def add_address_verification_data(xml, options)
+        address = options[:billing_address] || options[:address]
+        return if address.nil?
+        
+        xml.add_element("EnableAvsData").text = 1
+        xml.add_element("AvsAction").text = 1
+        
+        xml.add_element("AvsStreetAddress").text = address[:address1]
+        xml.add_element("AvsPostCode").text = address[:zip]
+      end
+      
+      def new_transaction
+        REXML::Document.new.add_element("Txn")
+      end
+
+      # Take in the request and post it to DPS
+      def commit(action, request)
+        add_credentials(request)
+        add_transaction_type(request, action)
+        
+        # Parse the XML response
+        response = parse( ssl_post(URL, request.to_s) )
+        
+        # Return a response
+        PaymentExpressResponse.new(response[:success] == APPROVED, response[:response_text], response,
+          :test => response[:test_mode] == '1',
+          :authorization => response[:dps_txn_ref]
+        )
+      end
+
+      # Response XML documentation: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#XMLTxnOutput
+      def parse(xml_string)
+        response = {}
+
+        xml = REXML::Document.new(xml_string)          
+
+        # Gather all root elements such as HelpText
+        xml.elements.each('Txn/*') do |element|
+          response[element.name.underscore.to_sym] = element.text unless element.name == 'Transaction'
+        end
+
+        # Gather all transaction elements and prefix with "account_"
+        # So we could access the MerchantResponseText by going
+        # response[account_merchant_response_text]
+        xml.elements.each('Txn/Transaction/*') do |element|
+          response[element.name.underscore.to_sym] = element.text
+        end
+        
+        response
+      end
+      
+      def format_date(month, year)
+        "#{format(month, :two_digits)}#{format(year, :two_digits)}"
+      end
+    end
+    
+    class PaymentExpressResponse < Response
+      # add a method to response so we can easily get the token
+      # for Validate transactions
+      def token
+        @params["billing_id"] || @params["dps_billing_id"]
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/paymentech_orbital/paymentech_orbital_response.rb

@@ -0,0 +1,72 @@
+module ActiveMerchant
+  module Billing
+    class PaymentechOrbitalResponse
+      cattr_accessor :elements
+
+      self.elements = [ 
+        :industry_type, :message_type, :merchant_id,
+        :terminal_id, :card_brand, :account_num, 
+        :order_id, :tx_ref_num, :tx_ref_idx, :proc_status,
+        :approval_status, :resp_code, :avs_resp_code,
+        :cvv2_resp_code, :auth_code, :status_msg, :resp_msg,
+        :customer_ref_num, :customer_name, :profile_proc_status,
+        :customer_profile_message, :resp_time
+      ]
+
+      def initialize(doc, options={})
+        @doc = REXML::Document.new(doc)
+        @options = options
+      end
+
+      def success?
+        proc_success? && approved?
+      end
+
+      def proc_success?
+        proc_status == "0"
+      end
+
+      def approved?
+        approval_status == "1"
+      end
+
+      def authorization
+        approval_status
+      end
+      
+      def test?
+        @options[:test] || false
+      end
+
+      def avs_result
+        @avs_result ||= AVSResult.new({:code => avs_resp_code})
+      end
+      
+      def cvv_result
+        @cvv_result ||= CVVResult.new({:code => cvv2_result_code})
+      end
+
+      private
+      def tagify(s)
+        s.to_s.gsub(/\/(.?)/) { 
+          "::#{$1.upcase}" 
+        }.gsub(/(?:^|_)(.)/) { 
+          $1.upcase 
+        }
+      end
+
+      def value_at(sym)
+        node = REXML::XPath.first(@doc, "//#{tagify(sym)}")
+        node ? node.text : nil
+      end
+
+      def method_missing(sym, *args, &blk)
+        if self.class.elements.include?(sym)
+          value_at(sym)
+        else
+          super(sym, *args, &blk)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+require File.dirname(__FILE__) + '/paymentech_orbital/paymentech_orbital_response'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaymentechOrbitalGateway < Gateway
+      cattr_accessor :enable_profile_management, :urls,
+                     :currency_code, :currency_exponent
+      
+      self.urls = {
+        :test => [
+          'https://orbitalvar1.paymentech.net/authorize', 
+          'https://orbitalvar2.paymentech.net/authorize'
+        ], 
+        :live => [
+          'https://orbital1.paymentech.net/authorize',
+          'https://orbital2.paymentech.net/authorize'
+        ]
+      }
+      
+      # Currency information for the api.
+      self.currency_code = "840"
+      self.currency_exponent = "2"
+      
+      # Money format
+      self.money_format = :cents
+      
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['US']
+      
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.example.net/'
+      
+      # The name of the gateway
+      self.display_name = 'Paymentect Orbital Gateway'
+      
+      # Enable profile management?
+      self.enable_profile_management = true
+      
+      def initialize(options = {})
+        requires!(options, :login, :password, :merchant_id, :bin, :terminal_id)
+        @options = options
+        super
+      end
+      
+      [:login, :password, :merchant_id, 
+       :bin, :terminal_id].each do |attr|
+        define_method(:"#{attr}") do
+          @options[:"#{attr}"]
+        end
+      end
+      
+      def authorize(money, creditcard, options = {})
+        request = build_request("NewOrder", money, options) do |xml|
+          add_credentials(xml, "A")
+          add_credit_card(xml, credit_card)
+          add_billing_address(xml, options[:billing_address]) if options[:billing_address]
+          add_profile_management(xml, options[:customer_ref_num]) if enable_profile_management?
+        end
+
+        commit('authonly', request)
+      end
+
+      def purchase(money, credit_card=nil, options = {})
+        request = build_request("NewOrder", money, options) do |xml|
+          add_credentials(xml, "AC")
+          add_credit_card(xml, credit_card)
+          add_billing_address(xml, options[:billing_address]) if options[:billing_address]
+          add_profile_management(xml, options[:customer_ref_num]) if enable_profile_management?
+        end
+
+        commit('sale', request)
+      end
+
+      def capture(money, authorization, options = {})
+        commit('capture', money, post)
+      end
+
+      private
+      def build_request(request_type, money, options)
+        xml = Builder::XmlMarkup.new(:indent => 2)
+        
+        xml.instruct!(:xml, :version => '1.0', :encoding => 'UTF-8')
+        xml.tag! "Request" do
+          xml.tag! request_type do
+            yield xml if block_given?
+
+            xml.tag! "OrderID", options[:order_id]
+            xml.tag! "Amount", money
+          end
+        end
+
+        xml.target!
+      end
+      
+      def add_credentials(xml, message_type)
+        xml.tag! "OrbitalConnectionUsername", login
+        xml.tag! "OrbitalConnectionPassword", password
+        xml.tag! "IndustryType", "EC"
+        xml.tag! "MessageType", message_type
+        xml.tag! "BIN", bin
+        xml.tag! "MerchantID", merchant_id
+        xml.tag! "TerminalID", terminal_id
+      end
+      
+      def add_credit_card(xml, credit_card=nil)
+        if credit_card
+          xml.tag! "CardBrand", card_brand(credit_card)
+          xml.tag! "AccountNum", credit_card.number
+          xml.tag! "Exp", "#{credit_card.month}#{credit_card.year}"
+          add_currency(xml)
+          xml.tag! "CardSecVal", credit_card.verification_value
+        else
+          xml.tag! "AccountNum", nil
+          add_currency(xml)
+        end
+      end
+      
+      def add_currency(xml)
+        xml.tag! "CurrencyCode", self.class.currency_code
+        xml.tag! "CurrencyExponent", self.class.currency_exponent
+      end
+      
+      def add_billing_address(xml, address)
+        xml.tag! "AVSzip", address[:zip]
+        xml.tag! "AVSaddress1", address[:address1]
+        xml.tag! "AVSaddress2", address[:address2]
+        xml.tag! "AVScity", address[:city]
+        xml.tag! "AVSstate", address[:state]
+        xml.tag! "AVSphoneNum" , address[:phone]
+        xml.tag! "AVSname", address[:name]
+        xml.tag! "AVScountryCode", address[:country]
+      end
+      
+      def add_profile_management(xml, customer_ref_num=nil)
+        if customer_ref_num
+          xml.tag! "CustomerRefNum", customer_ref_num
+        else
+          xml.tag! "CustomerProfileFromOrderInd", "A"
+          xml.tag! "CustomerProfileOrderOverrideInd", "NO"
+        end
+      end
+      
+      def commit(action, request)
+        resp = ssl_post(endpoint_url, request, {
+          "MIME-Version" => "1.0",
+          "Content-Type" => "Application/PTI46",
+          "Content-transfer-encoding" => "text",
+          "Request-number" => "1",
+          "Document-type" => "Request"
+        })
+
+        @response ||= PaymentechOrbitalResponse.new(resp, {
+          :test => test?
+        })
+      end
+      
+      def endpoint_url
+        self.class.urls[Base.gateway_mode][0]
+      end
+      
+      def enable_profile_management?
+        self.class.enable_profile_management
+      end
+    end
+  end
+end
+