activemerchant 1.28.0 → 1.29.1

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

@@ -2,29 +2,29 @@ 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. 
+
+    # 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. 
+      # 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 = %w[ AU MY NZ SG ZA GB US ]
-      
+
       self.homepage_url = 'http://www.paymentexpress.com/'
       self.display_name = 'PaymentExpress'
 
       self.live_url = self.test_url = 'https://sec.paymentexpress.com/pxpost.aspx'
-      
+
       APPROVED = '1'
-      
+
       TRANSACTIONS = {
         :purchase       => 'Purchase',
         :credit         => 'Refund',
@@ -32,7 +32,7 @@ module ActiveMerchant #:nodoc:
         :capture        => 'Complete',
         :validate       => 'Validate'
       }
-      
+
       # We require the DPS gateway username and password when the object is created.
       #
       # The PaymentExpress gateway also supports a :use_custom_payment_token boolean option.
@@ -40,25 +40,22 @@ module ActiveMerchant #:nodoc:
       # then the token will be sent as the DPS specified "DpsBillingId".  This is per the documentation at
       # http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Tokenbilling
       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.
       #
       # `payment_source` can be a usual ActiveMerchant credit_card object, or can also
-      # be a string of the `DpsBillingId` or `BillingId` which can be gotten through the 
+      # be a string of the `DpsBillingId` or `BillingId` which can be gotten through the
       # store method.  If you are using a `BillingId` instead of `DpsBillingId` you must
       # also set the instance method `#use_billing_id_for_token` to true, see the `#store`
       # method for an example of how to do this.
       def purchase(money, payment_source, options = {})
         request = build_purchase_or_authorization_request(money, payment_source, options)
-        commit(:purchase, request)      
+        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
@@ -68,19 +65,19 @@ module ActiveMerchant #:nodoc:
         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)                                            
+        request = build_capture_or_credit_request(money, identification, options)
         commit(:capture, request)
       end
-      
+
       # Refund funds to the card holder
       def refund(money, identification, options = {})
         requires!(options, :description)
-        
-        request = build_capture_or_credit_request(money, identification, options)                                            
+
+        request = build_capture_or_credit_request(money, identification, options)
         commit(:credit, request)
       end
 
@@ -88,9 +85,9 @@ module ActiveMerchant #:nodoc:
         deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
-      
+
       # Token Based Billing
-      # 
+      #
       # Instead of storing the credit card details locally, you can store them inside the
       # Payment Express system and instead bill future transactions against a token.
       #
@@ -102,7 +99,7 @@ module ActiveMerchant #:nodoc:
       # initialization of your gateway object.
       #
       # To specify and use your own token, you need to do two things.
-      # 
+      #
       # Firstly, pass in a `:billing_id` as an option in the hash of this store method.  No
       # validation is done on this BillingId by PaymentExpress so you must ensure that it is unique.
       #
@@ -124,37 +121,37 @@ module ActiveMerchant #:nodoc:
         request  = build_token_request(credit_card, options)
         commit(:validate, request)
       end
-    
+
       private
 
       def use_custom_payment_token?
         @options[:use_custom_payment_token]
       end
-      
+
       def build_purchase_or_authorization_request(money, payment_source, options)
-        result = new_transaction      
+        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)
@@ -162,26 +159,26 @@ module ActiveMerchant #:nodoc:
         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
           xml.add_element("Cvc2Presence").text = "1"
         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?
@@ -195,37 +192,37 @@ module ActiveMerchant #:nodoc:
           xml.add_element("DpsBillingId").text = token
         end
       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
@@ -234,10 +231,10 @@ module ActiveMerchant #:nodoc:
       def commit(action, request)
         add_credentials(request)
         add_transaction_type(request, action)
-        
+
         # Parse the XML response
         response = parse( ssl_post(self.live_url, request.to_s) )
-        
+
         # Return a response
         PaymentExpressResponse.new(response[:success] == APPROVED, response[:card_holder_help_text], response,
           :test => response[:test_mode] == '1',
@@ -249,7 +246,7 @@ module ActiveMerchant #:nodoc:
       def parse(xml_string)
         response = {}
 
-        xml = REXML::Document.new(xml_string)          
+        xml = REXML::Document.new(xml_string)
 
         # Gather all root elements such as HelpText
         xml.elements.each('Txn/*') do |element|
@@ -262,15 +259,15 @@ module ActiveMerchant #:nodoc:
         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

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

@@ -65,22 +65,18 @@ module ActiveMerchant #:nodoc:
         requires!(options, :login, :password)
 
         headers = {'X-PP-AUTHORIZATION' => options.delete(:auth_signature), 'X-PAYPAL-MESSAGE-PROTOCOL' => 'SOAP11'} if options[:auth_signature]
-        @options = {
+        options = {
           :pem => pem_file,
           :signature => signature,
           :headers => headers || {}
         }.update(options)
 
 
-        if @options[:pem].blank? && @options[:signature].blank?
+        if options[:pem].blank? && options[:signature].blank?
           raise ArgumentError, "An API Certificate or API Signature is required to make requests to PayPal"
         end
 
-        super
-      end
-
-      def test?
-        @options[:test] || Base.gateway_mode == :test
+        super(options)
       end
 
       def reauthorize(money, authorization, options = {})
@@ -509,10 +505,10 @@ module ActiveMerchant #:nodoc:
       def add_credentials(xml)
         xml.tag! 'RequesterCredentials', CREDENTIALS_NAMESPACES do
           xml.tag! 'n1:Credentials' do
-            xml.tag! 'Username', @options[:login]
-            xml.tag! 'Password', @options[:password]
-            xml.tag! 'Subject', @options[:subject]
-            xml.tag! 'Signature', @options[:signature] unless @options[:signature].blank?
+            xml.tag! 'n1:Username', @options[:login]
+            xml.tag! 'n1:Password', @options[:password]
+            xml.tag! 'n1:Subject', @options[:subject]
+            xml.tag! 'n1:Signature', @options[:signature] unless @options[:signature].blank?
           end
         end
       end

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

@@ -44,6 +44,13 @@ module ActiveMerchant #:nodoc:
            'phone'      => (contact_phone || address['Phone'])
         }
       end
+      
+      def shipping
+        shipping = (@params['UserSelectedOptions']||{})
+        {  'amount'   => shipping['ShippingOptionAmount'],
+           'name'     => shipping['ShippingOptionName']
+        }
+      end
     end
   end
 end

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

@@ -202,6 +202,9 @@ commit 'ManageRecurringPaymentsProfileStatus', build_manage_profile_request(prof
               if options.has_key?(:start_date)
                 xml.tag! 'n2:BillingStartDate', (options[:start_date].is_a?(Date) ? options[:start_date].to_time : options[:start_date]).utc.iso8601
               end
+              if options.has_key?(:outstanding_balance)
+                xml.tag! 'n2:OutstandingBalance', amount(options[:outstanding_balance]), 'currencyID' => options[:currency] || 'USD'
+              end
             end
           end
         end

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

@@ -1,97 +1,95 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class PaystationGateway < Gateway
-      
+
       self.live_url = self.test_url = "https://www.paystation.co.nz/direct/paystation.dll"
-      
+
       # an "error code" of "0" means "No error - transaction successful"
       SUCCESSFUL_RESPONSE_CODE = '0'
-      
+
       # an "error code" of "34" means "Future Payment Stored OK"
       SUCCESSFUL_FUTURE_PAYMENT = '34'
-      
+
       # TODO: check this with paystation
       self.supported_countries = ['NZ']
-      
+
       # TODO: check this with paystation (amex and diners need to be enabled)
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club ]
-      
+
       self.homepage_url        = 'http://paystation.co.nz'
       self.display_name        = 'Paystation'
-      
+
       self.default_currency    = 'NZD'
       self.money_format        = :cents
-        
+
       def initialize(options = {})
-        # You need to pass your Paystation ID and Gateway ID
         requires!(options, :paystation_id, :gateway_id)
-        @options = options
         super
-      end  
-      
+      end
+
       def authorize(money, credit_card, options = {})
         post = new_request
-        
+
         add_invoice(post, options)
         add_amount(post, money, options)
-        
+
         add_credit_card(post, credit_card)
-        
+
         add_authorize_flag(post, options)
-        
+
         commit(post)
       end
-      
+
       def capture(money, authorization_token, options = {})
         post = new_request
-        
+
         add_invoice(post, options)
         add_amount(post, money, options)
-        
+
         add_authorization_token(post, authorization_token, options[:credit_card_verification])
-        
+
         commit(post)
       end
-      
+
       def purchase(money, payment_source, options = {})
         post = new_request
-        
+
         add_invoice(post, options)
         add_amount(post, money, options)
-        
+
         if payment_source.is_a?(String)
-          add_token(post, payment_source)        
+          add_token(post, payment_source)
         else
           add_credit_card(post, payment_source)
         end
-        
+
         add_customer_data(post, options) if options.has_key?(:customer)
-        
+
         commit(post)
-      end                       
-    
+      end
+
       def store(credit_card, options = {})
         post = new_request
-        
+
         add_invoice(post, options)
         add_credit_card(post, credit_card)
         store_credit_card(post, options)
-        
+
         commit(post)
       end
-    
-      private    
-      
+
+      private
+
         def new_request
-          { 
+          {
             :pi    => @options[:paystation_id], # paystation account id
             :gi    => @options[:gateway_id],    # paystation gateway id
             "2p"   => "t",                      # two-party transaction type
             :nr    => "t",                      # -- redirect??
             :df    => "yymm"                    # date format: optional sometimes, required others
-          } 
+          }
         end
-      
+
         def add_customer_data(post, options)
           post[:mc] = options[:customer]
         end
@@ -103,78 +101,78 @@ module ActiveMerchant #:nodoc:
           post[:mo] = options[:invoice]      # "Order Details", displayed in Paystation Admin
           post[:mr] = options[:description]  # "Merchant Reference Code", seen from Paystation Admin
         end
-      
-        def add_credit_card(post, credit_card)     
-          
+
+        def add_credit_card(post, credit_card)
+
           post[:cn] = credit_card.number
           post[:ct] = credit_card.brand
           post[:ex] = format_date(credit_card.month, credit_card.year)
           post[:cc] = credit_card.verification_value if credit_card.verification_value?
-          
+
         end
-        
+
         # bill a token (stored via "store") rather than a Credit Card
         def add_token(post, token)
           post[:fp] = "t"    # turn on "future payments" - what paystation calls Token Billing
           post[:ft] = token
         end
-        
+
         def store_credit_card(post, options)
-          
+
           post[:fp] = "t"                                # turn on "future payments" - what paystation calls Token Billing
           post[:fs] = "t"                                # tells paystation to store right now, not bill
           post[:ft] = options[:token] if options[:token] # specify a token to use that, or let Paystation generate one
-        
+
         end
-        
+
         def add_authorize_flag(post, options)
           post[:pa] = "t" # tells Paystation that this is a pre-auth authorisation payment (account must be in pre-auth mode)
         end
-        
+
         def add_authorization_token(post, auth_token, verification_value = nil)
           post[:cp] = "t" # Capture Payment flag – tells Paystation this transaction should be treated as a capture payment
           post[:cx] = auth_token
           post[:cc] = verification_value
         end
-        
+
         def add_amount(post, money, options)
-          
+
           post[:am] = amount(money)
           post[:cu] = options[:currency] || currency(money)
-          
+
         end
-      
+
         def parse(xml_response)
           response = {}
-          
+
           xml = REXML::Document.new(xml_response)
-          
+
           # for normal payments, the root node is <Response>
           # for "future payments", it's <PaystationFuturePaymentResponse>
           xml.elements.each("#{xml.root.name}/*") do |element|
             response[element.name.underscore.to_sym] = element.text
           end
-                  
+
           response
-        end     
-      
+        end
+
         def commit(post)
-          
+
           post[:tm] = "T" if test? # test mode
-        
+
           pstn_prefix_params = post.collect { |key, value| "pstn_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
-          
+
           # need include paystation param as "initiator flag for payment engine"
           data     = ssl_post(self.live_url, "#{pstn_prefix_params}&paystation=_empty")
           response = parse(data)
           message  = message_from(response)
-          
-          PaystationResponse.new(success?(response), message, response, 
+
+          PaystationResponse.new(success?(response), message, response,
               :test          => (response[:tm] && response[:tm].downcase == "t"),
               :authorization => response[:paystation_transaction_id]
           )
         end
-        
+
         def success?(response)
           (response[:ec] == SUCCESSFUL_RESPONSE_CODE) || (response[:ec] == SUCCESSFUL_FUTURE_PAYMENT)
         end
@@ -182,13 +180,13 @@ module ActiveMerchant #:nodoc:
         def message_from(response)
           response[:em]
         end
-        
+
         def format_date(month, year)
           "#{format(year, :two_digits)}#{format(month, :two_digits)}"
         end
-        
+
     end
-    
+
     class PaystationResponse < Response
       # add a method to response so we can easily get the token
       # for Validate transactions

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

@@ -86,13 +86,10 @@ module ActiveMerchant
       def initialize(options={})
         @options = options
 
-        options[:merchant] ||= 'TEST' if test?
-
+        @options[:merchant] ||= 'TEST' if test?
         requires!(options, :username, :password, :merchant, :pem)
 
-        @options[:eci]      ||= 'SSL'
-
-        super
+        @options[:eci] ||= 'SSL'
       end
 
       def authorize(amount, payment_method, options={})
@@ -205,10 +202,6 @@ module ActiveMerchant
       rescue ActiveMerchant::ClientCertificateError
         return Response.new(false, "Invalid certificate", {}, :test => test?)
       end
-
-      def test?
-        (@options[:test] || super)
-      end
     end
   end
 end

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

@@ -99,7 +99,6 @@ module ActiveMerchant
 
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end