nolij_web 1.0.0

data/.gitignore

@@ -0,0 +1,20 @@
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+lib/try.rb
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nolijweb.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Shannon Henderson
+
+MIT License
+
+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.

data/README.rdoc

@@ -0,0 +1,50 @@
+= NolijWeb
+
+Talk to the Nolij Web API. The first version of this gem contains a small subset of available API methods. Document submission/printing(retrieval) are the main focus. Methods for folder listings, work flow request, and generated urls for the viewer are provided.
+
+The raw connection can be used to execute other types of requests.
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'nolij_web'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nolij_web
+
+== Basic Usage
+
+You should be able to use the handler for basic requests.
+  require 'nolij_web'
+
+  handler = NolijWeb::Handler.new(config_hash_or_path_to_config_yaml)
+
+  handler.folder_info({:folder_id => 1111111})
+
+Configuration can be passed as an assigned hash or read from a YAML file.
+  config = {
+            :username => 'username',
+            :password => 'password',
+            :base_url => 'https://somedomain.com/NolijWeb'
+           }
+
+== Passing a block to NolijWeb::Handler methods
+You may pass a custom block to handler methods. Please note that your block should return the response for successful request. Some of the methods rely on parsing XML responses from the server.
+
+== Using the Connection Directly
+
+You can use the handler's connection directly. See NolijWeb::Connection for info.
+
+== Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc "Run tests"
+task :default => :test

data/lib/nolij_web/attribute_missing_error.rb

@@ -0,0 +1,4 @@
+module NolijWeb
+  class AttributeMissingError < StandardError
+  end
+end

data/lib/nolij_web/authentication_error.rb

@@ -0,0 +1,4 @@
+module NolijWeb
+  class AuthenticationError < StandardError
+  end
+end

data/lib/nolij_web/connection.rb

@@ -0,0 +1,179 @@
+
+require 'rest_client'
+require 'logger'
+
+module NolijWeb
+=begin rdoc
+Nolijweb::Connection is the class that handles actual Nolijweb api sessions and requests. 
+
+===Basic Usage
+
+#get, #post, #delete will automatically wrap your request in open and close connection. Arguments are passed through to RestClient, so see RestClient docs for more options.
+  
+  conn = NolijWeb::Connection.new(config_hash_or_yaml_path)
+  conn.get('/print', :query_params => { :document_id => 1})
+
+===Manual Usage
+You can manually establish a connection and use the _custom_connection methods to execute multiple requests in series.
+
+Be sure the close the connection when you are finished.
+
+  conn = NolijWeb::Connection.new(config_hash_or_yaml_path)
+  conn.establish_connection
+   # do some stuff using get, post, etc. (_custom_connection methods)
+  close_connection
+=end
+  class Connection
+    attr_reader :base_url
+    attr_reader :username
+    attr_reader :cookies
+    attr_reader :connection
+
+    @@valid_config_keys = [:username, :password, :base_url]
+
+    def initialize(config)
+      if config.is_a?(String)
+        configure_with(config)
+      elsif config.is_a?(Hash)
+        configure(config)
+      else
+        raise ConnectionConfigurationError, 'Invalid configuration options supplied.'
+      end
+    end
+
+    # Configure using hash
+    def configure(opts = {})
+      @config = clean_config_hash(opts)
+
+      raise ConnectionConfigurationError, 'Nolij Web Connection configuration failed.' unless @config
+
+      @base_url = @config[:base_url] || ''
+      @username = @config[:username] || ''
+      @password = @config[:password] || ''
+      @connection = nil
+      @cookies = nil
+      @headers = {}
+    end
+
+    # Configure with yaml
+    def configure_with(path_to_yaml_file)
+      raise ConnectionConfigurationError, "Invalid request. #configure_with requires string" unless path_to_yaml_file.is_a?(String)
+      begin
+        @config = YAML::load(IO.read(path_to_yaml_file))
+      rescue Errno::ENOENT
+        raise ConnectionConfigurationError, "YAML configuration file was not found."
+        return
+      rescue Psych::SyntaxError
+       raise ConnectionConfigurationError, "YAML configuration file contains invalid syntax."
+       return
+      end
+
+      configure(@config)
+    end
+
+    def establish_connection
+      @connection = RestClient.post("#{@base_url}/j_spring_security_check", {:j_username => @username, :j_password => @password}) { |response, request, result, &block|
+        if [301, 302, 307].include? response.code
+          response
+        else
+          response.return!(request, result, &block)
+        end
+      }
+      @cookies = @connection.cookies if @connection
+      @headers = {:cookies => @cookies}
+      return true if @connection
+    end
+
+    def close_connection
+      RestClient.get("#{@base_url}/j_spring_security_logout", :cookies => @cookies) if @connection
+      @connection = nil
+      @cookies = nil
+      @headers = {}
+      return true
+    end
+
+    def get(path, headers = {}, &block)
+      execute(headers) do
+        get_custom_connection(path, @headers, &block)
+      end
+    end
+
+    def delete(path, headers = {}, &block)
+      execute(headers) do
+        delete_custom_connection(path, @headers, &block)
+      end
+    end
+
+    def post(path, payload, headers = {}, &block)
+      execute(headers) do
+        post_custom_connection(path, payload, @headers, &block)
+      end
+    end
+
+    def execute(headers = {}, &block)
+      establish_connection
+      if @connection
+        merge_headers(headers)
+        yield(block)
+      end
+    ensure
+      close_connection
+    end
+
+    # Use this inside an execute block to make mulitiple calls in the same request
+    def get_custom_connection(path, headers = {}, &block)
+      block ||= default_response_handler
+      url = URI.join(@base_url, URI.parse(@base_url).path + '/', path.to_s).to_s
+      RestClient.get(url, headers, &block)
+    end
+
+    # Use this inside an execute block to make mulitiple calls in the same request
+    def delete_custom_connection(path, headers = {}, &block)
+      block ||= default_response_handler
+      url = URI.join(@base_url, URI.parse(@base_url).path + '/', path.to_s).to_s
+      RestClient.delete(url, headers, &block)
+    end
+
+    # Use this inside an execute block to make mulitiple calls in the same request
+    def post_custom_connection(path, payload, headers = {}, &block)
+      block ||= default_response_handler
+      url = URI.join(@base_url, URI.parse(@base_url).path + '/', path.to_s).to_s
+      RestClient.post(url, payload, headers, &block)
+    end
+
+private
+
+    def clean_config_hash(config)
+      clean_config = {}
+      config = config.each {|k,v| config[k.to_sym] = v}
+      @@valid_config_keys.each{|k| clean_config[k] = config[k]}
+
+      return clean_config
+    end
+
+    def merge_headers(headers = {})
+      instance_cookies = @headers.delete(:cookies) || {}
+      local_cookies = headers.delete(:cookies) || {}
+      @headers = @headers.merge(headers)
+      @headers[:cookies] = instance_cookies.merge(local_cookies)
+      return @headers
+    end
+
+    def default_response_handler
+      @default_response_handler ||= lambda{ |response, request, result, &block|
+                                      case response.code
+                                      when 200
+                                        #Success!
+                                        return response
+                                      when 302
+                                        raise AuthenticationError, 'User is not logged in.'
+                                      when 401
+                                        raise AuthenticationError, 'Request requires authentication'
+                                      else
+                                        # Some other error. Let it bubble up.
+                                        response.return!(request, result, &block)
+                                      end
+                                    }
+    end
+  end
+end

data/lib/nolij_web/connection_configuration_error.rb

@@ -0,0 +1,4 @@
+module NolijWeb
+  class ConnectionConfigurationError < StandardError
+  end
+end

data/lib/nolij_web/handler.rb

@@ -0,0 +1,208 @@
+require 'nokogiri'
+require 'uri'
+module NolijWeb
+  class Handler
+    @@doc_handler_path    = 'handler/api/docs'
+    @@doc_viewer_path     = ''
+    @@workflow_path       = 'handler/api/workflow/workcomplete'
+    @@api_path            = 'handler/api'
+
+    attr_reader :connection
+
+    def initialize(connection_config)
+      @config = connection_config
+      @connection = Connection.new(@config)
+    end
+
+    # Folder contents
+    # required options: :folder_id
+    # additional options: :user_code, :user_id, :sort, :offset, :limit, :wfma_code
+    def folder_info(options = {}, &block)
+      folder_id = options[:folder_id]
+      raise AttributeMissingError, 'Folder ID is required.' unless folder_id.is_a?(String) && !folder_id.empty?
+
+      allowed_query_params_keys = [:user_code, :user_id, :sort, :offset, :limit, :wfma_code]
+      query_params = format_query_params(options, allowed_query_params_keys)
+      headers = options[:headers] || {}
+      relative_path = [@@doc_handler_path, options[:folder_id]].join('/')
+
+      response = @connection.get relative_path, headers.merge(:params => query_params),  &block
+
+      folder = Nokogiri.XML(response)
+    end
+
+    # Returns an array of hashes with the file info for each file in the folder
+    # See #folder_info for options
+    def folder_contents(options = {}, &block)
+      folder = folder_info(options, &block)
+      files = folder.xpath('//folderobjects//folderobject')
+
+      file_attrs = files.collect(&:attributes)
+      file_attrs = file_attrs.collect {|attr|
+        attr.inject({}){|n, (k,v)| n[k] = v.value; n}
+      }
+    end
+
+    # Submit a file.
+    # A local file path is required.
+    # required options: :folder_id
+    # additional options: :user_code, :wfma_code, :index_code, :dept_code, :custom_name, :folder_name
+    def submit_document(local_file, options = {}, &block)
+      folder_id = options[:folder_id]
+      folder_id = if folder_id.kind_of?(Numeric) || folder_id.kind_of?(String)
+                    folder_id.to_s
+                  else
+                    nil
+                  end
+      raise AttributeMissingError, 'Folder ID is required to submit a document.' unless folder_id.is_a?(String) && !folder_id.empty?
+
+      local_file ||= ''
+      file = begin
+          File.new(local_file)
+        rescue Errno::ENOENT
+        end
+
+      raise AttributeMissingError, 'Valid file or local filepath is required to submit a document.' unless file.is_a?(File)
+      options[:file_name] = File.basename(file.path)
+      allowed_query_params_keys = [:user_code, :wfma_code, :index_code, :dept_code, :custom_name, :file_name]
+      formatted_query = query_str(:allowed_query_params_keys => allowed_query_params_keys , :query_params => options)
+      relative_path = [@@doc_handler_path, folder_id].join('/') + formatted_query
+
+      # TODO custom attributes?
+      form_params = {}
+      form_params[:ocrwords] = options[:ocr_words] if options.has_key?(:oci_words)
+      form_params[:my_file] = file
+
+      #upload file to nolijweb
+      response = @connection.post relative_path, form_params, (options[:headers] || {}), &block
+
+      # return Nolij file id
+      doc_metadata = Nokogiri.XML(response)
+      document_id = doc_metadata.xpath('//documentmeta/@documentid').first
+      return document_id.value if document_id
+    end
+
+    # Print one or more documents to a single pdf
+    # required options: document_ids - can be a numer or an array of numbers
+    # additional options: :user_code, :document_id, :user_id
+    def print_document(options = {}, &block)
+      doc_ids = options.delete(:document_id)
+      raise AttributeMissingError, 'At least one document ID is required to print a document.' unless doc_ids
+      options[:document_id] = [doc_ids].flatten.compact.collect(&:to_i).join('-')
+
+      allowed_query_params_keys = [:user_code, :wfma_code, :user_id, :document_id]
+      query_params = format_query_params(options, allowed_query_params_keys)
+      headers = options[:headers] || {}
+      relative_path = [@@doc_handler_path, 'print'].join('/')
+
+      @connection.get relative_path, headers.merge(:params => query_params), &block
+    end
+
+    # Delete a document
+    # required options: :document_id, :folder_id
+    # additional options: :user_code, :user_id, :wfma_code
+    def delete_document(options = {}, &block)
+      folder_id = options[:folder_id]
+      document_id = options[:document_id]
+      raise AttributeMissingError, 'Folder ID is required to delete a document.' unless folder_id.is_a?(String) && ! folder_id.empty?
+      raise AttributeMissingError, 'Document ID is required to delete a document.' unless document_id.is_a?(String) && ! document_id.empty?
+
+      allowed_query_params_keys = [:user_code, :user_id, :wfma_code]
+      query_params = format_query_params(options, allowed_query_params_keys)
+      headers = options[:headers] || {}
+      relative_path = [@@doc_handler_path, 'delete', folder_id, document_id].join('/') + formatted_query
+
+      @connection.delete relative_path, headers.merge(:params => query_params), &block
+    end
+
+    # URL or path to verify that user is authenticated to Nolijweb in their browser.
+    # If the user is logged in redirect them to :redir path.
+    # If not, redirect to login and return them to the URL provided once they've authenticated.
+    # Redirect path must be relative to /public
+    # :redir is required. A path is returned unless :full_url => true
+    def login_check(options = {})
+      raise AttributeMissingError, 'Redirect path is required to check login' unless options[:redir].is_a?(String) && !options[:redir].empty?
+
+      full_url = options.delete(:full_url) || false
+      allowed_query_params_keys = [:redir]
+      formatted_query = query_str(:allowed_query_params_keys => allowed_query_params_keys , :query_params => options)
+
+      relative_path = ['public', 'apiLoginCheck.jsp'].join('/') + formatted_query
+      path = relative_path
+      url = full_url ? [@connection.base_url, path].join('/') : path
+      return url
+    end
+
+    # URL or path to open the standalone document viewer utility.
+    # required options: :document_id is required
+    # additional options: :user_code, :wfma_code
+    # use option  :full_url => true for a full url, otherwise a relative path is returned.
+    def viewer_url(options = {})
+      raise AttributeMissingError, 'Document ID is required to launch viewer' unless (options[:document_id].is_a?(String) && !options[:document_id].empty?) || options[:document_id].is_a?(Integer)
+      full_url = options.delete(:full_url) || false
+      url_opts = {}
+      allowed_query_params_keys = [:document_id, :user_code, :wfma_code]
+      formatted_query = query_str(:allowed_query_params_keys => allowed_query_params_keys , :query_params => options)
+      relative_path = [@@doc_viewer_path, 'documentviewer'].join('/') + formatted_query
+      path = relative_path
+      url = full_url ? [@connection.base_url, path].join('/') : path
+      return url
+    end
+
+    # Issue work complete to push item along in work flow
+    # required options: :wfma_code, :folder_name
+    # additional options: :user_id, :user_code
+    def work_complete(options = {}, &block)
+      raise AttributeMissingError, 'Workflow master code is required for workflow requests.' unless options[:wfma_code]
+      folder_id = options[:folder_id]
+      raise AttributeMissingError, 'Folder ID is required.' unless folder_id
+
+      raise AttributeMissingError, 'Folder name is required.' unless options[:folder_name]
+
+      allowed_query_params_keys = [:wfma_code, :user_id, :user_code, :folder_name]
+      formatted_query = query_str(:allowed_query_params_keys => allowed_query_params_keys , :query_params => options)
+      relative_path = [@@workflow_path, folder_id, formatted_query].join('/')
+
+      @connection.post relative_path, {}, options[:headers] || {}, &block
+    end
+
+    # Nolij Web server version information
+    def version(&block)
+      relative_path = [@@api_path, 'version'].join('/')
+      response = @connection.get relative_path, &block
+
+      info = Nokogiri.XML(response).xpath('//version').collect(&:attributes)
+      info= info.collect {|attr|
+        attr.inject({}){|n, (k,v)| n[k] = v.value; n}
+      }.first
+    end
+
+    # TODO Add query and query results methods
+
+private
+
+    def query_str(options = {})
+      keys = options[:allowed_query_params_keys] || []
+      query_params = options[:query_params] || {}
+      query_str = if query_params.empty?
+            ''
+          else
+           format_query_params(query_params, keys).collect{|k,v| "#{k}=#{URI.escape v}"}.join('&')
+          end
+      return query_str.empty? ? '' : "?#{query_str}" 
+    end
+
+    # format param names and return the query hash
+    def format_query_params(params = {}, keys = [])
+      keys.inject([]){|m, v| v.to_sym; m}
+      query_params = params.select{|k,v| keys.include?(k.to_sym)}
+      cleaned = query_params.inject({}) do |p,(k,v)|
+        key = k.to_s.gsub('_', '').to_sym
+        value = v.to_s
+        p[key] = value
+        p 
+      end
+      return cleaned.reject{|k,v| v.empty?}
+    end
+  end
+end

data/lib/nolij_web/version.rb

@@ -0,0 +1,5 @@
+module NolijWeb
+  class Version
+    VERSION = "1.0.0"
+  end
+end

data/lib/nolij_web.rb

@@ -0,0 +1,13 @@
+require 'rest_client'
+require 'uri'
+require 'nolij_web/connection'
+require 'nolij_web/handler'
+require "nolij_web/version"
+require 'nolij_web/authentication_error'
+require 'nolij_web/attribute_missing_error'
+require 'nolij_web/connection_configuration_error'
+
+# See README for installation and usage instructions
+module NolijWeb
+  # Nothing to see here
+end

data/nolij_web.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nolij_web/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nolij_web"
+  spec.version       = NolijWeb::Version::VERSION
+  spec.authors       = ["Shannon Henderson"]
+  spec.email         = ["shenders@reed.edu"]
+  spec.description   = %q{A Ruby wrapper for the Nolijweb API}
+  spec.summary       = %q{Interact with Nolijweb's REST API}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.extra_rdoc_files  = spec.files.select { |p| p =~ /^README/ } << 'LICENSE.txt'
+  spec.rdoc_options      = %w[--line-numbers --inline-source --main README.rdoc]
+
+  spec.add_runtime_dependency 'rest-client', '~> 1.6'
+  spec.add_runtime_dependency 'nokogiri', '~> 1.6'
+
+  spec.add_development_dependency 'minitest', '~> 5.0.0'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'webmock', '~>1.13'
+
+  spec.required_ruby_version = '>= 1.9.3'
+end

data/test/nolij_web/attribute_missing_error_test.rb

@@ -0,0 +1,7 @@
+require_relative '../test_helper'
+
+describe NolijWeb::AttributeMissingError do
+  it "should subclass StandardError" do
+    NolijWeb::AttributeMissingError.ancestors.must_include(StandardError)
+  end
+end

data/test/nolij_web/authentication_error_test.rb

@@ -0,0 +1,7 @@
+require_relative '../test_helper'
+
+describe NolijWeb::AuthenticationError do
+  it "should subclass StandardError" do
+    NolijWeb::AuthenticationError.ancestors.must_include(StandardError)
+  end
+end

data/test/nolij_web/connection_configuration_error_test.rb

@@ -0,0 +1,7 @@
+require_relative '../test_helper'
+
+describe NolijWeb::ConnectionConfigurationError do
+  it "should subclass StandardError" do
+    NolijWeb::ConnectionConfigurationError.ancestors.must_include(StandardError)
+  end
+end