umlaut 3.0.0alpha1

data/app/controllers/search_methods/sfx4.rb

@@ -0,0 +1,257 @@
+require 'nokogiri'
+
+module SearchMethods
+  module Sfx4
+    include MetadataHelper # for normalize_lccn
+    
+    protected
+    
+    # used by umlaut:load_sfx_urls task. Kind of hacky way of trying to extract
+    # target URLs from SFX4. 
+    def self.fetch_sfx_urls(sfx_global_db = "sfxglb41")      
+      connection = SfxDb::Object.connection
+
+      # Crazy crazy URLs to try to find PARSE_PARAMS in Sfx4 db that have a period in
+      # them, so they look like they might be URLs. Parse params could be at target service
+      # level, or at portfolio level; and could be in local overrides or in global kb. 
+      # This is crazy crazy SQL to get this, sorry. Talking directly to SFX db isn't
+      # a great idea, but best way we've found to get this for now. Might make more
+      # sense to try to use the (very very slow) SFX export in the future instead. 
+      sql = %{
+        SELECT 
+          COALESCE(LCL_SERVICE_LINKING_INFO.PARSE_PARAM,KB_TARGET_SERVICES.PARSE_PARAM) PARSE_PARAM
+        FROM
+          LCL_TARGET_INVENTORY		  	  
+        JOIN #{sfx_global_db}.KB_TARGET_SERVICES
+		  		ON KB_TARGET_SERVICES.TARGET_ID = LCL_TARGET_INVENTORY.TARGET_ID
+		  	JOIN LCL_SERVICE_INVENTORY 
+		  		ON LCL_TARGET_INVENTORY.TARGET_ID = LCL_SERVICE_INVENTORY.TARGET_ID
+		  	LEFT OUTER JOIN LCL_SERVICE_LINKING_INFO
+				  ON 	LCL_SERVICE_INVENTORY.TARGET_SERVICE_ID =	LCL_SERVICE_LINKING_INFO.TARGET_SERVICE_ID
+				WHERE
+				  ( LCL_SERVICE_LINKING_INFO.PARSE_PARAM like '%.%' OR
+				    KB_TARGET_SERVICES.PARSE_PARAM like '%.%' )
+				 AND
+				  LCL_SERVICE_INVENTORY.ACTIVATION_STATUS='ACTIVE'	     
+				 AND
+				  LCL_TARGET_INVENTORY.ACTIVATION_STATUS = 'ACTIVE'		 
+				  
+		 UNION
+		     -- object portfolio parse param version
+		   		   SELECT
+		     COALESCE(LCL_OBJECT_PORTFOLIO_LINKING_INFO.PARSE_PARAM, KB_OBJECT_PORTFOLIOS.PARSE_PARAM) PARSE_PARAM
+		   FROM
+		     #{sfx_global_db}.KB_OBJECT_PORTFOLIOS
+		   JOIN LCL_SERVICE_INVENTORY
+        ON KB_OBJECT_PORTFOLIOS.TARGET_SERVICE_ID = LCL_SERVICE_INVENTORY.TARGET_SERVICE_ID
+	     JOIN LCL_OBJECT_PORTFOLIO_INVENTORY
+	      ON KB_OBJECT_PORTFOLIOS.OP_ID = LCL_OBJECT_PORTFOLIO_INVENTORY.OP_ID
+       left outer join  LCL_OBJECT_PORTFOLIO_LINKING_INFO
+        ON KB_OBJECT_PORTFOLIOS.OP_ID = LCL_OBJECT_PORTFOLIO_LINKING_INFO.OP_ID        
+		   WHERE
+		    ( KB_OBJECT_PORTFOLIOS.PARSE_PARAM like '%.%' OR 
+          LCL_OBJECT_PORTFOLIO_LINKING_INFO.PARSE_PARAM like '%.%' )
+        AND LCL_OBJECT_PORTFOLIO_INVENTORY.ACTIVATION_STATUS = 'ACTIVE'        
+        AND LCL_SERVICE_INVENTORY.ACTIVATION_STATUS='ACTIVE'
+      }
+      
+      results =  connection.select_all(sql)
+      
+      urls = []
+      results.each do |line|
+        param_string = line["PARSE_PARAM"]
+        
+        # Try to get things that look sort of like URLs out. Brutal force,
+        # sorry. 
+        url_re = Regexp.new('(https?://\S+\.\S+)(\s|$)')
+        urls.concat( param_string.scan( url_re ).collect {|matches| matches[0]} )                
+      end      
+      urls.uniq!
+      return urls
+    end
+    
+    
+    # Needs to return ContextObjects
+    def find_by_title                  
+      connection = sfx4_db_connection
+  
+        
+      query_match_clause = case search_type_param
+        when "contains"
+          terms = title_query_param.split(" ")
+          #SFX4 seems to ignore 'the' or 'a' on the front, so we will too. 
+          if (["the", "a"].include? terms[0])
+            terms = terms.slice(1..-1)
+          end
+          # Then make each term required, but stemmed. Seems to match SFX4, 
+          # and more importantly give us decent results. 
+          query = terms.collect do |term|
+            "+" + connection.quote_string(term) + "*"
+          end.join(" ")
+          
+          "MATCH (TS.TITLE_SEARCH) AGAINST ('#{query}' IN BOOLEAN MODE)"
+        when "begins"
+          # For 'begins', searching against TITLE itself rather than TITLE_SEARCH gives us 
+          # results more like SFX4 native, without so many 'also known as' titles confusing
+          # things.           
+          "(T.TITLE_DISPLAY LIKE '#{connection.quote_string(title_query_param)}%' OR T.TITLE_SORT LIKE '#{connection.quote_string(title_query_param)}%')"
+          #"TS.TITLE_SEARCH LIKE '#{connection.quote_string(title_query_param)}%'"
+        else # exact
+          "( TS.TITLE_SEARCH = '#{connection.quote_string(title_query_param)}' OR 
+             T.TITLE_DISPLAY = '#{connection.quote_string(title_query_param)}' OR
+             T.TITLE_SORT = '#{connection.quote_string(title_query_param)}'
+           )"                        
+        end.upcase
+        
+      from_where_clause = %{
+        FROM 
+          AZ_TITLE T, AZ_TITLE_SEARCH TS 
+        WHERE 
+          TS.AZ_TITLE_ID = T.AZ_TITLE_ID AND 
+          #{query_match_clause} AND 
+          T.AZ_PROFILE = '#{connection.quote_string(sfx_az_profile)}'       
+      } 
+      
+      statement = %{
+        SELECT 
+          DISTINCT T.OBJECT_ID 
+        #{from_where_clause}
+        ORDER BY 
+          T.SCRIPT DESC, T.TITLE_SORT
+        LIMIT #{batch_size.to_i}
+        OFFSET #{(batch_size * (page - 1)).to_i}
+        }
+
+      # do the count  
+      total_hits = SfxDb::Object.count_by_sql(
+          "SELECT COUNT(DISTINCT(T.OBJECT_ID)) #{from_where_clause}"
+      )
+      
+      object_ids = connection.select_all(statement).collect {|i| i.values.first}
+                  
+      sql = SfxDb::Object.send(:sanitize_sql_array,
+        [%{
+           SELECT 
+              EI.OBJECT_ID, T.TITLE_DISPLAY, EI.EXTRA_INFO_XML 
+           FROM 
+              AZ_TITLE T 
+              JOIN AZ_EXTRA_INFO EI 
+                ON (EI.OBJECT_ID = T.OBJECT_ID AND EI.AZ_PROFILE = T.AZ_PROFILE)
+           WHERE
+              T.AZ_PROFILE=?
+              AND EI.OBJECT_ID IN (?)
+           ORDER BY 
+              T.SCRIPT DESC, T.TITLE_SORT
+          }, 
+          sfx_az_profile, 
+          object_ids])
+      
+      title_objects =  connection.select_all(sql)
+            
+      # Make em into context objects
+      context_objects = title_objects.collect do |sfx_obj|
+        ctx = OpenURL::ContextObject.new
+        # Start out wtih everything in search, to preserve date/vol/etc
+        ctx.import_context_object( context_object_from_params )        
+        
+        extra_info_xml = Nokogiri::XML( sfx_obj["EXTRA_INFO_XML"] )
+        
+        # Put SFX object id in rft.object_id, that's what SFX does. 
+        ctx.referent.set_metadata('object_id', sfx_obj["OBJECT_ID"])
+        ctx.referent.set_metadata("jtitle", sfx_obj["TITLE_DISPLAY"] || "Unknown Title")
+        
+        issn = extra_info_xml.search("item[key=issn]").text
+        isbn =  extra_info_xml.search("item[key=isbn]").text
+        lccn = extra_info_xml.search("item[key=lccn]").text
+        
+        ctx.referent.set_metadata("issn", issn ) unless issn.blank?
+        ctx.referent.set_metadata("isbn", isbn) unless isbn.blank?
+        ctx.referent.add_identifier("info:lccn/#{normalize_lccn(lccn)}") unless lccn.blank?      
+        
+        ctx
+      end
+      return [context_objects, total_hits]
+    end
+    
+    # Used for clicks on A, B, C, 0-9, etc. 
+    def find_by_group
+      connection = sfx4_db_connection
+      from_where_clause = %{
+           FROM 
+              AZ_TITLE T 
+              JOIN AZ_EXTRA_INFO EI 
+                ON (EI.OBJECT_ID = T.OBJECT_ID AND EI.AZ_PROFILE = T.AZ_PROFILE)
+              JOIN AZ_LETTER_GROUP 
+                ON (T.AZ_TITLE_ID = AZ_LETTER_GROUP.AZ_TITLE_ID) 
+           WHERE
+              T.AZ_PROFILE= '#{connection.quote_string(sfx_az_profile)}'          
+              AND #{sfx4_quoted_letter_group_condition}
+          }
+      count_sql = %{
+        SELECT count(*)
+        
+        #{from_where_clause}
+      }
+      
+      fetch_sql = %{
+           SELECT 
+              EI.OBJECT_ID, T.TITLE_DISPLAY, EI.EXTRA_INFO_XML
+              
+            #{from_where_clause}
+            
+           ORDER BY 
+             T.SCRIPT DESC, T.TITLE_SORT
+           LIMIT #{batch_size.to_i}
+           OFFSET #{(batch_size * (page - 1)).to_i}      
+      }
+          
+      total_count = SfxDb::Object.count_by_sql( count_sql )
+      context_objects = sfx4_db_to_ctxobj( connection.select_all(fetch_sql) )
+
+      return [context_objects, total_count]
+    end
+    
+    def sfx4_db_connection
+      SfxDb::Object.connection
+    end
+    
+    def sfx4_quoted_letter_group_condition
+      " AZ_LETTER_GROUP.AZ_LETTER_GROUP_NAME " +
+      case params[:id]
+      when "0-9"
+        " IN ('0','1','2','3','4','5','6','7','8','9')"
+      when /^Other/i
+        "= 'Others'"
+      else
+        "= '#{sfx4_db_connection.quote_string(params[:id].upcase)}'"
+      end
+    end
+    
+    def sfx4_db_to_ctxobj(title_rows)
+      title_rows.collect do |sfx_obj|
+        ctx = OpenURL::ContextObject.new
+        # Start out wtih everything in search, to preserve date/vol/etc
+        ctx.import_context_object( context_object_from_params )        
+        
+        extra_info_xml = Nokogiri::XML( sfx_obj["EXTRA_INFO_XML"] )
+        
+        # Put SFX object id in rft.object_id, that's what SFX does. 
+        ctx.referent.set_metadata('object_id', sfx_obj["OBJECT_ID"])
+        ctx.referent.set_metadata("jtitle", sfx_obj["TITLE_DISPLAY"] || "Unknown Title")
+        
+        issn = extra_info_xml.search("item[key=issn]").text
+        isbn =  extra_info_xml.search("item[key=isbn]").text
+        lccn = extra_info_xml.search("item[key=lccn]").text
+        
+        ctx.referent.set_metadata("issn", issn ) unless issn.blank?
+        ctx.referent.set_metadata("isbn", isbn) unless isbn.blank?
+        ctx.referent.add_identifier("info:lccn/#{normalize_lccn(lccn)}") unless lccn.blank?      
+        
+        ctx
+      end
+      
+    end
+    
+  end
+end
+

data/app/controllers/search_methods/sfx_api.rb

@@ -0,0 +1,47 @@
+module SearchMethods
+  
+  # NON-WORKING sketch of a search method that contacts SFX api directly.
+  # Problem with this was that SFX is way too slow; SFX api didn't take
+  # account of year/volume/issue when displaying multiple results anwyay,
+  # so there wasn't that functionality benefit. It just wasn't worth it. 
+  #
+  # This code is basically copied and pasted from before the refactor,
+  # it's not close to working yet, but is left for archival purposes
+  # in case anyone wants to take a stab at it. 
+  module SfxApi
+    
+    def find_by_title
+        ctx = context_object_from_params
+        search_results = []
+  
+        sfx_url = umlaut_config.sfx_base_url
+        unless (sfx_url)      
+          # try to guess it from our institutions
+          instutitions = Institution.find_all_by_default_institution(true)
+          instutitions.each { |i| i.services.each { |s| 
+             sfx_url = s.base_url if s.kind_of?(Sfx) }}      
+        end
+              
+        transport = OpenURL::Transport.new(sfx_url, ctx)
+        transport.extra_args["sfx.title_search"] = params["sfx.title_search"]
+        transport.extra_args["sfx.response_type"] = 'multi_obj_xml'
+  
+        
+        transport.transport_inline
+        
+        doc = REXML::Document.new transport.response
+        
+        #client = SfxClient.new(ctx, resolver)
+        
+        doc.elements.each('ctx_obj_set/ctx_obj') { | ctx_obj | 
+          ctx_attr = ctx_obj.elements['ctx_obj_attributes']
+          next unless ctx_attr and ctx_attr.has_text?
+          
+          perl_data = ctx_attr.get_text.value
+          search_results << Sfx.parse_perl_data( perl_data )
+        } 
+        return [search_results, doc.elements.length]     
+    end
+
+  end
+end

data/app/controllers/store_controller.rb

@@ -0,0 +1,64 @@
+class StoreController < UmlautController
+  #require 'open_url'
+  require 'openurl'
+  def index
+    
+    perm = Permalink.find(:first, :conditions => { :id => params[:id]})
+    co = OpenURL::ContextObject.new
+
+    # We might have a link to a Referent in our db, or we might
+    # instead have to rely on an XML serialized ContextObject in
+    # the permalink, if the Referent has been purged. Either way
+    # we're good. 
+    referent = nil
+    if ( perm && perm.referent)
+      referent = perm.referent
+    elsif (perm && perm.context_obj_serialized)
+      stored_co = perm.restore_context_object
+
+      # And a referrent, no referrer for now, we'll restore it later. 
+      referent = Referent.create_by_context_object( stored_co, nil, :permalink => false )
+      perm.referent = referent
+      perm.save!
+    end
+    
+
+    unless ( referent )
+      # We can't find a referent or succesfully restore an xml context
+      # object to send the user to the request. We can not resolve
+      # this permalink!
+      
+      raise NotFound.new("Permalink request could not be resolved. Returning 404. Permalink id: #{params[:id]}")            
+    end
+    
+    # Whether it was an already existing one, or a newly created one
+    # turn it back to a co so we can add a few more things. 
+    co.import_context_object(referent.to_context_object)
+    
+    # We preserve original referrer. Even though this isn't entirely accurate
+    # this is neccesary to get SFX to handle it properly when we call to SFX,
+    # including handling source-specific private data, etc. 
+    co.referrer.add_identifier( perm.orig_rfr_id ) if perm.orig_rfr_id
+
+    # Let's add any supplementary umlaut params passed to us
+    # Everything except the 'id' which we used for the Rails action. 
+    new_params = params.clone
+    new_params.delete(:id)
+    # and add in our new action
+    new_params[:controller] = 'resolve'
+    new_params[:action] = 'index'
+    # Plus let's tell it about the referent, to make sure we get a referent
+    # match even though we've changed the rfr_id etc.
+    new_params[:'umlaut.referent_id'] = referent.id
+
+    # Generate a Rails URL, then add on the KEV for our CO on the end
+    # You might think you can just merge these into a hash and use url_for,
+    # but Rails redirect_to/url_for isn't happy with multiple query params
+    # with same name.
+
+    redirect_to( url_for_with_co( new_params, co) )
+  end
+  
+  class NotFound < Exception ; end
+  
+end

data/app/controllers/umlaut/controller_behavior.rb

@@ -0,0 +1,20 @@
+# All behavior from UmlautController is extracted into this module,
+# so that we can generate a local UmlautController that includes
+# this module, and local app can configure or over-ride default behavior. 
+# 
+module Umlaut::ControllerBehavior
+  extend ActiveSupport::Concern
+  
+  include UmlautConfigurable
+  include Umlaut::ErrorHandling
+  include Umlaut::ControllerLogic
+  
+  included do |controller|
+    controller.helper Umlaut::Helper # global umlaut view helpers
+    
+    # init default configuration values
+    UmlautConfigurable.set_default_configuration!(controller.umlaut_config)
+  end
+  
+  
+end

data/app/controllers/umlaut/controller_logic.rb

@@ -0,0 +1,96 @@
+# Some standard logic needed accross Umlaut controllers, 
+# module included in UmlautController superclass so it'll be avail
+# to all controllers. Also exposes most of these methods as helpers so
+# they'll be avail in views as well as controllers. 
+module Umlaut::ControllerLogic
+  extend ActiveSupport::Concern
+  
+  included do
+      helper_method :escape_xml, :url_for_with_co, :permalink_url, :with_format
+  end
+  
+  protected
+  
+  # Just replaces <, >, &, ', and " so you can include arbitrary text
+  # as an xml payload. I think those three chars are all you need for
+  # an xml escape. Weird this isn't built into Rails, huh?
+  def escape_xml(string)    
+    string.gsub(/[&<>\'\"]/) do | match |
+     case match
+       when '&' then '&amp;'
+       when '<' then '&lt;'
+       when '>' then '&gt;'
+       when '"' then '&quot;'
+       when "'" then '&apos;'
+     end
+    end   
+  end
+    
+  # Pass in a hash of Rails params, plus a context object.
+  # Get back a url suitable for calling those params in your
+  # rails app, with the kev OpenURL context object tacked on
+  # the end. This is neccesary instead of the naive hash
+  # merge approach we were previously using, because
+  # of possibility of multiple openurl kev query params
+  # with same name.
+  def url_for_with_co(params, context_object)
+    url = url_for(params)
+    if (url.include?('?'))
+      url += '&'
+    else
+      url += '?'
+    end
+              
+    url += context_object.kev   
+
+    return url
+  end
+  
+  # if it's an xml-http-request, and we're redirecting to ourselves...
+  # afraid we're going to lost the X-Requested-With header on redirect,
+  # messing up our Rails code. Add it as a query param, sorry weird
+  # workaround.
+  def params_preserve_xhr(my_params = params)
+    if request.xml_http_request?                  
+        my_params = my_params.clone
+        my_params["X-Requested-With"] = "XmlHttpRequest"
+    end
+    my_params
+  end
+  
+  
+  # helper method we need available in controllers too
+  # Absolute URL for permalink for given request.
+  # Have to supply rails request and umlaut request.  
+  def permalink_url(rails_request, umlaut_request, options = {})
+    # if we don't have everything, we can't make a permalink. 
+    unless (umlaut_request && umlaut_request.referent &&
+            umlaut_request.referent.permalinks &&
+            umlaut_request.referent.permalinks[0] )
+
+            return nil
+    end
+    
+    return url_for(options.merge({:controller=>"store",    
+        :id=>umlaut_request.referent.permalinks[0].id,
+    :only_path => false}) )
+        
+  end
+  
+  # Let you render templates or partials in a different format
+  # than current request format. 
+  #     with_format("xml") do
+  #        render 
+  #     end
+  def with_format(format, &block)
+    old_formats = formats
+    begin
+      self.formats = [format]
+      return block.call
+    ensure
+      self.formats = old_formats
+    end
+  end
+  
+  
+end