hydra-head 3.0.0pre1

data/app/helpers/hydra_assets_helper.rb

@@ -0,0 +1,75 @@
+require 'mediashelf/active_fedora_helper'
+
+module HydraAssetsHelper
+  include MediaShelf::ActiveFedoraHelper
+
+  # Create a link for creating a new asset of the specified content_type
+  # If user is not logged in, the link leads to the login page with appropriate redirect params for creating the asset after logging in
+  # @param [String] link_label for the link
+  # @param [String] content_type 
+  def link_to_create_asset(link_label, content_type)
+    if current_user
+      link_to link_label, {:action => 'new', :controller => 'assets', :content_type => content_type}, :class=>"create_asset"
+    else      
+      link_to link_label, new_user_session_path(:redirect_params => {:action => "new", :controller=> "assets", :content_type => content_type}), :class=>"create_asset"
+    end
+  end
+  
+  # Render a link to delete the given asset from the repository.
+  # Includes a confirmation message. 
+  def delete_asset_link(pid, asset_type_display="asset")
+    "<a href=\"#{ url_for(:action=>:delete, :controller=>:catalog, :id=>pid)}\" class=\"delete_asset\" >Delete this #{asset_type_display}</a>".html_safe
+  end
+
+  def document_type(document)
+    document.fetch( Blacklight.config[:show][:display_type],[""]).first.gsub("info:fedora/afmodel:","")
+  end
+
+  def get_person_from_role(doc,role,opts={})  
+    i = 0
+    while i < 10
+      persons_roles = doc["person_#{i}_role_t"].map{|w|w.strip.downcase} unless doc["person_#{i}_role_t"].nil?
+      if persons_roles and persons_roles.include?(role.downcase)
+        return {:first=>doc["person_#{i}_first_name_t"], :last=>doc["person_#{i}_last_name_t"]}
+      end
+      i += 1
+    end
+  end
+
+  def get_file_asset_count(document)
+    count = 0
+    obj = load_af_instance_from_solr(document)
+    count += obj.file_objects.length unless obj.nil?
+    count
+  end
+  
+  def get_file_asset_description(document)
+    obj = load_af_instance_from_solr(document)
+    if obj.nil? || obj.file_objects.empty?
+      return ""
+    else
+       fobj = FileAsset.load_instance_from_solr(obj.file_objects.first.pid)
+       fobj.nil? ? "" : short_description(fobj.datastreams["descMetadata"].get_values("description").first)
+    end
+  end
+
+  def short_description(desc,max=150)
+    if desc.length > max
+      desc = desc[0..max].concat("...")
+    end
+    short_description = desc.capitalize
+  end
+  
+  def datastream_disseminator_url pid, datastream_name
+    begin
+      base_url = Fedora::Repository.instance.send(:connection).site.to_s
+    rescue
+      base_url = "http://localhost:8983/fedora"
+    end
+    "#{base_url}/get/#{pid}/#{datastream_name}"
+  end
+  
+  def disseminator_link pid, datastream_name
+    "<a class=\"fbImage\" href=\"#{ datastream_disseminator_url(pid, datastream_name) }\">view</a>"
+  end
+end

data/app/helpers/hydra_djatoka_helper.rb

@@ -0,0 +1,23 @@
+module HydraDjatokaHelper
+  
+  def hydra_djatoka_url_for(document, opts={})
+    
+    if document.kind_of?(SolrDocument)
+      pid = document.id
+    elsif document.kind_of?(Mash) 
+      pid = document[:id]
+    elsif document.respond_to?(:pid)
+        pid = document.pid
+    end
+    
+    if !pid.nil?
+      if opts[:scale]
+        result = url_for(:controller=>:get,:action=>"show",:id=>pid, :format=>"jp2", "image_server[scale]"=>opts[:scale])
+      else
+        result = url_for(:controller=>:get,:action=>"show",:id=>pid, :format=>"jp2", "image_server"=>true)
+      end
+    end
+      
+  end
+  
+end

data/app/helpers/hydra_fedora_metadata_helper.rb

@@ -0,0 +1,365 @@
+require "inline_editable_metadata_helper"
+require "block_helpers"
+require "active_support"
+require "redcloth" # Provides textile parsing support for textile_area method
+require 'sanitize' # Replaces white_list_helper
+
+module HydraFedoraMetadataHelper
+  
+  def fedora_text_field(resource, datastream_name, field_key, opts={})
+    field_name = field_name_for(field_key)
+    field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
+    field_values = [""] if field_values.empty?
+    if opts.fetch(:multiple, true)
+      container_tag_type = :li
+    else
+      field_values = [field_values.first]
+      container_tag_type = :span
+    end
+    
+    body = ""
+    
+    field_values.each_with_index do |current_value, z|
+      base_id = generate_base_id(field_name, current_value, field_values, opts)
+      name = "asset[#{datastream_name}][#{field_name}][#{z}]"
+      body << "<#{container_tag_type.to_s} class=\"editable-container field\" id=\"#{base_id}-container\">"
+        body << "<a href=\"\" title=\"Delete '#{h(current_value)}'\" class=\"destructive field\">Delete</a>" if opts.fetch(:multiple, true) && !current_value.empty?
+        body << "<span class=\"editable-text text\" id=\"#{base_id}-text\" style=\"display:none;\">#{h(current_value.lstrip)}</span>"
+        body << "<input class=\"editable-edit edit\" id=\"#{base_id}\" data-datastream-name=\"#{datastream_name}\" rel=\"#{field_name}\" name=\"#{name}\" value=\"#{h(current_value.lstrip)}\"/>"
+      body << "</#{container_tag_type}>"
+    end
+    result = field_selectors_for(datastream_name, field_key)
+    if opts.fetch(:multiple, true)
+      result << content_tag(:ol, body.html_safe, :rel=>field_name)
+    else
+      result << body
+    end
+    
+    result.html_safe
+  end
+  
+  def fedora_text_area(resource, datastream_name, field_key, opts={})
+    fedora_textile_text_area(resource, datastream_name, field_key, opts)
+  end
+  
+  # Textile textarea varies from the other methods in a few ways
+  # Since we're using jeditable with this instead of fluid, we need to provide slightly different hooks for the javascript
+  # * we are storing the datastream name in data-datastream-name so that we can construct a load url on the fly when initializing the textarea
+  def fedora_textile_text_area(resource, datastream_name, field_key, opts={})
+    field_name = field_name_for(field_key)
+    field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
+    field_values = [""] if field_values.empty?
+    if opts.fetch(:multiple, true)
+      container_tag_type = :li
+    else
+      field_values = [field_values.first]
+      container_tag_type = :span
+    end
+    body = ""
+    
+    field_values.each_with_index do |current_value, z|
+      base_id = generate_base_id(field_name, current_value, field_values, opts)
+      name = "asset[#{datastream_name}][#{field_name}][#{z}]".html_safe
+      processed_field_value = Sanitize.clean( RedCloth.new(current_value, [:sanitize_html]).to_html, Sanitize::Config::BASIC)
+      
+      body << "<#{container_tag_type.to_s} class=\"editable-container field\" id=\"#{base_id}-container\">".html_safe
+        # Not sure why there is we're not allowing the for the first textile to be deleted, but this was in the original helper.
+        body << "<a href=\"\" title=\"Delete '#{h(current_value)}'\" class=\"destructive field\">Delete</a>".html_safe unless z == 0
+        body << "<span class=\"editable-text text\" id=\"#{base_id}-text\" style=\"display:none;\">#{processed_field_value}</span>".html_safe
+        body << "<textarea class=\"editable-edit edit\" id=\"#{base_id}\" data-datastream-name=\"#{datastream_name}\" rel=\"#{field_name}\" name=\"#{name}\" rows=\"10\" cols=\"25\">#{h(current_value)}</textarea>".html_safe
+      body << "</#{container_tag_type}>".html_safe
+    end
+    
+    result = field_selectors_for(datastream_name, field_key)
+    
+    if opts.fetch(:multiple, true)
+      result << content_tag(:ol, body.html_safe, :rel=>field_name)
+    else
+      result << body
+    end
+    result.html_safe
+    
+  end
+  
+  # Expects :choices option.  Option tags for the select are generated from the :choices option using Rails "options_for_select":http://apidock.com/rails/ActionView/Helpers/FormOptionsHelper/options_for_select helper
+  # If no :choices option is provided, returns a regular fedora_text_field
+  def fedora_select(resource, datastream_name, field_key, opts={})
+    if opts[:choices].nil?
+      result = fedora_text_field(resource, datastream_name, field_key, opts)
+    else
+      choices = opts[:choices]
+      field_name = field_name_for(field_key)
+      field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
+      
+      body = ""
+      z = 0
+      base_id = generate_base_id(field_name, field_values.first, field_values, opts.merge({:multiple=>false}))
+      name = "asset[#{datastream_name}][#{field_name}][#{z}]".html_safe
+
+      body << "<select name=\"#{name}\" class=\"metadata-dd select-edit\" id=\"#{field_name}\" rel=\"#{field_name}\">".html_safe
+        body << options_for_select(choices, field_values)
+      body << "</select>".html_safe
+      
+      result = field_selectors_for(datastream_name, field_key)
+      result << body.html_safe
+    end
+    return result
+  end
+  
+  def fedora_date_select(resource, datastream_name, field_key, opts={})
+    field_name = field_name_for(field_key)
+    field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
+    base_id = generate_base_id(field_name, field_values.first, field_values, opts.merge({:multiple=>false}))
+    name = "asset[#{datastream_name}][#{base_id}]".html_safe
+    
+    value = field_values.first
+    field_value = value.nil? ? "" : value
+        
+    field_value[/(\d+)-(\d+)-(\d+)/]
+    year = ($1.nil? or $1.empty?) ? "" : $1.to_i
+    month = ($2.nil? or $2.empty?) ? "-1" : $2
+    day = ($3.nil? or $3.empty?) ? "-1" : $3
+    
+    # Make sure that month and day values are double-digit
+    [month, day].each {|v| v.length == 1 ? v.insert(0, "0") : nil }
+    
+    
+    year_options = Array.new(101) {|i| 1910+i}
+    # year_options = Array.new(4) {|i| 1990+i}
+    
+    year_options.insert(0, ["Year", "-1"])
+    
+    body = ""
+    body << "<div class=\"date-select\" name=\"#{name}\" rel=\"#{field_name}\">".html_safe
+      body << "<input class=\"controlled-date-part w4em\" style=\"width:4em;\" type=\"text\" id=\"#{base_id}-sel-y\" name=\"#{base_id}-sel-y\" maxlength=\"4\" value=\"#{year}\" />".html_safe
+      body << "<select class=\"controlled-date-part\" id=\"#{base_id}-sel-mm\" name=\"#{base_id}-sel-mm\">".html_safe
+        body << options_for_select([["Month","-1"],["January", "01"],["February", "02"],["March", "03"],
+                                      ["April", "04"],["May", "05"],["June", "06"],["July", "07"],["August", "08"],
+                                      ["September", "09"],["October", "10"],["November", "11"],["December", "12"]
+                                      ], month)
+      body << "</select> / ".html_safe
+      body << "<select class=\"controlled-date-part\" id=\"#{base_id}-sel-dd\" name=\"#{base_id}-sel-dd\">".html_safe
+        body << options_for_select([["Day","-1"],"01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31"], day)
+      body << "</select>".html_safe
+    body << "</div>".html_safe
+
+    script = <<-EOF
+    <script type="text/javascript">
+    // <![CDATA[  
+      // since the form element ids need to be generated on the server side for the options, the options are attached to the wrapping div via the jQuery data() method.
+      $('div.date-select[name="#{name}"]').data("opts", {                            
+        formElements:{"#{base_id}-sel-dd":"d","#{base_id}-sel-y":"Y","#{base_id}-sel-mm":"m"}         
+      });          
+    // ]]>
+    </script>
+    EOF
+    body << script.html_safe
+
+    
+    result = field_selectors_for(datastream_name, field_key)
+    result << body.html_safe
+    return result
+  end
+
+  def fedora_submit(resource, datastream_name, field_key, opts={})
+    result = ""
+    h_name = OM::XML::Terminology.term_hierarchical_name(*field_key)    
+    field_key.each do |pointer|
+      result << tag(:input, :type=>"submit", :rel=>h_name, :name=>"field_selectors[#{datastream_name}][#{h_name}]", :value => field_key.to_s.capitalize)
+    end
+    return result
+  end
+  
+  def fedora_checkbox(resource, datastream_name, field_key, opts={})
+    result = ""
+    field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
+    h_name = OM::XML::Terminology.term_hierarchical_name(*field_key)    
+    
+    v_name = field_key.last.to_s
+
+    checked = field_values.first.downcase == "yes" ? "checked" : ""
+    
+    result = field_selectors_for(datastream_name, field_key)
+    
+    # adding so that customized checked and unchecked values can be passed in
+    checked_value = (opts[:default_values] && opts[:default_values][:checked]) ? opts[:default_values][:checked] : "yes"
+    unchecked_value = (opts[:default_values] && opts[:default_values][:unchecked]) ? opts[:default_values][:unchecked] : "no"
+
+    result << tag(:input, :type=>"hidden", :id=>"#{h_name}_checked_value", :value=>checked_value )
+    result << tag(:input, :type=>"hidden", :id=>"#{h_name}_unchecked_value", :value=>unchecked_value )
+    
+    if field_values.first.downcase == "yes"
+      result << tag(:input, :type=>"checkbox", :id=>h_name, :class=>"fedora-checkbox", :rel=>h_name, :name=>"asset[#{datastream_name}][#{h_name}][0]", :value=>checked_value, :checked=>"checked")
+    else
+      result << tag(:input, :type=>"checkbox", :id=>h_name, :class=>"fedora-checkbox", :rel=>h_name, :name=>"asset[#{datastream_name}][#{h_name}][0]", :value=>unchecked_value)
+    end
+    return result
+  end
+  
+  # Expects :choices option. 
+  # :choices should be a hash with value/label pairs
+  # :choices => {"first_choice"=>"Apple", "second_choice"=>"Pear" }
+  # If no :choices option is provided, returns a regular fedora_text_field
+  def fedora_radio_button(resource, datastream_name, field_key, opts={})
+    if opts[:choices].nil?
+      result = fedora_text_field(resource, datastream_name, field_key, opts)
+    else
+      choices = opts[:choices]
+      
+      field_name = field_name_for(field_key)
+      field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
+      h_name = OM::XML::Terminology.term_hierarchical_name(*field_key)    
+      default_value = opts.keys.include?(:default_value) ? opts[:default_value] : ""
+      
+      selected_value = field_values.empty? ? "" : field_values.first
+      selected_value = default_value if selected_value.blank?
+
+      body = ""
+      z = 0
+      base_id = generate_base_id(field_name, field_values.first, field_values, opts.merge({:multiple=>false}))
+      name = "asset[#{datastream_name}][#{field_name}][#{z}]"
+      
+      result = field_selectors_for(datastream_name, field_key)
+      choices.sort.each do |choice,label|
+        if choice == selected_value
+          result << tag(:input, :type=>"radio", :id=>"availability_#{choice}", :class=>"fedora-radio-button", :rel=>h_name, :name=>"asset[#{datastream_name}][#{h_name}][0]", :value=>choice.downcase, :checked=>true)
+        else
+          result << tag(:input, :type=>"radio", :id=>"availability_#{choice}", :class=>"fedora-radio-button", :rel=>h_name, :name=>"asset[#{datastream_name}][#{h_name}][0]", :value=>choice.downcase)
+        end
+        result << " <label>#{label}</label> ".html_safe
+      end
+      result
+    end
+    return result
+  end
+  
+  
+  def fedora_text_field_insert_link(datastream_name, field_key, opts={})
+    field_name = field_name_for(field_key) || field_key
+    field_type = field_name == "person" ? "person" : "textfield"    
+    link_text = "Add #{(opts[:label] || field_key.last || field_key).to_s.camelize.titlecase}"
+    "<a class='addval #{field_type}' href='#' data-datastream-name=\"#{datastream_name}\" rel=\"#{field_name}\" title='#{link_text}'>#{link_text}</a>".html_safe
+  end
+  
+  def fedora_text_area_insert_link(datastream_name, field_key, opts={})
+    field_name = field_name_for(field_key)
+    link_text = "Add #{(opts[:label] || field_key.last || field_key).to_s.camelize.titlecase}".html_safe
+    "<a class='addval textarea' href='#' data-datastream-name=\"#{datastream_name}\" rel=\"#{field_name}\" title='#{link_text}'>#{link_text}</a>".html_safe
+  end
+  
+  def fedora_field_label(datastream_name, field_key, label=nil)
+    field_name = field_name_for(field_key)
+    if label.nil?
+      label = field_name
+    end
+    return content_tag "label", label, :for=>field_name
+  end
+  
+  # Generate hidden inputs to handle mapping field names to server-side metadata mappings
+  # this allows us to round-trip OM metadata mappings
+  # also (importantly) allows us to avoid executing xpath queries from http requests.
+  # *Note*: It's important that you serialize these inputs in order from top to bottom (standard HTML form behavior)
+  def field_selectors_for(datastream_name, field_key)
+    result = ""
+    if field_key.kind_of?(Array)
+      h_name = OM::XML::Terminology.term_hierarchical_name(*field_key)
+      field_key.each do |pointer|
+        if pointer.kind_of?(Hash)
+          k = pointer.keys.first
+          v = pointer.values.first
+          # result << "<input type=\"hidden\", rel=\"#{h_name}\" name=\"field_selectors[#{datastream_name}][#{h_name}][][#{k}]\" value=\"#{v}\"/>"
+          result << tag(:input, :type=>"hidden", :class=>"fieldselector", :rel=>h_name, :name=>"field_selectors[#{datastream_name}][#{h_name}][][#{k}]", :value=>v)
+        else
+          result << tag(:input, :type=>"hidden", :class=>"fieldselector", :rel=>h_name, :name=>"field_selectors[#{datastream_name}][#{h_name}][]", :value=>pointer.to_s)
+        end
+      end
+    end
+    return result
+  end
+  
+  # hydra_form_for block helper 
+  # allows you to construct an entire hydra form by passing a block into this method
+  class HydraFormFor < BlockHelpers::Base
+
+    def initialize(resource, opts={})
+      @resource = resource
+    end
+    
+    def fedora_label(datastream_name, field_key, opts={})
+      helper.fedora_label(@resource, datastream_name, field_key, opts)
+    end
+    
+    def fedora_text_field(datastream_name, field_key, opts={})
+      helper.fedora_label(@resource, datastream_name, field_key, opts)
+    end
+
+    def fedora_text_area(datastream_name, field_key, opts={})
+      helper.fedora_text_area(@resource, datastream_name, field_key, opts)
+    end
+    
+    def fedora_select(datastream_name, field_key, opts={})
+      helper.fedora_select(@resource, datastream_name, field_key, opts)
+    end
+
+    def fedora_submit(datastream_name, field_key, opts={})
+      helper.fedora_submit(@resource, datastream_name, field_key, opts)
+    end
+    
+    def fedora_checkbox(datastream_name, field_key, opts={})
+      helper.fedora_checkbox(@resource, datastream_name, field_key, opts)
+    end
+    
+    def fedora_radio_button(datastream_name, field_key, opts={})
+      helper.fedora_radio_button(@resource, datastream_name, field_key, opts)
+    end    
+    
+    def fedora_text_field_insert_link(datastream_name, field_key, opts={})
+      helper.fedora_text_field_insert_link(@resource, datastream_name, field_key, opts={})
+    end
+    
+    def fedora_field_label(datastream_name, field_key, opts={})
+      helper.fedora_field_label(@resource, datastream_name, field_key, opts)
+    end
+
+    def display(body)
+      inner_html = content_tag :input, :type=>"hidden", :name=>"content_type", :value=>@resource.class.to_s.underscore
+      inner_html = inner_html << body
+      content_tag :form, inner_html
+    end
+
+  end
+  
+  #
+  # Internal helper methods
+  #
+  
+  # retrieve field values from datastream.
+  # If :values is provided, skips accessing the datastream and returns the contents of :values instead.
+  def get_values_from_datastream(resource, datastream_name, field_key, opts={})
+    if opts.has_key?(:values)
+      values = opts[:values]
+      if values.nil? then values = [opts.fetch(:default, "")] end
+    else
+      values = resource.get_values_from_datastream(datastream_name, field_key, opts.fetch(:default, ""))
+      if values.empty? then values = [ opts.fetch(:default, "") ] end
+    end
+    return values
+  end
+  
+  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 generate_base_id(field_name, current_value, values, opts)
+    if opts.fetch(:multiple, true)
+      return field_name+"_"+values.index(current_value).to_s
+    else
+      return field_name
+    end
+  end
+  
+end