buckaruby 1.7.0 → 2.0.1

data/lib/buckaruby/gateway.rb

@@ -1,29 +1,21 @@
 # frozen_string_literal: true
 
-require 'bigdecimal'
+require 'forwardable'
 
 module Buckaruby
   # Implementation of the BPE 3.0 NVP Gateway.
   class Gateway
-    class << self
-      # Buckaroo mode can be set as class setting
-      attr_accessor :mode
-    end
+    extend Forwardable
 
-    attr_reader :config
+    def_delegators :config, :logger
 
     def initialize(options = {})
-      @config = Configuration.new(options)
-      @logger = config.logger
+      @options = options
     end
 
     # Returns the payment methods enabled by Buckaroo and supported by this library.
     def payment_methods
-      valid_payment_methods = [
-        PaymentMethod::IDEAL, PaymentMethod::IDEAL_PROCESSING, PaymentMethod::VISA, PaymentMethod::MASTER_CARD,
-        PaymentMethod::MAESTRO, PaymentMethod::AMERICAN_EXPRESS, PaymentMethod::SEPA_DIRECT_DEBIT,
-        PaymentMethod::PAYPAL, PaymentMethod::BANCONTACT_MISTER_CASH, PaymentMethod::SOFORT
-      ]
+      valid_payment_methods = PaymentMethod.all - [PaymentMethod::TRANSFER]
 
       response = execute_request(:specify_transaction)
       services = response.services.map { |service| service[:name] }
@@ -34,26 +26,33 @@ module Buckaruby
     # Get a list with payment issuers (currently only iDEAL).
     def issuers(payment_method)
       if payment_method != PaymentMethod::IDEAL && payment_method != PaymentMethod::IDEAL_PROCESSING
-        raise ArgumentError, "Invalid payment method, only iDEAL is supported."
+        raise ArgumentError, 'Invalid payment method, only iDEAL is supported.'
       end
 
-      Ideal::ISSUERS
+      response = execute_request(:specify_transaction, payment_method: payment_method)
+
+      service = response.services.first
+      description = service[:actiondescription].find { |action| action[:description].casecmp(Action::PAY).zero? } if service
+      params = description[:requestparameters].find { |param| param[:name].casecmp('issuer').zero? } if description
+      items = params[:listitemdescription] if params
+
+      items&.map { |item| [item[:value], item[:description]] }.to_h
     end
 
     # Setup a new transaction.
     def setup_transaction(options = {})
-      @logger.debug("[setup_transaction] options=#{options.inspect}")
+      logger.debug("[setup_transaction] options=#{options.inspect}")
 
       validate_setup_transaction_params!(options)
 
-      normalize_account_iban!(options) if options[:payment_method] == PaymentMethod::SEPA_DIRECT_DEBIT
+      normalize_consumer_iban!(options) if options[:payment_method] == PaymentMethod::SEPA_DIRECT_DEBIT
 
       execute_request(:setup_transaction, options)
     end
 
     # Setup a recurrent transaction.
     def recurrent_transaction(options = {})
-      @logger.debug("[recurrent_transaction] options=#{options.inspect}")
+      logger.debug("[recurrent_transaction] options=#{options.inspect}")
 
       validate_recurrent_transaction_params!(options)
 
@@ -62,14 +61,14 @@ module Buckaruby
 
     # Retrieve the specification for setting up a transaction.
     def specify_transaction(options = {})
-      @logger.debug("[specify_transaction] options=#{options.inspect}")
+      logger.debug("[specify_transaction] options=#{options.inspect}")
 
       execute_request(:specify_transaction, options)
     end
 
     # Checks if a transaction is refundable.
-    def refundable?(options = {})
-      @logger.debug("[refundable?] options=#{options.inspect}")
+    def refundable_transaction?(options = {})
+      logger.debug("[refundable_transaction?] options=#{options.inspect}")
 
       validate_required_params!(options, :transaction_id)
 
@@ -79,7 +78,7 @@ module Buckaruby
 
     # Refund a transaction.
     def refund_transaction(options = {})
-      @logger.debug("[refund_transaction] options=#{options.inspect}")
+      logger.debug("[refund_transaction] options=#{options.inspect}")
 
       validate_refund_transaction_params!(options)
 
@@ -103,7 +102,7 @@ module Buckaruby
 
     # Get transaction status.
     def status(options = {})
-      @logger.debug("[status] options=#{options.inspect}")
+      logger.debug("[status] options=#{options.inspect}")
 
       validate_status_params!(options)
 
@@ -111,8 +110,8 @@ module Buckaruby
     end
 
     # Checks if a transaction is cancellable.
-    def cancellable?(options = {})
-      @logger.debug("[cancellable?] options=#{options.inspect}")
+    def cancellable_transaction?(options = {})
+      logger.debug("[cancellable_transaction?] options=#{options.inspect}")
 
       validate_required_params!(options, :transaction_id)
 
@@ -122,7 +121,7 @@ module Buckaruby
 
     # Cancel a transaction.
     def cancel_transaction(options = {})
-      @logger.debug("[cancel_transaction] options=#{options.inspect}")
+      logger.debug("[cancel_transaction] options=#{options.inspect}")
 
       validate_required_params!(options, :transaction_id)
 
@@ -134,13 +133,13 @@ module Buckaruby
       execute_request(:cancel, options)
     end
 
-    # Verify the response / callback.
-    def callback(response = {})
-      if response.empty?
-        raise ArgumentError, "No callback parameters found"
+    # Parse and verify the push response.
+    def parse_push(response)
+      if response.nil? || response.empty?
+        raise ArgumentError, 'No push parameters found'
       end
 
-      CallbackResponse.new(response, config)
+      PushResponse.new(response, config)
     end
 
     private
@@ -161,29 +160,23 @@ module Buckaruby
 
       case options[:payment_method]
       when PaymentMethod::IDEAL, PaymentMethod::IDEAL_PROCESSING
-        required_params << :payment_issuer
+        required_params << :issuer
       when PaymentMethod::SEPA_DIRECT_DEBIT
-        required_params << [:account_iban, :account_name]
+        required_params << [:consumer_iban, :consumer_name]
       end
 
       validate_required_params!(options, required_params)
 
       validate_amount!(options)
 
-      valid_payment_methods = [
-        PaymentMethod::IDEAL, PaymentMethod::IDEAL_PROCESSING, PaymentMethod::VISA, PaymentMethod::MASTER_CARD,
-        PaymentMethod::MAESTRO, PaymentMethod::AMERICAN_EXPRESS, PaymentMethod::SEPA_DIRECT_DEBIT,
-        PaymentMethod::PAYPAL, PaymentMethod::BANCONTACT_MISTER_CASH, PaymentMethod::SOFORT, PaymentMethod::GIROPAY
-      ]
+      valid_payment_methods = PaymentMethod.all - [PaymentMethod::TRANSFER]
       validate_payment_method!(options, valid_payment_methods)
-
-      validate_payment_issuer!(options)
     end
 
     # Validate amount of money, must be greater than 0.
     def validate_amount!(options)
-      money = BigDecimal(options[:amount].to_s)
-      if money <= 0
+      amount = Amount.new(options[:amount])
+      unless amount.positive?
         raise ArgumentError, "Invalid amount: #{options[:amount]} (must be greater than 0)"
       end
     end
@@ -195,15 +188,6 @@ module Buckaruby
       end
     end
 
-    # Validate the payment issuer when iDEAL is selected as payment method.
-    def validate_payment_issuer!(options)
-      if options[:payment_method] == PaymentMethod::IDEAL || options[:payment_method] == PaymentMethod::IDEAL_PROCESSING
-        unless Ideal::ISSUERS.include?(options[:payment_issuer])
-          raise ArgumentError, "Invalid payment issuer: #{options[:payment_issuer]}"
-        end
-      end
-    end
-
     # Validate params for recurrent transaction.
     def validate_recurrent_transaction_params!(options)
       required_params = [:amount, :payment_method, :invoicenumber, :transaction_id]
@@ -222,7 +206,7 @@ module Buckaruby
     # Validate params for refund transaction.
     def validate_refund_transaction_params!(options)
       unless options[:transaction_id]
-        raise ArgumentError, "Missing required parameter: transaction_id"
+        raise ArgumentError, 'Missing required parameter: transaction_id'
       end
 
       if options[:amount]
@@ -233,58 +217,66 @@ module Buckaruby
     # Validate params for transaction status.
     def validate_status_params!(options)
       if !options[:transaction_id] && !options[:payment_id]
-        raise ArgumentError, "Missing parameters: transaction_id or payment_id should be present"
+        raise ArgumentError, 'Missing parameters: transaction_id or payment_id should be present'
       end
     end
 
     # Strip spaces from the IBAN.
-    def normalize_account_iban!(options)
-      iban = options[:account_iban].to_s.gsub(/\s/, "")
+    def normalize_consumer_iban!(options)
+      iban = options[:consumer_iban].to_s.gsub(/\s/, '')
 
-      options[:account_iban] = iban
+      options[:consumer_iban] = iban
     end
 
     # Build and execute a request.
     def execute_request(request_type, options = {})
       request = build_request(request_type)
       response = request.execute(options)
+      build_response(request_type, response)
+    end
 
+    # Factory method for constructing the request.
+    def build_request(request_type)
       case request_type
       when :setup_transaction
-        SetupTransactionResponse.new(response, config)
+        SetupTransactionRequest.new(config)
       when :recurrent_transaction
-        RecurrentTransactionResponse.new(response, config)
+        RecurrentTransactionRequest.new(config)
       when :specify_transaction
-        TransactionSpecificationResponse.new(response, config)
+        TransactionSpecificationRequest.new(config)
       when :refund_transaction
-        RefundTransactionResponse.new(response, config)
+        RefundTransactionRequest.new(config)
       when :refund_info
-        RefundInfoResponse.new(response, config)
+        RefundInfoRequest.new(config)
       when :status
-        StatusResponse.new(response, config)
+        StatusRequest.new(config)
       when :cancel
-        CancelResponse.new(response, config)
+        CancelRequest.new(config)
       end
     end
 
-    # Factory method for constructing a request.
-    def build_request(request_type)
+    # Factory method for constructing the response.
+    def build_response(request_type, response)
       case request_type
       when :setup_transaction
-        SetupTransactionRequest.new(config)
+        SetupTransactionResponse.new(response, config)
       when :recurrent_transaction
-        RecurrentTransactionRequest.new(config)
+        RecurrentTransactionResponse.new(response, config)
       when :specify_transaction
-        TransactionSpecificationRequest.new(config)
+        TransactionSpecificationResponse.new(response, config)
       when :refund_transaction
-        RefundTransactionRequest.new(config)
+        RefundTransactionResponse.new(response, config)
       when :refund_info
-        RefundInfoRequest.new(config)
+        RefundInfoResponse.new(response, config)
       when :status
-        StatusRequest.new(config)
+        StatusResponse.new(response, config)
       when :cancel
-        CancelRequest.new(config)
+        CancelResponse.new(response, config)
       end
     end
+
+    def config
+      @config ||= Configuration.new(@options)
+    end
   end
 end

data/lib/buckaruby/operation.rb

@@ -2,10 +2,10 @@
 
 module Buckaruby
   module Operation
-    TRANSACTION_REQUEST = "TransactionRequest"
-    TRANSACTION_STATUS = "TransactionStatus"
-    TRANSACTION_REQUEST_SPECIFICATION = "TransactionRequestSpecification"
-    REFUND_INFO = "RefundInfo"
-    CANCEL_TRANSACTION = "CancelTransaction"
+    TRANSACTION_REQUEST = 'TransactionRequest'
+    TRANSACTION_STATUS = 'TransactionStatus'
+    TRANSACTION_REQUEST_SPECIFICATION = 'TransactionRequestSpecification'
+    REFUND_INFO = 'RefundInfo'
+    CANCEL_TRANSACTION = 'CancelTransaction'
   end
 end

data/lib/buckaruby/payment_method.rb

@@ -1,21 +1,29 @@
 # frozen_string_literal: true
 
 module Buckaruby
+  # Supported payment methods.
   module PaymentMethod
-    IDEAL = "ideal" # iDEAL collecting
-    IDEAL_PROCESSING = "idealprocessing" # iDEAL processing
+    IDEAL = 'ideal' # iDEAL collecting
+    IDEAL_PROCESSING = 'idealprocessing' # iDEAL processing
 
-    SEPA_DIRECT_DEBIT = "sepadirectdebit"
-    PAYPAL = "paypal"
-    BANCONTACT_MISTER_CASH = "bancontactmrcash"
-    SOFORT = "sofortueberweisung"
-    GIROPAY = "giropay"
-    TRANSFER = "transfer"
+    SEPA_DIRECT_DEBIT = 'sepadirectdebit'
+    PAYPAL = 'paypal'
+    BANCONTACT = 'bancontactmrcash'
+    SOFORT = 'sofortueberweisung'
+    GIROPAY = 'giropay'
+    TRANSFER = 'transfer'
 
     # Credit cards
-    VISA = "visa"
-    MASTER_CARD = "mastercard"
-    MAESTRO = "maestro"
-    AMERICAN_EXPRESS = "amex"
+    VISA = 'visa'
+    MASTER_CARD = 'mastercard'
+    MAESTRO = 'maestro'
+    AMERICAN_EXPRESS = 'amex'
+
+    # Returns an array of all payment method values.
+    def all
+      constants.map { |c| const_get(c) }
+    end
+
+    module_function :all
   end
 end

data/lib/buckaruby/request.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'bigdecimal'
-require 'cgi'
 require 'date'
 require 'net/http'
 require 'openssl'
@@ -12,20 +10,21 @@ module Buckaruby
   class Request
     def initialize(config)
       @config = config
-      @logger = config.logger
     end
 
     def execute(options)
       uri = URI.parse(@config.api_url)
-      uri.query = "op=#{options[:operation]}" if options[:operation]
+      uri.query = URI.encode_www_form(op: operation) if operation
 
-      response = post_buckaroo(uri, build_request_data(options))
-
-      # @logger.debug("[execute] response: #{response.inspect}")
+      post_buckaroo(uri, build_request_data(options))
+    end
 
-      response
+    # Returns the service operation for this request.
+    def operation
+      nil
     end
 
+    # Returns the request parameters (to be implemented by subclasses).
     def build_request_params(_options)
       raise NotImplementedError
     end
@@ -34,12 +33,12 @@ module Buckaruby
 
     def post_buckaroo(uri, params)
       http = Net::HTTP.new(uri.host, uri.port)
-      if uri.scheme == "https"
+      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))
+      raw_response = http.post(uri.request_uri, URI.encode_www_form(params))
 
       unless raw_response.is_a?(Net::HTTPSuccess)
         raise InvalidResponseException, raw_response
@@ -64,28 +63,24 @@ module Buckaruby
       params[:add_buckaruby] = "Buckaruby #{Buckaruby::VERSION}"
 
       # Sign the data with our secret key.
-      params[:brq_signature] = Signature.generate_signature(params, @config)
+      params[:brq_signature] = Signature.generate(@config, params)
 
       params
     end
 
     def build_custom_params(options)
-      options.map { |key, value| [:"cust_#{key}", value] }.to_h
+      options.transform_keys { |key| :"cust_#{key}" }
     end
 
     def build_additional_params(options)
-      options.map { |key, value| [:"add_#{key}", value] }.to_h
-    end
-
-    def post_data(params)
-      params.map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      options.transform_keys { |key| :"add_#{key}" }
     end
   end
 
   # Base class for a transaction request.
   class TransactionRequest < Request
-    def execute(options)
-      super(options.merge(operation: Operation::TRANSACTION_REQUEST))
+    def operation
+      Operation::TRANSACTION_REQUEST
     end
 
     def build_request_params(options)
@@ -93,7 +88,7 @@ module Buckaruby
         brq_payment_method: options[:payment_method],
         brq_culture: options[:culture] || Language::DUTCH,
         brq_currency: options[:currency] || Currency::EURO,
-        brq_amount: BigDecimal(options[:amount].to_s).to_s("F"),
+        brq_amount: Amount.new(options[:amount]).to_s,
         brq_invoicenumber: options[:invoicenumber]
       }
 
@@ -120,35 +115,35 @@ module Buckaruby
       when PaymentMethod::IDEAL
         params.merge!(
           brq_service_ideal_action: Action::PAY,
-          brq_service_ideal_issuer: options[:payment_issuer],
-          brq_service_ideal_version: "2"
+          brq_service_ideal_issuer: options[:issuer],
+          brq_service_ideal_version: '2'
         )
       when PaymentMethod::IDEAL_PROCESSING
         params.merge!(
           brq_service_idealprocessing_action: Action::PAY,
-          brq_service_idealprocessing_issuer: options[:payment_issuer],
-          brq_service_idealprocessing_version: "2"
+          brq_service_idealprocessing_issuer: options[:issuer],
+          brq_service_idealprocessing_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_customeriban: options[:consumer_iban],
+          brq_service_sepadirectdebit_customeraccountname: options[:consumer_name]
         )
 
-        if options[:account_bic]
-          params[:brq_service_sepadirectdebit_customerbic] = options[:account_bic]
+        if options[:consumer_bic]
+          params[:brq_service_sepadirectdebit_customerbic] = options[:consumer_bic]
         end
 
         if options[:collect_date]
-          params[:brq_service_sepadirectdebit_collectdate] = options[:collect_date].strftime("%Y-%m-%d")
+          params[:brq_service_sepadirectdebit_collectdate] = options[:collect_date].strftime('%Y-%m-%d')
         end
 
         if options[:mandate_reference]
           params.merge!(
-            brq_service_sepadirectdebit_action: [Action::PAY, Action::EXTRA_INFO].join(","),
+            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")
+            brq_service_sepadirectdebit_mandatedate: Date.today.strftime('%Y-%m-%d')
           )
         end
       end
@@ -159,30 +154,6 @@ module Buckaruby
     end
   end
 
-  # Request for a creating a transaction specification.
-  class TransactionSpecificationRequest < Request
-    def execute(options)
-      super(options.merge(operation: Operation::TRANSACTION_REQUEST_SPECIFICATION))
-    end
-
-    def build_request_params(options)
-      params = {}
-
-      if options[:payment_method]
-        if options[:payment_method].respond_to?(:join)
-          params[:brq_services] = options[:payment_method].join(",")
-        else
-          params[:brq_services] = options[:payment_method]
-        end
-      end
-
-      params[:brq_latestversiononly] = "true"
-      params[:brq_culture] = options[:culture] || Language::DUTCH
-
-      params
-    end
-  end
-
   # Request for a creating a recurrent transaction.
   class RecurrentTransactionRequest < TransactionRequest
     def build_transaction_request_params(options)
@@ -193,7 +164,7 @@ module Buckaruby
 
       # 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_channel] = 'backoffice'
 
       params[:brq_originaltransaction] = options[:transaction_id]
 
@@ -201,16 +172,41 @@ module Buckaruby
     end
   end
 
+  # Request for a creating a transaction specification.
+  class TransactionSpecificationRequest < Request
+    def operation
+      Operation::TRANSACTION_REQUEST_SPECIFICATION
+    end
+
+    def build_request_params(options)
+      params = {}
+
+      if options[:payment_method]
+        params[:brq_services] =
+          if options[:payment_method].respond_to?(:join)
+            options[:payment_method].join(',')
+          else
+            options[:payment_method]
+          end
+      end
+
+      params[:brq_latestversiononly] = 'true'
+      params[:brq_culture] = options[:culture] || Language::DUTCH
+
+      params
+    end
+  end
+
   # Request for a creating a refund.
   class RefundTransactionRequest < Request
-    def execute(options)
-      super(options.merge(operation: Operation::TRANSACTION_REQUEST))
+    def operation
+      Operation::TRANSACTION_REQUEST
     end
 
     def build_request_params(options)
       params = {
         brq_payment_method: options[:payment_method],
-        brq_amount_credit: BigDecimal(options[:amount].to_s).to_s("F"),
+        brq_amount_credit: Amount.new(options[:amount]).to_s,
         brq_currency: options[:currency] || Currency::EURO,
         brq_invoicenumber: options[:invoicenumber]
       }
@@ -226,8 +222,8 @@ module Buckaruby
 
   # Request for retrieving refund information.
   class RefundInfoRequest < Request
-    def execute(options)
-      super(options.merge(operation: Operation::REFUND_INFO))
+    def operation
+      Operation::REFUND_INFO
     end
 
     def build_request_params(options)
@@ -241,8 +237,8 @@ module Buckaruby
 
   # Request for getting the status of a transaction.
   class StatusRequest < Request
-    def execute(options)
-      super(options.merge(operation: Operation::TRANSACTION_STATUS))
+    def operation
+      Operation::TRANSACTION_STATUS
     end
 
     def build_request_params(options)
@@ -257,14 +253,12 @@ module Buckaruby
 
   # Request for cancelling a transaction.
   class CancelRequest < Request
-    def execute(options)
-      super(options.merge(operation: Operation::CANCEL_TRANSACTION))
+    def operation
+      Operation::CANCEL_TRANSACTION
     end
 
     def build_request_params(options)
-      params = { brq_transaction: options[:transaction_id] }
-
-      params
+      { brq_transaction: options[:transaction_id] }
     end
   end
 end