umlaut 3.0.5 → 3.1.0.pre1

data/{lib → app/service_adaptors}/service.rb

@@ -32,7 +32,7 @@
 # to. If service returns original url or nil, original url will still be used. 
 
 class Service
-  attr_reader :priority, :service_id, :url, :task, :status, :name
+  attr_reader :priority, :service_id, :url, :task, :status, :name, :group
   attr_writer :session_id
   attr_accessor :request
   @@required_params_for_subclass = {} # initialize class var
@@ -66,7 +66,7 @@ class Service
           # handle both cases.
           raise NameError if value.nil?          
       rescue NameError
-      raise ArgumentError.new("Missing Service configuration parameter. Service type #{self.class} (id: #{self.service_id}) requires a config parameter named '#{param}'. Check your config/umlaut_config/services.yml file.")
+      raise ArgumentError.new("Missing Service configuration parameter. Service type #{self.class} (id: #{self.service_id}) requires a config parameter named '#{param}'. Check your config/umlaut_services.yml file.")
       end      
     end    
   end
@@ -244,7 +244,7 @@ class Service
         uml_request.dispatched_services.to_a.find do |disp|
           service == "*" || 
           (disp.service_id == service &&
-            (disp.status ==  DispatchedService.Succesful ))
+            (disp.status ==  DispatchedService::Successful ))
         end
       else
         # Check service responses

data/{lib → app}/service_adaptors/sfx.rb

@@ -36,11 +36,18 @@
 #     relationships, set to empty array [] to eliminate defaults. 
 # sfx_timeout: in seconds, for both open/read timeout value for SFX connection.
 #          Defaults to 8.
+# roll_up_prefixes: ARRAY of STRINGs, prefixes like "EBSCOHOST_". If multiple
+#      targets sharing one of the specified prefixes are supplied from SFX,
+#      they will be "rolled up" and collapsed, just the first one included
+#      in response. For TITLE-LEVEL (rather than article-level) requests,
+#      the roll-up algorithm is sensitive to COVERAGES, and will only suppress
+#      targets that have coverages included in remaining non-suppressed targets.  
 class Sfx < Service
   require 'uri'
   require 'htmlentities'
   require 'cgi'
   require 'nokogiri'
+  require 'date'
 
   #require 'open_url'
 
@@ -184,6 +191,10 @@ class Sfx < Service
     # We're going to keep our @really_distant_relationship stuff here. 
     related_titles = {}
     
+    # We organize our responses in a queue, so we can process them
+    # for collapse function, before actually writing to db. 
+    response_queue ||= {}
+    
     0.upto(sfx_objs.length - 1 ) do |sfx_obj_index|
     
       sfx_obj = sfx_objs[sfx_obj_index]
@@ -218,7 +229,7 @@ class Sfx < Service
 
       
       metadata = request.referent.metadata
-      
+            
       # For each target delivered by SFX
       sfx_obj.search("./ctx_obj_targets/target").each_with_index do|target, target_index|  
         response_data = {}
@@ -305,7 +316,7 @@ class Sfx < Service
               next
             end
             
-            related_note = "This version provided from related title:  <i>" + CGI.unescapeHTML( title ) + "</i>.\n"
+            related_note = "This version provided from related title:  <em>" + CGI.unescapeHTML( title ) + "</em>.\n"
           end
   
           if ( sfx_service_type == 'getDocumentDelivery' )
@@ -316,10 +327,18 @@ class Sfx < Service
 
           response_data[:url] = CGI.unescapeHTML((target/"./target_url").inner_text)
           response_data[:notes] = related_note.to_s + CGI.unescapeHTML((target/"./note").inner_text)
+          # Set the proxy boolean
+          response_data[:proxy] = CGI.unescapeHTML((target/"./proxy").inner_text).eql?("yes")
           response_data[:authentication] = CGI.unescapeHTML((target/"./authentication").inner_text)
           response_data[:source] = source
           response_data[:coverage] = coverage if coverage
-  
+          
+          
+          # machine actionable coverage elements, used for collapsing    
+          ( response_data[:coverage_begin_date], response_data[:coverage_end_date] ) =
+            determine_coverage_boundaries(target)
+          
+          
           # Sfx metadata we want
           response_data[:sfx_base_url] = @base_url
           response_data[:sfx_obj_index] = sfx_obj_index + 1 # sfx is 1 indexed
@@ -345,19 +364,34 @@ class Sfx < Service
           response_data[:debug_info] =" Target: #{sfx_target_name} ; SFX object ID: #{object_id}"
           
           response_data[:display_text] = (target/"./target_public_name").inner_text
-    
-          request.add_service_response(
-            response_data.merge(
-              :service => self,              
-              :service_type_value => umlaut_service
-           ))
-            
+        
+          response_data.merge!(
+            :service => self,              
+            :service_type_value => umlaut_service
+          )
+                                
+          #request.add_service_response( response_data )
+          # We add the response_data to a list for now, so we can post-process
+          # for collapse feature  before we actually add them. 
+          response_queue[umlaut_service] ||= []
+          response_queue[umlaut_service] << response_data
               
                               
         end
       end
     end
 
+    if response_queue["fulltext"].present?
+      response_queue["fulltext"] = roll_up_responses(response_queue["fulltext"], :coverage_sensitive => request.title_level_citation? )
+    end
+              
+    # Now that they've been post-processed, actually commit them. 
+    response_queue.each_pair do |type, list|
+      list.each do |response|      
+        request.add_service_response( response )
+      end
+    end
+    
     # Add in links to our related titles
     related_titles.each_pair do |issn, hash|
       request.add_service_response(        
@@ -377,6 +411,115 @@ class Sfx < Service
     
   end
 
+  # pass in a nokogiri element for <target>, we'll calculate 
+  # ruby Date objects for begin date and end date of coverage,
+  # passed out as a two-element array [begin, end]. 
+  #
+  # taking embargoes into account. nil if unbounded. 
+  def determine_coverage_boundaries(target)    
+    # machine actionable coverage elements, used for collapsing
+    if (in_node = target.at_xpath("./coverage/in"))
+        year = in_node.at_xpath("year").try(:text).try(:to_i)
+        if year && year != 0
+          begin_date = Date.new(year, 1, 1)
+          end_date   = Date.new(year, 12, 31)
+        end
+    end
+    
+    if (from = target.at_xpath("./coverage/from"))            
+      year   = from.at_xpath("year").try(:text).try(:to_i)     
+      # SFX KB does not have month/day, only year, set to begin of year
+      begin_date = Date.new(year, 1, 1) if year && year != 0
+    end
+    
+    if (from = target.at_xpath("./coverage/to"))            
+      year   = from.at_xpath("year").try(:text).try(:to_i)
+      # set to end of year
+      end_date = Date.new(year, 12, 31) if year && year != 0
+    end
+    
+    
+            
+    # If there's an embargo too, it may modify existing dates
+    if (embargo = target.at_xpath("./coverage/embargo"))
+      days = embargo.at_xpath("days").try(:text).try(:to_i)
+      days.try do |days|
+        embargo_days = Date.today - days
+        if embargo.at_xpath("availability").try(:text) == "available"
+          # only most recent X days, at earliest start                
+          begin_date = 
+            [begin_date || embargo_days, embargo_days].max                
+        else # not_available
+          # stops at most recent X days, at latest end
+          end_date = 
+            [end_date || embargo_days, embargo_days].min
+        end
+      end
+    end
+    return [begin_date, end_date]
+  end
+  
+  # Pass in a list of hashes for making ServiceResponse's, we will roll up
+  # those that should be rolled up per roll_up_prefixes configuration.
+  #
+  # In :coverage_sensitive => true, will roll up sensitive to overlapping
+  # coverage to not remove any coverage. 
+  #
+  # Does not mutate list passed in, don't try to change it to mutate,
+  # makes it hard to deal with list changing from underneath you in logic. 
+  def roll_up_responses(list, options = {})
+    options = options.reverse_merge(:coverage_sensitive => true)
+    
+    prefixes = @roll_up_prefixes
+    
+    # If not configured for roll-up, just return it directly. 
+    return list unless prefixes.present?
+
+    
+    if options[:coverage_sensitive] == true
+      # roll up targets with same prefix only if coverage is a strict
+      # subset of an existing one. If two are equal, take first.       
+      list = list.reject.each_with_index do |item, index|
+        prefix = prefixes.find {|p| item[:sfx_target_name].start_with?(p)}        
+        bdate = item[:coverage_begin_date] || Date.new(1,1,1)
+        edate = item[:coverage_end_date] || Date.today
+        
+        prefix && (
+          # earlier is equal or superset
+          list.slice(0, index).find do |candidate|
+            # nil considered very early or very late, unbounded
+            candidate_bdate = candidate[:coverage_begin_date] || Date.new(1,1,1)
+            candidate_edate = candidate[:coverage_end_date]   || Date.today
+            
+            candidate[:sfx_target_name].start_with?(prefix) &&
+            (candidate_bdate <= bdate) && (candidate_edate >= edate)
+          end ||
+          # later is superset, not equal
+          list.slice(index+1, list.length).find do |candidate|
+            candidate_bdate = (candidate[:coverage_begin_date] || Date.new(1,1,1))
+            candidate_edate = (candidate[:coverage_end_date]   || Date.today)
+                                                
+            candidate[:sfx_target_name].start_with?(prefix) &&
+            (candidate_bdate <= bdate) && (candidate_edate >= edate) &&
+            (! (bdate == candidate_bdate && edate == candidate_edate))
+          end
+          )
+      end            
+    else # not coverage_sensitive
+      # Just roll up to FIRST of each prefix
+      list = list.reject.each_with_index do |item, index|
+        prefix = prefixes.find {|p| item[:sfx_target_name].start_with?(p)}
+        
+        prefix && list.slice(0,index).find do |candidate|
+          candidate[:sfx_target_name].start_with?(prefix)
+        end      
+      end
+    end
+    
+    
+    return list
+  end
+  
    
   def sfx_click_passthrough
     # From config, or default to false. 
@@ -387,7 +530,7 @@ class Sfx < Service
   # umlaut service response is so old that we can't use it for
   # sfx click passthrough anymore. 
   def expired_sfx_request(response)
-    require 'CronTab'
+    require 'cron_tab'
 
     crontab_str = @sfx_requests_expire_crontab
 

data/app/service_adaptors/tr_link.rb

@@ -0,0 +1,267 @@
+# encoding: UTF-8
+
+# Uses ISI Web of Knowledge to generates links to "cited by" and "similar"
+# articles.
+#
+# REQUIREMENTS: You must be an ISI customer if you want these links to actually
+# work for your users. Off-campus users should be sent through EZProxy, see
+# the EZProxy plug-in.
+# 
+# You need to register for the  the Thomson 'Links Article Match Retrieval'
+# (LAMR) service api, which is used here. To register, see:
+# http://wokinfo.com/products_tools/products/related/amr/
+#
+# You register by IP address, so no API key is needed once your registration
+# goes through. 
+#
+# If you later need to change the IP addresses entitled to use this API, use
+# http://scientific.thomson.com/scientific/techsupport/cpe/form.html.
+# to request a change.
+#
+# File support/outage tickets at http://ip-science.thomsonreuters.com/support/
+#
+# Note, as of 13 april 09, there's a bug in ISI where journal titles including
+# ampersands cause an error. We will catch those errors and output a 'warning'
+# instead of an 'error', since it's a known problem. 
+class Isi < Service
+  require  'open-uri'
+  require 'nokogiri'
+  require 'net/http'
+  require 'builder'
+  
+  include MetadataHelper
+  
+  
+  def service_types_generated
+    return [ServiceTypeValue[:cited_by]]
+  end
+
+  def initialize(config)
+    #defaults
+    @wos_app_name = "Umlaut"
+    @display_name = "Web of Knowledge\xc2\xae" # trademark symbol
+    @api_url = "https://ws.isiknowledge.com/cps/xrpc"
+    @include_cited_by = true
+    @include_similar = true
+    
+    @credits = {
+      @display_name => "http://apps.webofknowledge.com"
+    }
+    
+    super(config)
+  end
+
+  def handle(request)
+    
+    unless ( sufficient_metadata?(request.referent))
+       return request.dispatched(self, true)
+    end
+    
+    xml = gen_lamr_request(request)
+    
+    isi_response = do_lamr_request(xml)
+    
+    
+    begin
+      #raise if it's an error HTTP response
+      isi_response.value
+    
+      response_xml = Nokogiri::XML(isi_response.body)    
+      # Check for errors.
+      if (error = (response_xml.at('val[@name = "error"]') || response_xml.at("error") || response_xml.at('null[@name = "error"]')))
+        raise IsiResponseException.new("ISI service reported error: #{error.inner_text}")      
+      end
+
+      add_responses( request, response_xml )
+    rescue IsiResponseException => e
+      # Is this the known problem with ampersands?
+      # if so, output a warning, but report success not exception,
+      # because this is a known condition.
+      metadata = request.referent.metadata
+      if ( (metadata["title"] && metadata["title"].include?('&')) ||
+           (metadata["jtitle"] && metadata['jtitle'].include?('&')))
+        Rails.logger.warn("ISI LAMR still exhibiting ampersand problems: #{e.message} ; OpenURL: ?#{request.to_context_object.kev}")
+        return request.dispatched(self, true)
+      else    
+        # Log the error, return exception condition. 
+
+        error_parts = []
+        error_parts << "ISI URI: #{@api_url}"
+        error_parts << "Request XML: #{xml}"
+        error_parts << "ISI Response body: #{response_xml}"
+
+
+        Rails.logger.error("#{e.message} ; " + error_parts.join("\n     ") )
+        return request.dispatched(self, false, e)
+      end
+    end
+    
+    return request.dispatched(self, true)
+  end
+
+  # A DOI is always sufficient. Otherwise, it gets complicated because the ISI
+  # service is kind of picky in weird ways. ISSN alone is not enough, we need
+  # jtitle.  Once you have jtitle, Vol/issue/start page are often enough, but
+  # article title really helps, and jtitle+atitle+year is often enough too. 
+  def sufficient_metadata?(referent)
+    metadata = referent.metadata
+    return get_doi(referent) || get_pmid(referent) ||
+        (  ( metadata['jtitle'] || 
+             metadata['title'] )   &&           
+           (! (metadata['atitle'].blank? ||
+              metadata['date'].blank?
+              ) ||
+            ! ( metadata['volume'].blank? || metadata['issue'].blank? ||
+                metadata['spage'].blank?))
+        )    
+  end
+
+  # produces XML to be posted to Thomson 'Links Article Match Retrieval' service api. 
+  def gen_lamr_request(request)
+    output = ""
+    
+    builder = Builder::XmlMarkup.new(:target => output, :indent => 2)
+    builder.instruct!(:xml, :encoding => "UTF-8")    
+
+    builder.request(:xmlns => "http://www.isinet.com/xrpc41", :src => "app.id=Umlaut") do
+      builder.fn(:name => "LinksAMR.retrieve") do
+        builder.list do
+          # first map is authentication info. empty 'map' element since we are IP authenticated. 
+          builder.map
+          # specify what we're requesting
+          builder.map do
+            builder.list(:name=>"WOS") do
+              builder.val("timesCited")
+              builder.val("ut")
+              builder.val("doi")
+              builder.val("sourceURL")
+              builder.val("citingArticlesURL")
+              builder.val("relatedRecordsURL")
+            end
+          end
+          # specify our query
+          builder.map do
+            builder.map(:name => "cite_id") do
+              # Here's the tricky part, depends on what we've got.
+              metadata = request.referent.metadata
+
+              # DOI
+              if ( doi = get_doi(request.referent))
+                builder.val(doi, :name => "doi")
+              end
+
+              if ( pmid = get_pmid(request.referent))
+                builder.val(pmid, :name => "pmid")
+              end
+
+              # Journal title is crucial for ISI -- ISSN alone is
+              # not enough, weirdly!
+              if ( ! metadata['jtitle'].blank? )
+                builder.val(metadata['jtitle'], :name => "stitle" )
+              else
+                builder.val(metadata['title'], :name => 'stitle' )
+              end
+              
+              # ISSN, not actually used much by ISI, but can't hurt. 
+              if ( issn = request.referent.issn )
+                # ISSN _needs_ a hyphen for WoS, bah!
+                unless issn.match( /\-/ )
+                  issn = issn[0,4] + '-' + issn[4,7]
+                end
+                builder.val(issn, :name => "issn")
+              end
+
+              # article title often helpful. 
+              unless ( metadata['atitle'].blank?)
+                builder.val( metadata['atitle'], :name => "atitle")
+              end
+              # year
+              unless ( metadata['date'].blank?)
+                #first four digits are year
+                builder.val( metadata["date"][0,4], :name => "year" )
+              end
+
+              # Vol/issue/page.  Oddly, issue isn't used very strongly
+              # by ISI, but can't hurt. 
+              unless ( metadata['volume'].blank? )
+                builder.val(metadata['volume'], :name => 'vol')
+              end
+              unless ( metadata['issue'].blank? )
+                builder.val( metadata['issue'] , :name => 'issue')
+              end
+              unless ( metadata['spage'].blank? )
+                builder.val(metadata['spage'], :name => 'spage ')
+              end
+              
+            end
+          end          
+        end
+      end
+    end
+    return output
+  end
+
+  def do_lamr_request(xml)
+    uri = URI.parse(@api_url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true if (uri.scheme == 'https')
+
+    headers = {'Content-Type' => 'application/xml'}
+    
+    return http.post(uri.request_uri, xml, headers)
+  end
+
+  def add_responses(request, response_xml)
+
+    results = response_xml.at('map[@name ="cite_id"] map[@name="WOS"]')
+    unless (results)
+      error_message = "#{self.id}: "
+      error_message << 'Unexpected ISI response. The ISI response was not reported as an error, but did not contain a <map name="WOS"> inside a <map name="cite_id"> as we expected it to:'
+      error_message << "\n ISI XML request:\n#{gen_lamr_request(request)}\n"
+      error_message << "\n ISI http response status: #{isi_response.code}\n"
+      error_message << "\n ISI http response body:\n#{isi_response.body}\n"
+      Rails.logger.error(error_message)
+    end
+
+    
+    # cited by
+    count = results.at('val[@name="timesCited"]')
+    count = count ? count.inner_text.to_i : 0    
+    
+    cited_by_url = results.at('val[@name="citingArticlesURL"]')
+    cited_by_url = cited_by_url.inner_text if cited_by_url
+
+    if (@include_cited_by && count > 0 && cited_by_url )
+      label = ServiceTypeValue[:cited_by].display_name_pluralize.downcase.capitalize    
+      if count && count == 1
+        label = ServiceTypeValue[:cited_by].display_name.downcase.capitalize
+      end
+      
+      request.add_service_response(:service=>self, 
+        :display_text => "#{count} #{label}", 
+        :count=> count, 
+        :url => cited_by_url,
+        :debug_info => "url: " + cited_by_url,
+        :service_type_value => :cited_by)
+    end
+    
+    # similar
+    
+    similar_url = results.at('val[@name ="relatedRecordsURL"]')
+    similar_url = similar_url.inner_text if similar_url
+
+    if (@include_similar && similar_url )
+        request.add_service_response( :service=>self, 
+          :display_text => " #{ServiceTypeValue[:similar].display_name_pluralize.downcase.capitalize}", 
+          :url => similar_url,
+          :debug_info => "url: " + similar_url,
+          :service_type_value => :similar)
+    end
+    
+  end
+  
+end
+
+class IsiResponseException < StandardError
+  
+end