umlaut 3.0.0alpha1

data/lib/generators/templates/umlaut_services.yml

@@ -0,0 +1,237 @@
+
+  # Configure what service plugins are used by Umlaut. This skeleton file
+  # has been generated into your app to help you get started. 
+  #
+  # If a service has "disabled:true", it's currently turned off. 
+  #
+  # Some services require local api key or connection details as config.
+  # Most services take other options for custom configuration too, not
+  # all options are neccesarily listed as examples here, see source
+  # or source-generated docs for more info.   
+
+default:
+    services:
+      
+      # SFX has pubmed lookup built in, so this service not generally
+      # needed with SFX, but included here as an example of it's availability
+      Pubmed:
+        disabled: true
+        priority: 0
+      
+      # Priority 3
+      
+      SFX:
+        type: Sfx
+        disabled: true
+        display_name: Find It       
+        base_url: YOUR_SFX_BASE_URL
+        priority: 3      
+      
+        
+      # First half of Amazon, run in foreground, get metadata and cover images.
+      Amazon:
+        disabled: true
+        display_name: Amazon.com
+        type: Amazon
+        url: http://webservices.amazon.com/onca/xml
+        api_key: "NEED_API_KEY"
+        secret_key: "NEED_SECRET_KEY"
+        associate_tag: "NEED_ASSOCIATE_ID"
+        priority: 3
+        service_types:
+          - abstract
+          - referent_enhance
+          - cover_image
+          
+      
+      # Priority c  : Background          
+      
+      # Second half of Amazon. It's Slow to lookup highlighted_link and search_inside
+      # availability, so we do it in a bg wave.  
+      Amazon_bg:
+        type: Amazon
+        disabled: true        
+        api_key: "NEED_API_KEY"
+        secret_key: "NEED_SECRET_KEY"
+        associate_tag: "NEED_ASSOCIATE_ID"
+        priority: c        
+        make_aws_call: false
+        service_types:
+          - highlighted_link
+          - search_inside
+          - excerpts
+          
+
+      
+      CoverThing:
+        type: CoverThing
+        disabled: true        
+        developer_key: YOUR_LT_KEY
+        priority: c
+        # Pre-empted by says if we already have a cover_image response
+        # from somewhere else that runs earlier, don't run this. 
+        preempted_by:
+          existing_type: cover_image
+          
+      ElsevierCover:
+        type: ElsevierCover
+        priority: c
+        
+      UlrichsCover:
+        type: UlrichsCover
+        priority: c      
+          
+      GoogleBookSearch:
+        type: GoogleBookSearch
+        disabled: true
+        priority: c        
+        api_key: 'YOUR_GBS_API_KEY'
+                
+      Ulrichs:
+        display_name: "Ulrich's Directory"
+        type: UlrichsLink
+        priority: c
+        
+      IsbnDb:
+        display_name: isbndb.com
+        disabled: true
+        type: IsbnDb
+        priority: c
+        access_key: YOUR_ISBNDB_ACCESS_KEY
+        
+      InternetArchive:
+        display_name: the Internet Archive
+        type: InternetArchive
+        priority: c
+        # disable audio results? uncomment:
+        #num_results_for_types:
+        #  audio: 0
+      
+      
+      # Priority d
+                
+      HathiTrust:
+        type: HathiTrust
+        priority: d
+        # Uncomment to link through this 'internal' URL instead
+        # of following permalinks. jrochkind does this to use
+        # a WAYFless shibboleth login with EZProxy. 
+        #direct_link_base: 'https://babel.hathitrust.org/shcgi/'
+        #
+        # This next says:
+        # Don't add HathiTrust fulltext if there's already a
+        # GoogleBookSearch fulltext. Still add other HT response
+        # types. 
+        preempted_by:
+          self_type: fulltext
+          existing_service: GoogleBookSearch
+          existing_type: fulltext
+          
+      EmailExport:
+        type: EmailExport
+        priority: d
+        
+      TxtHoldingExport:
+        type: TxtHoldingExport
+        priority: d
+      
+        
+      
+      ScopusCitations:
+        type: Scopus
+        disabled: true
+        priority: c
+        json_api_key: YOUR_SCOPUS_API_KEY
+        partner_id: YOUR_SCOPUS_PARTNER_ID
+        link_salt_key: "YOUR_SCOPUS_LINK_SALT_KEY"
+        
+      # Web of Knowledge API has no api key, but your
+      # IP needs to be registered with them. See source docs
+      # for how. 
+      IsiCitations:
+        type: Isi
+        disabled: true
+        priority: c
+        
+      # Thomson JCR LAMR api has no api key, but your
+      # IP needs to be registered with them. Same registraiton
+      # as for ISI WoK generally. 
+      Jcr:
+        type: Jcr
+        disabled: true
+        priority: c
+        
+      # Worldcat scraper can be quite slow, move it to wave 'd' to avoid
+      # holding up wave 'c'
+      Worldcat:
+        display_name: OCLC Worldcat.org
+        type: Worldcat
+        priority: d
+        # suppress_precheck says don't actually screen-scrape to
+        # see if the link is good, just link blindly. Mostly works
+        # for WorldCat, avoids the performance hit. 
+        suppress_precheck: true
+      
+      
+      WorldcatIdentities:
+        type: WorldcatIdentities
+        priority: d
+        # Turn off certain response types:
+        #note_types: false
+        #wikipedia_link: false
+        #openurl_widely_held: false
+        #require_identifier: true
+      
+      
+      # GPO is kind of experimental, it doesn't work great, but IF an 
+      # OpenURL includes a sudoc call number or other GPO identifiers,
+      # will try to link to full text via GPO catalog scrape. 
+      Gpo:
+        type: Gpo
+        disabled: true
+        priority: e
+        #preempted_by:
+        #  - existing_type: fulltext
+        #  - existing_type: fulltext_title_level
+
+
+      ####
+      # Link out filters: Effect what happens when a user clicks
+      # on an Umlaut link to a third party source. Link out filters
+      # can operate to change where link goes or execute side effects
+      # on click. 
+      ####
+
+      # Redirect outgoing links through EZProxy                
+      EZProxy:
+        type: Ezproxy
+        disabled: true
+        task: link_out_filter  
+        proxy_server:  HOSTNAME_OF_YOUR_EZPROXY
+        # By default, will pre-check with EZProxy api and
+        # only send links through EZProxy that are proxyable.
+        # requires proxy_password to be set. 
+        # optionally, set precheck_with_api false, and the EZProxy
+        # api won't be used, ALL links go through EZProxy. You may
+        # have EZProxy itself set to transparently redirect non-proxyable
+        # URLs back to non-proxied version.
+        #
+        #precheck_with_api: false
+        priority: 5
+        proxy_password: YOUR_EZPROXY_API_PWD
+        # Want to exclude certain hostnames from being directed through EZProxy?
+        # list them in array here:
+        #exclude: [ host.unversity.edu, otherhost.somewhere.com]
+        
+        
+      # Use of SFX api means that SFX can no longer keep statistics on
+      # clickthroughs. This link out filter will attempt to fake SFX into
+      # thinking a direct click happened when user clicks on an SFX link
+      # via Umlaut.  This is VERY fragile logic, required reverse engineering
+      # SFX and faking it out, still doesn't work all the time. But works
+      # much of the time. 
+      SFX_backchannel_record:
+        disabled: true
+        type: SfxBackchannelRecord
+        task: link_out_filter
+        priority: 6

data/lib/generators/umlaut/asset_hooks_generator.rb

@@ -0,0 +1,44 @@
+require 'rails/generators'
+
+module Umlaut
+  class AssetHooks < Rails::Generators::Base
+    
+    def add_to_stylesheet_manifest
+      unless IO.read("app/assets/stylesheets/application.css").include?('Umlaut')
+        insert_into_file "app/assets/stylesheets/application.css", :after => "/*" do
+          %q{ 
+ * The base Umlaut styles:
+ *= require 'umlaut'         
+          }
+        end
+        append_to_file("app/assets/stylesheets/application.css") do
+          %q{
+          
+  /* Umlaut needs a jquery-ui theme CSS. Here's an easy way to get one,
+     you can replace with another theme. */
+  @import url(http://ajax.googleapis.com/ajax/libs/jqueryui/1.8.16/themes/ui-lightness/jquery-ui.css);
+          }
+        end
+      else
+        say_status("skipped", "Your application.css already references Umlaut", :yellow)
+      end
+    end
+    
+    def add_to_javascript_manifest
+      unless IO.read("app/assets/javascripts/application.js").include?('Umlaut')
+        prepend_to_file "app/assets/javascripts/application.js" do
+          %q{
+ // Umlaut javascript required for proper functionality. The 'umlaut' file
+ // also forces require of jquery and jquery-ui, dependencies. 
+ //= require 'umlaut'          
+          }           
+        end
+      else
+        say_status("skipped", "Your application.js already references Umlaut", :yellow)
+      end
+        
+    end
+    
+    
+  end  
+end

data/lib/generators/umlaut/install_generator.rb

@@ -0,0 +1,110 @@
+require 'rails/generators'
+
+module Umlaut
+  class Install < Rails::Generators::Base
+    source_root File.join(Umlaut::Engine.root)
+    
+    class_option :only, :type=>:array
+    class_option :except, :type=>:array
+            
+    include ActionView::Helpers::TextHelper
+    
+    def config_cache_classes
+      guarded(:config_cache_classes) do
+        /^((\s*)config\.cache_classes +\= +false\s*)$/
+        gsub_file("config/environments/development.rb", /^(\s*)config\.cache_classes +\= +false\s*$/) do |match|
+          # for some reason we can't make access to $1 in here from the above
+          # regexp work, so we need to match again
+          match =~ /^(\s*)/        
+          <<-EOS
+#{$1}#
+#{$1}# UMLAUT: Umlaut's use of threading is not compatible with class
+#{$1}# reloading, even in development. Umlaut requires true here.
+#{$1}# Rails 3.2 _might_ let you get away with false when it comes out.
+#{$1}config.cache_classes = true
+            EOS
+        end
+      end
+    end
+    
+    def database_yml_hint
+      guarded(:database_yml_hint) do
+        insert_into_file("config/database.yml", :before => /^(\s*)development:/) do                     
+          <<-eos
+#
+# UMLAUT: mysql db with mysql2 adapter strongly recommended for Umlaut, in both 
+# production and development. sqlite3 has unclear semantics under threaded 
+# concurrency which umlaut uses, and in many cases simply does not work. 
+#
+# A high (connection) pool setting is also, sadly, generally
+# required at present. 
+#
+# development:
+#   adapter: mysql2
+#   host: 
+#   username:
+#   password:
+#   database:
+#   pool: 30
+
+          eos
+        end        
+      end
+    end
+    
+  
+    def routes
+      guarded(:routes) do
+        route("Umlaut::Routes.new(self).draw")
+      end
+    end
+    
+    def umlaut_services_skeleton
+      guarded(:umlaut_services_skeleton) do
+        copy_file("lib/generators/templates/umlaut_services.yml", "config/umlaut_services.yml")
+      end
+    end
+    
+    def migrations
+      guarded(:migrations) do
+        rake("umlaut:install:migrations")
+      end
+    end
+    
+    def asset_hooks
+      guarded(:asset_hooks) do
+        generate("umlaut:asset_hooks")
+      end
+    end
+    
+    def local_umlaut_controller
+      guarded(:local_umlaut_controller) do
+        copy_file("app/controllers/umlaut_controller.rb")
+      end
+    end
+      
+    def post_install_message            
+        say("\n              Umlaut installed, now:", :yellow)
+        $stdout.puts(
+          "              " +
+          word_wrap("After setting up your 'development' database in config/databases.yml, run `rake db:migrate`", :line_width => 60).
+            split("\n").
+            join("\n              ")
+          )
+        
+    end
+    
+    no_tasks do
+      def guarded(section, &block)
+        if (options[:only].nil? || options[:only].include?(section.to_s)) &&
+           (options[:except].nil? || ! options[:except].include?(section.to_s))
+          yield
+        else
+          say_status("skipped", section.to_s, :blue)
+        end
+        
+      end
+    end
+    
+  end  
+end

data/lib/hip3/bib.rb

@@ -0,0 +1,291 @@
+#!/usr/bin/ruby
+
+require 'marc'
+require 'stringio'
+
+module Hip3
+	# Bib record/object from HIP. Fetches in it's own data via
+	# HIP XML interface. Which may make it sensitive, sorry. If not fetched in yet, # for an item with 'copy' (serial) control, we  
+	# have to do TWO fetches to get complete information, one for summary
+	# holdings statements, plus another for items. Sigh, sorry. 
+	class Bib 
+		attr_accessor :httpSession, :hip_base_url
+		# should have copies or items, not both
+		attr_accessor :bibNum, :copies, :items
+    attr_writer :title
+    
+		# CustomFieldLookup objects
+		attr_accessor :item_field_lookup, :copy_field_lookup, :bib_field_lookup # We cache HIP's XML representation of bib with and without items serial items. 
+		attr_accessor :bib_xml, :xml_with_items 
+		# and the beautiful MARC xml object for the bib, ruby-marc object. 
+		attr_accessor :marx_xml
+		
+    # First arg: Horizon BibNo this thing represents.
+    # Second arg: Net::URI representing HIP base path.
+    # labelled args:
+		# bib_xml_doc => is optional Hpricot representing bib from HIP. If you have
+    # it already, give it to us and we won't have to fetch it. 
+    # http_session => optional already initialized http session. You are
+    #                 advised to use a Hip3::HTTPSession for it's error 
+    #                 handling.
+		def initialize(argBibNum, a_hip_base_path, params)
+      @title_label = 'Title'
+      
+      self.bibNum = argBibNum
+      raise ArgumentException.new("Nil 1st argument: You must supply a bib number to first arg of Bib.new") unless self.bibNum
+
+      self.hip_base_url = a_hip_base_path
+      raise ArgumentException.new("Nil 2nd arg: You must supply the HIP instance base URL as a Net::URI object in 2nd arg to Bib.new") unless self.hip_base_url
+     
+			
+			self.httpSession = params[:http_session]
+      self.httpSession ||= Hip3::HTTPSession.create(hip_base_url.host() )
+
+      self.title = params[:title]
+      
+			self.copies = nil
+
+			@bib_xml = params[:bib_xml_doc]
+		end
+
+		
+		
+		def hip_http_path
+			# 1000 items and copies per page, we want em all
+			return hip_base_url.path + "?index=BIB&term=#{bibNum}&ipp=1000&cpp=1000" 
+		end
+		def hip_http_xml_path
+			return hip_http_path + "&GetXML=1"
+		end
+	
+		# Fetch in our data from HIP. Called lazily by accessor methods. 
+		def load_from_store
+				
+			# If we have serial copies, load those. We never should have both, but oh well. 
+			serialElements = bib_xml.search('searchresponse/subscriptionsummary/serial')
+			self.copies = serialElements.collect do |serialElement|
+				holding = Hip3::SerialCopy.new( self, serialElement )				
+			
+				holding # collect holdings
+			end
+			@copies_loaded = true
+						
+			# If we didn't have copies, we might have items directly in this bib.  
+			if (self.copies.length == 0 &&
+				!bib_xml.search('searchresponse/items/searchresults/results/row').nil?)
+				self.xml_with_items = bib_xml
+				load_items_from_store
+			end
+			@items_loaded = true
+
+		end
+	
+		# This method gets the XML from HIP and puts it in an ivar. 
+		def xml_with_items
+			# first try to load our bib record, that might give us items.
+			unless (@xml_with_items)
+				load_from_store
+			end
+			# If we still don't have it, have to load the item xml
+			unless (@xml_with_items)
+				# Got to make another request
+				# give us up to 1000 item records!
+				bibWithItemsRequestPath = self.hip_http_xml_path + "&view=items&ipp=1000"
+        
+        
+				resp = Hip3::HTTPSession.safe_get(httpSession, bibWithItemsRequestPath)
+				@xml_with_items = Hpricot.XML( resp.body )
+			end
+		
+			return @xml_with_items
+		end
+		
+		def bib_xml
+			unless (@bib_xml)
+				summaryRequestPath = hip_http_xml_path
+		
+				resp = Hip3::HTTPSession.safe_get(httpSession, summaryRequestPath )
+				@bib_xml = Hpricot.XML( resp.body )						
+			end
+			
+			return @bib_xml
+		end
+
+
+
+		def marc_xml
+			# Sadly, loading this takes ANOTHER request. At least this
+			# request, unlike the HIP requests, is speedy. We need this
+      # for getting 856 urls with sub-fields. Depends on Casey
+      # Durfee's package to provide marcxml from hip being installed. 
+			unless (@marc_xml)
+				# should have copies or items, not both
+				path = "/mods/?format=marcxml&bib=#{bibNum}"
+        #host = hip_base_url.host
+        host = hip_base_url.host
+        port = hip_base_url.port
+
+        # If it's https, rejigger it to be http, that's just the way we roll.      
+        port = 80 if port == 443;
+        
+        # put in a rescue on bad http, reword error. 
+        resp = Hip3::HTTPSession.start(host, port) {|http| http.get(path) }
+        
+        
+				
+				reader = MARC::XMLReader.new( StringIO.new(resp.body.to_s) )
+				# there should only be one record in there, just grap one. Since
+        # this is an odd object, we can't just do reader[0], but instead:        
+				xml = reader.find { true }
+        
+        # HIP marc doesn't have the bibID in it. We want the bibID in there.
+        # Set it ourselves.
+        xml.fields.push( MARC::ControlField.new('001', bibNum()))
+        
+				@marc_xml = xml 
+			end
+			return @marc_xml
+		end
+			
+		# Load _serial_ Item data from HIP belonging to this BIB. Called lazily by accessors.
+		# Will also work for mono item data, but no reason to call it, can get mono item data
+		# without this extra fetch. 
+		def load_items_from_store
+					
+			itemRowElements =  xml_with_items.search('searchresponse/items/searchresults/results/row');			
+			itemRowElements.each do | el |
+				# constructor will take care of registering the thing with us
+				Hip3::Item.new(el, self)
+			end
+			# Tell all our copies they're loaded, so they won't try and load again
+			copies.each { |c| c.items_loaded = true }
+			
+		end
+	
+		def item_field_lookup
+			
+			# This guy loads our lookup obj
+			unless @item_field_lookup
+				xml = self.xml_with_items
+				itemLabels = xml.search('searchresponse/items/searchresults/header/col/label').collect {|e| e.inner_text}				
+				@item_field_lookup = CustomFieldLookup.new(itemLabels)
+			end
+			
+			return @item_field_lookup
+		end
+		
+		# Lookup custom HIP admin assigned fields in copy summary record
+		# => CustomFieldLookup object. 
+		def copy_field_lookup
+			unless @copy_field_lookup
+				labels = self.bib_xml.search('searchresponse/subscriptionsummary/header/col/label').collect {|e| e.inner_text}
+				@copy_field_lookup = CustomFieldLookup.new(labels)
+			end
+			
+			return @copy_field_lookup
+		end
+
+		def bib_field_lookup
+			unless ( @bib_field_lookup)
+				labels = self.bib_xml.search('searchresponse/fullnonmarc/header/col/label').collect {|e| e.inner_text}
+				@bib_field_lookup = CustomFieldLookup.new(labels)
+			end
+			return @bib_field_lookup
+		end
+
+		# Look up a field added in HIP Admin screen, by label given in that screen.
+		def custom_field_for_label(label)
+			dataRows = self.bib_xml.search('searchresponse/fullnonmarc/results/row[1]/cell');
+			return bib_field_lookup.text_value_for(dataRows, label)
+		end
+
+		# copy records, in case of serial bib
+		def copies
+			self.load_from_store unless @copies_loaded
+			return @copies || [] # never return nil, always return an array
+		end
+		
+		# Items directly held by this bib, only in case of mono bib
+		def items
+			self.load_from_store unless @items_loaded
+			
+			return @items || []
+		end
+		
+		# Returns items OR copies, depending on whether it's a serial
+		# or a mono bib. HIP doesn't generally allow a mixture of of both.
+		def holdings
+			return items + copies
+		end
+
+    def title
+      unless (@title)
+        # title may already have been lazily loaded, or loaded by the
+        # bibsearcher. Otherwise, we need to extract it from the bib_xml, 
+        # which is kind of a pain.
+
+        # first find the index number of the title.
+        labels = bib_xml().search('//fullnonmarc/searchresults/header/col/label')
+        title_index = nil
+        (0..(labels.length-1)).each do |i|
+          if (labels[i].inner_text == @title_label)
+            title_index = i
+            break
+          end
+        end
+
+        if title_index
+          raw_title = bib_xml().at("//fullnonmarc/searchresults/results/row/cell[#{title_index + 1}]/data/text").inner_text
+          # remove possible author on there, after a '/' char. That's how HIP rolls. 
+          @title = raw_title.sub(/\/.*$/, '')
+        else
+          @title = 'unknown'
+        end
+        
+      end
+      
+    
+      return @title
+    end
+		
+		# We could try to store the copies in a hash for efficiency, but
+		# we're only going to have a handful, it's not worth it. 
+		def copy_for_id(copy_id)
+			copies.find { |c|  c.id == copy_id }
+		end
+				
+		
+		# Will add this to an appropriate Copy record if one exists,
+		# otherwise directly to our items array. According to HIP's
+		# constriants, a bib should never have copies _and_ directly
+		# included items, just one or the other. 
+		def register_item(item)			
+			copy = copy_for_id( item.copy_id )
+			if ( copy.nil? )
+				# can't find a copy record, guess it's a directly registered item
+				register_direct_item( item )
+			else
+				copy.register_item( item )
+			end
+			
+		end
+		
+		# An item that does not have a copy parent, but is directly
+		# related to the big. 
+		def register_direct_item( item )
+			@items ||= []
+			@items.push( item ) if ! @items.include?(item)	
+		end
+
+		def http_url
+		
+			return "#{hip_base_url.scheme}://#{hip_base_url.host}:#{hip_base_url.port}#{hip_http_path}"
+		end
+		
+		def to_s
+			return "#<Hip3::Bib bibnum=#{bibNum} #{http_url}>"
+		end
+	end
+	
+					
+end