activemerchant 1.15.0 → 1.16.0

data/CHANGELOG

@@ -1,6 +1,27 @@
 = ActiveMerchant CHANGELOG
 
+== Version 1.16.0 (May 12, 2011)
+
+* Bogus: Support referenced transactions for #authorize, #purchase, #recurring and
+#credit [dasch/jduff]
+* Payment Express: Update gateway url [bayan/titanous]
+* Moneybookers: Send country and account_name if provided [Soleone]
+* Moneris: Add Diners Club and Discover [Soleone]
+* Cybersource: add auth_reversal support [jeberly/titanous]
+* WorldPay: Update endpoint URLs for offsite gateway [Soleone]
+* Worldpay: Add JCB and add Maestro [Soleone]
+* Authorize.net: Add Diners Club and JCB [Soleone]
+* Quickpay: Add testmode for subscribe and authorize [dasch/jduff]
+* Orbital: fix handling of phone numbers. [ntalbott]
+* Braintree: Add Diners Club [cody]
+* Add ePaymentPlans offsite payment [robertomiranda/Soleone]
+* Add Stripe gateway [boucher/titanous]
+* Add Paystation gateway [nikz/jduff]
+* Bump minimum ActiveSupport version to 2.3.11 [titanous]
+* Use securerandom from stdlib not active_support [phlipper/jduff]
+
 == Version 1.15.0 (May 12, 2011)
+
 * DirecPay: Fix address to not include address2 twice in some cases [Soleone]
 * DirecPay: Send company if available [Soleone]
 * Realex: Fix hash signature [ntalbott/Soleone]

data/CONTRIBUTORS

@@ -230,4 +230,16 @@ Orbital Paymentech Gateway (July, 2009)
 
 DIRECTebanking - Payment Network AG (May, 2011)
 
-* Gerwin Brunner (Vilango)
+* Gerwin Brunner (Vilango)
+
+Stripe
+
+* Ross Boucher (boucher)
+
+Paystation (July, 2011)
+
+* Nik Wakelin (nikz)
+
+ePaymentPlans offsite gatway (June, 2011)
+
+* Roberto Miranda (robertomiranda)

data/lib/active_merchant.rb

@@ -20,8 +20,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
-                    
-$:.unshift File.dirname(__FILE__)
 
 require 'active_support'
 require 'active_support/core_ext/string/inflections'
@@ -31,10 +29,9 @@ require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/class/delegating_attributes'
 require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/kernel/requires'
 require 'active_support/base64'
-require 'active_support/secure_random'
 
+require 'securerandom'
 require 'builder'
 require 'cgi'
 require 'rexml/document'
@@ -44,7 +41,7 @@ require 'active_merchant/billing'
 require 'active_merchant/version'
 
 module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:    
+  module Billing #:nodoc:
     autoload :Integrations, 'active_merchant/billing/integrations'
   end
 end

data/lib/active_merchant/billing/avs_result.rb

@@ -53,9 +53,9 @@ module ActiveMerchant
       # Map vendor's AVS result code to a street match code
       STREET_MATCH_CODE = {
         'Y' => %w( A B D H J M O Q T V X Y ),
-        'N' => %w( C K L N P W Z ),
+        'N' => %w( C K L N W Z ),
         'X' => %w( G S ),
-        nil => %w( E F I R U )
+        nil => %w( E F I P R U )
       }.inject({}) do |map, (type, codes)|
         codes.each { |code| map[code] = type }
         map

data/lib/active_merchant/billing/credit_card.rb

@@ -80,6 +80,12 @@ module ActiveMerchant #:nodoc:
         [@first_name, @last_name].compact.join(' ')
       end
 
+      def name=(full_name)
+        names = full_name.split
+        self.last_name  = names.pop
+        self.first_name = names.join(" ")
+      end
+
       def verification_value?
         !@verification_value.blank?
       end

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

@@ -42,7 +42,7 @@ module ActiveMerchant #:nodoc:
       AVS_RESULT_CODE, TRANSACTION_ID, CARD_CODE_RESPONSE_CODE  = 5, 6, 38
 
       self.supported_countries = ['US']
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
       self.homepage_url = 'http://www.authorize.net/'
       self.display_name = 'Authorize.Net'
 

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

@@ -153,8 +153,7 @@ module ActiveMerchant #:nodoc:
           {       
             :success => success,
             :message => message,
-            :authorization =>
-              [find(doc, "//OrderFormDoc/Id"), find(doc, "//Transaction/Id")].join(":"),
+            :authorization => find(doc, "//Transaction/Id"),
             :avs_result => find(doc, "//Transaction/AvsRespCode"),
             :cvv_result => find(doc, "//Transaction/Cvv2Resp"),
             :order_id => find(doc, "//OrderFormDoc/Transaction/Id"),

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

@@ -18,9 +18,9 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'http://example.com'
       self.display_name = 'Bogus'
       
-      def authorize(money, creditcard, options = {})
+      def authorize(money, credit_card_or_reference, options = {})
         money = amount(money)
-        case creditcard.number
+        case normalize(credit_card_or_reference)
         when '1'
           Response.new(true, SUCCESS_MESSAGE, {:authorized_amount => money}, :test => true, :authorization => AUTHORIZATION )
         when '2'
@@ -30,10 +30,10 @@ module ActiveMerchant #:nodoc:
         end      
       end
   
-      def purchase(money, creditcard, options = {})
+      def purchase(money, credit_card_or_reference, options = {})
         money = amount(money)
-        case creditcard.number
-        when '1'
+        case normalize(credit_card_or_reference)
+        when '1', AUTHORIZATION
           Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
         when '2'
           Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE },:test => true)
@@ -42,9 +42,9 @@ module ActiveMerchant #:nodoc:
         end
       end
  
-      def recurring(money, creditcard, options = {})
+      def recurring(money, credit_card_or_reference, options = {})
         money = amount(money)
-        case creditcard.number
+        case normalize(credit_card_or_reference)
         when '1'
           Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
         when '2'
@@ -54,14 +54,14 @@ module ActiveMerchant #:nodoc:
         end
       end
  
-      def credit(money, creditcard, options = {})
-        if creditcard.is_a?(String)
+      def credit(money, credit_card_or_reference, options = {})
+        if credit_card_or_reference.is_a?(String)
           deprecated CREDIT_DEPRECATION_MESSAGE
-          return refund(money, creditcard, options)
+          return refund(money, credit_card_or_reference, options)
         end
 
         money = amount(money)
-        case creditcard.number
+        case normalize(credit_card_or_reference)
         when '1'
           Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true )
         when '2'
@@ -71,9 +71,9 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def refund(money, ident, options = {})
+      def refund(money, reference, options = {})
         money = amount(money)
-        case ident
+        case reference
         when '1'
           raise Error, REFUND_ERROR_MESSAGE
         when '2'
@@ -83,9 +83,9 @@ module ActiveMerchant #:nodoc:
         end
       end
  
-      def capture(money, ident, options = {})
+      def capture(money, reference, options = {})
         money = amount(money)
-        case ident
+        case reference
         when '1'
           raise Error, CAPTURE_ERROR_MESSAGE
         when '2'
@@ -95,21 +95,21 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def void(ident, options = {})
-        case ident
+      def void(reference, options = {})
+        case reference
         when '1'
           raise Error, VOID_ERROR_MESSAGE
         when '2'
-          Response.new(false, FAILURE_MESSAGE, {:authorization => ident, :error => FAILURE_MESSAGE }, :test => true)
+          Response.new(false, FAILURE_MESSAGE, {:authorization => reference, :error => FAILURE_MESSAGE }, :test => true)
         else
-          Response.new(true, SUCCESS_MESSAGE, {:authorization => ident}, :test => true)
+          Response.new(true, SUCCESS_MESSAGE, {:authorization => reference}, :test => true)
         end
       end
       
-      def store(creditcard, options = {})
-        case creditcard.number
+      def store(credit_card_or_reference, options = {})
+        case normalize(credit_card_or_reference)
         when '1'
-          Response.new(true, SUCCESS_MESSAGE, {:billingid => '1'}, :test => true, :authorization => AUTHORIZATION )
+          Response.new(true, SUCCESS_MESSAGE, {:billingid => '1'}, :test => true, :authorization => AUTHORIZATION)
         when '2'
           Response.new(false, FAILURE_MESSAGE, {:billingid => nil, :error => FAILURE_MESSAGE }, :test => true)
         else
@@ -117,8 +117,8 @@ module ActiveMerchant #:nodoc:
         end              
       end
       
-      def unstore(identification, options = {})
-        case identification
+      def unstore(reference, options = {})
+        case reference
         when '1'
           Response.new(true, SUCCESS_MESSAGE, {}, :test => true)
         when '2'
@@ -127,6 +127,16 @@ module ActiveMerchant #:nodoc:
           raise Error, UNSTORE_ERROR_MESSAGE
         end
       end
+
+      private
+
+      def normalize(credit_card_or_reference)
+        if credit_card_or_reference.respond_to?(:number)
+          credit_card_or_reference.number
+        else
+          credit_card_or_reference.to_s
+        end
+      end
     end
   end
 end

data/lib/active_merchant/billing/gateways/braintree/braintree_common.rb

@@ -1,7 +1,7 @@
 module BraintreeCommon
   def self.included(base)
     base.supported_countries = ['US']
-    base.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb]
+    base.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
     base.homepage_url = 'http://www.braintreepaymentsolutions.com'
     base.display_name = 'Braintree'
     base.default_currency = 'USD'

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

@@ -109,6 +109,10 @@ module ActiveMerchant #:nodoc:
         setup_address_hash(options)
         commit(build_auth_request(money, creditcard, options), options )
       end
+      
+      def auth_reversal(money, identification, options = {})
+        commit(build_auth_reversal_request(money, identification, options), options)
+      end
 
       # Capture an authorization that has previously been requested
       def capture(money, authorization, options = {})
@@ -225,6 +229,15 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def build_auth_reversal_request(money, identification, options)
+        order_id, request_id, request_token = identification.split(";")
+        options[:order_id] = order_id
+        xml = Builder::XmlMarkup.new :indent => 2
+        add_purchase_data(xml, money, true, options)
+        add_auth_reversal_service(xml, request_id, request_token)
+        xml.target!
+      end
+
       def build_credit_request(money, identification, options)
         order_id, request_id, request_token = identification.split(";")
         options[:order_id] = order_id
@@ -324,6 +337,13 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_auth_reversal_service(xml, request_id, request_token)
+        xml.tag! 'ccAuthReversalService', {'run' => 'true'} do
+          xml.tag! 'authRequestID', request_id
+          xml.tag! 'authRequestToken', request_token
+        end
+      end
+
       def add_credit_service(xml, request_id, request_token)
         xml.tag! 'ccCreditService', {'run' => 'true'} do
           xml.tag! 'captureRequestID', request_id

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

@@ -14,7 +14,7 @@ module ActiveMerchant #:nodoc:
       LIVE_URL = 'https://www3.moneris.com/gateway2/servlet/MpgRequest'
       
       self.supported_countries = ['CA']
-      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover]
       self.homepage_url = 'http://www.moneris.com/'
       self.display_name = 'Moneris'
   

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

@@ -154,7 +154,7 @@ module ActiveMerchant #:nodoc:
           xml.tag! :AVSaddress2, address[:address2]
           xml.tag! :AVScity, address[:city]
           xml.tag! :AVSstate, address[:state]
-          xml.tag! :AVSphoneNum, address[:phone] ? address[:phone].scan(/\d/).to_s : nil
+          xml.tag! :AVSphoneNum, address[:phone] ? address[:phone].scan(/\d/).join.to_s : nil
           xml.tag! :AVSname, creditcard.name
           xml.tag! :AVScountryCode, address[:country]
         end
@@ -162,7 +162,7 @@ module ActiveMerchant #:nodoc:
 
       def add_creditcard(xml, creditcard, currency=nil)
         xml.tag! :AccountNum, creditcard.number
-        xml.tag! :Exp, creditcard.expiry_date.expiration.strftime("%m%y")
+        xml.tag! :Exp, expiry_date(creditcard)
         
         xml.tag! :CurrencyCode, currency_code(currency)
         xml.tag! :CurrencyExponent, '2' # Will need updating to support currencies such as the Yen.
@@ -312,6 +312,10 @@ module ActiveMerchant #:nodoc:
       def currency_code(currency)
         CURRENCY_CODES[(currency || self.default_currency)].to_s
       end
+      
+      def expiry_date(credit_card)
+        "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
+      end
     end
   end
 end

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

@@ -21,7 +21,7 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'http://www.paymentexpress.com/'
       self.display_name = 'PaymentExpress'
       
-      URL = 'https://www.paymentexpress.com/pxpost.aspx'
+      URL = 'https://sec.paymentexpress.com/pxpost.aspx'
       
       APPROVED = '1'
       

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

@@ -0,0 +1,201 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaystationGateway < Gateway
+      
+      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  
+      
+      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)        
+        else
+          add_credit_card(post, payment_source)
+        end
+        
+        add_customer_data(post, options) if options.has_key?(:customer)
+        
+        commit(post)
+      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    
+      
+        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
+
+        def add_invoice(post, options)
+          requires!(options, :order_id)
+
+          post[:ms] = options[:order_id]     # "Merchant Session", must be unique per request
+          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)     
+          
+          post[:cn] = credit_card.number
+          post[:ct] = credit_card.type
+          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     
+      
+        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(URL, "#{pstn_prefix_params}&paystation=_empty")
+          response = parse(data)
+          message  = message_from(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
+
+        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
+      def token
+        @params["future_payment_token"]
+      end
+    end
+  end
+end
+