buckaruby 1.0.0

data/lib/buckaruby/request.rb

@@ -0,0 +1,193 @@
+require 'bigdecimal'
+require 'cgi'
+require 'date'
+require 'logger'
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+module Buckaruby
+  # Base class for any request.
+  class Request
+    def initialize(options)
+      @options = options
+
+      @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+    end
+
+    def execute(options)
+      uri = URI.parse(api_url)
+      uri.query = "op=#{options[:operation]}" if options[:operation]
+
+      raw_response = post_buckaroo(uri, build_request_data(options))
+      response = parse_response(raw_response)
+
+      @logger.debug("[execute] response: #{response.inspect}")
+
+      return response
+    end
+
+    def build_request_params(_options)
+      raise NotImplementedError
+    end
+
+    private
+
+    def post_buckaroo(uri, params)
+      http = Net::HTTP.new(uri.host, uri.port)
+      if uri.scheme == "https"
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+
+      raw_response = http.post(uri.request_uri, post_data(params))
+      return raw_response.body
+    # Try to catch some common exceptions Net::HTTP might raise
+    rescue Errno::ETIMEDOUT, Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED, EOFError, IOError, SocketError,
+           Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::OpenTimeout, Net::ProtocolError, Net::ReadTimeout,
+           OpenSSL::SSL::SSLError => ex
+      raise ConnectionException, ex
+    end
+
+    def build_request_data(options)
+      params = { brq_websitekey: @options[:website] }
+
+      params.merge!(build_request_params(options))
+
+      params[:add_buckaruby] = "Buckaruby #{Buckaruby::VERSION}"
+
+      # Sign the data with our secret key.
+      params[:brq_signature] = Signature.generate_signature(params, @options)
+
+      return params
+    end
+
+    def post_data(params)
+      return params.map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+    end
+
+    def parse_response(body)
+      query = CGI.parse(body)
+      query.each { |key, value| query[key] = value.first }
+      return query
+    end
+
+    def test?
+      return @options[:mode] == :test
+    end
+
+    def api_url
+      return test? ? Urls::TEST_URL : Urls::PRODUCTION_URL
+    end
+  end
+
+  # Base class for a transaction request.
+  class TransactionRequest < Request
+    def execute(options)
+      super(options.merge(operation: Operation::TRANSACTION_REQUEST))
+    end
+
+    def build_request_params(options)
+      params = {
+        brq_payment_method: options[:payment_method],
+        brq_culture: options[:culture] || Language::DUTCH,
+        brq_currency: options[:currency] || Currency::EURO,
+        brq_amount: BigDecimal.new(options[:amount].to_s).to_s("F"),
+        brq_invoicenumber: options[:invoicenumber]
+      }
+
+      params.merge!(build_transaction_request_params(options))
+
+      params[:brq_clientip] = options[:client_ip] if options[:client_ip]
+      params[:brq_description] = options[:description] if options[:description]
+      params[:brq_return] = options[:return_url] if options[:return_url]
+
+      return params
+    end
+
+    def build_transaction_request_params(_options)
+      raise NotImplementedError
+    end
+  end
+
+  # Request for a creating a new transaction.
+  class SetupTransactionRequest < TransactionRequest
+    def execute(options)
+      super(options.merge(action: Action::PAY))
+    end
+
+    def build_transaction_request_params(options)
+      params = {}
+
+      case options[:payment_method]
+      when PaymentMethod::IDEAL
+        params.merge!(
+          brq_service_ideal_action: Action::PAY,
+          brq_service_ideal_issuer: options[:payment_issuer],
+          brq_service_ideal_version: "2"
+        )
+      when PaymentMethod::SEPA_DIRECT_DEBIT
+        params.merge!(
+          brq_service_sepadirectdebit_action: Action::PAY,
+          brq_service_sepadirectdebit_customeriban: options[:account_iban],
+          brq_service_sepadirectdebit_customeraccountname: options[:account_name],
+          brq_service_sepadirectdebit_collectdate: (Date.today + 5).strftime("%Y-%m-%d")
+        )
+
+        if options[:account_bic]
+          params[:brq_service_sepadirectdebit_customerbic] = options[:account_bic]
+        end
+
+        if options[:mandate_reference]
+          params.merge!(
+            brq_service_sepadirectdebit_action: [Action::PAY, Action::EXTRA_INFO].join(","),
+            brq_service_sepadirectdebit_mandatereference: options[:mandate_reference],
+            brq_service_sepadirectdebit_mandatedate: Date.today.strftime("%Y-%m-%d")
+          )
+        end
+      end
+
+      params[:brq_startrecurrent] = options[:recurring] if options[:recurring]
+
+      return params
+    end
+  end
+
+  # Request for a creating a recurrent transaction.
+  class RecurrentTransactionRequest < TransactionRequest
+    def execute(options)
+      super(options.merge(action: Action::PAY_RECURRENT))
+    end
+
+    def build_transaction_request_params(options)
+      params = {}
+
+      key = :"brq_service_#{options[:payment_method]}_action"
+      params[key] = Action::PAY_RECURRENT
+
+      # Indicate that this is a request without user redirection to a webpage.
+      # This is needed to make recurrent payments working.
+      params[:brq_channel] = "backoffice"
+
+      params[:brq_originaltransaction] = options[:transaction_id]
+
+      return params
+    end
+  end
+
+  # Request for getting the status of a transaction.
+  class StatusRequest < Request
+    def execute(options)
+      super(options.merge(operation: Operation::TRANSACTION_STATUS))
+    end
+
+    def build_request_params(options)
+      params = {}
+
+      params[:brq_transaction] = options[:transaction_id] if options[:transaction_id]
+      params[:brq_payment] = options[:payment_id] if options[:payment_id]
+
+      return params
+    end
+  end
+end

data/lib/buckaruby/response.rb

@@ -0,0 +1,198 @@
+require 'date'
+
+module Buckaruby
+  # Base class for any response.
+  class Response
+    attr_reader :params
+
+    def initialize(response, options)
+      @params = Support::CaseInsensitiveHash.new(response)
+
+      verify_signature!(response, options)
+    end
+
+    private
+
+    def verify_signature!(response, options)
+      if params[:brq_apiresult] != "Fail"
+        sent_signature = params[:brq_signature]
+        generated_signature = Signature.generate_signature(response, options)
+
+        if sent_signature != generated_signature
+          raise SignatureException, sent_signature, generated_signature
+        end
+      end
+    end
+  end
+
+  # Base class for a transaction response.
+  class TransactionResponse < Response
+    def account_bic
+      case payment_method
+      when PaymentMethod::IDEAL
+        return params[:brq_service_ideal_consumerbic]
+      when PaymentMethod::SEPA_DIRECT_DEBIT
+        return params[:brq_service_sepadirectdebit_customerbic]
+      end
+    end
+
+    def account_iban
+      case payment_method
+      when PaymentMethod::IDEAL
+        return params[:brq_service_ideal_consumeriban]
+      when PaymentMethod::SEPA_DIRECT_DEBIT
+        return params[:brq_service_sepadirectdebit_customeriban]
+      end
+    end
+
+    def account_name
+      case payment_method
+      when PaymentMethod::IDEAL
+        return params[:brq_service_ideal_consumername] || params[:brq_customer_name]
+      when PaymentMethod::SEPA_DIRECT_DEBIT
+        return params[:brq_service_sepadirectdebit_customername] || params[:brq_customer_name]
+      end
+    end
+
+    def collect_date
+      if payment_method == PaymentMethod::SEPA_DIRECT_DEBIT
+        return parse_date(params[:brq_service_sepadirectdebit_collectdate])
+      end
+    end
+
+    def invoicenumber
+      return params[:brq_invoicenumber]
+    end
+
+    def mandate_reference
+      if payment_method == PaymentMethod::SEPA_DIRECT_DEBIT
+        return params[:brq_service_sepadirectdebit_mandatereference]
+      end
+    end
+
+    def payment_id
+      return params[:brq_payment]
+    end
+
+    def payment_method
+      return parse_payment_method(params[:brq_payment_method] || params[:brq_transaction_method])
+    end
+
+    def redirect_url
+      return params[:brq_redirecturl]
+    end
+
+    def refund_transaction_id
+      return params[:brq_relatedtransaction_refund]
+    end
+
+    def reversal_transaction_id
+      return params[:brq_relatedtransaction_reversal]
+    end
+
+    def timestamp
+      return parse_time(params[:brq_timestamp])
+    end
+
+    def transaction_id
+      return params[:brq_transactions]
+    end
+
+    def transaction_type
+      if params[:brq_transaction_type] && !params[:brq_transaction_type].empty?
+        # See http://support.buckaroo.nl/index.php/Transactietypes
+        case params[:brq_transaction_type]
+        when 'C001', 'C002', 'C004', 'C021', 'C043', 'C044', 'C046', 'C090', 'V001', 'V002', 'V010', 'V021', 'V090'
+          return TransactionType::PAYMENT
+        when 'C005', 'V014', 'V031', 'V032', 'V034', 'V043', 'V044', 'V046', 'V094'
+          return TransactionType::PAYMENT_RECURRENT
+        when 'C079', 'C080', 'C082', 'C092', 'C101', 'C102', 'C121', 'C500', 'V067', 'V068', 'V070', 'V079', 'V080', 'V082', 'V092', 'V101', 'V102', 'V110'
+          return TransactionType::REFUND
+        when 'C501', 'C502', 'C562', 'V111', 'V131', 'V132', 'V134', 'V143', 'V144', 'V146'
+          return TransactionType::REVERSAL
+        end
+      else
+        # Fallback when transaction type is not known (cancelling credit card)
+        return TransactionType::PAYMENT
+      end
+    end
+
+    def transaction_status
+      # See http://support.buckaroo.nl/index.php/Statuscodes
+      case params[:brq_statuscode]
+      when '190'
+        return TransactionStatus::SUCCESS
+      when '490', '491', '492'
+        return TransactionStatus::FAILED
+      when '690'
+        return TransactionStatus::REJECTED
+      when '790', '791'
+        return TransactionStatus::PENDING
+      when '890', '891'
+        return TransactionStatus::CANCELLED
+      end
+    end
+
+    def to_h
+      hash = {
+        account_bic: account_bic,
+        account_iban: account_iban,
+        account_name: account_name,
+        collect_date: collect_date,
+        invoicenumber: invoicenumber,
+        mandate_reference: mandate_reference,
+        payment_id: payment_id,
+        payment_method: payment_method,
+        refund_transaction_id: refund_transaction_id,
+        reversal_transaction_id: reversal_transaction_id,
+        timestamp: timestamp,
+        transaction_id: transaction_id,
+        transaction_type: transaction_type,
+        transaction_status: transaction_status
+      }.reject { |_key, value| value.nil? }
+
+      return hash
+    end
+
+    private
+
+    def parse_date(date)
+      return date ? Date.strptime(date, '%Y-%m-%d') : nil
+    end
+
+    def parse_time(time)
+      return time ? Time.strptime(time, '%Y-%m-%d %H:%M:%S') : nil
+    end
+
+    def parse_payment_method(method)
+      return method ? method.downcase : nil
+    end
+  end
+
+  # Base class for a transaction response via the API.
+  class TransactionApiResponse < TransactionResponse
+    def initialize(response, options)
+      super(response, options)
+
+      if params[:brq_apiresult].nil? || params[:brq_apiresult] == "Fail"
+        raise ApiException, params
+      end
+    end
+  end
+
+  # Response when creating a new transaction.
+  class SetupTransactionResponse < TransactionApiResponse
+  end
+
+  # Response when creating a recurrent transaction.
+  class RecurrentTransactionResponse < TransactionApiResponse
+  end
+
+  # Response when getting the status of a transaction.
+  class StatusResponse < TransactionApiResponse
+  end
+
+  # Response when verifying the Buckaroo callback.
+  class CallbackResponse < TransactionResponse
+  end
+end

data/lib/buckaruby/signature.rb

@@ -0,0 +1,30 @@
+require 'digest'
+
+module Buckaruby
+  # Calculate a signature based on the parameters of the payment request or response.
+  # -> see BPE 3.0 Gateway NVP, chapter 4 'Digital Signature'
+  class Signature
+    def self.generate_signature(params, options)
+      secret = options[:secret]
+      hash_method = options[:hash_method]
+
+      case hash_method
+      when :sha1
+        return Digest::SHA1.hexdigest(generate_signature_string(params, secret))
+      when :sha256
+        return Digest::SHA256.hexdigest(generate_signature_string(params, secret))
+      when :sha512
+        return Digest::SHA512.hexdigest(generate_signature_string(params, secret))
+      else
+        raise ArgumentError, "Invalid hash method provided: #{hash_method}"
+      end
+    end
+
+    def self.generate_signature_string(params, secret)
+      sign_params = params.select { |key, _value| key.to_s.upcase.start_with?("BRQ_", "ADD_", "CUST_") && key.to_s.casecmp("BRQ_SIGNATURE").nonzero? }
+      string = sign_params.sort_by { |p| p.first.downcase }.map { |param| "#{param[0]}=#{param[1]}" }.join
+      string << secret
+      return string
+    end
+  end
+end

data/lib/buckaruby/support/case_insensitive_hash.rb

@@ -0,0 +1,35 @@
+module Buckaruby
+  module Support
+    # The case insensitive Hash is a Hash with case insensitive keys that
+    # can also be accessed by using a Symbol.
+    class CaseInsensitiveHash < Hash
+      def initialize(constructor = {})
+        if constructor.is_a?(Hash)
+          super()
+          update(constructor)
+        else
+          super(constructor)
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      protected
+
+      def update(hash)
+        hash.each_pair { |key, value| self[convert_key(key)] = value }
+      end
+
+      def convert_key(key)
+        string = key.is_a?(Symbol) ? key.to_s : key
+        return string.downcase
+      end
+    end
+  end
+end

data/lib/buckaruby/transaction_status.rb

@@ -0,0 +1,9 @@
+module Buckaruby
+  module TransactionStatus
+    SUCCESS = 1
+    FAILED = 2
+    REJECTED = 3
+    CANCELLED = 4
+    PENDING = 5
+  end
+end

data/lib/buckaruby/transaction_type.rb

@@ -0,0 +1,8 @@
+module Buckaruby
+  module TransactionType
+    PAYMENT = 1
+    PAYMENT_RECURRENT = 2
+    REFUND = 3
+    REVERSAL = 4
+  end
+end

data/lib/buckaruby/urls.rb

@@ -0,0 +1,6 @@
+module Buckaruby
+  module Urls
+    TEST_URL = "https://testcheckout.buckaroo.nl/nvp/"
+    PRODUCTION_URL = "https://checkout.buckaroo.nl/nvp/"
+  end
+end

data/lib/buckaruby/version.rb

@@ -0,0 +1,3 @@
+module Buckaruby
+  VERSION = "1.0.0"
+end

data/lib/buckaruby.rb

@@ -0,0 +1,20 @@
+require_relative 'buckaruby/support/case_insensitive_hash'
+
+require_relative 'buckaruby/action'
+require_relative 'buckaruby/currency'
+require_relative 'buckaruby/ideal'
+require_relative 'buckaruby/language'
+require_relative 'buckaruby/operation'
+require_relative 'buckaruby/payment_method'
+require_relative 'buckaruby/transaction_status'
+require_relative 'buckaruby/transaction_type'
+require_relative 'buckaruby/urls'
+
+require_relative 'buckaruby/exception'
+require_relative 'buckaruby/gateway'
+require_relative 'buckaruby/iban'
+require_relative 'buckaruby/request'
+require_relative 'buckaruby/response'
+require_relative 'buckaruby/signature'
+
+require_relative 'buckaruby/version'