flinks 0.1.0

data/lib/flinks.rb

@@ -0,0 +1,12 @@
+require 'flinks/client'
+
+module Flinks
+
+  # Alias for Flinks::Client.new
+  #
+  # @return [Flinks::Client]
+  def new(options = {})
+    Flinks::Client.new(options)
+  end
+  module_function :new
+end

data/lib/flinks/api/account.rb

@@ -0,0 +1,74 @@
+module Flinks
+  module API
+    module Account
+      AccountSummaryRequestSchema = Dry::Validation.Schema do
+        required(:request_id).filled(:str?)
+        optional(:direct_refresh).maybe(:bool?)
+        optional(:with_balance).maybe(:bool?)
+        optional(:with_transactions).maybe(:bool?)
+        optional(:with_account_identity).maybe(:bool?)
+        optional(:most_recent).maybe(:bool?)
+        optional(:most_recent_cached).maybe(:bool?)
+      end
+
+      AccountDetailRequestSchema = Dry::Validation.Schema do
+        required(:request_id).filled(:str?)
+        optional(:with_account_identity).maybe(:bool?)
+        optional(:with_kyc).maybe(:bool?)
+        optional(:with_transactions).maybe(:bool?)
+        optional(:with_balance).maybe(:bool?)
+        optional(:get_mfa_questions_answers).maybe(:bool?)
+        optional(:date_from).maybe(:date?)
+        optional(:date_to) { date? | date_time? }
+        optional(:accounts_filter).each(:str?)
+
+        optional(:refresh_delta).each do
+          schema do
+            required(:account_id).filled(:str?)
+            required(:transaction_id).filled(:str?)
+          end
+        end
+
+        optional(:days_of_transactions).included_in?(['Days90', 'Days360'])
+        optional(:most_recent).maybe(:bool?)
+        optional(:most_recent_cached).maybe(:bool?)
+      end
+
+      # @see https://sandbox-api.flinks.io/Readme/#get-accounts-summary
+      # @param request_id [String]
+      # @param options [Hash]
+      # @return [Hash]
+      def accounts_summary(request_id:, options: {})
+        payload = AccountSummaryRequestSchema.call(options.merge(request_id: request_id))
+        raise ArgumentError, error_message(payload) unless payload.success?
+
+        post("#{customer_id}/BankingServices/GetAccountsSummary", body: payload.to_h)
+      end
+
+      # @see https://sandbox-api.flinks.io/Readme/#get-accounts-detail
+      # @param request_id [String]
+      # @param options [Hash]
+      # @return [Hash]
+      def accounts_detail(request_id:, options: {})
+        payload = AccountDetailRequestSchema.call(options.merge(request_id: request_id))
+        raise ArgumentError, error_message(payload) unless payload.success?
+
+        post("#{customer_id}/BankingServices/GetAccountsDetail", body: payload.to_h)
+      end
+
+      # @see https://sandbox-api.flinks.io/Readme/#get-accounts-summary
+      # @param request_id [String]
+      # @return [Hash]
+      def accounts_summary_async(request_id:)
+        get("#{customer_id}/BankingServices/GetAccountsSummaryAsync/#{request_id}")
+      end
+
+      # @see https://sandbox-api.flinks.io/Readme/#get-accounts-detail
+      # @param request_id [String]
+      # @return [Hash]
+      def accounts_detail_async(request_id:)
+        get("#{customer_id}/BankingServices/GetAccountsDetailAsync/#{request_id}")
+      end
+    end
+  end
+end

data/lib/flinks/api/card.rb

@@ -0,0 +1,13 @@
+module Flinks
+  module API
+    module Card
+
+      # https://sandbox-api.flinks.io/Readme/#delete-card-information
+      # @param card_id [String]
+      # @return [Hash]
+      def delete_card(card_id:)
+        get("#{customer_id}/BankingServices/DeleteCard/#{card_id}")
+      end
+    end
+  end
+end

data/lib/flinks/api/refresh.rb

@@ -0,0 +1,28 @@
+module Flinks
+  module API
+    module Refresh
+      
+      # @see https://sandbox-api.flinks.io/Readme/#scheduling-background-refresh
+      # @param login_id [String]
+      # @return [Hash]
+      def activate_scheduled_refresh(login_id:)
+        patch("#{customer_id}/BankingServices/ActivateScheduledRefresh/#{login_id}")
+      end
+
+      # @see https://sandbox-api.flinks.io/Readme/#scheduling-background-refresh
+      # @param login_id [String]
+      # @return [Hash]
+      def deactivate_scheduled_refresh(login_id:)
+        patch("#{customer_id}/BankingServices/DeactivateScheduledRefresh/#{login_id}")
+      end
+
+      # @see https://sandbox-api.flinks.io/Readme/#scheduling-background-refresh
+      # @param activated [Boolean]
+      # @param login_id [String]
+      # @return [Hash]
+      def set_scheduled_refresh(activated, login_id:)
+        patch("#{customer_id}/BankingServices/SetScheduledRefresh", params: { login_id: login_id, is_activated: activated })
+      end
+    end
+  end
+end

data/lib/flinks/api/statement.rb

@@ -0,0 +1,30 @@
+module Flinks
+  module API
+    module Statement
+
+      StatementRequestSchema = Dry::Validation.Schema do
+        optional(:accounts_filter).each(:str?)
+        optional(:number_of_statements).included_in?(['MostRecent', 'Months3', 'Months12'])
+        optional(:most_recent).maybe(:bool?)
+        optional(:most_recent_cached).maybe(:bool?)
+      end
+
+      # @see https://sandbox-api.flinks.io/Readme/#get-pdf-statements
+      # @param options [Hash]
+      # @return [Hash]
+      def statements(options: {})
+        payload = StatementRequestSchema.call(options)
+        raise ArgumentError, error_message(payload) unless payload.success?
+
+        post("#{customer_id}/BankingServices/GetStatements", body: payload.to_h)
+      end
+
+      # @see https://sandbox-api.flinks.io/Readme/#get-pdf-statements
+      # @param request_id [String]
+      # @return [Hash]
+      def statements_async(request_id:)
+        get("#{customer_id}/BankingServices/GetStatementsAsync/#{request_id}")
+      end
+    end
+  end
+end

data/lib/flinks/client.rb

@@ -0,0 +1,36 @@
+require 'active_support'
+require 'active_support/core_ext/object'
+require 'dry-initializer'
+require 'dry-validation'
+
+require 'flinks/version'
+require 'flinks/request'
+require 'flinks/api/account'
+require 'flinks/api/card'
+require 'flinks/api/refresh'
+require 'flinks/api/statement'
+
+module Flinks
+  class Client
+    extend Dry::Initializer
+
+    include Flinks::Request
+    include Flinks::API::Account
+    include Flinks::API::Card
+    include Flinks::API::Refresh
+    include Flinks::API::Statement
+
+    option :customer_id
+    option :api_endpoint, default: proc { "https://sandbox.flinks.io/v3/" }
+    option :user_agent,   default: proc { "Flinks Ruby Gem #{Flinks::VERSION}" }
+    option :on_error,     default: proc { proc {} }
+    option :debug,        default: proc { false }
+
+    #
+    # @param validation [Dry::Validation::Result]
+    # @return [String]
+    def error_message(validation)
+      validation.messages(full: true).values.flatten.to_sentence
+    end
+  end
+end

data/lib/flinks/error.rb

@@ -0,0 +1,107 @@
+module Flinks
+  class Error < StandardError
+    attr_reader :response, :code
+
+    # @param response [HTTP::Response]
+    # @return [Flinks::Error]
+    def self.from_response(response)
+      klass = case response.code
+              when 400      then Flinks::BadRequest
+              when 401      then Flinks::Unauthorized
+              when 403      then error_for_403(response)
+              when 404      then Flinks::NotFound
+              when 405      then Flinks::MethodNotAllowed
+              when 406      then Flinks::NotAcceptable
+              when 409      then Flinks::Conflict
+              when 415      then Flinks::UnsupportedMediaType
+              when 422      then Flinks::UnprocessableEntity
+              when 400..499 then Flinks::ClientError
+              when 500      then Flinks::InternalServerError
+              when 501      then Flinks::NotImplemented
+              when 502      then Flinks::BadGateway
+              when 503      then Flinks::ServiceUnavailable
+              when 500..599 then Flinks::ServerError
+              else
+                self
+              end
+
+      klass.new(response)
+    end
+
+    # @param response [HTTP::Response]
+    # @return [Flinks::Error]
+    def self.error_for_403(response)
+      if response.parse['FlinksCode'] == 'TOO_MANY_REQUESTS'
+        Flinks::TooManyRequests
+      else
+        Flinks::Forbidden
+      end
+    end
+
+    # @param response [HTTP::Response]
+    # @return [Flinks::Error]
+    def initialize(response)
+      @response = response
+      @code = response.code
+
+      super(build_message)
+    end
+
+    # @return [String]
+    def build_message
+      message = response.parse['Message']
+      message << " - FlinksCode: #{response.parse['FlinksCode']}"
+    rescue HTTP::Error
+      response.reason
+    end
+  end
+
+  # Raised when API returns a 400..499 HTTP status code
+  class ClientError < Error; end
+
+  # Raised when API returns a 400 HTTP status code
+  class BadRequest < ClientError; end
+
+  # Raised when API returns a 401 HTTP status code
+  class Unauthorized < ClientError; end
+
+  # Raised when API returns a 403 HTTP status code
+  class Forbidden < ClientError; end
+
+  # Raised when API returns a 403 HTTP status code
+  # Rate limit exceeded
+  class TooManyRequests < ClientError; end
+
+  # Raised when API returns a 404 HTTP status code
+  class NotFound < ClientError; end
+
+  # Raised when API returns a 405 HTTP status code
+  class MethodNotAllowed < ClientError; end
+
+  # Raised when API returns a 406 HTTP status code
+  class NotAcceptable < ClientError; end
+
+  # Raised when API returns a 409 HTTP status code
+  class Conflict < ClientError; end
+
+  # Raised when API returns a 415 HTTP status code
+  class UnsupportedMediaType < ClientError; end
+
+  # Raised when API returns a 422 HTTP status code
+  class UnprocessableEntity < ClientError; end
+
+  # Raised when API returns a 500..599 HTTP status code
+  class ServerError < Error; end
+
+  # Raised when API returns a 500 HTTP status code
+  class InternalServerError < ServerError; end
+
+  # Raised when API returns a 501 HTTP status code
+  class NotImplemented < ServerError; end
+
+  # Raised when API returns a 502 HTTP status code
+  class BadGateway < ServerError; end
+
+  # Raised when API returns a 503 HTTP status code
+  class ServiceUnavailable < ServerError; end
+end

data/lib/flinks/request.rb

@@ -0,0 +1,66 @@
+require 'http'
+
+require 'flinks/error'
+
+module Flinks
+  module Request
+
+    # Performs a HTTP Get request
+    #
+    # @param path [String]
+    # @param params [Hash]
+    def get(path, params: {})
+      request(:get, URI.parse(api_endpoint).merge(path), params: params)
+    end
+
+    # Performs a HTTP Post request
+    #
+    # @param path [String]
+    # @param params [Hash]
+    # @param body [Hash]
+    def post(path, params: {}, body: {})
+      request(:post, URI.parse(api_endpoint).merge(path), params: params, body: body)
+    end
+
+    # Performs a HTTP Patch request
+    #
+    # @param path [String]
+    # @param params [Hash]
+    # @param body [Hash]
+    def patch(path, params: {}, body: {})
+      request(:patch, URI.parse(api_endpoint).merge(path), params: params, body: body)
+    end
+
+
+    private
+
+    # @return [HTTP::Client]
+    # @raise [Flinks::Error]
+    def request(method, path, params: {}, body: {})
+      headers = {
+        'Accept'     => "application/json",
+        'User-Agent' => user_agent
+      }
+
+      # Build payload
+      payload = body.transform_keys { |k| k.to_s.camelize }
+
+      # Perform request
+      response = Http.headers(headers).send(method, path, params: params, json: payload)
+
+      if debug
+        p response
+      end
+
+      # Pass on errors when HTTP status included in 400 to 599
+      if (400..599).include?(response.code)
+        raise Error.from_response(response)
+
+        on_error.call(response.code, response.reason, body)
+      end
+
+      # Return parsed json body
+      response.parse
+    end
+  end
+end

data/lib/flinks/version.rb

@@ -0,0 +1,3 @@
+module Flinks
+  VERSION = File.read('VERSION')
+end

data/spec/lib/api/account.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Flinks::API::Account do
+  let(:api_endpoint) { Flinks::Client.dry_initializer.definitions[:api_endpoint].default.call }
+  let(:client) { Flinks.new(customer_id: 'customer_id') }
+  let(:request_id) { 'request_id' }
+
+  describe '#accounts_summary' do
+    before do
+      stub_request(:post, /#{api_endpoint}/)
+        .to_return(status: 200, body: "{}", headers: { 'Content-Type'=>'application/json' })
+    end
+
+    it "returns an object" do
+      expect(client.accounts_summary(request_id: request_id)).to be_a(Hash)
+    end
+
+    context "with valid options" do
+      let(:options) do
+        {
+          direct_refresh: true,
+          with_balance: true,
+          with_transactions: true,
+          with_account_identity: true,
+          most_recent: true,
+          most_recent_cached: true
+        }
+      end
+
+      it "returns an object" do
+        expect(client.accounts_summary(request_id: request_id, options: options)).to be_a(Hash)
+      end
+    end
+
+    context "with invalid options" do
+      let(:options) do
+        {
+          direct_refresh: 'invalid',
+          with_balance: 'invalid',
+          with_transactions: 'invalid',
+          with_account_identity: 'invalid',
+          most_recent: 'invalid',
+          most_recent_cached: 'invalid'
+        }
+      end
+
+      it "raises an error" do
+        expect {
+          client.accounts_summary(request_id: request_id, options: options)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#accounts_detail' do
+    before do
+      stub_request(:post, /#{api_endpoint}/)
+        .to_return(status: 200, body: "{}", headers: { 'Content-Type'=>'application/json' })
+    end
+
+    context "with valid options" do
+      let(:options) do
+        {
+          with_account_identity: true,
+          with_kyc: true,
+          with_transactions: true,
+          with_balance: true,
+          get_mfa_questions_answers: true,
+          date_from: Date.today,
+          date_to: Date.today,
+          accounts_filter: ['string'],
+          refresh_delta: [{ account_id: 'id', transaction_id: 'id' }],
+          days_of_transactions: 'Days90',
+          most_recent: true,
+          most_recent_cached: true
+        }
+      end
+
+      it "returns an object" do
+        expect(client.accounts_detail(request_id: request_id, options: options)).to be_a(Hash)
+      end
+    end
+
+    context "with invalid options" do
+      let(:options) do
+        {
+          with_account_identity: 'invalid',
+          with_kyc: 'invalid',
+          with_transactions: 'invalid',
+          with_balance: 'invalid',
+          get_mfa_questions_answers: 'invalid',
+          date_from: 'invalid',
+          date_to: 'invalid',
+          accounts_filter: 'invalid',
+          refresh_delta: 'invalid',
+          days_of_transactions: 'invalid',
+          most_recent: 'invalid',
+          most_recent_cached: 'invalid'
+        }
+      end
+
+      it "raises an error" do
+        expect {
+          client.accounts_detail(request_id: request_id, options: options)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#accounts_summary_async' do
+    before do
+      stub_request(:get, /#{api_endpoint}/)
+        .to_return(status: 200, body: "{}", headers: { 'Content-Type'=>'application/json' })
+    end
+
+    it "returns an object" do
+      expect(client.accounts_summary_async(request_id: request_id)).to be_a(Hash)
+    end
+  end
+
+  describe '#accounts_detail_async' do
+    before do
+      stub_request(:get, /#{api_endpoint}/)
+        .to_return(status: 200, body: "{}", headers: { 'Content-Type'=>'application/json' })
+    end
+
+    it "returns an object" do
+      expect(client.accounts_detail_async(request_id: request_id)).to be_a(Hash)
+    end
+  end
+end