filebound_client 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'filebound_client'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/example_test.yml

@@ -0,0 +1,9 @@
+---
+host: fb_host
+api_base_uri: /api
+username: username
+password: password
+use_ntlm: true
+ntlm_user: user
+ntlm_password: password
+ntlm_domain: domain.com

data/filebound_client.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'filebound_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'filebound_client'
+  spec.version       = FileboundClient::VERSION
+  spec.authors       = ['Bryan Richardson']
+  spec.email         = ['brichardson@heiskell.com']
+
+  spec.summary       = '%q{Provides connection to FileBound API}'
+  spec.homepage      = 'https://github.com/JDHeiskell/filebound_client'
+  spec.license       = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.16.0'
+  spec.add_development_dependency 'rake', '~> 12.3.0'
+  spec.add_development_dependency 'yard', '~> 0.9.0'
+
+  spec.add_runtime_dependency 'ruby-ntlm', '~> 0.0.4'
+end

data/lib/ext/hash.rb

@@ -0,0 +1,8 @@
+# Extends Hash with additional helper methods
+class Hash
+  # Allows for conversion of string keys to symbols
+  # @return [Hash] hash with symbols for keys
+  def symbolize_keys
+    each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
+  end
+end

data/lib/ext/object.rb

@@ -0,0 +1,19 @@
+# Extends Object with additional helper methods
+class Object
+  # Adds blank? method to any object
+  # Lifted from: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/blank.rb
+  # @return [true, false]
+  def blank?
+    # rubocop:disable Style/DoubleNegation
+    respond_to?(:empty?) ? !!empty? : !self
+    # rubocop:enable Style/DoubleNegation
+  end
+
+  # Checks where object is greater than zero
+  # Returns false of object is nil
+  # @return [true, false]
+  def greater_than_zero?
+    return false if nil?
+    to_i > 0
+  end
+end

data/lib/filebound_client.rb

@@ -0,0 +1,102 @@
+require 'ext/object'
+require 'ext/hash'
+require 'filebound_client/version'
+require 'filebound_client/configuration'
+require 'filebound_client/config'
+require 'filebound_client/connection'
+require 'filebound_client/endpoints'
+require 'logger'
+
+# This is the core module
+module FileboundClient
+  # This encapsulates all client/server communications
+  class Client
+    include FileboundClient::Endpoints
+
+    # General client exception class
+    class FileboundClientException < StandardError
+      attr_reader :result
+      def initialize(message, result)
+        super(message)
+        @result = result
+      end
+    end
+
+    # Creates, initialize and logs into the Filebound API
+    # @param [Hash] config a hash of configuration values
+    # @return [FileboundClient::Client] an instance of FileboundClient::Client
+    def self.connect(config)
+      connection = FileboundClient::Connection.build_connection(config)
+      raise FileboundClientException.new('Failed to login', 401) unless connection.login
+      new(connection)
+    end
+
+    # Initializes the client with the supplied Connection
+    # @param [Connection] connection the logged in Connection
+    # @return [FileboundClient::Client] an instance of FileboundClient::Client
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Executes a GET request on the current Filebound client session expecting JSON in the body of the response
+    # @param [String] url the resource url to request
+    # @param [Hash] query_params the optional query parameters to pass to the GET request
+    # @return [Hash] the JSON parsed hash of the response body
+    def get(url, query_params = nil)
+      JSON.parse(perform('get', url, query: query_params), symbolize_names: true)
+    end
+
+    # Executes a GET request on the current Filebound client session expecting binary in the body of the response
+    # @param [String] url the resource url to request
+    # @param [Hash] query_params the optional query parameters to pass to the GET request
+    # @return [String] Base64 encoded binary string
+    def get_binary(url, query_params = nil)
+      perform('get', url, query: query_params)
+    end
+
+    # Executes a PUT request on the current Filebound client session expecting JSON in the body of the request/response
+    # @param [String] url the resource url to request
+    # @param [Hash] query_params the optional query parameters to pass to the PUT request
+    # @param [Hash] body the hash that will be converted to JSON when inserted in the body of the request
+    # @return [Hash] the JSON parsed hash of the response body
+    def put(url, query_params = nil, body = nil)
+      params = { headers: { 'Content-Type' => 'application/json' }, query: query_params, body: body }
+      JSON.parse(perform('put', url, params), symbolize_names: true)
+    end
+
+    # Executes a POST request on the current Filebound client session expecting JSON in the body of the request/response
+    # @param [String] url the resource url to request
+    # @param [Hash] query_params the optional query parameters to pass to the POST request
+    # @param [Hash] body the hash that will be converted to JSON when inserted in the body of the request
+    # @return [Hash] the JSON parsed hash of the response body
+    def post(url, query_params = nil, body = nil)
+      params = { headers: { 'Content-Type' => 'application/json' }, query: query_params, body: body }
+      JSON.parse(perform('post', url, params), symbolize_names: true)
+    end
+
+    # Executes a DELETE request on the current Filebound client session
+    # @param [String] url the resource url to request
+    # @param [Hash] query_params the optional query parameters to pass to the DELETE request
+    # @return [true, false] true if resource was deleted successfully
+    def delete(url, query_params = nil)
+      perform('delete', url, query: query_params)
+      true
+    end
+
+    # The connection representing the currently logged on session with the Filebound API
+    # @return [FileboundClient::Connection] the security token used in all requests made to the Filebound server
+    attr_reader :connection
+
+    private_class_method :new
+
+    private
+
+    def perform(action, url, params)
+      response = connection.send(action, url, params)
+      # rubocop:disable Metrics/LineLength
+      raise FileboundClientException.new("#{action.upcase} request failed: #{response.code}", response.code) unless response.code == '200'
+      # rubocop:enable Metrics/LineLength
+      response.body
+    end
+  end
+end

data/lib/filebound_client/config.rb

@@ -0,0 +1,33 @@
+module FileboundClient
+  # Config module
+  module Config
+    # Retrive the current configuration
+    # @return [FileboundClient::Configuration]
+    def configuration
+      @configuration
+    end
+
+    # Retrieve the default logger
+    # @return [Logger] the default logger
+    def default_logger
+      logger ||= Logger.new(STDOUT)
+      logger.level = Logger::DEBUG
+      logger
+    end
+
+    # Creates a new Configuration object and yields to the caller
+    # Also sets the logger
+    def configure
+      @configuration ||= Configuration.new
+      yield @configuration
+
+      @configuration.logger ||= default_logger
+    end
+
+    # Simple logger plugin for debugging
+    def logger(message)
+      return unless configuration.logger
+      configuration.logger.debug(message)
+    end
+  end
+end

data/lib/filebound_client/configuration.rb

@@ -0,0 +1,6 @@
+module FileboundClient
+  # Encapsulate configuration data
+  class Configuration
+    attr_accessor :host, :api_base_uri, :username, :password, :logger, :ntlm_auth
+  end
+end

data/lib/filebound_client/connection.rb

@@ -0,0 +1,183 @@
+require 'ntlm/http'
+require 'filebound_client/config'
+require 'json'
+
+module FileboundClient
+  # Encapsulates low level logic to talk to Filebound server
+  class Connection
+    include Config
+
+    # The token returned from the Filebound server on successfully logging in
+    # @return [Guid] the security token used in all requests made to the Filebound server
+    attr_reader :token
+
+    # Creates a new connection using the supplied configuration
+    # @param [Configuration] config the Configuration to use for the connection
+    # @return [Connection] the newly created and initialized Connection
+    def self.build_connection(config)
+      new(config)
+    end
+
+    # Initialize a new connection with the supplied configuration
+    # @param [Configuration] config the Configuration to use for the connection
+    # @return [Connection] the newly created and initialized Connection
+    def initialize(config)
+      configure do |c|
+        c.host = config[:host]
+        c.api_base_uri = config[:api_base_uri]
+        c.username = config[:username]
+        c.password = config[:password]
+        # rubocop:disable Metrics/LineLength
+        c.ntlm_auth = { user: config[:ntlm_user], password: config[:ntlm_password], domain: config[:ntlm_domain] } if config[:use_ntlm]
+        # rubocop:enable Metrics/LineLength
+      end
+    end
+
+    private_class_method :new
+
+    # The Filebound server hostname and protocol
+    # @return [String] the Filebound server URL
+    # @example
+    #    "http://localhost"
+    def host
+      configuration.host
+    end
+
+    # The base path to the API on the Filebound server
+    # @return [String] the base path to the API
+    # @example
+    #   "/api"
+    def api_base_uri
+      configuration.api_base_uri
+    end
+
+    # The username to log on to the Filebound server with
+    # @return [String] the username
+    # @example
+    #   "username"
+    def username
+      configuration.username
+    end
+
+    # The password to log on to the Filebound server with
+    # @return [String] the password
+    # @example
+    #   "password"
+    def password
+      configuration.password
+    end
+
+    # The NTLM username to use for NTLM Authentication
+    # @return [String] the NTLM username
+    # @example
+    #   "ntlm_user"
+    def ntlm_user
+      configuration.ntlm_auth[:user] if configuration.ntlm_auth
+    end
+
+    # The NTLM password to use for NTLM Authentication
+    # @return [String] the NTLM password
+    # @example
+    #   "ntlm_password"
+    def ntlm_password
+      configuration.ntlm_auth[:password] if configuration.ntlm_auth
+    end
+
+    # The NTLM domain to use for NTLM Authentication
+    # @return [String] the NTLM domain
+    # @example
+    #   "ntlm_domain"
+    def ntlm_domain
+      configuration.ntlm_auth[:domain] if configuration.ntlm_auth
+    end
+
+    # The authentication query parameters required by all requests to the API
+    # @return [Hash] the query parameters hash
+    def auth_params
+      { query: { guid: token } }
+    end
+
+    # Sends a GET request to the supplied resource using the supplied params hash
+    # @param [String] url the url that represents the resource
+    # @param [Hash] params the params Hash that will be sent in the request (keys: query, headers, body)
+    # @return [Net::HTTPResponse] the response from the GET request
+    def get(url, params)
+      request = Net::HTTP::Get.new(resource_url(url, query_params(params[:query])))
+      execute_request(request, params)
+    end
+
+    # Sends a PUT request to the supplied resource using the supplied params hash
+    # @param [String] url the url that represents the resource
+    # @param [Hash] params the params Hash that will be sent in the request (keys: query, headers, body)
+    # @return [Net::HTTPResponse] the response from the PUT request
+    def put(url, params)
+      request = Net::HTTP::Put.new(resource_url(url, query_params(params[:query])))
+      request.body = params[:body].to_json
+      execute_request(request, params)
+    end
+
+    # Sends a POST request to the supplied resource using the supplied params hash
+    # @param [String] url the url that represents the resource
+    # @param [Hash] params the params Hash that will be sent in the request (keys: query, headers, body)
+    # @return [Net::HTTPResponse] the response from the POST request
+    def post(url, params)
+      request = Net::HTTP::Post.new(resource_url(url, query_params(params[:query])))
+      request.body = params[:body].to_json
+      execute_request(request, params)
+    end
+
+    # Sends a DELETE request to the supplied resource using the supplied params hash
+    # @param [String] url the url that represents the resource
+    # @param [Hash] params the params Hash that will be sent in the request (keys: query, headers, body)
+    # @return [Net::HTTPResponse] the response from the DELETE request
+    def delete(url, params)
+      request = Net::HTTP::Delete.new(resource_url(url, query_params(params[:query])))
+      execute_request(request, params)
+    end
+
+    # Sends a POST request to the Filebound API's login endpoint to request a new security token
+    # @return [true, false] returns true if the login was successful and the token was set
+    def login
+      response = post('/login', body: { username: configuration.username, password: configuration.password },
+                                headers: { 'Content-Type' => 'application/json' })
+      if response.is_a?(Net::HTTPSuccess)
+        @token = JSON.parse(response.body, symbolize_names: true)
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def resource_url(url, query)
+      return "#{api_base_uri}/#{url.reverse.chomp('/').reverse}" unless query
+      query_string = query.map { |k, v| "#{k}=#{v}" }.join('&')
+      "#{api_base_uri}/#{url.reverse.chomp('/').reverse}?#{query_string}"
+    end
+
+    def query_params(params)
+      if params
+        auth_params[:query].merge!(params)
+      else
+        auth_params[:query]
+      end
+    end
+
+    def set_headers(request, headers)
+      if headers.respond_to?(:to_hash)
+        headers.each do |k, v|
+          request[k.to_s] = v.to_s
+        end
+      end
+      request
+    end
+
+    def execute_request(request, params)
+      http = Net::HTTP.new(configuration.host)
+      request = set_headers(request, params[:headers])
+      request.ntlm_auth(ntlm_user, ntlm_domain, ntlm_password) if configuration.ntlm_auth
+      http.request(request)
+    end
+  end
+end

data/lib/filebound_client/endpoints.rb

@@ -0,0 +1,52 @@
+require 'filebound_client/endpoints/projects'
+require 'filebound_client/endpoints/files'
+require 'filebound_client/endpoints/documents'
+require 'filebound_client/endpoints/version'
+require 'filebound_client/endpoints/assignments'
+require 'filebound_client/endpoints/dividers'
+require 'filebound_client/endpoints/document_binary_data'
+require 'filebound_client/endpoints/eform_data'
+require 'filebound_client/endpoints/separators'
+
+module FileboundClient
+  # Module for resource endpoints
+  module Endpoints
+    # Sets up macros for use by endpoints and includes all endpoints
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def self.included(klass)
+      klass.instance_eval do
+        # @!macro [attach] fb.allow_new
+        # Returns a new empty resource with defaulted values
+        # @return [Hash] a new hash of $1
+        def self.allow_new(name)
+          define_method("#{name}_new") do
+            get('/empty', template: name.to_s)
+          end
+        end
+
+        # @!macro [attach] fb.allow_all
+        # Returns an array $1 hashes
+        # @param [Hash] query_params params to pass to the request
+        # @return [Array] an array of $1 hashes
+        def self.allow_all(name)
+          define_method(name.to_s) do |query_params = nil|
+            get("/#{name}", query_params)
+          end
+        end
+      end
+
+      klass.class_eval do
+        include FileboundClient::Endpoints::Projects
+        include FileboundClient::Endpoints::Files
+        include FileboundClient::Endpoints::Documents
+        include FileboundClient::Endpoints::Version
+        include FileboundClient::Endpoints::Assignments
+        include FileboundClient::Endpoints::Dividers
+        include FileboundClient::Endpoints::DocumentBinaryData
+        include FileboundClient::Endpoints::EFormData
+        include FileboundClient::Endpoints::Separators
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+  end
+end