umlaut 3.0.0alpha1

data/app/controllers/application_controller.rb

@@ -0,0 +1,14 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base  
+  
+
+  protect_from_forgery
+  
+   
+  
+     
+end
+
+ 

data/app/controllers/export_email_controller.rb

@@ -0,0 +1,123 @@
+class ExportEmailController < UmlautController
+  
+  before_filter :load_objects
+  layout Proc.new { |controller|         
+     if (controller.request.xhr? ||
+         controller.params["X-Requested-With"] == "XmlHttpRequest")
+       nil
+     else
+       config.layout
+     end
+  }
+
+  def load_objects
+    @svc_response = ServiceResponse.find(params[:id])
+    @user_request = @svc_response.request if @svc_response
+  end
+  
+  def email    
+
+  end 
+  
+  def txt    
+
+  end
+    
+  def send_email
+    @email = params[:email]
+    @fulltexts = @user_request.get_service_type('fulltext', { :refresh=>true })
+    @holdings = @user_request.get_service_type('holding', { :refresh=>true })
+    
+      if valid_email?
+        Emailer.citation(@email, @user_request, @fulltexts, @holdings).deliver 
+        respond_to do |format|
+          format.html {  render }
+        end
+      else
+        @partial = "email"
+        flash[:error] = email_validation_error
+        redirect_to params_preserve_xhr(params.merge(:action => "email"))        
+      end
+    
+  end
+  
+  def send_txt
+    @number = params[:number]
+    # Remove any punctuation or spaces etc
+    @number.gsub!(/[^\d]/, '') if @number
+
+    
+    @provider = params[:provider]
+    
+    @email = "#{@number}@#{@provider}" unless @number.nil? or @provider.nil?
+
+    @holding_id = params[:holding]
+    
+      if valid_txt_number? && valid_txt_holding?
+        Emailer.short_citation(@email, @user_request, location(@holding_id), call_number(@holding_id)).deliver 
+
+        render # send_txt.rhtml       
+      else        
+        flash[:error] = txt_validation_error        
+        redirect_to params_preserve_xhr(params.merge(:action => "txt"))
+      end    
+  end
+  
+  private
+    def valid_txt_number?
+      return (! @number.blank?) && @number.length == 10
+    end
+
+    def valid_txt_holding?
+       return ! @holding_id.blank?
+    end
+    
+    def valid_email?
+      return @email =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
+    end
+    
+  
+  def txt_validation_error
+    rv = ""
+    unless valid_txt_number? && valid_txt_holding?
+      rv += "<div class=\"validation_errors\">"
+      rv += "<span>Please provide the following:</span>"
+      rv += "<ul>"
+      rv += "<li>a valid number</li>" unless valid_txt_number?
+      rv += "<li>the item you wish to send</li>" unless valid_txt_holding?
+      rv += "</ul>"
+      rv += "</div>"
+    end
+    return rv
+  end
+  
+  def email_validation_error
+    rv = ""
+    unless valid_email?
+      rv += "<div class=\"validation_errors\">"
+      rv += "<span>Please provide the following:</span>"
+      rv += "<ul>"
+      rv += "<li>a valid email address</li>"
+      rv += "</ul>"
+      rv += "</div>"
+    end
+    return rv
+  end
+
+  def holding(id)
+    return ServiceResponse.find(id) unless id.nil?
+  end
+  
+  def location(id)
+    return holding(id).view_data[:collection_str] unless holding(id).nil?
+  end
+    
+  def call_number(id)
+    return holding(id).view_data[:call_number] unless holding(id).nil?
+  end
+
+
+
+
+ 
+end

data/app/controllers/js_helper_controller.rb

@@ -0,0 +1,10 @@
+# Controller that just has one helper action for external sites using
+# our Javascript HTML updater stuff. 
+class JsHelperController < UmlautController
+
+  def loader
+    @generate_urls_with_host = true
+    render :template => "js_helper/loader.erb.js"
+  end
+  
+end

data/app/controllers/link_router_controller.rb

@@ -0,0 +1,87 @@
+# All clicks on a ServiceResponse are actually sent through this controller,
+# which redirects to actual destination. That allows statistic logging,
+# as well as special behavior (like EZProxy redirection, or showing in a
+# bannered frameset). 
+require 'cgi'
+class LinkRouterController < UmlautController
+  def index
+
+    # Capture mysterious exception for better error reporting. 
+    begin
+      svc_response = ServiceResponse.find(params[:id])
+    rescue ActiveRecord::RecordNotFound => exception 
+      # Usually this happens when it's a spider trying an old link. "go" links
+      # don't stay good forever! Bad spider, ignoring our robots.txt.
+      log_error_with_context(exception, :warn)      
+
+      raise exception# will be caught by top level rescue_from            
+    end
+
+
+    @collection = self.create_collection         
+
+    clickthrough = Clickthrough.new
+    clickthrough.request_id = svc_response.request_id
+    clickthrough.service_response_id = svc_response.id
+    clickthrough.save
+
+
+    redirect_to calculate_url_for_response(svc_response)
+  end
+  
+  protected
+  
+  # Must return a Hash where each key is a unique service name, and
+  # each value a hash that defines a service. Like the hash in services.yml
+  # under default/services.  By default, this method in fact just loads
+  # and returns that hash, but can be over-ridden with local logic for
+  # determining proper list of services for current request.
+  #
+  # Local over-ride could even in theory return a custom subclass of Collection, 
+  # with customized dispatch behavior. Probably not a great idea though.  
+  def create_collection    
+    # trim out ones with disabled:true
+    services = ServiceStore.config["default"]["services"].reject {|id, hash| hash["disabled"] == true}
+            
+    return Collection.new(@user_request, services)
+  end
+  
+  
+  # Used to calculate a destination/target url for an Umlaut response item.
+  #
+  # Pass in a ServiceType join object (not actually a ServiceResponse, sorry)
+  # Calculates the URL for it, and then runs our link_out_filters on it,
+  # returning the final calculated url. 
+  #
+  # Also requires a rails 'params' object, since url calculation sometimes
+  # depends on submitted HTTP params.
+  #
+  # Used from LinkController's index,
+  def calculate_url_for_response(svc_response)
+      svc = ServiceStore.instantiate_service!(svc_response.service_id, nil)
+      
+      destination =  svc.response_url(svc_response, params)
+
+      # if response_url returned a string, it's an external url and we're
+      # done. If it's something else, usually a hash, then pass it to
+      # url_for to generate a url.
+      if destination.kind_of?(String)
+        url = destination
+
+        # Call link_out_filters, if neccesary.
+        # These are services listed as  task: link_out_filter  in services.yml
+        (1..9).each do |priority|
+          @collection.link_out_service_level( priority ).each do |filter|
+            filtered_url = filter.link_out_filter(url, svc_response)
+            url = filtered_url if filtered_url
+          end
+        end
+        return url
+      else        
+        return url_for(params_preserve_xhr(destination))
+      end
+  end
+
+  
+   
+end

data/app/controllers/open_search_controller.rb

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

data/app/controllers/resolve_controller.rb

@@ -0,0 +1,288 @@
+# 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). 
+
+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. 
+  @@no_create_request_actions = ['background_update']
+  after_filter :save_request
+  
+  # Take layout from config, default to resolve_basic.rhtml layout. 
+  layout umlaut_config.resolve_layout,  
+         :except => [:partial_html_sections]
+  
+  	
+  def index
+    self.service_dispatch()
+
+    # check for menu skipping configuration. link is a ServiceType object
+    link = should_skip_menu
+    if ( ! link.nil? )                   
+      
+      redirect_to url_for(:controller => "link_router",
+                   :action => "index",
+                   :id => link.id )            
+    else
+      # Render configed view, if configed, or default view if not.             
+      render umlaut_config.resolve_view
+    end
+
+  end
+
+  # inputs an OpenURL request into the system and stores it, but does
+  # 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. 
+  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. 
+    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"] = permalink_url( request, @user_request )
+
+    # Return empty body. Once we have the xml response done,
+    # this really ought to return an xml response, but with
+    # no service responses yet available.
+    render(:nothing => true)
+  end
+
+  # Useful for developers, generate a coins. Start from
+  # 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 = 
+         {:controller=>"resolve",
+          :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
+      # meta-refresh update on progress of background services.
+      # Your layout should respect this instance var--it will if it uses
+      # the resolve_head_content partial, which it should.
+      @meta_refresh_self = umlaut_config.lookup!("poll_wait_seconds", 4)
+    end
+  end
+
+  # This action is for external callers. An external caller _could_ get
+  # data as xml or json or whatever. But Umlaut already knows how to render
+  # it. What if the external caller wants the rendered content, but in
+  # 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.   
+  
+  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. 
+    @generating_embed_partials = true
+        
+    # Run the request if neccesary. 
+    self.service_dispatch()
+    @user_request.save!
+
+    self.api_render()
+    
+  end
+  
+  def api
+
+    # Run the request if neccesary. 
+    self.service_dispatch()
+    @user_request.save!
+
+    api_render()
+    
+  end  
+
+
+    
+  def rescue_action_in_public(exception)  
+    render(:template => "error/resolve_error", :status => 500 ) 
+  end  
+
+  protected
+  
+  
+  # Must return a Hash where each key is a unique service name, and
+  # each value a hash that defines a service. Like the hash in services.yml
+  # under default/services.  By default, this method in fact just loads
+  # and returns that hash, but can be over-ridden with local logic for
+  # determining proper list of services for current request.
+  #
+  # Local over-ride could even in theory return a custom subclass of Collection, 
+  # with customized dispatch behavior. Probably not a great idea though.  
+  def create_collection    
+    # trim out ones with disabled:true
+    services = ServiceStore.config["default"]["services"].reject {|id, hash| hash && hash["disabled"] == true}
+            
+    return Collection.new(@user_request, services)
+  end
+    
+  # 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. 
+    session[nil] = nil
+    
+    # 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      
+  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. 
+  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'] )      
+      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?    
+
+    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  
+      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, 
+          :conditions => ["service_type_value_name = ?", service.name])
+        
+        return_value = candidates.first 
+        
+      end
+
+      # But wait, make sure it's included in :services if present.
+      if (return_value && skip[:services] )
+        return_value = nil unless skip[:services].include?( return_value.service_id )
+      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;    
+  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    
+    # 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" 
+    elsif params["umlaut.response_format"]
+      request.format = params["umlaut.response_format"]
+    end
+        
+    
+    respond_to do |format|
+      format.xml do         
+        render(:layout => false)
+      end
+      
+      format.json do        
+        # get the xml in a string
+        xml_str = 
+          with_format(:xml) do
+            render_to_string(:layout=>false)
+          end
+        # convert to hash. For some reason the ActionView::OutputBuffer
+        # we actually have (which looks like a String but isn't exactly)
+        # can't be converted to a hash, we need to really force String
+        # with #to_str
+        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    
+    end
+  end
+
+  def service_dispatch()
+    @collection.dispatch_services!
+  end
+
+
+  
+end
+