umlaut 3.0.0alpha1

data/lib/service_adaptors/primo_source.rb

@@ -0,0 +1,78 @@
+# == Overview
+# PrimoSource is a PrimoService that converts primo_source service types into Primo source holdings.
+# This mechanism allows linking to original data sources and expanded holdings information
+# based on those sources and can be implemented per source.
+# To create a Primo source holding, you first must create a local class representing the source in
+# module Exlibris::Primo::Source::Local which extends Exlibris::Primo::Holding.
+# Two methods are then available for overriding:
+#     :expand -   expand holdings that may have been collapsed into a single availlibrary element 
+#                 in Primo based on information from the source
+#                 default: [self]
+#     :dedup? -   if this data source contain duplicate holdings that need to be deduped, set to true
+#                 default: false
+# The following properties can also be overridden in the initialize method
+#     :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
+# PrimoSources are not for everyone as they require programming but they do allow further customization 
+# and functionality as necessary.
+#
+# == Further Documentation
+# Exlibris::Primo::Holding provides further documentation related to creating local sources.
+#
+# ==Examples
+# Two examples of customized sources are:
+# * Exlibris::Primo::Source::Aleph 
+# * Exlibris::Primo::Source::Local::NYUAleph 
+class PrimoSource < PrimoService
+
+  # Overwrites PrimoService#new.
+  def initialize(config)
+    @service_types = ["holding"]
+    super(config)
+  end
+
+  # Overwrites PrimoService#handle.
+  def handle(request)
+    primo_sources = request.get_service_type('primo_source', {})
+    sources_seen = Array.new # for de-duplicating holdings from catalog.
+    primo_sources.each do |primo_source|
+      source = primo_source.view_data
+      # There are some cases where source records may need to be de-duplicated against existing records
+      # Check if we've already seen this record.
+      seen_sources_key = source.source_id.to_s + source.source_record_id.to_s
+      next if source.dedup? and sources_seen.include?(seen_sources_key)
+      # If we get this far, record that we've seen this holding.
+      sources_seen.push(seen_sources_key)
+      # There may be multiple holdings mapped to one availlibrary here, 
+      # so we get the additional holdings and add them.
+      source.expand.each do |holding|
+        service_data = {}
+        @holding_attributes.each do |attr|
+          service_data[attr] = holding.method(attr).call
+        end
+        service_data.merge!({
+          :call_number => holding.call_number, :collection => holding.collection,
+          :collection_str => "#{holding.library} #{holding.collection}",
+          :coverage_str => holding.coverage.join("<br />"),
+          :coverage_str_array => holding.coverage,
+  				# :expired determines whether we show the holding in this service
+  				# Since this is fresh, the data has not yet expired.
+  				:expired => false, 
+   				# :latest determines whether we show the holding in other services, e.g. txt and email.
+  				# It persists for one more cycle than :expired so services that run after
+  				# this one, but in the same resolution request have access to the latest holding data.
+          :latest => true
+        })
+        request.add_service_response(
+          service_data.merge(
+            :service=>self,
+            :service_type_value => "holding" 
+          )
+        )
+      end
+    end
+    return request.dispatched(self, true)
+  end
+end

data/lib/service_adaptors/pubmed.rb

@@ -0,0 +1,133 @@
+# Looks up pmid from NLM api, and enhances referent with citation data. 
+#
+# If you use SFX, you prob don't need/want this, as SFX does this already. 
+class Pubmed < Service  
+  require 'uri'
+  require 'net/http'
+  require 'nokogiri'
+  
+  include MetadataHelper
+  
+  def initialize(config)
+    @display_name = "PubMed"
+    @url = 'http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi'
+    super(config)
+  end
+  
+  def handle(request)
+    return request.dispatched(self, true) unless pmid = get_pmid(request.referent)
+        
+    return request.dispatched(self, false) unless response = self.fetch_record(pmid)
+    
+    self.enhance_referent(response, request)
+    
+    return request.dispatched(self, true)    
+  end
+  
+  def service_types_generated
+    @service_types ||= [ServiceTypeValue["referent_enhance"]]
+  end
+    
+  
+  # Do the request.  Takes the PMID as inputs 
+  def fetch_record(pmid)  
+    pmid_url = self.url + "?db=pubmed&retmode=xml&rettype=full&id="+pmid
+    begin
+      response = Net::HTTP.get_response(URI.parse(pmid_url))
+    rescue
+      return false
+    end
+    return false if response.body.match("<ERROR>Empty id list - nothing todo</ERROR>")
+    return response.body
+  end    
+  
+  # Pull everything useful out of the Pubmed record
+  def enhance_referent(body, request)   
+    doc = Nokogiri::XML(body)
+    return unless cite = doc.at("PubmedArticleSet/PubmedArticle/MedlineCitation") # Nothing of interest here
+    
+    return unless article = cite.at("Article") # No more useful metadata   
+    if abstract = article.at("Abstract/AbstractText")
+      request.add_service_response(        
+      :service=>self,
+      :display_text => "Abstract from #{@display_name}",
+      :content => abstract.inner_text,
+      :service_type_value => 'abstract') unless abstract.inner_text.blank?      
+    end
+    
+    if journal = article.at("Journal")
+      if issn = journal.at('ISSN')
+        if issn.attributes['issntype']=="Print"                  
+          request.referent.enhance_referent('issn', issn.inner_html)
+        else 
+          request.referent.enhance_referent('eissn', issn.inner_html)        
+        end
+      end
+      if jrnlissue = journal.at('JournalIssue')
+        if volume = jrnlissue.at('Volume')
+          request.referent.enhance_referent('volume', volume.inner_text)
+        end
+        if issue = jrnlissue.at('Issue')
+          request.referent.enhance_referent('issue', issue.inner_text)
+        end   
+        if date = jrnlissue.at('PubDate')    
+          
+          request.referent.enhance_referent('date', openurl_date(date))
+          
+        end              
+      end
+      
+      if jtitle = journal.at('Title')
+        request.referent.enhance_referent('jtitle', jtitle.inner_text)          
+      end
+      if stitle = journal.at('ISOAbbreviation')
+        request.referent.enhance_referent('stitle', stitle.inner_text)
+      end       
+      
+      if atitle = article.at('ArticleTitle')
+        request.referent.enhance_referent('atitle', atitle.inner_text)
+      end   
+      
+      if pages = article.at('Pagination/MedlinePgn')
+        page_str = pages.inner_text
+        request.referent.enhance_referent('pages', page_str)
+        if spage = page_str.split("-")[0]
+          request.referent.enhance_referent('spage', spage.strip)
+        end
+      end                
+      
+      if author = article.at('AuthorList/Author')
+        if last_name = author.at('LastName')
+          request.referent.enhance_referent('aulast', last_name.inner_text)
+        end
+        if first_name = author.at('ForeName')
+          request.referent.enhance_referent('aufirst', first_name.inner_text)
+        end          
+        if initials = author.at('Initials')
+          request.referent.enhance_referent('auinit', initials.inner_text)
+        end          
+      end              
+    end      
+  
+  end
+  
+  # input a PubMed <PubDate> element, return
+  # a string usable as rft.date yyyymmdd
+  def openurl_date(date_xml)
+    date = ""
+    
+    if y = date_xml.at("Year")
+      date << ("%04d" % y.inner_text.strip[0,4].to_i )
+      if m = date_xml.at("Month")
+        # Month name to number
+        date << ( "%02d" % DateTime.parse(m.inner_text.strip).month )
+        if d = date_xml.at("Day")
+          date << ("%02d" % d.inner_text.strip[0,2].to_i)
+        end
+      end
+    end
+            
+    return date             
+  end
+
+end

data/lib/service_adaptors/request_to_fixture.rb

@@ -0,0 +1,68 @@
+# This service helps create fixture data for testing purposes.
+# It really just writes out to Yaml the Request (attributes only), Referent,
+# and ReferentValues. 
+# The Request, Referent and ReferentValues must be cut and pasted into the 
+# relevant fixture files to be used in testing.
+ 
+
+class RequestToFixture < Service
+  required_config_params :file
+  attr_reader :file
+  
+  def service_types_generated  
+  end
+  
+  def initialize(config)
+    super(config)
+  end
+  
+  def handle(request)
+    final_string = ''
+    fh = File.open(@file, 'a')
+    dump_request(request, final_string)
+    dump_referent_values(request, final_string)    
+    
+    cleanup(final_string)
+    fh.puts final_string
+    fh.close
+    return request.dispatched(self, true)
+  end
+  
+  def dump_request(request, string)
+    #YAML.dump(request, fh)
+    dump_proper(request, string, 'request')
+    put_cutline(string)
+    dump_proper(request.referent, string, 'referent')
+    put_cutline(string)
+  end
+  
+  def dump_referent_values(request, string)
+    referent_values = request.referent.referent_values.sort_by{|rv| rv.id}
+      referent_values.each do |rv|
+        dump_proper(rv, string, 'referent_value')
+      end
+      put_cutline(string)
+  end
+  
+  def dump_proper(data, string, type)
+    values = {}
+    data.attributes.each do |var, val|
+      values[var] = val
+    end
+    fixture = {}
+    fixture[type + '_' + data.id.to_s] = values
+    string << YAML.dump(fixture)
+    
+  end
+  
+  def put_cutline(string)
+    string << "\n-------------CUT HERE----------------\n"
+  end
+  
+  # removes lines that only contain three dashes. These mess up our fixtures.
+  def cleanup(string)
+    string.gsub!(/^--- $/, "")
+  end
+  
+  
+end

data/lib/service_adaptors/scopus.rb

@@ -0,0 +1,295 @@
+# Service adapter plug-in.
+# 
+# PURPOSE: Includes "cited by", "similar articles" and "more by these authors"
+# links from scopus. Also will throw in an abstract from Scopus if found. 
+#
+# LIMTATIONS: You must be a Scopus customer for these links generated to work
+# for your users at all! Off-campus users should be going through ezproxy, see
+# the EZProxy plug-in.
+# Must find a match in scopus, naturally. "cited by" will only
+# be included if Scopus has non-0 "cited by" links. But there's no good way
+# to precheck similar/more-by for this, so they are provided blind and may
+# result in 0 hits.  You can turn them off if you like, with @include_similar,
+# and @include_more_by_authors. 
+#
+# REGISTERING:  This plug in actually has to use two seperate Scopus APIs.
+# For the first, the scopus 'json' search api, you must regsiter and get an
+# api key from scopus, which you can do here:
+# http://searchapi.scopus.com
+# Then include as @json_api_key in service config.
+#
+# For the second Scopus API, you theoretically need a Scopus "PartnerID" and
+# corresponding "release number", in @partner_id and @scopus_release
+# There's no real easy way to get one. Scopus says:
+#    "To obtain a partner ID or release number, contact your nearest regional
+#    Scopus office. A list of Scopus contacts is available at
+#    http://www.info.scopus.com/contactus/index.shtml"
+# Bah! But fortunately, using the "partnerID" assigned to the Scopus Json
+# API, 65, _seems_ to work, and is coded here as the default. You could try
+# going with that. When you register a partnerID, you also get a 'salt key',
+# which is currently not used by this code, but @link_salt_key is reserved
+# for it in case added functionality does later. 
+#
+class Scopus < Service
+  require  'open-uri'
+  require 'multi_json'
+  include MetadataHelper
+  include UmlautHttp
+  
+  required_config_params :json_api_key
+
+  def service_types_generated
+    types = []
+    types.push( ServiceTypeValue[:abstract]) if @include_abstract
+    types.push( ServiceTypeValue[:cited_by] ) if @include_cited_by
+    types.push( ServiceTypeValue[:abstract] ) if @include_abstract
+    types.push( ServiceTypeValue[:similar] ) if @include_similar
+    types.push( ServiceTypeValue[@more_by_authors_type] ) if @include_more_by_authors
+
+    return types
+  end
+
+  def initialize(config)
+    #defaults
+    @display_name = "Scopus"
+    @registered_referer
+    @scopus_search_base = 'http://www.scopus.com/scsearchapi/search.url'
+    
+    @include_abstract = true
+    @include_cited_by = true
+    @include_similar = true
+    @include_more_by_authors = true
+    @more_by_authors_type = "similar"
+
+    @inward_cited_by_url = "http://www.scopus.com/scopus/inward/citedby.url"
+    #@partner_id = "E5wmcMWC"
+    @partner_id = 65
+    @link_salt_key = nil
+    @scopus_release = "R6.0.0"
+
+    # Scopus offers two algorithms for finding similar items.
+    # This variable can be:
+    # "key" => keyword based similarity 
+    # "ref" => reference based similiarity (cites similar refs?) Seems to offer 0 hits quite often, so we use keyword instead. 
+    # "aut" => author. More docs by same authors. Incorporated as seperate link usually. 
+    @more_like_this_type = "key"
+    @inward_more_like_url = "http://www.scopus.com/scopus/inward/mlt.url"
+    
+    @credits = {
+      @display_name => "http://www.scopus.com/home.url"
+    }
+    
+    super(config)
+  end
+
+  def handle(request)
+    scopus_search = scopus_search(request)
+
+    # we can't make a good query, nevermind. 
+    return request.dispatched(self, true) if scopus_search.blank? 
+
+    
+    # The default fields returned dont' include the eid (Scopus unique id) that we need, so we'll supply our own exhaustive list of &fields=
+    url = 
+    "#{@scopus_search_base}?devId=#{@json_api_key}&search=#{scopus_search}&callback=findit_callback&fields=title,doctype,citedbycount,inwardurl,sourcetitle,issn,vol,issue,page,pubdate,eid,scp,doi,firstAuth,authlist,affiliations,abstract";
+    
+    # Make the call.
+    headers = {}
+    headers["Referer"] = @registered_referer if @registered_referer 
+
+    response = open(url, headers).read    
+    
+    # Okay, Scopus insists on using a jsonp technique to embed the json array in
+    # a procedure call. We don't want that, take the actual content out of it's
+    # jsonp wrapper. 
+    response =~ /^\w*findit_callback\((.*)\);?$/
+    response = $1;
+    
+    # Take the first hit from scopus's results, hope they relevancy ranked it
+    # well. For DOI/pmid search, there should ordinarly be only one hit!
+    results = MultiJson.decode(response)
+
+    if ( results["ERROR"])
+      Rails.logger.error("Error from Scopus API: #{results["ERROR"].inspect}   openurl: ?#{request.referent.to_context_object.kev}")
+      return request.dispatched(self, false)
+    end
+
+    # For reasons not clear to me, the JSON data structures vary.
+    first_hit = nil
+    if ( results["PartOK"])
+      first_hit = results["PartOK"]["Results"][0]
+    elsif ( results["OK"] )
+      first_hit = results["OK"]["Results"][0]
+    else
+      # error. 
+    end
+
+    if ( first_hit )
+    
+      if (@include_cited_by && first_hit["citedbycount"].to_i > 0)
+        add_cited_by_response(first_hit, request)
+      end
+  
+      if (@include_abstract && first_hit["abstract"])
+        add_abstract(first_hit, request)
+      end
+
+      if (@include_similar)
+        url = more_like_this_url(first_hit)
+        # Pre-checking for actual hits not currently working, disabled.
+        if (true || ( hits = check_for_hits(url) ) > 0 )
+          request.add_service_response( 
+            :service=>self, 
+            :display_text => "#{hits} #{ServiceTypeValue[:similar].display_name_pluralize.downcase.capitalize}", 
+            :url => url, 
+            :service_type_value => :similar)          
+        end                
+      end
+
+      if ( @include_more_by_authors)
+        url = more_like_this_url(first_hit, :type => "aut")
+        # Pre-checking for actual hits not currently working, disabled. 
+        if (true || ( hits = check_for_hits(url) ) > 0 )
+          request.add_service_response( 
+            :service=>self, 
+            :display_text => "#{hits} More from these authors", 
+            :url => url, 
+            :service_type_value => :similar)          
+        end        
+      end
+
+    end
+
+    return request.dispatched(self, true)
+  end
+
+  # Comes up with a scopus advanced search query intended to find the exact
+  # known item identified by this citation.
+  #
+  # Will try to use DOI or PMID if available. Otherwise
+  # will use issn/year/vol/iss/start page if available.
+  # In some cases may resort to author/title. 
+  def scopus_search(request)
+    
+    if (doi = get_doi(request.referent))
+      return CGI.escape( "DOI(#{phrase(doi)})" )
+    elsif (pmid = get_pmid(request.referent))
+      return CGI.escape( "PMID(#{phrase(pmid)})" )
+    elsif (isbn = get_isbn(request.referent))
+      # I don't think scopus has a lot of ISBN-holding citations, but
+      # it allows search so we might as well try. 
+      return CGI.escape( "ISBN(#{phrase(isbn)})" )
+    else            
+      # Okay, we're going to try to do it on issn/vol/issue/page.
+      # If we don't have issn, we'll reluctantly use journal title
+      # (damn you google scholar).
+      metadata = request.referent.metadata
+      issn = request.referent.issn
+      if ( (issn || ! metadata['jtitle'].blank? ) &&
+           ! metadata['volume'].blank? &&
+           ! metadata['issue'].blank? &&
+           ! metadata['spage'].blank? )
+        query = "VOLUME(#{phrase(metadata['volume'])}) AND ISSUE(#{phrase(metadata['issue'])}) AND PAGEFIRST(#{phrase(metadata['spage'])}) "
+        if ( issn )
+          query += " AND (ISSN(#{phrase(issn)}) OR EISSN(#{phrase(issn)}))"
+        else
+          query += " AND EXACTSRCTITLE(#{phrase(metadata['jtitle'])})"
+        end
+        return CGI.escape(query)
+      end
+      
+    end
+  end
+  
+  # backslash escapes any double quotes, and embeds string in scopus
+  # phrase search double quotes. Does NOT uri-escape. 
+  def phrase(str)
+    '"' + str.gsub('"', '\\"') + '"'
+  end
+
+  # Input is a ruby hash that came from the scopus JSON, representing
+  # a single hit. We're going to add this as a result. 
+  def add_cited_by_response(result, request)
+    # While scopus provides an "inwardurl" in the results, this just takes
+    # us to the record detail page. We actually want to go RIGHT to the
+    # list of cited-by items. So we create our own, based on Scopus's
+    # reversed engineered predictable URLs. 
+
+    count = result["citedbycount"]
+    label = ServiceTypeValue[:cited_by].display_name_pluralize.downcase.capitalize    
+      if count && count == 1
+        label = ServiceTypeValue[:cited_by].display_name.downcase.capitalize
+      end
+    cited_by_url = cited_by_url( result )
+    
+    request.add_service_response(:service=>self, 
+      :display_text => "#{count} #{label}", 
+      :count=> count, 
+      :url => cited_by_url, 
+      :service_type_value => :cited_by)
+
+  end
+
+  def add_abstract(first_hit, request)
+
+    return if first_hit["abstract"].blank?
+    
+    request.add_service_response( 
+      :service=>self, 
+      :display_text => "Abstract from #{@display_name}", 
+      :content => first_hit["abstract"], 
+      :url => detail_url(first_hit), 
+      :service_type_value => :abstract)
+  end
+
+  def detail_url(hash)
+    url = hash["inwardurl"]
+    # for some reason ampersand's in query string have wound up double escaped
+    # and need to be fixed.
+    url = url.gsub(/\&amp\;/, '&')
+
+    return url
+  end
+
+  def cited_by_url(result)
+    eid = CGI.escape(result["eid"])    
+    #return "#{@scopus_cited_by_base}?eid=#{eid}&src=s&origin=recordpage"
+    # Use the new scopus direct link format!
+    return "#{@inward_cited_by_url}?partnerID=#{@partner_id}&rel=#{@scopus_release}&eid=#{eid}"
+    return 
+  end
+
+  def more_like_this_url(result, options = {})
+    options[:type] ||= @more_like_this_type
+    
+    eid = CGI.escape(result["eid"])
+    return "#{@inward_more_like_url}?partnerID=#{@partner_id}&rel=#{@scopus_release}&eid=#{eid}&mltType=#{options[:type]}"
+  end
+
+  # NOT currently working. Scopus doesn't make this easy. 
+  # Takes a scopus direct url for which we're not sure if there will be results
+  # or not, and requests it and html screen-scrapes to get hit count. (We
+  # can conveniently find this just in the html <title> at least).
+  # Works for cited_by and more_like_this searches at present. 
+  # May break if Scopus changes their html title!
+  def check_for_hits(url)
+  
+    response = http_fetch(url).body
+
+    response_html = Nokogiri::HTML(response)
+
+    title = response_xml.at('title').inner_text
+    # title is "X documents" (or 'Documents') if there are hits.
+    # It's annoyingly "Search Error" if there are either 0 hits, or
+    # if there was an actual error. So we can't easily log actual
+    # errors, sorry.
+    title.downcase =~ /^\s*(\d+)?\s+document/
+    if ( hits = $1)
+      return hits.to_i
+    else
+      return 0
+    end    
+  end
+
+    
+end