umlaut 3.0.0alpha1

data/lib/service_adaptors/gpo.rb

@@ -0,0 +1,124 @@
+# Still in progress. Uses illegal info:sudoc and info:gpo to get a
+# a sudoc or a GPO Item Number for a given referent, and finds online
+# availability, and/or links to GPO lookup for local depository with the
+# item.
+class Gpo < Service
+  include MetadataHelper
+  require 'nokogiri'
+  require 'open-uri' 
+  
+  
+  def initialize(config)
+    @display_name = "U.S. Government Printing Office"
+    @gpo_item_find = true
+    @sudoc_url_lookup = true
+    super(config)
+  end
+
+  def service_types_generated
+    a = []
+    a.push(ServiceTypeValue["highlighted_link"]) if @gpo_item_find
+    a.push(ServiceTypeValue["fulltext"]) if @sudoc_url_lookup
+    return a
+  end
+
+  def handle(request)
+    
+    if ( @gpo_item_find )
+      items = analyze_gpo_items(  get_gpo_item_nums(request.referent)  )
+      
+      items.each do |item, formats|
+         # Generate URL to GPO Item Number lookup to finding
+         # it in a repository near you. 
+  
+         request.add_service_response(:service => self, 
+             :display_text => "Find in a Federal Depository Library",
+             :url => gpo_item_lookup_url(item),
+             :notes => "In " + formats.join(" or "),
+             :service_type_value => "highlighted_link"
+             )
+      end
+    end
+    sudoc = get_sudoc(request.referent)
+    
+    if ( sudoc && @sudoc_url_lookup )
+      add_links_from_sudoc(request, sudoc)
+    end
+    
+
+    request.dispatched(self, true)
+    
+  end
+
+  # Takes an array of string of GPO Items with formats in parens, groups
+  # them by individual Item Number, identified by formats. 
+  def analyze_gpo_items(items)
+    item_hash = {}
+
+    items.each do |i|      
+
+      bare_item = i
+      format_str = 'paper'
+
+      # seperate the format marker from the base item number, if present.
+      # if it's not present, means paper. 
+      if ( i =~ /^(.*)\(([^\)]+)\)\s*$/  )      
+        bare_item = $1.strip
+        format_str = $2.strip
+        format_str = "microform" if format_str == "MF"
+      end
+      
+      item_hash[bare_item] ||= []
+      
+      item_hash[bare_item].push( format_str )      
+    end
+    
+    return item_hash  
+  end
+
+  def gpo_item_lookup_url(item)
+    return "http://catalog.gpo.gov/fdlpdir/locate.jsp?ItemNumber=" + CGI.escape(item)
+  end
+
+  def add_links_from_sudoc(request, sudoc)
+    # Screen scrape the GPO catalog.
+    
+    response = open( gpo_sudoc_find_url(sudoc)  ).read
+
+    response_dom = Nokogiri::HTML(response)
+    
+    # Find each tr with class tr1, holding a td => The sixth td in there =>
+    # one or more 'a' tags in there. These are links to fulltext. 
+    links = response_dom.search('//tr[@class = "tr1"][td]/td[7]/a')
+
+    urls_seen = []
+    
+    links.each do |link|
+      # The href is an internally pointing ILS link. But the text inside
+      # the a is what we want, it's actually a URL, fortunately. . 
+
+      url = link.inner_text
+      unless urls_seen.include?(url)
+      
+        notes = nil
+        if (links.length > 1)        
+          notes = "via " + URI.parse(url).host
+        end
+  
+        request.add_service_response(:service => self, 
+         :display_text => @display_name,
+         :url => url,
+         :notes => notes,
+         :service_type_value => "fulltext"
+         )
+         urls_seen.push( url )
+      end         
+    end
+    
+  end
+
+  def gpo_sudoc_find_url(sudoc)
+    return "http://catalog.gpo.gov/F/?func=find-a&find_code=GVD&request=#{CGI.escape('"'+sudoc+'"')}&local_base=GPO01PUB"
+  end
+  
+end

data/lib/service_adaptors/hathi_trust.rb

@@ -0,0 +1,308 @@
+require 'open-uri'
+require 'multi_json'
+require 'cgi'
+
+# Service that searches HathiTrust from the University of Michigan
+#
+# Supports full text links, and search inside. 
+#
+# We link to HathiTrust using a direct babel.hathitrust.org URL instead
+# of the handle.net redirection, for two reasonsL
+# 1) Can't use the handle.net redirection for the "direct link to search
+#    results for user-entered query" feature. 
+# 2) Some may want to force a Shibboleth login on HT links. Can't do that
+#    with the handle.net redirection either. If you do want to do that,
+#    possibly in concert with an EZProxy mediated WAYFless login,
+#    set direct_link_base in your services.yml to:
+#    "https://babel.hathitrust.org/shcgi/"
+#
+# Many (but not all) HT books will also be in Google Books (and vice versa)
+# However, HT was more generous in deciding what books are public domain than GBS.
+# Therefore the main expected use case is to use with Google Books, with
+# HT being a lower priority, using preempted_by config.  
+#
+# Some may prefer HT search inside interface to Google, so search inside
+# is not suppressed with presence of google. You can turn off HT
+# search inside entirely if you like.
+#
+# For HT records representing one volume of several, a :excerpts type
+# response will be added if full text is avail for some. Or a :highlighted_link
+# if only search inside is available for some.
+# Or set config show_multi_volume=false to prevent this and ignore partial
+# volumes. 
+# 
+# Two possibilities are available for sdr rights "full" or "searchonly".
+# The third possibility is that sdr will be null.
+#
+# An ISBN with search-only: 0195101464
+class HathiTrust < Service  
+  include MetadataHelper
+  
+  attr_reader :url, :display_name, :note
+  
+  def service_types_generated    
+    types = [ ServiceTypeValue[:fulltext] ]
+    types.concat([ServiceTypeValue[:excerpts], ServiceTypeValue[:highlighted_link]]) if @show_multi_volume
+    types << ServiceTypeValue[:search_inside] if @show_search_inside
+    return types
+  end
+  
+  def initialize(config)
+    @api_url = 'http://catalog.hathitrust.org/api/volumes'
+    # Set to 'https://babel.hathitrust.org/shcgi/' to force
+    # Shibboleth login, possibly in concert with EZProxy providing
+    # WAYFLess login. 
+    @direct_link_base = 'http://babel.hathitrust.org/cgi/'
+    @display_name = 'HathiTrust'
+    @num_full_views = 1 # max num full view links to include
+    @note =  '' #'Fulltext books from the University of Michigan'
+    @show_search_inside = true
+    @show_multi_volume = true
+    
+    @credits = {
+      "HathiTrust" => "http://www.hathitrust.org"
+    }
+    
+    super(config)
+  end
+  
+  def handle(request)
+    params = get_parameters(request.referent)
+    return request.dispatched(self, true) if params.blank?
+    
+    ht_json = do_query(params)
+    return request.dispatched(self, true) if ht_json.nil?
+    
+    #extract the "items" list from the first result group from
+    #response.
+    first_group = ht_json.values.first    
+    items = first_group["items"]
+    
+    
+    
+    # Only add fulltext if we're not skipping due to GBS
+    if ( preempted_by(request, "fulltext"))
+      Rails.logger.debug("#{self.class}: Skipping due to pre-emption")
+    else
+      full_views_shown = create_fulltext_service_response(request, items)
+    end
+    
+    if @show_multi_volume
+      #possibly partial volumes
+      create_partial_volume_responses(request, ht_json)
+    end
+
+    
+
+    create_search_inside(request, items)
+        
+    return request.dispatched(self, true)
+  end
+  
+  # just a wrapper around get_bibkey_parameters
+  def get_parameters(rft)
+    # API supports oclcnum, isbn, or lccn, and can provide more than one of each. 
+    get_bibkey_parameters(rft) do |isbn, lccn, oclcnum|         
+      keys = Array.new
+                  
+      keys << "oclc:" + CGI.escape(oclcnum) unless oclcnum.blank?    
+      keys <<  "lccn:" + CGI.escape(lccn) unless lccn.blank?
+      # Only include ISBN if we have it and we do NOT have oclc or lccn,
+      # Bill Dueber's advice for best matching. HT api will only match
+      # if ALL the id's we supply match. 
+      keys << "isbn:" + CGI.escape(isbn) unless (isbn.blank? || keys.length > 0)
+
+      if keys.length > 0        
+        return keys.join(";")
+      else
+        return nil
+      end
+    end
+  end
+  
+  # method that takes a referent and a block for parameter creation
+  # The block receives isbn, lccn, oclcnum and is responsible for formatting
+  # the parameters for the particular service
+  # FIXME consider moving this into metadata_helper
+  def get_bibkey_parameters(rft)
+    isbn = get_identifier(:urn, "isbn", rft)
+    oclcnum = get_identifier(:info, "oclcnum", rft)
+    lccn = get_lccn(rft)
+        
+    yield(isbn, lccn, oclcnum)    
+  end
+  
+  # conducts query and parses the JSON
+  def do_query(params)    
+    link = @api_url + "/brief/json/" + params
+    return MultiJson.decode( open(link).read )
+  end
+  
+    
+  def create_fulltext_service_response(request, items)
+    return nil if items.empty?
+    
+    display_name = @display_name
+    count = 0
+    
+    items.each do |item|         
+      next if is_serial_part?(item)
+      
+      
+      next unless full_view?(item)
+      
+      request.add_service_response(
+          :service=>self, 
+          :display_text=>display_name,           
+          :url=> direct_url_to(item), 
+          :notes=> note_for(item), 
+          :service_type_value => :fulltext 
+      )
+      count += 1
+      break if count == @num_full_views
+    end   
+    return count
+  end
+  
+  
+  # If HT has partial serial volumes, include a link to that. 
+  # Need to pass in complete HT json response
+  def create_partial_volume_responses(request, ht_json)
+    items =  ht_json.values.first["items"]
+    full_ids = items.collect do |i| 
+      i["fromRecord"] if (is_serial_part?(i) && full_view?(i))
+    end.compact.uniq
+    
+    full_ids.each do |recordId|
+      record = ht_json.values.first["records"][recordId]
+      next unless record && record["recordURL"]
+        
+      request.add_service_response(
+          :service=>self, 
+          :display_text=>@display_name,           
+          :url=> record["recordURL"],
+          :notes => excerpt_note_for(record),
+          :service_type_value => :excerpts
+      )
+    end
+    
+    if full_ids.empty?
+      search_ids = items.collect do |i|
+        i["fromRecord"] if (is_serial_part?(i) )
+      end.compact.uniq
+      
+      search_ids.each do |recordId|
+        record = ht_json.values.first["records"][recordId]
+        next unless record && record["recordURL"]
+        
+        request.add_service_response(
+            :service=>self, 
+            :display_text=>"Search inside some volumes",           
+            :url=> record["recordURL"],
+            :service_type_value => :highlighted_link             
+        )   
+
+      end
+      
+    end
+    
+    
+  end
+  
+  def create_search_inside(request, items)
+    return if items.empty?
+
+    # Can only include search from the first one  
+    # There's search inside for _any_ HT item. We think. 
+    item = items.first
+    
+    # if this is a serial, we don't want to search inside just part of it, forget it
+    return if is_serial_part?(item) 
+    
+    direct_url = search_url_to(item)
+    return unless direct_url
+
+    request.add_service_response( 
+        :service => self,
+        :display_text=>@display_name,
+        :url=> direct_url,
+        :service_type_value => :search_inside
+       )
+  end
+  
+  def direct_url_to(item_json)
+    if @direct_link_base
+      # we're constructing our own link because we need our EZProxy
+      # to recognize it for WAYFLess login, which it won't if we use
+      # the handle.net url, sorry. 
+      # We also need direct link for direct link to search results.
+      @direct_link_base + "pt?id=" + CGI.escape(item_json['htid'])
+    else
+      item['itemURL']
+    end
+  end
+  
+  def note_for(item)
+    if item['orig']
+      "Digitized from #{item['orig']}"
+    else
+      nil
+    end
+  end
+  
+  def excerpt_note_for(record)
+    return nil unless record["titles"].kind_of?(Array)
+    "Some volumes of: #{record["titles"].first}"
+  end
+  
+  def is_serial_part?(item)
+    # if it's got enumCron, then it's just part of a serial,
+    # we don't want to say the serial title as a whole has full text
+    # or can be searched, skip it. 
+    return item['enumcron']
+  end
+  
+  def full_view?(item)
+    item["usRightsString"] == "Full view"
+  end
+  
+  def search_url_to(item_json)
+    if @direct_link_base
+      @direct_link_base + "ptsearch?id=" + CGI.escape(item_json['htid'])
+    else
+      return nil
+    end
+  end
+
+
+  
+  
+  # Handle search_inside
+  def response_url(service_response, submitted_params)
+    if ( ! (service_response.service_type_value.name == "search_inside" ))
+      return super(service_response, submitted_params)
+    else
+      base = service_response[:url]      
+      query = CGI.escape(submitted_params["query"] || "")
+      url = base + "&q1=#{query}"
+
+      return url
+    end
+  end
+  
+  # sample OCLCnums with appropriate results showing that we can pick up other
+  #   resources by using this service
+  # 02029914  MBooks: full, GBS: info with search inside
+  # 01635828  MBooks: full, GBS: snippet
+  # 55517975  MBooks: search, GBS: limited preview
+  # 02299399  MBooks: full, GBS: snippet
+  # 16857172  MBooks: full, GBS: info
+  
+  # Example of a serial with some full text volumes:
+  # JAMA, lccn:07037314
+  #
+  # Example of a multi-volume with search-only, split accross
+  # two HT records. 
+  # Handbook of biochemistry and molecular biology lccn: 75029514
+  
+end

data/lib/service_adaptors/hip3_service.rb

@@ -0,0 +1,150 @@
+# Needs to be called Hip3Service to avoid conflicting with Hip3 module
+# Params include:
+# map_856_to_service :  Umlaut ServiceTypeValue to map 856 links to. Defaults
+#                     to fulltext_title_level
+
+
+class Hip3Service < Service
+  required_config_params :base_path, :display_name
+  attr_reader :base_path
+
+  include MetadataHelper
+  include MarcHelper
+
+  def initialize(config)
+    # defaults
+    @map_856_to_service = 'fulltext'
+    # If you are sending an OpenURL from a library service, you may
+    # have the HIP bibnum, and include it in the OpenURL as, eg.
+    # rft_id=http://catalog.library.jhu.edu/bib/343434 (except URL-encoded)
+    # Then you'd set rft_id_bibnum_prefix to http://catalog.library.jhu.edu/bib/
+    @rft_id_bibnum_prefix = nil
+    @profile = "general"
+    super(config)
+
+    # Trim question-mark from base_url, if given
+    @base_path.chop! if (@base_path.rindex('?') ==  @base_path.length)     
+  end
+
+  # Standard method, used by background service updater. See Service docs. 
+  def service_types_generated
+    # We generate full text and holdings types, right now.
+    types = [ ServiceTypeValue[:fulltext], ServiceTypeValue[:holding], ServiceTypeValue[:table_of_contents] ]
+    
+    return types
+  end
+
+
+  def handle(request)    
+    bib_searcher = Hip3::BibSearcher.new(@base_path)
+    
+    bib_searcher.issn = request.referent.issn 
+    bib_searcher.isbn = request.referent.isbn
+    bib_searcher.sudoc = get_sudoc(request.referent)
+
+    results = bib_searcher.search
+
+    add_856_links(request, results.collect {|b| b.marc_xml})
+    add_copies(request, results)
+
+    return request.dispatched(self, true)
+
+  end
+
+  # Takes an array of Hip3::Bib objects believed to be exact matches
+  # for the citation querried, and adds response objects for them
+  # Returns a hash of arrays of ServiceResponses added. 
+  def add_copies(request, bib_array, options = {})
+    #debugger
+    
+    # default    
+    options[:match_reliability] ||= ServiceResponse::MatchExact
+
+    responses_added = Hash.new
+
+    
+
+    
+    #Okay, we actually want to make each _copy_ into a service response.
+    #A bib may have multiple copies. We are merging bibs, and just worrying
+    #about the aggregated list of copies.
+    holdings = bib_array.collect { |bib| bib.holdings }.flatten
+    bib_array.each do |bib|
+      
+    
+      bib.holdings.each do |holding|
+  
+      
+        next if holding.dummy?
+  
+        
+        
+        service_data = {}
+        service_data[:url] = holding.bib.http_url
+        service_data[:source_name] = holding.collection_str unless holding.collection_str.nil?
+        service_data[:call_number] = holding.call_no
+        service_data[:status] = holding.status_str
+        service_data[:location] = holding.location_str
+        service_data[:collection_str] = holding.collection_str
+        service_data[:copy_str] = holding.copy_str
+        service_data[:coverage_str] = holding.coverage_str
+        service_data[:coverage_str_array] = holding.coverage_str_to_a 
+        service_data[:notes] = holding.notes
+        # If it's not a serial copy, we can add a direct request url.
+        unless ( holding.kind_of?(Hip3::SerialCopy) )
+          service_data[:request_url] = self.base_path + "?profile=#{@profile}&menu=request&aspect=none&bibkey=#{holding.bib.bibNum}&itemkey=#{holding.id}"
+        end
+  
+        # Need to say it's not an exact match neccesarily?
+        
+        unless ( options[:match_reliability] == ServiceResponse::MatchExact )
+            service_data[:match_reliability] = options[:match_reliability]
+            
+            service_data[:edition_str] = edition_statement(bib.marc_xml)
+        end
+        
+        display_text = ""
+        #display_text << (holding.location_str + ' ')unless holding.location_str.nil?
+        display_text << (holding.copy_str + ' ') unless holding.copy_str.nil?
+  
+        # coverage strings, may be multiple
+        holding.coverage_str_to_a.each {|s| display_text << (s + ' ')}
+  
+        display_text << holding.notes unless holding.notes.nil?
+        service_data[:display_text] = display_text
+        
+        response = request.add_service_response(
+          service_data.merge(
+            :service=>self, 
+            :service_type_value => 'holding'  )
+          )
+  
+        responses_added['holding'] ||= Array.new
+        responses_added['holding'].push( response )
+  
+      end
+    end
+
+    return responses_added
+  end
+
+  def url_service_type( field )
+    return service_type_for_856(field, :default_service_type =>  @map_856_to_service)            
+  end
+
+  def get_bibnum(rft)
+    return nil unless @rft_id_bibnum_prefix
+
+    identifier = rft.identifiers.find do |id| 
+      id[0, @rft_id_bibnum_prefix.length] == @rft_id_bibnum_prefix
+    end
+
+    if ( identifier )
+      return identifier[@rft_id_bibnum_prefix.length, identifier.length]
+    else
+      return nil
+    end
+    
+  end
+
+end