adyen 0.2.3 → 0.3.0

data/.gitignore

@@ -2,3 +2,4 @@
 /pkg
 /doc
 adyen-*.gem
+.yardoc

data/README.rdoc

@@ -26,7 +26,8 @@ You can also install it as a Rails plugin (*deprecated*):
 
 == Usage
 
-See the project wiki on http://wiki.github.com/wvanbergen/adyen to get started.
+See the project wiki on http://wiki.github.com/wvanbergen/adyen to get started. Complete
+RDoc documentation for the project can be found on http://rdoc.info/projects/wvanbergen/adyen.
 
 * For more information about Adyen, see http://www.adyen.com
 * For more information about integrating Adyen, see their manuals at

data/adyen.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name    = 'adyen'
-  s.version = "0.2.3"
-  s.date    = "2009-12-11"
+  s.version = "0.3.0"
+  s.date    = "2009-12-14"
 
   s.summary = "Integrate Adyen payment services in you Ruby on Rails application."
   s.description = <<-EOS

data/lib/adyen.rb

@@ -1,20 +1,28 @@
+# The Adyen module is the container module for all Adyen related functionality, 
+# which is implemented in submodules. This module only contains some global 
+# configuration methods.
+#
+# The most important submodules are:
+# * {Adyen::Form} for generating payment form fields, generating redirect URLs 
+#   to the Adyen payment system, and generating and checking of signatures.
+# * {Adyen::Notification} for handling notifications sent by Adyen to your servers.
+# * {Adyen::SOAP} for communicating with the Adyen SOAP services for payment
+#   maintenance and issuing recurring payments.
 module Adyen
 
   # Loads configuration settings from a Hash.
   #
-  # This method is called recursively for every module. The second
-  # argument is used to denote the current working module.
+  # @param [Hash] hash The (nested Hash) with configuration variables.
+  # @param [Module] mod The current working module. This parameter is used
+  #    to recursively traverse the hash for submodules.
+  # @raise [StandardError] An exception is raised of an unkown configuration 
+  #    setting is encountered in the hash.
   def self.load_config(hash, mod = Adyen)
     hash.each do |key, value|
       if key.to_s =~ /^[a-z]/ && mod.respond_to?(:"#{key}=")
         mod.send(:"#{key}=", value)
       elsif key.to_s =~ /^[A-Z]/
-        begin
-          submodule = mod.const_get(key)
-        rescue LoadError => e
-          raise "Unknown Adyen module to configure: #{mod.name}::#{key}"
-        end
-        self.load_config(value, submodule)
+        self.load_config(value, mod.const_get(key))
       else
         raise "Unknown configuration variable: '#{key}' for #{mod}"
       end
@@ -25,27 +33,37 @@ module Adyen
   LIVE_RAILS_ENVIRONMENTS = ['production']
 
   # Setter voor the current Adyen environment.
-  # Must be either 'test' or 'live'
+  # @param ['test', 'live'] env The Adyen environment to use
   def self.environment=(env)
     @environment = env
   end
 
-  # Returns the current Adyen environment.
-  # Returns either 'test' or 'live'.
+  # Returns the current Adyen environment, either test or live.
+  #
+  # It will return the +override+ value if set, it will return the value set
+  # using {Adyen.environment=} otherwise. If this value also isn't set, the
+  # environemtn is determined with {Adyen.autodetect_environment}.
+  #
+  # @param ['test', 'live'] override An environemt to override the default with.
+  # @return ['test', 'live'] The Adyen environment that is currently being used.
   def self.environment(override = nil)
     override || @environment || Adyen.autodetect_environment
   end
 
-  # Autodetects the Adyen environment based on the RAILS_ENV constant
+  # Autodetects the Adyen environment based on the RAILS_ENV constant.
+  # @return ['test', 'live'] The Adyen environment that corresponds to the Rails environment
   def self.autodetect_environment
     (defined?(RAILS_ENV) && Adyen::LIVE_RAILS_ENVIRONMENTS.include?(RAILS_ENV.to_s.downcase)) ? 'live' : 'test'
   end
 
   # Loads submodules on demand, so that dependencies are not required.
+  # @param [Symbol] sym The name of the submodule
+  # @return [Module] The actual loaded submodule.
+  # @raise [LoadError, NameError] If the submodule cannot be loaded
   def self.const_missing(sym)
     require "adyen/#{sym.to_s.downcase}"
     return Adyen.const_get(sym)
-  rescue Exception => e
+  rescue Exception
     super(sym)
   end
 end

data/lib/adyen/form.rb

@@ -1,6 +1,25 @@
 require 'action_view'
 
 module Adyen
+
+  # The Adyen::Form module contains all functionality that is used to send payment requests 
+  # to the Adyen payment system, using either a HTML form (see {Adyen::Form.hidden_fields}) 
+  # or a HTTP redirect (see {Adyen::Form.redirect_url}).
+  #
+  # Moreover, this module contains a method ({Adyen::Form.redirect_signature_check}) to
+  # check the request that is made to your website after the visitor has made his payment
+  # on the Adyen system for genuinity.
+  #
+  # You can use different skins in Adyen to define different payment environments. You can
+  # register these skins under a custom name in the module. The other methods will automatically
+  # use this information (i.e. the skin code and the shared secret) if it is available. 
+  # Otherwise, you have to provide it yourself for every method call you make. See
+  # {Adyen::Form.register_skin} for more information.
+  #
+  # @see Adyen::Form.register_skin
+  # @see Adyen::Form.hidden_fields
+  # @see Adyen::Form.redirect_url
+  # @see Adyen::Form.redirect_signature_check
   module Form
 
     extend ActionView::Helpers::TagHelper
@@ -9,41 +28,75 @@ module Adyen
     # SKINS
     ######################################################
 
+    # Returns all registered skins and their accompanying skin code and shared secret.
+    # @return [Hash] The hash of registered skins.
     def self.skins
       @skins ||= {}
     end
     
+    # Sets the registered skins.
+    # @param [Hash<Symbol, Hash>] hash A hash with the skin name as key and the skin parameter hash 
+    #    (which should include +:skin_code+ and +:shared_secret+) as value.
+    # @see Adyen::Form.register_skin
     def self.skins=(hash)
       @skins = hash.inject({}) do |skins, (name, skin)|
         skins[name.to_sym] = skin.merge(:name => name.to_sym)
         skins
       end
     end
-    
+
+    # Registers a skin for later use.
+    #
+    # You can store a skin using a self defined symbol. Once the skin is registered,
+    # you can refer to it using this symbol instead of the hard-to-remember skin code.
+    # Moreover, the skin's shared_secret will be looked up automatically for calculting
+    # signatures.
+    #
+    # @example
+    #   Adyen::Form.register_skin(:my_skin, 'dsfH67PO', 'Dfs*7uUln9')
+    # @param [Symbol] name The name of the skin.
+    # @param [String] skin_code The skin code for this skin, as defined by Adyen.
+    # @param [String] shared_secret The shared secret used for signature calculation.
+    # @see Adyen.load_config
     def self.register_skin(name, skin_code, shared_secret)
       self.skins[name.to_sym] = {:name => name.to_sym, :skin_code => skin_code, :shared_secret => shared_secret }
     end
 
+    # Returns skin information given a skin name.
+    # @param [Symbol] skin_name The name of the skin
+    # @return [Hash, nil] A hash with the skin information, or nil if not found.
     def self.skin_by_name(skin_name)
       self.skins[skin_name.to_sym]
     end
-    
+
+    # Returns skin information given a skin code.
+    # @param [String] skin_code The skin code of the skin
+    # @return [Hash, nil] A hash with the skin information, or nil if not found.
     def self.skin_by_code(skin_code)
-      self.skins.detect { |(name, skin)| skin[:skin_code] == skin_code }.last rescue nil      
+      self.skins.detect { |(name, skin)| skin[:skin_code] == skin_code }.last rescue nil
     end
-    
+
+    # Returns the shared secret belonging to a skin code.
+    # @param [String] skin_code The skin code of the skin
+    # @return [String, nil] The shared secret for the skin, or nil if not found. 
     def self.lookup_shared_secret(skin_code)
       skin = skin_by_code(skin_code)[:shared_secret] rescue nil
-    end    
-    
+    end
+
     ######################################################
     # DEFAULT FORM / REDIRECT PARAMETERS
-    ######################################################    
+    ######################################################
 
+    # Returns the default parameters to use, unless they are overridden.
+    # @see Adyen::Form.default_parameters
+    # @return [Hash] The hash of default parameters
     def self.default_parameters
       @default_arguments ||= {}
     end
     
+    # Sets the default parameters to use.
+    # @see Adyen::Form.default_parameters
+    # @param [Hash] hash The hash of default parameters
     def self.default_parameters=(hash)
       @default_arguments = hash
     end
@@ -52,18 +105,34 @@ module Adyen
     # ADYEN FORM URL
     ######################################################
 
+    # The URL of the Adyen payment system that still requires the current
+    # Adyen enviroment to be filled in.
     ACTION_URL = "https://%s.adyen.com/hpp/select.shtml"
 
+    # Returns the URL of the Adyen payment system, adjusted for an Adyen environment.
+    #
+    # @param [String] environment The Adyen environment to use. This parameter can be 
+    #    left out, in which case the 'current' environment will be used.
+    # @return [String] The absolute URL of the Adyen payment system that can be used
+    #    for payment forms or redirects.
+    # @see Adyen::Form.environment
+    # @see Adyen::Form.redirect_url
     def self.url(environment = nil)
-      environment ||= Adyen.environment(environment)
+      environment ||= Adyen.environment
       Adyen::Form::ACTION_URL % environment.to_s
     end
 
-
     ######################################################
     # POSTING/REDIRECTING TO ADYEN
     ######################################################
 
+    # Transforms the payment parameters hash to be in the correct format.
+    # It will also include the default_parameters hash. Finally, switches 
+    # the +:skin+ parameter out for the +:skin_code+ and +:shared_secret+ 
+    # parameter using the list of registered skins. 
+    #
+    # @private
+    # @param [Hash] parameters The payment parameters hash to transform
     def self.do_parameter_transformations!(parameters = {})
       raise "YENs are not yet supported!" if parameters[:currency_code] == 'JPY' # TODO: fixme
 
@@ -80,26 +149,90 @@ module Adyen
       end
     end
 
-    def self.payment_parameters(parameters = {})
+    # Transforms the payment parameters to be in the correct format and calculates the merchant
+    # signature parameter. It also does some basic health checks on the parameters hash.
+    #
+    # @param [Hash] parameters The payment parameters. The parameters set in the 
+    #    {Adyen::Form.default_parameters} hash will be included automatically.
+    # @param [String] shared_secret The shared secret that should be used to calculate
+    #    the payment request signature. This parameter can be left if the skin that is
+    #    used is registered (see {Adyen::Form.register_skin}), or if the shared secret 
+    #    is provided as the +:shared_secret+ parameter.
+    # @return [Hash] The payment parameters with the +:merchant_signature+ parameter set.
+    # @raise [StandardError] Thrown if some parameter health check fails.
+    def self.payment_parameters(parameters = {}, shared_secret = nil)
       do_parameter_transformations!(parameters)
       
       raise "Cannot generate form: :currency code attribute not found!"         unless parameters[:currency_code]
       raise "Cannot generate form: :payment_amount code attribute not found!"   unless parameters[:payment_amount]
       raise "Cannot generate form: :merchant_account attribute not found!"      unless parameters[:merchant_account]
       raise "Cannot generate form: :skin_code attribute not found!"             unless parameters[:skin_code]
-      raise "Cannot generate form: :shared_secret signing secret not provided!" unless parameters[:shared_secret]
 
-      # Merchant signature
-      parameters[:merchant_sig] = calculate_signature(parameters)
-      return parameters      
+      # Calculate the merchant signature using the shared secret.
+      shared_secret ||= parameters.delete(:shared_secret)
+      raise "Cannot calculate payment request signature without shared secret!" unless shared_secret
+      parameters[:merchant_sig] = calculate_signature(parameters, shared_secret)
+      
+      return parameters
     end
     
+    # Returns an absolute URL to the Adyen payment system, with the payment parameters included
+    # as GET parameters in the URL. The URL also depends on the current Adyen enviroment.
+    #
+    # The payment parameters that are provided to this method will be merged with the 
+    # {Adyen::Form.default_parameters} hash. The default parameter values will be overrided
+    # if another value is provided to this method.
+    #
+    # You do not have to provide the +:merchant_sig+ parameter: it will be calculated automatically
+    # if you provide either a registered skin name as the +:skin+ parameter or provide both the
+    # +:skin_code+ and +:shared_secret+ parameters.
+    #
+    # Note that Internet Explorer has a maximum length for URLs it can handle (2083 characters). 
+    # Make sure that the URL is not longer than this limit if you want your site to work in IE.
+    #
+    # @example
+    #
+    #    def pay
+    #      # Genarate a URL to redirect to Adyen's payment system.
+    #      adyen_url = Adyen::Form.redirect_url(:skin => :my_skin, :currency_code => 'USD',
+    #            :payment_amount => 1000, merchant_account => 'MyMerchant', ... )
+    #      
+    #      respond_to do |format|
+    #        format.html { redirect_to(adyen_url) }
+    #      end
+    #    end
+    #
+    # @param [Hash] parameters The payment parameters to include in the payment request.
+    # @return [String] An absolute URL to redirect to the Adyen payment system.
     def self.redirect_url(parameters = {})
-      self.url + '?' + payment_parameters(parameters).map { |(k, v)| "#{k.to_s.camelize(:lower)}=#{CGI.escape(v.to_s)}" }.join('&')
+      self.url + '?' + payment_parameters(parameters).map { |(k, v)| 
+        "#{k.to_s.camelize(:lower)}=#{CGI.escape(v.to_s)}" }.join('&')
     end
-
+    
+    # Returns a HTML snippet of hidden INPUT tags with the provided payment parameters. 
+    # The snippet can be included in a payment form that POSTs to the Adyen payment system.
+    #
+    # The payment parameters that are provided to this method will be merged with the 
+    # {Adyen::Form.default_parameters} hash. The default parameter values will be overrided
+    # if another value is provided to this method.
+    #
+    # You do not have to provide the +:merchant_sig+ parameter: it will be calculated automatically
+    # if you provide either a registered skin name as the +:skin+ parameter or provide both the
+    # +:skin_code+ and +:shared_secret+ parameters.
+    #
+    # @example
+    #    <% form_tag(Adyen::Form.url) do %>
+    #      <%= Adyen::Form.hidden_fields(:skin => :my_skin, :currency_code => 'USD',
+    #            :payment_amount => 1000, ...) %>
+    #      <%= submit_tag("Pay invoice")
+    #    <% end %>
+    #
+    # @param [Hash] parameters The payment parameters to include in the payment request.
+    # @return [String] An HTML snippet that can be included in a form that POSTs to the
+    #       Adyen payment system.
     def self.hidden_fields(parameters = {})
-      # Generate hidden input tags
+      
+      # Generate a hidden input tag per parameter, join them by newlines.
       payment_parameters(parameters).map { |key, value|
         self.tag(:input, :type => 'hidden', :name => key.to_s.camelize(:lower), :value => value)
       }.join("\n")
@@ -109,6 +242,10 @@ module Adyen
     # MERCHANT SIGNATURE CALCULATION
     ######################################################
 
+    # Generates the string that is used to calculate the request signature. This signature
+    # is used by Adyen to check whether the request is genuinely originating from you.
+    # @param [Hash] parameters The parameters that will be included in the payment request.
+    # @return [String] The string for which the siganture is calculated.
     def self.calculate_signature_string(parameters)
       merchant_sig_string = ""
       merchant_sig_string << parameters[:payment_amount].to_s    << parameters[:currency_code].to_s      <<
@@ -120,26 +257,80 @@ module Adyen
                              parameters[:shopper_statement].to_s << parameters[:billing_address_type].to_s
     end
 
-    def self.calculate_signature(parameters)
-       Adyen::Encoding.hmac_base64(parameters.delete(:shared_secret), calculate_signature_string(parameters))
+    # Calculates the payment request signature for the given payment parameters. 
+    #
+    # This signature is used by Adyen to check whether the request is
+    # genuinely originating from you. The resulting signature should be
+    # included in the payment request parameters as the +merchantSig+
+    # parameter; the shared secret should of course not be included.
+    #
+    # @param [Hash] parameters The payment parameters for which to calculate
+    #    the payment request signature.
+    # @param [String] shared_secret The shared secret to use for this signature. 
+    #    It should correspond with the skin_code parameter. This parameter can be 
+    #    left out if the shared_secret is included as key in the parameters.
+    # @return [String] The signature of the payment request
+    def self.calculate_signature(parameters, shared_secret = nil)
+      shared_secret ||= parameters.delete(:shared_secret)
+      Adyen::Encoding.hmac_base64(shared_secret, calculate_signature_string(parameters))
     end
 
     ######################################################
     # REDIRECT SIGNATURE CHECKING
     ######################################################
 
+    # Generates the string for which the redirect signature is calculated, using the request paramaters.
+    # @param [Hash] params A hash of HTTP GET parameters for the redirect request.
+    # @return [String] The signature string.
     def self.redirect_signature_string(params)
       params[:authResult].to_s + params[:pspReference].to_s + params[:merchantReference].to_s + params[:skinCode].to_s
     end
-
+    
+    # Computes the redirect signature using the request parameters, so that the 
+    # redirect can be checked for forgery.
+    #
+    # @param [Hash] params A hash of HTTP GET parameters for the redirect request.
+    # @param [String] shared_secret The shared secret for the Adyen skin that was used for
+    #     the original payment form. You can leave this out of the skin is registered 
+    #     using the {Adyen::Form.register_skin} method.
+    # @return [String] The redirect signature
     def self.redirect_signature(params, shared_secret = nil)
       shared_secret ||= lookup_shared_secret(params[:skinCode])
       Adyen::Encoding.hmac_base64(shared_secret, redirect_signature_string(params))
     end
 
+    # Checks the redirect signature for this request by calcultating the signature from
+    # the provided parameters, and comparing it to the signature provided in the +merchantSig+
+    # parameter.
+    #
+    # If this method returns false, the request could be a forgery and should not be handled.
+    # Therefore, you should include this check in a +before_filter+, and raise an error of the
+    # signature check fails.
+    #
+    # @example
+    #   class PaymentsController < ApplicationController
+    #     before_filter :check_signature, :only => [:return_from_adyen]
+    #     
+    #     def return_from_adyen
+    #       @invoice = Invoice.find(params[:merchantReference])
+    #       @invoice.set_paid! if params[:authResult] == 'AUTHORISED'
+    #     end
+    #     
+    #     private
+    #     
+    #     def check_signature
+    #       raise "Forgery!" unless Adyen::Form.redirect_signature_check(params)
+    #     end
+    #   end
+    #
+    # @param [Hash] params params A hash of HTTP GET parameters for the redirect request. This
+    #      should include the +:merchantSig+ parameter, which contains the signature.
+    # @param [String] shared_secret The shared secret for the Adyen skin that was used for
+    #     the original payment form. You can leave this out of the skin is registered 
+    #     using the {Adyen::Form.register_skin} method.
+    # @return [true, false] Returns true only if the signature in the parameters is correct.
     def self.redirect_signature_check(params, shared_secret = nil)
       params[:merchantSig] == redirect_signature(params, shared_secret)
     end
-
   end
-end
+end

data/lib/adyen/notification.rb

@@ -1,18 +1,51 @@
 require 'activerecord'
 
 module Adyen
+  
+  # The +Adyen::Notification+ class handles notifications sent by Adyen to your servers.
+  #
+  # Because notifications contain important payment status information, you should store
+  # these notifications in your database. For this reason, +Adyen::Notification+ inherits
+  # from +ActiveRecord::Base+, and a migration is included to simply create a suitable table
+  # to store the notifications in.
+  #
+  # Adyen can either send notifications to you via HTTP POST requests, or SOAP requests.
+  # Because SOAP is not really well supported in Rails and setting up a SOAP server is
+  # not trivial, only handling HTTP POST notifications is currently supported.
+  #
+  # @example
+  #    @notification = Adyen::Notification::HttpPost.log(request)
+  #    if @notification.successful_authorisation?
+  #      @invoice = Invoice.find(@notification.merchant_reference)
+  #      @invoice.set_paid!
+  #    end
+  #
+  # @see Adyen::Notification::HttpPost.log
   class Notification < ActiveRecord::Base
 
+    # The default table name to use for the notifications table.
     DEFAULT_TABLE_NAME = :adyen_notifications
     set_table_name(DEFAULT_TABLE_NAME)
 
+    # A notification should always include an event_code
     validates_presence_of :event_code
+    
+    # A notification should always include a psp_reference
     validates_presence_of :psp_reference
+    
+    # A notification should be unique using the composed key of
+    # [:psp_reference, :event_code, :success]
     validates_uniqueness_of :success, :scope => [:psp_reference, :event_code]
 
     # Make sure we don't end up with an original_reference with an empty string
     before_validation { |notification| notification.original_reference = nil if notification.original_reference.blank? }
 
+    # Logs an incoming notification into the database.
+    #
+    # @param [Hash] params The notification parameters that should be stored in the database.
+    # @return [Adyen::Notification] The initiated and persisted notification instance.
+    # @raise This method will raise an exception if the notification cannot be stored.
+    # @see Adyen::Notification::HttpPost.log
     def self.log(params)
       converted_params = {}
       # Convert each attribute from CamelCase notation to under_score notation
@@ -24,16 +57,30 @@ module Adyen
       self.create!(converted_params)
     end
 
+    # Returns true if this notification is an AUTHORISATION notification
+    # @return [true, false] true iff event_code == 'AUTHORISATION'
+    # @see Adyen.notification#successful_authorisation?
     def authorisation?
       event_code == 'AUTHORISATION'
     end
 
     alias :authorization? :authorisation?
 
+    # Returns true if this notification is an AUTHORISATION notification and
+    # the success status indicates that the authorization was successfull.
+    # @return [true, false] true iff  the notification is an authorization
+    #   and the authorization was successful according to the success field.
     def successful_authorisation?
       event_code == 'AUTHORISATION' && success?
     end
+    
+    alias :successful_authorization? :successful_authorisation?
 
+    # Collect a payment using the recurring contract that was initiated with
+    # this notification. The payment is collected using a SOAP call to the 
+    # Adyen SOAP service for recurring payments.
+    # @param [Hash] options The payment parameters.
+    # @see Adyen::SOAP::RecurringService#submit
     def collect_payment_for_recurring_contract!(options)
       # Make sure we convert the value to cents
       options[:value] = Adyen::Formatter::Price.in_cents(options[:value])
@@ -41,13 +88,16 @@ module Adyen
       Adyen::SOAP::RecurringService.submit(options.merge(:recurring_reference => self.psp_reference))
     end
 
+    # Deactivates the recurring contract that was initiated with this notification.
+    # The contract is deactivated by sending a SOAP call to the Adyen SOAP service for
+    # recurring contracts.
+    # @param [Hash] options The recurring contract parameters.
+    # @see Adyen::SOAP::RecurringService#deactivate
     def deactivate_recurring_contract!(options)
       raise "This is not a recurring contract!" unless event_code == 'RECURRING_CONTRACT'
       Adyen::SOAP::RecurringService.deactivate(options.merge(:recurring_reference => self.psp_reference))
     end
 
-    alias :successful_authorization? :successful_authorisation?
-
     class HttpPost < Notification
 
       def self.log(request)
@@ -67,6 +117,8 @@ module Adyen
       end
     end
 
+    # An ActiveRecord migration that can be used to create a suitable table  
+    # to store Adyen::Notification instances for your application.
     class Migration < ActiveRecord::Migration
 
       def self.up(table_name = Adyen::Notification::DEFAULT_TABLE_NAME)

data/lib/adyen/soap.rb

@@ -47,19 +47,18 @@ module Adyen
         klass.endpoint :version => 1, :uri => 'bogus'
       end
 
-      # Setup basic auth headers in the HTTP client
+      # Setup some CURL options to handle redirects correctly.
       def on_after_create_http_client(http_client)
-        debug { |logger| logger.puts "Authorization: #{Adyen::SOAP.username}:#{Adyen::SOAP.password}..." }
-        # Handsoap BUG: Setting headers does not work, using a Curb specific method for now.
-        # auth = Base64.encode64("#{Adyen::SOAP.username}:#{Adyen::SOAP.password}").chomp
-        # http_client.headers['Authorization'] = "Basic #{auth}"
-        http_client.userpwd = "#{Adyen::SOAP.username}:#{Adyen::SOAP.password}"
-        
-        # Setup some CURL options to handle redirects correctly.
         http_client.follow_location = true
         http_client.max_redirects   = 1
       end
 
+      # Setup basic authentication
+      def on_after_create_http_request(http_request)
+        debug { |logger| logger.puts "Authorization: #{Adyen::SOAP.username}:#{Adyen::SOAP.password}..." }
+        http_request.set_auth Adyen::SOAP.username, Adyen::SOAP.password
+      end
+
       # Setup XML namespaces for SOAP request body
       def on_create_document(doc)
         doc.alias 'payment',   'http://payment.services.adyen.com'
@@ -128,6 +127,22 @@ module Adyen
         end
       end
 
+      # Retrieves the recurring contracts for a shopper. Requires the following arguments:
+      #
+      # * <tt>:merchent_account</tt> The merchant account under which to place
+      #       this payment.
+      # * <tt>:shopper_reference</tt> The refrence of the shopper. This should be
+      #       the same as the reference that was used to create the recurring contract.
+      def list(args = {})
+        invoke_args = Adyen::SOAP.default_arguments.merge(args)
+        response = invoke('recurring:listRecurringDetails') do |message|
+          message.add('recurring:recurringRequest') do |req|
+            req.add('recurring:merchantAccount', invoke_args[:merchant_account])
+            req.add('recurring:shopperReference', invoke_args[:shopper_reference])
+          end
+        end
+      end
+
       # Deactivates a recurring payment contract. Requires the following arguments:
       #
       # * <tt>:merchent_account</tt> The merchant account under which to place

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: adyen
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-11 00:00:00 +01:00
+date: 2009-12-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency