hydra-head 3.0.0pre1

data/lib/hydra/assets_controller_helper.rb

@@ -0,0 +1,144 @@
+require "om"
+module Hydra::AssetsControllerHelper
+  
+  def apply_depositor_metadata(asset)
+    if asset.respond_to?(:apply_depositor_metadata) && current_user.respond_to?(:login)
+      asset.apply_depositor_metadata(current_user.login)
+    end
+  end
+
+  def set_collection_type(asset, collection)
+    if asset.respond_to?(:set_collection_type)
+      asset.set_collection_type(collection)
+    end
+  end
+  
+  # 
+  # parses your params hash, massaging them into an appropriate set of params and opts to pass into ActiveFedora::Base.update_indexed_attributes
+  #
+  def prep_updater_method_args
+    logger.warn "DEPRECATED: Hydra::AssetsControllerHelper.prep_updater_method_args is deprecated.  Use/override sanitize_update_params instead."
+    args = {:params=>{}, :opts=>{}}
+    
+    params["asset"].each_pair do |datastream_name,fields|
+      
+      args[:opts][:datastreams] = datastream_name
+      
+      # TEMPORARY HACK: special case for supporting textile 
+      if params["field_id"]=="abstract_0" 
+        params[:field_selectors] = {"descMetadata" => {"abstract" => [:abstract]}}
+      end
+      
+      if params.fetch("field_selectors",false) && params["field_selectors"].fetch(datastream_name, false)
+        # If there is an entry in field_selectors for the datastream (implying a nokogiri datastream), retrieve the field_selector for this field.
+        # if no field selector, exists, use the field name
+        fields.each_pair do |field_name,field_values|
+          parent_select = OM.destringify( params["field_selectors"][datastream_name].fetch(field_name, field_name) )
+          args[:params][parent_select] = field_values       
+        end        
+      else
+        args[:params] = unescape_keys(params[:asset][datastream_name])
+      end
+    end
+    
+    @sanitized_params = args
+    return args
+     
+  end
+
+  
+  # Builds a Hash that you can feed into ActiveFedora::Base.update_datstream_attributes
+  # If params[:asset] is empty, returns an empty Hash
+  # @return [Hash] a Hash that you can feed into ActiveFedora::Base.update_datstream_attributes
+  #   {
+  #    "descMetadata"=>{ [{:person=>0}, :role]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"} },
+  #    "properties"=>{ "notes"=>"foo" }
+  #   }
+  def sanitize_update_params
+    @sanitized_params ||= {}
+    
+    unless params["asset"].nil?
+      params["asset"].each_pair do |datastream_name,fields|
+      
+        @sanitized_params[datastream_name] = {}
+      
+        # TEMPORARY HACK: special case for supporting textile 
+        if params["field_id"]=="abstract_0" 
+          params[:field_selectors] = {"descMetadata" => {"abstract" => [:abstract]}}
+        end
+      
+        if params.fetch("field_selectors",false) && params["field_selectors"].fetch(datastream_name, false)
+          # If there is an entry in field_selectors for the datastream (implying a nokogiri datastream), retrieve the field_selector for this field.
+          # if no field selector, exists, use the field name
+          fields.each_pair do |field_name,field_values|
+            parent_select = OM.destringify( params["field_selectors"][datastream_name].fetch(field_name, field_name) )
+            @sanitized_params[datastream_name][parent_select] = field_values       
+          end        
+        else
+          @sanitized_params[datastream_name] = unescape_keys(params[:asset][datastream_name])
+        end
+      end
+    end
+    
+    return @sanitized_params
+  end
+  
+  # Tidies up the response from updating the document, making it more JSON-friendly
+  # @param [Hash] response_from_update the response from updating the object's values
+  # @return [Hash] A Hash where value of "updated" is an array with fieldname / index / value Hash for each field updated
+  def tidy_response_from_update(response_from_update)
+    response = Hash["updated"=>[]]
+    last_result_value = ""
+    response_from_update.each_pair do |field_name,changed_values|
+      changed_values.each_pair do |index,value|
+        response["updated"] << {"field_name"=>field_name,"index"=>index,"value"=>value} 
+        last_result_value = value
+      end
+    end
+    # If handling submission from jeditable (which will only submit one value at a time), return the value it submitted
+    if params.has_key?(:field_id)
+      response = last_result_value
+    end
+    return response
+  end
+  
+  
+  # Updates the document based on the provided parameters
+  # @param [ActiveFedora::Base] document
+  # @param [Hash] params should be the type expected by ActiveFedora::Base.update_datastream_attributes
+  def update_document(document, params)
+    # this will only work if there is only one datastream being updated.
+    # once ActiveFedora::MetadataDatastream supports .update_datastream_attributes, use that method instead (will also be able to pass through params["asset"] as-is without usin prep_updater_method_args!)
+    # result = document.update_indexed_attributes(params[:params], params[:opts])
+    result = document.update_datastream_attributes(params)
+  end
+  
+  # moved destringify into OM gem. 
+  # ie.  OM.destringify( params )
+  # Note: OM now handles destringifying params internally.  You probably don't have to do it!
+  
+  private
+    
+  def send_datastream(datastream)
+    send_data datastream.content, :filename=>datastream.label, :type=>datastream.attributes["mimeType"]
+  end
+  
+  #underscores are escaped w/ + signs, which are unescaped by rails to spaces
+  def unescape_keys(attrs)
+    h=Hash.new
+    attrs.each do |k,v|
+      h[k.gsub(/ /, '_')]=v
+
+    end
+    h
+  end
+  def escape_keys(attrs)
+    h=Hash.new
+    attrs.each do |k,v|
+      h[k.gsub(/_/, '+')]=v
+
+    end
+    h
+  end
+  
+end

data/lib/hydra/catalog.rb

@@ -0,0 +1,64 @@
+require "hydra/access_controls_enforcement"
+# Include this module into any of your Blacklight Catalog classes (ie. CatalogController) to add Hydra functionality
+#
+# The primary function of this module is to mix in a number of other Hydra Modules, including 
+#   Hydra::AccessControlsEnforcement
+#
+# This module will only work if you also include Blacklight::Catalog in the Controller you're extending.
+# The hydra head rails generator will create the CatalogController for you in app/controllers/catalog_controller.rb
+# @example 
+#  require 'blacklight/catalog'
+#  require 'hydra/catalog'
+#  class CustomCatalogController < ApplicationController  
+#    include Blacklight::Catalog
+#    include Hydra::Catalog
+#  end
+module Hydra::Catalog
+  
+  def self.included(klass)
+    # Other modules to auto-include
+    klass.send(:include, Hydra::AccessControlsEnforcement)
+    klass.send(:include, MediaShelf::ActiveFedoraHelper)
+    klass.send(:include, Hydra::RepositoryController)
+    
+    
+    # Controller filters
+    # Also see the generator (or generated CatalogController) to see more before_filters in action
+    klass.before_filter :require_solr, :require_fedora, :only=>[:show, :edit, :index, :delete]
+    klass.before_filter :load_fedora_document, :only=>[:show,:edit]
+    klass.before_filter :lookup_facets, :only=>:edit
+    
+    # View Helpers
+    klass.helper :hydra
+    klass.helper :hydra_assets
+    klass.helper :hydra_uploader
+    klass.helper :article_metadata
+  end
+  
+  def edit
+    show
+    render "show"
+  end
+  
+  # This will render the "delete" confirmation page and a form to submit a destroy request to the assets controller
+  def delete
+    show
+    render "show"
+  end
+  
+  def load_fedora_document
+    af_base = ActiveFedora::Base.load_instance(params[:id])
+    the_model = ActiveFedora::ContentModel.known_models_for( af_base ).first
+    if the_model.nil?
+      @document_fedora = af_base
+    else
+      @document_fedora = the_model.load_instance(params[:id])
+    end
+    @file_assets = @document_fedora.file_objects(:response_format=>:solr)
+  end
+  
+  def lookup_facets
+    params = {:qt=>"search",:defType=>"dismax",:q=>"*:*",:rows=>"0",:facet=>"true", :facets=>{:fields=>Blacklight.config[:facet][:field_names]}}
+    @facet_lookup = Blacklight.solr.find params
+  end
+end

data/lib/hydra/common_mods_index_methods.rb

@@ -0,0 +1,42 @@
+# Provides some helper methods for indexing compound or non-standard facets
+#
+# == Methods
+# 
+# extract_person_full_names
+#   This method returns a Hash of person_full_name_facet values which combine Lastname, Firstname
+# extract_person_organizations
+#   This method returns a Hash of person_full_name_facet values which extract the persons affiliation and puts it in an mods_organization_facet
+
+module Hydra::CommonModsIndexMethods
+  # Extracts the first and last names of persons and creates Solr::Field objects with for person_full_name_facet
+  #
+  # == Returns:
+  # An array of Solr::Field objects
+  #
+  def extract_person_full_names
+    names = {}
+    self.find_by_terms(:person).each do |person|
+      name_parts = person.children.inject({}) do |hash,child|
+        hash[child.get_attribute(:type)] = child.text if ["family","given"].include? child.get_attribute(:type)
+        hash
+      end
+      ::Solrizer::Extractor.insert_solr_field_value(names,  "person_full_name_facet", [name_parts["family"], name_parts["given"]].join(", ") ) if name_parts.keys == ["family","given"]
+      names
+    end
+    return names
+  end
+
+  # Extracts the affiliations of persons and creates Solr::Field objects for them
+  #
+  # == Returns:
+  # An array of Solr::Field objects
+  #
+  def extract_person_organizations
+    # self.find_by_terms(:person,:affiliation).map { |org| Solr::Field.new({:mods_organization_facet=>org.text}) }
+    orgs = {}
+    self.find_by_terms(:person,:affiliation).each do |org| 
+      ::Solrizer::Extractor.insert_solr_field_value(orgs, "mods_organization_facet", org.text) 
+    end
+    return orgs
+  end
+end

data/lib/hydra/controller.rb

@@ -0,0 +1,7 @@
+# Adds behaviors that Hydra needs all controllers to have. (mostly view helpers)
+module Hydra::Controller
+  def self.included(base)
+    base.helper :hydra_assets
+    base.helper :hydra_fedora_metadata
+  end
+end

data/lib/hydra/file_assets_helper.rb

@@ -0,0 +1,144 @@
+module Hydra::FileAssetsHelper
+  
+  # Creates a File Asset, adding the posted blob to the File Asset's datastreams and saves the File Asset
+  #
+  # @return [FileAsset] the File Asset  
+  def create_and_save_file_asset_from_params
+    if params.has_key?(:Filedata)
+      @file_asset = create_asset_from_params
+      add_posted_blob_to_asset
+      @file_asset.save
+      return @file_asset
+    else
+      render :text => "400 Bad Request", :status => 400
+    end
+  end
+  
+  # Puts the contents of params[:Filedata] (posted blob) into a datastream within the given @asset
+  # Sets asset label and title to filename if they're empty
+  #
+  # @param [FileAsset] the File Asset to add the blob to
+  # @return [FileAsset] the File Asset  
+  def add_posted_blob_to_asset(asset=@file_asset)
+    file_name = filename_from_params
+    asset.add_file_datastream(posted_file, :label=>file_name, :mimeType=>mime_type(file_name))
+    asset.set_title_and_label( file_name, :only_if_blank=>true )
+  end
+  
+  # Associate the new file asset with its container
+  def associate_file_asset_with_container(file_asset=nil, container_id=nil)
+    if container_id.nil?
+      container_id = params[:asset_id]
+    end
+    if file_asset.nil?
+      file_asset = @file_asset
+    end
+    file_asset.add_relationship(:is_part_of, container_id)
+    file_asset.datastreams["RELS-EXT"].dirty = true
+    file_asset.save
+  end
+  
+  # Apply any posted file metadata to the file asset
+  def apply_posted_file_metadata         
+    @metadata_update_response = update_document(@file_asset, @sanitized_params)
+    @file_asset.save
+  end
+  
+  
+  # The posted File 
+  # @return [File] the posted file.  Defaults to nil if no file was posted.
+  def posted_file
+    params[:Filedata]
+  end
+  
+  # A best-guess filename based on POST params
+  # If Filename was submitted, it uses that.  Otherwise, it calls +original_filename+ on the posted file
+  def filename_from_params
+    if !params[:Filename].nil?
+      file_name = params[:Filename]      
+    else
+      file_name = posted_file.original_filename
+      params[:Filename] = file_name
+    end
+  end
+  
+  # Creates a File Asset and sets its label from params[:Filename]
+  #
+  # @return [FileAsset] the File Asset
+  def create_asset_from_params    
+    file_asset = FileAsset.new
+    file_asset.label = params[:Filename]
+    
+    return file_asset
+  end
+  
+  # This is pre-Hydra code that created an AudioAsset, VideoAsset or ImageAsset based on the
+  # current params in the controller.
+  #
+  # @return [Constant] the recommended Asset class
+  def asset_class_from_params
+    if params.has_key?(:type)
+      chosen_type = case params[:type]
+      when "AudioAsset"
+        AudioAsset
+      when "VideoAsset"
+        VideoAsset
+      when "ImageAsset"
+        ImageAsset
+      else
+        FileAsset
+      end
+    elsif params.has_key?(:Filename)
+      chosen_type = choose_model_by_filename( params[:Filename] )
+    else
+      chosen_type = FileAsset
+    end
+    
+    return chosen_type
+  end
+  
+  def choose_model_by_filename(filename)
+    choose_model_by_filename_extension( File.extname(filename) )
+  end
+  
+  # Rudimentary method to choose an Asset class based on a filename extension
+  #
+  # @param [String] extension
+  # @return [Constant] the recommended Asset class.  Default: FileAsset
+  #
+  # Recognized extensions: 
+  # AudioAsset => ".wav", ".mp3", ".aiff"
+  # VideoAsset => ".mov", ".flv", ".mp4"
+  # ImageAsset => ".jpeg", ".jpg", ".gif", ".png"
+  def choose_model_by_filename_extension(extension)
+    
+    Hydra.config[:file_asset_types][:extension_mappings].each_pair do |klass, extensions|
+      if extensions.include?(extension)
+        return klass
+      end
+    end
+    
+    return Hydra.config[:file_asset_types][:default]
+    
+    # case extension
+    # when ".wav", ".mp3", ".aiff"
+    #   AudioAsset
+    # when ".mov", ".flv", ".mp4", ".m4v"
+    #   VideoAsset
+    # when ".jpeg", ".jpg", ".gif", ".png"
+    #   ImageAsset
+    # else
+    #  FileAsset
+    # end
+  end
+
+  private
+  # Return the mimeType for a given file name
+  # @param [String] file_name The filename to use to get the mimeType
+  # @return [String] mimeType for filename passed in. Default: application/octet-stream if mimeType cannot be determined
+  def mime_type file_name
+    mime_types = MIME::Types.of(file_name)
+    mime_type = mime_types.empty? ? "application/octet-stream" : mime_types.first.content_type
+  end
+  
+end

data/lib/hydra/fixtures.rb

@@ -0,0 +1,43 @@
+module Hydra
+
+  class Fixtures
+    def self.filename_for_pid(pid)
+      File.join("test_support","fixtures","#{pid.gsub(":","_")}.foxml.xml")
+    end
+
+    def self.delete(pid)
+      begin
+        ActiveFedora::Base.load_instance(pid).delete
+        1
+      rescue ActiveFedora::ObjectNotFoundError
+        logger.debug "The object #{pid} has already been deleted (or was never created)."
+        0
+      end
+    end
+
+    def self.reload(pid)
+      delete(pid)
+      import_and_index(pid)
+    end
+
+    def self.import_and_index(pid)
+      body = import_to_fedora(filename_for_pid(pid))
+      index(pid)
+      body
+    end
+
+    def self.index(pid)
+        solrizer = Solrizer::Fedora::Solrizer.new 
+        solrizer.solrize(pid) 
+    end
+
+    def self.import_to_fedora(filename)
+      file = File.new(filename, "r")
+puts "Loading #{filename}"
+      result = foxml = Fedora::Repository.instance.ingest(file.read)
+      raise "Failed to ingest the fixture." unless result
+      result.body
+    end
+  end
+
+end