finapps 2.1.4 → 2.2.1

data/lib/core_extensions/object/is_integer.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-module ObjectExtensions
-  refine Object do
-    def integer?
-      Integer(self)
-    rescue
-      false
-    end
-  end
-end

data/lib/core_extensions/string/json_to_hash.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-module StringExtensions
-  refine String do
-    def json_to_hash
-      ::JSON.parse(self)
-    rescue ::JSON::ParserError
-      # logger.error "##{__method__} => Unable to parse JSON response."
-    end
-  end
-end

data/lib/finapps/error.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-# Defines some errors to identify Exceptions within this gem
-module FinApps # :nodoc:
-  # Base error class.
-  class Error < StandardError; end
-  # Raised for existing but invalid arguments.
-  class InvalidArgumentsError < Error; end
-  # Raised whenever a required argument is missing.
-  class MissingArgumentsError < Error; end
-
-  # Raised whenever there is a session timeout at the API.
-  class ApiSessionTimeoutError < Error; end
-
-  %i(InvalidArgumentsError MissingArgumentsError ApiSessionTimeoutError).each do |const|
-    Error.const_set(const, FinApps.const_get(const))
-  end
-end

data/lib/finapps/middleware/middleware.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require 'faraday' unless defined? Faraday
-
-module FinApps
-  module Middleware
-    autoload :AcceptJson, 'finapps/middleware/request/accept_json'
-    autoload :UserAgent, 'finapps/middleware/request/user_agent'
-    autoload :NoEncodingBasicAuthentication, 'finapps/middleware/request/no_encoding_basic_authentication'
-    autoload :TenantAuthentication, 'finapps/middleware/request/tenant_authentication'
-    autoload :CustomLogger, 'finapps/middleware/response/custom_logger'
-
-    if Faraday::Middleware.respond_to? :register_middleware
-      Faraday::Request.register_middleware \
-        accept_json: -> { AcceptJson },
-        user_agent: -> { UserAgent },
-        no_encoding_basic_authentication: -> { NoEncodingBasicAuthentication },
-        tenant_authentication: -> { TenantAuthentication }
-      Faraday::Response.register_middleware \
-        custom_logger: -> { CustomLogger }
-    end
-  end
-end

data/lib/finapps/middleware/request/accept_json.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module Middleware
-    # This middleware sets the Accept request-header field to specify JSON as acceptable media type for the response.
-    class AcceptJson < Faraday::Middleware
-      KEY = 'Accept' unless defined? KEY
-
-      def call(env)
-        env[:request_headers][KEY] = 'application/json'
-        @app.call(env)
-      end
-    end
-  end
-end

data/lib/finapps/middleware/request/no_encoding_basic_authentication.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module Middleware
-    # Adds a custom header for basic authorization.
-    # If the value for this header already exists, it is not overriden.
-    class NoEncodingBasicAuthentication < Faraday::Middleware
-      KEY = 'Authorization' unless defined? KEY
-
-      def initialize(app, token)
-        super(app)
-        sanitized = token.to_s.strip.delete("\n")
-        @header_value = "Basic #{sanitized}"
-      end
-
-      def call(env)
-        env[:request_headers][KEY] ||= @header_value
-        @app.call(env)
-      end
-    end
-  end
-end

data/lib/finapps/middleware/request/tenant_authentication.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module Middleware
-    # Adds a custom header for tenant level authorization.
-    # If the value for this header already exists, it is not overriden.
-    class TenantAuthentication < Faraday::Middleware
-      KEY = 'X-FinApps-Token' unless defined? KEY
-
-      def initialize(app, identifier, token)
-        super(app)
-        @header_value = "#{identifier.to_s.strip}=#{token.to_s.strip}"
-      end
-
-      def call(env)
-        env[:request_headers][KEY] ||= @header_value
-        @app.call(env)
-      end
-    end
-  end
-end

data/lib/finapps/middleware/request/user_agent.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module Middleware
-    # This middleware sets the User-Agent request-header field to identify thei client.
-    class UserAgent < Faraday::Middleware
-      KEY = 'User-Agent' unless defined? KEY
-      RUBY = "#{RUBY_ENGINE}/#{RUBY_PLATFORM} #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
-
-      def call(env)
-        env[:request_headers][KEY] = "finapps-ruby/#{FinApps::VERSION} (#{RUBY})"
-        @app.call(env)
-      end
-    end
-  end
-end

data/lib/finapps/middleware/response/custom_logger.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module Middleware
-    class CustomLogger < Faraday::Response::Middleware
-      extend Forwardable
-      include FinApps::Utils::ParameterFilter
-
-      DEFAULT_OPTIONS = {bodies: false}.freeze
-
-      def initialize(app, logger=nil, options={})
-        super(app)
-        @logger = logger || begin
-          require 'logger'
-          ::Logger.new(STDOUT)
-        end
-        @options = DEFAULT_OPTIONS.merge(options)
-      end
-
-      def_delegators :@logger, :debug, :info, :warn, :error, :fatal
-
-      def call(env)
-        debug "#{self.class.name}##{__method__} => URL: #{env.method.upcase} #{env.url}"
-        debug "#{self.class.name}##{__method__} => Request Headers: #{dump env.request_headers}"
-
-        super
-      end
-
-      def on_complete(env)
-        debug "#{self.class.name}##{__method__} => URL: #{env.method.upcase} #{env.url}"
-        debug "#{self.class.name}##{__method__} => Response Headers: #{dump env.response_headers}"
-        debug "#{self.class.name}##{__method__} => Response Body: #{dump env.body}" if env.body
-      end
-
-      private
-
-      def dump(value)
-        skip_sensitive_data(value.is_a?(Array) ? value.to_h : value).to_json
-      end
-    end
-  end
-end

data/lib/finapps/middleware/response/raise_error.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module Middleware
-    class RaiseError < Faraday::Response::Middleware # :nodoc:
-      using ObjectExtensions
-      using StringExtensions
-
-      SUCCESS_STATUSES = 200..299
-      CONNECTION_FAILED_STATUS = 407
-      API_SESSION_TIMEOUT = 419
-
-      def on_complete(env)
-        return if SUCCESS_STATUSES.include?(env[:status])
-
-        if env[:status] == API_SESSION_TIMEOUT
-          raise(FinApps::Error::ApiSessionTimeoutError, 'Api Session Timed out')
-        elsif env[:status] == CONNECTION_FAILED_STATUS
-          raise(Faraday::Error::ConnectionFailed, '407 "Proxy Authentication Required"')
-        else
-          raise(Faraday::Error::ClientError, response_values(env))
-        end
-      end
-
-      def response_values(env)
-        {
-          status:         env.status,
-          headers:        env.response_headers,
-          body:           env.body,
-          error_messages: error_messages(env.body)
-        }
-      end
-
-      private
-
-      def error_messages(body)
-        return nil if body.blank?
-        body = body.json_to_hash if body.is_a?(String)
-        has_message_key?(body) ? body['messages'] : nil
-      end
-
-      def has_message_key?(body)
-        body.respond_to?(:key?) && body.key?('messages')
-      end
-    end
-  end
-end

data/lib/finapps/rest/base_client.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module REST
-    # base client functionality
-    class BaseClient
-      include ::FinApps::Utils::Loggeable
-      include ::FinApps::REST::Connection
-      using ObjectExtensions
-      using StringExtensions
-
-      attr_reader :config
-
-      def initialize(options, logger=nil)
-        @config = FinApps::REST::Configuration.new options
-        @logger = logger
-      end
-
-      def user_credentials?
-        config.valid_user_credentials?
-      end
-
-      # Returns an initialized Faraday connection object.
-      #
-      # @return Faraday::Connection.
-      def connection
-        @connection ||= faraday(config, logger)
-      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 [Hash] params
-      # @return [Hash,Array<String>]
-      def send_request(path, method, params={})
-        raise FinApps::MissingArgumentsError.new 'Missing argument: path.' if path.blank?
-        raise FinApps::MissingArgumentsError.new 'Missing argument: method.' if method.blank?
-
-        response, error_messages = execute_request(path, method, params)
-        result = if empty?(response)
-                   nil
-                 else
-                   block_given? ? yield(response) : response.body
-                 end
-
-        [result, error_messages]
-      end
-
-      # Defines methods to perform HTTP GET, POST, PUT and DELETE requests.
-      # Returns a hash obtained from parsing the JSON object in the response body.
-      #
-      def method_missing(method_id, *arguments, &block)
-        if %i(get post put delete).include? method_id
-          connection.send(method_id) do |req|
-            req.url arguments.first
-            req.body = arguments[1] unless method_id == :get
-          end
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method_sym, include_private=false)
-        [:get, :post, :put, :delete].include?(method_sym) ? true : super
-      end
-
-      private
-
-      def empty?(response)
-        response.blank? || (response.respond_to?(:body) && response.body.blank?)
-      end
-
-      def execute_request(path, method, params)
-        errors = []
-
-        begin
-          response = execute_method path, method, params
-
-        rescue FinApps::ApiSessionTimeoutError => error
-          handle_error(error)
-        rescue FinApps::InvalidArgumentsError => error
-          handle_error error
-        rescue FinApps::MissingArgumentsError => error
-          handle_error error
-        rescue Faraday::Error::ConnectionFailed => error
-          handle_error error
-        rescue Faraday::Error::ClientError => error
-          errors = handle_client_error(error)
-        end
-
-        [response, errors]
-      end
-
-      def handle_error(error)
-        logger.fatal "#{self.class}##{__method__} => #{error}"
-        raise error
-      end
-
-      def handle_client_error(error)
-        logger.warn "#{self.class}##{__method__} => #{error.class.name}, #{error}"
-        error.response.present? && error.response[:error_messages] ? error.response[:error_messages] : [error.message]
-      end
-
-      def execute_method(path, method, params)
-        case method
-        when :get
-          get(path)
-        when :post
-          post(path, params)
-        when :put
-          put(path, params)
-        when :delete
-          delete(path, params)
-        else
-          raise FinApps::InvalidArgumentsError.new "Method not supported: #{method}."
-        end
-      end
-    end
-  end
-end

data/lib/finapps/rest/configuration.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module REST
-    # Represents the client configuration options
-    class Configuration # :nodoc:
-      using ObjectExtensions
-      using HashExtensions
-
-      attr_accessor :host,
-                    :tenant_identifier, :tenant_token,
-                    :user_identifier, :user_token,
-                    :proxy, :timeout, :retry_limit, :log_level
-
-      def initialize(options={})
-        FinApps::REST::Defaults::DEFAULTS.merge(options.compact).each {|key, value| public_send("#{key}=", value) }
-        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_user_credentials?
-        FinApps::REST::Credentials.new(user_identifier, user_token).valid?
-      end
-
-      private
-
-      def valid_host?
-        host.start_with?('http://', 'https://')
-      end
-    end
-  end
-end

data/lib/finapps/rest/connection.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module REST
-    module Connection # :nodoc:
-      # @return [Faraday::Connection]
-      def faraday(config, logger)
-        options = {
-          url: "#{config.host}/v#{Defaults::API_VERSION}/",
-          request: {open_timeout: config.timeout,
-                    timeout: config.timeout}
-        }
-
-        Faraday.new(options) do |conn|
-          conn.request :accept_json
-          conn.request :user_agent
-          conn.request :tenant_authentication, config.tenant_identifier, config.tenant_token
-          conn.request :json
-          conn.request :retry
-          conn.request :multipart
-          conn.request :url_encoded
-          conn.request :no_encoding_basic_authentication, config.user_token if config.valid_user_credentials?
-
-          conn.use FinApps::Middleware::RaiseError
-          conn.response :rashify
-          conn.response :json, content_type: /\bjson$/
-          conn.response :custom_logger, logger, bodies: (ENV['SILENT_LOG_BODIES'] != 'true')
-
-          # Adapter (ensure that the adapter is always last.)
-          conn.adapter :typhoeus
-        end
-      end
-      module_function :faraday # becomes available as a *private instance method* to classes that mix in the module
-    end
-  end
-end

data/lib/finapps/rest/credentials.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-module FinApps
-  module REST
-    # represents both tenant and user credentials
-    class Credentials
-      using ObjectExtensions
-      using StringExtensions
-
-      attr_reader :identifier, :token
-
-      def initialize(identifier, token)
-        @identifier = identifier
-        @token = token
-      end
-
-      def valid?
-        identifier.present? && token.present?
-      end
-    end
-  end
-end