umlaut 3.0.0beta2 → 3.0.0beta3

data/lib/exlibris/aleph/patron.rb

@@ -1,64 +0,0 @@
-module Exlibris::Aleph
-  class Patron < RestAPI
-    attr_accessor :patron_id
-
-    def initialize(patron_id, uri)
-      @patron_id = patron_id
-      raise "Initialization error in #{self.class}. Missing patron id." if @patron_id.nil?
-      super(uri)
-      @uri = @uri+ "/patron/#{patron_id}"
-    end
-
-    # Place a hold on the specificed item.
-    # Raises errors if 
-    def place_hold(adm_library, bib_library, bib_id, item_id, params)
-      pickup_location = params[:pickup_location]
-      raise "Error in place hold.  Missing pickup location." if pickup_location.nil?
-      last_interest_date = params.fetch(:last_interest_date, "")
-      start_interest_date = params.fetch(:start_interest_date, "")
-      sub_author = params.fetch(:sub_author, "")
-      sub_title = params.fetch(:sub_title, "")
-      pages = params.fetch(:pages, "")
-      note_1 = params.fetch(:note_1, "")
-      note_2 = params.fetch(:note_2, "")
-      rush = params.fetch(:rush, "N")
-      body_str = "<hold-request-parameters>"
-      body_str << "<pickup-location>#{pickup_location}</pickup-location>"
-      body_str << "<last-interest-date>#{last_interest_date}</last-interest-date>"
-      body_str << "<start-interest-date>#{start_interest_date}</start-interest-date>"
-      body_str << "<sub-author>#{sub_author}</sub-author>"
-      body_str << "<sub-title>#{sub_title}</sub-title>"
-      body_str << "<pages>#{pages}</pages>"
-      body_str << "<note-1>#{note_1}</note-1>"
-      body_str << "<note-2>#{note_2}</note-2>"
-      body_str << "<rush>#{rush}</rush>"
-      body_str << "</hold-request-parameters>"
-      options = { :body => "post_xml=#{body_str}"}
-      @response = self.class.put(@uri+ "/record/#{bib_library}#{bib_id}/items/#{item_id}/hold", options)
-      raise "Error placing hold through Aleph REST APIs. #{error}" unless error.nil?
-      return @response
-    end
-
-    def loans()
-      @response = self.class.get(@uri+ "/circulationActions/loans?view=full")
-      raise "Error getting loans through Aleph REST APIs. #{error}" unless error.nil?
-      return @response
-    end
-
-    def renew_loans(item_id="")
-      # Will renew all if specific item not specified
-      @response = self.class.post(@uri+ "/circulationActions/loans/#{item_id}")
-      raise "Error renewing loan(s) through Aleph REST APIs. #{error}" unless error.nil?
-      return @response
-    end
-
-    def note
-      return (not @response.first.last.kind_of?(Hash) or @response.first.last["create_hold"].nil?) ? "" : ": #{@response.first.last["create_hold"]["note"]}" if @response.instance_of?(Hash)
-    end
-
-    def error
-      return nil if reply_code == "0000"
-      return "#{reply_text}#{note}"
-    end
-  end
-end

data/lib/exlibris/aleph/record.rb

@@ -1,54 +0,0 @@
-module Exlibris::Aleph
-  class Record < RestAPI
-    def initialize(bib_library, record_id, uri)
-      @record_id = record_id
-      raise "Initialization error in #{self.class}. Missing record id." if @record_id.nil?
-      @bib_library = bib_library
-      raise "Initialization error in #{self.class}. Missing bib library." if @bib_library.nil?
-      super(uri)
-      @uri = @uri+ "/record/#{bib_library}#{record_id}"
-      # Format :xml parses response as a hash.
-      # Eventually I'd like this to be the default since it raises exceptions for invalid XML.
-      # self.class.format :xml
-      # Format :html does no parsing, just passes back raw XML for parsing by client
-      self.class.format :html
-    end
-
-    # Returns an XML string representation of a bib.  
-    # Every method call refreshes the data from the underlying API.
-    # Raises and exception if there are errors.
-    def bib
-      @response = self.class.get(@uri+ "?view=full")
-      raise "Error getting bib from Aleph REST APIs. #{error}" unless error.nil?
-      return @response
-    end
-
-    # Returns an array of items. Each item is represented as an HTTParty hash. 
-    # Every method call refreshes the data from the underlying API.
-    # Raises an exception if the response is not valid XML or there are errors.
-    def items
-      @items = []
-      self.class.format :xml
-      # Since we're parsing xml, this will raise an error
-      # if the response isn't xml.
-      @response = self.class.get(@uri+ "/items?view=full")
-      self.class.format :html
-      raise "Error getting items from Aleph REST APIs. #{error}" if not error.nil? or 
-        @response.nil? or @response["get_item_list"].nil? or @response["get_item_list"]["items"].nil?
-      item_list = @response["get_item_list"]["items"]["item"]
-      @items.push(item_list) if item_list.instance_of?(Hash)
-      item_list.each {|item|@items.push(item)} if item_list.instance_of?(Array)
-      Rails.logger.warn("No items returned from Aleph in #{self.class}.") if @items.empty?
-      return @items
-    end
-
-    # Returns an XML string representation of holdings 
-    # Every method call refreshes the data from the underlying API.
-    # Raises and exception if there are errors.
-    def holdings
-      @response = self.class.get(@uri+ "/holdings?view=full")
-      raise "Error getting holdings from Aleph REST APIs. #{error}" unless error.nil?
-      return @response
-    end
-  end
-end

data/lib/exlibris/aleph/rest_api.rb

@@ -1,29 +0,0 @@
-module Exlibris::Aleph
-  require 'httparty'
-  class RestAPI
-    include HTTParty
-    format :xml
-    def initialize(uri)
-      @uri = uri
-      raise "Initialization error in #{self.class}. Missing URI." if @uri.nil?
-    end
-    def error
-      return nil if reply_code == "0000" 
-      return "#{reply_text}"
-    end
-    def reply_code
-      return "No response." if @response.nil?
-      return (not @response.first.last.kind_of?(Hash) or @response.first.last["reply_code"].nil?) ? "Unexpected response hash." : @response.first.last["reply_code"] if @response.instance_of?(Hash)
-      response_match = @response.match(/\<reply-code\>(.+)\<\/reply-code\>/) if @response.instance_of?(String)
-      return (response_match.nil?) ? "Unexpected response string." : response_match[1] if @response.instance_of?(String)
-      return "Unexpected response type."
-    end
-    def reply_text
-      return "No response." if @response.nil?
-      return (not @response.first.last.kind_of?(Hash) or @response.first.last["reply_text"].nil?) ? "Unexpected response hash." : @response.first.last["reply_text"] if @response.instance_of?(Hash)
-      response_match = @response.match(/\<reply-text\>(.+)\<\/reply-text\>/) if @response.instance_of?(String)
-      return (response_match.nil?) ? "Unexpected response string." : response_match[1] if @response.instance_of?(String)
-      return "Unexpected response type."
-    end
-  end
-end

data/lib/exlibris/primo/holding.rb

@@ -1,186 +0,0 @@
-module Exlibris::Primo
-# == Overview
-# Exlibris::Primo::Holding represents a Primo holding.
-# This class should be extended to create Primo source objects for 
-# expanding holdings information, linking to Primo sources, and storing 
-# additional metadata based on those sources.
-#
-# == Tips on Extending
-# When extending the class, a few basics guidelines should be observed.
-# 1.  A Exlibris::Primo::Holding is initialized from random Hash of parameters.
-#     Instance variables are created from these parameters for use in the class.
-#
-# 2.  A Exlibris::Primo::Holding can be initialized from an input 
-#     Exlibris::Primo::Holding by specifying the reserved
-#     parameter name :holding, i.e. :holding => input_holding.
-#     If the input holding has instance variables that are also specified in
-#     the random Hash, the value in the Hash takes precedence.
-#
-# 3.  The following methods are available for overriding:
-#     expand -    expand holdings information based on data source. default: [self]
-#     dedup? -    does this data source contain duplicate holdings that need to be deduped? default: false
-#
-# 4.  The following instance variables will be saved in the view_data and will be available
-#     to a local holding partial:
-#     @record_id, @source_id, @original_source_id, @source_record_id,
-#     @availlibrary, @institution_code, @institution, @library_code, @library,
-#     @status_code, @status, @id_one, @id_two, @origin, @display_type, @coverage, @notes,
-#     @url, @request_url, @match_reliability, @request_link_supports_ajax_call, @source_data
-#
-# 5.  Additional source data should be saved in the @source_data instance variable.
-#     @source_data is a hash that can contain any number of string elements,
-#     perfect for storing local source information.
-#     @source_data will get saved in the view_data and will be available to a 
-#     local holding partial.
-#
-# == Examples
-# Example of Primo source implementations are:
-# * Exlibris::Primo::Source::Aleph
-  class Holding
-    @base_attributes = [ :record_id, :source_id, :original_source_id, :source_record_id,
-      :availlibrary, :institution_code, :institution, :library_code, :library,
-      :status_code, :status, :id_one, :id_two, :origin, :display_type, :coverage, :notes,
-      :url, :request_url, :match_reliability, :request_link_supports_ajax_call, :source_data ]
-    # Make sure attribute you're aliasing in in base_attributes
-    @attribute_aliases = { :collection => :id_one, :call_number => :id_two }
-    @required_parameters = [ :base_url, :record_id, :source_id, 
-      :original_source_id, :source_record_id, :availlibrary,
-      :institution_code, :library_code, :id_one, :id_two, :status_code ]
-    @parameter_default_values = { :vid => "DEFAULT", :config => {}, 
-      :max_holdings => 10, :request_link_supports_ajax_call => false,
-      :coverage => [], :source_data => {} }
-    @decode_variables = { 
-      :institution => {}, 
-      :library => { :address => "libraries" },
-      :status => { :address => "statuses" }
-    }
-    class << self; attr_reader :base_attributes, :attribute_aliases, :required_parameters, :parameter_default_values, :decode_variables end
-
-    def initialize(parameters={})
-      # Set attr_readers
-      base_attributes = (self.class.base_attributes.nil?) ? 
-        Exlibris::Primo::Holding.base_attributes : self.class.base_attributes
-      base_attributes.each { |attribute|
-        self.class.send(:attr_reader, attribute)
-      }
-      # Defensive copy the holding parameter.
-      holding = parameters[:holding].clone unless parameters[:holding].nil?
-      raise "Initialization error in #{self.class}. Unexpected holding parameter: #{holding.class}." unless holding.kind_of? Holding or holding.nil?
-      # Copy the defensive copy of holding to self.
-      holding.instance_variables.each { |name| 
-        instance_variable_set((name).to_sym, holding.instance_variable_get(name)) 
-      } if holding.kind_of? Holding
-      # Add required instance variables, raising an exception if they're missing
-      # Params passed in overwrite instance variables copied from the holding
-      required_parameters = (self.class.required_parameters.nil?) ? 
-        Exlibris::Primo::Holding.required_parameters : self.class.required_parameters
-      required_parameters.each do |param|
-        instance_variable_set(
-          "@#{param}".to_sym, 
-          parameters.delete(param) { 
-            instance_variable_get("@#{param}") if instance_variable_defined?("@#{param}") }
-        )
-        raise_required_parameter_error param unless instance_variable_defined?("@#{param}")
-      end
-      # Set additional instance variables from passed parameters
-      # Params passed in overwrite instance variables copied from the holding
-      parameters.each { |param, value| 
-        instance_variable_set("@#{param}".to_sym, value)
-      }
-      # If appropriate, add defaults to non-required elements
-      parameter_default_values = (self.class.parameter_default_values.nil?) ? 
-        Exlibris::Primo::Holding.parameter_default_values : self.class.parameter_default_values
-      parameter_default_values.each { |param, default|
-        instance_variable_set("@#{param}".to_sym, default) unless instance_variable_defined?("@#{param}")
-      }
-      # Set decoded fields
-      decode_variables = (self.class.decode_variables.nil?) ? 
-        Exlibris::Primo::Holding.decode_variables : self.class.decode_variables
-      decode_variables.each { |var, decode_params|
-        decode var, decode_params, true
-      }
-      # Deep link URL to record
-      @url = primo_url if @url.nil?
-      # Set source parameters
-      @source_config = @config["sources"][source_id] unless @config["sources"].nil?
-      @source_class = @source_config["class_name"] unless @source_config.nil?
-      @source_url = @source_config["base_url"] unless @source_config.nil?
-      @source_type = @source_config["type"] unless @source_config.nil?
-      @source_data = {
-        :source_class => @source_class,
-        :source_url => @source_url,
-        :source_type => @source_type
-      }
-      # Set aliases for convenience
-      attribute_aliases = (self.class.attribute_aliases.nil?) ? 
-        Exlibris::Primo::Holding.attribute_aliases : self.class.attribute_aliases
-      attribute_aliases.each { |alias_name, method_name|
-        begin
-          self.class.send(:alias_method, alias_name.to_sym, method_name.to_sym)
-        rescue NameError => ne
-          raise NameError, "Error in #{self}. Make sure method, #{method_name}, is defined. You may need to add it to #{self} @base_attributes.\nRoot exception: #{ne.message}"
-        end
-      }
-    end
-    
-    # Returns an array of self.
-    # Should be overridden by source subclasses to map multiple holdings
-    # to one availlibrary.
-    def expand
-      return [self]
-    end
-
-    # Determine if we're de-duplicating.
-    # Should be overridden by source subclasses if appropriate.
-    def dedup?
-      return false
-    end
-    
-    # Return this holding as a new holdings subclass instance based on source
-    def to_source
-      return self if @source_class.nil?
-      begin
-        # Get source class in Primo::Source module
-         return Exlibris::Primo::Source.const_get(@source_class).new(:holding => self)
-      rescue Exception => e
-        Rails.logger.error("#{e.message}")
-        Rails.logger.error("Class #{@source_class} can't be found in Exlibris::Primo::Source.  
-          Please check primo.yml to ensure the class_name is defined correctly.  
-          Not converting to source.")
-        return self
-      end
-    end
-
-    def [](key)
-      raise "Error in #{self.class}. #{key} doesn't exist or is restricted." unless self.class.base_attributes.include?(key)
-      method(key).call
-    end
-
-    protected
-    def decode(var, decode_params={}, refresh=false)
-      return instance_variable_get("@#{var}") unless (not instance_variable_defined?("@#{var}")) or refresh
-      code_sym = (decode_params[:code].nil?) ? "#{var}_code".to_sym : decode_params[:code]
-      code = instance_variable_get("@#{code_sym}")
-      config_sym = (decode_params[:config].nil?) ? :config : decode_params[:config]
-      config = instance_variable_get("@#{config_sym}")
-      address = (decode_params[:address].nil?) ? "#{var}s" : decode_params[:address]
-      instance_variable_set("@#{var}", 
-        (config[address].nil? or config[address][code].nil?) ? 
-          code : config[address][code]) unless code.nil?
-    end
-
-    # Returns Primo deep link URL to record
-    def primo_url
-      "#{@base_url}/primo_library/libweb/action/dlDisplay.do?docId=#{@record_id}&institution=#{@institution_code}&vid=#{@vid}"
-    end
- 
-    private
-    # def self.add_attr_reader(reader)
-    #   attr_reader reader.to_sym
-    # end
-    # 
-    def raise_required_parameter_error(parameter)
-      raise "Initialization error in #{self.class}. Missing required parameter: #{parameter}."
-    end
-  end
-end

data/lib/exlibris/primo/related_link.rb

@@ -1,17 +0,0 @@
-module Exlibris::Primo
-  # 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

data/lib/exlibris/primo/rsrc.rb

@@ -1,17 +0,0 @@
-module Exlibris::Primo
-  # 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

data/lib/exlibris/primo/searcher.rb

@@ -1,297 +0,0 @@
-# == Overview
-# Searcher searches Primo for records.
-# 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, Searcher.search
-# will raise a RuntimeException. 
-require "iconv"
-
-module Exlibris::Primo
-  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.server.institution.edu }
-    # Other optional parameters are :vid => "view_id", :config => { Hash of primo config settings}
-    # 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
-      Rails.logger.warn("Insufficient search terms for #{self.class}. "+
-        "Please refer to #{self.class}'s documentation to determine how to structure "+
-        "a sufficient query.") and return if insufficient_query?
-      # Call Primo Web Services
-      unless @primo_id.nil? or @primo_id.empty?
-        get_record = Exlibris::PrimoWS::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::PrimoWS::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
-        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, :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 => "",
-            :match_reliability => 
-              (record.xpath("pnx:display/pnx:title", PNX_NS) and record.xpath("pnx:display/pnx:creator", PNX_NS)) ? 
-                (reliable_match?(:title => record.xpath("pnx:display/pnx:title", PNX_NS).inner_text, :author => record.xpath("pnx:display/pnx:creator", PNX_NS).inner_text)) ? 
-                  ServiceResponse::MatchExact : ServiceResponse::MatchUnsure : ServiceResponse::MatchExact
-          }
-          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
-    
-    # Determine how sure we are that this is a match.
-    # Dynamically compares record metadata to input values 
-    # based on the values passed in.
-    # Minimum requirement is to check title.
-    def reliable_match?(record_metadata)
-      return true unless (@primo_id.nil? or @primo_id.empty?)
-      return true unless (@issn.nil? or @issn.empty?) and (@isbn.nil? or @isbn.empty?)
-      return false if (record_metadata.nil? or record_metadata.empty? or record_metadata[:title].nil? or record_metadata[:title].empty?)
-      # Titles must be equal
-      return false unless record_metadata[:title].downcase.eql?(@title.downcase)
-      # Compare record metadata with metadata that was passed in.  
-      # Only check if the record metadata value contains the input value since we can't be too strict.
-      record_metadata.each { |type, value| return false if value.downcase.match("#{self.method(type).call}".downcase).nil?}
-      return true
-    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
-    
-    # def convert_diacritics(string)
-    #   converter = Iconv.new('UTF-8', 'UTF-8')
-    #   # Convert value to UTF-8
-    #   return converter.iconv(string) unless string.nil?
-    # end
-  end
-end