n8_activemerchant 1.9.3

data/lib/active_merchant/billing/gateways/payflow/payflow_common_api.rb

@@ -0,0 +1,207 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module PayflowCommonAPI
+      def self.included(base)
+        base.default_currency = 'USD'
+          
+        base.class_inheritable_accessor :partner
+        
+        # Set the default partner to PayPal
+        base.partner = 'PayPal'
+        
+        base.supported_countries = ['US', 'CA', 'SG', 'AU']
+        
+        base.class_inheritable_accessor :timeout
+        base.timeout = 60
+        
+        # Enable safe retry of failed connections
+        # Payflow is safe to retry because retried transactions use the same
+        # X-VPS-Request-ID header. If a transaction is detected as a duplicate
+        # only the original transaction data will be used by Payflow, and the
+        # subsequent Responses will have a :duplicate parameter set in the params
+        # hash.
+        base.retry_safe = true
+      end
+      
+      XMLNS = 'http://www.paypal.com/XMLPay'
+      TEST_URL = 'https://pilot-payflowpro.paypal.com'
+      LIVE_URL = 'https://payflowpro.paypal.com'
+      
+      CARD_MAPPING = {
+        :visa => 'Visa',
+        :master => 'MasterCard',
+        :discover => 'Discover',
+        :american_express => 'Amex',
+        :jcb => 'JCB',
+        :diners_club => 'DinersClub',
+        :switch => 'Switch',
+        :solo => 'Solo'
+      }
+      
+      TRANSACTIONS = { 
+        :purchase       => "Sale",
+        :authorization  => "Authorization",
+        :capture        => "Capture",
+        :void           => "Void",
+        :credit         => "Credit" 
+      }
+      
+      CVV_CODE = {
+        'Match' => 'M',
+        'No Match' => 'N',
+        'Service Not Available' => 'U', 
+        'Service not Requested' => 'P'
+      }
+          
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        
+        @options = options
+        @options[:partner] = partner if @options[:partner].blank?
+        super
+      end  
+      
+      def test?
+        @options[:test] || super
+      end
+      
+      def capture(money, authorization, options = {})
+        request = build_reference_request(:capture, money, authorization, options)
+        commit(request)
+      end
+      
+      def void(authorization, options = {})
+        request = build_reference_request(:void, nil, authorization, options)
+        commit(request)
+      end
+  
+      private      
+      def build_request(body, request_type = nil)
+        xml = Builder::XmlMarkup.new
+        xml.instruct!
+        xml.tag! 'XMLPayRequest', 'Timeout' => timeout.to_s, 'version' => "2.1", "xmlns" => XMLNS do
+          xml.tag! 'RequestData' do
+            xml.tag! 'Vendor', @options[:login]
+            xml.tag! 'Partner', @options[:partner]
+            if request_type == :recurring
+              xml << body
+            else
+              xml.tag! 'Transactions' do
+                xml.tag! 'Transaction' do
+                  xml.tag! 'Verbosity', 'MEDIUM'
+                  xml << body
+                end
+              end
+            end
+          end
+          xml.tag! 'RequestAuth' do
+            xml.tag! 'UserPass' do
+              xml.tag! 'User', !@options[:user].blank? ? @options[:user] : @options[:login]
+              xml.tag! 'Password', @options[:password]
+            end
+          end
+        end
+        xml.target!
+      end
+      
+      def build_reference_request(action, money, authorization, options)
+        xml = Builder::XmlMarkup.new
+        xml.tag! TRANSACTIONS[action] do
+          xml.tag! 'PNRef', authorization
+        
+          unless money.nil?
+            xml.tag! 'Invoice' do
+              xml.tag! 'TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money)
+            end
+          end
+        end
+        
+        xml.target!
+      end
+
+      def add_address(xml, tag, address, options)  
+        return if address.nil?
+        xml.tag! tag do
+          xml.tag! 'Name', address[:name] unless address[:name].blank?
+          xml.tag! 'EMail', options[:email] unless options[:email].blank?
+          xml.tag! 'Phone', address[:phone] unless address[:phone].blank?
+          xml.tag! 'CustCode', options[:customer] if !options[:customer].blank? && tag == 'BillTo'
+          
+          xml.tag! 'Address' do
+            xml.tag! 'Street', address[:address1] unless address[:address1].blank?
+            xml.tag! 'City', address[:city] unless address[:city].blank?
+            xml.tag! 'State', address[:state].blank? ? "N/A" : address[:state]
+            xml.tag! 'Country', address[:country] unless address[:country].blank?
+            xml.tag! 'Zip', address[:zip] unless address[:zip].blank?
+          end
+        end
+      end
+          
+      def parse(data)
+        response = {}
+        xml = REXML::Document.new(data)
+        root = REXML::XPath.first(xml, "//ResponseData")
+        
+        # REXML::XPath in Ruby 1.8.6 is now unable to match nodes based on their attributes
+        tx_result = REXML::XPath.first(root, "//TransactionResult")
+        
+        if tx_result && tx_result.attributes['Duplicate'] == "true"
+          response[:duplicate] = true 
+        end
+        
+        root.elements.to_a.each do |node|
+          parse_element(response, node)
+        end
+
+        response
+      end
+      
+      def parse_element(response, node)
+        node_name = node.name.underscore.to_sym
+        case
+        when node_name == :rp_payment_result
+          # Since we'll have multiple history items, we can't just flatten everything
+          # down as we do everywhere else. RPPaymentResult elements are not contained
+          # in an RPPaymentResults element so we'll come here multiple times
+          response[node_name] ||= []
+          response[node_name] << ( payment_result_response = {} )
+          node.elements.each{ |e| parse_element(payment_result_response, e) }
+        when node.has_elements?
+          node.elements.each{|e| parse_element(response, e) }
+        when node_name.to_s =~ /amt$/
+          # *Amt elements don't put the value in the #text - instead they use a Currency attribute
+          response[node_name] = node.attributes['Currency']
+        when node_name == :ext_data
+          response[node.attributes['Name'].underscore.to_sym] = node.attributes['Value']
+        else
+          response[node_name] = node.text
+        end
+      end
+      
+      def build_headers(content_length)
+        {
+          "Content-Type" => "text/xml",
+          "Content-Length" => content_length.to_s,
+      	  "X-VPS-Client-Timeout" => timeout.to_s,
+      	  "X-VPS-VIT-Integration-Product" => "ActiveMerchant",
+      	  "X-VPS-VIT-Runtime-Version" => RUBY_VERSION,
+      	  "X-VPS-Request-ID" => Utils.generate_unique_id
+    	  }
+    	end
+    	
+    	def commit(request_body, request_type = nil)
+        request = build_request(request_body, request_type)
+        headers = build_headers(request.size)
+        
+    	  response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, request, headers))
+
+    	  build_response(response[:result] == "0", response[:message], response,
+    	    :test => test?,
+    	    :authorization => response[:pn_ref] || response[:rp_ref],
+    	    :cvv_result => CVV_CODE[response[:cv_result]],
+    	    :avs_result => { :code => response[:avs_result] }
+        )
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/payflow/payflow_express_response.rb

@@ -0,0 +1,39 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayflowExpressResponse < Response
+      def email
+        @params['e_mail']
+      end
+      
+      def full_name
+        "#{@params['name']} #{@params['lastname']}"
+      end
+      
+      def token
+        @params['token']
+      end
+      
+      def payer_id
+        @params['payer_id']
+      end
+      
+      # Really the shipping country, but it is all the information provided
+      def payer_country
+        address['country']
+      end
+      
+      def address
+        {  'name'       => full_name,
+           'company'    => nil,
+           'address1'   => @params['street'],
+           'address2'   => @params['shiptostreet2'],
+           'city'       => @params['city'],
+           'state'      => @params['state'],
+           'country'    => @params['country'],
+           'zip'        => @params['zip'],
+           'phone'      => nil
+        }
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/payflow/payflow_response.rb

@@ -0,0 +1,13 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayflowResponse < Response
+      def profile_id
+        @params['profile_id']
+      end
+      
+      def payment_history
+        @payment_history ||= @params['rp_payment_result'].collect{ |result| result.stringify_keys } rescue []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + '/payflow/payflow_common_api'
+require File.dirname(__FILE__) + '/payflow/payflow_express_response'
+require File.dirname(__FILE__) + '/paypal_express_common'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayflowExpressGateway < Gateway 
+      include PayflowCommonAPI
+      include PaypalExpressCommon
+      
+      self.test_redirect_url = 'https://www.sandbox.paypal.com/cgi-bin/webscr?cmd=_express-checkout&token='
+      self.homepage_url = 'https://www.paypal.com/cgi-bin/webscr?cmd=xpt/merchant/ExpressCheckoutIntro-outside'
+      self.display_name = 'PayPal Express Checkout'
+      
+      def authorize(money, options = {})
+        requires!(options, :token, :payer_id)
+        request = build_sale_or_authorization_request('Authorization', money, options)
+        commit(request)
+      end
+      
+      def purchase(money, options = {})        
+        requires!(options, :token, :payer_id)
+        request = build_sale_or_authorization_request('Sale', money, options)
+        commit(request)
+      end
+      
+      def credit(money, identification, options = {})
+        request = build_reference_request(:credit, money, identification, options)
+        commit(request)
+      end        
+
+      def setup_authorization(money, options = {})
+        requires!(options, :return_url, :cancel_return_url)
+        
+        request = build_setup_express_sale_or_authorization_request('Authorization', money, options)
+        commit(request)
+      end
+      
+      def setup_purchase(money, options = {})
+        requires!(options, :return_url, :cancel_return_url)
+        
+        request = build_setup_express_sale_or_authorization_request('Sale', money, options)
+        commit(request)
+      end
+      
+      def details_for(token)
+        request = build_get_express_details_request(token)
+        commit(request)
+      end
+      
+      private
+      def build_get_express_details_request(token)
+        xml = Builder::XmlMarkup.new :indent => 2  
+        xml.tag! 'GetExpressCheckout' do
+          xml.tag! 'Authorization' do
+            xml.tag! 'PayData' do  
+              xml.tag! 'Tender' do
+                xml.tag! 'PayPal' do
+                  xml.tag! 'Token', token
+                end
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+      
+      def build_setup_express_sale_or_authorization_request(action, money, options = {})
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.tag! 'SetExpressCheckout' do
+          xml.tag! action do
+            xml.tag! 'PayData' do
+              xml.tag! 'Invoice' do
+                xml.tag! 'CustIP', options[:ip] unless options[:ip].blank?
+                xml.tag! 'InvNum', options[:order_id] unless options[:order_id].blank?
+                xml.tag! 'Description', options[:description] unless options[:description].blank?
+            
+                billing_address = options[:billing_address] || options[:address]
+                add_address(xml, 'BillTo', billing_address, options) if billing_address
+                add_address(xml, 'ShipTo', options[:shipping_address], options) if options[:shipping_address]
+                
+                xml.tag! 'TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money)
+              end
+              
+              xml.tag! 'Tender' do
+                add_paypal_details(xml, options)
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+      
+      def build_sale_or_authorization_request(action, money, options) 
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.tag! 'DoExpressCheckout' do
+          xml.tag! action do
+            xml.tag! 'PayData' do
+              xml.tag! 'Invoice' do 
+                xml.tag! 'TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money)
+              end
+              xml.tag! 'Tender' do
+                add_paypal_details xml, options
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+      
+      def add_paypal_details(xml, options)
+         xml.tag! 'PayPal' do
+          xml.tag! 'EMail', options[:email] unless options[:email].blank?
+          xml.tag! 'ReturnURL', options[:return_url] unless options[:return_url].blank?
+          xml.tag! 'CancelURL', options[:cancel_return_url] unless options[:cancel_return_url].blank?
+          xml.tag! 'NotifyURL', options[:notify_url] unless options[:notify_url].blank?
+          xml.tag! 'PayerID', options[:payer_id] unless options[:payer_id].blank?
+          xml.tag! 'Token', options[:token] unless options[:token].blank?
+          xml.tag! 'NoShipping', options[:no_shipping] ? '1' : '0'
+          xml.tag! 'AddressOverride', options[:address_override] ? '1' : '0'
+          xml.tag! 'ButtonSource', application_id.to_s.slice(0,32) unless application_id.blank? 
+          
+          # Customization of the payment page
+          xml.tag! 'PageStyle', options[:page_style] unless options[:page_style].blank?
+          xml.tag! 'HeaderImage', options[:header_image] unless options[:header_image].blank?
+          xml.tag! 'HeaderBackColor', options[:header_background_color] unless options[:header_background_color].blank?
+          xml.tag! 'HeaderBorderColor', options[:header_border_color] unless options[:header_border_color].blank?
+          xml.tag! 'PayflowColor', options[:background_color] unless options[:background_color].blank?
+        end
+      end
+      
+      def build_response(success, message, response, options = {})
+        PayflowExpressResponse.new(success, message, response, options)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/payflow_express'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayflowExpressUkGateway < PayflowExpressGateway
+      self.default_currency = 'GBP'
+      self.partner = 'PayPalUk'
+      
+      self.supported_countries = ['GB']
+      self.homepage_url = 'https://www.paypal.com/uk/cgi-bin/webscr?cmd=_additional-payment-overview-outside'
+      self.display_name = 'PayPal Express Checkout (UK)'
+    end
+  end
+end
+

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

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/payflow'
+require File.dirname(__FILE__) + '/payflow_express_uk' 
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayflowUkGateway < PayflowGateway
+      self.default_currency = 'GBP'
+      self.partner = 'PayPalUk'
+      
+      def express
+        @express ||= PayflowExpressUkGateway.new(@options)
+      end
+      
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :solo, :switch]
+      self.supported_countries = ['GB']
+      self.homepage_url = 'https://www.paypal.com/uk/cgi-bin/webscr?cmd=_wp-pro-overview-outside'
+      self.display_name = 'PayPal Website Payments Pro (UK)'
+    end
+  end
+end
+

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[:card_holder_help_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