First version

.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

.ruby-version

@@ -0,0 +1 @@
+2.4.1

Gemfile.lock

@@ -44,20 +44,20 @@ GEM
     unf (0.1.4)
       unf_ext
     unf_ext (0.0.7.6)
-    webmock (2.3.2)
+    webmock (3.7.6)
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
-      hashdiff
+      hashdiff (>= 0.4.0, < 2.0.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler
   flanks-api-ruby!
-  rake (~> 10.0)
-  rspec (~> 3.0)
-  webmock (~> 2.3.1)
+  rake
+  rspec
+  webmock
 
 BUNDLED WITH
-   1.16.1
+   1.17.3

README.md

@@ -6,3 +6,10 @@ Changelog
 ---------
 
 * v.0.1.0 TBD
+
+About Flanks
+------------
+
+* [Public site](https://www.flanks.io/)
+* [Documentation](https://docs.flanks.io/)
+* [Platform](https://platform.flanks.io/)

flanks.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rest-client", "~> 2.0.2"
 
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "webmock", "~> 2.3.1"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
 end

lib/flanks.rb

@@ -1,2 +1,13 @@
 require 'flanks/version'
 require 'flanks/configuration'
+require 'flanks/base'
+require 'flanks/error'
+require 'flanks/resource'
+require 'flanks/collection'
+
+require 'flanks/resources/account'
+require 'flanks/resources/bank'
+require 'flanks/resources/link'
+require 'flanks/resources/link_code'
+require 'flanks/resources/token'
+require 'flanks/resources/transaction'

lib/flanks/base.rb

@@ -0,0 +1,92 @@
+require 'rest-client'
+require 'json'
+
+module Flanks
+  BASE_URL = 'https://api.flanks.io'
+  SENSIBLE_HEADERS = %w{Authorization}
+  SENSIBLE_PARAMS = %w{client_secret password credentials_token code}
+
+  class << self
+    attr_accessor :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def api_call(method:, path:, params: {}, token: nil)
+      url = Flanks.const_get(:BASE_URL) + path
+
+      headers = { 'Content-Type' => 'application/json' }
+
+      unless token.nil?
+        headers.merge!(Authorization: "Bearer #{token}")
+      end
+
+      log_request(method, url, headers, params)
+
+      if method == :post
+        payload = params.to_json
+      else
+        headers.merge!(params: params)
+      end
+
+      request_params = { method: method, url: url, headers: headers }
+      request_params.merge!(payload: payload) unless payload.nil?
+
+      begin
+        response = RestClient::Request.execute(request_params)
+        return {} if response.empty?
+
+        JSON.parse(response)
+      rescue StandardError => error
+        # TODO handle properly
+        response = JSON.parse(error.response)
+        raise Error.new(response['error'])
+      end
+    end
+
+    def log_request(method, url, headers, params)
+      log_message("")
+      log_message("=> #{method.upcase} #{url}")
+
+      log_message("* Headers")
+      headers.each do |key, value|
+        safe_value = if SENSIBLE_HEADERS.include?(key.to_s)
+                       "<masked>"
+                     else
+                       value
+                     end
+
+        log_message("#{key}: #{safe_value}")
+      end
+
+      if params.any?
+        log_message("* Params")
+        params.each do |key, value|
+          safe_value = if SENSIBLE_PARAMS.include?(key.to_s)
+                         "<masked>"
+                       else
+                         value
+                       end
+
+          log_message("#{key}: #{safe_value}")
+        end
+      else
+        log_message("* No params")
+      end
+    end
+
+    def log_message(message)
+      return if message.nil?
+
+      logger = Flanks.configuration.logger
+      return if logger.nil?
+
+      logger.info(message)
+    end
+  end
+end

lib/flanks/collection.rb

@@ -0,0 +1,55 @@
+module Flanks
+  class Collection < Array
+    def initialize(response, item_class, token = nil)
+      @item_class = item_class
+      @token = token
+      populate!(response, item_class)
+    end
+
+    def next_page?
+      !@next_page_uri.nil?
+    end
+
+    def previous_page?
+      !@previous_page_uri.nil?
+    end
+
+    def next_page!
+      return unless next_page?
+
+      uri = URI.parse(@next_page_uri)
+      params = if uri.query
+                 Hash[URI::decode_www_form(uri.query)]
+               else
+                 {}
+               end
+
+      response = Bankin.api_call(:get, uri.path, params, @token)
+      populate!(response, @item_class)
+      self
+    end
+
+    def load_all!
+      while next_page? do
+        next_page!
+      end
+      self
+    end
+
+    private
+
+    def populate!(response, item_klass)
+      response.each do |item|
+        self << item_klass.new(item, @token)
+      end
+
+      # TODO review
+      # set_pagination(response['pagination'])
+    end
+
+    def set_pagination(pagination_data)
+      @next_page_uri = pagination_data['next_uri']
+      @previous_page_uri = pagination_data['previous_uri']
+    end
+  end
+end

lib/flanks/configuration.rb

@@ -1,4 +1,5 @@
 module Flanks
   class Configuration
+    attr_accessor :client_id, :client_secret, :username, :password, :logger
   end
 end

lib/flanks/error.rb

@@ -0,0 +1,9 @@
+module Flanks
+  class Error < StandardError
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+  end
+end

lib/flanks/resource.rb

@@ -0,0 +1,101 @@
+module Flanks
+  class Resource
+    def initialize(data, token = nil)
+      @token = token
+      generate_attr_readers
+      set_data(data)
+    end
+
+    def fields
+      self.class.fields
+    end
+
+    def resources
+      self.class.resources
+    end
+
+    def collections
+      self.class.collections
+    end
+
+    private
+
+    def generate_attr_readers
+      fields.each do |field|
+        define_singleton_method(field) do
+          load_data! if instance_variable_get("@#{field}").nil?
+          instance_variable_get("@#{field}")
+        end
+      end
+
+      (resources + collections).each do |resource|
+        define_singleton_method(resource[:name]) do
+          load_data! if instance_variable_get("@#{resource[:name]}").nil?
+          instance_variable_get("@#{resource[:name]}")
+        end
+      end
+    end
+
+    def set_data(data)
+      fields.each do |field|
+        next unless data.key?(field.to_s)
+        instance_variable_set("@#{field}", data[field.to_s])
+      end
+
+      resources.each do |resource|
+        next unless data.key?(resource[:name].to_s)
+        klass = Object.const_get("Flanks::#{resource[:klass]}")
+        instance_variable_set("@#{resource[:name]}", klass.new(data[resource[:name].to_s], @token))
+      end
+
+      collections.each do |collection|
+        next unless data[collection[:name].to_s]
+        klass = Object.const_get("Flanks::#{collection[:klass]}")
+        arr = data[collection[:name].to_s].map { |item | klass.new(item, @token) }
+        instance_variable_set("@#{collection[:name]}", arr)
+        instance_variable_set("@#{collection[:name]}_ids", arr.map(&:id))
+      end
+    end
+
+    def load_data!
+      return if @loaded
+      response = Flanks.api_call(method: :get, path: @resource_uri, token: @token)
+      set_data(response)
+      @loaded = true
+    end
+
+    class << self
+      def fields
+        @fields || [:resource_type, :resource_uri]
+      end
+
+      def resources
+        @resources || []
+      end
+
+      def collections
+        @collections || []
+      end
+
+      def auth_delegate(name, options)
+        define_method(name) do |*args|
+          klass = Object.const_get("Flanks::#{options[:class]}")
+          klass.send(options[:method], self.token, *args)
+        end
+      end
+
+      def has_fields(*new_fields)
+        @fields = (fields + new_fields).uniq
+      end
+
+      def has_resource(name, klass)
+        @resources = resources << { name: name, klass: klass }
+      end
+
+      def has_collection(name, klass)
+        @collections = collections << { name: name, klass: klass }
+        attr_reader :"#{name}_ids"
+      end
+    end
+  end
+end

lib/flanks/resources/account.rb

@@ -0,0 +1,20 @@
+module Flanks
+  class Account < Resource
+    RESOURCE_PATH = '/v0/bank/credentials/account'
+
+    has_fields :iban, :entity, :alias, :balance, :currency, :description,
+               :isOwner, :numOwners, :owners, :_id
+
+    def self.list(token:, credentials_token:)
+      response = Flanks.api_call(
+        method: :post,
+        path: RESOURCE_PATH,
+        token: token,
+        params: {
+          credentials_token: credentials_token
+        }
+      )
+      Collection.new(response, self)
+    end
+  end
+end

lib/flanks/resources/bank.rb

@@ -0,0 +1,16 @@
+module Flanks
+  class Bank < Resource
+    RESOURCE_PATH = '/v0/bank/available'
+
+    has_fields :id, :name
+
+    def self.list(token:)
+      response = Flanks.api_call(
+        method: :get,
+        path: RESOURCE_PATH,
+        token: token
+      )
+      Collection.new(response, self)
+    end
+  end
+end

lib/flanks/resources/link.rb

@@ -0,0 +1,19 @@
+module Flanks
+  class Link < Resource
+    RESOURCE_PATH = '/v0/platform/link'
+
+    has_fields :message, :credentials_token, :extra
+
+    def self.create(token:, code:)
+      response = Flanks.api_call(
+        method: :post,
+        path: RESOURCE_PATH,
+        token: token,
+        params: {
+          code: code
+        }
+      )
+      new(response)
+    end
+  end
+end