exlibris-primo 0.1.5 → 1.0.0

data/README.rdoc

@@ -1,68 +0,0 @@
-= Exlibris::Primo
-{<img src="https://secure.travis-ci.org/scotdalton/exlibris-primo.png" alt="Build Status" />}[https://secure.travis-ci.org/scotdalton/exlibris-primo]
-{<img src="https://gemnasium.com/scotdalton/exlibris-primo.png" alt="Dependency Status" />}[https://gemnasium.com/scotdalton/exlibris-primo]
-{<img src="https://codeclimate.com/badge.png" />}[https://codeclimate.com/github/scotdalton/exlibris-primo]
-
-Exlibris::Primo offers a set of libraries for interacting with the ExLibris Primo APIs.
-
-== Exlibris::Primo::Searcher
-The Exlibris::Primo::Searcher class performs a search against Primo for given parameters
-and exposes the set of holdings (availibrary elements), rsrcs, tocs, and related links (addlink elements).
-
-=== Example of Exlibris::Primo::Searcher in action
-  setup = {
-    :base_url => "http://primo.institution.edu", :vid => "VID", :institution => "INSTITUTION",
-    :config => {
-      "libraries" => 
-        {"library_code1" => "library_display_1", "library_code2" => "library_display_1"}, 
-      "statuses" => 
-        {"status_code1" => "status_display_1", "status_code2" => "status_display_2"}}
-  }
-  params = {
-     :primo_id => primo_id,
-     :isbn => isbn, 
-     :issn => issn,
-     :title => title,
-     :author => author,
-     :genre => genre
-  }
-  searcher = Exlibris::Primo::Searcher.new(setup, params)
-  count = search.count
-  holdings = searcher.holdings
-  rsrcs = searcher.rsrcs
-  tocs = searcher.tocs
-  related_links = searcher.related_links
-
-== Exlibris::Primo::Record
-The Exlibris::Primo::Record class creates an object representation of a Primo record for given parameters
-and exposes the record's primary attributes (format, title, author, url, openurl) and full record Xml (raw_xml)
-as instance variables.
-
-=== Example of Exlibris::Primo::Record in action
-  setup = { 
-    :base_url => "http://primo.institution.edu", 
-    :resolver_base_url => "http://resolver.institution.edu", 
-    :vid => "VID", 
-    :institution => "DEFAULT", 
-    :record_id => "PrimoRecordId" 
-  }
-  record = Exlibris::Primo::Record.new(setup)
-  raw_xml = record.instance_variable_get(:@raw_xml)
-  record_hash = record.to_h
-  openurl = record_hash["openurl"]
-	
-== Exlibris::Primo::EShelf
-The Exlibris::Primo::EShelf class provides methods for reading a given user's Primo eshelf and eshelf structure as well as adding and removing records.
-
-=== Example of Exlibris::Primo::EShelf in action
-  setup = { 
-    :base_url => "http://primo.institution.edu", 
-    :vid => "VID", 
-    :resolver_base_url => "http://resolver.institution.edu"
-  }
-  eshelf = Exlibris::Primo::EShelf.new(setup, "USER_ID", "PRIMO")
-  records = eshelf.records
-  p records.first.class
-  record_count = eshelf.count
-  basket_id = eshelf.basket_id
-  eshelf.add_records(["PrimoRecordId","PrimoRecordId2"], basket_id)

data/lib/exlibris/primo/related_link.rb

@@ -1,20 +0,0 @@
-module Exlibris
-  module Primo
-    # == Overview
-    # Class for handling Primo related links from links/addlink
-    class RelatedLink
-      @base_attributes = [ :record_id, :addlink, :url, :display,  :notes ]
-      class << self; attr_reader :base_attributes end
-      def initialize(options={})
-        base_attributes = (self.class.base_attributes.nil?) ? 
-          Exlibris::Primo::RelatedLink.base_attributes : self.class.base_attributes
-        base_attributes.each { |attribute|
-          self.class.send(:attr_reader, attribute)
-        }
-        options.each { |option, value| 
-          self.instance_variable_set(('@'+option.to_s).to_sym, value) 
-        }
-      end
-    end
-  end
-end

data/lib/exlibris/primo/rsrc.rb

@@ -1,20 +0,0 @@
-module Exlibris
-  module Primo
-    # == Overview
-    # Class for handling Primo Rsrcs from links/linktorsrc
-    class Rsrc
-      @base_attributes = [ :record_id, :linktorsrc, :v, :url, :display, :institution_code, :origin, :notes ]
-      class << self; attr_reader :base_attributes end
-      def initialize(options={})
-        base_attributes = (self.class.base_attributes.nil?) ? 
-          Exlibris::Primo::Rsrc.base_attributes : self.class.base_attributes
-        base_attributes.each { |attribute|
-          self.class.send(:attr_reader, attribute)
-        }
-        options.each { |option, value| 
-          self.instance_variable_set(('@'+option.to_s).to_sym, value) 
-        }
-      end
-    end
-  end
-end

data/lib/exlibris/primo/searcher.rb

@@ -1,277 +0,0 @@
-module Exlibris
-  module Primo
-    # == Overview
-    # Exlibris::Primo::Searcher searches Primo for records.
-    # Exlibris::Primo::Searcher must have sufficient metadata to make 
-    # the request. Sufficient means either:
-    #     * We have a Primo doc id
-    #     * We have either an isbn OR an issn
-    #     * We have a title AND an author AND a genre
-    # If none of these criteria are met, Exlibris::Primo::Searcher.search
-    # will not perform the search.
-    # Exlibris::Primo::Searcher will populate the following instance variables
-    # accessible through readers:
-    #   :count, :holdings, :rsrcs, :tocs, :related_links
-    # The reader :response makes the full xml result available as a Nokogiri::XML::Document.
-    class Searcher
-      #@required_setup = [ :base_url ]
-      #@setup_default_values = { :vid => "DEFAULT", :config => {} }
-
-      attr_reader :response, :count
-      attr_reader :cover_image, :titles, :author
-      attr_reader :holdings, :rsrcs, :tocs, :related_links
-      PNX_NS = {'pnx' => 'http://www.exlibrisgroup.com/xsd/primo/primo_nm_bib'}
-      SEARCH_NS = {'search' => 'http://www.exlibrisgroup.com/xsd/jaguar/search'}
-    
-      # Instantiates the object and performs the search for based on the input search criteria.
-      # :setup parameter requires { :base_url => http://primo.institution.edu }
-      # Other optional parameters are :vid => "view_id", :config => { Hash of primo config settings}
-      # Hash of config settings are of the form:
-      #   {"libraries" => {"library_code1" => "library_display_1", "library_code2" => "library_display_1"}, "statuses" => {"status_code1" => "status_display_1", "status_code2" => "status_display_2"}}
-      # :search_params are a sufficient combination of 
-      #   { :primo_id => "primo_1", :isbn => "ISBN", :issn => "ISSN", :title => "Title", :author => "Author", :genre => "Genre" }
-      def initialize(setup, search_params)
-        @holdings = []
-        @rsrcs = []
-        @tocs = []
-        @related_links = []
-        @holding_attributes = Exlibris::Primo::Holding.base_attributes
-        @base_url = setup[:base_url]
-        raise_required_setup_parameter_error :base_url if @base_url.nil?
-        @institution = setup[:institution]
-        raise_required_setup_parameter_error :institution if @institution.nil?
-        @vid = setup.fetch(:vid, "DEFAULT")
-        raise_required_setup_parameter_error :vid if @vid.nil?
-        @config = setup.fetch(:config, {})
-        raise_required_setup_parameter_error :config if @config.nil?
-        search_params.each { |param, value| self.instance_variable_set("@#{param}".to_sym, value) }
-        # Perform the search
-        search
-      end
-
-      private
-      def self.add_attr_reader(reader)
-        attr_reader reader.to_sym
-      end
-    
-      # Execute search based on instance vars
-      # Process Holdings based on display/availlibrary
-      # Process URLs based on links/linktorsrc
-      # Process TOCs based on links/linktotoc
-      def search
-        return if insufficient_query?
-        # Call Primo Web Services
-        unless @primo_id.nil? or @primo_id.empty?
-          get_record = Exlibris::Primo::WebService::GetRecord.new(@primo_id, @base_url, {:institution => @institution}) 
-          @response = get_record.response
-          process_record and process_search_results #since this is a search in addition to being a record call
-        else
-          brief_search = Exlibris::Primo::WebService::SearchBrief.new(search_params, @base_url, {:institution => @institution})
-          @response = brief_search.response
-          process_search_results
-        end
-      end
-
-      # Determine whether we have sufficient search criteria to search
-      # Sufficient means either:
-      #     * We have a Primo doc id
-      #     * We have either an isbn OR an issn
-      #     * We have a title AND an author AND a genre
-      def insufficient_query?
-        return false unless (@primo_id.nil? or @primo_id.empty?)
-        return false unless (@issn.nil? or @issn.empty?) and (@isbn.nil? or @isbn.empty?)
-        return false unless (@title.nil? or @title.empty?) or (@author.nil? or @author.empty?) or (@genre.nil? or @genre.empty?)
-        return true
-      end
-    
-      # Search params are determined by input to Exlibris::PrimoWS::SearchBrief
-      def search_params
-        search_params = {}
-        unless (@issn.nil? or @issn.empty?) and (@isbn.nil? or @isbn.empty?)
-          search_params[:isbn] = @isbn unless @isbn.nil?
-          search_params[:issn] = @issn if search_params.empty?
-        else
-          search_params[:title] = @title unless @title.nil?
-          search_params[:author] = @author unless @title.nil? or @author.nil?
-          search_params[:genre] = @genre unless @title.nil? or @author.nil? or @genre.nil?
-        end
-        return search_params
-      end
-    
-      # Process a single record
-      def process_record
-        @count = response.at("//search:DOCSET", SEARCH_NS)["TOTALHITS"] unless response.nil? or @count
-        response.at("//pnx:addata", PNX_NS).children.each do |addata_child|
-          name = addata_child.name and value = addata_child.inner_text if addata_child.elem?
-          next if value.nil?
-          self.class.add_attr_reader name.to_sym unless name.nil?
-          instance_variable_set("@#{name}".to_sym, "#{value}") unless name.nil?
-        end
-        @cover_image = response.at("//pnx:addata/pnx:lad02", PNX_NS).inner_text unless response.at("//pnx:addata/pnx:lad02", PNX_NS).nil?
-        @titles = []
-        response.search("//pnx:display/pnx:title", PNX_NS).each do |title|
-          @titles.push(title.inner_text)
-        end
-        @authors = []
-        response.search("//pnx:display/pnx:creator", PNX_NS).each do |creator|
-          @authors.push(creator.inner_text)
-        end
-      end
- 
-      # Process search results
-      # Process Holdings based on display/availlibrary
-      # Process URLs based on links/linktorsrc
-      # Process TOCs based on links/linktotoc
-      def process_search_results
-        @count = response.at("//search:DOCSET", SEARCH_NS)["TOTALHITS"] unless response.nil? or @count
-        # Loop through records to set metadata for holdings, urls and tocs
-        response.search("//pnx:record", PNX_NS).each do |record|
-          # Default genre to article if necessary
-          record_genre = (record.xpath("pnx:addata/pnx:genre", PNX_NS).nil?) ? "article" : record.xpath("pnx:addata/pnx:genre", PNX_NS).inner_text
-          # Don't process if passed in genre doesn't match the record genre unless the discrepancy is only b/w journals and articles
-          # If we're working off id numbers, we should be good to proceed
-          next unless @primo_id or @isbn or @issn or 
-              @genre == record_genre or (@genre == "journal" and record_genre == "article")
-          # Just take the first element for record level elements 
-          # (should only be one, except sourceid which will be handled later)
-          record_id = record.xpath("pnx:control/pnx:recordid", PNX_NS).inner_text
-          record_title = record.xpath("pnx:display/pnx:title", PNX_NS).inner_text
-          record_author = record.xpath("pnx:display/pnx:creator", PNX_NS).inner_text
-          display_type = record.xpath("pnx:display/pnx:type", PNX_NS).inner_text
-          original_source_id = record.xpath("pnx:control/pnx:originalsourceid", PNX_NS).inner_text unless record.xpath("pnx:control/pnx:originalsourceid", PNX_NS).nil?
-          original_source_ids = process_control_hash(record, "pnx:control/pnx:originalsourceid", PNX_NS)
-          source_id = record.xpath("pnx:control/pnx:sourceid", PNX_NS).inner_text
-          source_ids = process_control_hash(record, "pnx:control/pnx:sourceid", PNX_NS)
-          source_record_id = record.xpath("pnx:control/pnx:sourcerecordid", PNX_NS).inner_text
-          # Process holdings
-          source_record_ids = process_control_hash(record, "pnx:control/pnx:sourcerecordid", PNX_NS)
-          record.xpath("pnx:display/pnx:availlibrary", PNX_NS).each do |availlibrary|
-            availlibrary, institution_code, library_code, id_one, id_two, status_code, origin = process_availlibrary availlibrary
-            holding_original_source_id = (origin.nil?) ? original_source_ids[record_id] : original_source_ids[origin] unless original_source_ids.empty?
-            holding_original_source_id = original_source_id if holding_original_source_id.nil?
-            holding_source_id = (origin.nil?) ? source_ids[record_id] : source_ids[origin] unless source_ids.empty?
-            holding_source_id = source_id if holding_source_id.nil?
-            holding_source_record_id = (origin.nil?) ? source_record_ids[record_id] : source_record_ids[origin] unless source_record_ids.empty?
-            holding_source_record_id =  source_record_id if holding_source_record_id.nil?
-            holding_parameters = {
-              :base_url => @base_url, :vid => @vid, :config => @config,
-              :record_id => record_id, :title => record_title, :author => record_author, 
-              :original_source_id => holding_original_source_id, :source_id => holding_source_id, 
-              :source_record_id => holding_source_record_id, :origin => origin, 
-              :availlibrary => availlibrary, :institution_code => institution_code, 
-              :library_code => library_code, :id_one => id_one, :id_two => id_two, 
-              :status_code => status_code, :origin => origin, :display_type => display_type, :notes => ""
-            }
-            holding = Exlibris::Primo::Holding.new(holding_parameters)
-            @holdings.push(holding) unless holding.nil?
-          end
-          # Process urls
-          record.xpath("pnx:links/pnx:linktorsrc", PNX_NS).each do |linktorsrc|
-            linktorsrc, v, url, display, institution_code, origin = process_linktorsrc linktorsrc
-            rsrc = Exlibris::Primo::Rsrc.new({
-              :record_id => record_id, :linktorsrc => linktorsrc, 
-              :v => v, :url => url, :display => display, 
-              :institution_code => institution_code, :origin => origin,
-              :notes => ""
-            }) unless linktorsrc.nil?
-            @rsrcs.push(rsrc) unless (rsrc.nil? or rsrc.url.nil?)
-          end
-          # Process tocs
-          record.xpath("pnx:links/pnx:linktotoc", PNX_NS).each do |linktotoc|
-            linktotoc, url, display = process_linktotoc linktotoc
-            toc = Exlibris::Primo::Toc.new({
-              :record_id => record_id, :linktotoc => linktotoc, 
-              :url => url, :display => display, 
-              :notes => ""
-            }) unless linktotoc.nil?
-            @tocs.push(toc) unless (toc.nil? or toc.url.nil?)
-          end
-          # Process addlinks
-          record.xpath("pnx:links/pnx:addlink", PNX_NS).each do |addlink|
-            addlink, url, display = process_addlink addlink
-            related_link = Exlibris::Primo::RelatedLink.new({
-              :record_id => record_id, :addlink => addlink, 
-              :url => url, :display => display, 
-              :notes => ""
-            }) unless addlink.nil?
-            @related_links.push(related_link) unless (related_link.nil? or related_link.url.nil?)
-          end
-        end
-      end
-
-      def process_control_hash(record, xpath, ns)
-        h = {}
-        record.xpath(xpath, ns).each do |e|
-          str = e.inner_text unless e.nil?
-          a = str.split(/\$(?=\$)/) unless str.nil?
-          v = nil
-          o = nil
-          a.each do |s|
-            v = s.sub!(/^\$V/, "") unless s.match(/^\$V/).nil?
-            o = s.sub!(/^\$O/, "") unless s.match(/^\$O/).nil?
-          end
-          h[o] = v unless (o.nil? or v.nil?)
-        end
-        return h
-      end
-    
-      def process_availlibrary(input)
-        availlibrary, institution_code, library_code, id_one, id_two, status_code, origin =
-          nil, nil, nil, nil, nil, nil, nil
-        return institution_code, library_code, id_one, id_two, status_code, origin if input.nil? or input.inner_text.nil?
-        availlibrary = input.inner_text
-        availlibrary.split(/\$(?=\$)/).each do |s|
-          institution_code = s.sub!(/^\$I/, "") unless s.match(/^\$I/).nil?
-          library_code = s.sub!(/^\$L/, "") unless s.match(/^\$L/).nil?
-          id_one = s.sub!(/^\$1/, "") unless s.match(/^\$1/).nil?
-          id_two = s.sub!(/^\$2/, "") unless s.match(/^\$2/).nil?
-          # Always display "Check Availability" if this is from Primo.
-          #@status_code = s.sub!(/^\$S/, "") unless s.match(/^\$S/).nil?
-          status_code = "check_holdings"
-          origin = s.sub!(/^\$O/, "") unless s.match(/^\$O/).nil?
-        end
-        return availlibrary, institution_code, library_code, id_one, id_two, status_code, origin
-      end
-    
-      def process_linktorsrc(input)
-        linktorsrc, v, url, display, institution_code, origin = nil, nil, nil, nil, nil, nil
-        return linktorsrc, v, url, display, institution_code, origin if input.nil? or input.inner_text.nil?
-        linktorsrc = input.inner_text
-        linktorsrc.split(/\$(?=\$)/).each do |s|
-          v = s.sub!(/^\$V/, "")  unless s.match(/^\$V/).nil?
-          url = s.sub!(/^\$U/, "")  unless s.match(/^\$U/).nil?
-          display = s.sub!(/^\$D/, "")  unless s.match(/^\$D/).nil?
-          institution_code = s.sub!(/^\$I/, "") unless s.match(/^\$I/).nil?
-          origin = s.sub!(/^\$O/, "") unless s.match(/^\$O/).nil?
-        end
-        return linktorsrc, v, url, display, institution_code, origin
-      end
-
-      def process_linktotoc(input)
-        linktotoc, url, display, = nil, nil, nil
-        return linktotoc, url, display if input.nil? or input.inner_text.nil?
-        linktotoc = input.inner_text
-        linktotoc.split(/\$(?=\$)/).each do |s|
-          url = s.sub!(/^\$U/, "")  unless s.match(/^\$U/).nil?
-          display = s.sub!(/^\$D/, "")  unless s.match(/^\$D/).nil?
-        end
-        return linktotoc, url, display
-      end
-
-      def process_addlink(input)
-        addlink, url, display, = nil, nil, nil
-        return addlink, url, display if input.nil? or input.inner_text.nil?
-        addlink = input.inner_text
-        addlink.split(/\$(?=\$)/).each do |s|
-          url = s.sub!(/^\$U/, "")  unless s.match(/^\$U/).nil?
-          display = s.sub!(/^\$D/, "")  unless s.match(/^\$D/).nil?
-        end
-        return addlink, url, display
-      end
-
-      def raise_required_setup_parameter_error(parameter)
-        raise "Initialization error in #{self.class}. Missing required setup parameter: #{parameter}."
-      end
-    end
-  end
-end

data/lib/exlibris/primo/toc.rb

@@ -1,20 +0,0 @@
-module Exlibris
-  module Primo
-    # == Overview
-    # Class for handling Primo TOCs from links/linktotoc
-    class Toc
-      @base_attributes = [ :record_id, :linktotoc, :url, :display,  :notes ]
-      class << self; attr_reader :base_attributes end
-      def initialize(options={})
-        base_attributes = (self.class.base_attributes.nil?) ? 
-          Exlibris::Primo::Toc.base_attributes : self.class.base_attributes
-        base_attributes.each { |attribute|
-          self.class.send(:attr_reader, attribute)
-        }
-        options.each { |option, value| 
-          self.instance_variable_set(('@'+option.to_s).to_sym, value) 
-        }
-      end
-    end
-  end
-end

data/lib/exlibris/primo/web_service.rb

@@ -1,203 +0,0 @@
-module Exlibris
-  module Primo
-    # == Overview
-    # Module for calling Primo Web Services
-    # Please note the following:
-    # * Be sure to configure the Primo Back Office with the relevant IPs to enable interaction via the Web Services
-    # * This module does not parse the response but instead stores it as an Nokogiri::XML::Document for the calling classes to parse
-    module WebService
-      require 'nokogiri'
-      require 'rexml/document'
-
-      # WebServiceBase is the base class for all Primo Web Services
-      # It can be extended but is not intended for use by itself
-      # To call a PrimoWebService implementing classes must explicity 
-      # call the method make_call.
-      class WebServiceBase
-        attr_reader :response, :error
-
-        # Call to web service is made through make_call
-        # Raise a method not found exception if the method name is not valid
-        def make_call(base_url, service, method_name, param_name, input)
-          require 'soap/rpc/driver'
-          endpoint_url = base_url + "/PrimoWebServices/services/primo/" + service
-          soap_client = SOAP::RPC::Driver.new(endpoint_url, "http://www.exlibris.com/primo/xsd/wsRequest", "")
-          soap_client.add_method(method_name, param_name) unless (respond_to? method_name)
-          @response = Nokogiri::XML(soap_client.method(method_name).call(input.to_s))
-          raise "Error making call to Primo web service.  Response from web service is #{@response}." if @response.nil?
-          @error = []
-          response.search("ERROR").each do |e|
-            # Primo Web Service calls will return an <ERROR MESSAGE="{MESSAGE}" CODE="{CODE}" />
-            # tag even when it succeeds. Key off CODE == 0 which is a successful call.
-            #debugger
-            @error.push(e.attributes["MESSAGE"]) unless e.nil? or e.attributes["CODE"].value.to_i == 0
-          end
-          raise "Error making call to Primo web service.  #{@error.inspect}" unless @error.empty?
-        end
-        
-        private
-        def tag!(name, value)
-          REXML::Element.new(name).add_text(value)
-        end
-      end
-
-      # Search is the base class for Search web services
-      # It can be extended but is not intended for use by itself
-      # Two known implementations are SearchBrief and GetRecord
-      class Search < WebServiceBase
-        # Search is instantiated by calling Search.new with the following parameters
-        #   String method_name: web service method being called
-        #   String param_name: name of input parameter
-        #   String input_root: input root tag name
-        #   REXML::Element primo_search_request: REXML:Element representation of the search base on ExL Schema
-        #   REXML:Elements[] additional_input: any additional input as an array of REXML::Elements
-        #   String base_url: Primo URL
-        #   Hash option: options NOT USED 
-        def initialize(method_name, param_name, input_root, primo_search_request, additional_input, base_url, options)
-          input = REXML::Element.new(input_root)
-          input.add_namespace("http://www.exlibris.com/primo/xsd/wsRequest")
-          input.add_element(primo_search_request)
-          additional_input.each do |e|  
-            input.add_element(e)
-          end
-          make_call(base_url, "searcher", method_name, param_name, input)
-        end
-
-        private
-        def primo_search_request(search_params={}, start_index="1", bulk_size="5", did_u_mean_enabled="false", highlighting_enabled="false", get_more=nil)
-          xml = REXML::Element.new("PrimoSearchRequest")
-          xml.add_namespace("http://www.exlibris.com/primo/xsd/search/request")
-          xml.add_element(query_terms(search_params))
-          xml.add_element(tag!("StartIndex", start_index)) unless start_index.nil?
-          xml.add_element(tag!("BulkSize", bulk_size)) unless bulk_size.nil?
-          xml.add_element(tag!("DidUMeanEnabled", did_u_mean_enabled))  unless did_u_mean_enabled.nil?
-          xml.add_element(tag!("HighlightingEnabled", highlighting_enabled))  unless highlighting_enabled.nil?
-          xml.add_element(tag!("GetMore", get_more))  unless get_more.nil?
-          return xml
-        end
-
-        def query_terms(search_params, bool_operator="AND")
-          xml = REXML::Element.new("QueryTerms")
-          xml.add_element(tag!("BoolOpeator", bool_operator)) unless bool_operator.nil?
-          search_params.each do |m, v|
-            begin
-              xml.add_element(self.method("#{m}_query_term").call(v))
-            rescue Exception => e
-              raise "Invalid search params.\nSupported search params are\n\t:isbn\n\t:issn\n\t:title\n\t:author\n\t:genre\n\nException: #{e.inspect}"
-            end
-          end
-          return xml
-        end
-
-        def query_term(value=nil, index_field="any", precision_operator="contains")
-          xml = REXML::Element.new("QueryTerm")
-          xml.add_element(tag!("IndexField", index_field)) unless value.nil?
-          xml.add_element(tag!("PrecisionOperator", precision_operator)) unless value.nil?
-          xml.add_element(tag!("Value", value)) unless value.nil?
-          return xml
-        end
-
-        def isbn_query_term(isbn)
-          return query_term(isbn, "isbn", "exact")
-        end
-
-        def issn_query_term(issn)
-          return query_term(issn, "isbn", "exact")
-        end
-
-        def title_query_term(title)
-          return query_term(title, "title")
-        end
-
-        def author_query_term(author)
-          return query_term(author, "creator")
-        end
-
-        def genre_query_term(genre)
-          return query_term(genre, "any", "exact")
-        end
-      end
-
-      # SearchBrief does a brief result search through the Primo APIs
-      # Not all Primo API options are currently supported
-      # Supported search params are
-      #   :isbn, :issn, :title :author, :genre
-      #   e.g. {:isbn => "0143039008", :title => "Travels with My Aunt"}
-      # Invalid params will raise an exception
-      class SearchBrief < Search
-        def initialize(search_params, base_url, options={})
-          additional_input=[]
-          additional_input.push(tag!("institution", options.delete(:institution))) if options.has_key?(:institution)
-          super("searchBrief", "searchBriefRequest", "searchRequest", primo_search_request(search_params), additional_input, base_url, options)
-        end
-      end
-
-      # GetRecord get a Primo record based on doc id
-      # Not all Primo API options are currently supported
-      class GetRecord < Search
-        def initialize(doc_id, base_url, options={})
-          additional_input=[]
-          additional_input.push(tag!("docId", doc_id))
-          additional_input.push(tag!("institution", options.delete(:institution))) if options.has_key?(:institution)
-          super("getRecord", "getRecordRequest", "fullViewRequest", primo_search_request, additional_input, base_url, options)
-        end
-      end
-      
-      # EShelf is the base class for EShelf web services
-      # It can be extended but is not intended for use by itself
-      # Known implementations are GetEShelf, AddToEShelf, RemoveFromEShelf, GetEShelfStructure
-      class EShelf < WebServiceBase
-        def initialize(method_name, param_name, input_root, user_id, institution, additional_input, base_url, options, service_name = nil)
-          input = REXML::Element.new(input_root)
-          input.add_namespace("http://www.exlibris.com/primo/xsd/wsRequest")
-          input.add_element(tag!("userId", user_id)) if !user_id.nil?
-          input.add_element(tag!("institution", institution)) if !institution.nil?
-          additional_input.each do |e|  
-            input.add_element(e)
-          end
-          service_name = "eshelf" if service_name.nil?
-          make_call(base_url, service_name, method_name, param_name, input)
-        end
-
-        private
-        def docs(doc_ids=[], folder_id=nil, folder_name=nil)
-          additional_input = []
-          doc_ids.each { |doc_id| additional_input.push(tag!("docId", doc_id)) }
-          additional_input.push(tag!("folderId", folder_id)) unless folder_id.nil?
-          additional_input.push(tag!("folderName", folder_name)) unless folder_name.nil?
-          return additional_input
-        end
-      end
-
-      # Get EShelf based on user_id and institution
-      class GetEShelf < EShelf
-        def initialize(user_id, institution, base_url, options={})
-          super("getEshelf", "getEshelfRequest", "getEshelfRequest", user_id, institution, [], base_url, options)
-          raise "Error making call to Primo web service.  #{@error.inspect}" unless @error.empty? or @error.attribe
-        end
-      end
-
-      # Get EShelf structure based on user_id and institution
-      class GetEShelfStructure < EShelf
-        def initialize(user_id, institution, base_url, options={})
-          super("getEshelfStructure", "getEshelfStructureRequest", "getEshelfStructureRequest", user_id, institution, [tag!("includeBasketItems","false")], base_url, options, "eshelfstructure")
-          raise "Error making call to Primo web service.  #{@error.inspect}" unless @error.empty? or @error.attribe
-        end
-      end
-
-      # Add document to EShelf based on user_id and institution
-      class AddToEShelf < EShelf
-        def initialize(doc_ids, folder_id, user_id, institution, base_url, options={})
-          super("addToEshelf", "addToEshelfRequest", "addToEshelfRequest", user_id, institution, docs(doc_ids, folder_id), base_url, options)
-        end
-      end
-
-      # Remove document from EShelf based on user_id and institution
-      class RemoveFromEShelf < EShelf
-        def initialize(doc_ids, folder_id, user_id, institution, base_url, options={})
-          super("removeFromEshelf", "removeFromEshelfRequest", "removeFromEshelfRequest", user_id, institution, docs(doc_ids, folder_id), base_url, options)
-        end
-      end
-    end
-  end
-end