umlaut 3.0.0alpha1

data/lib/service.rb

@@ -0,0 +1,336 @@
+# Services are defined from the config/umlaut_config/services.yml file.
+# hey should have the following properties
+# id : unique internal string for the service, unique in yml file
+# display_name : user displayable string
+# url : A base url of some kind used by specific service
+# type : Class name of class found in lib/service_adaptors to be used for logic
+# priority: 0-9 (foreground) or a-z (background) for order of service operation
+#
+# Specific service_adaptor classes may have specific addtional configuration,
+# commonly including 'password' or 'api_key'.
+# specific service can put " required_config_parms :param1, :param2"
+# in definition, for requirement exception raising on initialize.
+#
+# = Service Sub-classes
+# Can include required config params in the class definition, eg:
+#     required_config_params :api_key, :base_url
+#
+# Should define #service_types_generated returning an array of
+# ServiceTypeValues.  This is neccesary for the Service to be
+# run as a background service, and have the auto background updater
+# work.
+#
+# The vast majority of services are 'standard' services, however
+# there are other 'tasks' that a service can be. Well, right now, one
+# other, 'link_out_filter'. The services 'task' config property
+# sets the task/function/hook of the service. Default is 'standard'.
+#
+# A standard service defines handle(request)
+#
+# A link_out_filter service defines link_out_filter(request, url). If service
+# returns a new url from filter_url, that's the url the user will be directed
+# 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_writer :session_id
+  attr_accessor :request
+  @@required_params_for_subclass = {} # initialize class var
+
+  # Some constants for 'function' values
+  StandardTask = 'standard'
+  LinkOutFilterTask = 'link_out_filter'
+
+  
+  def initialize(config)
+    
+    config.each do | key, val |
+      self.instance_variable_set(('@'+key).to_sym, val)
+    end
+
+    # task defaults to standard
+    @task ||= StandardTask
+
+    # check required params, and throw if neccesary
+
+    required_params = Array.new
+    # Some things required for all services
+    required_params << "priority"
+    # Custom things for this particular sub-class
+    
+    required_params.concat( @@required_params_for_subclass[self.class.name] ) if @@required_params_for_subclass[self.class.name]
+    required_params.each do |param|
+      begin
+          value = self.instance_variable_get('@' + param.to_s)
+          # docs say it raises a nameerror if it doesn't exist, docs
+          # lie. So we'll just raise one ourselves, and catch it, to
+          # handle both cases.
+          raise NameError if value.nil?          
+      rescue NameError
+      raise ArgumentError.new("Missing Service configuration parameter. Service type #{self.class} (id: #{self.id}) requires a config parameter named '#{param}'. Check your config/umlaut_config/services.yml file.")
+      end      
+    end    
+  end
+
+  # Must be implemented by concrete sub-class. return an Array of 
+  # ServiceTypeValues constituting the types of ServiceResponses the service
+  # might generate. Used by Umlaut infrastructure including the background
+  # service execution scheme itslef, as well asxml services returning 
+  # information on services in progress.
+  #
+  # Example for a service that only generates fulltext: 
+  #    return [ ServiceTypeValue[:fulltext] ]
+  def service_types_generated
+    raise Exception.new("#{self.class}: service_types_generated() must be implemented by Service concrete sub-class!")
+  end
+
+
+  # Method that should actually be called to trigger the service.
+  # Will check pre-emption. 
+  def handle_wrapper(request)
+    unless ( preempted_by(request) )
+      return handle(request)
+    else
+      # Pre-empted, log and close dispatch record as 'succesful'.
+      Rails.logger.debug("Service #{service_id} was pre-empted and not run.")
+      return request.dispatched(self, true)
+    end
+  end
+  
+  # Implemented by sub-class. Standard response-generating services implement
+  # this method to do their work, generate responses and/or metadata. 
+  def handle(request)
+    raise Exception.new("#{self.class}: handle() must be implemented by Service concrete sub-class, for standard services!")
+  end
+
+  # This method is implemented by a concrete sub-class meant to
+  # fulfill the task:link_out_filter. Will be called when the user clicks
+  # on a url that will redirect external to Umlaut. The link_out_filter
+  # service has the ability to intervene and record and/or change
+  # the url. link_out_filters are called in order of priority config param
+  # assigned, 0 through 9.
+  #
+  # orig_url is the current url umlaut is planning on sending the user to.
+  # service_type is the ServiceType object responsible for this url.
+  # the third argument is reserved for future use an options hash. 
+  def link_out_filter(orig_url, service_response, other_args = {})
+    raise Exception.new("#{self.class}: #link_out_filter must be implemented by Service concrete sub-class with task link_out_filter!")
+  end
+
+  
+  def display_name
+    # If no display_name is set, default to the id string. Not a good idea,
+    # but hey. 
+    return @display_name ||= self.service_id    
+  end
+
+
+  # Pass this method a ServiceResponse object, it will return a hash-like object of 
+  # display values, for the view. Implementation is usually in sub-class, by
+  # means of a set of methods "to_[service type name]" implemented in sub-class
+  #. parseResponse will find those. Subclasses will not generally override
+  # view_data_from_service_type, although they can for complete custom
+  # handling. Make sure to return a Hash or hash-like (duck-typed) object.
+  def view_data_from_service_type(service_response)
+  
+    service_type_code = service_response.service_type_value.name
+    
+    begin
+      # try to call a method named "to_#{service_type_code}", implemented by sub-class
+      self.send("to_#{service_type_code}", service_response)
+    rescue NoMethodError 
+    # No to_#{response_type} method? How about the catch-all method?
+    # If not implemented in sub-class, we have a VERY basic
+    # default implementation in this class. 
+        self.send("response_to_view_data", service_response)
+    end
+  end
+
+  # Default implementation to take a ServiceResponse and parse
+  # into a hash of values useful to the view. Basic implementation
+  # just asks ServiceResposne for it's data_values object, which
+  # contains all ServiceResponse data (including arbitrary keys serialized
+  # in the hash) in an object with the hash accessor method [] . 
+  def response_to_view_data(service_response)
+      return service_response.data_values
+  end
+
+  # Sub-class can call class method like:
+  #  required_config_params  :symbol1, :symbol2, symbol3
+  # in class definition body. List of config parmas that
+  # are required, exception will be thrown if not present. 
+  def self.required_config_params(*params)
+    params.each do |p|
+      # Key on name of specific sub-class. Since this is a class
+      # method, that should be self.name
+      @@required_params_for_subclass[self.name] ||= Array.new
+      a = @@required_params_for_subclass[self.name]
+      a.push( p ) unless a.include?( p )
+    end
+  end
+
+
+  def session_id
+    unless (@session_id)
+      raise Exception.new("This service has not been initialized with a request!") unless request
+      
+      @session_id = request.session_id
+    end
+    return @session_id
+  end
+
+  # FakeSession little placeholder class we'll use in self.session to trick
+  # out Rails.
+  class FakeSession
+    attr_accessor :session_id  
+    def initialize(a_session_id)
+      self.session_id = a_session_id
+    end
+    def new_session
+      return self.session_id
+    end
+  end
+  # Returns a read-only version of the session hash. Lazy loaded. 
+  # See #update_session for making changes. Will have to be fixed
+  # for Rails 2.3.
+  def session    
+    #lazy load
+    unless (@session_data || session_id.blank? )           
+      # Craziness to restore a session in Rails pre 2.2. Will definitely
+      # need to be changed for Rails 2.3
+      
+      fake_cgi_session = FakeSession.new(session_id)
+  
+      @session_store_obj = 
+          ActionController::Base.session_store.new(fake_cgi_session)
+      @_session_data = @session_store_obj.restore
+      # modifications here are not going to be automatically stored,
+      # so don't do them. See #update_session instead. 
+      @session_data = @_session_data.clone
+      @session_data.freeze
+    end
+    if ( session_id.blank? && @session_data.nil?)
+      raise Exception.new("No session_id is available, therefore no session is available.")
+    end
+    return @session_data
+  end
+
+  
+  # If we just allowed changes to our session hash, and rewrote it to
+  # the store, we'd get a race condition where we could over-write another
+  # service's changes. Rails itself is actually subject to that too.
+  # So, you tell us exactly which values you want to update, we'll
+  # refetch a fresh session, and save it with your changes.
+  #
+  # We're not actually guarding against the race condition, just
+  # fetching and storing quickly and hoping to miss it. FIXME.
+  #
+  # example: update_session( :new_value => "foo", :other => "bar")
+  #
+  # Will have to be fixed for Rails 2.3.
+  def update_session(new_values)
+    # force a new fetch
+    @session = nil
+    session
+    #and update that guy, with our mutable version
+    @_session_data.merge!(new_values)
+    @session_store_obj.close
+    # and update our cached copy to have the changes. 
+    @session_data = @_session_data.clone
+    @session_data.freeze
+  end
+
+ # This method is called by Umlaut when user clicks on a service response. 
+ # Default implementation here just returns response['url']. You can
+ # over-ride in a sub-class to provide custom implementation of on-demand
+ # url generation. Second argument is the http request params sent
+ # by the client, used for service types that take form submissions (eg
+ # search_inside). 
+ # Should return a String url.
+ def response_url(service_response, submitted_params )
+   url = service_response[:url]
+   raise "No url provided by service response" if url.nil? || url.empty?
+   return url
+ end
+
+
+ # Pre-emption hashes specify a combination of existing responses or
+ # service executions that can pre-empt this service. Can specify
+ # a service, a response type (ServiceTypeValue), or a combination of both.
+ #
+ # service's preempted_by property can either be a single pre-emption hash,
+ # or an array of pre-emption hashes. 
+ #
+ # Can also specify that pre-emption is only of a certain service type
+ # generated by self.
+ #
+ # The Service base class will enforce pre-emption and not even run
+ # a service at all *so long as self_type is nil or '*' *. If the pre-emption
+ # only applies to certain types generated by the service and not the entire
+ # execution of the service, the concrete service subclass must implement
+ # logic to do that. Calling the preempted method with the second argument
+ # set will be helpful in writing this logic. 
+ #
+ # A preemption hash has string keys:
+ #    existing_service: id of service that will pre-empt this service.
+ #                      If key does not exist or is "*", then not specified,
+ #                      any service. (existing_type will be specified). 
+ #    existing_type:  ServiceTypeValue name that pre-empts this
+ #                    service. "+" means that the service specified
+ #                    in existing_service must have generated some
+ #                    response, but type does not matter. "*" means
+ #                    that the service specified in existing_service
+ #                    must have completed succesfully, but may not
+ #                    have generated any responses.
+ #    self_type:      If blank or "*", preemption applies to any running
+ #                    of this service at all. If set to a ServiceTypeValue
+ #                    name, pre-emption is only of certain types generated
+ #                    by this service. 
+ def preempted_by(uml_request, for_type_generated=nil)
+   preempted_by = @preempted_by
+   return false if preempted_by.nil?
+   preempted_by = [preempted_by] unless preempted_by.kind_of?(Array)
+   preemption = nil
+
+   preempted_by.each do | hash |
+      service = hash["existing_service"] || "*"
+      other_type = hash["existing_type"] || "*"      
+      self_type = hash["self_type"] || "*"
+
+      next unless (self_type == "*" || self_type == for_type_generated)
+
+      if (other_type == "*")
+        # Need to check dispatched services instead of service_types,
+        # as we pre-empt even if no services created. 
+        preemption = 
+        uml_request.dispatched_services.to_a.find do |disp|
+          service == "*" || 
+          (disp.service_id == service &&
+            (disp.status ==  DispatchedService.Succesful ))
+        end
+      else
+        # Check service responses
+        preemption = 
+          uml_request.service_responses.to_a.find do |response|
+          ( other_type == "*" || other_type == "+" ||
+            response.service_type_value.name == other_type)  &&
+          ( service == "*" ||
+            response.service_id == service)         
+        end
+      end
+      break if preemption
+   end
+   return (! preemption.nil? )
+ end
+ 
+ # used by render_service_credits helper method, returns
+ # a hash with keys being a human-displayable name of a third party
+ # to give 'credit' to, and value being a URL (or nil) to link the
+ # name to. 
+ # computed from @credits config variable, or returns empty hash. 
+ def credits
+   @credits || {}
+ end
+
+  
+end

data/lib/service_adaptors/ajax_export.rb

@@ -0,0 +1,37 @@
+# This is an abstract superclass other services over-ride to get
+# extra ajaxy windows upon click on link. 
+class AjaxExport < Service
+  required_config_params :ajax_id, :controller
+
+  def initialize(config)
+    super(config)
+  end
+
+  # Standard method, used by background service updater. See Service docs. 
+  def service_types_generated
+    types = [ ServiceTypeValue[:export_citation] ]
+    
+    return types
+  end
+  
+  def handle(request)    
+      
+    request.add_service_response(:service=>self, 
+      :display_text => @display_text,
+      :link_supports_ajax_call => true,
+      :notes=> @note,
+      :service_type_value => 'export_citation'  )
+
+    return request.dispatched(self, true)
+  end
+
+  def response_url(service_response, params)
+    # Hash that caller will pass to url_for to create an internally
+    # facing link.
+    return {:controller=>@form_controller, 
+     :action=>@form_action, 
+     :id => service_response.id, 
+     :format => params[:format]}
+  end
+  
+end

data/lib/service_adaptors/amazon.rb

@@ -0,0 +1,412 @@
+#
+#   As of Aug 15 2009, Amazon API calls will require a secret key from Amazon.
+#   If you are unable to get such an account/key, this service can still be used
+#   for certain functions by setting 'make_aws_call' to false, and configuring
+#   'service_types' to only include one or more of:  ["search_inside",
+#   "highlighted_link", "excerpts"]
+#   Other services, such as enhance_referent and cover_image require api access.
+#
+#   More about registering for and finding your AWS access key and secret key
+#   can be found here:
+# http://docs.amazonwebservices.com/AWSECommerceService/latest/DG/AWSCredentials.html
+# http://docs.amazonwebservices.com/AWSECommerceService/latest/DG/ViewingCredentials.html
+#
+#
+#   services.yml params:
+#   api_key:    required. AWS "access key". 
+#   secret_key:  required unless make_aws_call==false. AWS "secret access key". 
+#   associate_tag: required unless make_aws_call==false. Now required by Amazon API. 
+#                  sign up for an associates_id at: https://affiliate-program.amazon.com/
+#                  it's the same thing as your 'associate id'. 
+#   service_types: Optional. Array of strings of service type values to be
+#                  loaded, to over-ride defaults.
+#   make_aws_call:  default true.   If false, then either uses an ASIN stored
+#                     in referent from previous service, or tries assuming
+#                     that an ISBN, if present, is the ASIN. 
+#                     of services ran an amazon service adaptor
+#                     Can be used to split amazon into
+#                     two waves, since highlighted_link and cover_image
+#                     calls require _another_ HTTP request to amazon
+#                     and screen scrape. Or can be used if you don't
+#                     have access to Amazon API. 
+#
+#  See example of two-wave amazon in config/umlaut_distribution/services.yml-dist. 
+#
+class Amazon < Service
+  require 'open-uri'
+  require 'nokogiri'
+  require 'isbn'
+  
+  
+  include MetadataHelper
+  
+  required_config_params :url, :api_key, :associate_tag
+  attr_reader :url
+
+  def initialize(config)
+    # defaults
+    @url = 'http://webservices.amazon.com/onca/xml'     
+    @reader_base_url = 'http://www.amazon.com/gp/reader/'
+    # Old version non-lightboxed, whcih doesn't work very well anymore.     
+    # @reader_base_url = 'http://www.amazon.com/gp/sitbv3/reader/'
+    @display_name = "Amazon.com"
+    @display_text = "Amazon's page"
+    @service_types = ["abstract", "highlighted_link", "cover_image", "search_inside", "referent_enhance", "excerpts"]
+    @make_aws_call = true
+    @http_timeout = 5
+    
+    @credits = {
+      "Amazon" => "http://www.amazon.com/"
+    }
+    
+    super(config)
+
+    # Need the secret_key after 15 aug 09.
+    unless (@secret_key || ! @make_aws_call)
+      if ( Time.now < Time.gm(2009, 8, 15))
+        Rails.logger.warn("Amazon service will require a secret_key after 15 August 2009 to make Amazon API calls.")
+      else
+        raise Exception.new("Amazon API now requires a secret_key. The Amazon service can only be used with make_aws_call=false unless you have an Amazon secret key configured.")
+      end
+    end
+
+    # Only a few service types can get by without an aws call
+    if (! @make_aws_call &&
+          @service_types.find {|type|  ! ["search_inside", "highlighted_link", "excerpts"].include?(type) }  )
+      raise Exception.new("You can only set make_aws_call == false on the definition of an Amazon service adaptor when the adaptor is also set to generate no service responses other than highlighted_link, search_inside, and excerpts")
+    end
+  end
+
+
+  def service_types_generated
+    types = Array.new
+
+    @service_types.each do |type|
+      types.push( ServiceTypeValue[type])
+    end
+    
+    return types
+  end
+  
+  def handle(request)
+    
+    isbn = request.referent.metadata['isbn']
+    isbn = isbn.gsub(/[^0-9X]/,'') if isbn
+    
+    return request.dispatched(self, true) if isbn.blank?
+
+    begin
+
+      selected_aws_vals = {}
+      if ( @make_aws_call )
+        aws_response = make_aws_request( isbn )
+        
+        return request.dispatched(self, true) if aws_response.blank?
+  
+        # Add service responses based on AWS response
+        selected_aws_vals = 
+          self.add_aws_service_responses(request, aws_response)
+      end
+
+      if ( selected_aws_vals == nil)
+        # no aws found.
+        return request.dispatched(self, true)
+      end
+      
+      # Add service responses based on ASIN--may be run in a
+      # later service wave. Look up asin in db if we don't have
+      # it from current service exec. 
+      asin = selected_aws_vals[:asin] || 
+          get_identifier(:urn, "asin", request.referent)
+          
+      self.add_asin_service_responses(request, asin, selected_aws_vals[:item_url])
+      
+    rescue TimeoutError
+      # Try again later if we timeout; temporary error condition. 
+      return request.dispatched(self, DispatchedService::FailedTemporary)    
+    rescue Exception => e
+      # Unexpected error, fatal error condition. 
+      return request.dispatched(self, DispatchedService::FailedFatal, e)
+    end
+    
+    return request.dispatched(self, true)
+  end
+
+  def make_aws_request(isbn)
+    # We're assuming the ISBN is the ASIN Amazon ID. Not neccesarily valid
+    # assumption, but works enough of the time and there's no easy
+    # alternative.
+    # Convert 13 to 10 if neccesary. 
+    
+    # got to try converting to 10. An ISBN-13 is never an ASIN.    
+    isbn = ISBN.ten( isbn )
+              
+
+    query_params = {
+      "Service"=>"AWSECommerceService",
+      "AWSAccessKeyId"=>@api_key,
+      "AssociateTag"=>@associate_tag,
+      "Operation"=>"ItemLookup",
+      "ResponseGroup"=>"Large",
+      "ItemId"=>isbn }
+    
+    # has to be signed
+    query = nil
+
+    if ( @secret_key )
+      aws = AwsProductSign.new(:access_key => @api_key, 
+                               :secret_key => @secret_key )
+      query = aws.query_with_signature( query_params )
+    else
+      query = query_params.collect {|key, value| CGI.escape(key) + '=' + CGI.escape(value)}.join("&")
+    end
+      
+    uri = URI.parse(self.url+'?'+query)
+    # send the request
+    http = Net::HTTP.new(uri.host, 80)  
+    http.open_timeout = @http_timeout
+    http.read_timeout = @http_timeout
+    http_response = http.send_request('GET', uri.path + '?' + uri.query)    
+    
+    return http_response
+  end
+  
+  def add_aws_service_responses(request, aws_response)
+    return_hash = Hash.new
+        
+    aws = Nokogiri::XML(aws_response.body)
+    # extract and collect info from the xml    
+    
+    # if we get an error from Amazon, return now. 
+    err = (aws.at("ItemLookupResponse/Items/Request/Errors/Error"))
+    err = (aws.at("ItemLookupErrorResponse")) if err.blank?
+    
+    unless (err.blank?)
+      if (err.at('code').inner_text == 'AWS.InvalidParameterValue')
+        # Indicates an ISBN that Amazon doesn't know about, or that
+        # was mal-formed. We can't tell the difference, so either
+        # way let's silently ignore. 
+        return
+      else
+        raise Exception.new("Error from Amazon web service: " + err.to_s)
+      end
+    end
+
+    asin = (aws.at("ItemLookupResponse/Items/Item/ASIN")).inner_text
+
+    # Store the asin in the referent as non-metadata private data, so
+    # a future background service can use it. Store as a urn identifier.
+    request.referent.add_identifier("urn:asin:#{asin}") unless asin.blank?
+
+    return_hash[:asin] = asin
+    
+    if ( @service_types.include?("cover_image") )
+      # collect cover art urls
+      ["small","medium","large"].each do | size |
+        if (img = aws.at("ItemLookupResponse/Items/Item/"+size.capitalize+"Image/URL"))
+          request.add_service_response(
+            :service=>self, 
+            :display_text => 'Cover Image',
+            :key=>size, 
+            :url => img.inner_text, 
+            :asin => asin, 
+            :size => size,
+            :service_type_value => :cover_image)          
+        end
+      end
+      
+    end
+
+    item_url = (aws.at("ItemLookupResponse/Items/Item/DetailPageURL")).inner_text
+    # Store to return to caller
+    return_hash[:item_url] = item_url
+
+    
+    # get description
+    if (  @service_types.include?("abstract") &&
+         desc =
+         (aws.at("ItemLookupResponse/Items/Item/EditorialReviews/EditorialReview/Content")))
+
+      # For some reason we need to un-escape the desc. Don't entirely get it.
+      desc_text = CGI.unescapeHTML( desc.inner_text )
+
+      unless ( desc_text.blank? )
+        request.add_service_response(
+          :service=>self, 
+          :display_text => "Description from Amazon.com", 
+          :url => item_url, 
+          :key=>'abstract', 
+          :value_string=>asin, 
+          :content=>desc_text ,
+          :service_type_value => 'abstract')
+      end
+    end
+    
+
+    if ( @service_types.include?("similar_item"))
+      # Get Amazon's 'similar products' to help recommend other useful items
+      (aws.search("ItemLookupResponse/Items/Item/SimilarProducts/SimilarProduct")).each do |similar|
+        request.add_service_response(
+          :service=>self,
+          :key=>'book', 
+          :value_string=>(similar.at("ASIN")).inner_text, 
+          :value_alt_string=>(similar.at("Title")).inner_text,
+          :service_type_value => 'similar_item')
+      end
+
+   end
+
+    if ( @service_types.include?("referent_enhance"))
+      item_attributes = aws.at("ItemLookupResponse/Items/Item/ItemAttributes")
+      
+      request.referent.enhance_referent('format', 'book', false) unless request.referent.format == 'book'
+      metadata = request.referent.metadata
+      unless (metadata['btitle'] || metadata['title'])
+        if title = (item_attributes.at("Title"))
+          request.referent.enhance_referent('btitle', normalize_aws_title(title.inner_text))
+        end
+
+      end
+			# Enhance with full author name string even if aulast is already present, because full string may be useful for worldcat identities. 
+      unless (metadata['au'] )
+        if author = (item_attributes.at("Author"))
+          request.referent.enhance_referent('au', author.inner_text)
+        end
+      end
+
+      unless metadata['pub']
+        if pub = (item_attributes.at("Publisher"))
+          request.referent.enhance_referent('pub', pub.inner_text)
+        end
+      end      
+      unless metadata['tpages']
+        if tpages = (item_attributes.at("NumberOfPages"))
+          request.referent.enhance_referent('tpages', tpages.inner_text)
+        end
+      end
+    end
+
+    return return_hash
+  end
+
+  def add_asin_service_responses(request, asin, item_url)
+    # we want to highlight Amazon to link to 'search in this book', etc.
+    if asin
+      # Search or Look inside the book offered? We only know by trying and
+      # then screen-scraping.
+      search_inside = false
+      look_inside = false
+
+      # Check for search_inside or look_inside if we're configured
+      # to supply highlighted_link or search_inside, that's what we
+      # need it for.
+      if ( @service_types.include?("highlighted_link") ||
+           @service_types.include?("search_inside"))
+        inside_base = @reader_base_url + asin
+        # lame screen-scrape for search inside availability. We need to
+        # distinguish between no results, "look inside", and "search inside".
+        response = open(inside_base).read
+
+        # This regexp only suitable for screen-scraping the old-style "sitbv3"
+        # reader page screen
+        if (response.include?("<div class='sitb-pop-search'>"))
+          # then we have search_inside. I think this always includes 'look', but
+          # we'll test seperate for that. 
+          search_inside= true
+        end
+        
+        if (response.include?('<a href="/gp/reader/'))
+          # then we have look inside, not neccesarily search.  
+          look_inside = true
+        end
+      end
+
+      if ( @service_types.include?("search_inside") && search_inside )
+        request.add_service_response( 
+          :service => self,
+          :display_text=>@display_name,
+          :url=> inside_base,
+          :service_type_value => :search_inside
+         )   
+      end
+
+      # Link to look inside if we have it, otherwise ordinary amazon detail
+      # page. 
+
+      if (@service_types.include?("excerpts") &&
+          ( search_inside || look_inside ))
+        
+                         
+         request.add_service_response(
+            :service=>self,
+            :url => inside_base, 
+            :asin=>asin,
+            :display_text => @display_name,            
+            :service_type_value => 'excerpts')
+         
+      elsif ( @service_types.include?("highlighted_link"))
+          # Just link to Amazon page if we can. If we did the AWS request
+          # before, afraid we didn't store the item url, just the
+          # asin, reconstruct a valid one, even if not the one given to us
+          # by AWS. 
+          amazon_page = item_url || ("http://www.amazon.com/o/ASIN/" + asin)
+          
+                         
+          request.add_service_response(
+            :service=>self,
+            :url => amazon_page, 
+            :asin=>asin,
+            :display_text => @display_text,            
+            :service_type_value => 'highlighted_link')
+      end
+      
+    end
+
+  end
+  
+  # Catch url_for call for search_inside, because we're going to redirect
+  def response_url(service_response, submitted_params)
+    if ( ! (service_response.service_type_value.name == "search_inside" ))
+      return super(service_response, submitted_params)
+    else
+      # search inside!
+      base = service_response[:url]
+      query = CGI.escape(submitted_params["query"] || "")
+      url = base + "/ref=sib_dp_srch_pop?v=search-inside&keywords=#{query}&go=Go%21"
+      return url
+    end
+  end
+
+  #amazon is in the habit of including things in parens at the end
+  #of the title that aren't really part of the title. The parens
+  # are really an edition and/or series statement. We have nowhere
+  # good to store that. 
+  def normalize_aws_title(title)
+    title.sub(/\([^)]*\)\s*$/, '')
+  end
+
+  
+end
+
+# Example of no look or search:
+# www.amazon.com/gp/reader/0794521789
+
+# Example of look and search:
+# http://www.amazon.com/gp/reader/1851960511
+
+# Example of 'look inside' with no search:
+# http://www.amazon.com/gp/reader/0140441115/
+
+# Scraping /gp/reader page. 
+
+# Only look inside (preview) if link like:
+# <a href="/gp/reader/1851960511/ref=sib_dp_pop_sup?ie=UTF8&amp;p=random#reader-link
+# OR:
+# <a href="/gp/reader/0140441115/ref=sib_dp_kd#reader-link" onclick="if (typeof(SitbReader) != 'undefined')
+
+
+# Only search inside if:
+
+# '<td class="tinypopup">Search Inside This Book:</td>'
+# OR: <div class='sitb-pop-search'> 
+