finapps 1.0.8 → 2.0.2

data/lib/finapps/rest/client.rb

@@ -1,214 +1,26 @@
 module FinApps
   module REST
-    class Client
+    class Client < BaseClient # :nodoc:
       include FinApps::REST::Defaults
-      include FinApps::Logging
-      include FinApps::REST::Connection
 
-      attr_reader :config, :company_credentials
-
-      # @param [String] company_identifier
-      # @param [String] company_token
+      # @param [String] tenant_identifier
+      # @param [String] tenant_token
       # @param [Hash] options
       # @return [FinApps::REST::Client]
-      def initialize(company_identifier, company_token, options = {})
-        @config = DEFAULTS.merge! options
-        logger_config config
+      def initialize(tenant_identifier, tenant_token, logger=nil, options={})
+        raise FinApps::MissingArgumentsError.new 'Invalid company_identifier.' if tenant_identifier.blank?
+        raise FinApps::MissingArgumentsError.new 'Invalid company_token.' if tenant_token.blank?
 
-        @company_credentials = {:company_identifier => company_identifier, :company_token => company_token}
-        @company_credentials.validate_required_strings!
-      end
+        merged_options = FinApps::REST::Defaults::DEFAULTS.merge options
+        merged_options[:tenant_credentials] = {identifier: tenant_identifier,
+                                               token:      tenant_token}
 
-      def connection
-        @connection ||= set_up_connection(self.company_credentials, @config)
+        super(merged_options, logger)
       end
 
       def users
         @users ||= FinApps::REST::Users.new self
       end
-
-      def institutions
-        @institutions ||= FinApps::REST::Institutions.new self
-      end
-
-      def user_institutions
-        @user_institutions ||= FinApps::REST::UserInstitutions.new self
-      end
-
-      def transactions
-        @transactions ||= FinApps::REST::Transactions.new self
-      end
-
-      def categories
-        @categories ||= FinApps::REST::Categories.new self
-      end
-
-      def budget_models
-        @budget_models ||= FinApps::REST::BudgetModels.new self
-      end
-
-      def budget_calculation
-        @budget_calculation ||= FinApps::REST::BudgetCalculation.new self
-      end
-
-      def budgets
-        @budgets ||= FinApps::REST::Budgets.new self
-      end
-
-      def cashflows
-        @cashflows ||= FinApps::REST::Cashflows.new self
-      end
-
-      def alert
-        @alert ||= FinApps::REST::Alert.new self
-      end
-
-      def alert_definition
-        @alert_definition ||= FinApps::REST::AlertDefinition.new self
-      end
-
-      def alert_settings
-        @alert_settings ||= FinApps::REST::AlertSettings.new self
-      end
-
-      def alert_preferences
-        @alert_preferences ||= FinApps::REST::AlertPreferences.new self
-      end
-
-      def rule_sets
-        @rule_sets ||= FinApps::REST::Relevance::Rulesets.new self
-      end
-
-      # Performs HTTP GET, POST, UPDATE and DELETE requests.
-      # You shouldn't need to use this method directly, but it can be useful for debugging.
-      # Returns a hash obtained from parsing the JSON object in the response body.
-      #
-      # @param [String] path
-      # @param [String] method
-      # @param [Proc] proc
-      # @return [Hash,Array<String>]
-      def send_request(path, method, params = {}, &proc)
-        raise FinApps::REST::MissingArgumentsError.new 'Missing argument: path.' if path.blank?
-        raise FinApps::REST::MissingArgumentsError.new 'Missing argument: method.' if method.blank?
-
-        result, error_messages = nil, []
-
-        begin
-          case method
-            when :get
-              response = get(path)
-            when :post
-              response = post(path, params)
-            when :put
-              response = put(path, params)
-            when :delete
-              response = delete(path, params)
-            else
-              raise FinApps::REST::InvalidArgumentsError.new "Method not supported: #{method}."
-          end
-
-          if response.present?
-            result = block_given? ? proc.call(response) : response.body
-          else
-            logger.error "##{__method__} => Null response found. Unable to process it."
-          end
-
-        rescue FinApps::REST::InvalidArgumentsError => error
-          raise error
-        rescue FinApps::REST::Error => error
-          error_messages = error.error_messages
-        rescue Faraday::ParsingError => error
-          error_messages << 'Unable to parse the server response.'
-          logger.error "##{__method__} => Faraday::ParsingError, #{error.to_s}"
-        rescue Exception => error
-          error_messages << 'Unexpected error.'
-          logger.fatal "##{__method__} => Exception, #{error.to_s}"
-          logger.fatal error
-        ensure
-          logger.debug "##{__method__} => Failed, error_messages: #{error_messages.pretty_inspect}" if error_messages.present?
-        end
-
-        return result, error_messages
-      end
-
-      # @param [String] user_identifier
-      # @param [String] user_token
-      def user_credentials!(user_identifier, user_token)
-        {:user_identifier => user_identifier, :user_token => user_token}.validate_required_strings!
-
-        @config[:user_identifier] = user_identifier
-        @config[:user_token] = user_token
-
-        logger.debug "##{__method__} => Attempting to set user credentials on current connection."
-        @connection = set_up_connection(company_credentials, config)
-      end
-
-      private
-
-      # Performs an HTTP GET request.
-      # Returns a hash obtained from parsing
-      # the JSON object in the response body.
-      #
-      # @param [String] path
-      # @return [Hash,Array<String>]
-      def get(path)
-        raise MissingArgumentsError.new 'Missing argument: path.' if path.blank?
-
-        logger.debug "##{__method__} => GET path:#{path}"
-        connection.get { |req| req.url path }
-      end
-
-      # Performs an HTTP POST request.
-      # Returns a hash obtained from parsing
-      # the JSON object in the response body.
-      #
-      # @param [String] path
-      # @param [Hash] params
-      # @return [Hash,Array<String>]
-      def post(path, params = {})
-        raise MissingArgumentsError.new 'Missing argument: path.' if path.blank?
-
-        logger.debug "##{__method__} => POST path:#{path} params:#{skip_sensitive_data params }"
-        connection.post do |req|
-          req.url path
-          req.body = params
-        end
-      end
-
-      # Performs an HTTP PUT request.
-      # Returns a hash obtained from parsing
-      # the JSON object in the response body.
-      #
-      # @param [String] path
-      # @param [Hash] params
-      # @return [Hash,Array<String>]
-      def put(path, params = {})
-        raise MissingArgumentsError.new 'Missing argument: path.' if path.blank?
-
-        logger.debug "##{__method__} => PUT path:#{path} params:#{skip_sensitive_data(params)}"
-        connection.put do |req|
-          req.url path
-          req.body = params
-        end
-      end
-
-      # Performs an HTTP DELETE request.
-      # Returns a hash obtained from parsing
-      # the JSON object in the response body.
-      #
-      # @param [String] path
-      # @param [Hash] params
-      # @return [Hash,Array<String>]
-      def delete(path, params = {})
-        raise MissingArgumentsError.new 'Missing argument: path.' if path.blank?
-
-        logger.debug "##{__method__} => DELETE path:#{path} params:#{skip_sensitive_data(params)}"
-        connection.delete do |req|
-          req.url path
-          req.body = params
-        end
-      end
-
     end
   end
-end
+end

data/lib/finapps/rest/configuration.rb

@@ -0,0 +1,55 @@
+module FinApps
+  module REST
+    class Configuration # :nodoc:
+      include FinApps::HashConstructable
+
+      using CoreExtensions::Integerable
+
+      RUBY = "#{RUBY_ENGINE}/#{RUBY_PLATFORM} #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}".freeze
+      HEADERS = {
+        accept:     'application/json',
+        user_agent: "finapps-ruby/#{FinApps::VERSION} (#{RUBY})"
+      }.freeze
+
+      attr_accessor :host, :timeout, :tenant_credentials, :user_credentials, :url,
+                    :proxy_addr, :proxy_port, :proxy_user, :proxy_pass,
+                    :retry_limit, :log_level
+
+      def initialize(options)
+        super(options, FinApps::REST::Defaults::DEFAULTS)
+        validate
+        @url = "#{host}/v#{FinApps::REST::Defaults::API_VERSION}/"
+      end
+
+      def connection_options
+        {url:     url,
+         request: {open_timeout: timeout, timeout: timeout},
+         headers: {accept: HEADERS[:accept], user_agent: HEADERS[:user_agent]}}
+      end
+
+      def valid_user_credentials?
+        valid_credentials? user_credentials
+      end
+
+      private
+
+      def validate
+        raise FinApps::MissingArgumentsError.new 'Missing tenant_credentials.' unless valid_tenant_credentials?
+        raise FinApps::InvalidArgumentsError.new "Invalid argument. {host: #{host}}" unless valid_host?
+        raise FinApps::InvalidArgumentsError.new "Invalid argument. {timeout: #{timeout}}" unless timeout.integer?
+      end
+
+      def valid_tenant_credentials?
+        valid_credentials? tenant_credentials
+      end
+
+      def valid_credentials?(h)
+        h.is_a?(Hash) && %i(identifier token).all? {|x| h.key? x } && h.values.all?(&:present?)
+      end
+
+      def valid_host?
+        host.start_with?('http://', 'https://')
+      end
+    end
+  end
+end

data/lib/finapps/rest/connection.rb

@@ -1,50 +1,31 @@
-require 'pp'
-
 module FinApps
   module REST
-    module Connection
-      include FinApps::REST::Defaults
-
-      # @param [Hash] company_credentials
-      # @param [Hash] config
-      # @return [Faraday::Connection]
-      def set_up_connection(company_credentials, config)
-        host_url = config[:host].blank? ? DEFAULTS[:host] : config[:host]
-        raise InvalidArgumentsError.new "Invalid argument: host_url: #{host_url}" unless host_url.start_with?('http://', 'https://')
-
-        base_url = "#{host_url}/v#{API_VERSION}"
-        timeout = config[:timeout].blank? ? DEFAULTS[:timeout] : config[:timeout]
+    module Connection # :nodoc:
+      module_function
 
-        Faraday.new(:url => base_url,
-                    :request => {
-                        :open_timeout => timeout,
-                        :timeout => timeout},
-                    :headers => {
-                        :accept => HEADERS[:accept],
-                        :user_agent => HEADERS[:user_agent]}) do |conn|
+      def faraday(config, logger)
+        Faraday.new(config.connection_options) do |conn|
+          # tenant level authentication
+          conn.use FinApps::Middleware::TenantAuthentication, config.tenant_credentials
 
-          # add basic authentication header if user credentials were provided
-          user_identifier = config[:user_identifier]
-          user_token = config[:user_token]
-          conn.request :basic_auth, user_identifier, user_token unless user_identifier.blank? || user_token.blank?
-
-          # company level authentication
-          conn.use FinApps::Middleware::ApiToken, company_credentials
+          # user level authentication
+          if config.valid_user_credentials?
+            conn.request :basic_auth, config.user_credentials[:identifier], config.user_credentials[:token]
+          end
 
           conn.request :json
           conn.request :retry
           conn.request :multipart
           conn.request :url_encoded
-          conn.use FinApps::Middleware::RaiseHttpExceptions
+          conn.use FinApps::Middleware::RaiseError
           conn.response :rashify
-          conn.response :json, :content_type => /\bjson$/
-          conn.use FinApps::Middleware::ResponseLogger
+          conn.response :json, content_type: /\bjson$/
+          conn.response :logger, logger # , bodies: true
 
           # Adapter (ensure that the adapter is always last.)
           conn.adapter :typhoeus
         end
       end
-
     end
   end
-end
+end

data/lib/finapps/rest/defaults.rb

@@ -1,89 +1,80 @@
 module FinApps
   module REST
     module Defaults
-
-      API_VERSION = '1'
-
-      HEADERS = {
-          :accept => 'application/json',
-          :user_agent => "finapps-ruby/#{FinApps::VERSION} (#{RUBY_ENGINE}/#{RUBY_PLATFORM} #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL})"
-      }.freeze
+      API_VERSION = '2'.freeze
 
       # noinspection SpellCheckingInspection
       DEFAULTS = {
-          :host => 'https://api.financialapps.com',
-          :timeout => 30,
-          :proxy_addr => nil,
-          :proxy_port => nil,
-          :proxy_user => nil,
-          :proxy_pass => nil,
-          :retry_limit => 1,
-          :log_level => Logger::INFO
-      }
-
+        host:        'https://dev.financialapps.com',
+        timeout:     30,
+        proxy_addr:  nil,
+        proxy_port:  nil,
+        proxy_user:  nil,
+        proxy_pass:  nil,
+        retry_limit: 1,
+        log_level:   Logger::INFO
+      }.freeze
 
       END_POINTS = {
-          :users_create => 'users/new',
-          :users_update => 'user',
-          :users_update_password => 'user/password',
-          :users_delete => 'users/:public_id',
-          :users_show => 'users/:public_id',
-          :users_login => 'users/login',
-
-          :relevance_rulesets_list => 'relevance/ruleset/names',
-          :relevance_rulesets_show => 'relevance/ruleset/:ruleset_name',
-          :relevance_rulesets_run => 'relevance/run',
+        users_create:              'users/new',
+        users_update:              'user',
+        users_update_password:     'user/password',
+        users_delete:              'users/:public_id',
+        users_show:                'users/:public_id',
+        users_login:               'users/login',
 
-          :institutions_list => 'institutions/:search_term/search',
-          :institutions_form => 'institutions/:site_id/form',
+        relevance_rulesets_list:   'relevance/ruleset/names',
+        relevance_rulesets_show:   'relevance/ruleset/:ruleset_name',
+        relevance_rulesets_run:    'relevance/run',
 
-          :user_institutions_list => 'institutions/user',
-          :user_institutions_add => 'institutions/:site_id/add',
-          :user_institutions_show => 'institutions/user/:user_institution_id',
-          :user_institutions_update => 'institutions/user/:user_institution_id/credentials',
-          :user_institutions_delete => 'institutions/user/:user_institution_id',
-          :user_institutions_status => 'institutions/user/:user_institution_id/status',
-          :user_institutions_mfa => 'institutions/user/:user_institution_id/mfa',
-          :user_institutions_refresh => 'institutions/user/refresh',
-          :user_institutions_form => 'institutions/user/:user_institution_id/form',
+        institutions_list:         'institutions/:search_term/search',
+        institutions_form:         'institutions/:site_id/form',
 
-          :transactions_show => 'transaction/:transaction_id',
-          :transactions_list => 'transactions/search',
-          :transactions_update => 'transactions/edit',
+        user_institutions_list:    'institutions/user',
+        user_institutions_add:     'institutions/:site_id/add',
+        user_institutions_show:    'institutions/user/:user_institution_id',
+        user_institutions_update:  'institutions/user/:user_institution_id/credentials',
+        user_institutions_delete:  'institutions/user/:user_institution_id',
+        user_institutions_status:  'institutions/user/:user_institution_id/status',
+        user_institutions_mfa:     'institutions/user/:user_institution_id/mfa',
+        user_institutions_refresh: 'institutions/user/refresh',
+        user_institutions_form:    'institutions/user/:user_institution_id/form',
 
-          :categories_list => 'categories',
-          :categories_new => 'categories',
-          :categories_update => 'categories',
-          :categories_show => 'categories/:category_id',
-          :categories_delete => 'categories/:category_id',
+        transactions_show:         'transaction/:transaction_id',
+        transactions_list:         'transactions/search',
+        transactions_update:       'transactions/edit',
 
-          :budget_models_list => 'budget/templates',
-          :budget_models_show => 'budget/template/:budget_model_id',
+        categories_list:           'categories',
+        categories_new:            'categories',
+        categories_update:         'categories',
+        categories_show:           'categories/:category_id',
+        categories_delete:         'categories/:category_id',
 
-          :budget_calculation_create => 'budget/template/:budget_model_id/:income',
-          :budget_calculation_show => 'categories',
+        budget_models_list:        'budget/templates',
+        budget_models_show:        'budget/template/:budget_model_id',
 
-          :budget_update => 'budget',
-          :budget_show => 'budget/:start_date/:end_date',
+        budget_calculation_create: 'budget/template/:budget_model_id/:income',
+        budget_calculation_show:   'categories',
 
-          :cashflow_show => 'cashflow/:start_date/:end_date',
+        budget_update:             'budget',
+        budget_show:               'budget/:start_date/:end_date',
 
-          :alert_list => 'alerts/:page/:requested/:sort/:asc/:read',
-          :alert_update => 'alerts/:alert_id/:read',
-          :alert_delete => 'alerts/:alert_id',
+        cashflow_show:             'cashflow/:start_date/:end_date',
 
-          :alert_definition_list => 'alerts/definitions',
-          :alert_definition_show => 'alerts/definitions/:alert_name',
+        alert_list:                'alerts/:page/:requested/:sort/:asc/:read',
+        alert_update:              'alerts/:alert_id/:read',
+        alert_delete:              'alerts/:alert_id',
 
-          :alert_settings_show => 'alerts/settings',
-          :alert_settings_update => 'alerts/settings',
+        alert_definition_list:     'alerts/definitions',
+        alert_definition_show:     'alerts/definitions/:alert_name',
 
-          :alert_preferences_show => 'alerts/preferences',
-          :alert_preferences_update => 'alerts/preferences'
+        alert_settings_show:       'alerts/settings',
+        alert_settings_update:     'alerts/settings',
 
+        alert_preferences_show:    'alerts/preferences',
+        alert_preferences_update:  'alerts/preferences'
 
       }.freeze
-
     end
   end
-end
+end

data/lib/finapps/rest/resource.rb

@@ -1,14 +1,11 @@
 module FinApps
   module REST
-    class Resource
-      include FinApps::Logging
-
+    class Resource # :nodoc:
       # @param [Hash] hash
       def initialize(hash)
-        hash.each { |k, v| instance_variable_set("@#{k}", v) unless v.nil? } if hash.present?
+        hash.each {|k, v| instance_variable_set("@#{k}", v) unless v.nil? } if hash.present?
         self
       end
-
     end
   end
-end
+end

data/lib/finapps/rest/resources.rb

@@ -1,10 +1,6 @@
 module FinApps
   module REST
-    class Resources
-
-      include FinApps::REST::Defaults
-      include FinApps::Logging
-
+    class Resources # :nodoc:
       attr_reader :client
 
       # @param [FinApps::REST::Client] client
@@ -13,6 +9,15 @@ module FinApps
         @client = client
       end
 
+      def create(params, endpoint)
+        raise MissingArgumentsError.new 'Missing argument: params.' if params.blank?
+
+        path = Defaults::END_POINTS[endpoint]
+        logger.debug "#{name}##{__method__} => path: #{path} params: #{params}"
+
+        results, error_messages = client.send_request(path, :post, params)
+        [results, error_messages]
+      end
     end
   end
-end
+end

data/lib/finapps/rest/users.rb

@@ -1,76 +1,42 @@
 module FinApps
   module REST
-
-    require 'erb'
-
-    class Users < FinApps::REST::Resources
-      include FinApps::Logging
+    class Users < FinApps::REST::Resources # :nodoc:
+      require 'erb'
       include FinApps::REST::Defaults
 
       # @param [String] public_id
       # @return [FinApps::REST::User, Array<String>]
       def show(public_id)
         raise MissingArgumentsError.new 'Missing argument: public_id.' if public_id.blank?
-        logger.debug "##{__method__} => public_id: #{public_id}"
 
         end_point = Defaults::END_POINTS[:users_show]
-        logger.debug "##{__method__} => end_point: #{end_point}"
-
         path = end_point.sub ':public_id', ERB::Util.url_encode(public_id)
+
         logger.debug "##{__method__} => path: #{path}"
 
-        user, error_messages = client.send_request(path, :get) { |r| User.new(r.body) }
-        return user, error_messages
+        results, error_messages = client.send_request(path, :get)
+        [results, error_messages]
       end
 
       # @param [Hash] params
       # @return [FinApps::REST::User, Array<String>]
-      def create(params = {})
-        raise MissingArgumentsError.new 'Missing argument: params.' if params.blank?
-        logger.debug "##{__method__} => params: #{skip_sensitive_data params}"
-
-        end_point = Defaults::END_POINTS[:users_create]
-        logger.debug "##{__method__} => end_point: #{end_point}"
-
-        user, error_messages = client.send_request(end_point, :post, params) { |r| User.new(r.body) }
-        return user, error_messages
+      def create(params)
+        super(params, :users_create)
       end
 
       # @param [Hash] params
       # @return [Array<String>]
-      def update(params = {})
-        logger.debug "##{__method__} => params: #{skip_sensitive_data params}"
-
-        path = Defaults::END_POINTS[:users_update]
-        logger.debug "##{__method__} => path: #{path}"
+      def update(params)
+        raise MissingArgumentsError.new 'Missing argument: params.' if params.blank?
+        logger.debug "##{__method__} => params: #{params}"
 
-        _, error_messages = client.send_request(path, :put, params.compact)
-        error_messages
-      end
+        end_point = Defaults::END_POINTS[:users_update]
+        path = end_point
 
-      # @param [Hash] params
-      # @return [FinApps::REST::User, Array<String>]
-      def update_password(params = {})
-        logger.debug "##{__method__} => params: #{skip_sensitive_data params}"
-
-        path = Defaults::END_POINTS[:users_update_password]
         logger.debug "##{__method__} => path: #{path}"
 
-        user, error_messages = client.send_request(path, :put, params.compact) { |r| User.new(r.body) }
-        return user, error_messages
-      end
-
-      # @param [Hash] params
-      # @return [FinApps::REST::User, Array<String>]
-      def login(params = {})
-        raise MissingArgumentsError.new 'Missing argument: params.' if params.blank?
-        logger.debug "##{__method__} => params: #{skip_sensitive_data params}"
-
-        end_point = Defaults::END_POINTS[:users_login]
-        logger.debug "##{__method__} => end_point: #{end_point}"
-
-        user, error_messages = client.send_request(end_point, :post, params) { |r| User.new(r.body) }
-        return user, error_messages
+        results, error_messages = client.send_request(path, :put, params.compact)
+        [results, error_messages]
       end
 
       # @param [String] public_id
@@ -85,15 +51,9 @@ module FinApps
         path = end_point.sub ':public_id', ERB::Util.url_encode(public_id)
         logger.debug "##{__method__} => path: #{path}"
 
-        _, error_messages = client.send_request(path, :delete)
-        error_messages
+        results, error_messages = client.send_request(path, :delete)
+        [results, error_messages]
       end
-
     end
-
-    class User < FinApps::REST::Resource
-      attr_accessor :public_id, :token, :email, :first_name, :last_name, :postal_code
-    end
-
   end
-end
+end

data/lib/finapps/utils/loggeable.rb

@@ -0,0 +1,13 @@
+module FinApps
+  module Utils
+    # Adds logging capabilities when included into other classes
+    module Loggeable
+      def logger
+        @logger ||= begin
+          require 'logger'
+          ::Logger.new(STDOUT)
+        end
+      end
+    end
+  end
+end

data/lib/finapps/version.rb

@@ -1,3 +1,3 @@
 module FinApps
-  VERSION = '1.0.8'
+  VERSION = '2.0.2'.freeze
 end