tikkie-api 0.1.0 → 2.0.0

data/lib/tikkie/api.rb

@@ -1,32 +1,59 @@
 # frozen_string_literal: true
 
-require "tikkie/api/access_token"
-require "tikkie/api/authentication"
+require "tikkie/api/version"
+
+require "tikkie/api/amount"
 require "tikkie/api/client"
 require "tikkie/api/configuration"
 require "tikkie/api/exception"
 require "tikkie/api/request"
-require "tikkie/api/version"
+require "tikkie/api/response"
+
+require "tikkie/api/clients/base"
+require "tikkie/api/clients/payment_requests"
+require "tikkie/api/clients/payment_requests_subscription"
+require "tikkie/api/clients/payments"
+require "tikkie/api/clients/refunds"
+require "tikkie/api/clients/sandbox_apps"
+
+require "tikkie/api/resources/base"
+require "tikkie/api/resources/error"
+require "tikkie/api/resources/list"
+require "tikkie/api/resources/payment_request"
+require "tikkie/api/resources/payment_requests"
+require "tikkie/api/resources/payment_requests_subscription"
+require "tikkie/api/resources/payment"
+require "tikkie/api/resources/payments"
+require "tikkie/api/resources/refund"
+require "tikkie/api/resources/sandbox_app"
+
+# Below the deprecated Tikkie v1 API code which will be removed after 01-01-2021.
+require "tikkie/api/v1/access_token"
+require "tikkie/api/v1/authentication"
+require "tikkie/api/v1/client"
+require "tikkie/api/v1/configuration"
+require "tikkie/api/v1/exception"
+require "tikkie/api/v1/request"
+
+require "tikkie/api/v1/requests/payment_requests"
+require "tikkie/api/v1/requests/platforms"
+require "tikkie/api/v1/requests/users"
+
+require "tikkie/api/v1/responses/base"
+require "tikkie/api/v1/responses/bank_account"
+require "tikkie/api/v1/responses/error"
+require "tikkie/api/v1/responses/pagination"
+require "tikkie/api/v1/responses/payment_request_created"
+require "tikkie/api/v1/responses/payment_request"
+require "tikkie/api/v1/responses/payment_requests"
+require "tikkie/api/v1/responses/payment"
+require "tikkie/api/v1/responses/platform"
+require "tikkie/api/v1/responses/platforms"
+require "tikkie/api/v1/responses/user"
+require "tikkie/api/v1/responses/users"
 
-require "tikkie/api/requests/payment_requests"
-require "tikkie/api/requests/platforms"
-require "tikkie/api/requests/users"
-
-require "tikkie/api/responses/base"
-require "tikkie/api/responses/bank_account"
-require "tikkie/api/responses/error"
-require "tikkie/api/responses/pagination"
-require "tikkie/api/responses/payment_request_created"
-require "tikkie/api/responses/payment_request"
-require "tikkie/api/responses/payment_requests"
-require "tikkie/api/responses/payment"
-require "tikkie/api/responses/platform"
-require "tikkie/api/responses/platforms"
-require "tikkie/api/responses/user"
-require "tikkie/api/responses/users"
-
-require "tikkie/api/types/payment_request_status"
-require "tikkie/api/types/payment_status"
-require "tikkie/api/types/platform_status"
-require "tikkie/api/types/platform_usage"
-require "tikkie/api/types/user_status"
+require "tikkie/api/v1/types/payment_request_status"
+require "tikkie/api/v1/types/payment_status"
+require "tikkie/api/v1/types/platform_status"
+require "tikkie/api/v1/types/platform_usage"
+require "tikkie/api/v1/types/user_status"

data/lib/tikkie/api/amount.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Tikkie
+  module Api
+    # Helper for converting amounts to cents and back.
+    class Amount
+      class << self
+        def from_cents(cents)
+          amount = BigDecimal(cents) / 100
+          new(amount)
+        end
+      end
+
+      def initialize(amount)
+        @amount = BigDecimal(amount.to_s)
+      end
+
+      def to_d
+        @amount
+      end
+
+      # Convert the amount to a String with 2 decimals.
+      def to_s
+        format("%.2f", @amount)
+      end
+
+      def to_cents
+        cents = @amount * 100
+        cents.to_i
+      end
+    end
+  end
+end

data/lib/tikkie/api/client.rb

@@ -4,20 +4,28 @@ module Tikkie
   module Api
     # Tikkie API client.
     class Client
-      def initialize(config)
-        @request = Tikkie::Api::Request.new(config)
+      def initialize(api_key:, app_token: nil, sandbox: false)
+        @config = Tikkie::Api::Configuration.new(api_key: api_key, app_token: app_token, sandbox: sandbox)
       end
 
-      def platforms
-        Tikkie::Api::Requests::Platforms.new(@request)
+      def payment_requests_subscription
+        Tikkie::Api::Clients::PaymentRequestsSubscription.new(@config)
       end
 
-      def users
-        Tikkie::Api::Requests::Users.new(@request)
+      def payment_requests
+        Tikkie::Api::Clients::PaymentRequests.new(@config)
       end
 
-      def payment_requests
-        Tikkie::Api::Requests::PaymentRequests.new(@request)
+      def payments
+        Tikkie::Api::Clients::Payments.new(@config)
+      end
+
+      def refunds
+        Tikkie::Api::Clients::Refunds.new(@config)
+      end
+
+      def sandbox_apps
+        Tikkie::Api::Clients::SandboxApps.new(@config)
       end
     end
   end

data/lib/tikkie/api/clients/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Clients
+      # Base class for all clients.
+      class Base
+        attr_reader :config
+
+        def initialize(config)
+          @config = config
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/clients/payment_requests.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Clients
+      # Payment Request endpoint at Tikkie.
+      class PaymentRequests < Base
+        def list(options = {})
+          payment_requests = Tikkie::Api::Resources::PaymentRequests.new(config, options)
+          payment_requests.load
+        end
+
+        def get(payment_request_token, options = {})
+          payment_request = Tikkie::Api::Resources::PaymentRequest.new(config, options.merge(payment_request_token: payment_request_token))
+          payment_request.load
+        end
+
+        def create(attributes = {}, options = {})
+          payment_request = Tikkie::Api::Resources::PaymentRequest.new(config, options)
+          payment_request.save(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/clients/payment_requests_subscription.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Clients
+      # Payment Request Subscription endpoint at Tikkie.
+      class PaymentRequestsSubscription < Base
+        def create(attributes = {}, options = {})
+          payment_request = Tikkie::Api::Resources::PaymentRequestsSubscription.new(config, options)
+          payment_request.save(attributes)
+        end
+
+        def delete(options = {})
+          payment_request = Tikkie::Api::Resources::PaymentRequestsSubscription.new(config, options)
+          payment_request.delete
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/clients/payments.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Clients
+      # Payment endpoint at Tikkie.
+      class Payments < Base
+        def list(payment_request_token, options = {})
+          payments = Tikkie::Api::Resources::Payments.new(config, options.merge(payment_request_token: payment_request_token))
+          payments.load
+        end
+
+        def get(payment_request_token, payment_token, options = {})
+          payment = Tikkie::Api::Resources::Payment.new(config, options.merge(payment_request_token: payment_request_token, payment_token: payment_token))
+          payment.load
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/clients/refunds.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Clients
+      # Refund endpoint at Tikkie.
+      class Refunds < Base
+        def get(payment_request_token, payment_token, refund_token, options = {})
+          payment = Tikkie::Api::Resources::Refund.new(config, options.merge(payment_request_token: payment_request_token, payment_token: payment_token, refund_token: refund_token))
+          payment.load
+        end
+
+        def create(payment_request_token, payment_token, attributes = {}, options = {})
+          payment = Tikkie::Api::Resources::Refund.new(config, options.merge(payment_request_token: payment_request_token, payment_token: payment_token))
+          payment.save(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/clients/sandbox_apps.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Clients
+      # Sandbox App endpoint at Tikkie.
+      class SandboxApps < Base
+        def create(attributes = {}, options = {})
+          payment = Tikkie::Api::Resources::SandboxApp.new(config, options)
+          payment.save(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/configuration.rb

@@ -2,60 +2,21 @@
 
 module Tikkie
   module Api
-    # Tikkie API Configuration. An API Key and private key are mandatory.
-    # see https://developer.abnamro.com/get-started
+    # Tikkie API configuration.
     class Configuration
-      SANDBOX_API_URL = "https://api-sandbox.abnamro.com/v1/"
-      PRODUCTION_API_URL = "https://api.abnamro.com/v1/"
+      SANDBOX_API_URL = "https://api-sandbox.abnamro.com/v2/tikkie/"
+      PRODUCTION_API_URL = "https://api.abnamro.com/v2/tikkie/"
 
-      SANDBOX_OAUTH_TOKEN_URL = "https://auth-sandbox.abnamro.com/oauth/token"
-      PRODUCTION_OAUTH_TOKEN_URL = "https://auth.abnamro.com/oauth/token"
+      attr_reader :api_key, :app_token, :sandbox
 
-      DEFAULT_HASHING_ALGORITHM = "RS256"
-      VALID_HASHING_ALGORITHMS = %w[RS256 RS384 RS512].freeze
-
-      attr_reader :api_key, :private_key, :options
-
-      def initialize(api_key, private_key, options = {})
+      def initialize(api_key:, app_token: nil, sandbox: false)
         @api_key = api_key
-        @private_key = private_key
-        @options = options
-      end
-
-      def private_data
-        unless File.exist?(@private_key)
-          raise Tikkie::Api::Exception, "Private key does not exist: #{@private_key}"
-        end
-
-        OpenSSL::PKey::RSA.new(File.read(@private_key))
-      end
-
-      def jwt_hashing_algorithm
-        if @options[:hashing_algorithm]
-          unless VALID_HASHING_ALGORITHMS.include?(@options[:hashing_algorithm])
-            raise Tikkie::Api::Exception, "Invalid hashing algorithm provided: #{@options[:hashing_algorithm]} (expected: #{VALID_HASHING_ALGORITHMS.join(', ')})"
-          end
-
-          @options[:hashing_algorithm]
-        else
-          DEFAULT_HASHING_ALGORITHM
-        end
+        @app_token = app_token
+        @sandbox = sandbox
       end
 
       def api_url
-        if @options[:test]
-          SANDBOX_API_URL
-        else
-          PRODUCTION_API_URL
-        end
-      end
-
-      def oauth_token_url
-        if @options[:test]
-          SANDBOX_OAUTH_TOKEN_URL
-        else
-          PRODUCTION_OAUTH_TOKEN_URL
-        end
+        @sandbox ? SANDBOX_API_URL : PRODUCTION_API_URL
       end
     end
   end

data/lib/tikkie/api/exception.rb

@@ -2,20 +2,40 @@
 
 module Tikkie
   module Api
-    # Tikkie base exception.
-    class Exception < RuntimeError
+    # Generic Tikkie Exception.
+    class Exception < StandardError
     end
 
-    # Exception when the authentication fails.
-    class AuthenticationException < Tikkie::Api::Exception
-      attr_reader :response, :body
+    # Exception when an HTTP request fails.
+    class RequestError < Tikkie::Api::Exception
+      attr_accessor :response
 
       def initialize(response)
         @response = response
-        @body = response.body
+      end
+
+      def errors
+        response.errors
+      end
+
+      def request_uri
+        response.request_uri
+      end
+
+      def http_code
+        response.http_code
+      end
+
+      def http_message
+        response.http_message
+      end
+
+      def messages
+        errors.map(&:message)
+      end
 
-        message = "Authentication failure at Tikkie"
-        super(message)
+      def to_s
+        "#{http_code} #{http_message}: #{messages.join(', ')}"
       end
     end
   end

data/lib/tikkie/api/request.rb

@@ -2,55 +2,79 @@
 
 require 'net/http'
 require 'uri'
+require 'logger'
 
 module Tikkie
   module Api
     # Make authenticated HTTP requests to the Tikkie API.
     class Request
+      attr_reader :config
+
       def initialize(config)
         @config = config
       end
 
       def get(path, params = {})
-        uri = URI.parse(File.join(@config.api_url, path))
-        uri.query = URI.encode_www_form(params) unless params.empty?
-
-        request = Net::HTTP::Get.new(uri)
-        request["Api-Key"] = @config.api_key
-        request["Authorization"] = "Bearer #{access_token}"
+        request(:get, path, params)
+      end
 
-        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
-          http.request(request)
-        end
+      def post(path, params = {}, body = {})
+        request(:post, path, params, body)
+      end
 
-        response
+      def delete(path, params = {})
+        request(:delete, path, params)
       end
 
-      def post(path, params = {})
-        uri = URI.parse(File.join(@config.api_url, path))
+      private
 
-        request = Net::HTTP::Post.new(uri)
-        request["Api-Key"] = @config.api_key
-        request["Authorization"] = "Bearer #{access_token}"
-        request["Content-Type"] = "application/json"
-        request.body = params.to_json
+      def request(http_method, path, params = {}, body = {})
+        uri = URI.join(config.api_url, path)
+        uri.query = URI.encode_www_form(params) unless params.empty?
 
-        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
-          http.request(request)
+        logger.debug("[Tikkie] Request: #{http_method.upcase} #{uri}") if ENV['TIKKIE_DEBUG']
+
+        case http_method
+        when :get
+          request = Net::HTTP::Get.new(uri)
+        when :post
+          request = Net::HTTP::Post.new(uri)
+          request.body = body.to_json
+        when :delete
+          request = Net::HTTP::Delete.new(uri)
+        else
+          raise Tikkie::Api::Exception, "Invalid HTTP method: #{http_method}"
         end
 
-        response
-      end
+        request["Accept"] = "application/json"
+        request["Content-Type"] = "application/json"
+        request["Api-Key"] = config.api_key
+        request["X-App-Token"] = config.app_token if config.app_token
+        request["User-Agent"] = "Ruby tikkie-api/#{Tikkie::Api::VERSION}"
 
-      private
+        client = Net::HTTP.new(uri.hostname, uri.port)
+        client.use_ssl = uri.scheme == "https"
+        client.verify_mode = OpenSSL::SSL::VERIFY_PEER
 
-      def access_token
-        if @access_token.nil? || @access_token.expired?
-          @authentication ||= Tikkie::Api::Authentication.new(@config)
-          @access_token = @authentication.authenticate
+        begin
+          response = Tikkie::Api::Response.new(client.request(request))
+        # Try to catch some common exceptions Net::HTTP might raise.
+        rescue Errno::ETIMEDOUT, Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED, Errno::EHOSTUNREACH,
+               IOError, SocketError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::OpenTimeout,
+               Net::ProtocolError, Net::ReadTimeout, OpenSSL::SSL::SSLError => e
+          raise Tikkie::Api::Exception, e.message
         end
 
-        @access_token.token
+        logger.debug("[Tikkie] Response: #{response.http_code}, body: #{response.body}") if ENV['TIKKIE_DEBUG']
+
+        raise Tikkie::Api::Exception, "Invalid payload" if response.invalid?
+        raise Tikkie::Api::RequestError, response if response.error?
+
+        response
+      end
+
+      def logger
+        @logger ||= Logger.new(STDOUT)
       end
     end
   end