cul_hydra 1.0.0

data/lib/cul_hydra/controllers/static_image_aggregators.rb

@@ -0,0 +1,105 @@
+require 'cul_hydra/controllers/helpers/resources_helper_behavior'
+module Cul::Hydra::Controllers
+module StaticImageAggregators
+  extend ActiveSupport::Concern
+  
+  included do
+    include Hydra::AssetsControllerHelper
+    include Cul::Hydra::Controllers::Helpers::ResourcesHelperBehavior  
+    include Hydra::RepositoryController  
+    include MediaShelf::ActiveFedoraHelper
+    include Blacklight::SolrHelper
+    before_filter :require_fedora
+    prepend_before_filter :sanitize_update_params
+  end
+  
+  def index
+    if params[:layout] == "false"
+      # action = "index_embedded"
+      layout = false
+    end
+    if !params[:container_id].nil?
+      container_uri = "info:fedora/#{params[:container_id]}"
+      escaped_uri = container_uri.gsub(/(:)/, '\\:')
+      extra_controller_params =  {:q=>"cul_member_of_s:#{escaped_uri}"}
+      @response, @document_list = get_search_results( extra_controller_params )
+      
+      # Including this line so permissions tests can be run against the container
+      @container_response, @document = get_solr_response_for_doc_id(params[:container_id])
+      
+      # Including these lines for backwards compatibility (until we can use Rails3 callbacks)
+      @container =  ActiveFedora::Base.load_instance(params[:container_id])
+      @solr_result = @container.file_objects(:response_format=>:solr)
+    else
+      # @solr_result = ActiveFedora::SolrService.instance.conn.query('has_model_field:info\:fedora/ldpd\:Resource', @search_params)
+      @solr_result = Resource.find_by_solr(:all)
+    end
+    render :action=>params[:action], :layout=>layout
+  end
+  
+  def new
+    @asset = StaticImageAggregator.new
+    apply_depositor_metadata(@asset)
+    set_collection_type(@asset, params[:content_type])
+    if !params[:container_id].nil?
+      associate_resource_with_container(@asset, params[:container_id])
+    end
+    @asset.save
+    @asset.refresh
+    msg = "Created a Static Image Aggregator with pid #{@asset.pid}. Now it's ready to be edited."
+    flash[:notice]= msg
+  
+    if params.has_key?(:Filedata)
+      @file_asset = create_and_save_resource_from_params
+      apply_depositor_metadata(@file_asset)
+    
+      flash[:notice] += " The file #{params[:Filename]} has been saved in <a href=\"#{asset_url(@file_asset.pid)}\">#{@file_asset.pid}</a>."
+            
+      if !params[:container_id].nil?
+        associate_resource_with_container(@file_asset, @asset.pid)
+      end
+    
+      ## Apply any posted file metadata
+      unless params[:asset].nil?
+        logger.debug("applying submitted file metadata: #{@sanitized_params.inspect}")
+        @metadata_update_response = update_document(@file_asset, @sanitized_params)
+      end
+      @file_asset.save
+      # If redirect_params has not been set, use {:action=>:index}
+      logger.debug "Created #{@file_asset.pid}."
+    end
+    @asset.save
+    
+    session[:scripts] = params[:combined] == "true"
+    redirect_to url_for(:action=>"edit", :id=>@asset.pid, :new_asset=>true, :controller=>'catalog')
+
+  end
+
+  # Common destroy method for all AssetsControllers 
+  def destroy
+    # The correct implementation, with garbage collection:
+    # if params.has_key?(:container_id)
+    #   container = ActiveFedora::Base.load_instance(params[:container_id]) 
+    #   container.file_objects_remove(params[:id])
+    #   FileAsset.garbage_collect(params[:id])
+    # else
+    
+    # The dirty implementation (leaves relationship in container object, deletes regardless of whether the file object has other containers)
+    ActiveFedora::Base.load_instance(params[:id]).delete 
+    render :text => "Deleted #{params[:id]} from #{params[:container_id]}."
+  end
+  
+  
+  def show
+    @image_agg = StaticImageAggregator.find(params[:id])
+    if (@image_agg.nil?)
+      logger.warn("No such object: " + params[:id])
+      flash[:notice]= "No such object."
+      redirect_to(:action => 'index', :q => nil , :f => nil)
+    else
+      @id_array = @image_agg.containers(:response_format => :id_array)
+    end
+    render :action=>params[:action], :layout=>(params[:layout]=="false")
+  end
+end
+end

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::SearchHelper
+    #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