umlaut 3.0.0alpha1

data/lib/service_adaptors/sfx_backchannel_record.rb

@@ -0,0 +1,69 @@
+# This is a link_out_filter service, it msut be set up in your services.yml
+# with task: link_out_filter
+#
+# no parameters. 
+#
+## Send an sfx 'pass through' URL _in the background_. Send the user to the
+# target resource directly, but also send a back-channel hit to SFX
+# so SFX will record it for statistical purposes. The reason we
+# do it like this is sometimes the 'pass through' url doesn't work! Better
+# to just lose the statistic than to mess up the user.
+# 
+# We also do it all in a background thread, to avoid slowing down the user
+# with this step if SFX is being slow. 
+require 'uri'
+require 'net/http'
+
+class SfxBackchannelRecord < Service
+
+   def initialize(config)
+     @display_name = "SFX Statistics"
+     super(config)
+     @timeout ||= 5
+   end
+   
+  # This is meant to be called as task:link_out_filter, it doesn't have an
+  # implementation for handle, it implements link_out_filter() instead. 
+  def handle(request)
+     raise "Not implemented."
+  end
+
+  # Hook method called by Umlaut. 
+  # We always return nil because we aren't interested in modifying the url,
+  # just using the callback to record the click with SFX. 
+  def link_out_filter(orig_url, service_response, other_args = {})
+    # Only work on responses that came from SFX.
+    unless (service_response.service.class.to_s == "Sfx")
+       return nil
+    end
+    make_backchannel_request( service_response )
+    
+    
+    return nil
+  end
+
+  # Does everything in a background thread to avoid slowing down the user. 
+  def make_backchannel_request(service_response)
+
+    Thread.new do
+      begin
+        direct_sfx_url = Sfx.pass_through_url(service_response.data_values)
+        # now we call that url through a back channel just to record it
+        # with SFX.
+        
+        parsed_uri = URI.parse(direct_sfx_url )
+        sfx_response = Net::HTTP.get_response( parsed_uri  )
+        
+        #raise if not 200 OK response
+        unless ( sfx_response.kind_of?(Net::HTTPSuccess) ||
+                 sfx_response.kind_of?(Net::HTTPRedirection) )
+               # raise
+               sfx_response.value
+        end                
+      rescue Exception => e
+        Rails.logger.error("Could not record sfx backchannel click for service_response id #{service_response.id} ; sfx backchannel url attempted: #{direct_sfx_url} ; problem: #{e}")
+        Rails.logger.error( e.backtrace.join("\n"))
+      end
+    end
+  end
+end

data/lib/service_adaptors/txt_holding_export.rb

@@ -0,0 +1,32 @@
+# Since this relies on finding holdings that exist, you need to run it in
+# a service wave AFTER anything that might generate holdings. 
+class TxtHoldingExport < AjaxExport
+
+  def initialize(config)
+    @display_text = "Send to phone"
+    @form_controller = "export_email"
+    @form_action = "txt"
+    # providers is a hash of:
+    # user-presentable-string => hostname for email to txt service. 
+    @providers = {
+     "Cingular/AT&T" => "cingularme.com",
+     "Nextel" => "messaging.nextel.com",     
+     "Sprint" => "messaging.sprintpcs.com",
+     "T-Mobile"=> "tmomail.net",
+     "Verizon"=> "vtext.com",
+     "Virgin"=> "vmobl.com"
+    }
+    super(config)
+  end
+
+  def handle(request)
+    
+    holdings = request.get_service_type('holding', { :refresh => true })
+    unless holdings.nil? or holdings.empty?
+      super(request)
+    else
+      return request.dispatched(self, true)
+    end
+  end
+  
+end

data/lib/service_adaptors/ulrichs_cover.rb

@@ -0,0 +1,57 @@
+# Ulrich's provides journal cover images that are _publically_ available, at
+# predictable urls based on issn. Not sure if this is intentional. But as
+# an ulrich's subscriber, I feel fine using it. If my insitution was not
+# an ulrich's subscriber, I probably wouldn't use this service. 
+class UlrichsCover < Service
+  require 'open-uri'
+  
+  def service_types_generated
+    return [ServiceTypeValue[:cover_image]]
+  end
+
+  def initialize(config)
+    @base_url = "http://images.serialssolutions.com/ulrichs/"
+    
+    super(config)
+  end
+  
+  def handle(request)
+    issn = request.referent.issn
+
+    # We need an ISSN
+    return request.dispatched(self, true) unless issn 
+
+    # No hyphens please
+    issn = issn.gsub(/[^0-9X]/, '')
+    
+    check_url = @base_url + issn + '.gif'
+
+    # does it exist?
+    if ( url_resolves(check_url)   )
+       request.add_service_response(:service => self,
+                                    :service_type_value => :cover_image ,
+                                    :url => check_url, 
+                                    :size => "medium" )
+    end   
+    
+    return request.dispatched(self, true)
+  end
+
+  def url_resolves(url)
+    uri_obj = URI.parse(url)
+    response = Net::HTTP.start(uri_obj.host, uri_obj.port) {|http|
+      http.head(uri_obj.request_uri)
+    }
+    if (response.kind_of?( Net::HTTPSuccess  ))
+      return true
+    elsif ( response.kind_of?(Net::HTTPNotFound))
+      return false
+    else
+      # unexpected condition, raise
+      response.value
+    end
+
+    
+  end
+  
+end

data/lib/service_adaptors/ulrichs_link.rb

@@ -0,0 +1,47 @@
+# A very simple service that simply generates a "highlighted_link" to
+# the Ulrich's periodical directory, if an ISSN is present.
+# Does not actually look up first to make sure there are results, it's
+# a blind link.
+# config params:
+# link_name: Name to put on the link. Defaults to "Periodical Information from Ulrich's Directory". 
+class UlrichsLink < Service
+
+  def initialize(config)
+    # Original one, which just apes the UlrichsWeb html interface, and gives
+    # you a search results screen even with only one hit. 
+    #@base_url = "http://www.ulrichsweb.com/ulrichsweb/Search/doAdvancedSearch.asp?QuickCriteria=ISSN&Action=Search&collection=SERIAL&QueryMode=Simple&ResultTemplate=quickSearchResults.hts&SortOrder=Asc&SortField=f_display_title&ScoreThreshold=0&ResultCount=25&SrchFrm=Home&setting_saving=on&QuickCriteriaText="
+    super(config)
+    # better one, which Yvette at Ulrich's showed me for SFX, which seems to work better.
+    @vendor ||= "Umlaut"
+    @base_url ||= "https://ulrichsweb.serialssolutions.com/api/openurl?issn="
+    # Old one
+    #@base_url ||= "http://www.ulrichsweb.com/ulrichsweb/Search/call_fullCitation.asp?/vendor_redirect.asp?oVendor=#{@vendor}&oIssn="
+    @link_name = "Periodical information"
+  end
+  
+  def service_types_generated
+    return [ServiceTypeValue[:highlighted_link]]
+  end
+
+  def handle(request)
+    unless (request.referent.issn.blank?)
+      display_text = @link_name
+
+      url = url_for_issn( request.referent.issn )
+      
+      request.add_service_response(
+        :service=>self, 
+        :url=>url, 
+        :display_text=>display_text,
+        :service_type_value => :highlighted_link)
+    end
+
+    return request.dispatched(self, true)
+  end
+
+  def url_for_issn(issn)
+    # with or without hyphen should work fine. 
+    return @base_url + issn
+  end
+  
+end

data/lib/service_adaptors/worldcat.rb

@@ -0,0 +1,116 @@
+# Link to worldcat.org that relies on screen scraping to see if it's gotten
+# a hit. 
+#
+# Warning, worldcat can be awfully slow to respond. 
+# optional search_zip_code param.
+# Optional base_url param, but I don't know why you'd want to change it.
+# display_text
+require 'uri'
+require 'net/http'
+class Worldcat < Service
+  include MetadataHelper
+  include UmlautHttp
+  
+  def initialize(config)
+    # defaults
+    @suppress_precheck = false # it seems unneccesary to pre-check worldcat, it's mostly ALWAYS a positive hit. And pre-checking against worldcat is running into Worldcat's rate limiting defenses. If neccesary, you can turn this off. Really, we should be using the Worldcat API anyway. 
+    @base_url = 'http://www.worldcat.org/'
+    @display_text = 'Find in other libraries'
+    @display_name = 'OCLC WorldCat.org'
+    
+    @credits = {
+      "OCLC WorldCat.org" => "http://www.worldcat.org/"
+    }
+    
+    super(config)
+  end
+
+  def service_types_generated
+    return [ServiceTypeValue['highlighted_link']]
+  end
+  
+  def handle(request)
+    isbn = get_identifier(:urn, "isbn", request.referent)
+    issn = get_identifier(:urn, "issn", request.referent)
+    oclcnum = get_identifier(:info, "oclcnum", request.referent)
+    
+    
+    isxn_key = nil
+    isxn_value = nil
+    if (! oclcnum.blank?)
+      isxn_key = 'oclc'
+      isxn_value = oclcnum    
+    elsif (! issn.blank?)
+      isxn_key = 'issn'
+      #isxn_value = ref_metadata['issn'] + '+dt:ser'
+      isxn_value = issn
+    elsif (! isbn.blank?)
+      isxn_key = 'isbn'
+      isxn_value = isbn
+    else
+      # We have no useful identifiers
+      return request.dispatched(self, true)
+    end
+
+    # Do some cleanup of the value. Sometimes spaces or other
+    # weird chars get in there, why not strip out everything that
+    # isn't a number or X?
+    isxn_value = isxn_value.gsub( /[^\dX]/, '')
+    # and URL escape just to be safe, although really shouldn't be neccesary
+    isxn_value = URI.escape( isxn_value )
+    
+    # We do a pre-emptive lookup to worldcat to try and see if worldcat
+    # has a hit or not, before adding the link.
+    isxn_key = URI.escape( isxn_key )
+    uri_str = @base_url+isxn_key+'/'+isxn_value
+    uri_str +=  "&loc=#{URI.escape(@search_zip_code.to_s)}" if @search_zip_code
+
+    
+    begin
+      worldcat_uri = URI.parse(uri_str)
+    rescue Exception => e
+      Rails.logger.error("Bad worldcat uri string constructed?")
+      Rails.logger.error(e)
+      return request.dispatched(self, DispatchedService::FailedFatal)
+    end
+
+    unless ( @suppress_precheck )
+    
+      http = Net::HTTP.new worldcat_uri.host
+      http.open_timeout = 7
+      http.read_timeout = 7
+  
+      
+      begin
+        # Fake being a proxy to send info on actual end-user client to worldcat,
+        # to lessen chance of worldcat traffic limiters. 
+        headers = proxy_like_headers( request, worldcat_uri.host )
+        wc_response = http.get(worldcat_uri.path, headers)
+      rescue  Timeout::Error => exception
+        return request.dispatched(self, DispatchedService::FailedTemporary, exception)
+      end
+  
+      # Bad response code?
+      unless wc_response.code == "200"
+        # Could be temporary, could be fatal. Let's say temporary. 
+        return request.dispatched(self, DispatchedService::FailedTemporary, Exception.new("oclc returned error http status code: #{wc_response.code}"))
+      end
+  
+      # Sadly, worldcat returns a 200 even if there are no matches.
+      # We need to screen-scrape to discover if there are matches.
+      if (wc_response.body =~ /The page you tried was not found\./)
+        # Not found in worldcat, we won't add a link.
+        return request.dispatched(self, true)
+      end
+    end
+    
+    request.add_service_response(
+      :service=>self, 
+      :url=>worldcat_uri.to_s,
+      :display_text=>@display_text, 
+      :service_type_value => :highlighted_link
+      )
+    
+    return request.dispatched(self, true)
+  end
+end

data/lib/service_adaptors/worldcat_identities.rb

@@ -0,0 +1,591 @@
+# Service that uses available metadata to try to find an exact match to a 
+# WorldCat Identity. 
+#
+# Requires sufficient author information and/or an oclcnumber to have enough
+# info to try and find a match. Best to run AFTER services that may enhance
+# metadata with this info (such as Amazon). 
+# 
+# See: http://outgoing.typepad.com/outgoing/2008/06/linking-to-worl.html
+# 
+# Creates a highlighted_link
+# Even though the WorldCat Identities API is built on top of SRU we use 
+# open-uri to simply fetch the "html" page (which is really XML with a stylesheet)
+# and look at the XML directly. 
+
+#. SRU was too slow and was timing out the background service.
+# (because SRU parses the response with REXML? we don't want to have anything
+#  to do with REXML! Even still retrieving the large XML file and traversing
+#  it with Hpricot (what we used to use) was still rather slow. The suggestion is to enable few
+#  note_types and then constrain the number shown. The defaults are hopefully 
+#  sane in this regard. note_types can be set to false to turn them off.
+#  
+#  Also can create an optional link to Wikipedia.
+#  
+#  There's probably a lot more we could pull out of these identities pages if
+#  we wanted to. If more of these are used they might warrant their own 
+#  service type and part of the page for better layout.
+
+class WorldcatIdentities < Service
+  require 'open-uri' # SRU is too slow even though we use an SRU-like link
+  require 'nokogiri'
+  include MetadataHelper
+  
+  attr_reader :url, :note_types, :display_name, :wikipedia_link, :openurl_base,
+    :require_identifier,
+    # below starts the note_types which can be restrained
+    :num_of_roles, :num_of_subject_headings, :num_of_works, :num_of_genres
+  
+  def service_types_generated
+    return [ ServiceTypeValue[:highlighted_link] ]
+  end
+  
+  def initialize(config)
+    @url = 'http://worldcat.org/identities/search/'
+    @note_types = ["combined_counts"]
+    @display_name = "WorldCat Identities"
+    @require_identifier = false
+    # any plural note_types can be restrained 
+    @num_of_roles = 5
+    @num_of_works = 1
+    @num_of_genres = 5
+    @wikipedia_link = true
+    @openurl_widely_held = true
+    @worldcat_widely_held = false
+    @openurl_base  = '/resolve'
+    
+    @credits = {
+      "WorldCat Identities" => "http://www.worldcat.org/identities/"
+    }
+    
+    super(config)
+  end
+  
+  def handle(request)
+    index, query = define_query(request.referent)
+    
+    unless query.blank?
+      do_query(request, index, query)
+    end
+    return request.dispatched(self, true)    
+  end
+  
+  def define_query(rft)
+    oclcnum = get_identifier(:info, "oclcnum", rft)
+    metadata = rft.metadata
+    
+    # Do we have enough info to do a query with sufficient precision?
+    # We are choosing better recall in exchange for lower precision. 
+    # We'll search with oclcnum if we have it, but not require it, we'll search
+    # fuzzily on various parts of the name if neccesary.
+    if ( oclcnum.blank? && ( metadata['aulast'].blank? || metadata['aufirst'].blank? ) && metadata['au'].blank? && metadata['aucorp'].blank?  ) or (oclcnum.blank? && @require_identifier) 
+      Rails.logger.debug("Worldcat Identities Service Adaptor: Skipped: Insufficient metadata for lookup")      
+      return nil
+    end
+    
+    
+    # instead of searching across all indexes we target the one we want
+    name_operator = "%3D"
+    if ((! metadata['aulast'].blank?) && oclcnum)
+      # Just last name is enough, we have an oclcnum.       
+      index = 'PersonalIdentities'
+      name_part = 'FamilyName'
+      name = clean_name(metadata['aulast'])
+    elsif (! metadata['au'].blank? )
+      # Next choice, undivided author string
+      index = "PersonalIdentities"
+      name_part = 'Name'
+      name = clean_name(metadata['au'])
+      name_operator = "all"
+    elsif (not metadata['aulast'].blank? and not metadata['aufirst'].blank?)
+      # combine them.
+      index = "PersonalIdentities"
+      name_part = 'Name'
+      name = clean_name(metadata['aufirst'] + ' ' + metadata['aulast'])
+      name_operator = "all"
+    elsif metadata['aucorp']
+      # corp name
+      index = 'CorporateIdentities'
+      name_part = 'Name'
+      name = clean_name(metadata['aucorp'])
+    else
+      # oclcnum but no author information at all! Might still work...
+      index = "Identities"
+    end
+
+    query_conditions = []
+    query_conditions << "local.#{name_part}+#{name_operator}+%22#{name}%22" if name    
+    query_conditions << "local.OCLCNumber+%3D+%22#{CGI.escape(oclcnum)}%22" unless oclcnum.blank?
+
+    query = query_conditions.join("+and+")
+    
+    # Sort keys is important when we don't have an oclcnumber, and doesn't hurt
+    # when we do. 
+    query += "&sortKeys=holdingscount"
+    return index, query 
+  end
+  
+  # We might have to remove certain characters, but for now we just CGI.escape 
+  # it and remove any periods
+  def clean_name(name)
+    CGI.escape(name).gsub('.', '')
+  end
+  
+  def do_query(request, index, query)
+    # since we're only doing exact matching with last name and OCLCnum
+    # we only request 1 record to hopefully speed things up.
+    link = @url + index + '?query=' +query + "&maximumRecords=1"
+
+    result = open(link).read
+    xml = Nokogiri::XML(result)
+    
+    # Identities namespaces are all over the place, it's too hard
+    # to interrogate with namespaces, ask nokogiri to remove them all
+    # instead. 
+    xml.remove_namespaces!
+    
+    
+    return nil if xml.at("numberOfRecords").inner_text == '0'
+    create_link(request, xml)
+    create_wikipedia_link(request, xml) if @wikipedia_link
+    create_openurl_widely_held(request, xml) if @openurl_widely_held
+    create_worldcat_widely_held(request, xml) if @worldcat_widely_held
+  end
+  
+  def create_link(request, xml)
+    display_name = "About " + extract_display_name(xml)
+    extracted_notes = extract_notes(xml) if @note_types
+    url = extract_url(xml)
+    create_service_response(request, display_name, url, extracted_notes )
+  end
+    
+  def extract_notes(xml)    
+    note_pieces = []    
+    # a tiny bit of metaprogramming to make it easy to add methods and config
+    # for note_types
+    @note_types.each do |nt|
+      method = ("extract_" + nt).to_sym  
+      answer = self.send(method, xml)
+      note_pieces << answer unless answer.nil?
+    end
+   return nil if note_pieces.blank? 
+   return note_pieces.join(' | ')
+  end
+  
+  def extract_display_name(doc)
+    name = []    
+    rawname = doc.at("nameInfo/rawName")
+    return nil unless rawname
+    rawname.children.each do |name_part|
+      name << name_part.inner_text      
+    end
+    return nil if name.blank?
+    return name.join(' ')
+  end
+    
+  def extract_subject_headings(doc)
+    subject_headings = []
+    (doc.search("biogSH")).each_with_index do |sh, i|
+      subject_headings << sh.inner_text
+      break if @num_of_subject_headings == i + 1
+    end
+    return nil if subject_headings.blank?
+    "subject headings: " + subject_headings.join('; ')
+  end
+  
+  def extract_roles(doc)
+    codes = []
+    (doc.search("relators/relator")).each_with_index do |relate, i|
+      codes << relate.attributes['code']
+      break if @num_of_roles == i + 1
+    end
+    return nil if codes.blank?
+    roles = codes.map{|code| RELATOR_CODES[code] }
+    "roles: " + roles.join(', ')
+  end
+  
+  # FIXME a lot more could be done with "by citations". identities gives summaries
+  # of the most popular works as well as other descriptive information like
+  # subject headings. This might be able to be used for enhancing metadata.
+  def extract_works(doc)
+    works = []
+    doc.search("by/citation/title").each_with_index do |t, i|
+      works << t.inner_text
+      break if @num_of_works == i + 1
+    end
+    return nil if works.blank?
+    "most widely held #{works.length == 1 ? "work" : "works"}: " + works.join("; ")
+  end
+  
+  def extract_genres(doc)
+    genres = []
+    doc.search("genres/genre").each_with_index do |g, i|
+      genres << g.inner_text
+      break if @num_of_genres == i + 1
+    end
+    return nil if genres.blank?
+    "genres: " + genres.join(', ')
+  end
+  
+  def extract_combined_counts(doc)
+    work_count = extract_work_count(doc)
+    publications_count = extract_publications_count(doc)
+    holdings_count = extract_holdings_count(doc)
+    work_count << " in " << publications_count << " with " <<
+      holdings_count
+  end
+  
+  def extract_work_count(doc)
+    work_count = doc.at("workCount").inner_text
+    return insert_commas(work_count)  << " works"
+  end
+  
+  def extract_holdings_count(doc)
+    total_holdings = doc.at("totalHoldings").inner_text
+    return insert_commas(total_holdings) << " total holdings in WorldCat"
+  end
+  
+  def extract_publications_count(doc)
+    return insert_commas( doc.at("recordCount").inner_text ) << " publications"
+  end
+  
+  def extract_url(doc)
+    pnkey = doc.at("pnkey").inner_text
+    return 'http://worldcat.org/identities/' << pnkey
+  end
+  
+  def insert_commas(n)
+    n.reverse.scan(/(?:\d*\.)?\d{1,3}-?/).join(',').reverse
+  end
+  
+  def create_service_response(request, display_name, url, extracted_notes)
+    request.add_service_response( 
+        :service=>self,    
+        :url=>url,
+        :display_text=>display_name,
+        :notes => extracted_notes,
+        :service_type_value => :highlighted_link)
+  end
+  
+  def create_wikipedia_link(request, xml)
+    name_element =  xml.at("wikiLink")
+    return nil unless name_element
+    name = name_element.inner_text
+    # This is the base link that worldcat identities uses so we use the same
+    link = "http://en.wikipedia.org/wiki/Special:Search?search=" << name
+    request.add_service_response( 
+        :service=>self,    
+        :url=>link,
+        :display_text=> "About " + name.titlecase,
+        :notes => '', 
+        :source => 'Wikipedia',
+        :service_type_value => :highlighted_link)
+  end
+  
+  def create_openurl_widely_held(request, xml)
+    widely_held = get_widely_held_info(xml)
+    # try to remove circular links
+    return nil if circular_link?(request, widely_held)
+    
+    openurl = create_openurl(request, widely_held) 
+    
+    request.add_service_response( 
+        :service=>self,    
+        :url=>openurl,
+        :display_text=> widely_held['title'],
+        :notes => "This author's most widely held work.",
+        :service_type_value => :highlighted_link) 
+  end
+  
+  def circular_link?(request, citation_info)
+    rft = request.referent
+    request_oclcnum = get_identifier(:info, "oclcnum", rft)
+    request_title = get_search_title(rft)
+    return true if citation_info['oclcnum'] == request_oclcnum
+    #further cleaning might be necessary for titles to be good matches
+    return true if citation_info['title'].strip == request_title.strip
+  end
+  
+  #createsa  minimal openurl to make a new request to umlaut
+  def create_openurl(request, wh)
+    metadata = request.referent.metadata
+    
+    co = OpenURL::ContextObject.new
+    cor = co.referent
+    cor.set_format(wh['record_type'])
+    cor.add_identifier("info:oclcnum/#{wh['oclcnum']}")
+    cor.set_metadata('aulast', metadata['aulast'] ) if metadata['aulast']
+    cor.set_metadata('aufirst', metadata['aufirst']) if metadata['aufirst']
+    cor.set_metadata('aucorp', metadata['aucorp']) if metadata['aucorp']
+    cor.set_metadata('title', wh['title'])
+    link = @openurl_base + '?' + co.kev
+    return link
+  end
+  
+  # We just link to worldcat using the oclc number provided
+  # FIXME this might need special partial if we incorporate a cover image
+  def create_worldcat_widely_held(request, xml)
+    
+    # try to prevent circular links
+    top_holding_info = get_widely_held_info(xml) 
+    return nil if circular_link?(request, top_holding_info)    
+    
+    # http://www.worldcat.org/links/
+    most = top_holding_info['most']
+    title = top_holding_info['title']
+    oclcnum = top_holding_info['oclcnum']
+    
+    link = 'http://www.worldcat.org/oclc/' << oclcnum
+    cover_image_link = extract_cover_image_link(request, most)    
+    notes = "this author's most widely held work in WorldCat"
+     if  cover_image_link 
+      display_text = '<img src="' << cover_image_link << '" style="width:75px;"/>' 
+      notes = title << ' is ' << notes
+    else
+      display_text = title
+    end
+    
+    request.add_service_response( 
+        :service=>self,    
+        :url=>link,
+        :display_text=> display_text,
+        :notes => notes,
+        :service_type_value => :highlighted_link) 
+  end
+  
+  def get_widely_held_info(xml)
+    h = {}
+    h['most'] = most = xml.at("by/citation")
+    h['oclcnum'] = clean_oclcnum(most.at("oclcnum").inner_text)
+    h['title'] = most.at("title").inner_text
+    h['record_type'] = most.at('recordType').inner_text
+    h
+  end
+  
+  def extract_cover_image_link(request, citation)
+    cover = citation.at("cover")
+    return nil unless cover
+    # we try not to show a cover if we already probably have the same cover 
+    # showing.
+    oclc = clean_oclcnum( cover.attributes['oclc'] )
+    metadata = request.referent.metadata
+    if metadata['oclcnum'] and metadata['oclcnum'] =~ oclc
+      return nil
+    end 
+    cover_number = cover.inner_text
+    if metadata['isbn'] and metadata['isbn'] == cover_number
+      return nil
+    end
+    
+    if cover.attributes["type"] == 'isbn'
+      link = "http://www.worldcat.org/wcpa/servlet/DCARead?standardNoType=1&standardNo="
+      return link << cover_number
+    end
+    return nil
+  end
+  
+  def clean_oclcnum(num)
+    # got the follow from referent.rb ~152 and added ocn
+    if num =~ /(ocn0*|ocm0*|\(OCoLC\)|ocl70*|0+)(.*)$/
+      num = $2
+    end
+    return num
+  end
+  
+  # relator codes are from http://worldcat.org/identities/relators.xml which was
+  # referenced from http://worldcat.org/identities/Identities.xsl
+  RELATOR_CODES = {
+    "act" => "Actor",
+    "adp" => "Adapter",
+    "aft" => "Author of afterword, colophon, etc.",
+    "anm" => "Animator ",
+    "ann" => "Annotator",
+    "ant" => "Bibliographic antecedent",
+    "app" => "Applicant",
+    "aqt" => "Author in quotations or text abstracts",
+    "arc" => "Architect",
+    "arr" => "Arranger",
+    "art" => "Artist",
+    "asg" => "Assignee",
+    "asn" => "Associated name",
+    "att" => "Attributed name",
+    "auc" => "Auctioneer",
+    "aud" => "Author of dialog",
+    "aui" => "Author of introduction",
+    "aus" => "Author of screenplay",
+    "aut" => "Author",
+    "bdd" => "Binding designer",
+    "bjd" => "Bookjacket designer",
+    "bkd" => "Book designer",
+    "bkp" => "Book producer",
+    "bnd" => "Binder",
+    "bpd" => "Bookplate designer",
+    "bsl" => "Bookseller",
+    "ccp" => "Conceptor",
+    "chr" => "Choreographer",
+    "clb" => "Collaborator",
+    "cli" => "Client",
+    "cll" => "Calligrapher",
+    "clt" => "Collotyper",
+    "cmm" => "Commentator",
+    "cmp" => "Composer",
+    "cmt" => "Compositor",
+    "cng" => "Cinematographer ",
+    "cnd" => "Conductor",
+    "cns" => "Censor",
+    "coe" => "Contestant -appellee",
+    "col" => "Collector",
+    "com" => "Compiler",
+    "cos" => "Contestant",
+    "cot" => "Contestant -appellant",
+    "cov" => "Cover designer",
+    "cpc" => "Copyright claimant",
+    "cpe" => "Complainant-appellee",
+    "cph" => "Copyright holder",
+    "cpl" => "Complainant",
+    "cpt" => "Complainant-appellant",
+    "cre" => "Creator",
+    "crp" => "Correspondent",
+    "crr" => "Corrector",
+    "csl" => "Consultant",
+    "csp" => "Consultant to a project",
+    "cst" => "Costume designer",
+    "ctb" => "Contributor",
+    "cte" => "Contestee-appellee",
+    "ctg" => "Cartographer",
+    "ctr" => "Contractor",
+    "cts" => "Contestee",
+    "ctt" => "Contestee-appellant",
+    "cur" => "Curator",
+    "cwt" => "Commentator for written text",
+    "dfd" => "Defendant",
+    "dfe" => "Defendant-appellee",
+    "dft" => "Defendant-appellant",
+    "dgg" => "Degree grantor",
+    "dis" => "Dissertant",
+    "dln" => "Delineator",
+    "dnc" => "Dancer",
+    "dnr" => "Donor",
+    "dpc" => "Depicted",
+    "dpt" => "Depositor",
+    "drm" => "Draftsman",
+    "drt" => "Director",
+    "dsr" => "Designer",
+    "dst" => "Distributor",
+    "dte" => "Dedicatee",
+    "dto" => "Dedicator",
+    "dub" => "Dubious author",
+    "edt" => "Editor",
+    "egr" => "Engraver",
+    "elt" => "Electrotyper",
+    "eng" => "Engineer",
+    "etr" => "Etcher",
+    "exp" => "Expert",
+    "fac" => "Facsimilist",
+    "flm" => "Film editor",
+    "fmo" => "Former owner",
+    "fpy" => "First party",
+    "fnd" => "Funder",
+    "frg" => "Forger",
+    "grt" => "Graphic technician",
+    "hnr" => "Honoree",
+    "hst" => "Host",
+    "ill" => "Illustrator",
+    "ilu" => "Illuminator",
+    "ins" => "Inscriber",
+    "inv" => "Inventor",
+    "itr" => "Instrumentalist",
+    "ive" => "Interviewee",
+    "ivr" => "Interviewer",
+    "lbt" => "Librettist",
+    "lee" => "Libelee-appellee",
+    "lel" => "Libelee",
+    "len" => "Lender",
+    "let" => "Libelee-appellant",
+    "lgd" => "Lighting designer ",
+    "lie" => "Libelant-appellee",
+    "lil" => "Libelant",
+    "lit" => "Libelant-appellant",
+    "lsa" => "Landscape architect",
+    "lse" => "Licensee",
+    "lso" => "Licensor",
+    "ltg" => "Lithographer",
+    "lyr" => "Lyricist",
+    "mfr" => "Manufacturer ",
+    "mdc" => "Metadata contact",
+    "mod" => "Moderator",
+    "mon" => "Monitor",
+    "mrk" => "Markup editor",
+    "mte" => "Metal-engraver",
+    "mus" => "Musician",
+    "nrt" => "Narrator",
+    "opn" => "Opponent",
+    "org" => "Originator",
+    "orm" => "Organizer of meeting",
+    "oth" => "Other",
+    "own" => "Owner",
+    "pat" => "Patron",
+    "pbd" => "Publishing director",
+    "pbl" => "Publisher",
+    "pfr" => "Proofreader",
+    "pht" => "Photographer",
+    "plt" => "Platemaker",
+    "pop" => "Printer of plates",
+    "ppm" => "Papermaker",
+    "ppt" => "Puppeteer ",
+    "prc" => "Process contact",
+    "prd" => "Production personnel",
+    "prf" => "Performer",
+    "prg" => "Programmer",
+    "prm" => "Printmaker",
+    "pro" => "Producer",
+    "prt" => "Printer",
+    "pta" => "Patent applicant",
+    "pte" => "Plaintiff -appellee",
+    "ptf" => "Plaintiff",
+    "pth" => "Patent holder",
+    "ptt" => "Plaintiff-appellant",
+    "rbr" => "Rubricator",
+    "rce" => "Recording engineer",
+    "rcp" => "Recipient",
+    "red" => "Redactor",
+    "ren" => "Renderer",
+    "res" => "Researcher",
+    "rev" => "Reviewer",
+    "rpt" => "Reporter",
+    "rpy" => "Responsible party",
+    "rse" => "Respondent -appellee",
+    "rsg" => "Restager ",
+    "rsp" => "Respondent",
+    "rst" => "Respondent-appellant",
+    "rth" => "Research team head",
+    "rtm" => "Research team member",
+    "sad" => "Scientific advisor",
+    "sce" => "Scenarist",
+    "scl" => "Sculptor",
+    "scr" => "Scribe",
+    "sec" => "Secretary",
+    "sgn" => "Signer",
+    "sng" => "Singer",
+    "spk" => "Speaker",
+    "spn" => "Sponsor",
+    "spy" => "Second party",
+    "srv" => "Surveyor",
+    "std" => "Set designer ",
+    "stl" => "Storyteller",
+    "stn" => "Standards body",
+    "str" => "Stereotyper",
+    "tch" => "Teacher ",
+    "ths" => "Thesis advisor",
+    "trc" => "Transcriber",
+    "trl" => "Translator",
+    "tyd" => "Type designer",
+    "tyg" => "Typographer",
+    "vdg" => "Videographer ",
+    "voc" => "Vocalist",
+    "wam" => "Writer of accompanying material",
+    "wdc" => "Woodcutter",
+    "wde" => "Wood -engraver",
+    "wit" => "Witness"    
+  }
+  
+end