cul_scv_hydra 0.22.6 → 0.22.7

data/lib/cul_hydra/fedora/url_helper_behavior.rb

@@ -0,0 +1,32 @@
+module Cul
+  module Hydra
+    module Fedora
+      module UrlHelperBehavior
+
+        def fedora_url
+          @fedora_url ||= ActiveFedora.config.credentials[:url]
+        end
+
+        def pid_for_url(pid)
+          pid.gsub(/^\//,'').gsub(/info:fedora\//,'')
+        end
+
+        def fedora_object_url(pid)
+          fedora_url + '/objects/' + pid_for_url(pid)
+        end
+
+        def fedora_ds_url(pid, dsid)
+          fedora_object_url(pid) + '/datastreams/' + dsid
+        end
+
+        def fedora_method_url(pid, method)
+          fedora_object_url(pid) + '/methods/' + method
+        end
+
+        def fedora_risearch_url
+          fedora_url + '/risearch'
+        end
+      end
+    end
+  end
+end

data/lib/cul_hydra/indexer.rb

@@ -0,0 +1,84 @@
+module Cul::Hydra::Indexer
+
+  def self.descend_from(pid, pids_to_omit=nil, verbose_output=false)
+    if pid.blank?
+      raise 'Please supply a pid (e.g. rake recursively_index_fedora_objects pid=ldpd:123)'
+    end
+
+    begin
+
+      unless ActiveFedora::Base.exists?(pid)
+        raise 'Could not find Fedora object with pid: ' + pid
+      end
+
+      if pids_to_omit.present? && pids_to_omit.include?(pid)
+        puts 'Skipping topmost object in this set (' + pid + ') because it has been intentionally omitted...' if verbose_output
+      else
+        puts 'Indexing topmost object in this set (' + pid + ')...' if verbose_output
+        puts 'If this is a BagAggregator with a lot of members, this may take a while...' if verbose_output
+
+        yield pid
+
+      end
+
+      puts 'Recursively retreieving and indexing all members of ' + pid + '...'
+
+      unique_pids = Cul::Hydra::RisearchMembers.get_recursive_member_pids(pid, true)
+
+      total_number_of_members = unique_pids.length
+      puts 'Recursive search found ' + total_number_of_members.to_s + ' members.' if verbose_output
+
+      if pids_to_omit.present?
+        unique_pids = unique_pids - pids_to_omit
+        total_number_of_members = unique_pids.length
+        puts 'After checking against the list of omitted pids, the total number of objects to index will be: ' + total_number_of_members.to_s if verbose_output
+      end
+
+      i = 1
+      if total_number_of_members > 0
+        unique_pids.each {|pid|
+
+          puts 'Recursing on ' + i.to_s + ' of ' + total_number_of_members.to_s + ' members (' + pid + ')...' if verbose_output
+
+          yield pid
+
+          i += 1
+        }
+      end
+
+    rescue RestClient::Unauthorized => e
+      error_message = "Skipping #{pid} due to error: " + e.message + '.  Problem with Fedora object?'
+      puts error_message
+      logger.error error_message if defined?(logger)
+    end
+
+    puts 'Recursion complete!'
+
+  end
+  def self.recursively_index_fedora_objects(top_pid, pids_to_omit=nil, skip_generic_resources=false, verbose_output=false)
+
+    descend_from(top_pid, pids_to_omit, verbose_output) do |pid|
+      self.index_pid(pid, skip_generic_resources, verbose_output)
+    end
+
+  end
+
+  def self.index_pid(pid, skip_generic_resources=false, verbose_output=false)
+    # We found an object with the desired PID. Let's reindex it
+    begin
+      active_fedora_object = ActiveFedora::Base.find(pid, :cast => true)
+
+      if skip_generic_resources && active_fedora_object.is_a?(GenericResource)
+        puts 'Object was skipped because GenericResources are being skipped and it is a GenericResource.'
+      else
+        active_fedora_object.update_index
+        puts 'done.' if verbose_output
+      end
+    rescue SystemExit, Interrupt => e
+      # Allow system interrupt (ctrl+c)
+      raise e
+    rescue Exception => e
+      puts "Encountered problem with #{pid}.  Skipping record.  Exception: #{e.message}"
+    end
+  end
+end

data/lib/cul_hydra/om.rb

@@ -0,0 +1,7 @@
+module Cul
+  module Hydra
+    module Om
+      autoload :StandardMods, "cul_hydra/om/standard_mods"
+    end
+  end
+end

data/lib/cul_hydra/om/standard_mods.rb

@@ -0,0 +1,115 @@
+require 'active-fedora'
+require 'solrizer'
+require 'cul_hydra/solrizer_patch'
+module Cul
+module Hydra
+module Om
+  class StandardMods < ::ActiveFedora::OmDatastream
+
+    set_terminology do |t|
+      t.root(:path=>"mods",
+             :xmlns=>"http://www.loc.gov/mods/v3",
+             :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-4.xsd")
+      t.identifier(:path=>"identifier", :attributes=>{:type=>"local"}, :data_type=>:symbol)
+      t.clio(:path=>"identifier", :attributes=>{:type=>"CLIO"}, :data_type=>:symbol)
+      t.title_info(:path=>"titleInfo", :index_as=>[:not_searchable]) {
+        t.main_title(:path=>"title", :index_as=>[:not_searchable])
+      }
+      t.title(:path=>'mods/oxns:titleInfo/oxns:title', :index_as=>[:searchable,:displayable, :sortable])
+      t.abstract
+      t.subject {
+        t.topic
+      }
+      t.type_of_resource(:path=>"typeOfResource", :index_as=>[:not_searchable])
+      t.physical_description(:path=>"physicalDescription", :index_as=>[:not_searchable]){
+        t.form_marc(:path=>"form", :attributes=>{:authority=>"marcform"}, :index_as=>[:not_searchable])
+        t.form_nomarc(:path=>"form[@authority !='marcform']", :index_as=>[:not_searchable, :displayable, :facetable, :textable])
+        t.extent(:path=>"extent", :index_as=>[:not_searchable])
+        t.reformatting_quality(:path=>"reformattingQuality", :index_as=>[:not_searchable])
+        t.internet_media_type(:path=>"internetMediaType", :index_as=>[:not_searchable])
+        t.digital_origin(:path=>"digitalOrigin", :index_as=>[:not_searchable])
+      }
+      t.lib_format(proxy: [:physical_description, :form_nomarc] )
+      t.location(:path=>"location", :index_as=>[:not_searchable]){
+        t.repo_text(:path=>"physicalLocation",:attributes=>{:authority=>:none},  :index_as=>[:not_searchable])
+        t.repo_code(:path=>"physicalLocation",:attributes=>{:authority=>"marcorg"}, :index_as=>[:not_searchable])
+      }
+      t.lib_repo_text(:ref=>[:location, :repo_text], :label=>"lib_repo", :index_as=>[:searchable])
+      t.lib_repo(:ref=>[:location, :repo_code], :index_as=>[:not_searchable,:facetable, :displayable])
+      t.project_host(:path=>"relatedItem", :attributes=>{:type=>"host", :displayLabel=>"Project"}, :index_as=>[:not_searchable]){
+        t.p_title(:path=>'titleInfo',:index_as=>[:not_searchable])
+      }
+      t.lib_project(:proxy=>[:project_host, :p_title],:index_as=>[:facetable,:displayable, :not_searchable])
+      t.collection_host(:path=>"relatedItem", :attributes=>{:type=>"host", :displayLabel=>"Collection"}, :index_as=>[:not_searchable]){
+        t.c_title(:path=>'titleInfo',:index_as=>[:not_searchable])
+      }
+      t.lib_project(:path=>"mods/oxns:relatedItem[@type='host'][@displayLabel='Project']/oxns:titleInfo/oxns:title",:index_as=>[:facetable,:displayable, :not_searchable])
+      t.lib_collection(:path=>"mods/oxns:relatedItem[@type='host'][@displayLabel='Collection']/oxns:titleInfo/oxns:title",:index_as=>[:facetable,:displayable, :not_searchable])
+      t.note(:path=>"note")
+      t.access_condition(:path=>"accessCondition", :attributes=>{:type=>"useAndReproduction"}, :index_as => [:searchable], :data_type => :symbol)
+      t.record_info(:path=>"recordInfo", :index_as=>[:not_searchable]) {
+        t.record_creation_date(:path=>"recordCreationDate",:attributes=>{:encoding=>"w3cdtf"}, :index_as=>[:not_searchable])
+        t.record_content_source(:path=>"recordContentSource",:attributes=>{:authority=>"marcorg"}, :index_as=>[:not_searchable])
+        t.language_of_cataloging(:path=>"languageOfCataloging", :index_as=>[:not_searchable]){
+          t.language_term(:path=>"languageTerm", :index_as=>[:not_searchable], :attributes=>{:type=>:none})
+          t.language_code(:path=>"languageTerm",:attributes=>{:type=>'code',:authority=>"iso639-2b"}, :index_as=>[:not_searchable])
+        }
+        t.record_origin(:path=>"recordOrigin", :index_as=>[:not_searchable])
+      }
+
+      t.origin_info(:path=>"originInfo", :index_as=>[:not_searchable]){
+        t.date(:path=>"dateIssued", :attributes=>{:encoding=>'w3cdtf'}, :index_as=>[:not_searchable])
+        t.key_date(:path=>"dateIssued", :attributes=>{:encoding=>'w3cdtf',:keyDate=>'yes'}, :index_as=>[:not_searchable])
+        t.start_date(:path=>"dateIssued", :attributes=>{:encoding=>'w3cdtf',:keyDate=>'yes',:point=>'start'}, :index_as=>[:not_searchable])
+        t.end_date(:path=>"dateIssued", :attributes=>{:encoding=>'w3cdtf',:point=>'end'}, :index_as=>[:not_searchable])
+      }
+    end
+
+    def self.xml_template
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.mods(:version=>"3.4",
+           "xmlns"=>"http://www.loc.gov/mods/v3",
+           "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance"){
+        }
+      end
+      builder.doc.encoding = 'UTF-8'
+      builder.doc.root["xsi:schemaLocation"] = 'http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-4.xsd'
+      return builder.doc
+    end
+
+    def prefix
+      #if ::ActiveFedora::VERSION >= '8'
+      #  Rails.logger.warn("the prefix method of #{self.class.name} was overriden to maintain backwards compatibility")
+      #end
+      ''
+    end
+
+    def method_missing method, *args
+      query = false
+      _mname = method.id2name
+      if _mname[-1,1] == '?'
+        query = true
+        _mname = _mname[0,_mname.length-1]
+      end
+      _msym = _mname.to_sym
+      begin
+        has_term = self.class.terminology.has_term?(_msym)
+
+        _r = (has_term)? find_by_terms(_msym, *args) : nil
+        if query
+          return !( _r.nil? || _r.size()==0)
+        else
+          return _r
+        end
+      rescue
+        super
+      end
+    end
+    def update_values(params)
+      super
+      self.dirty = true
+    end
+  end
+end
+end
+end

data/lib/cul_hydra/risearch_members.rb

@@ -0,0 +1,92 @@
+module Cul::Hydra::RisearchMembers
+module ClassMethods
+  def get_recursive_member_pids(pid, verbose_output=false, cmodel_type='all')
+
+    recursive_member_query =
+      'select $child $parent from <#ri>
+      where
+      walk($child <http://purl.oclc.org/NET/CUL/memberOf> <fedora:' + pid + '> and $child <http://purl.oclc.org/NET/CUL/memberOf> $parent)'      
+
+    unless cmodel_type == 'all'
+      recursive_member_query += ' and $child <fedora-model:hasModel> $cmodel'
+      recursive_member_query += ' and $cmodel <mulgara:is> <info:fedora/ldpd:' + cmodel_type + '>'
+    end
+
+    puts 'Performing query:' if verbose_output
+    puts recursive_member_query if verbose_output
+
+    search_response = JSON(Cul::Hydra::Fedora.repository.find_by_itql(recursive_member_query, {
+      :type => 'tuples',
+      :format => 'json',
+      :limit => '',
+      :stream => 'on'
+    }))
+
+    unique_pids = search_response['results'].map{|result| result['child'].gsub('info:fedora/', '') }.uniq
+
+    return unique_pids
+
+  end
+
+  def get_direct_member_results(pid, verbose_output=false, format='json')
+
+    direct_member_query =
+      'select $pid from <#ri>
+      where $pid <http://purl.oclc.org/NET/CUL/memberOf> <fedora:' + pid + '>'
+
+    puts 'Performing query:' if verbose_output
+    puts direct_member_query if verbose_output
+
+    search_response = JSON(Cul::Hydra::Fedora.repository.find_by_itql(direct_member_query, {
+      :type => 'tuples',
+      :format => format,
+      :limit => '',
+      :stream => 'on'
+    }))
+
+    return search_response['results']
+  end
+
+  def get_direct_member_pids(pid, verbose_output=false)
+    unique_pids = get_direct_member_results(pid,verbose_output,'json')
+    unique_pids.map{|result| result['pid'].gsub('info:fedora/', '') }.uniq
+  end
+  
+  def get_direct_member_count(pid, verbose_output=false)
+    count = get_direct_member_results(pid,verbose_output,'count/json')
+    return count.blank? ? 0 : count[0]['count'].to_i
+  end
+
+  #Project constituents
+
+  def get_project_constituent_results(pid, verbose_output=false, format='json')
+
+    project_constituent_query =
+      'select $pid from <#ri>
+      where $pid <info:fedora/fedora-system:def/relations-external#isConstituentOf> <fedora:' + pid + '>'
+
+    puts 'Performing query:' if verbose_output
+    puts project_constituent_query if verbose_output
+
+    search_response = JSON(Cul::Hydra::Fedora.repository.find_by_itql(project_constituent_query, {
+      :type => 'tuples',
+      :format => format,
+      :limit => '',
+      :stream => 'on'
+    }))
+
+    return search_response['results']
+  end
+
+  def get_project_constituent_pids(pid, verbose_output=false)
+    unique_pids = get_project_constituent_results(pid,verbose_output,'json')
+    unique_pids.map{|result| result['pid'].gsub('info:fedora/', '') }.uniq
+  end
+
+  def get_project_constituent_count(pid, verbose_output=false)
+    count = get_project_constituent_results(pid,verbose_output,'count/json')
+    return count.blank? ? 0 : count[0]['count'].to_i
+  end
+end
+extend ClassMethods
+end

data/lib/cul_hydra/solrizer.rb

@@ -0,0 +1,10 @@
+module Cul
+  module Hydra
+    module Solrizer
+      autoload :Extractor, "cul_hydra/solrizer/extractor"
+      autoload :TerminologyBasedSolrizer, "cul_hydra/solrizer/terminology_based_solrizer"
+      autoload :ValueMapper, "cul_hydra/solrizer/value_mapper"
+      autoload :ModsFieldable, "cul_hydra/solrizer/mods_fieldable"
+    end
+  end
+end

data/lib/cul_hydra/solrizer/extractor.rb

@@ -0,0 +1,27 @@
+module Cul::Hydra::Solrizer
+class Extractor < ::Solrizer::Extractor
+  # Insert +field_value+ for +field_name+ into +solr_doc+
+  # Handles inserting new values into a Hash while ensuring that you don't destroy or overwrite any existing values in the hash.
+  # Ensures that field values are always appended to arrays within the values hash. 
+  # Ensures that values are run through format_node_value
+  # Also ensures that values are unique if specified
+  # @param [Hash] solr_doc
+  # @param [String] field_name
+  # @param [String] field_value
+  # @param [boolean] unique
+  def self.insert_solr_field_value(solr_doc, field_name, field_value, unique=false)
+    formatted_value = self.format_node_value(field_value)
+    if solr_doc.has_key?(field_name)
+      solr_doc[field_name] << formatted_value unless (unique and solr_doc[field_name].include? formatted_value)
+    else
+      solr_doc.merge!( {field_name => [formatted_value]} ) 
+    end
+    return solr_doc
+  end
+
+  # Instance Methods
+  def insert_solr_field_value(solr_doc, field_name, field_value, unique=false)
+    Cul::Hydra::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_name, field_value, unique)
+  end
+end
+end

data/lib/cul_hydra/solrizer/mods_fieldable.rb

@@ -0,0 +1,435 @@
+module Cul::Hydra::Solrizer
+	module ModsFieldable
+    extend ActiveSupport::Concern
+    include Solrizer::DefaultDescriptors::Normal
+
+    MODS_NS = {'mods'=>'http://www.loc.gov/mods/v3'}
+
+    module ClassMethods
+      def value_mapper(maps=nil)
+        @value_mapper ||= ValueMapper.new(maps)
+      end
+
+      def map_field(field_key, map_key)
+        value_mapper.map_field(field_key, map_key)
+      end
+
+      def map_value(field_key, value_key)
+        value_mapper.map_value(field_key, value_key)
+      end
+
+      def maps_field?(field_key)
+        value_mapper.maps_field? field_key
+      end
+      def normalize(t, strip_punctuation=false)
+        # strip whitespace
+        n_t = t.dup.strip
+        # collapse intermediate whitespace
+        n_t.gsub!(/\s+/, ' ')
+        # pull off paired punctuation, and any leading punctuation
+        if strip_punctuation
+          n_t = n_t.sub(/^\((.*)\)$/, "\\1")
+          n_t = n_t.sub(/^\{(.*)\}$/, "\\1")
+          n_t = n_t.sub(/^\[(.*)\]$/, "\\1")
+          n_t = n_t.sub(/^"(.*)"$/, "\\1")
+          n_t = n_t.sub(/^'(.*)'$/, "\\1")
+          n_t = n_t.sub(/^<(.*)>$/, "\\1")
+          #n_t = n_t.sub(/^\p{Ps}(.*)\p{Pe}/u, "\\1")
+          n_t = n_t.sub(/^[[:punct:]]+/, '')
+          # this may have 'created' leading/trailing space, so strip
+          n_t.strip!
+        end
+        n_t
+      end
+    end
+
+    extend ClassMethods
+
+    def mods
+      ng_xml.xpath('/mods:mods', MODS_NS).first
+    end
+
+    def projects
+      mods.xpath("./mods:relatedItem[@type='host' and @displayLabel='Project']", MODS_NS).collect do |p_node|
+        ModsFieldable.normalize(main_title(p_node), true)
+      end
+    end
+
+    def collections
+      mods.xpath("./mods:relatedItem[@type='host' and @displayLabel='Collection']", MODS_NS).collect do |p_node|
+        ModsFieldable.normalize(main_title(p_node), true)
+      end
+    end
+
+    def sort_title(node=mods)
+      # include only the untyped [!@type] titleInfo, exclude noSort
+      base_text = ''
+      t = node.xpath('./mods:titleInfo[not(@type)]', MODS_NS).first
+      if t
+        t.children.each do |child|
+          base_text << child.text unless child.name == 'nonSort'
+        end
+      end
+      base_text = ModsFieldable.normalize(base_text, true)
+      base_text = nil if base_text.empty?
+      base_text
+    end
+
+    def main_title(node=mods)
+      # include only the untyped [!@type] titleInfo
+      t = node.xpath('./mods:titleInfo[not(@type)]', MODS_NS).first
+      if t
+        ModsFieldable.normalize(t.text)
+      else
+        nil
+      end
+    end
+
+    def titles(node=mods)
+      # all titles without descending into relatedItems
+      # For now, this only includes the main title and selected alternate_titles
+      all_titles = []
+      all_titles << main_title unless main_title.nil?
+      all_titles += alternative_titles unless alternative_titles.nil?
+    end
+
+    def alternative_titles(node=mods)
+      node.xpath('./mods:titleInfo[@type and (@type="alternative" or @type="abbreviated" or @type="translated" or @type="uniform")]', MODS_NS).collect do |t|
+        ModsFieldable.normalize(t.text)
+      end
+    end
+
+    def names(role_authority=nil, role=nil)
+      # get all the name nodes
+      # keep all child text except the role terms
+      xpath = "./mods:name"
+      unless role_authority.nil?
+        xpath << "/mods:role/mods:roleTerm[@authority='#{role_authority.to_s}'"
+        unless role.nil?
+          xpath << " and normalize-space(text()) = '#{role.to_s.strip}'"
+        end
+        xpath << "]/ancestor::mods:name"
+      end
+      names = mods.xpath(xpath, MODS_NS).collect do |node|
+        base_text = node.xpath('./mods:namePart', MODS_NS).collect { |c| c.text }.join(' ')
+        ModsFieldable.normalize(base_text, true)
+      end
+
+      # Note: Removing subject names from name field extraction.
+      # See: https://issues.cul.columbia.edu/browse/DCV-231 and https://issues.cul.columbia.edu/browse/SCV-102
+      #xpath = "./mods:subject" + xpath[1,xpath.length]
+      #mods.xpath(xpath, MODS_NS).each do |node|
+      #  base_text = node.xpath('./mods:namePart', MODS_NS).collect { |c| c.text }.join(' ')
+      #  names << ModsFieldable.normalize(base_text, true)
+      #end
+
+      names
+    end
+
+    def dates(node=mods)
+      # get all the dateIssued with keyDate = 'yes', but not point = 'end'
+    end
+
+    def formats(node=mods)
+      # get all the form values with authority != 'marcform'
+      node.xpath("./mods:physicalDescription/mods:form[@authority != 'marcform']", MODS_NS).collect do |n|
+        ModsFieldable.normalize(n.text)
+      end
+    end
+
+    def repository_code(node=mods)
+      # get the location/physicalLocation[@authority = 'marcorg']
+      repo_code_node = node.xpath("./mods:location/mods:physicalLocation[@authority = 'marcorg']", MODS_NS).first
+
+      if repo_code_node
+        ModsFieldable.normalize(repo_code_node.text)
+      else
+        return nil
+      end
+    end
+
+    def repository_text(node=mods)
+      # get the location/physicalLocation[not(@authority)]
+      repo_text_node = node.xpath("./mods:location/mods:physicalLocation[not(@authority)]", MODS_NS).first
+
+      if repo_text_node
+        ModsFieldable.normalize(repo_text_node.text)
+      else
+        return nil
+      end
+    end
+
+    def translate_repo_marc_code(code, type)
+      #code = ModsFieldable.normalize(code)
+
+      if type == 'short'
+        return translate_with_default(SHORT_REPO, code, 'Non-Columbia Location')
+      elsif type == 'long'
+        return translate_with_default(LONG_REPO, code, 'Non-Columbia Location')
+      elsif type == 'full'
+        return translate_with_default(FULL_REPO, code, 'Non-Columbia Location')
+      end
+
+      return nil
+    end
+
+    def translate_project_title(project_title, type)
+      normalized_project_title = ModsFieldable.normalize(project_title)
+
+      if type == 'short'
+        return translate_with_default(SHORT_PROJ, normalized_project_title, normalized_project_title)
+      elsif type == 'full'
+        return translate_with_default(FULL_PROJ, normalized_project_title, normalized_project_title)
+      end
+
+      return nil
+    end
+
+    def shelf_locators(node=mods)
+      node.xpath("./mods:location/mods:shelfLocator", MODS_NS).collect do |n|
+        ModsFieldable.normalize(n.text, true)
+      end
+    end
+
+    def textual_dates(node=mods)
+      dates = []
+      node.xpath("./mods:originInfo/mods:dateCreated[not(@keyDate) and not(@point) and not(@w3cdtf)]", MODS_NS).collect do |n|
+        dates << ModsFieldable.normalize(n.text, true)
+      end
+      node.xpath("./mods:originInfo/mods:dateIssued[not(@keyDate) and not(@point) and not(@w3cdtf)]", MODS_NS).collect do |n|
+        dates << ModsFieldable.normalize(n.text, true)
+      end
+      node.xpath("./mods:originInfo/mods:dateOther[not(@keyDate) and not(@point) and not(@w3cdtf)]", MODS_NS).collect do |n|
+        dates << ModsFieldable.normalize(n.text, true)
+      end
+      return dates
+    end
+
+    def date_range_to_textual_date(start_year, end_year)
+      start_year = start_year.to_i.to_s # Remove zero-padding if present
+      end_year = end_year.to_i.to_s # Remove zero-padding if present
+
+      if start_year == end_year
+        return [start_year]
+      else
+        return [('Between ' +
+          (start_year.to_i > 0 ? start_year : start_year[1,start_year.length] + ' BCE') +
+          ' and ' +
+          (end_year.to_i > 0 ? (start_year.to_i > 0 ? end_year : end_year + ' CE') : end_year[1,end_year.length] + ' BCE')
+        )]
+      end
+    end
+
+    def date_notes(node=mods)
+      date_notes = []
+      node.xpath("./mods:note[@type = 'date' or @type = 'date source']", MODS_NS).collect do |n|
+        date_notes << ModsFieldable.normalize(n.text, true)
+      end
+      return date_notes
+    end
+
+    def non_date_notes(node=mods)
+      non_date_notes = []
+      node.xpath("./mods:note[not(@type) or (@type != 'date' and @type != 'date source')]", MODS_NS).collect do |n|
+        non_date_notes << ModsFieldable.normalize(n.text, true)
+      end
+      return non_date_notes
+    end
+
+    def item_in_context_url(node=mods)
+      item_in_context_url_val = []
+      node.xpath("./mods:location/mods:url[@access='object in context' and @usage='primary display']", MODS_NS).collect do |n|
+        item_in_context_url_val << ModsFieldable.normalize(n.text, true)
+      end
+      item_in_context_url_val
+    end
+
+    def project_url(node=mods)
+      project_url_val = []
+      node.xpath("./mods:relatedItem[@type='host' and @displayLabel='Project']/mods:location/mods:url", MODS_NS).collect do |n|
+        project_url_val << ModsFieldable.normalize(n.text, true)
+      end
+      project_url_val
+    end
+
+    def all_subjects(node=mods)
+      list_of_subjects = []
+
+      node.xpath("./mods:subject/mods:topic", MODS_NS).collect do |n|
+        list_of_subjects << ModsFieldable.normalize(n.text, true)
+      end
+      node.xpath("./mods:subject/mods:geographic", MODS_NS).collect do |n|
+        list_of_subjects << ModsFieldable.normalize(n.text, true)
+      end
+      node.xpath("./mods:subject/mods:name", MODS_NS).collect do |n|
+        list_of_subjects << ModsFieldable.normalize(n.text, true)
+      end
+      node.xpath("./mods:subject/mods:temporal", MODS_NS).collect do |n|
+        list_of_subjects << ModsFieldable.normalize(n.text, true)
+      end
+      node.xpath("./mods:subject/mods:titleInfo", MODS_NS).collect do |n|
+        list_of_subjects << ModsFieldable.normalize(n.text, true)
+      end
+      node.xpath("./mods:subject/mods:genre", MODS_NS).collect do |n|
+        list_of_subjects << ModsFieldable.normalize(n.text, true)
+      end
+
+      return list_of_subjects
+    end
+
+    def origin_info_place(node=mods)
+      places = []
+      node.xpath("./mods:originInfo/mods:place/mods:placeTerm", MODS_NS).collect do |n|
+        places << ModsFieldable.normalize(n.text, true)
+      end
+      return places
+    end
+
+    def origin_info_place_for_display(node=mods)
+      # If there are multiple origin_info place elements, choose only the ones without valueURI attributes.  Otherwise show the others.
+      places_with_uri = []
+      places_without_uri = []
+      node.xpath("./mods:originInfo/mods:place/mods:placeTerm[@valueURI]", MODS_NS).collect do |n|
+        places_with_uri << ModsFieldable.normalize(n.text, true)
+      end
+      node.xpath("./mods:originInfo/mods:place/mods:placeTerm[not(@valueURI)]", MODS_NS).collect do |n|
+        places_without_uri << ModsFieldable.normalize(n.text, true)
+      end
+
+      return (places_without_uri.length > 0 ? places_without_uri : places_with_uri)
+    end
+
+    def coordinates(node=mods)
+      coordinate_values = []
+      node.xpath("./mods:subject/mods:cartographics/mods:coordinates", MODS_NS).collect do |n|
+        n = ModsFieldable.normalize(n.text, true)
+        if n.match(/-*\d+\.\d+\s*,\s*-*\d+\.\d+\s*/) # Expected coordinate format: 40.123456,-73.5678
+          coordinate_values << n
+        end
+      end
+      coordinate_values
+    end
+
+    def to_solr(solr_doc={})
+      solr_doc = (defined? super) ? super : solr_doc
+
+      return solr_doc if mods.nil? 	# There is no mods.  Return because there is nothing to process, otherwise NoMethodError will be raised by subsequent lines.
+
+      solr_doc["all_text_teim"] ||= []
+
+      solr_doc["title_si"] = sort_title
+      solr_doc["title_ssm"] = titles
+      solr_doc["alternative_title_ssm"] = alternative_titles
+      solr_doc["all_text_teim"] += solr_doc["alternative_title_ssm"]
+      solr_doc["lib_collection_sim"] = collections
+      solr_doc["lib_name_sim"] = names
+      solr_doc["lib_name_teim"] = solr_doc["lib_name_sim"]
+      solr_doc["all_text_teim"] += solr_doc["lib_name_teim"]
+      solr_doc["lib_all_subjects_ssm"] = all_subjects
+      solr_doc["lib_all_subjects_teim"] = solr_doc["lib_all_subjects_ssm"]
+      solr_doc["all_text_teim"] += solr_doc["lib_all_subjects_teim"]
+      solr_doc["lib_name_ssm"] = solr_doc["lib_name_sim"]
+      solr_doc["lib_author_sim"] = names(:marcrelator, 'aut')
+      solr_doc["lib_recipient_sim"] = names(:marcrelator, 'rcp')
+      solr_doc["lib_format_sim"] = formats
+      solr_doc["lib_shelf_sim"] = shelf_locators
+      solr_doc["lib_date_textual_ssm"] = textual_dates
+      solr_doc["lib_date_notes_ssm"] = date_notes
+      solr_doc["lib_non_date_notes_ssm"] = non_date_notes
+      solr_doc["lib_item_in_context_url_ssm"] = item_in_context_url
+      solr_doc["lib_project_url_ssm"] = project_url
+      solr_doc["origin_info_place_ssm"] = origin_info_place
+      solr_doc["origin_info_place_for_display_ssm"] = origin_info_place_for_display
+
+      repo_marc_code = repository_code
+      unless repo_marc_code.nil?
+        solr_doc["lib_repo_short_ssim"] = [translate_repo_marc_code(repo_marc_code, 'short')]
+        solr_doc["lib_repo_long_sim"] = [translate_repo_marc_code(repo_marc_code, 'long')]
+        solr_doc["lib_repo_full_ssim"] = [translate_repo_marc_code(repo_marc_code, 'full')]
+      end
+      solr_doc["lib_repo_text_ssm"] = repository_text
+
+      project_titles = projects
+      unless project_titles.nil?
+        solr_doc["lib_project_short_ssim"] = []
+        solr_doc["lib_project_full_ssim"] = []
+        project_titles.each {|project_title|
+          solr_doc["lib_project_short_ssim"] << translate_project_title(project_title, 'short')
+          solr_doc["lib_project_full_ssim"] << translate_project_title(project_title, 'full')
+        }
+        solr_doc["lib_project_short_ssim"].uniq!
+        solr_doc["lib_project_full_ssim"].uniq!
+      end
+
+      # Create convenient start and end date values based on one of the many possible originInfo/dateX elements.
+      possible_start_date_fields = ['origin_info_date_issued_ssm', 'origin_info_date_issued_start_ssm', 'origin_info_date_created_ssm', 'origin_info_date_created_start_ssm', 'origin_info_date_other_ssm', 'origin_info_date_other_start_ssm']
+      possible_end_date_fields = ['origin_info_date_issued_end_ssm', 'origin_info_date_created_end_ssm', 'origin_info_date_other_end_ssm']
+      start_date = nil
+      end_date = nil
+      start_year = nil
+      end_year = nil
+      possible_start_date_fields.each{|key|
+        if solr_doc.has_key?(key)
+            start_date = solr_doc[key][0]
+          break
+        end
+      }
+      possible_end_date_fields.each{|key|
+        if solr_doc.has_key?(key)
+            end_date = solr_doc[key][0]
+          break
+        end
+      }
+
+      if start_date.present?
+
+        end_date = start_date if end_date.blank?
+
+        year_regex = /^(-?\d{1,4}).*/
+
+        start_year_match = start_date.match(year_regex)
+        if start_year_match && start_year_match.captures.length > 0
+          start_year = start_year_match.captures[0]
+          start_year = zero_pad_year(start_year)
+          solr_doc["lib_start_date_year_itsi"] = start_year.to_i # TrieInt version for searches
+        end
+
+        end_year_match = end_date.match(year_regex)
+        if end_year_match && end_year_match.captures.length > 0
+          end_year = end_year_match.captures[0]
+          end_year = zero_pad_year(end_year)
+          solr_doc["lib_end_date_year_itsi"] = end_year.to_i # TrieInt version for searches
+        end
+
+        solr_doc["lib_date_year_range_si"] = start_year + '-' + end_year if start_year
+
+        # When no textual date is available, fall back to other date data (if available)
+        if solr_doc["lib_date_textual_ssm"].blank?
+          solr_doc["lib_date_textual_ssm"] = date_range_to_textual_date(start_year.to_i, end_year.to_i)
+        end
+      end
+
+      # Geo data
+      solr_doc["geo"] = coordinates
+
+      solr_doc.each do |k, v|
+        if self.class.maps_field? k
+          solr_doc[k] = self.class.map_value(k, v)
+        end
+      end
+
+      solr_doc
+    end
+
+    def zero_pad_year(year)
+      year = year.to_s
+      is_negative = year.start_with?('-')
+      year_without_sign = (is_negative ? year[1, year.length]: year)
+      if year_without_sign.length < 4
+        year_without_sign = year_without_sign.rjust(4, '0')
+      end
+
+      return (is_negative ? '-' : '') + year_without_sign
+    end
+  end
+end