activemerchant 1.4.2 → 1.5.0

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

@@ -0,0 +1,279 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # = Ogone DirectLink Gateway
+    #
+    # DirectLink is the API version of the Ogone Payment Platform. It allows server to server
+    # communication between Ogone systems and your e-commerce website.
+    #
+    # This implementation follows the specification provided in the DirectLink integration
+    # guide version 2.4 (December 2008), available here:
+    # https://secure.ogone.com/ncol/Ogone_DirectLink_EN.pdf
+    #
+    # It also features aliases, which allow to store/unstore credit cards, as specified in
+    # the Alias Manager Option guide version 2.2 available here:
+    # https://secure.ogone.com/ncol/Ogone_Alias_EN.pdf
+    #
+    # It was last tested on Release 04.79 of Ogone e-Commerce (dated 11/02/2009).
+    #
+    # For any questions or comments, please contact Nicolas Jacobeus (nj@belighted.com).
+    #
+    # == Example use:
+    #
+    #   gateway = ActiveMerchant::Billing::OgoneGateway.new(
+    #               :login     => "my_ogone_psp_id",
+    #               :user      => "my_ogone_user_id",
+    #               :password  => "my_ogone_pswd",
+    #               :signature => "my_ogone_sha1_signature" # extra security, only if you configured your Ogone environment so
+    #            )
+    #
+    #   # set up credit card obj as in main ActiveMerchant example
+    #   creditcard = ActiveMerchant::Billing::CreditCard.new(
+    #     :type       => 'visa',
+    #     :number     => '4242424242424242',
+    #     :month      => 8,
+    #     :year       => 2009,
+    #     :first_name => 'Bob',
+    #     :last_name  => 'Bobsen'
+    #   )
+    #
+    #   # run request
+    #   response = gateway.purchase(1000, creditcard, :order_id => "1") # charge 10 EUR
+    #
+    #   If you don't provide an :order_id, the gateway will generate a random one for you.
+    #
+    #   puts response.success?      # Check whether the transaction was successful
+    #   puts response.message       # Retrieve the message returned by Ogone
+    #   puts response.authorization # Retrieve the unique transaction ID returned by Ogone
+    #
+    #   To use the alias feature, simply add :alias in the options hash:
+    #
+    #   gateway.purchase(1000, creditcard, :order_id => "1", :alias => "myawesomecustomer") # associates the alias to that creditcard
+    #   gateway.purchase(2000, nil,        :order_id => "2", :alias => "myawesomecustomer") # don't need to know the creditcard for subsequent orders
+    #
+    class OgoneGateway < Gateway
+
+      URLS = {
+        :test =>       { :order => 'https://secure.ogone.com/ncol/test/orderdirect.asp',
+                         :maintenance => 'https://secure.ogone.com/ncol/test/maintenancedirect.asp' },
+        :production => { :order => 'https://secure.ogone.com/ncol/prod/orderdirect.asp',
+                         :maintenance => 'https://secure.ogone.com/ncol/prod/maintenancedirect.asp' }
+      }
+
+      CVV_MAPPING = { 'OK' => 'M',
+                      'KO' => 'N',
+                      'NO' => 'P' }
+
+      AVS_MAPPING = { 'OK' => 'M',
+                      'KO' => 'N',
+                      'NO' => 'R' }
+      SUCCESS_MESSAGE = "The transaction was successful"
+
+      self.supported_countries = ['BE', 'DE', 'FR', 'NL', 'AT', 'CH']
+      # also supports Airplus and UATP
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb, :maestro]
+      self.homepage_url = 'http://www.ogone.com/'
+      self.display_name = 'Ogone'
+      self.default_currency = 'EUR'
+      self.money_format = :cents
+
+      def initialize(options = {})
+        requires!(options, :login, :user, :password)
+        @options = options
+        super
+      end
+
+      # Verify and reserve the specified amount on the account, without actually doing the transaction.
+      def authorize(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)
+        add_address(post, payment_source, options)
+        add_customer_data(post, options)
+        add_money(post, money, options)
+        commit('RES', post)
+      end
+
+      # Verify and transfer the specified amount.
+      def purchase(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)
+        add_address(post, payment_source, options)
+        add_customer_data(post, options)
+        add_money(post, money, options)
+        commit('SAL', post)
+      end
+
+      # Complete a previously authorized transaction.
+      def capture(money, authorization, options = {})
+        post = {}        
+        add_authorization(post, reference_from(authorization))
+        add_invoice(post, options)
+        add_customer_data(post, options)
+        add_money(post, money, options)
+        commit('SAL', post)
+      end
+
+      # Cancels a previously authorized transaction.
+      def void(identification, options = {})
+        post = {}
+        add_authorization(post, reference_from(identification))
+        commit('DES', post)
+      end
+
+      # Credit the specified account by a specific amount.
+      def credit(money, identification_or_credit_card, options = {})        
+        if reference_transaction?(identification_or_credit_card)
+          # Referenced credit: refund of a settled transaction
+          perform_reference_credit(money, identification_or_credit_card, options)
+        else # must be a credit card or card reference
+          perform_non_referenced_credit(money, identification_or_credit_card, options)
+        end
+      end
+      
+      def test?
+        @options[:test] || super
+      end
+      
+      private
+      def reference_from(authorization)
+        authorization.split(";").first
+      end
+      
+      def reference_transaction?(identifier)
+        return false unless identifier.is_a?(String) 
+        reference, action = identifier.split(";")
+        !action.nil?
+      end
+      
+      def perform_reference_credit(money, payment_target, options = {})
+        post = {}
+        add_authorization(post, reference_from(payment_target))
+        add_money(post, money, options)
+        commit('RFD', post)        
+      end
+      
+      def perform_non_referenced_credit(money, payment_target, options = {})
+        # Non-referenced credit: acts like a reverse purchase
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_target, options)
+        add_address(post, payment_target, options)
+        add_customer_data(post, options)
+        add_money(post, money, options)
+        commit('RFD', post)
+      end
+      
+      def add_payment_source(post, payment_source, options)
+        if payment_source.is_a?(String)
+          add_alias(post, payment_source)
+          add_eci(post, '9')
+        else
+          add_alias(post, options[:store])
+          add_creditcard(post, payment_source)
+        end
+      end  
+      
+      def add_eci(post, eci)
+        add_pair post, 'ECI', eci
+      end
+      
+      def add_alias(post, _alias)
+        add_pair post, 'ALIAS',   _alias
+      end
+
+      def add_authorization(post, authorization)
+        add_pair post, 'PAYID',   authorization
+      end
+
+      def add_money(post, money, options)
+        add_pair post, 'currency', options[:currency] || currency(money)
+        add_pair post, 'amount',   amount(money)
+      end
+
+      def add_customer_data(post, options)
+        add_pair post, 'EMAIL',       options[:email]
+        add_pair post, 'REMOTE_ADDR', options[:ip]
+      end
+
+      def add_address(post, creditcard, options)
+        return unless options[:billing_address]
+        add_pair post, 'Owneraddress', options[:billing_address][:address1]
+        add_pair post, 'OwnerZip',     options[:billing_address][:zip]
+        add_pair post, 'ownertown',    options[:billing_address][:city]
+        add_pair post, 'ownercty',     options[:billing_address][:country]
+        add_pair post, 'ownertelno',   options[:billing_address][:phone]
+      end
+
+      def add_invoice(post, options)
+        add_pair post, 'orderID', options[:order_id] || generate_unique_id[0...30]
+        add_pair post, 'COM',     options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        add_pair post, 'CN',     creditcard.name
+        add_pair post, 'CARDNO', creditcard.number
+        add_pair post, 'ED',     "%02d%02s" % [creditcard.month, creditcard.year.to_s[-2..-1]]
+        add_pair post, 'CVC',    creditcard.verification_value
+      end
+
+      def parse(body)
+        xml = REXML::Document.new(body)
+        xml.root.attributes
+      end
+
+      def commit(action, parameters)
+        add_pair parameters, 'PSPID',      @options[:login]
+        add_pair parameters, 'USERID',     @options[:user]
+        add_pair parameters, 'PSWD',       @options[:password]
+        url = URLS[test? ? :test : :production][parameters['PAYID'] ? :maintenance : :order ]
+        response = parse(ssl_post(url, post_data(action, parameters)))
+        options = { :authorization => [response["PAYID"], action].join(";"),
+                    :test => test?,
+                    :avs_result => { :code => AVS_MAPPING[response["AAVCheck"]] },
+                    :cvv_result => CVV_MAPPING[response["CVCCheck"]] }
+        Response.new(successful?(response), message_from(response), response, options)
+      end
+      
+      def successful?(response)
+        response["NCERROR"] == "0"
+      end
+
+      def message_from(response)
+        if successful?(response) 
+          SUCCESS_MESSAGE
+        else
+          format_error_message(response["NCERRORPLUS"])
+        end
+      end
+      
+      def format_error_message(message)
+        raw_message = message.to_s.strip
+        case raw_message
+        when /\|/
+          raw_message.split("|").join(", ").capitalize
+        when /\//
+          raw_message.split("/").first.to_s.capitalize
+        else
+          raw_message.to_s.capitalize
+        end
+      end
+
+      def post_data(action, parameters = {})
+        add_pair parameters, 'Operation' , action
+        if @options[:signature] # the user wants a SHA-1 signature
+          string = ['orderID','amount','currency','CARDNO','PSPID','Operation','ALIAS'].map{|s|parameters[s]}.join + @options[:signature]
+          add_pair parameters, 'SHASign' , Digest::SHA1.hexdigest(string)
+        end
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def add_pair(post, key, value, options = {})
+        post[key] = value if !value.blank? || options[:required]
+      end
+
+    end
+  end
+end

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

@@ -100,7 +100,7 @@ module ActiveMerchant #:nodoc:
       
       def parse(body)
         response = {}
-        body.collect do |l| 
+        body.to_s.each_line do |l| 
           key, value = l.split(":", 2)
           response[key.to_s.downcase.to_sym] = value.strip
         end

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

@@ -182,7 +182,7 @@ module ActiveMerchant #:nodoc:
         {
           "Content-Type" => "text/xml",
           "Content-Length" => content_length.to_s,
-      	  "X-VPS-Timeout" => timeout.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

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

@@ -26,7 +26,7 @@ module ActiveMerchant #:nodoc:
         {  'name'       => full_name,
            'company'    => nil,
            'address1'   => @params['street'],
-           'address2'   => nil,
+           'address2'   => @params['shiptostreet2'],
            'city'       => @params['city'],
            'state'      => @params['state'],
            'country'    => @params['country'],

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

@@ -8,7 +8,7 @@ module ActiveMerchant #:nodoc:
       include PayflowCommonAPI
       include PaypalExpressCommon
       
-      self.test_redirect_url = 'https://test-expresscheckout.paypal.com/cgi-bin/webscr?cmd=_express-checkout&token='      
+      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'
       

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

@@ -44,26 +44,15 @@ module ActiveMerchant #:nodoc:
       
       # Funds are transferred immediately.
       def purchase(money, payment_source, options = {})
-        
-        credit_card = payment_source if payment_source.respond_to?(:number)
-        
-        if credit_card        
-          options[:credit_card] = credit_card
-        else
-          options[:token]       = payment_source
-        end
-        
-        request = build_purchase_or_authorization_request(money, 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, credit_card, options = {})
-        options[:credit_card] = credit_card
-
-        request = build_purchase_or_authorization_request(money, options)
+      def authorize(money, payment_source, options = {})
+        request = build_purchase_or_authorization_request(money, payment_source, options)
         commit(:authorization, request)
       end
       
@@ -95,17 +84,19 @@ module ActiveMerchant #:nodoc:
       
       private
       
-      def build_purchase_or_authorization_request(money, options)
+      def build_purchase_or_authorization_request(money, payment_source, options)
         result = new_transaction      
-        
-        returning result do |r|
-          add_credit_card(r, options[:credit_card]) if options[:credit_card]
-          add_billing_token(r, options[:token])     if options[:token]
-        
-          add_amount(r, money, options)
-          add_invoice(r, options)
-          add_address_verification_data(r, options)
+
+        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)
@@ -114,18 +105,15 @@ module ActiveMerchant #:nodoc:
         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
-          
-        returning result do |r|
-          add_credit_card(r, credit_card)
-          add_amount(r, 100, options) #need to make an auth request for $1
-          add_token_request(r, options)
-        end
+        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)
@@ -179,8 +167,8 @@ module ActiveMerchant #:nodoc:
         address = options[:billing_address] || options[:address]
         return if address.nil?
         
-        xml.add_element("EnableAvsData").text = 0
-        xml.add_element("AvsAction").text = 0
+        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]

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

@@ -11,14 +11,14 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://www.paypal.com/cgi-bin/webscr?cmd=_wp-pro-overview-outside'
       self.display_name = 'PayPal Website Payments Pro (US)'
       
-      def authorize(money, credit_card, options = {})
+      def authorize(money, credit_card_or_referenced_id, options = {})
         requires!(options, :ip)
-        commit 'DoDirectPayment', build_sale_or_authorization_request('Authorization', money, credit_card, options)
+        commit define_transaction_type(credit_card_or_referenced_id), build_sale_or_authorization_request('Authorization', money, credit_card_or_referenced_id, options)
       end
 
-      def purchase(money, credit_card, options = {})
+      def purchase(money, credit_card_or_referenced_id, options = {})
         requires!(options, :ip)
-        commit 'DoDirectPayment', build_sale_or_authorization_request('Sale', money, credit_card, options)
+        commit define_transaction_type(credit_card_or_referenced_id), build_sale_or_authorization_request('Sale', money, credit_card_or_referenced_id, options)
       end
       
       def express
@@ -26,15 +26,28 @@ module ActiveMerchant #:nodoc:
       end
       
       private
-      def build_sale_or_authorization_request(action, money, credit_card, options)
+      
+      def define_transaction_type(transaction_arg)
+        if transaction_arg.is_a?(String)
+          return 'DoReferenceTransaction'
+        else
+          return 'DoDirectPayment'
+        end
+      end
+      
+      def build_sale_or_authorization_request(action, money, credit_card_or_referenced_id, options)
+        transaction_type = define_transaction_type(credit_card_or_referenced_id)
+        reference_id = credit_card_or_referenced_id if transaction_type == "DoReferenceTransaction"
+        
         billing_address = options[:billing_address] || options[:address]
         currency_code = options[:currency] || currency(money)
        
         xml = Builder::XmlMarkup.new :indent => 2
-        xml.tag! 'DoDirectPaymentReq', 'xmlns' => PAYPAL_NAMESPACE do
-          xml.tag! 'DoDirectPaymentRequest', 'xmlns:n2' => EBAY_NAMESPACE do
+        xml.tag! transaction_type + 'Req', 'xmlns' => PAYPAL_NAMESPACE do
+          xml.tag! transaction_type + 'Request', 'xmlns:n2' => EBAY_NAMESPACE do
             xml.tag! 'n2:Version', API_VERSION
-            xml.tag! 'n2:DoDirectPaymentRequestDetails' do
+            xml.tag! 'n2:' + transaction_type + 'RequestDetails' do
+              xml.tag! 'n2:ReferenceID', reference_id if transaction_type == 'DoReferenceTransaction'
               xml.tag! 'n2:PaymentAction', action
               xml.tag! 'n2:PaymentDetails' do
                 xml.tag! 'n2:OrderTotal', amount(money), 'currencyID' => currency_code
@@ -54,7 +67,7 @@ module ActiveMerchant #:nodoc:
                 
                 add_address(xml, 'n2:ShipToAddress', options[:shipping_address]) if options[:shipping_address]
               end
-              add_credit_card(xml, credit_card, billing_address, options)
+              add_credit_card(xml, credit_card_or_referenced_id, billing_address, options) unless transaction_type == 'DoReferenceTransaction'
               xml.tag! 'n2:IPAddress', options[:ip]
             end
           end