budgea.rb

# encoding: UTF-8

# MIT License
#
# Copyright (c) 2014-2020 Budget Insight
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.


begin
  require 'rubygems'
  require 'rest_client'
rescue LoadError
  puts %{
  I'm so sorry to ask you for the rest_client gem. \
  In fact ruby has no efficent HTTP client at this time (w/o big bug or missing feature)

  $ gem install rest_client -v 1.7.3
        }
  exit 1
end
require 'base64'
require 'open-uri'
require 'json'

# Usage
#
#   Normal flow with `client_id` and `client_secret`
#   ```
#   require 'budgea'
#   management_token = "XXXXXX"
#   budgea_client = Budgea::Client.new 'XXX.biapi.pro', { client_id: ENV['BUDGEA_CLIENT_ID'],
#                                                  client_secret: ENV['BUDGEA_CLIENT_SECRET'],
#                                                  redirect_uri: 'https://lvh.me:3000/user/settings' }
#
#   puts client.get_authentication_url('', types: 'providers')    # Example with a 'provider' Webview
#   puts client.get_authentication_button('', types: 'providers') # Example with a 'provider' Webview
#   ```
#
#   With a management token
#   ```
#   require 'budgea'
#   management_token = "XXXXXX" # TODO LIEN VERS PAGE MANAGEMENT TOKEN
#   budgea_client = Budgea::Client.new 'XXXXXX.biapi.pro', { access_token: management_token, access_token_type: 'bearer' }
#
#   budgea_client.get('/clients') # Adminitration endpoints in API Reference
#   ```

module Budgea
  class Client
    VERSION = '2.1.0'.freeze

    attr_accessor :client_id
    attr_accessor :client_secret
    attr_accessor :access_token
    attr_writer   :access_token_type

    def access_token_type
      @access_token_type || 'bearer'
    end

    def initialize(domain, settings = {})
      @settings = {
        connect_endpoint: '/auth/webview/connect',
        manage_endpoint: '/auth/webview/manage',
        token_endpoint: '/auth/token/access',
        code_endpoint: '/auth/token/code',
        base_url: "https://#{domain}/2.0",
        http_headers: { 'User-Agent': "BudgeaAPI Client #{VERSION}" },
        client_id: nil,
        client_secret: nil,
        access_token_param_name: 'token',
        redirect_uri: nil,
        transfer_endpoint: '/auth/webview/transfer',
        transfer_redirect_uri: nil
      }.merge(settings)

      @access_token      = @settings[:access_token] ? @settings[:access_token] : nil
      @access_token_type = @settings[:access_token_type] ? @settings[:access_token_type] : 'bearer'
    end

    def handle_callback(params = {})
      raise AuthFailed, params['error'] || 'Authentication failed' if params['error']
      return false unless params.key?('code')
      new_params = { code: params['code'], redirect_uri: @settings[:redirect_uri], grant_type: 'authorization_code' }

      uri = URI.parse(@settings[:base_url] + @settings[:token_endpoint])
      #::RestClient.proxy = 'http://localhost:8888'
      resource = ::RestClient::Resource.new uri.to_s, @settings[:client_id], @settings[:client_secret]
      response = resource.post(new_params)

      raise ConnectionError, 'Can’t reach remote URI' unless response.code == 200

      json_response = JSON.parse response.to_str
      raise AuthFailed, json_response['error'] || 'Authentication failed' if json_response['error']

      @access_token = json_response['access_token']
      @access_token_type = json_response['token_type']
      params[:state] || true
    end

    # Method: get_connect_url
    #
    # Parameter `connector_capabilities` can be either `bank` or `document`
    #   Default value is `bank`, no need to specify it in this case
    #
    # Usage:
    #   client.get_connect_url('')                                     # Add a bank
    #    OR
    #   client.get_connect_url('', connector_capabilities: 'document') # Add a provider
    #
    def get_connect_url(state = '', connector_capabilities: nil)
      query_string_params = {
        response_type: 'code',
        client_id: @settings[:client_id],
        redirect_uri: @settings[:redirect_uri],
        state: state
      }
      query_string_params[:connector_capabilities] = connector_capabilities.to_s if connector_capabilities.present?

      endpoint_uri_with_params(@settings[:authorization_endpoint], query_string_params)
    end

    # Compatibility alias for get_connect_url
    def get_authentication_url(state = '', connector_capabilities: nil)
      get_connect_url(state, connector_capabilities)
    end

    # Usage
    #   client.get_connect_button('Partager ses comptes')                                          # Add a bank
    #    OR
    #   client.get_connect_button('Partager ses fournisseurs', connector_capabilities: 'document') # Add a provider
    #
    def get_connect_button(text, connector_capabilities: nil)
      authentication_url = get_connect_url('', connector_capabilities: connector_capabilities)

      button = "
                <a href='#{authentication_url}'
                  style=\"display: inline-block; background: #ff6100; padding: 8px 16px; border-radius: 4px; color: white; text-decoration: none; font: 12pt/14pt 'Roboto', sans-serif\">
                  #{text}
                </a>"
      button.html_safe
    end

    # Compatibility alias for get_connect_url
    def get_authentication_button(text, connector_capabilities: nil)
      get_connect_button(text, connector_capabilities)
    end

    def get_manage_url(state = '', connector_capabilities: nil)
      code_endpoint_response = get(@settings[:code_endpoint])
      code_endpoint_response = JSON.parse(code_endpoint_response) if code_endpoint_response.is_a?(String)

      query_string_params = {
        response_type: 'code',
        client_id: @settings[:client_id],
        redirect_uri: @settings[:redirect_uri],
        state: state,
        code: code_endpoint_response['code']
      }
      query_string_params[:connector_capabilities] = connector_capabilities.to_s if connector_capabilities.present?

      endpoint_uri_with_params(@settings[:authorization_endpoint], query_string_params)
    end

    # Compatibility alias for get_manage_url
    def get_settings_url(text, connector_capabilities: nil)
      get_manage_url(text, connector_capabilities)
    end

    def get_transfer_url(state = '')
      code_endpoint_response = get(@settings[:code_endpoint])
      code_endpoint_response = JSON.parse(code_endpoint_response) if code_endpoint_response.is_a?(String)

      query_string_params = {
        redirect_uri: @settings[:transfer_redirect_uri],
        state: state,
        code: code_endpoint_response['code']
      }

      endpoint_uri_with_params(@settings[:transfer_endpoint], query_string_params)
    end

    # Compatibility alias for get_transfer_url
    def get_transfers_url(state = '')
      get_transfer_url(text, connector_capabilities)
    end

    def get(uri, params = {})
      fetch(uri, params)
    end

    def fetch(uri, params = {}, method = :get, http_headers = {})
      http_headers.merge!(@settings[:http_headers])
      # http_headers.merge!({:content_type => :json, :accept => :json})
      http_headers[:accept] = :json

      if @access_token
        case @access_token_type
        when 'url'
          raise ArgumentException, 'You need to give parameters as Hash if you want to give the token within the URI.' unless params.is_a?(Hash)
          params[@access_token_param_name] = @access_token
        when 'bearer'
          http_headers['Authorization'] = "Bearer #{@access_token}"
        when 'oauth'
          http_headers['Authorization'] = "OAuth #{@access_token}"
        else
          raise InvalidAccessTokenType, "Invalid access token type: #{@access_token_type}"
        end
      end

      # RestClient.proxy = 'http://localhost:8888'
      uri = absurl(uri)
      ressource = RestClient::Resource.new uri.to_s
      response = nil
      begin
        final_params = params.merge(http_headers)
        response = ressource.send(method, params.merge(final_params))
      rescue RestClient::Exception => e
        message = JSON.parse(e.response.to_str)
        raise(AuthRequired, message) if response.code.in?([401, 403])
        return message
      end

      if response.headers[:content_type] == 'application/json'
        JSON.parse(response.to_str)
      else
        response.to_str
      end
    end

    def get_accounts(_expand = nil)
      ret = get('/users/me/accounts')

      ret['accounts'] ? ret['accounts'].map { |account| Account.new(self, account) } : ret
    end

    def get_transactions(account_id = nil)
      ret = if account_id
              get("/users/me/accounts/#{account_id}/transactions", 'expand' => 'category')
            else
              get('/users/me/transactions/', 'expand' => 'category')
            end
      ret['transactions'] ? ret['transactions'].map { |transaction| Transaction.new(self, transaction) } : ret
    end

    private

    def absurl(url)
      url.start_with?('http') ? File.join(@settings[:base_url], url) : url
    end

    def endpoint_uri_with_params(endpoint_path, query_string_params)
      endpoint_url = File.join(@settings[:base_url], endpoint_path)

      uri = URI.parse(endpoint_url)
      uri.query = URI.encode_www_form(query_string_params)
      uri.to_s
    end
  end

  class Transaction
    attr_reader :id, :date, :value, :nature
    attr_reader :original_wording, :simplified_wording, :stemmed_wording
    attr_reader :category, :client
    attr_reader :state, :date_scraped, :rdate, :coming, :active, :comment

    def initialize(client, resp)
      @client             = client
      @id                 = resp['id']
      @date               = resp['date']
      @value              = resp['value']
      @nature             = resp['nature']
      @original_wording   = resp['original_wording']
      @simplified_wording = resp['simplified_wording']
      @stemmed_wording    = resp['stemmed_wording']
      @category           = client.get('category', nil)
      @state              = resp['state']
      @date_scraped       = resp['date_scraped']
      @rdate              = resp['rdate']
      @coming             = resp['coming']
      @active             = resp['active']
      @comment            = resp['comment']
    end
  end

  class Account
    attr_reader :client
    attr_reader :id, :number, :name, :balance, :last_update

    def initialize(client, response)
      @client      = client
      @id          = response['id']
      @number      = response['number']
      @name        = response['name']
      @balance     = response['balance']
      @last_update = response['last_update']
    end

    def transactions
      ret = client.get_transactions(id)
      ret['transactions'] ? ret['transactions'].map { |transaction| Transaction.new(client, transaction) } : ret
    end
  end

  class BudgeaException < RuntimeError; end
  class ConnectionError < BudgeaException; end
  class InvalidAccessTokenType < BudgeaException; end
  class AuthRequired < BudgeaException; end
  class AuthFailed < BudgeaException; end
end