activemerchant 1.32.1 → 1.33.0

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

@@ -1,3 +1,4 @@
+require 'nokogiri'
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     module PayflowCommonAPI
@@ -140,17 +141,18 @@ module ActiveMerchant #:nodoc:
 
       def parse(data)
         response = {}
-        xml = REXML::Document.new(data)
-        root = REXML::XPath.first(xml, "//ResponseData")
+        xml = Nokogiri::XML(data)
+        xml.remove_namespaces!
+        root = xml.xpath("//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")
+        tx_result = root.xpath(".//TransactionResult").first
 
-        if tx_result && tx_result.attributes['Duplicate'] == "true"
+        if tx_result && tx_result.attributes['Duplicate'].to_s == "true"
           response[:duplicate] = true
         end
 
-        root.elements.to_a.each do |node|
+        root.xpath(".//*").each do |node|
           parse_element(response, node)
         end
 
@@ -166,14 +168,14 @@ module ActiveMerchant #:nodoc:
           # 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) }
+          node.xpath(".//*").each{ |e| parse_element(payment_result_response, e) }
+        when node.xpath(".//*").to_a.any?
+          node.xpath(".//*").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']
+          response[node_name] = node.attributes['Currency'].to_s
         when node_name == :ext_data
-          response[node.attributes['Name'].underscore.to_sym] = node.attributes['Value']
+          response[node.attributes['Name'].to_s.underscore.to_sym] = node.attributes['Value'].to_s
         else
           response[node_name] = node.text
         end

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

@@ -1,13 +1,13 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class PaymillGateway < Gateway
-      self.supported_countries = %w(AD AT BE CY CZ DE DK EE ES FI FO FR GB GR
-                                    HU IE IL IS IT LI LT LU LV MT NL NO PL PT
-                                    SE SI SK TR VA)
+      self.supported_countries = %w(AD AT BE CH CY CZ DE DK EE ES FI FO FR GB GR
+                                    HU IE IL IS IT LI LT LU LV MT NL NO PL PT SE
+                                    SI SK TR VA)
 
       self.supported_cardtypes = [:visa, :master]
       self.homepage_url = 'https://paymill.com'
-      self.display_name = 'Paymill'
+      self.display_name = 'PAYMILL'
       self.money_format = :cents
       self.default_currency = 'EUR'
 
@@ -154,7 +154,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def save_card_url
-        (test? ? 'https://test-token.paymill.com' : 'https://token-v2.paymill.com')
+        (test? ? 'https://test-token.paymill.com' : 'https://token-v2.paymill.de')
       end
 
       def post_data(params)

data/lib/active_merchant/billing/gateways/paypal/paypal_common_api.rb

@@ -617,11 +617,11 @@ module ActiveMerchant #:nodoc:
         response = parse(action, ssl_post(endpoint_url, build_request(request), @options[:headers]))
 
         build_response(successful?(response), message_from(response), response,
-    	    :test => test?,
-    	    :authorization => authorization_from(response),
-    	    :fraud_review => fraud_review?(response),
-    	    :avs_result => { :code => response[:avs_code] },
-    	    :cvv_result => response[:cvv2_code]
+          :test => test?,
+          :authorization => authorization_from(response),
+          :fraud_review => fraud_review?(response),
+          :avs_result => { :code => response[:avs_code] },
+          :cvv_result => response[:cvv2_code]
         )
       end
 
@@ -630,7 +630,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(response)
-        response[:transaction_id] || response[:authorization_id] || response[:refund_transaction_id] # middle one is from reauthorization
+        (
+          response[:transaction_id] ||
+          response[:authorization_id] ||
+          response[:refund_transaction_id] ||
+          response[:billing_agreement_id]
+        )
       end
 
       def successful?(response)

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

@@ -59,9 +59,19 @@ module ActiveMerchant #:nodoc:
         commit 'DoExpressCheckoutPayment', build_sale_or_authorization_request('Sale', money, options)
       end
 
-      def reference_transaction(money, options = {})
+      def store(token, options = {})
+        commit 'CreateBillingAgreement', build_create_billing_agreement_request(token, options)
+      end
+
+      def authorize_reference_transaction(money, options = {})
         requires!(options, :reference_id, :payment_type, :invoice_id, :description, :ip)
 
+        commit 'DoReferenceTransaction', build_reference_transaction_request('Authorization', money, options)
+      end
+
+      def reference_transaction(money, options = {})
+        requires!(options, :reference_id)
+
         commit 'DoReferenceTransaction', build_reference_transaction_request('Sale', money, options)
       end
 
@@ -142,7 +152,7 @@ module ActiveMerchant #:nodoc:
               end
               xml.tag! 'n2:CallbackURL', options[:callback_url] unless options[:callback_url].blank?
 
-              add_payment_details(xml, with_money_default(money), currency_code, options)
+              add_payment_details(xml, money, currency_code, options)
               if options[:shipping_options]
                 options[:shipping_options].each do |shipping_option|
                   xml.tag! 'n2:FlatRateShippingOptions' do
@@ -166,6 +176,18 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def build_create_billing_agreement_request(token, options = {})
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.tag! 'CreateBillingAgreementReq', 'xmlns' => PAYPAL_NAMESPACE do
+          xml.tag! 'CreateBillingAgreementRequest', 'xmlns:n2' => EBAY_NAMESPACE do
+            xml.tag! 'n2:Version', API_VERSION
+            xml.tag! 'Token', token
+          end
+        end
+
+        xml.target!
+      end
+
       def build_reference_transaction_request(action, money, options)
         currency_code = options[:currency] || currency(money)
 
@@ -179,7 +201,7 @@ module ActiveMerchant #:nodoc:
               xml.tag! 'n2:ReferenceID', options[:reference_id]
               xml.tag! 'n2:PaymentAction', action
               xml.tag! 'n2:PaymentType', options[:payment_type] || 'Any'
-              add_payment_details(xml, with_money_default(money), currency_code, options)
+              add_payment_details(xml, money, currency_code, options)
               xml.tag! 'n2:IPAddress', options[:ip]
             end
           end
@@ -192,10 +214,6 @@ module ActiveMerchant #:nodoc:
         PaypalExpressResponse.new(success, message, response, options)
       end
 
-      def with_money_default(money)
-        amount(money).to_f.zero? ? 100 : money
-      end
-
       def locale_code(country_code)
         NON_STANDARD_LOCALE_CODES[country_code] || country_code
       end

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

@@ -29,7 +29,7 @@ module ActiveMerchant #:nodoc:
         add_creditcard(post, creditcard)
         add_address(post, creditcard, options)
 
-        commit('charges', post)
+        commit('charges', post, options)
       end
 
       # Create a customer and associated credit card. The token that is returned
@@ -40,14 +40,14 @@ module ActiveMerchant #:nodoc:
         add_creditcard(post, creditcard)
         add_customer_data(post, options)
         add_address(post, creditcard, options)
-        commit('customers', post)
+        commit('customers', post, options)
       end
 
       # Refund a transaction, note that the money attribute is ignored at the
       # moment as the API does not support partial refunds. The parameter is
       # kept for compatibility reasons
       def refund(money, token, options = {})
-        commit("charges/#{CGI.escape(token)}/refunds", :amount => amount(money))
+        commit("charges/#{CGI.escape(token)}/refunds", { :amount => amount(money) }, options)
       end
 
       private
@@ -112,11 +112,11 @@ module ActiveMerchant #:nodoc:
         result
       end
 
-      def commit(action, params)
+      def commit(action, params, options)
         url = "#{test? ? test_url : live_url}/#{action}"
 
         begin
-          body = parse(ssl_post(url, post_data(params), headers(params)))
+          body = parse(ssl_post(url, post_data(params), headers(options)))
         rescue ResponseError => e
           body = parse(e.response.body)
         end

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

@@ -119,17 +119,22 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      # Performs a credit transaction. (Sage +Credit+ transaction).
+      def credit(money, source, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, source, options)
+      end
+
+      # Performs a refund transaction.
       #
       # ==== Parameters
       #
       # * <tt>money</tt> - The amount to be authorized as an integer value in cents.
-      # * <tt>source</tt> - The CreditCard or Check object to be used as the target for the credit.
-      def credit(money, source, options = {})
+      # * <tt>source</tt> - The CreditCard or Check object to be used as the target for the refund.
+      def refund(money, source, options = {})
         if card_brand(source) == "check"
-          virtual_check.credit(money, source, options)
+          virtual_check.refund(money, source, options)
         else
-          bankcard.credit(money, source, options)
+          bankcard.refund(money, source, options)
         end
       end
 

data/lib/active_merchant/billing/gateways/sage/sage_bankcard.rb

@@ -6,7 +6,7 @@ module ActiveMerchant #:nodoc:
       include SageCore
       self.live_url = 'https://www.sagepayments.net/cgi-bin/eftBankcard.dll?transaction'
       self.source = 'bankcard'
-          
+
       # Credit cards supported by Sage
       # * VISA
       # * MasterCard
@@ -17,42 +17,47 @@ module ActiveMerchant #:nodoc:
       # * JCB
       # * Sears
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
-      
+
       def authorize(money, credit_card, options = {})
         post = {}
         add_credit_card(post, credit_card)
         add_transaction_data(post, money, options)
         commit(:authorization, post)
       end
-      
+
       def purchase(money, credit_card, options = {})
         post = {}
         add_credit_card(post, credit_card)
         add_transaction_data(post, money, options)
         commit(:purchase, post)
-      end                       
-    
-      # The +money+ amount is not used. The entire amount of the 
+      end
+
+      # The +money+ amount is not used. The entire amount of the
       # initial authorization will be captured.
       def capture(money, reference, options = {})
         post = {}
         add_reference(post, reference)
         commit(:capture, post)
       end
-      
+
       def void(reference, options = {})
         post = {}
         add_reference(post, reference)
         commit(:void, post)
       end
-      
+
       def credit(money, credit_card, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, credit_card, options)
+      end
+
+      def refund(money, credit_card, options = {})
         post = {}
         add_credit_card(post, credit_card)
         add_transaction_data(post, money, options)
         commit(:credit, post)
       end
-          
+
       private
       def exp_date(credit_card)
         year  = sprintf("%.4i", credit_card.year)
@@ -67,7 +72,7 @@ module ActiveMerchant #:nodoc:
         post[:C_exp]        = exp_date(credit_card)
         post[:C_cvv]        = credit_card.verification_value if credit_card.verification_value?
       end
-      
+
       def parse(data)
         response = {}
         response[:success]          = data[1,1]
@@ -78,7 +83,7 @@ module ActiveMerchant #:nodoc:
         response[:avs_result]       = data[43, 1].strip
         response[:risk]             = data[44, 2]
         response[:reference]        = data[46, 10]
-        
+
         response[:order_number], response[:recurring] = data[57...-1].split("\034")
         response
       end

data/lib/active_merchant/billing/gateways/sage/sage_core.rb

@@ -45,7 +45,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_customer_data(post, options)
-        post[:T_customer_number] = options[:customer]
+        post[:T_customer_number] = options[:customer] if Float(options[:customer]) rescue nil
       end
 
       def add_addresses(post, options)

data/lib/active_merchant/billing/gateways/sage/sage_virtual_check.rb

@@ -6,7 +6,7 @@ module ActiveMerchant #:nodoc:
       include SageCore
       self.live_url = 'https://www.sagepayments.net/cgi-bin/eftVirtualCheck.dll?transaction'
       self.source = 'virtual_check'
-      
+
       def purchase(money, credit_card, options = {})
         post = {}
         add_check(post, credit_card)
@@ -14,21 +14,26 @@ module ActiveMerchant #:nodoc:
         add_transaction_data(post, money, options)
         commit(:purchase, post)
       end
-      
+
       def void(reference, options = {})
         post = {}
         add_reference(post, reference)
         commit(:void, post)
       end
-      
+
       def credit(money, credit_card, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, source, options)
+      end
+
+      def refund(money, credit_card, options = {})
         post = {}
         add_check(post, credit_card)
         add_check_customer_data(post, options)
         add_transaction_data(post, money, options)
         commit(:credit, post)
       end
-      
+
       private
       def add_check(post, check)
         post[:C_first_name]   = check.first_name
@@ -38,37 +43,37 @@ module ActiveMerchant #:nodoc:
         post[:C_check_number] = check.number
         post[:C_acct_type]    = account_type(check)
       end
-      
+
       def add_check_customer_data(post, options)
         # Required  Customer Type – (NACHA Transaction Class)
-        # CCD for Commercial, Merchant Initiated 
+        # CCD for Commercial, Merchant Initiated
         # PPD for Personal, Merchant Initiated
-        # WEB for Internet, Consumer Initiated 
-        # RCK for Returned Checks 
-        # ARC for Account Receivable Entry 
+        # WEB for Internet, Consumer Initiated
+        # RCK for Returned Checks
+        # ARC for Account Receivable Entry
         # TEL for TelephoneInitiated
         post[:C_customer_type] = "WEB"
 
-        # Optional  10  Digit Originator  ID – Assigned  By for  each transaction  class  or  business  purpose. If  not provided, the default Originator ID for the specific  Customer Type will be applied.  
+        # Optional  10  Digit Originator  ID – Assigned  By for  each transaction  class  or  business  purpose. If  not provided, the default Originator ID for the specific  Customer Type will be applied. 
         post[:C_originator_id] = options[:originator_id]
 
         # Optional  Transaction Addenda
         post[:T_addenda] = options[:addenda]
 
-        # Required  Check  Writer  Social  Security  Number  (  Numbers Only, No Dashes )  
+        # Required  Check  Writer  Social  Security  Number  (  Numbers Only, No Dashes ) 
         post[:C_ssn] = options[:ssn].to_s.gsub(/[^\d]/, '')
 
         post[:C_dl_state_code] = options[:drivers_license_state]
         post[:C_dl_number]     = options[:drivers_license_number]
         post[:C_dob]           = format_birth_date(options[:date_of_birth])
       end
-      
+
       def format_birth_date(date)
         date.respond_to?(:strftime) ? date.strftime("%m/%d/%Y") : date
       end
 
-      # DDA for Checking 
-      # SAV for Savings  
+      # DDA for Checking
+      # SAV for Savings 
       def account_type(check)
         case check.account_type
         when 'checking' then 'DDA'
@@ -76,7 +81,7 @@ module ActiveMerchant #:nodoc:
         else raise ArgumentError, "Unknown account type #{check.account_type}"
         end
       end
-      
+
       def parse(data)
         response = {}
         response[:success]          = data[1,1]
@@ -84,7 +89,7 @@ module ActiveMerchant #:nodoc:
         response[:message]          = data[8,32].strip
         response[:risk]             = data[40, 2]
         response[:reference]        = data[42, 10]
-        
+
         extra_data = data[53...-1].split("\034")
         response[:order_number] = extra_data[0]
         response[:authentication_indicator] = extra_data[1]

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

@@ -160,6 +160,7 @@ module ActiveMerchant #:nodoc:
 
       def add_optional_data(post, options)
         add_pair(post, :GiftAidPayment, options[:gift_aid_payment]) unless options[:gift_aid_payment].blank?
+        add_pair(post, :Apply3DSecure, options[:apply_3d_secure]) unless options[:apply_3d_secure].blank?
       end
 
       def add_address(post, options)

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

@@ -0,0 +1,239 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransnationalGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.networkmerchants.com/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.tnbci.com/'
+      self.display_name = 'Transnational'
+
+      self.money_format = :dollars
+      self.default_currency = 'USD'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, creditcard_or_vault_id, options = {})
+        post = build_auth_post(money, creditcard_or_vault_id, options)
+        commit('auth', post)
+      end
+
+      def purchase(money, creditcard_or_vault_id, options = {})
+        post = build_purchase_post(money, creditcard_or_vault_id, options)
+        commit('sale', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = build_capture_post(money, authorization, options)
+        commit('capture', post)
+      end
+
+      def void(authorization, options = {})
+        post = build_void_post(authorization, options)
+        commit('void', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = build_refund_post(money, authorization, options)
+        commit('refund', post)
+      end
+
+      def store(creditcard, options = {})
+        post = build_store_post(creditcard, options)
+        commit_vault('add_customer', post)
+      end
+
+      def unstore(customer_vault_id, options = {})
+        post = build_unstore_post(customer_vault_id, options)
+        commit_vault('delete_customer', post)
+      end
+
+      private
+
+      def build_auth_post(money, creditcard_or_vault_id, options)
+        post = {}
+        add_order(post, options)
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_vault_id, options)
+        add_amount(post, money)
+        post
+      end
+
+      def build_purchase_post(money, creditcard, options)
+        build_auth_post(money, creditcard, options)
+      end
+
+      def build_capture_post(money, authorization, option)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money)
+        post
+      end
+
+      def build_void_post(authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        post
+      end
+
+      def build_refund_post(money, authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money)
+        post
+      end
+
+      def build_store_post(creditcard_or_check, options)
+        post = {}
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_check, options)
+        post
+      end
+
+      def build_unstore_post(customer_vault_id, options)
+        post = {}
+        post['customer_vault_id'] = customer_vault_id
+        post
+      end
+
+      def add_order(post, options)
+        post[:orderid] = options[:order_id]
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_address(post, options)
+        post[:email] = options[:email]
+        post[:ipaddress] = options[:ip]
+
+        address = options[:billing_address] || options[:address] || {}
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:city] = address[:city]
+        post[:state] = address[:state]
+        post[:zip] = address[:zip]
+        post[:country] = address[:country]
+        post[:phone] = address[:phone]
+      end
+
+      def add_shipping_address(post, options)
+        shipping_address = options[:shipping_address] || {}
+        post[:shipping_address1] = shipping_address[:address1]
+        post[:shipping_address2] = shipping_address[:address2]
+        post[:shipping_city] = shipping_address[:city]
+        post[:shipping_state] = shipping_address[:state]
+        post[:shipping_zip] = shipping_address[:zip]
+        post[:shipping_country] = shipping_address[:country]
+      end
+
+      def add_swipe_data(post, options)
+        # unencrypted tracks
+        post[:track_1] = options[:track_1]
+        post[:track_2] = options[:track_2]
+        post[:track_3] = options[:track_3]
+
+        # encrypted tracks
+        post[:magnesafe_track_1] = options[:magnesafe_track_1]
+        post[:magnesafe_track_2] = options[:magnesafe_track_2]
+        post[:magnesafe_track_3] = options[:magnesafe_track_3]
+        post[:magnesafe_magneprint] = options[:magnesafe_magneprint]
+        post[:magnesafe_ksn] = options[:magnesafe_ksn]
+        post[:magnesafe_magneprint_status] = options[:magnesafe_magneprint_status]
+      end
+
+      def add_payment_method(post, creditcard_or_check_or_vault_id, options)
+        post[:processor_id] = options[:processor_id]
+        post[:customer_vault] = 'add_customer' if options[:store]
+
+        add_swipe_data(post, options)
+
+        # creditcard_or_check can be blank if using swipe data
+        if creditcard_or_check_or_vault_id.is_a?(CreditCard) # creditcard or check
+          creditcard = creditcard_or_check_or_vault_id
+          post[:firstname] = creditcard.first_name
+          post[:lastname] = creditcard.last_name
+          post[:ccnumber] = creditcard.number
+          post[:ccexp] = format(creditcard.month, :two_digits) + format(creditcard.year, :two_digits)
+          post[:cvv] = creditcard.verification_value
+          post[:payment] = 'creditcard'
+        elsif creditcard_or_check_or_vault_id.is_a?(Check)
+          check = creditcard_or_check_or_vault_id
+          post[:firstname] = check.first_name
+          post[:lastname] = check.last_name
+          post[:checkname] = check.name
+          post[:checkaba] = check.routing_number
+          post[:checkaccount] = check.account_number
+          post[:account_type] = check.account_type
+          post[:account_holder_type] = check.account_holder_type
+          post[:payment] = 'check'
+        else
+          post[:customer_vault_id] = creditcard_or_check_or_vault_id
+        end
+      end
+
+      def add_login(post)
+        post[:username] = @options[:login]
+        post[:password] = @options[:password]
+      end
+
+      def add_amount(post, money)
+        post[:currency] = options[:currency] || currency(money)
+        post[:amount] = amount(money)
+      end
+
+      def commit_vault(action, parameters)
+        commit(nil, parameters.merge(:customer_vault => action))
+      end
+
+      def commit(action, parameters)
+        raw = parse(ssl_post(self.live_url, build_request(action, parameters)))
+
+        success = (raw['response'] == ResponseCodes::APPROVED)
+
+        authorization = authorization_from(success, parameters, raw)
+
+        Response.new(success, raw['responsetext'], raw,
+          :test => test?,
+          :authorization => authorization,
+          :avs_result => { :code => raw['avsresponse']},
+          :cvv_result => raw['cvvresponse']
+        )
+      end
+
+      def build_request(action, parameters)
+        parameters[:type] = action if action
+        add_login(parameters)
+        parameters.to_query
+      end
+
+      def authorization_from(success, parameters, response)
+        return nil unless success
+
+        authorization = response['transactionid']
+        if(parameters[:customer_vault] && (authorization.nil? || authorization.empty?))
+          authorization = response['customer_vault_id']
+        end
+
+        authorization
+      end
+
+      class ResponseCodes
+        APPROVED = '1'
+        DENIED = '2'
+        ERROR = '3'
+      end
+
+      def parse(raw_response)
+        rsp = CGI.parse(raw_response)
+        rsp.keys.each { |k| rsp[k] = rsp[k].first } # flatten out the values
+        rsp
+      end
+    end
+  end
+end
+