adyen 1.6.0 → 2.0.0.pre1

data/lib/adyen/matchers.rb

@@ -21,7 +21,7 @@ module Adyen
 
         # Add a check for all the other fields specified
         checks.each do |key, value|
-          condition  = "\n  descendant::input[@type='hidden'][@name='#{Adyen::Form.camelize(key)}']"
+          condition  = "\n  descendant::input[@type='hidden'][@name='#{Adyen::Util.camelize(key)}']"
           condition << "[@value='#{value}']" unless value == :anything
           xpath_query << "[#{condition}]"
         end

data/lib/adyen/rest.rb

@@ -0,0 +1,53 @@
+require 'adyen'
+require 'adyen/rest/client'
+
+module Adyen
+
+  # The Adyen::REST module allows you to interact with Adyen's REST API.
+  #
+  # The primary method here is {Adyen::REST.session}, which will yield a
+  # {Adyen::REST::Client} which you can use to send API requests.
+  #
+  # @example
+  #
+  #     Adyen::REST.session do |client|
+  #       client.http.read_timeout = 5
+  #       response = client.api_request(...)
+  #       # ...
+  #     end
+  #
+  # @see Adyen::REST.session Use Adyen::REST.session to run code against the API.
+  # @see Adyen::REST::Client Adyen::REST::Client implements the actual API calls.
+  module REST
+
+    # Provides a REST API client this is configured using the values in <tt>Adyen.configuration</tt>.
+    # @param options [Hash] (see Adyen::REST::Client#initialize)
+    # @return [Adyen::REST::Client] A configured client instance
+    # @see .session
+    def self.client
+      Adyen::REST::Client.new(
+        Adyen.configuration.environment,
+        Adyen.configuration.api_username,
+        Adyen.configuration.api_password
+      )
+    end
+
+    # Exectutes a session against the Adyen REST API.
+    #
+    # It will use a standard client from {Adyen::REST.client}, or it uses a provided client.
+    # The client will be yielded to the block, and will be closed after the block is finisged
+    #
+    # @param client [Adyen::REST::Client] A custom API client if a default one won't do.
+    # @yield The provided block will be called in which you can interact with the API using
+    #   the provided client. The client will be closed after the block returns.
+    # @yieldparam client [Adyen::REST::Client] The REST client to use for the session.
+    # @return [void]
+    # @see Adyen::REST::Client
+    def self.session(client = nil)
+      client ||= self.client
+      yield(client)
+    ensure
+      client.close
+    end
+  end
+end

data/lib/adyen/rest/authorise_payment.rb

@@ -0,0 +1,148 @@
+module Adyen
+  module REST
+
+    # This module implements the <b>Payment.authorise</b>, and <b>Payment.authorise3d</b>
+    # API calls, and includes a custom response class to make handling the response easier.
+    module AuthorisePayment
+
+      class Request < Adyen::REST::Request
+
+        def set_amount(currency, value)
+          self['amount'] = { currency: currency, value: value }
+        end
+
+        def set_encrypted_card_data(source)
+          encrypted_json = if source.respond_to?(:params)
+            source.params['adyen-encrypted-data']
+          elsif source.respond_to?(:[]) && source.key?('adyen-encrypted-data')
+            source['adyen-encrypted-data']
+          else
+            source
+          end
+
+          self['additional_data.card.encrypted.json'] = encrypted_json
+        end
+
+        def set_browser_info(request)
+          self['shopper_ip']                 = request.ip
+          self['browser_info.accept_header'] = request['Accept'] || "text/html;q=0.9,*/*",
+          self['browser_info.user_agent']    = request.user_agent
+        end
+
+        def set_3d_secure_parameters(request)
+          set_browser_info(request)
+          self['pa_response'] = request.params['PaRes']
+          self['md']          = request.params['MD']
+        end
+      end
+
+      # The Response class implements some extensions for the authorise payment call.
+      # @see Adyen::REST::Response
+      class Response < Adyen::REST::Response
+
+        # Checks whether the authorisation was successful.
+        # @return [Boolean] <tt>true</tt> iff the authorisation was successful, and the
+        #   authorised amount can be captured.
+        def authorised?
+          result_code == AUTHORISED
+        end
+
+        alias_method :authorized?, :authorised?
+
+        # Check whether the payment was refused.
+        # @return [Boolean] <tt>true</tt> iff the authorisation was not successful.
+        def refused?
+          result_code == REFUSED
+        end
+
+        # Checks whether the result of the authorization call was RedirectShopper,
+        # which means that the customer has to be redirected away from your site to
+        # complete the 3Dsecure transaction.
+        # @return [Boolean] <tt>true</tt> iff the shopper has to be redirected,
+        #   <tt>false</tt> in any other case.
+        def redirect_shopper?
+          result_code == REDIRECT_SHOPPER
+        end
+
+        # Returns the result code from the transaction.
+        # @return [String] The result code.
+        # @see #authorised?
+        # @see #refused?
+        # @see #redirect_shopper?
+        def result_code
+          self[:result_code]
+        end
+
+        private
+
+        AUTHORISED       = 'Authorised'.freeze
+        REFUSED          = 'Refused'.freeze
+        REDIRECT_SHOPPER = 'RedirectShopper'.freeze
+        private_constant :AUTHORISED, :REFUSED, :REDIRECT_SHOPPER
+      end
+
+      # Generates <tt>Payment.authorise</tt> request for Adyen's webservice.
+      # @param (see #authorise_payment)
+      # @return [Adyen::REST::Request] The request to send
+      # @see #authorise_payment
+      def authorise_payment_request(attributes = {})
+        Adyen::REST::AuthorisePayment::Request.new('Payment.authorise', attributes,
+            prefix: 'payment_request',
+            response_class: Adyen::REST::AuthorisePayment::Response,
+            response_options: { prefix: 'payment_result' })
+      end
+
+      # Sends an authorise payment request to Adyen's webservice.
+      # @param attributes [Hash] The attributes to include in the request.
+      # @return [Adyen::REST::AuthorisePayment::Response] The response from Adyen.
+      #   The response responds to <tt>.authorised?</tt> to check whether the
+      #   authorization was successful.
+      # @see Adyen::REST::AuthorisePayment::Response#authorised?
+      def authorise_payment(attributes)
+        request = authorise_payment_request(attributes)
+        execute_request(request)
+      end
+
+      # Generates a <tt>Payment.authorise3d</tt> request to Adyen's webservice.
+      #
+      # The response differs based on the credit card uses in the transaction.
+      # For some credit cards, an additional offsite step may be required to complete
+      # the transaction. Check <tt>.redirect_shopper?</tt> to see if this is the case.
+      # Other cards are not 3DSecure-enabled, and may immediately authorise the
+      # transaction. Check <tt>.authorised?</tt> to see if this is the case.
+      #
+      # @param attributes [Hash] The attributes to include in the request.
+      # @return [Adyen::REST::AuthorisePayment::Response] The response from Adyen.
+      # @see Adyen::REST::AuthorisePayment::Response#redirect_shopper?
+      # @see Adyen::REST::AuthorisePayment::Response#authorised?
+      def authorise_payment_3dsecure_request(attributes = {})
+        Adyen::REST::AuthorisePayment::Request.new('Payment.authorise3d', attributes,
+            prefix: 'payment_request_3d',
+            response_class: Adyen::REST::AuthorisePayment::Response,
+            response_options: { prefix: 'payment_result' })
+      end
+
+      # Sends a 3Dsecure-enabled authorise payment request to Adyen's webservice.
+      #
+      # The response differs based on the credit card uses in the transaction.
+      # For some credit cards, an additional offsite step may be required to complete
+      # the transaction. Check <tt>.redirect_shopper?</tt> to see if this is the case.
+      # Other cards are not 3DSecure-enabled, and may immediately authorise the
+      # transaction. Check <tt>.authorised?</tt> to see if this is the case.
+      #
+      # @param attributes [Hash] The attributes to include in the request.
+      # @return [Adyen::REST::AuthorisePayment::Response] The response from Adyen.
+      # @see Adyen::REST::AuthorisePayment::Response#redirect_shopper?
+      # @see Adyen::REST::AuthorisePayment::Response#authorised?
+      def authorise_payment_3dsecure(attributes)
+        request = authorise_payment_3dsecure_request(attributes)
+        execute_request(request)
+      end
+
+      alias_method :authorize_payment_request, :authorise_payment_request
+      alias_method :authorize_payment, :authorise_payment
+      alias_method :authorize_payment_3dsecure_request, :authorise_payment_3dsecure_request
+      alias_method :authorize_payment_3dsecure, :authorise_payment_3dsecure
+    end
+  end
+end

data/lib/adyen/rest/client.rb

@@ -0,0 +1,110 @@
+require 'cgi'
+require 'net/http'
+
+require 'adyen/rest/errors'
+require 'adyen/rest/request'
+require 'adyen/rest/response'
+require 'adyen/rest/authorise_payment'
+require 'adyen/rest/modify_payment'
+
+module Adyen
+  module REST
+
+    # The Client class acts as a client to Adyen's REST webservice.
+    #
+    # @!attribute environment [r]
+    #   The adyen environment to interact with. Either <tt>'live'</tt> or <tt>'test'</tt>.
+    #   @return [String]
+    class Client
+      include AuthorisePayment
+      include ModifyPayment
+
+      attr_reader :environment
+
+      # @param environment [String] The Adyen environment to interface with. Either
+      #   <tt>'live'</tt> or <tt>'test'</tt>.
+      # @param username [String] The webservice username, e.g. <tt>ws@Company.Account</tt>
+      # @param password [String] The password associated with the username
+      def initialize(environment, username, password)
+        @environment, @username, @password = environment, username, password
+      end
+
+      # Closes the client.
+      #
+      # - This will terminate the HTTP connection.
+      # - After calling this method, the behavior of any further method calls against
+      #   this client instance is undefined.
+      #
+      # @return [void]
+      def close
+        @http.finish if @http && @http.started?
+        @http = nil
+      end
+
+      # The underlying <tt>Net::HTTP</tt> instance that is used to execute HTTP
+      # request against the API.
+      #
+      # You can use this to set options on the Net::HTTP instance, like <tt>read_timeout</tt>.
+      # Many of these options will only work if you set them before the HTTP connection is
+      # opened, i.e. before doing the first API call.
+      #
+      # @return [Net::HTTP] The underlying Net::HTTP instance the client uses to perform HTTP request.
+      def http
+        @http ||= Net::HTTP.new(endpoint.host, endpoint.port).tap do |http|
+          http.use_ssl = endpoint.scheme == 'https'
+        end
+      end
+
+      # Executes an API request, and returns a reponse of the given type.
+      #
+      # @param request [Adyen::REST::Request] The API request to execute.
+      #   <tt>validate!</tt> will be called on the this object before the
+      #   request is made.
+      # @param response_type [Class] The response type to use. Use either
+      #   <tt>Adyen::REST::Response</tt> or a subclass.
+      # @return [Adyen::REST::Response] A response instance of the provided type
+      # @see execute_http_request The <tt>execute_http_request</tt> takes care
+      #   of  executing the underlying HTTP request.
+      def execute_request(request)
+        request.validate!
+        http_response = execute_http_request(request)
+        request.build_response(http_response)
+      end
+
+      protected
+
+      # Executes a HTTP request against Adyen's REST webservice.
+      # @param request [Adyen::REST::Request] The request to execute.
+      # @return [Net::HTTPResponse] The response from the server.
+      # @raise [Adyen::REST::Error] if the HTTP response code was not 200.
+      # @see #http Use the <tt>http</tt> method to set options on the underlying
+      #   <tt>Net::HTTP</tt> object, like timeouts.
+      def execute_http_request(request)
+        http_request = Net::HTTP::Post.new(endpoint.path)
+        http_request.basic_auth(@username, @password)
+        http_request.set_form_data(request.form_data)
+
+        case response = http.request(http_request)
+        when Net::HTTPOK
+          return response
+        when Net::HTTPInternalServerError
+          raise Adyen::REST::ResponseError.new(response.body)
+        when Net::HTTPUnauthorized
+          raise Adyen::REST::Error.new("Webservice credentials are incorrect")
+        else
+          raise Adyen::REST::Error.new("Unexpected HTTP response: #{response.code}")
+        end
+      end
+
+      # The endpoint URI for this client.
+      # @return [URI] The endpoint to use for the environment.
+      def endpoint
+        @endpoint ||= URI(ENDPOINT % [environment])
+      end
+
+      # @see Adyen::REST::Client#endpoint
+      ENDPOINT = 'https://pal-%s.adyen.com/pal/adapter/httppost'
+      private_constant :ENDPOINT
+    end
+  end
+end

data/lib/adyen/rest/errors.rb

@@ -0,0 +1,33 @@
+module Adyen
+  module REST
+
+    # The main exception class for error reporting when using the REST API Client.
+    class Error < ::StandardError
+    end
+
+    # Exception class for errors on requests
+    class RequestValidationFailed < Error
+    end
+
+    # Exception class for error responses from the Adyen API.
+    #
+    # @!attribute category
+    #    @return [String, nil]
+    # @!attribute code
+    #    @return [Integer, nil]
+    # @!attribute description
+    #    @return [String, nil]
+    class ResponseError < Error
+      attr_accessor :category, :code, :description
+
+      def initialize(response_body)
+        if match = /\A(\w+)\s(\d+)\s(.*)\z/.match(response_body)
+          @category, @code, @description = match[1], match[2].to_i, match[3]
+          super("API request error: #{description} (code: #{code}/#{category})")
+        else
+          super("API request error: #{response_body}")
+        end
+      end
+    end
+  end
+end

data/lib/adyen/rest/modify_payment.rb

@@ -0,0 +1,97 @@
+module Adyen
+  module REST
+
+    # This module implements the <b>Payment.capture</b> API to capture
+    # previously authorised payments.
+    module ModifyPayment
+      class Request < Adyen::REST::Request
+        def set_modification_amount(currency, value)
+          self['modification_amount'] = { currency: currency, value: value }
+        end
+
+        alias_method :set_amount, :set_modification_amount
+      end
+
+      class Response < Adyen::REST::Response
+        attr_reader :expected_response
+
+        def initialize(http_response, options = {})
+          super
+          @expected_response = options[:expects]
+        end
+
+        def received?
+          self[:response] == expected_response
+        end
+      end
+
+      # Constructs and issues a Payment.capture API call.
+      def capture_payment(attributes = {})
+        request = capture_payment_request(attributes)
+        execute_request(request)
+      end
+
+      def capture_payment_request(attributes = {})
+        Adyen::REST::ModifyPayment::Request.new('Payment.capture', attributes,
+          prefix: 'modification_request',
+          response_class: Adyen::REST::ModifyPayment::Response,
+          response_options: {
+            prefix: 'modification_result',
+            expects: '[capture-received]'
+          }
+        )
+      end
+
+      # Constructs and issues a Payment.cancel API call.
+      def cancel_payment(attributes = {})
+        request = cancel_payment_request(attributes)
+        execute_request(request)
+      end
+
+      def cancel_payment_request(attributes = {})
+        Adyen::REST::ModifyPayment::Request.new('Payment.cancel', attributes,
+          prefix: 'modification_request',
+          response_class: Adyen::REST::ModifyPayment::Response,
+          response_options: {
+            prefix: 'modification_result',
+            expects: '[cancel-received]'
+          }
+        )
+      end
+
+      # Constructs and issues a Payment.cancel API call.
+      def refund_payment(attributes = {})
+        request = refund_payment_request(attributes)
+        execute_request(request)
+      end
+
+      def refund_payment_request(attributes = {})
+        Adyen::REST::ModifyPayment::Request.new('Payment.refund', attributes,
+          prefix: 'modification_request',
+          response_class: Adyen::REST::ModifyPayment::Response,
+          response_options: {
+            prefix: 'modification_result',
+            expects: '[refund-received]'
+          }
+        )
+      end
+
+      # Constructs and issues a Payment.cancel API call.
+      def cancel_or_refund_payment(attributes = {})
+        request = cancel_or_refund_payment_request(attributes)
+        execute_request(request)
+      end
+
+      def cancel_or_refund_payment_request(attributes = {})
+        Adyen::REST::ModifyPayment::Request.new('Payment.cancelOrRefund', attributes,
+          prefix: 'modification_request',
+          response_class: Adyen::REST::ModifyPayment::Response,
+          response_options: {
+            prefix: 'modification_result',
+            expects: '[cancelOrRefund-received]'
+          }
+        )
+      end
+    end
+  end
+end