cul_scv_hydra 0.22.6 → 0.22.7

data/lib/cul_hydra/controllers/suggestions.rb

@@ -0,0 +1,126 @@
+require 'cul_hydra'
+require 'json'
+module Cul::Hydra::Controllers
+module Suggestions
+  extend ActiveSupport::Concern
+  included do
+    include Blacklight::SolrHelper
+    include MediaShelf::ActiveFedoraHelper
+  end
+
+  def index
+    stub = params[:term] || ""
+    if params[:term_id].nil?
+      raise "Cannot provide suggestions without a term name"
+    end
+    field_name = params[:term_id]
+    field_key = field_key_from(field_name, Cul::Hydra::Om::ModsDocument.terminology)
+    solr_name = get_solr_name(field_key, Cul::Hydra::Om::ModsDocument)
+    solr_params = {}
+    solr_params['wt'] = 'json'
+    solr_params['terms'] = 'true'
+    solr_params['terms.fl'] = solr_name
+    solr_params['terms.lower'] = stub
+    solr_params['terms.lower.incl'] = false
+    solr_params['terms.prefix'] = stub
+    solr_params['terms.sort'] = 'index'
+    solr_response = Blacklight.solr.get 'terms', {:params => solr_params}
+    result = []
+    hash = {}
+    (1...solr_response['terms'].length).step(2) { |ix|
+      solr_response['terms'][ix].each { |val|
+        result << val if val.is_a? String
+      }
+    }
+    send_data result.to_json, :disposition => 'inline', :type => 'text/plain'
+    return
+  end
+
+## field_key_from(field_name) to reverse this method from HydraFedoraMetadataHelper
+#  def field_name_for(field_key)
+#   if field_key.kind_of?(Array)
+#     return OM::XML::Terminology.term_hierarchical_name(*field_key)
+#   else
+#     field_key.to_s
+#   end
+#  end
+
+  def field_key_from(field_name, terminology)
+    # this is a hack, but necessary until/unless OM generates names differently
+   candidates = field_name.split('__')
+   field_key = []
+   candidates.each_with_index { |candidate, ix|
+     if (candidates[ix + 1] and candidates[ix + 1].match(/\d+/))
+       field_key << {OM.destringify(candidate) => Integer(candidates.delete_at(ix + 1))}
+     else
+       field_key << OM.destringify(candidate)
+     end
+   }
+   logger.debug field_key.inspect
+   field_key
+  end
+
+  # ** largely copied from ActiveFedora::NokogiriDatastream.get_values **
+  def get_solr_name(term_pointer, dsClass)
+    term = dsClass.terminology.retrieve_term(*OM.pointers_to_flat_array(term_pointer, false))
+    names = []
+    if is_hierarchical_term_pointer?(*term_pointer)
+      bases = []
+      #add first item in term_pointer as start of bases
+      # then iterate through possible nodes that might exist
+      term_pointer.first.kind_of?(Hash) ? bases << term_pointer.first.keys.first : bases << term_pointer.first
+      for i in 1..(term_pointer.length-1)
+        #iterate in reverse so that we can modify the bases array while iterating
+        (bases.length-1).downto(0) do |j|
+          current_last = (term_pointer[i].kind_of?(Hash) ? term_pointer[i].keys.first : term_pointer[i])
+          if (term_pointer[i-1].kind_of?(Hash))
+            #just use index supplied instead of trying possibilities
+            index = term_pointer[i-1].values.first
+            solr_name_base = OM::XML::Terminology.term_hierarchical_name({bases[j]=>index},current_last)
+            solr_name = generate_solr_symbol(solr_name_base, term.data_type)
+            bases.delete_at(j)
+            #insert the new solr name base if found
+            bases.insert(j,solr_name_base) if has_solr_name?(solr_name,solr_doc)
+          else
+            #detect how many nodes exist
+            index = 0
+            current_base = bases[j]
+            bases.delete_at(j)
+            solr_name_base = OM::XML::Terminology.term_hierarchical_name({current_base=>index},current_last)
+            solr_name = generate_solr_symbol(solr_name_base, term.data_type)
+            bases.insert(j,solr_name_base)
+          end
+        end
+      end
+      bases.each do |base|
+        names << generate_solr_symbol(base.to_sym, term.data_type)
+      end
+    else
+#this is not hierarchical and we can simply look for the solr name created using the terms without any indexes
+      generic_field_name_base = OM::XML::Terminology.term_generic_name(*term_pointer)
+      names << generate_solr_symbol(generic_field_name_base, term.data_type)
+    end
+    names
+  end
+
+  # ** copied from ActiveFedora::NokogiriDatastream **
+  #@return true if the term_pointer contains an index
+  # ====Example:
+  #     [:image, {:title_set=>1}, :title] return true
+  #     [:image, :title_set, :title]      return false
+  def is_hierarchical_term_pointer?(*term_pointer)
+    if term_pointer.length>1
+      term_pointer.each do |pointer|
+        if pointer.kind_of?(Hash)
+          return true
+        end
+      end
+    end
+    return false
+  end
+  # ** copied from ActiveFedora::NokogiriDatastream **
+  def generate_solr_symbol(base, data_type)
+    Solrizer::XML::TerminologyBasedSolrizer.default_field_mapper.solr_name(base.to_sym, data_type)
+  end
+end
+end

data/lib/cul_hydra/controllers/terms.rb

@@ -0,0 +1,205 @@
+require 'cul_hydra'
+require 'json'
+require 'blacklight'
+module Cul::Hydra::Controllers
+module Terms
+  extend ActiveSupport::Concern
+  included do
+    include ::Blacklight::SolrHelper
+    #include MediaShelf::ActiveFedoraHelper
+  end
+
+  def index
+    if params[:layout] == "false"
+      layout = false
+    end
+    if params[:term_id]
+      @solr_name = solr_name(params[:term_id])
+    else
+      @solr_name = params[:solr_name]
+    end
+    @terms = term_values
+    render :action=>params[:action], :layout=>layout
+  end
+
+  # this method should be overridden to use the appropriate terminology
+  def solr_name(term_id)
+    if term_id.nil?
+      raise "Cannot provide suggestions without a term name"
+    end
+    field_key = field_key_from(term_id, Cul::Hydra::Om::ModsDocument.terminology)
+    get_solr_name(field_key, Cul::Hydra::Om::ModsDocument)
+  end
+  def term_values
+    if @solr_name.nil?
+      logger.debug "no solr field name, return nil for term values"
+      return nil
+    end
+    stub = params[:term_value]
+    solr_params = {}
+    solr_params['wt'] = 'json'
+    solr_params['terms'] = 'true'
+    solr_params['terms.fl'] = @solr_name
+    if stub
+      solr_params['terms.lower'] = stub
+      solr_params['terms.lower.incl'] = false
+      solr_params['terms.prefix'] = stub
+      solr_params['terms.sort'] = 'index'
+    else
+      solr_params['terms.sort'] = params.fetch(:sort,'count')
+      solr_params['terms.limit'] = -1
+    end
+    solr_response = Blacklight.solr.get 'terms', {:params => solr_params}
+    result = []
+    hash = {}
+    (1...solr_response['terms'].length).step(2) { |ix|
+      _t = solr_response['terms'][ix]
+      (0..._t.length).step(2) { |jx|
+        result << [_t[jx], _t[jx + 1]]
+      }
+    }
+    return result
+  end
+
+## field_key_from(field_name) to reverse this method from HydraFedoraMetadataHelper
+#  def field_name_for(field_key)
+#   if field_key.kind_of?(Array)
+#     return OM::XML::Terminology.term_hierarchical_name(*field_key)
+#   else
+#     field_key.to_s
+#   end
+#  end
+
+  def field_key_from(hier_field_name, t)
+   candidates = hier_field_name.split('_')
+   field_key = []
+   candidates.inject(field_key) { |ptrs, term|
+     if term =~ /\d+/
+       ptr = {ptrs.pop=>term.to_i}
+     else
+       ptr = (ptrs.empty? or ptrs.last.is_a? Hash) ? term.to_sym : (ptrs.pop.to_s + "_" + term).to_sym
+     end
+     ptrs.push ptr   
+   }
+   return field_key if t.has_term? *field_key
+   # pointers are probably from ambiguous underscores
+   amb = field_key.dup
+   field_key = []
+   amb.each do |candidate|
+     key = (candidate.is_a? Hash) ? candidate.keys.first : candidate # no indexes should be included
+     parts = key.to_s.split('_')
+     ptrs = parts_to_terms(parts, t, field_key)
+     if ptrs.nil? or !t.has_term? *ptrs
+       raise "Couldn't generate pointer from term name going forward for \"" + hier_field_name + "\" (no matched term sequence)"
+     else 
+       if candidate.is_a? Hash
+         ptr_key = ptrs.pop
+         ptrs.push({ptr_key => candidate[candidate.keys.first] })
+       end
+       field_key = ptrs
+     end
+   end
+   return field_key if t.has_term? *field_key
+   raise "Couldn't generate pointer from term name going forward for \"" + hier_field_name + "\", tried " + field_key.inspect
+  end
+  
+  def parts_to_terms(parts, t, prefix=[])
+    return nil if parts.length == 0 # this should be short-circuited in the loop below rather than recurring
+    if parts.length == 1
+      new_term_ptr = prefix.dup.push parts[0].to_sym
+      if t.has_term? *new_term_ptr
+        return new_term_ptr 
+      else
+        return nil
+      end
+    end
+
+    results = []
+    parts.each_index do |ix|
+      term_ptr = prefix.dup.push parts[0...(parts.length - ix)].join('_').to_sym
+
+      if t.has_term? *term_ptr
+        case ix
+        when 0
+          results.push term_ptr
+        when 1
+          new_term_ptr = term_ptr.concat [parts.last.to_sym]
+          results.push new_term_ptr if t.has_term? *new_term_ptr
+        else
+          new_term_ptr = parts_to_terms(parts[parts.length - ix, ix], t, term_ptr)
+          results.push new_term_ptr if !new_term_ptr.nil?
+        end
+      end
+    end
+
+    if results.length == 1
+      return results[0]
+    else
+      return nil
+    end
+  end
+
+  # ** largely copied from ActiveFedora::NokogiriDatastream.get_values **
+  def get_solr_name(term_pointer, dsClass)
+    term = dsClass.terminology.retrieve_term(*OM.pointers_to_flat_array(term_pointer, false))
+    names = []
+    if is_hierarchical_term_pointer?(*term_pointer)
+      bases = []
+      #add first item in term_pointer as start of bases
+      # then iterate through possible nodes that might exist
+      term_pointer.first.kind_of?(Hash) ? bases << term_pointer.first.keys.first : bases << term_pointer.first
+      for i in 1..(term_pointer.length-1)
+        #iterate in reverse so that we can modify the bases array while iterating
+        (bases.length-1).downto(0) do |j|
+          current_last = (term_pointer[i].kind_of?(Hash) ? term_pointer[i].keys.first : term_pointer[i])
+          if (term_pointer[i-1].kind_of?(Hash))
+            #just use index supplied instead of trying possibilities
+            index = term_pointer[i-1].values.first
+            solr_name_base = OM::XML::Terminology.term_hierarchical_name({bases[j]=>index},current_last)
+            solr_name = generate_solr_symbol(solr_name_base, term.data_type)
+            bases.delete_at(j)
+            #insert the new solr name base if found
+            bases.insert(j,solr_name_base) if has_solr_name?(solr_name,solr_doc)
+          else
+            #detect how many nodes exist
+            index = 0
+            current_base = bases[j]
+            bases.delete_at(j)
+            solr_name_base = OM::XML::Terminology.term_hierarchical_name({current_base=>index},current_last)
+            solr_name = generate_solr_symbol(solr_name_base, term.data_type)
+            bases.insert(j,solr_name_base)
+          end
+        end
+      end
+      bases.each do |base|
+        names << generate_solr_symbol(base.to_sym, term.data_type)
+      end
+    else
+#this is not hierarchical and we can simply look for the solr name created using the terms without any indexes
+      generic_field_name_base = OM::XML::Terminology.term_generic_name(*term_pointer)
+      names << generate_solr_symbol(generic_field_name_base, term.data_type)
+    end
+    names
+  end
+
+  # ** copied from ActiveFedora::NokogiriDatastream **
+  #@return true if the term_pointer contains an index
+  # ====Example:
+  #     [:image, {:title_set=>1}, :title] return true
+  #     [:image, :title_set, :title]      return false
+  def is_hierarchical_term_pointer?(*term_pointer)
+    if term_pointer.length>1
+      term_pointer.each do |pointer|
+        if pointer.kind_of?(Hash)
+          return true
+        end
+      end
+    end
+    return false
+  end
+  # ** copied from ActiveFedora::NokogiriDatastream **
+  def generate_solr_symbol(base, data_type)
+    Solrizer::XML::TerminologyBasedSolrizer.default_field_mapper.solr_name(base.to_sym, data_type)
+  end
+end
+end

data/lib/cul_hydra/engine.rb

@@ -0,0 +1,31 @@
+# -*- encoding : utf-8 -*-
+# lib/cul_hydra/engine.rb
+require "cul_hydra"
+require "rails"
+
+module Cul::Hydra
+  class Engine < ::Rails::Engine
+  	isolate_namespace Cul::Hydra
+
+    config.mount_at = '/'
+
+    config.autoload_paths += %W(
+      #{config.root}/app/controllers/concerns
+      #{config.root}/app/models/concerns
+    )
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.integration_tool :rspec
+    end
+
+    # Make the rake tasks visible.
+    rake_tasks do
+      Dir.chdir(File.expand_path(File.join(File.dirname(__FILE__), '..'))) do
+        Dir.glob(File.join('tasks', '*.rake')).each do |railtie|
+          #load railtie # Commenting this out for now because we appear to be loading rake tasks twice
+        end
+      end
+    end
+  end
+end

data/lib/cul_hydra/fedora.rb

@@ -0,0 +1,41 @@
+module Cul
+  module Hydra
+    module Fedora
+      autoload :DummyObject, 'cul_hydra/fedora/dummy_object'
+      autoload :RubydoraPatch, 'cul_hydra/fedora/rubydora_patch'
+      autoload :UrlHelperBehavior, 'cul_hydra/fedora/url_helper_behavior'
+      module ClassMethods
+        def config_path
+          File.join(Rails.root.to_s, 'config', 'fedora.yml')
+        end
+        def config
+          ActiveFedora.fedora_config.credentials
+        end
+        def connection
+          @connection ||= ActiveFedora::RubydoraConnection.new(ActiveFedora.fedora_config.credentials)
+        end
+
+        def repository
+          @repository ||= begin
+            repo = connection.connection
+            repo.extend(RubydoraPatch)
+            repo
+          end
+        end
+
+        def ds_for_uri(fedora_uri, fake_obj=nil)
+          return nil unless fedora_uri =~ /info\:fedora\/.*/
+          p = fedora_uri.split('/')
+          return ds_for_opts({pid: p[1], dsid: p[2]})
+        end
+
+        def ds_for_opts(opts={}, fake_obj=nil)
+          return nil unless opts[:pid] and opts[:dsid]
+          fake_obj = fake_obj.nil? ? DummyObject.new(opts[:pid]) : fake_obj.spawn(opts[:pid])
+          return (opts[:class] || ::Rubydora::Datastream).new(fake_obj, opts[:dsid])
+        end
+      end
+      extend ClassMethods
+    end
+  end
+end

data/lib/cul_hydra/fedora/dummy_object.rb

@@ -0,0 +1,37 @@
+module Cul
+  module Hydra
+    module Fedora
+      class DummyObject
+        attr_accessor :pid
+        def initialize(pid, isNew=false)
+          @pid = pid
+          @isNew = isNew
+        end
+        def new_record?
+          @isNew
+        end
+        def new_record=(val)
+          @isNew = val
+        end
+        def internal_uri
+          @uri ||= "info:fedora/#{@pid}"
+        end
+        def connection
+          Cul::Hydra::Fedora.connection
+        end    
+        def repository
+          Cul::Hydra::Fedora.repository
+        end
+        def spawn(pid)
+          s = DummyObject.new(pid, @isNew)
+          s.connection= connection
+          s.repository= repository
+          s
+        end
+        protected
+        def connection=(connection); @connection = connection; end
+        def repository=(repo); @repository = repo; end
+      end
+    end
+  end
+end

data/lib/cul_hydra/fedora/rubydora_patch.rb

@@ -0,0 +1,16 @@
+module Cul
+  module Hydra
+    module Fedora
+      module RubydoraPatch
+        def find_by_itql query, options = {}
+          begin
+            self.risearch(query, {:lang => 'itql'}.merge(options))
+          rescue Exception => e
+            logger.error e if defined?(logger)
+            "{\"results\":[]}"
+          end
+        end
+      end
+    end
+  end
+end