tikkie-api 0.1.0 → 2.0.0

data/lib/tikkie/api/resources/sandbox_app.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module Resources
+      # Resource for a Sandbox App.
+      class SandboxApp < Base
+        def app_token
+          body[:appToken]
+        end
+
+        private
+
+        def create_resource(attributes)
+          request.post("sandboxapps", options, attributes)
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/response.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module Tikkie
+  module Api
+    # Parses and wraps the response from the Tikkie API.
+    class Response
+      attr_reader :response, :body
+
+      def initialize(response)
+        @response = response
+        @body = response.body ? parse_body(response.body) : {}
+      end
+
+      def success?
+        http_code == 200 || http_code == 201 || http_code == 204
+      end
+
+      def error?
+        !success?
+      end
+
+      def invalid?
+        body.nil?
+      end
+
+      def request_uri
+        response.uri
+      end
+
+      def http_code
+        response.code.to_i
+      end
+
+      def http_message
+        response.message
+      end
+
+      def errors
+        @errors ||= begin
+          errors = []
+
+          if body[:errors]
+            body[:errors].each do |error|
+              errors << Tikkie::Api::Resources::Error.new(error)
+            end
+          end
+
+          errors
+        end
+      end
+
+      private
+
+      def parse_body(body)
+        JSON.parse(body, symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/tikkie/api/v1/access_token.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module V1
+      # Access token that can be used to make API calls.
+      class AccessToken
+        attr_accessor :token
+
+        def initialize(token, expires_in)
+          @token = token
+          @expires_at = Time.now + expires_in.to_i
+        end
+
+        def expired?
+          Time.now > @expires_at
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/v1/authentication.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'jwt'
+require 'net/http'
+require 'uri'
+
+module Tikkie
+  module Api
+    module V1
+      # Provides authentication for the ABN AMRO OAuth API.
+      # see https://developer.abnamro.com/get-started#authentication
+      class Authentication
+        def initialize(config)
+          @config = config
+        end
+
+        def authenticate
+          uri = URI.parse(File.join(@config.api_url, "/oauth/token"))
+
+          request = Net::HTTP::Post.new(uri)
+          request["Api-Key"] = @config.api_key
+
+          request.set_form_data(
+            client_assertion: jwt_token,
+            client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
+            grant_type: "client_credentials",
+            scope: "tikkie"
+          )
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+            http.request(request)
+          end
+
+          if response.is_a?(Net::HTTPSuccess)
+            json = JSON.parse(response.body, symbolize_names: true)
+
+            Tikkie::Api::V1::AccessToken.new(json[:access_token], json[:expires_in])
+          else
+            raise Tikkie::Api::V1::AuthenticationException, response
+          end
+        end
+
+        private
+
+        def jwt_token
+          now = Time.now.to_i
+
+          payload = {
+            nbf: now - 120,
+            exp: now + 120, # Token is valid for 2 minutes
+            iss: "Ruby Tikkie client",
+            sub: @config.api_key,
+            aud: @config.oauth_token_url
+          }
+
+          # Send header typ as String, not symbol (JWT version 1.x adds "typ" as String by default).
+          headers = {
+            "typ" => "JWT"
+          }
+
+          JWT.encode(payload, @config.private_data, @config.jwt_hashing_algorithm, headers)
+        end
+      end
+    end
+  end
+end

data/lib/tikkie/api/v1/client.rb

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

data/lib/tikkie/api/v1/configuration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module V1
+      # 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::V1::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::V1::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
+end

data/lib/tikkie/api/v1/exception.rb

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

data/lib/tikkie/api/v1/request.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module Tikkie
+  module Api
+    module V1
+      # 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::V1::Authentication.new(@config)
+            @access_token = @authentication.authenticate
+          end
+
+          @access_token.token
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Tikkie
+  module Api
+    module V1
+      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::V1::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::V1::Responses::PaymentRequest.new(response)
+          end
+
+          def create(platform_token, user_token, bank_account_token, options = {})
+            params = {
+              currency: options.fetch(:currency),
+              description: options.fetch(:description)
+            }
+            params[:amountInCents] = to_cents(options[:amount]) if options.key?(:amount)
+            params[:externalId] = options[:external_id] if options.key?(:external_id)
+
+            response = @request.post("/tikkie/platforms/#{platform_token}/users/#{user_token}/bankaccounts/#{bank_account_token}/paymentrequests", params)
+
+            Tikkie::Api::V1::Responses::PaymentRequestCreated.new(response)
+          end
+
+          private
+
+          def to_cents(amount)
+            decimal = BigDecimal(amount.to_s)
+            decimal *= 100 # to cents
+            decimal.to_i
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Tikkie
+  module Api
+    module V1
+      module Requests
+        # Platforms operations at Tikkie.
+        class Platforms
+          def initialize(request)
+            @request = request
+          end
+
+          def list
+            response = @request.get("/tikkie/platforms")
+            Tikkie::Api::V1::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::V1::Responses::Platform.new(response)
+          end
+        end
+      end
+    end
+  end
+end