umlaut 3.0.5 → 3.1.0.pre1

data/app/controllers/open_search_controller.rb

@@ -1,9 +1,8 @@
 class OpenSearchController < UmlautController
-  
+
   layout false
-  
-  
+
   def index
     render(:content_type => "application/xml")
   end
-end
+end

data/app/controllers/resolve_controller.rb

@@ -1,53 +1,60 @@
 # Requests to the Resolve controller are OpenURLs.
 # There is one exception: Instead of an OpenURL, you can include the
 # parameter umlaut.request_id=[some id] to hook up to a pre-existing
-# umlaut request (that presumably was an OpenURL). 
-
+# umlaut request (that presumably was an OpenURL).
 class ResolveController < UmlautController
-  
-  
-  
-  
   before_filter :init_processing
+
   # Init processing will look at this list, and for actions mentioned,
   # will not create a @user_request if an existing one can't be found.
-  # Used for actions meant only to deal with existing requests. 
+  # Used for actions meant only to deal with existing requests.
   @@no_create_request_actions = ['background_update']
   after_filter :save_request
-  
-  layout :layout_name,  
-         :except => [:partial_html_sections]
-  
-  	
+
+  layout :resolve_layout, :except => [:partial_html_sections]
+
   def index
     self.service_dispatch()
-
     # check for menu skipping configuration. link is a ServiceResponse
     link = should_skip_menu
-    if ( ! link.nil? )                   
-      
+    if ( ! link.nil? )
       redirect_to url_for(:controller => "link_router",
                    :action => "index",
-                   :id => link.id )            
+                   :id => link.id )
     else
-      # Render configed view, if configed, or default view if not.             
+      # Render configed view, if configed, or default view if not.
       render umlaut_config.resolve_view
     end
+  end
+
+  # Return permalink for request, creating one if it doesn't already exist.
+  # Usually called by AJAX, to create on-demand permalink. 
+  def get_permalink
+    unless current_permalink_url
+      permalink = Permalink.new_with_values!(@user_request.referent, @user_request.referrer_id)            
+      @user_request.referent.permalinks << permalink
+    end
 
+    respond_to do |format|
+      format.html 
+      format.json do         
+        render :json => {:permalink => current_permalink_url}
+      end
+    end    
   end
 
   # inputs an OpenURL request into the system and stores it, but does
-  # NOT actually dispatch services to provide a response. Will usually 
+  # NOT actually dispatch services to provide a response. Will usually
   # be called by software, not a human browser. Sometimes
   # it's useful to do this as a first step before redirecting the user
   # to the actual resolve action for the supplied request--for instance,
-  # when the OpenURL metadata comes in a POST and can't be redirected. 
+  # when the OpenURL metadata comes in a POST and can't be redirected.
   def register_request
     # init before filter already took care of setting up the request.
     @user_request.save!
 
     # Return data in headers allowing client to redirect user
-    # to view actual response. 
+    # to view actual response.
     headers["x-umlaut-request_id"] = @user_request.id
     headers["x-umlaut-resolve_url"] = url_for( :controller => 'resolve', 'umlaut.request_id'.to_sym => @user_request.id )
     headers["x-umlaut-permalink_url"] = current_permalink_url()
@@ -62,26 +69,21 @@ class ResolveController < UmlautController
   # search/journals?umlaut.display_coins=true
   # or search/books?umlaut.display_coins=true
   def display_coins
-
   end
 
   # Display a non-javascript background service status page--or
   # redirect back to index if we're done.
   def background_status
-
     unless ( @user_request.any_services_in_progress? )
-      
       # Just redirect to ordinary index, no need to show progress status.
-      # Include request.id, but also context object kev. 
-      
-      params_hash = 
+      # Include request.id, but also context object kev.
+      params_hash =
          {:controller=>"resolve",
-          :action=>'index', 
+          :action=>'index',
           'umlaut.skip_resolve_menu'.to_sym => params['umlaut.skip_resolve_menu'],
           'umlaut.request_id'.to_sym => @user_request.id }
-      
+
       url = url_for_with_co( params_hash, @user_request.to_context_object )
-      
       redirect_to( url )
     else
       # If we fall through, we'll show the background_status view, a non-js
@@ -98,127 +100,97 @@ class ResolveController < UmlautController
   # discrete letter packets, a packet of HTML for each ServiceTypeValue?
   # This does that, and also let's the caller know if background
   # services are still running and should be refreshed, and gives
-  # the caller a URL to refresh from if neccesary.   
-  
+  # the caller a URL to refresh from if neccesary.
   def partial_html_sections
     # Tell our application_helper#url_for to generate urls with hostname
     @generate_urls_with_host = true
-
     # Force background status to be the spinner--default js way of putting
     # spinner in does not generally work through ajax techniques.
     @force_bg_progress_spinner = true
-
     # Mark that we're doing a partial generation, because it might
-    # matter later. 
+    # matter later.
     @generating_embed_partials = true
-        
-    # Run the request if neccesary. 
+    # Run the request if neccesary.
     self.service_dispatch()
     @user_request.save!
-
     self.api_render()
-    
   end
-  
-  def api
 
-    # Run the request if neccesary. 
+  def api
+    # Run the request if neccesary.
     self.service_dispatch()
     @user_request.save!
-
     api_render()
-    
-  end  
-
+  end
 
-    
-  def rescue_action_in_public(exception)  
-    render(:template => "error/resolve_error", :status => 500 ) 
-  end  
+  def rescue_action_in_public(exception)
+    render(:template => "error/resolve_error", :status => 500 )
+  end
 
   protected
-  
-  
-  # We intentionally use a method calculated at request-time for layout,
-  # so it can be changed in config at request-time. 
-  def layout_name
-    umlaut_config.resolve_layout
-  end
 
-    
-  # Retrives or sets up the relevant Umlaut Request, and returns it. 
+  # Retrives or sets up the relevant Umlaut Request, and returns it.
   def init_processing
     # intentionally trigger creation of session if it didn't already exist
     # because we need to track session ID for caching. Can't find any
     # way to force session creation without setting a value in session,
-    # so we do this weird one. 
+    # so we do this weird one.
     session[nil] = nil
-    
+
     # We have to clean the params of bad char encoding bytes, or it causes
     # no end of problems later. We can't just refuse to process, sources
-    # do send us bad bytes, I'm afraid. 
+    # do send us bad bytes, I'm afraid.
     params.values.each do |v|
       EnsureValidEncoding.ensure_valid_encoding!(v, :invalid => :replace)
     end
-    
-    # Create an UmlautRequest object. 
+    # Create an UmlautRequest object.
     options = {}
     if (  @@no_create_request_actions.include?(params[:action])  )
       options[:allow_create] = false
     end
     @user_request ||= Request.find_or_create(params, session, request, options )
-
     # If we chose not to create a request and still don't have one, bale out.
     return unless @user_request
-    
     @user_request.save!
-     
-    @collection = create_collection      
+    @collection = create_collection
   end
 
   def save_request
     @user_request.save!
   end
- 	
 
   # Based on app config and context, should we skip the resolve
   # menu and deliver a 'direct' link? Returns nil if menu
   # should be displayed, or the ServiceType join object
-  # that should be directly linked to. 
+  # that should be directly linked to.
   def should_skip_menu
     # From usabilty test, do NOT skip if coming from A-Z list/journal lookup.
     # First, is it over-ridden in url?
     if ( params['umlaut.skip_resolve_menu'] == 'false')
       return nil
-    elsif ( params['umlaut.skip_resolve_menu_for_type'] )      
+    elsif ( params['umlaut.skip_resolve_menu_for_type'] )
       skip = {:service_types => params['umlaut.skip_resolve_menu_for_type'].split(",") }
     end
-    
-    # Otherwise if not from url, load from app config
-    skip  ||= umlaut_config.skip_resolve_menu  if skip.nil?    
 
+    # Otherwise if not from url, load from app config
+    skip  ||= umlaut_config.skip_resolve_menu  if skip.nil?
     if (skip.kind_of?( FalseClass ))
       # nope
       return nil
     end
-
     return_value = nil
     if (skip.kind_of?(Hash) )
       # excluded rfr_ids?
       exclude_rfr_ids = skip[:excluded_rfr_ids]
-      rfr_id = @user_request.referrer_id  
+      rfr_id = @user_request.referrer_id
       return nil if exclude_rfr_ids != nil && exclude_rfr_ids.find {|i| i == rfr_id}
-
       # Services to skip for?
       skip[:service_types].each do | service |
-        service = ServiceTypeValue[service] unless service.kind_of?(ServiceTypeValue)  
-
-        candidates = 
-        @user_request.service_responses.find(:all, 
+        service = ServiceTypeValue[service] unless service.kind_of?(ServiceTypeValue)
+        candidates =
+        @user_request.service_responses.find(:all,
           :conditions => ["service_type_value_name = ?", service.name])
-        
-        return_value = candidates.first 
-        
+        return_value = candidates.first
       end
 
       # But wait, make sure it's included in :services if present.
@@ -227,40 +199,34 @@ class ResolveController < UmlautController
       end
     elsif (skip.kind_of?(Proc ))
       return_value = skip.call( :request => @user_request )
-      
     else
       logger.error( "Unexpected value in config 'skip_resolve_menu'; assuming false." )
     end
-    
-    return return_value;    
+    return return_value;
   end
 
-  
-
-
   # Uses an "umlaut.response_format" param to return either
   # XML or JSON(p).  Is called from an action that has a standardly rendered
   # Rails template that delivers XML.  Will convert that standardly rendered
-  # template output to json using built in converters if needed.  
-  def api_render    
+  # template output to json using built in converters if needed.
+  def api_render
     # Format?
     request.format = "xml" if request.format.html? # weird hack to support legacy behavior, with xml as default
     if params["umlaut.response_format"] == "jsonp"
       request.format = "json"
-      params["umlaut.jsonp"] ||= "umlautLoaded" 
+      params["umlaut.jsonp"] ||= "umlautLoaded"
     elsif params["umlaut.response_format"]
       request.format = params["umlaut.response_format"]
     end
-        
-    
+
     respond_to do |format|
-      format.xml do         
+      format.xml do
         render(:layout => false)
       end
-      
-      format.json do        
+
+      format.json do
         # get the xml in a string
-        xml_str = 
+        xml_str =
           with_format(:xml) do
             render_to_string(:layout=>false)
           end
@@ -271,19 +237,14 @@ class ResolveController < UmlautController
         data_as_hash = Hash.from_xml( xml_str.to_str )
         # And conver to json. Ta-da!
         json_str = data_as_hash.to_json
-  
         # Handle jsonp, deliver JSON inside a javascript function call,
-        # with function name specified in parameters. 
-        render(:json => json_str, :callback => params["umlaut.jsonp"] )      
-      end    
+        # with function name specified in parameters.
+        render(:json => json_str, :callback => params["umlaut.jsonp"] )
+      end
     end
   end
 
   def service_dispatch()
     @collection.dispatch_services!
   end
-
-
-  
-end
-
+end

data/app/controllers/resource_controller.rb

@@ -4,7 +4,7 @@
 #
 # It does NOT take URL in request parameters, but instead takes a response ID.
 # it will only proxy urls already stored in umlaut responses, so this is not
-# an open proxy with the security problems that would cause. 
+# an open proxy with the security problems that would cause.
 class ResourceController < UmlautController
   require 'open-uri'
 
@@ -13,9 +13,9 @@ class ResourceController < UmlautController
   # render :text=>proc, problem is we needed to know the content-type before
   # we read any of the response, which we didn't. This implementation holds
   # the whole image in memory for a second while it delivers it, oh well.
-  # doesn't seem to effect speed much, even though it's not optimal. 
+  # doesn't seem to effect speed much, even though it's not optimal.
   def proxy
-    svc_resp = ServiceResponse.find(params[:id])      
+    svc_resp = ServiceResponse.find(params[:id])
     url_str =  svc_resp.view_data[:url]
     uri = nil
     begin
@@ -27,17 +27,16 @@ class ResourceController < UmlautController
     proxied_headers = proxy_headers( request, uri.host )
     remote_response = open(uri, 'rb', proxied_headers)
 
-    # copy certain headers to our proxied response    
+    # copy certain headers to our proxied response
     ["Content-Type", "Cache-Control", "Expires", "Content-Length", "Last-Modified", "Etag", "Date"].each do |key|
       value = remote_response.meta[key.downcase] # for some reason open-uri lowercases em
-      # rack doens't like it if we set a nil value here. 
+      # rack doens't like it if we set a nil value here.
       response.headers[key] = value unless value.blank?
     end
     response.headers["X-Original-Url"] = url_str
-    
+
     # And send the actual result out
     render(:text => remote_response.read)
-    
   end
 
   protected
@@ -49,11 +48,8 @@ class ResourceController < UmlautController
   # TODO should refactor to DRY.
   # Argument here is a Rails Request
   def proxy_headers( request, host  )
-    orig_env = request.headers  
-  
+    orig_env = request.headers
     header = {}
-    
-  
     header["User-Agent"] = orig_env['HTTP_USER_AGENT'] || 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9) Gecko/2008061015 Firefox/3.0'
     header['Accept'] = orig_env['HTTP_ACCEPT'] || 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
     header['Accept-Language'] = orig_env['HTTP_ACCEPT_LANGUAGE'] || 'en-us,en;q=0.5'
@@ -61,25 +57,23 @@ class ResourceController < UmlautController
     header["Accept-Charset"] = orig_env['HTTP_ACCEPT_CHARSET'] || 'UTF-8,*'
 
     # Set referrer to be, well, an Umlaut page, like the one we are
-    # currently generating would be best. That is, the resolve link. 
-    
+    # currently generating would be best. That is, the resolve link.
     header["Referer"] = "http://#{orig_env['HTTP_HOST']}#{orig_env['REQUEST_URI']}"
 
-    # Proxy X-Forwarded headers. 
+    # Proxy X-Forwarded headers.
 
     # The original Client's ip, most important and honest. Look for
     # and add on to any existing x-forwarded-for, if neccesary, as per
-    # x-forwarded-for convention. 
+    # x-forwarded-for convention.
     header['X-Forwarded-For'] =  (orig_env['HTTP_X_FORWARDED_FOR']) ?
        (orig_env['HTTP_X_FORWARDED_FOR'].to_s + ', ' + request.remote_ip.to_s) :
        request.remote_ip.to_s
-       
-    #Theoretically the original host requested by the client in the Host HTTP request header. We're disembling a bit.  
+
+    #Theoretically the original host requested by the client in the Host HTTP request header. We're disembling a bit.
     header['X-Forwarded-Host'] = host if host
-    # The proxy server: That is, Umlaut, us. 
+    # The proxy server: That is, Umlaut, us.
     header['X-Forwarded-Server'] = orig_env['SERVER_NAME'] || ''
 
     return header
   end
-  
-end
+end

data/app/controllers/search_controller.rb

@@ -1,14 +1,15 @@
 # The search controller handles searches fo manually entered citations,
 # or possibly ambiguous citations generally. It also provides an A-Z list.
 #
-# As a source of this data, it generally talks to the SFX database directly. 
+# As a source of this data, it generally talks to the SFX database directly.
 # The particular method it uses to get this data is defined in a SearchMethod
 # module (app/controllers/search_methods), that gets applied to the controller.
-# Currently Sfx3 direct database or Sfx4 direct database are supported. In
-# either case with database connection info in your database.yml file under
-# sfx_db. 
-# 
-# Future plans include a local database of titles, perhaps loaded from an 
+# Currently Sfx4 direct database and Sfx4Solr (SFX indexed in Solr via Sunspot)
+# are supported.
+# In either case with database connection info in your database.yml file under
+# sfx_db.
+#
+# Future plans include a local database of titles, perhaps loaded from an
 # external KB. Not done yet.
 #
 # = SearchMethod module implementation
@@ -19,64 +20,59 @@
 #     #sfx_az_profile, #title_query_param, #search_type_param, #batch_size and
 #     #page to return state.  Returns a two-element array pair, first element
 #     is a list of OpenURL::ContextObject for current batch, send element
-#     is int total hit count. 
+#     is int total hit count.
 #   [#find_by_group]
 #     Used for clicks on "A", "B" ... "0-9", "Other" links.  Find the group
 #     link clicked on in params[:id].  Use #batch_size and #page for paging.
 #     As in #find_by_title, return two element array, first elememt is array
-#     of OpenURL::ContextObject, second element is total hit count. 
+#     of OpenURL::ContextObject, second element is total hit count.
 class SearchController < UmlautController
   @@search_batch_size = 20
   @@az_batch_size = 20
   @@autocomplete_limit = 15
-  
+
   layout :layout_name, :except => [ :opensearch, :opensearch_description ]
 
   before_filter :normalize_params
-  
+
   def initialize(*params)
     super(*params)
-    
-    self.extend( search_method_module  )
+    self.extend( search_method_module )
   end
-  
+
   def index
-    @page_title = "Journals"  
-    journals()          
-  end  
-  
+    @page_title = "Journals"
+    journals()
+  end
+
   def journals
     @submit_hash = params["umlaut.display_coins"] ? {:controller=>'resolve', :action=>'display_coins'} : {:controller=>'search', :action=>'journal_search'}
 
-    # Render configed view, if configed, or default     
+    # Render configed view, if configed, or default
     render umlaut_config.lookup!("search_view", "journals")
   end
 
-  # Not sure if this action actually works or does anything at present. 
+  # Not sure if this action actually works or does anything at present.
   def books
      @submit_action = params["umlaut.display_coins"] ? "display_coins" : "index"
   end
 
-  
   # @display_results is left as an array of ContextObject objects.
   # Or, redirect to resolve action for single hit.
   # O hit also redirects to resolve action, as per SFX behavior--this
-  # gives a catalog lookup and an ILL form for 0-hit. 
-  # param umlaut.title_search_type (aka sfx.title_search) 
+  # gives a catalog lookup and an ILL form for 0-hit.
+  # param umlaut.title_search_type (aka sfx.title_search)
   # can be 'begins', 'exact', or 'contains'. Other
   # form params should be OpenURL, generally
   def journal_search
     @batch_size = batch_size
     @start_result_num = (page * batch_size) - (batch_size - 1)
-    
     @search_context_object = context_object_from_params
-    
     if (! params["rft.object_id"].blank? ||
         ! params["rft.issn"].blank? ||
         ! params["rft_id"].blank? )
       # If we have an exact-type 'search', just switch to 'resolve' action
-      redirect_to url_for_with_co( {:controller => 'resolve'}, context_object_from_params ) 
-      
+      redirect_to url_for_with_co( {:controller => 'resolve'}, context_object_from_params )
       # don't do anything else.
       return
     elsif (params['rft.jtitle'].blank?)
@@ -86,56 +82,50 @@ class SearchController < UmlautController
       redirect_to :controller=>:search, :action=>:index
       return
     end
-    
-    
-    
+
     # Call our particular search method, #find_by_title added by search
-    # method module. 
+    # method module.
     (@display_results, @hits) = self.find_by_title
     #find_by_title_via_sfx_db
-    
+
     # Calculate end-result number for display
     @end_result_num = @start_result_num + batch_size - 1
     if @end_result_num > @hits
       @end_result_num = @hits
     end
-        
+
     if (@page == 1) && (@display_results.length == 1)
       # If we narrowed down to one result redirect
       # to resolve action.
-      redirect_to( url_for_with_co({:controller => 'resolve'}, @display_results[0]) )      
+      redirect_to( url_for_with_co({:controller => 'resolve'}, @display_results[0]) )
     elsif (@display_results.length == 0)
       # 0 hits, do it too.
       redirect_to(  url_for_with_co({:controller => 'resolve'}, @search_context_object) )
     end
-
+    @page_title = 'Journal titles that '
+    @page_title +=
+      (params["umlaut.title_search_type"] == "begins") ?
+        'begin with ' : 'contain '
+    @page_title += "'" + params['rft.jtitle'] + "'"
   end
 
-
-  # Used for browse-by-letter 
+  # Used for browse-by-letter
   def journal_list
     @batch_size = batch_size
-    @page = page         
+    @page = page
     @start_result_num = (@page * @batch_size) - (@batch_size - 1)
-
-
-    (@display_results, @hits) = find_by_group                         
-
-
+    (@display_results, @hits) = find_by_group
     # Calculate end-result number for display
     @end_result_num = @start_result_num + @batch_size - 1
     if @end_result_num > @hits
       @end_result_num = @hits
     end
-    
+    # TODO: Make page titles configurable
+    @page_title = "Browse by Journal Title: #{params['id']}"
     # Use our ordinary search displayer to display
     # It'll notice the action and do just a bit of special stuff.
     render(:template => "search/journal_search")
-  end  
-
-  
-  
-  
+  end
 
   # Should return an array of hashes, with each has having :title and :object_id
   # keys. Can come from local journal index or SFX or somewhere else.
@@ -145,35 +135,35 @@ class SearchController < UmlautController
    # Don't search on blank query.
    query = params['rft.jtitle']
    search_type = params["umlaut.title_search_type"] || "contains"
-   unless ( query.blank? )    
+   unless ( query.blank? )
       (context_objects, total_count) = find_by_title
-      @titles = context_objects.collect do |co| 
+      @titles = context_objects.collect do |co|
         metadata = co.referent.metadata
         {:object_id => metadata["object_id"], :title => (metadata["jtitle"] || metadata["btitle"] || metadata["title"])}
       end
    end
-   render :text => @titles.to_json, :content_type => "application/json"   
-  end  
-  
+   render :text => @titles.to_json, :content_type => "application/json"
+  end
+
   def opensearch_description
-    @headers['Content-Type'] = 'application/opensearchdescription+xml' 
+    @headers['Content-Type'] = 'application/opensearchdescription+xml'
   end
 
   protected
 
   # We intentionally use a method calculated at request-time for layout,
-  # so it can be changed in config at request-time. 
+  # so it can be changed in config at request-time.
   def layout_name
     umlaut_config.search_layout
   end
 
   def normalize_params
-    # citation search params  
-  
+    # citation search params
+
     # sfx.title_search and umlaut.title_search_type are synonyms
     params["sfx.title_search"] = params["umlaut.title_search_type"] if params["sfx.title_search"].blank?
     params["umlaut.title_search_type"] = params["sfx.title_search"] if params["umlaut.title_search_type"].blank?
-    
+
     # Likewise, params[:journal][:title] is legacy params['rft.jtitle']
     unless (params[:journal].blank? || params[:journal][:title].blank? ||
             ! params['rft.jtitle'].blank? )
@@ -186,11 +176,10 @@ class SearchController < UmlautController
       params[:journal][:title] = params['rft.jtitle']
     end
 
-    
     # Grab identifiers out of the way we've encoded em
     # Accept legacy SFX-style encodings too
     if ( ! params['rft_id_value'].blank? ||
-        ! params['pmid_value'].blank? || 
+        ! params['pmid_value'].blank? ||
         ! params['doi_value'].blank?  )
 
       if (! params['rft_id_value'].blank?)
@@ -203,15 +192,15 @@ class SearchController < UmlautController
         id_type = params['doi_id'] || 'doi'
         id_value = params['doi_value']
       end
-              
+
       params['rft_id'] = "info:#{id_type}/#{id_value}"
     end
 
     # SFX v2 A-Z list url format---convert to Umlaut
     if params[:letter_group]
-      params[:id] = case params[:letter_group].to_i        
+      params[:id] = case params[:letter_group].to_i
         when 1 then '0-9'
-        # 2-27 mean A-Z, convert via ASCII value arithmetic.  
+        # 2-27 mean A-Z, convert via ASCII value arithmetic.
         when 2..27 then ((params[:letter_group].to_i) +63 ).chr
         when 28 then 'Others'
       end
@@ -224,21 +213,21 @@ class SearchController < UmlautController
         when /^0/ then '0-9'
         when 'Others' then 'Other'
         else params[:param_letter_group_value]
-      end          
+      end
     end
 
     # Normalize request for 'Others'
-    if params[:id] =~ /^other/i 
+    if params[:id] =~ /^other/i
        params[:id] = 'Others'
     end
-    
+
     # for reasons I can't tell, our JS on IE ends up putting some
     # newlines in the object_id, which messes us all up.
     params['rft.object_id'].strip! if params['rft.object_id']
 
     ## If needed combine date elements to an OpenURL date
-    unless (params["__year"].blank? && 
-            params["__month"].blank? && 
+    unless (params["__year"].blank? &&
+            params["__month"].blank? &&
             params["__day"].blank?)
       isoDate = ""
       unless ["", "****", "Year"].include?(params["__year"])
@@ -254,35 +243,34 @@ class SearchController < UmlautController
         params["date"] = isoDate
       end
     end
-
   end
 
   def context_object_from_params
-    @context_object_from_params ||= 
+    @context_object_from_params ||=
       begin
-      params_c = params.clone  
-  
+      params_c = params.clone
+
       # Take out the weird ones that aren't really part of the OpenURL
       ignored_keys = [:journal, "utf8", "__year", "__month", "__day", "action", "controller", "Generate_OpenURL2", "rft_id_type", "rft_id_value"]
       ignored_keys.each { |k| params_c.delete(k) }
-      
+
       # Normalize ISSN to have dash
       if ( ! params['rft.issn'].blank? && params['rft.issn'][4,1] != '-' && params['rft.issn'].length >= 4)
         params['rft.issn'].insert(4,'-')
       end
-    
+
       ctx = OpenURL::ContextObject.new
       # Make sure it uses a journal type referent please, that's what we've
       # got here.
       ctx.referent = OpenURL::ContextObjectEntity.new_from_format( 'info:ofi/fmt:xml:xsd:journal' )
       ctx.import_hash( params_c )
-  
+
       # Not sure where ":rft_id_value" as opposed to 'rft_id' comes from, but
       # it was in old code. We do it after CO creation to handle multiple
       # identifiers
       if (! params_c[:rft_id_value].blank?)
         ctx.referent.add_identifier( params_c[:rft_id_value] )
-      end              
+      end
       ctx
     end
   end
@@ -290,28 +278,28 @@ class SearchController < UmlautController
   def search_method_module
     umlaut_config.lookup!("search.az_search_method", SearchMethods::Sfx4)
   end
-  
+
   # sfx a-z profile as defined in config, used for direct db connections
-  # to sfx. 
+  # to sfx.
   def sfx_az_profile
     umlaut_config.lookup!("search.sfx_az_profile", "default")
   end
   helper_method :sfx_az_profile
-  
-  def title_query_param    
+
+  def title_query_param
     params['rft.jtitle']
   end
   helper_method :title_query_param
-  
+
   def search_type_param
     params['umlaut.title_search_type'] || 'contains'
   end
   helper_method :search_type_param
-  
+
   def batch_size
     case params[:action]
       when "journal_list"
-        @@az_batch_size      
+        @@az_batch_size
       when "auto_complete_for_journal_title"
         @@autocomplete_limit
       else
@@ -319,16 +307,9 @@ class SearchController < UmlautController
     end
   end
   helper_method :batch_size
-  
+
   def page
-    @page ||= params['page'].blank? ? 1 : params['page'].to_i     
+    @page ||= params['page'].blank? ? 1 : params['page'].to_i
   end
-  helper_method :page    
-
-
- 
-
-
-
- 
-end
+  helper_method :page
+end