umlaut 3.0.0alpha9 → 3.0.0alpha10

data/app/controllers/umlaut_controller.rb

@@ -57,6 +57,11 @@ class UmlautController < ApplicationController
       # (see lib/referent_filters )        
       # add_referent_filters!( :match => /.*/, :filter => DissertationCatch.new ) 
     
+      # Turn off permalink-generation? If you don't want it at all, or
+      # don't want it temporarily because you are pointing at a database
+      # that won't last. 
+      # create_permalinks false
+      
       # How many seconds between updates of the background updater for background
       # services?
       # poll_wait_seconds 4

data/app/models/collection.rb

@@ -53,6 +53,95 @@ class Collection
   # Sets all services in collection to have a 'queued' status if appropriate.
   # Then actually executes the services that are dispatchable (queued).    
   def dispatch_services!
+    queued_service_ids = prepare_for_dispatch!
+    
+    dispatch_foreground!(queued_service_ids)
+        
+    dispatch_background!(queued_service_ids)        
+  end
+  
+  # Call prepare_for_dispatch! first, the return value from that call
+  # is suitable as argument for this call: queued_service_ids, list of
+  # service id's already identified as suitable for running, and
+  # marked queued in the DispatchedService table. 
+  #
+  # Will run such services in foreground priority waves. And then reload
+  # the UmlautRequest object in the current thread, to pick up any
+  # changes made in service threads. 
+  def dispatch_foreground!(queued_service_ids)
+    # Foreground services
+    (0..9).each do | priority |      
+      services_to_run = self.instantiate_services!(:level => priority, :ids => queued_service_ids)
+      next if services_to_run.empty?      
+      ServiceWave.new(services_to_run , priority).handle(umlaut_request, umlaut_request.session_id)
+    end
+    
+    # Need to reload the request from db, so it gets changes
+    # made by services in threads, so future code (such as view rendering)
+    # will see changes.     
+    umlaut_request.reload
+  end
+  
+  # Call prepare_for_dispatch! first, the return value from that call
+  # is suitable as argument for this call: queued_service_ids, list of
+  # service id's already identified as suitable for running, and
+  # marked queued in the DispatchedService table.
+  #
+  # Will run such services in background priority waves.   
+  def dispatch_background!(queued_service_ids)
+    # Now we do some crazy magic, start a Thread to run our background
+    # services. We are NOT going to wait for this thread to join,
+    # we're going to let it keep doing it's thing in the background after
+    # we return a response to the browser
+    backgroundThread = Thread.new(self, umlaut_request) do | t_collection,  t_request|
+      # Tell our AR extension not to allow implicit checkouts
+      ActiveRecord::Base.forbid_implicit_checkout_for_thread! if ActiveRecord::Base.respond_to?("forbid_implicit_checkout_for_thread!")
+      
+      # got to reserve an AR connection for our main 'background traffic director'
+      # thread, so it has a connection to use to mark services as failed, at least. 
+      ActiveRecord::Base.connection_pool.with_connection do
+        begin
+          # Deal with ruby's brain dead thread scheduling by setting
+          # bg threads to a lower priority so they don't interfere with fg
+          # threads.
+          Thread.current.priority = -1          
+        
+          ('a'..'z').each do | priority |
+            services_to_run = self.instantiate_services!(:level => priority, :ids => queued_service_ids)        
+            next if services_to_run.empty?      
+            ServiceWave.new(services_to_run , priority).handle(umlaut_request, umlaut_request.session_id)                               
+          end        
+       rescue Exception => e
+          # We are divorced from any HTTP request at this point, and may not
+          # have access to an ActiveRecord connection. Not much
+          # we can do except log it. 
+          # If we're catching an exception here, service processing was
+          # probably interrupted, which is bad. You should not intentionally
+          # raise exceptions to be caught here.
+          #
+          # Normally even unexpected exceptions were caught inside the ServiceWave,
+          # and logged to db as well as logfile if possible, only bugs in ServiceWave
+          # itself should wind up caught here. 
+          Thread.current[:exception] = e
+          logger.error("Background Service execution exception: #{e}\n\n   " + clean_backtrace(e).join("\n"))                
+       end
+     end
+    end
+  end
+  
+  
+  # Goes through all services and marks them with a DispatchedService
+  # record in 'queued' state. 
+  #
+  # Will time out any too-old services in a running state. 
+  #
+  # Will remove DispatchedService status for 
+  # any services marked failed that are old enough to re-run, or services
+  # that are too old to re-use.   Such services are then queuable. 
+  #
+  # Returns array of Service identifiers for services that are now
+  # queued and execable. 
+  def prepare_for_dispatch!
     # Go through currently dispatched services, looking for timed out
     # services -- services still in progress that have taken too long,
     # as well as service responses that are too old to be used.      
@@ -117,60 +206,7 @@ class Collection
       end        
     end
     
-
-    
-    # Now actually dispatch. 
-    
-    # Foreground services
-    (0..9).each do | priority |      
-      services_to_run = self.instantiate_services!(:level => priority, :ids => queued_service_ids)
-      next if services_to_run.empty?      
-      ServiceWave.new(services_to_run , priority).handle(umlaut_request, umlaut_request.session_id)
-    end
-    
-    # Need to reload the request from db, so it gets changes
-    # made by services in threads. 
-    umlaut_request.reload
-    
-    # Now we run background services.
-    # Now we do some crazy magic, start a Thread to run our background
-    # services. We are NOT going to wait for this thread to join,
-    # we're going to let it keep doing it's thing in the background after
-    # we return a response to the browser
-    backgroundThread = Thread.new(self, umlaut_request) do | t_collection,  t_request|
-      # Tell our AR extension not to allow implicit checkouts
-      ActiveRecord::Base.forbid_implicit_checkout_for_thread! if ActiveRecord::Base.respond_to?("forbid_implicit_checkout_for_thread!")
-      
-      # got to reserve an AR connection for our main 'background traffic director'
-      # thread, so it has a connection to use to mark services as failed, at least. 
-      ActiveRecord::Base.connection_pool.with_connection do
-        begin
-          # Deal with ruby's brain dead thread scheduling by setting
-          # bg threads to a lower priority so they don't interfere with fg
-          # threads.
-          Thread.current.priority = -1          
-        
-          ('a'..'z').each do | priority |
-            services_to_run = self.instantiate_services!(:level => priority, :ids => queued_service_ids)        
-            next if services_to_run.empty?      
-            ServiceWave.new(services_to_run , priority).handle(umlaut_request, umlaut_request.session_id)                               
-          end        
-       rescue Exception => e
-         #debugger
-          # We are divorced from any request at this point, not much
-          # we can do except log it. Actually, we'll also store it in the
-          # db, and clean up after any dispatched services that need cleaning up.
-          # If we're catching an exception here, service processing was
-          # probably interrupted, which is bad. You should not intentionally
-          # raise exceptions to be caught here.
-          Thread.current[:exception] = e
-          logger.error("Background Service execution exception1: #{e}\n\n   " + clean_backtrace(e).join("\n"))                
-       end
-     end
-    end
-
-    
-    
+    return queued_service_ids
   end
   
   def completed_dispatch_expired?(ds)

data/app/models/referent.rb

@@ -85,6 +85,9 @@ class Referent < ActiveRecord::Base
   # :permalink => false if you already have a permalink and don't
   # need to create one. Caller should attach that permalink to this referent!
   def self.create_by_context_object(co, options = {})    
+    options = { :permalink => UmlautController.umlaut_config.create_permalinks    
+    }.merge(options)
+    
     
     self.clean_up_context_object(co)    
     rft = Referent.new
@@ -186,8 +189,10 @@ class Referent < ActiveRecord::Base
         rv.key_name = key_name
         rv.value = value
         rv.normalized_value = normalized_value
-
-        unless (key_name == "identifier" || key_name == "format")
+        
+        if key_name == "private_data"
+          rv.private_data = true
+        elsif key_name != "identifier" && key_name != "format"
           rv.metadata = true
         end
 
@@ -209,11 +214,19 @@ class Referent < ActiveRecord::Base
     if rft.format
       ensure_value!('format', rft.format)
     end
-                      
+    if rft.private_data
+      # this comes in as "pid" or "rft_dat", we store it in
+      # our database as "private_data", sorry, easiest way to
+      # fit this in at the moment. 
+      ensure_value!("private_data", rft.private_data)
+    end
+    
     rft.metadata.each { | key, value |
       next unless value
       ensure_value!( key, value)      
-    }    
+    }
+
+    
   end
 
   # pass in a Referent, or a ropenurl ContextObjectEntity that has a metadata
@@ -320,9 +333,8 @@ class Referent < ActiveRecord::Base
     co.referent = OpenURL::ContextObjectEntity.new_from_format( fmt_uri )
     rft = co.referent
     
-    # Now set all the values. 
+    # Now set all the values.
     self.referent_values.each do | val |
-      next if val.private_data?
       if val.metadata?
         rft.set_metadata(val.key_name, val.value)
         next
@@ -338,8 +350,7 @@ class Referent < ActiveRecord::Base
     # call self.metadata once and use the array for efficiency, don't
     # keep calling it. profiling shows it DOES make a difference. 
     my_metadata = self.metadata
-    
-    
+
     if my_metadata['atitle'] && ! my_metadata['atitle'].blank?
       citation[:title] = my_metadata['atitle']
       citation[:title_label], citation[:subtitle_label] = 
@@ -392,23 +403,25 @@ class Referent < ActiveRecord::Base
     end
     if ! my_metadata["au"].blank?
       citation[:author] = my_metadata["au"]
-    elsif  my_metadata["aulast"]
+    elsif my_metadata["aulast"]
       citation[:author] = my_metadata["aulast"]
       if ! my_metadata["aufirst"].blank?
-   		citation[:author] += ',	'+my_metadata["aufirst"]
+        citation[:author] += ',	'+my_metadata["aufirst"]
       else
         if ! my_metadata["auinit"].blank?
           citation[:author] += ',	'+my_metadata["auinit"]
         else
-		  if ! my_metadata["auinit1"].blank?
+          if ! my_metadata["auinit1"].blank?
             citation[:author] += ',	'+my_metadata["auinit1"]
-   		  end
-       	  if ! my_metadata["auinitm"].blank?
+          end
+          if ! my_metadata["auinitm"].blank?
             citation[:author] += my_metadata["auinitm"]
-   		  end
-   	    end
-   	  end
-   	end 
+          end
+        end
+      end
+    elsif my_metadata["aucorp"]
+      citation[:author] = my_metadata["aucorp"]
+    end 
    	if my_metadata['spage']
    	  citation[:page] = my_metadata['spage']
    	  citation[:page] += ' - ' + my_metadata['epage'] if ! my_metadata['epage'].blank?

data/app/models/service_wave.rb

@@ -5,12 +5,13 @@
 class ServiceWave
   attr_accessor :services
   attr_accessor :priority_level
+  attr_reader :config
 
   # Priority level is purely information, used for debug output. 
   def initialize(service_objects, priority_level = nil, config = UmlautController.umlaut_config)
     @services = service_objects
     @priority_level = priority_level
-
+    @config = config
     @log_timing = config.lookup!("log_service_timing", true)
 
     # Don't forward exceptions, that'll interrupt other service processing.
@@ -44,58 +45,75 @@ class ServiceWave
     Rails.logger.info(TermColor.color("Umlaut: Launching service wave #{@priority_level}", :yellow) + ", request #{request.id}") if @log_timing
 
     
+    
     threads = []
     some_service_executed = false
     @services.each do | service |
       some_service_executed = true
       local_request = nil
-        
-      threads << Thread.new(request.id, service.clone) do | request_id, local_service |
-        # Deal with ruby's brain dead thread scheduling by setting
-        # bg threads to a lower priority so they don't interfere with fg
-        # threads.
-        Thread.current.priority = -1
+      
+      service_start = Time.now          
 
-        # Save some things in thread local hash useful for debugging
-        Thread.current[:debug_name] = local_service.class.name
-        Thread.current[:service] = service
+      if config.lookup!("threaded_service_wave", true)
 
-        # Tell our AR extension not to allow implicit checkouts
-        ActiveRecord::Base.forbid_implicit_checkout_for_thread! if ActiveRecord::Base.respond_to?("forbid_implicit_checkout_for_thread!")
-        begin
-          service_start = Time.now          
-          local_request = ActiveRecord::Base.connection_pool.with_connection do
-            # pre-load all relationships so no ActiveRecord activity will be
-            # needed later to see em. 
-            Request.includes(:referent, :service_responses, :dispatched_services).find(request_id)
+      
+        threads << Thread.new(request.id, service.clone) do | request_id, local_service |
+          # Deal with ruby's brain dead thread scheduling by setting
+          # bg threads to a lower priority so they don't interfere with fg
+          # threads.
+          Thread.current.priority = -1
+  
+          # Save some things in thread local hash useful for debugging
+          Thread.current[:debug_name] = local_service.class.name
+          Thread.current[:service] = service
+  
+          # Tell our AR extension not to allow implicit checkouts
+          ActiveRecord::Base.forbid_implicit_checkout_for_thread! if ActiveRecord::Base.respond_to?("forbid_implicit_checkout_for_thread!")
+          begin
+            local_request = ActiveRecord::Base.connection_pool.with_connection do
+              # pre-load all relationships so no ActiveRecord activity will be
+              # needed later to see em. 
+              Request.includes(:referent, :service_responses, :dispatched_services).find(request_id)
+            end
+            
+  
+            if prepare_dispatch!(local_request, local_service, session_id)                          
+              local_service.handle_wrapper(local_request)
+            else
+              Rails.logger.info("NOT launching service #{local_service.service_id},  level #{@priority_level}, request #{local_request.id}: not in runnable state") if @log_timing
+            end
+            
+           
+          rescue Exception => e
+            # We may not be able to access ActiveRecord because it may
+            # have been an AR connection error, perhaps out of connections
+            # in the pool. So log and record in non-AR ways. 
+            # the code waiting on our thread will see exception
+            # reported in Thread local var, and log it AR if possible. 
+            
+            
+            # Log it too, although experience shows it may never make it to the 
+            # log for mysterious reasons. 
+            Rails.logger.error(TermColor.color("Umlaut: Threaded service raised exception.", :red, true) + "Service: #{service.service_id}, #{e}\n  #{clean_backtrace(e).join("\n  ")}")
+            
+            # And stick it in a thread variable too
+            Thread.current[:exception] = e                      
+          ensure
+            Rails.logger.info(TermColor.color("Umlaut: Completed service #{local_service.service_id}", :yellow)+ ",  level #{@priority_level}, request #{local_request && local_request.id}: in #{Time.now - service_start}.") if @log_timing
           end
-          
-
-          if prepare_dispatch!(local_request, local_service, session_id)                          
-            local_service.handle_wrapper(local_request)
+        end
+      else # not threaded
+        begin
+          if prepare_dispatch!(request, service, session_id)                          
+              service.handle_wrapper(request)
           else
-            Rails.logger.info("NOT launching service #{local_service.service_id},  level #{@priority_level}, request #{local_request.id}: not in runnable state") if @log_timing
+              Rails.logger.info("NOT launching service #{service.service_id},  level #{@priority_level}, request #{request.id}: not in runnable state") if @log_timing
           end
-          
-         
-        rescue Exception => e
-          # We may not be able to access ActiveRecord because it may
-          # have been an AR connection error, perhaps out of connections
-          # in the pool. So log and record in non-AR ways. 
-          # the code waiting on our thread will see exception
-          # reported in Thread local var, and log it AR if possible. 
-          
-          
-          # Log it too, although experience shows it may never make it to the 
-          # log for mysterious reasons. 
-          Rails.logger.error(TermColor.color("Umlaut: Threaded service raised exception.", :red, true) + "Service: #{service.service_id}, #{e}\n  #{clean_backtrace(e).join("\n  ")}")
-          
-          # And stick it in a thread variable too
-          Thread.current[:exception] = e                      
         ensure
-          Rails.logger.info(TermColor.color("Umlaut: Completed service #{local_service.service_id}", :yellow)+ ",  level #{@priority_level}, request #{local_request && local_request.id}: in #{Time.now - service_start}.") if @log_timing
+          Rails.logger.info(TermColor.color("Umlaut: Completed service #{service.service_id}", :yellow)+ ",  level #{@priority_level}, request #{request && request.id}: in #{Time.now - service_start}.") if @log_timing
         end
-      end                    
+      end
+      
     end
 
     # Wait for all the threads to complete, if any. 

data/lib/exlibris/primo/holding.rb

@@ -36,7 +36,6 @@ module Exlibris::Primo
 # == Examples
 # Example of Primo source implementations are:
 # * Exlibris::Primo::Source::Aleph
-# * Exlibris::Primo::Source::Local::NYUAleph
   class Holding
     @base_attributes = [ :record_id, :source_id, :original_source_id, :source_record_id,
       :availlibrary, :institution_code, :institution, :library_code, :library,
@@ -141,16 +140,11 @@ module Exlibris::Primo
     def to_source
       return self if @source_class.nil?
       begin
-        # Check source class in source module, if not found, see if there is a local class
-         return (Exlibris::Primo::Source.const_defined?(@source_class)) ? 
-           Exlibris::Primo::Source.const_get(@source_class).new(:holding => self) : 
-           Exlibris::Primo::Source::Local.const_get(@source_class).new(:holding => self)
+        # Get source class in Primo::Source module
+         return Exlibris::Primo::Source.const_get(@source_class).new(:holding => self)
       rescue Exception => e
-        # !!!!!!!!!!REMOVE NEXT LINE (raise e) WHEN GOING TO PRODUCTION!!!!!!!!!
-        raise e
         Rails.logger.error("#{e.message}")
-        Rails.logger.error("Class #{@source_class} can't be found in either 
-          Exlibris::Primo::Source or Exlibris::Primo::Source::Local.  
+        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

data/lib/exlibris/primo/related_link.rb

@@ -0,0 +1,17 @@
+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/searcher.rb

@@ -16,7 +16,9 @@ module Exlibris::Primo
 
     attr_reader :response, :count
     attr_reader :cover_image, :titles, :author
-    attr_reader :holdings, :rsrcs, :tocs
+    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 }
@@ -28,6 +30,7 @@ module Exlibris::Primo
       @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?
@@ -95,22 +98,21 @@ module Exlibris::Primo
     
     # Process a single record
     def process_record
-      @count = response.at("//DOCSET")["TOTALHITS"] unless response.nil? or @count
-      response.at("//addata").each_child do |addata_child|
-        name = addata_child.pathname and value = addata_child.inner_text.chars.to_s if addata_child.elem?
+      @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, "#{convert_diacritics(value)}") unless name.nil?
         instance_variable_set("@#{name}".to_sym, "#{value}") unless name.nil?
       end
-      @cover_image = response.at("//addata/lad02").inner_text unless response.at("//addata/lad02").nil?
+      @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("//display/title") do |title|
-        @titles.push(title.inner_text.chars.to_s)
+      response.search("//pnx:display/pnx:title", PNX_NS).each do |title|
+        @titles.push(title.inner_text)
       end
       @authors = []
-      response.search("//display/creator") do |e|
-        @authors.push(e.inner_text.chars.to_s)
+      response.search("//pnx:display/pnx:creator", PNX_NS).each do |creator|
+        @authors.push(creator.inner_text)
       end
     end
  
@@ -119,30 +121,27 @@ module Exlibris::Primo
     # Process URLs based on links/linktorsrc
     # Process TOCs based on links/linktotoc
     def process_search_results
-      @count = (response.at("//DOCSET").nil?) ? 
-        (response.at("//sear:DOCSET")["TOTALHITS"].nil?) ? 0 : 
-          response.at("//sear:DOCSET")["TOTALHITS"] : 
-            response.at("//DOCSET")["TOTALHITS"] unless response.nil? or @count
+      @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("//record") do |record|
+      response.search("//pnx:record", PNX_NS).each do |record|
         # Default genre to article if necessary
-        record_genre = (record.at("addata/genre").nil?) ? "article" : record.at("addata/genre").inner_text
+        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.at("control/recordid").inner_text
-        display_type = record.at("display/type").inner_text
-        original_source_id = record.at("control/originalsourceid").inner_text unless record.at("control/originalsourceid").nil?
-        original_source_ids = process_control_hash(record, "control/originalsourceid")
-        source_id = record.at("control/sourceid").inner_text
-        source_ids = process_control_hash(record, "control/sourceid")
-        source_record_id = record.at("control/sourcerecordid").inner_text
+        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, "control/sourcerecordid")
-        record.search("display/availlibrary") do |availlibrary|
+        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?
@@ -158,14 +157,15 @@ module Exlibris::Primo
             :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 => 
-              (reliable_match?(:title => record.at("display/title").inner_text, :author => record.at("display/creator").inner_text)) ? 
-                ServiceResponse::MatchExact : ServiceResponse::MatchUnsure 
+              (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.search("links/linktorsrc") do |linktorsrc|
+        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, 
@@ -176,7 +176,7 @@ module Exlibris::Primo
           @rsrcs.push(rsrc) unless (rsrc.nil? or rsrc.url.nil?)
         end
         # Process tocs
-        record.search("links/linktotoc") do |linktotoc|
+        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, 
@@ -185,12 +185,22 @@ module Exlibris::Primo
           }) 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)
+    def process_control_hash(record, xpath, ns)
       h = {}
-      record.search(xpath) do |e|
+      record.xpath(xpath, ns).each do |e|
         str = e.inner_text unless e.nil?
         a = str.split(/\$(?=\$)/) unless str.nil?
         v = nil
@@ -263,6 +273,17 @@ module Exlibris::Primo
       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