activemerchant 1.28.0 → 1.29.0

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
 

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

@@ -1,140 +1,138 @@
-#  This class implements the Psigate gateway for the ActiveMerchant module.
-#  Psigate = http://www.psigate.com/ The class  is currently set up to use
-#  the psigate test server while rails is in testing or developement mode.
-#  The real server will be used while in production mode.
-#  
-#  Modifications by Sean O'Hara ( sohara at sohara dot com )
-#  
-#  Usage for a PreAuth (authorize) is as follows:
-#  
-#  twenty = 2000
-#  gateway = PsigateGateway.new(
-#    :login => 'teststore',
-#    :password => 'psigate1234'
-#  )
-#  
-#  creditcard = CreditCard.new(
-#    :number => '4242424242424242',
-#    :month => 8,
-#    :year => 2006,
-#    :first_name => 'Longbob',
-#    :last_name => 'Longsen'
-#  )
-#  response = @gateway.authorize(twenty, creditcard,
-#     :order_id =>  1234,
-#     :billing_address => {
-#  	    :address1 => '123 fairweather Lane',
-#  	    :address2 => 'Apt B',
-#  	    :city => 'New York',
-#  	    :state => 'NY',
-#  	    :country => 'U.S.A.',
-#  	    :zip => '10010'
-#    },
-#    :email => 'jack@yahoo.com'
-#  )
-
 require 'rexml/document'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-
+    # This class implements the Psigate gateway for the ActiveMerchant module.
+    #
+    # Modifications by Sean O'Hara ( sohara at sohara dot com )
+    #
+    # Usage for a PreAuth (authorize) is as follows:
+    #
+    # gateway = PsigateGateway.new(
+    #   :login => 'teststore',
+    #   :password => 'psigate1234'
+    # )
+    #
+    # creditcard = CreditCard.new(
+    #   :number => '4242424242424242',
+    #   :month => 8,
+    #   :year => 2006,
+    #   :first_name => 'Longbob',
+    #   :last_name => 'Longsen'
+    # )
+    #
+    # twenty = 2000
+    # response = @gateway.authorize(twenty, creditcard,
+    #    :order_id =>  1234,
+    #    :billing_address => {
+    #      :address1 => '123 fairweather Lane',
+    #      :address2 => 'Apt B',
+    #      :city => 'New York',
+    #      :state => 'NY',
+    #      :country => 'U.S.A.',
+    #      :zip => '10010'
+    #   },
+    #   :email => 'jack@yahoo.com'
+    # )
     class PsigateGateway < Gateway
       self.test_url  = 'https://dev.psigate.com:7989/Messenger/XMLMessenger'
       self.live_url  = 'https://secure.psigate.com:7934/Messenger/XMLMessenger'
-      
+
       self.supported_cardtypes = [:visa, :master, :american_express]
       self.supported_countries = ['CA']
       self.homepage_url = 'http://www.psigate.com/'
       self.display_name = 'Psigate'
-   
+
       SUCCESS_MESSAGE = 'Success'
       FAILURE_MESSAGE = 'The transaction was declined'
-      
+
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options                          
-        super      
-      end      
-    
-      # Psigate PreAuth
+        super
+      end
+
       def authorize(money, creditcard, options = {})
-        requires!(options, :order_id)                                                          
-        options.update({ :CardAction => "1" })
-        commit(money, creditcard, options)      
+        requires!(options, :order_id)
+        options[:CardAction] = "1"
+        commit(money, creditcard, options)
       end
-      
-      # Psigate Sale
+
       def purchase(money, creditcard, options = {})
-        requires!(options, :order_id)                                                          
-        options.update({ :CardAction => "0" })
-        commit(money, creditcard, options)     
+        requires!(options, :order_id)
+        options[:CardAction] = "0"
+        commit(money, creditcard, options)
       end
-      
-      # Psigate PostAuth
+
       def capture(money, authorization, options = {})
-        options.update({ :CardAction => "2", :order_id => authorization })
+        options[:CardAction] = "2"
+        options[:order_id], options[:trans_ref_number] = split_authorization(authorization)
         commit(money, nil, options)
       end
-      
 
-      # Psigate Credit
       def credit(money, authorization, options = {})
         deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, authorization, options)
       end
 
       def refund(money, authorization, options = {})
-        options.update({ :CardAction => "3", :order_id => authorization })
+        options[:CardAction] = "3"
+        options[:order_id], options[:trans_ref_number] = split_authorization(authorization)
         commit(money, nil, options)
       end
 
-      private                       
-    
-      def commit(money, creditcard, options = {}) 
-        response = parse(ssl_post(test? ? self.test_url : self.live_url, post_data(money, creditcard, options)))
+      def void(authorization, options = {})
+        options[:CardAction] = "9"
+        options[:order_id], options[:trans_ref_number] = split_authorization(authorization)
+        commit(nil, nil, options)
+      end
+
+      private
+
+      def commit(money, creditcard, options = {})
+        response = parse(ssl_post(url, post_data(money, creditcard, options)))
 
-        Response.new(successful?(response), message_from(response), response, 
-          :test => test?, 
-          :authorization => response[:orderid],
+        Response.new(successful?(response), message_from(response), response,
+          :test => test?,
+          :authorization => build_authorization(response) ,
           :avs_result => { :code => response[:avsresult] },
           :cvv_result => response[:cardidresult]
         )
       end
-      
+
+      def url
+        (test? ? self.test_url : self.live_url)
+      end
+
       def successful?(response)
         response[:approved] == "APPROVED"
       end
-                                               
+
       def parse(xml)
         response = {:message => "Global Error Receipt", :complete => false}
 
-        xml = REXML::Document.new(xml)          
+        xml = REXML::Document.new(xml)
         xml.elements.each('//Result/*') do |node|
-
           response[node.name.downcase.to_sym] = normalize(node.text)
-
         end unless xml.root.nil?
 
         response
-      end     
+      end
 
       def post_data(money, creditcard, options)
         xml = REXML::Document.new
         xml << REXML::XMLDecl.new
-        root  = xml.add_element("Order")
-        
-        for key, value in parameters(money, creditcard, options)
+        root = xml.add_element("Order")
+
+        parameters(money, creditcard, options).each do |key, value|
           root.add_element(key.to_s).text = value if value
-        end    
+        end
 
         xml.to_s
       end
-      
-      # Set up the parameters hash just once so we don't have to do it
-      # for every action. 
-      def parameters(money, creditcard, options = {})  
+
+      def parameters(money, creditcard, options = {})
         params = {
-          # General order paramters
+          # General order parameters
           :StoreID => @options[:login],
           :Passphrase => @options[:password],
           :TestResult => options[:test_result],
@@ -143,12 +141,13 @@ module ActiveMerchant #:nodoc:
           :Phone => options[:phone],
           :Fax => options[:fax],
           :Email => options[:email],
-          
-          # Credit Card paramaters
+          :TransRefNumber => options[:trans_ref_number],
+
+          # Credit Card parameters
           :PaymentType => "CC",
           :CardAction => options[:CardAction],
-          
-          # Financial paramters
+
+          # Financial parameters
           :CustomerIP => options[:ip],
           :SubTotal => amount(money),
           :Tax1 => options[:tax1],
@@ -159,9 +158,9 @@ module ActiveMerchant #:nodoc:
         if creditcard
           exp_month = sprintf("%.2i", creditcard.month) unless creditcard.month.blank?
           exp_year = creditcard.year.to_s[2,2] unless creditcard.year.blank?
-          card_id_code = creditcard.verification_value.blank? ? nil : "1"
+          card_id_code = (creditcard.verification_value.blank? ? nil : "1")
 
-          params.update( 
+          params.update(
             :CardNumber => creditcard.number,
             :CardExpMonth => exp_month,
             :CardExpYear => exp_year,
@@ -169,9 +168,9 @@ module ActiveMerchant #:nodoc:
             :CardIDNumber => creditcard.verification_value
           )
         end
-        
-        if address = options[:billing_address] || options[:address]           
-          params[:Bname] = address[:name] || creditcard.name 
+
+        if(address = (options[:billing_address] || options[:address]))
+          params[:Bname] = address[:name] || creditcard.name
           params[:Baddress1]    = address[:address1] unless address[:address1].blank?
           params[:Baddress2]    = address[:address2] unless address[:address2].blank?
           params[:Bcity]        = address[:city]     unless address[:city].blank?
@@ -180,9 +179,9 @@ module ActiveMerchant #:nodoc:
           params[:Bcountry]     = address[:country]  unless address[:country].blank?
           params[:Bcompany]     = address[:company]  unless address[:company].blank?
         end
-        
+
         if address = options[:shipping_address]
-          params[:Sname]        = address[:name] || creditcard.name 
+          params[:Sname]        = address[:name] || creditcard.name
           params[:Saddress1]    = address[:address1] unless address[:address1].blank?
           params[:Saddress2]    = address[:address2] unless address[:address2].blank?
           params[:Scity]        = address[:city]     unless address[:city].blank?
@@ -191,10 +190,10 @@ module ActiveMerchant #:nodoc:
           params[:Scountry]     = address[:country]  unless address[:country].blank?
           params[:Scompany]     = address[:company]  unless address[:company].blank?
         end
-       	 	
-        return params
+
+        params
       end
-      
+
       def message_from(response)
         if response[:approved] == "APPROVED"
           return SUCCESS_MESSAGE
@@ -214,6 +213,15 @@ module ActiveMerchant #:nodoc:
         else field
         end
       end
+
+      def split_authorization(authorization)
+        order_id, trans_ref_number = authorization.split(';')
+        [order_id, trans_ref_number]
+      end
+
+      def build_authorization(response)
+        [response[:orderid], response[:transrefnumber]].join(";")
+      end
     end
   end
 end