tikkie-api 0.1.0

data/lib/tikkie/api/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    # Tikkie API client.
+    class Client
+      def initialize(config)
+        @request = Tikkie::Api::Request.new(config)
+      end
+
+      def platforms
+        Tikkie::Api::Requests::Platforms.new(@request)
+      end
+
+      def users
+        Tikkie::Api::Requests::Users.new(@request)
+      end
+
+      def payment_requests
+        Tikkie::Api::Requests::PaymentRequests.new(@request)
+      end
+    end
+  end
+end

data/lib/tikkie/api/configuration.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    # Tikkie API Configuration. An API Key and private key are mandatory.
+    # see https://developer.abnamro.com/get-started
+    class Configuration
+      SANDBOX_API_URL = "https://api-sandbox.abnamro.com/v1/"
+      PRODUCTION_API_URL = "https://api.abnamro.com/v1/"
+
+      SANDBOX_OAUTH_TOKEN_URL = "https://auth-sandbox.abnamro.com/oauth/token"
+      PRODUCTION_OAUTH_TOKEN_URL = "https://auth.abnamro.com/oauth/token"
+
+      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 = {})
+        @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
+      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
+      end
+    end
+  end
+end

data/lib/tikkie/api/exception.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    # Tikkie base exception.
+    class Exception < RuntimeError
+    end
+
+    # Exception when the authentication fails.
+    class AuthenticationException < Tikkie::Api::Exception
+      attr_reader :response, :body
+
+      def initialize(response)
+        @response = response
+        @body = response.body
+
+        message = "Authentication failure at Tikkie"
+        super(message)
+      end
+    end
+  end
+end

data/lib/tikkie/api/request.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module Tikkie
+  module Api
+    # Make authenticated HTTP requests to the Tikkie API.
+    class Request
+      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}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(request)
+        end
+
+        response
+      end
+
+      def post(path, params = {})
+        uri = URI.parse(File.join(@config.api_url, path))
+
+        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
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(request)
+        end
+
+        response
+      end
+
+      private
+
+      def access_token
+        if @access_token.nil? || @access_token.expired?
+          @authentication ||= Tikkie::Api::Authentication.new(@config)
+          @access_token = @authentication.authenticate
+        end
+
+        @access_token.token
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Tikkie
+  module Api
+    module Requests
+      # Payment requests operations at Tikkie.
+      class PaymentRequests
+        def initialize(request)
+          @request = request
+        end
+
+        def list(platform_token, user_token, options = {})
+          offset = options[:offset] || 0
+          limit = options[:limit] || 20
+          from_date = options[:from_date]
+          to_date = options[:to_date]
+
+          params = { offset: offset, limit: limit }
+          params[:fromDate] = from_date.respond_to?(:utc) ? from_date.utc.iso8601 : from_date if from_date
+          params[:toDate] = to_date.respond_to?(:utc) ? to_date.utc.iso8601 : to_date if to_date
+
+          response = @request.get("/tikkie/platforms/#{platform_token}/users/#{user_token}/paymentrequests", params)
+          Tikkie::Api::Responses::PaymentRequests.new(response, offset: offset, limit: limit)
+        end
+
+        def get(platform_token, user_token, payment_request_token)
+          response = @request.get("/tikkie/platforms/#{platform_token}/users/#{user_token}/paymentrequests/#{payment_request_token}")
+
+          Tikkie::Api::Responses::PaymentRequest.new(response)
+        end
+
+        def create(platform_token, user_token, bank_account_token, options = {})
+          params = {
+            amountInCents: to_cents(options.fetch(:amount)),
+            currency: options.fetch(:currency),
+            description: options.fetch(:description),
+            externalId: options[:external_id]
+          }
+          response = @request.post("/tikkie/platforms/#{platform_token}/users/#{user_token}/bankaccounts/#{bank_account_token}/paymentrequests", params)
+
+          Tikkie::Api::Responses::PaymentRequestCreated.new(response)
+        end
+
+        private
+
+        def to_cents(amount)
+          decimal = BigDecimal.new(amount.to_s)
+          decimal *= 100 # to cents
+          decimal.to_i
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/requests/platforms.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Requests
+      # Platforms operations at Tikkie.
+      class Platforms
+        def initialize(request)
+          @request = request
+        end
+
+        def list
+          response = @request.get("/tikkie/platforms")
+          Tikkie::Api::Responses::Platforms.new(response)
+        end
+
+        def create(options = {})
+          params = {
+            name: options.fetch(:name),
+            phoneNumber: options.fetch(:phone_number),
+            platformUsage: options.fetch(:platform_usage),
+            email: options[:email],
+            notificationUrl: options[:notification_url]
+          }
+          response = @request.post("/tikkie/platforms", params)
+
+          Tikkie::Api::Responses::Platform.new(response)
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/requests/users.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Requests
+      # Users operations at Tikkie.
+      class Users
+        def initialize(request)
+          @request = request
+        end
+
+        def list(platform_token)
+          response = @request.get("/tikkie/platforms/#{platform_token}/users")
+          Tikkie::Api::Responses::Users.new(response)
+        end
+
+        def create(platform_token, options = {})
+          params = {
+            name: options.fetch(:name),
+            phoneNumber: options.fetch(:phone_number),
+            iban: options.fetch(:iban),
+            bankAccountLabel: options.fetch(:bank_account_label)
+          }
+          response = @request.post("/tikkie/platforms/#{platform_token}/users", params)
+
+          Tikkie::Api::Responses::User.new(response)
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/responses/bank_account.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Responses
+      # Bank account of a user.
+      class BankAccount < Base
+        def bank_account_token
+          data[:bankAccountToken]
+        end
+
+        def bank_account_label
+          data[:bankAccountLabel]
+        end
+
+        def iban
+          data[:iban]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Tikkie
+  module Api
+    module Responses
+      # Base class for all responses.
+      class Base
+        attr_reader :response, :data
+
+        def initialize(response)
+          if response.respond_to?(:body)
+            @response = response
+            @data = JSON.parse(response.body, symbolize_names: true)
+          else
+            @data = response
+          end
+        end
+
+        def response_code
+          response.code.to_i if response
+        end
+
+        def success?
+          response_code == 200 || response_code == 201
+        end
+
+        def error?
+          !success?
+        end
+
+        def trace_id
+          response["Trace-Id"] if response
+        end
+
+        def errors
+          @errors ||= begin
+            errors = []
+
+            if data[:errors]
+              data[:errors].each do |error|
+                errors << Tikkie::Api::Responses::Error.new(error)
+              end
+            end
+
+            errors
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/responses/error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Responses
+      # Error response from Tikkie.
+      class Error < Base
+        def code
+          data[:code]
+        end
+
+        def message
+          data[:message]
+        end
+
+        def reference
+          data[:reference]
+        end
+
+        def trace_id
+          data[:traceId]
+        end
+
+        def status
+          data[:status]
+        end
+
+        def category
+          data[:category]
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/responses/pagination.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Responses
+      # Helper for paginated responses.
+      module Pagination
+        attr_accessor :offset, :limit, :elements, :total_elements
+
+        def more_elements?
+          @total_elements && @total_elements > @offset + @elements
+        end
+
+        def next_offset
+          @offset + @limit if more_elements?
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/responses/payment.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'time'
+
+module Tikkie
+  module Api
+    module Responses
+      # Payment that is associated with a payment request.
+      class Payment < Base
+        def payment_token
+          data[:paymentToken]
+        end
+
+        def counter_party_name
+          data[:counterPartyName]
+        end
+
+        def amount
+          decimal = BigDecimal.new(data[:amountInCents])
+          decimal /= 100.0
+          decimal
+        end
+
+        def currency
+          data[:amountCurrency]
+        end
+
+        def description
+          data[:description]
+        end
+
+        def created_at
+          Time.parse(data[:created]) if data[:created]
+        end
+
+        # See PaymentStatus
+        def online_payment_status
+          data[:onlinePaymentStatus]
+        end
+
+        def paid?
+          online_payment_status == Tikkie::Api::Types::PaymentStatus::PAID
+        end
+      end
+    end
+  end
+end