adyen_jpiqueras 2.3.0

data/lib/adyen/templates/notification_migration.rb

@@ -0,0 +1,29 @@
+# @private
+class CreateAdyenNotifications < ActiveRecord::Migration
+  
+  def self.up
+    create_table :adyen_notifications do |t|
+      t.boolean  :live,                  :null => false, :default => false
+      t.string   :event_code,            :null => false, :limit => 40
+      t.string   :psp_reference,         :null => false, :limit => 50
+      t.string   :original_reference,    :null => true
+      t.string   :merchant_reference,    :null => false
+      t.string   :merchant_account_code, :null => false
+      t.datetime :event_date,            :null => false
+      t.boolean  :success,               :null => false, :default => false
+      t.string   :payment_method,        :null => true
+      t.string   :operations,            :null => true
+      t.text     :reason,                :null => true
+      t.string   :currency,              :null => true, :limit => 3
+      t.integer  :value,                 :null => true
+      t.boolean  :processed,             :null => false, :default => false
+      t.timestamps
+    end
+     
+    add_index :adyen_notifications, [:merchant_account_code, :psp_reference, :event_code, :success], :unique => true, :name => 'adyen_notification_uniqueness'
+  end
+
+  def self.down
+    drop_table :adyen_notifications
+  end
+end

data/lib/adyen/templates/notification_model.rb

@@ -0,0 +1,69 @@
+# The +AdyenNotification+ 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, +AdyenNotification+ 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 = AdyenNotification.log(request)
+#    if @notification.successful_authorisation?
+#      @invoice = Invoice.find(@notification.merchant_reference)
+#      @invoice.set_paid!
+#    end
+class AdyenNotification < ActiveRecord::Base
+  # 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
+  # [:merchant_account_code, :psp_reference, :event_code, :success]
+  validates_uniqueness_of :success, :scope => [:merchant_account_code, :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)
+    # Assign explicit each attribute from CamelCase notation to notification
+    # For example, merchantReference will be converted to merchant_reference
+    self.new.tap do |notification|
+      params.each do |key, value|
+        setter = "#{key.to_s.underscore}="
+        notification.send(setter, value) if notification.respond_to?(setter)
+      end
+
+      notification.save!
+    end
+  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_method :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?
+    authorisation? && success?
+  end
+
+  alias_method :successful_authorization?, :successful_authorisation?
+end

data/lib/adyen/util.rb

@@ -0,0 +1,147 @@
+require 'date'
+require 'openssl'
+require 'base64'
+
+module Adyen
+  module Util
+    extend self
+
+    # Returns a valid Adyen string representation for a date
+    def format_date(date)
+      case date
+      when Date, DateTime, Time
+        date.strftime('%Y-%m-%d')
+      when String
+        raise ArgumentError, "Invalid date notation: #{date.inspect}!" unless /^\d{4}-\d{2}-\d{2}$/ =~ date
+        date
+      else
+        raise ArgumentError, "Cannot convert #{date.inspect} to date!"
+      end
+    end
+
+    # Returns a valid Adyen string representation for a timestamp
+    def format_timestamp(time)
+      case time
+      when Date, DateTime, Time
+        time.strftime('%Y-%m-%dT%H:%M:%SZ')
+      when String
+        raise ArgumentError, "Invalid timestamp notation: #{time.inspect}!" unless /^\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}Z$/ =~ time
+        time
+      else
+        raise ArgumentError, "Cannot convert #{time.inspect} to timestamp!"
+      end
+    end
+
+    # Returns a base64-encoded signature for a message
+    # @param [String] hmac_key The secret key to use for the HMAC signature.
+    # @param [String] message The message to sign.
+    # @return [String] The signature, base64-encoded.
+    def hmac_base64(hmac_key, message)
+      digest = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha1'), hmac_key, message)
+      Base64.strict_encode64(digest).strip
+    end
+
+    # Retuns a message gzip-compressed and base64-encoded.
+    # @param [String] message The message to compress and encode.
+    # @return [String] The compressed and encoded version of the message
+    def gzip_base64(message)
+      sio = StringIO.new
+      gz  = Zlib::GzipWriter.new(sio)
+      gz.write(message)
+      gz.close
+      Base64.strict_encode64(sio.string)
+    end
+
+    # Returns the camelized version of a string.
+    # @param [:to_s] identifier The identifier to turn to camelcase.
+    # @return [String] The camelcase version of the identifier provided.
+    def camelize(identifier)
+      CAMELCASE_EXCEPTIONS[identifier.to_s] || identifier.to_s.gsub(/_+(.)/) { $1.upcase }
+    end
+
+    # Returns the underscore version of a string.
+    # @param [:to_s] identifier The identifier to turn to underscore notation.
+    # @return [String] The underscore version of the identifier provided.
+    def underscore(identifier)
+      UNDERSCORE_EXCEPTIONS[identifier.to_s] || identifier.to_s
+        .gsub(/([A-Z]{2,})([A-Z])/) { "#{$1.downcase}#{$2}" }
+        .gsub(/(?!\A)([A-Z][a-z]*)/, '_\1')
+        .downcase
+    end
+
+    # Transforms the nested parameters Hash into a 'flat' Hash which is understood by adyen. This is:
+    #  * all keys are camelized
+    #  * all keys are stringified
+    #  * nested hash is flattened, keys are prefixed with root key
+    #
+    # @example
+    #    flatten {:billing_address => { :street => 'My Street'}}
+    #
+    #    # resolves in:
+    #    {'billingAddress.street' =>  'My Street'}
+    #
+    # @param [Hash] nested_hash The nested hash to transform
+    # @param [String] prefix The prefix to add to the key
+    # @param [Hash] return_hash The new hash which is retruned (needed for recursive calls)
+    # @return [Hash] The return hash filled with camelized and prefixed key, stringified value
+    def flatten(nested_hash, prefix = "", return_hash = {})
+      nested_hash ||= {}
+      nested_hash.inject(return_hash) do |hash, (key, value)|
+        key = "#{prefix}#{camelize(key)}"
+        if value.is_a?(Hash)
+          flatten(value, "#{key}.", return_hash)
+        else
+          hash[key] = value.to_s
+        end
+        hash
+      end
+    end
+
+    # Transforms a flat hash into a nested hash structure.
+    #  * all keys are underscored
+    #  * all keys are stringified
+    #  * flattened hash is deflattened, using . as namespace separator
+    #
+    # @example
+    #    deflatten {'billingAddress.street' =>  'My Street'}
+    #
+    #    # resolves in:
+    #    {'billing_address' => { 'street' => 'My Street'}}
+    #
+    # @param [Hash] flattened_hash The flat hash to transform
+    # @param [Hash] return_hash The new hash which will be returned (needed for recursive calls)
+    # @return [Hash] A nested hash structure, using strings as key.
+    def deflatten(flattened_hash, return_hash = {})
+      return return_hash if flattened_hash.nil?
+      flattened_hash.each do |key, value|
+        deflatten_pair(key, value, return_hash)
+      end
+      return_hash
+    end
+
+    private
+
+    def deflatten_pair(key, value, return_hash)
+      head, rest = key.split('.', 2)
+      key = underscore(head)
+      if rest.nil?
+        raise ArgumentError, "Duplicate key in flattened hash." if return_hash.key?(key)
+        return_hash[key] = value
+      else
+        return_hash[key] ||= {}
+        raise ArgumentError, "Key nesting conflict in flattened hash." unless return_hash[key].is_a?(Hash)
+        deflatten_pair(rest, value, return_hash[key])
+      end
+    end
+
+    # This hash contains exceptions to the standard underscore to camelcase conversion rules.
+    CAMELCASE_EXCEPTIONS = {
+      'shopper_ip' => 'shopperIP'
+    }
+
+    # This hash contains exceptions to the standard camelcase to underscore conversion rules.
+    UNDERSCORE_EXCEPTIONS = CAMELCASE_EXCEPTIONS.invert
+
+    private_constant :CAMELCASE_EXCEPTIONS, :UNDERSCORE_EXCEPTIONS
+  end
+end

data/lib/adyen/version.rb

@@ -0,0 +1,5 @@
+module Adyen
+  # Version constant for the Adyen plugin.
+  # Set it & commit the change before running rake release.
+  VERSION = "2.3.0"
+end

data/spec/api/api_spec.rb

@@ -0,0 +1,231 @@
+# encoding: UTF-8
+require 'api/spec_helper'
+
+describe Adyen::API do
+  include APISpecHelper
+
+  describe "shortcut methods" do
+    describe "for the PaymentService" do
+      before do
+        @payment = double('PaymentService')
+      end
+
+      def should_map_shortcut_to(method, params)
+        Adyen::API::PaymentService.should_receive(:new).with(params).and_return(@payment)
+        @payment.should_receive(method)
+      end
+
+      it "performs a `authorise payment' request without enabling :recurring" do
+        should_map_shortcut_to(:authorise_payment,
+          :reference => 'order-id',
+          :amount => { :currency => 'EUR', :value => 1234 },
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :card => { :expiry_month => 12, :expiry_year => 2012, :holder_name => "Simon Hopper", :number => '4444333322221111', :cvc => '737' },
+          :recurring => false,
+          :fraud_offset => nil,
+          :instant_capture => false
+        )
+        Adyen::API.authorise_payment('order-id',
+          { :currency => 'EUR', :value => 1234 },
+          { :reference => 'user-id', :email => 's.hopper@example.com' },
+          { :expiry_month => 12, :expiry_year => 2012, :holder_name => "Simon Hopper", :number => '4444333322221111', :cvc => '737' }
+        )
+      end
+
+      it "performs a `authorise payment' request with additional :fraud_offset" do
+        should_map_shortcut_to(:authorise_payment,
+          :reference => 'order-id',
+          :amount => { :currency => 'EUR', :value => 1234 },
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :card => { :expiry_month => 12, :expiry_year => 2012, :holder_name => "Simon Hopper", :number => '4444333322221111', :cvc => '737' },
+          :recurring => false,
+          :fraud_offset => -100,
+          :instant_capture => false
+        )
+        Adyen::API.authorise_payment('order-id',
+          { :currency => 'EUR', :value => 1234 },
+          { :reference => 'user-id', :email => 's.hopper@example.com' },
+          { :expiry_month => 12, :expiry_year => 2012, :holder_name => "Simon Hopper", :number => '4444333322221111', :cvc => '737' },
+          false,
+          -100,
+          false
+        )
+      end
+
+      it "performs a `authorise payment' request with enabling :recurring" do
+        should_map_shortcut_to(:authorise_payment,
+          :reference => 'order-id',
+          :amount => { :currency => 'EUR', :value => 1234 },
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :card => { :expiry_month => 12, :expiry_year => 2012, :holder_name => "Simon Hopper", :number => '4444333322221111', :cvc => '737' },
+          :recurring => true,
+          :fraud_offset => nil,
+          :instant_capture => false,
+        )
+        Adyen::API.authorise_payment('order-id',
+          { :currency => 'EUR', :value => 1234 },
+          { :reference => 'user-id', :email => 's.hopper@example.com' },
+          { :expiry_month => 12, :expiry_year => 2012, :holder_name => "Simon Hopper", :number => '4444333322221111', :cvc => '737' },
+          true,
+          nil,
+          false
+        )
+      end
+
+      it "performs a `authorise recurring payment' request without specific detail" do
+        should_map_shortcut_to(:authorise_recurring_payment,
+          :reference => 'order-id',
+          :amount => { :currency => 'EUR', :value => 1234 },
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :recurring_detail_reference => 'LATEST',
+          :instant_capture => false,
+          :fraud_offset => nil
+        )
+        Adyen::API.authorise_recurring_payment('order-id',
+          { :currency => 'EUR', :value => 1234 },
+          { :reference => 'user-id', :email => 's.hopper@example.com' }
+        )
+      end
+
+      it "performs a `authorise recurring payment' request with specific detail" do
+        should_map_shortcut_to(:authorise_recurring_payment,
+          :reference => 'order-id',
+          :amount => { :currency => 'EUR', :value => 1234 },
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :recurring_detail_reference => 'recurring-detail-reference',
+          :instant_capture => false,
+          :fraud_offset => nil
+        )
+        Adyen::API.authorise_recurring_payment('order-id',
+          { :currency => 'EUR', :value => 1234 },
+          { :reference => 'user-id', :email => 's.hopper@example.com' },
+          'recurring-detail-reference'
+        )
+      end
+
+      it "performs a `authorise recurring payment' request with specific detail and fraud offset" do
+        should_map_shortcut_to(:authorise_recurring_payment,
+          :reference => 'order-id',
+          :amount => { :currency => 'EUR', :value => 1234 },
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :recurring_detail_reference => 'recurring-detail-reference',
+          :fraud_offset => 50,
+          :instant_capture => false
+        )
+        Adyen::API.authorise_recurring_payment('order-id',
+          { :currency => 'EUR', :value => 1234 },
+          { :reference => 'user-id', :email => 's.hopper@example.com' },
+          'recurring-detail-reference',
+          50,
+          false
+        )
+      end
+
+      it "performs a `authorise one-click payment' request with specific detail" do
+        should_map_shortcut_to(:authorise_one_click_payment,
+          :reference => 'order-id',
+          :amount => { :currency => 'EUR', :value => 1234 },
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :card => { :cvc => '737' },
+          :recurring_detail_reference => 'recurring-detail-reference',
+          :fraud_offset => nil,
+          :instant_capture => false
+        )
+        Adyen::API.authorise_one_click_payment('order-id',
+          { :currency => 'EUR', :value => 1234 },
+          { :reference => 'user-id', :email => 's.hopper@example.com' },
+          { :cvc => '737' },
+          'recurring-detail-reference'
+        )
+      end
+
+      it "performs a `authorise one-click payment' request with specific detail and fraud offset" do
+        should_map_shortcut_to(:authorise_one_click_payment,
+          :reference => 'order-id',
+          :amount => { :currency => 'EUR', :value => 1234 },
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :card => { :cvc => '737' },
+          :recurring_detail_reference => 'recurring-detail-reference',
+          :fraud_offset => -10,
+          :instant_capture => false,
+        )
+        Adyen::API.authorise_one_click_payment('order-id',
+          { :currency => 'EUR', :value => 1234 },
+          { :reference => 'user-id', :email => 's.hopper@example.com' },
+          { :cvc => '737' },
+          'recurring-detail-reference',
+          -10,
+          false
+        )
+      end
+
+      it "performs a `capture' request" do
+        should_map_shortcut_to(:capture, :psp_reference => 'original-psp-reference', :amount => { :currency => 'EUR', :value => '1234' })
+        Adyen::API.capture_payment('original-psp-reference', { :currency => 'EUR', :value => '1234' })
+      end
+
+      it "performs a `refund payment' request" do
+        should_map_shortcut_to(:refund, :psp_reference => 'original-psp-reference', :amount => { :currency => 'EUR', :value => '1234' })
+        Adyen::API.refund_payment('original-psp-reference', { :currency => 'EUR', :value => '1234' })
+      end
+
+      it "performs a `cancel or refund payment' request" do
+        should_map_shortcut_to(:cancel_or_refund, :psp_reference => 'original-psp-reference')
+        Adyen::API.cancel_or_refund_payment('original-psp-reference')
+      end
+
+      it "performs a `cancel payment' request" do
+        should_map_shortcut_to(:cancel, :psp_reference => 'original-psp-reference')
+        Adyen::API.cancel_payment('original-psp-reference')
+      end
+    end
+
+    describe "for the RecurringService" do
+      before do
+        @recurring = double('RecurringService')
+      end
+
+      def should_map_shortcut_to(method, params)
+        Adyen::API::RecurringService.should_receive(:new).with(params).and_return(@recurring)
+        @recurring.should_receive(method)
+      end
+
+      it "performs a `tokenize creditcard details' request" do
+        should_map_shortcut_to(:store_token,
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :card => { :expiry_month => 12, :expiry_year => 2012, :holder_name => "Simon Hopper", :number => '4444333322221111' }
+        )
+        Adyen::API.store_recurring_token(
+          { :reference => 'user-id', :email => 's.hopper@example.com' },
+          { :expiry_month => 12, :expiry_year => 2012, :holder_name => "Simon Hopper", :number => '4444333322221111' }
+        )
+      end
+
+      it "performs a `tokenize ELV details' request" do
+        should_map_shortcut_to(:store_token,
+          :shopper => { :reference => 'user-id', :email => 's.hopper@example.com' },
+          :elv => { :bank_location => "Berlin", :bank_name => "TestBank", :bank_location_id => "12345678", :holder_name => "Simon Hopper", :number => "1234567890" }
+        )
+        Adyen::API.store_recurring_token(
+          { :reference => 'user-id', :email => 's.hopper@example.com' },
+          { :bank_location => "Berlin", :bank_name => "TestBank", :bank_location_id => "12345678", :holder_name => "Simon Hopper", :number => "1234567890" }
+        )
+      end
+
+      it "preforms a `list recurring details' request" do
+        should_map_shortcut_to(:list, :shopper => { :reference => 'user-id' })
+        Adyen::API.list_recurring_details('user-id')
+      end
+
+      it "performs a `disable recurring contract' request for all details" do
+        should_map_shortcut_to(:disable, :shopper => { :reference => 'user-id' }, :recurring_detail_reference => nil)
+        Adyen::API.disable_recurring_contract('user-id')
+      end
+
+      it "performs a `disable recurring contract' request for a specific detail" do
+        should_map_shortcut_to(:disable, :shopper => { :reference => 'user-id' }, :recurring_detail_reference => 'detail-id')
+        Adyen::API.disable_recurring_contract('user-id', 'detail-id')
+      end
+    end
+  end
+end