activemerchant 1.1.0 → 1.2.0

data/lib/active_merchant/billing/integrations/gestpay/helper.rb

@@ -30,8 +30,6 @@ module ActiveMerchant #:nodoc:
                                 :expiry_year  => 'PAY1_EXPYEAR',
                                 :verification_value => 'PAY1_CVV'
           
-          mapping :billing_address, {}
-          
           def customer(params = {})
             add_field(mappings[:customer][:email], params[:email])
             add_field('PAY1_CHNAME', "#{params[:first_name]} #{params[:last_name]}")

data/lib/active_merchant/billing/integrations/helper.rb

@@ -7,6 +7,11 @@ module ActiveMerchant #:nodoc:
         class_inheritable_hash :mappings
         class_inheritable_accessor :country_format
         self.country_format = :alpha2
+        
+        # The application making the calls to the gateway
+        # Useful for things like the PayPal build notation (BN) id fields
+        class_inheritable_accessor :application_id
+        self.application_id = 'ActiveMerchant'
 
         def initialize(order, account, options = {})
           options.assert_valid_keys([:amount, :currency, :test])
@@ -49,8 +54,10 @@ module ActiveMerchant #:nodoc:
         private
         
         def add_address(key, params)
+          return if mappings[key].nil?
+          
           code = lookup_country_code(params.delete(:country))
-          add_field(mappings[key][:country], code) if mappings[key] 
+          add_field(mappings[key][:country], code) 
           add_fields(key, params)
         end
         

data/lib/active_merchant/billing/integrations/nochex.rb

@@ -4,6 +4,65 @@ require File.dirname(__FILE__) + '/nochex/notification.rb'
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     module Integrations #:nodoc:
+      # To start with Nochex, follow the instructions for installing 
+      # ActiveMerchant as a plugin, as described on 
+      # http://www.activemerchant.org/.
+      # 
+      # The plugin will automatically add the ActionView helper for 
+      # ActiveMerchant, which will allow you to make the Nochex payments.  
+      # The idea behind the helper is that it generates an invisible 
+      # forwarding screen that will automatically redirect the user.  
+      # So you would collect all the information about the order and then 
+      # simply render the hidden form, which redirects the user to Nochex.
+      # 
+      # The syntax of the helper is as follows:
+      # 
+      #   <% payment_service_for 'order id', 'nochex_user_id',
+      #                                 :amount => 50.00,
+      #                                 :service => :nochex,
+      #                                 :html => { :id => 'nochex-form' } do |service| %>
+      #   
+      #      <% service.customer :first_name => 'Cody',
+      #                         :last_name => 'Fauser',
+      #                         :phone => '(555)555-5555',
+      #                         :email => 'cody@example.com' %>
+      #   
+      #      <% service.billing_address :city => 'Ottawa',
+      #                                :address1 => '21 Snowy Brook Lane',
+      #                                :address2 => 'Apt. 36',
+      #                                :state => 'ON',
+      #                                :country => 'CA',
+      #                                :zip => 'K1J1E5' %>
+      #   
+      #      <% service.invoice '#1000' %>
+      #      <% service.shipping '0.00' %>
+      #      <% service.tax '0.00' %>
+      #   
+      #      <% service.notify_url url_for(:action => 'notify', :only_path => false) %>
+      #      <% service.return_url url_for(:action => 'done', :only_path => false) %>
+      #      <% service.cancel_return_url 'http://mystore.com' %>
+      #    <% end %>
+      #   
+      # The notify_url is the URL that the Nochex IPN will be sent.  You can 
+      # handle the notification in your controller action as follows:
+      #   
+      #   class NotificationController < ApplicationController
+      #     include ActiveMerchant::Billing::Integrations
+      #   
+      #     def notify
+      #       notification =  Nochex::Notification.new(request.raw_post)
+      #       
+      #       begin
+      #         # Acknowledge notification with Nochex
+      #         raise StandardError, 'Illegal Notification' unless notification.acknowledge
+      #           # Process the payment  
+      #       rescue => e
+      #           logger.warn("Illegal notification received: #{e.message}")
+      #       ensure
+      #           head(:ok)
+      #       end
+      #     end
+      #   end
       module Nochex
        
         mattr_accessor :service_url
@@ -12,10 +71,12 @@ module ActiveMerchant #:nodoc:
         mattr_accessor :notification_confirmation_url
         self.notification_confirmation_url = 'https://www.nochex.com/nochex.dll/apc/apc'
 
+        # Simply a convenience method that returns a new 
+        # ActiveMerchant::Billing::Integrations::Nochex::Notification
         def self.notification(post)
           Notification.new(post)
         end  
       end
     end
   end
-end
+end

data/lib/active_merchant/billing/integrations/nochex/notification.rb

@@ -74,25 +74,18 @@ module ActiveMerchant #:nodoc:
           #     else
           #       ... log possible hacking attempt ...
           #     end
-          def acknowledge      
-            payload = raw
+          def acknowledge
+             payload =  raw
 
-            uri = URI.parse(Nochex.notification_confirmation_url)
+             response = ssl_post(Nochex.notification_confirmation_url, payload, 
+               'Content-Length' => "#{payload.size}",
+               'User-Agent'     => "Active Merchant -- http://activemerchant.org",
+               'Content-Type'   => "application/x-www-form-urlencoded"
+             )
 
-            request = Net::HTTP::Post.new(uri.path)
+             raise StandardError.new("Faulty Nochex result: #{response}") unless ["AUTHORISED", "DECLINED"].include?(response)
 
-            request['Content-Length'] = "#{payload.size}"
-            request['User-Agent'] = "Active Merchant -- http://home.leetsoft.com/am"
-            request['Content-Type'] = "application/x-www-form-urlencoded" 
-
-            http = Net::HTTP.new(uri.host, uri.port)
-            http.verify_mode    = OpenSSL::SSL::VERIFY_NONE unless @ssl_strict
-            http.use_ssl        = true
-
-            response = http.request(request, payload)
-
-            raise StandardError.new("Faulty Nochex result: #{response.body}") unless ["AUTHORISED", "DECLINED"].include?(response.body)
-            response.body == "AUTHORISED"
+             response == "AUTHORISED"
           end
         end
       end

data/lib/active_merchant/billing/integrations/notification.rb

@@ -43,7 +43,7 @@ module ActiveMerchant #:nodoc:
         def parse(post)
           @raw = post.to_s
           for line in @raw.split('&')    
-            key, value = *line.scan( %r{^(\w+)\=(.*)$} ).flatten
+            key, value = *line.scan( %r{^([A-Za-z0-9_.]+)\=(.*)$} ).flatten
             params[key] = CGI.unescape(value)
           end
         end

data/lib/active_merchant/billing/integrations/paypal/helper.rb

@@ -29,7 +29,8 @@ module ActiveMerchant #:nodoc:
             add_field('no_shipping', '1')
             add_field('no_note', '1')
             add_field('charset', 'utf-8')
-            add_field('address_override', '1')
+            add_field('address_override', '0')
+            add_field('bn', application_id.to_s.slice(0,32)) unless application_id.blank?
           end
 
           mapping :amount, 'amount'
@@ -45,57 +46,69 @@ module ActiveMerchant #:nodoc:
           mapping :no_note, 'no_note'
           mapping :address_override, 'address_override'
 
+          mapping :application_id, 'bn'
+
           mapping :customer, :first_name => 'first_name',
                              :last_name  => 'last_name',
-                             :email      => 'email',
-                             :phone      => 'night_phone_a'
+                             :email      => 'email'
 
-          mapping :billing_address, :city    => 'city',
-                                    :address1  => 'address1',
-                                    :address2  => 'address2',
-                                    :state   => 'state',
-                                    :zip     => 'zip',
-                                    :country => 'country',
-                                    :phone_a  => "night_phone_a",
-                                    :phone_b  => "night_phone_b",
-                                    :phone_c  => "night_phone_c"
+          mapping :shipping_address,  :city    => 'city',
+                                      :address1 => 'address1',
+                                      :address2 => 'address2',
+                                      :state   => 'state',
+                                      :zip     => 'zip',
+                                      :country => 'country'
+          
+          def shipping_address(params = {})
+            
+            if params.has_key?(:phone)
+              phone = params.delete(:phone).to_s
+          
+              # Whipe all non digits
+              phone.gsub!(/\D+/, '')
+          
+              # Parse in the us style (555 555 5555) which seems to be the only format paypal supports. Ignore anything before this. 
+              if phone =~ /(\d{3})(\d{3})(\d{4})$/
+                add_field('night_phone_a', $1) 
+                add_field('night_phone_b', $2) 
+                add_field('night_phone_c', $3) 
+              end
+            end
+            
+            # Get the country code in the correct format
+            # Use what we were given if we can't find anything
+            country_code = lookup_country_code(params.delete(:country))
+            add_field(mappings[:shipping_address][:country], country_code)
+              
+            province_code = params.delete(:state)
+                       
+            case country_code
+            when 'CA'
+              add_field(mappings[:shipping_address][:state], CANADIAN_PROVINCES[province_code.upcase]) unless province_code.nil?
+            when 'US'
+              add_field(mappings[:shipping_address][:state], province_code)
+            else
+              add_field(mappings[:shipping_address][:state], province_code.blank? ? 'N/A' : province_code)
+            end
+              
+            # Everything else 
+            params.each do |k, v|
+              field = mappings[:shipping_address][k]
+              add_field(field, v) unless field.nil?
+            end
+          end
           
-           def billing_address(params = {})
-             
-             if params.has_key?(:phone)
-               phone = params.delete(:phone).to_s
-
-               # Whipe all non digits
-               phone.gsub!(/\D+/, '')
-
-               # Parse in the us style (555 555 5555) which seems to be the only format paypal supports. Ignore anything before this. 
-               if phone =~ /(\d{3})(\d{3})(\d{4})$/
-                 add_field(mappings[:billing_address][:phone_a], $1) 
-                 add_field(mappings[:billing_address][:phone_b], $2) 
-                 add_field(mappings[:billing_address][:phone_c], $3) 
-               end
-             end
-             
-             # Get the country code in the correct format
-             # Use what we were given if we can't find anything
-             country_code = lookup_country_code(params.delete(:country))
-             add_field(mappings[:billing_address][:country], country_code)
-             # Fix Canadian province if required
-             if country_code == 'CA'
-               province_code = params.delete(:state)
-               add_field(mappings[:billing_address][:state], CANADIAN_PROVINCES[province_code.upcase]) unless province_code.nil?
-             end
-               
-             # Everything else 
-             params.each do |k, v|
-               field = mappings[:billing_address][k]
-               add_field(field, v) unless field.nil?
-             end
-           end
-
-
           mapping :tax, 'tax'
           mapping :shipping, 'shipping'
+          mapping :cmd, 'cmd'
+          mapping :custom, 'custom'
+          mapping :src, 'src'
+          mapping :sra, 'sra'
+          %w(a p t).each do |l|
+            (1..3).each do |i|
+              mapping "#{l}#{i}".to_sym, "#{l}#{i}"
+            end
+          end
         end
       end
     end

data/lib/active_merchant/billing/integrations/paypal/notification.rb

@@ -42,36 +42,8 @@ module ActiveMerchant #:nodoc:
         #     end
         #   end
         class Notification < ActiveMerchant::Billing::Integrations::Notification
-          # Overwrite this certificate. It contains the Paypal sandbox certificate by default.
-          #
-          # Example:
-          #   Paypal::Notification.paypal_cert = File::read("paypal_cert.pem")
-          cattr_accessor :paypal_cert
-          @@paypal_cert = """
------BEGIN CERTIFICATE-----
-MIIDoTCCAwqgAwIBAgIBADANBgkqhkiG9w0BAQUFADCBmDELMAkGA1UEBhMCVVMx
-EzARBgNVBAgTCkNhbGlmb3JuaWExETAPBgNVBAcTCFNhbiBKb3NlMRUwEwYDVQQK
-EwxQYXlQYWwsIEluYy4xFjAUBgNVBAsUDXNhbmRib3hfY2VydHMxFDASBgNVBAMU
-C3NhbmRib3hfYXBpMRwwGgYJKoZIhvcNAQkBFg1yZUBwYXlwYWwuY29tMB4XDTA0
-MDQxOTA3MDI1NFoXDTM1MDQxOTA3MDI1NFowgZgxCzAJBgNVBAYTAlVTMRMwEQYD
-VQQIEwpDYWxpZm9ybmlhMREwDwYDVQQHEwhTYW4gSm9zZTEVMBMGA1UEChMMUGF5
-UGFsLCBJbmMuMRYwFAYDVQQLFA1zYW5kYm94X2NlcnRzMRQwEgYDVQQDFAtzYW5k
-Ym94X2FwaTEcMBoGCSqGSIb3DQEJARYNcmVAcGF5cGFsLmNvbTCBnzANBgkqhkiG
-9w0BAQEFAAOBjQAwgYkCgYEAt5bjv/0N0qN3TiBL+1+L/EjpO1jeqPaJC1fDi+cC
-6t6tTbQ55Od4poT8xjSzNH5S48iHdZh0C7EqfE1MPCc2coJqCSpDqxmOrO+9QXsj
-HWAnx6sb6foHHpsPm7WgQyUmDsNwTWT3OGR398ERmBzzcoL5owf3zBSpRP0NlTWo
-nPMCAwEAAaOB+DCB9TAdBgNVHQ4EFgQUgy4i2asqiC1rp5Ms81Dx8nfVqdIwgcUG
-A1UdIwSBvTCBuoAUgy4i2asqiC1rp5Ms81Dx8nfVqdKhgZ6kgZswgZgxCzAJBgNV
-BAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMREwDwYDVQQHEwhTYW4gSm9zZTEV
-MBMGA1UEChMMUGF5UGFsLCBJbmMuMRYwFAYDVQQLFA1zYW5kYm94X2NlcnRzMRQw
-EgYDVQQDFAtzYW5kYm94X2FwaTEcMBoGCSqGSIb3DQEJARYNcmVAcGF5cGFsLmNv
-bYIBADAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAFc288DYGX+GX2+W
-P/dwdXwficf+rlG+0V9GBPJZYKZJQ069W/ZRkUuWFQ+Opd2yhPpneGezmw3aU222
-CGrdKhOrBJRRcpoO3FjHHmXWkqgbQqDWdG7S+/l8n1QfDPp+jpULOrcnGEUY41Im
-jZJTylbJQ1b5PBBjGiP0PpK48cdF
------END CERTIFICATE-----
-"""
-
+          include PostsData
+          
           # Was the transaction complete?
           def complete?
             status == "Completed"
@@ -144,6 +116,10 @@ jZJTylbJQ1b5PBBjGiP0PpK48cdF
           def test?
             params['test_ipn'] == '1'
           end
+          
+          def account
+            params['business'] || params['receiver_email']
+          end
 
           # Acknowledge the transaction to paypal. This method has to be called after a new 
           # ipn arrives. Paypal will verify that all the information we received are correct and will return a 
@@ -159,26 +135,17 @@ jZJTylbJQ1b5PBBjGiP0PpK48cdF
           #     else
           #       ... log possible hacking attempt ...
           #     end
-          def acknowledge      
+          def acknowledge
             payload =  raw
 
-            uri = URI.parse(Paypal.service_url)
-            request_path = "#{uri.path}?cmd=_notify-validate"
-
-            request = Net::HTTP::Post.new(request_path)
-            request['Content-Length'] = "#{payload.size}"
-            request['User-Agent']     = "Active Merchant -- http://home.leetsoft.com/am"
-
-            http = Net::HTTP.new(uri.host, uri.port)
-
-            http.verify_mode    = OpenSSL::SSL::VERIFY_NONE unless @ssl_strict
-            http.use_ssl        = true
-
-            request = http.request(request, payload)
-
-            raise StandardError.new("Faulty paypal result: #{request.body}") unless ["VERIFIED", "INVALID"].include?(request.body)
+            response = ssl_post(Paypal.service_url + '?cmd=_notify-validate', payload, 
+              'Content-Length' => "#{payload.size}",
+              'User-Agent'     => "Active Merchant -- http://activemerchant.org"
+            )
+            
+            raise StandardError.new("Faulty paypal result: #{response}") unless ["VERIFIED", "INVALID"].include?(response)
 
-            request.body == "VERIFIED"
+            response == "VERIFIED"
           end
         end
       end

data/lib/active_merchant/lib/error.rb

@@ -0,0 +1,4 @@
+module ActiveMerchant #:nodoc:
+  class ActiveMerchantError < StandardError #:nodoc:
+  end
+end

data/lib/active_merchant/lib/post_data.rb

@@ -0,0 +1,22 @@
+require 'cgi'
+
+class PostData < Hash
+  class_inheritable_accessor :required_fields, :instance_writer => false
+  self.required_fields = []
+  
+  def []=(key, value)
+    return if value.blank? && !required?(key)
+    super
+  end
+  
+  def to_post_data
+    collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")  
+  end
+  
+  alias_method :to_s, :to_post_data
+  
+  private
+  def required?(key)
+    required_fields.include?(key)
+  end
+end

data/lib/active_merchant/lib/posts_data.rb

@@ -1,9 +1,15 @@
 module ActiveMerchant #:nodoc:
+  class ConnectionError < ActiveMerchantError
+  end
+  
   module PostsData  #:nodoc:
     
     def self.included(base)
       base.class_inheritable_accessor :ssl_strict
       base.ssl_strict = true
+      
+      base.class_inheritable_accessor :pem_password
+      base.pem_password = false
     end
     
     def ssl_post(url, data, headers = {})
@@ -12,19 +18,31 @@ module ActiveMerchant #:nodoc:
       http = Net::HTTP.new(uri.host, uri.port) 
       http.use_ssl        = true
       
-      if self.class.ssl_strict
+      if ssl_strict
         http.verify_mode    = OpenSSL::SSL::VERIFY_PEER
         http.ca_file        = File.dirname(__FILE__) + '/../../certs/cacert.pem'
       else
         http.verify_mode    = OpenSSL::SSL::VERIFY_NONE
       end
       
-      unless @options[:pem].blank?
+      if @options && !@options[:pem].blank?
         http.cert           = OpenSSL::X509::Certificate.new(@options[:pem])
-        http.key            = OpenSSL::PKey::RSA.new(@options[:pem])
+        
+        if pem_password
+          raise ArgumentError, "The private key requires a password" if @options[:pem_password].blank?
+          http.key            = OpenSSL::PKey::RSA.new(@options[:pem], @options[:pem_password])
+        else
+          http.key            = OpenSSL::PKey::RSA.new(@options[:pem])
+        end
+      end
+
+      begin
+        http.post(uri.request_uri, data, headers).body
+      rescue EOFError => e
+        raise ConnectionError, "The remote server dropped the connection"
+      rescue Errno::ECONNREFUSED => e
+        raise ConnectionError, "The remote server refused the connection"
       end
-      
-      http.post(uri.path, data, headers).body
     end    
   end
 end