hydra-head 3.0.0pre1

data/lib/hydra/repository_controller.rb

@@ -0,0 +1,102 @@
+require "mediashelf/active_fedora_helper"
+# Hydra-repository Contoller is a controller layer mixin. It is in the controller scope: request params, session etc.
+# 
+# NOTE: Be careful when creating variables here as they may be overriding something that already exists.
+# The ActionController docs: http://api.rubyonrails.org/classes/ActionController/Base.html
+#
+# Override these methods in your own controller for customizations:
+# 
+# class HomeController < ActionController::Base
+#   
+#   include Stanford::SolrHelper
+#   
+#   def solr_search_params
+#     super.merge :per_page=>10
+#   end
+#   
+# end
+#
+module Hydra::RepositoryController
+  
+  include MediaShelf::ActiveFedoraHelper
+      
+      
+  
+  
+  def self.included(c)
+    if c.respond_to?(:helper_method)
+      c.helper_method :solr_name
+      c.helper_method :format_pid
+    end
+  end
+  
+  
+  #
+  # This method converts pid strings into xhtml safe IDs, since xhmlt expects namespaces to be defined. 
+  # I.E. hydrus:123 = hydrus_123
+  def format_pid(pid)
+    pid.gsub(":", "_")
+  end
+  
+  
+  
+  def solr_name(field_name, field_type = :text)
+    ::ActiveFedora::SolrService.solr_name(field_name, field_type)
+  end
+  
+  # Uses submitted params Hash to figure out what Model to load
+  # params should contain :content_type and :id
+  def load_document_from_params
+    af_model = retrieve_af_model(params[:content_type])
+    unless af_model 
+      af_model = ModsAsset
+    end
+    return af_model.find(params[:id])
+  end
+  
+  # Returns a list of datastreams for download.
+  # Uses user's roles and "mime_type" value in submitted params to decide what to return.
+  # if you pass the optional argument of :canonical=>true, it will return the canonical datastream for this object (a single object not a hash of datastreams)
+  def downloadables(fedora_object=@fedora_object, opts={})
+    if opts[:canonical]
+      mime_type = opts[:mime_type] ? opts[:mime_type] : "application/pdf"
+      result = filter_datastreams_for_mime_type(fedora_object.datastreams, mime_type).sort.first[1]
+    elsif editor? 
+      if params["mime_type"] == "all"
+        result = fedora_object.datastreams
+      else
+        result = Hash[]
+        fedora_object.datastreams.each_pair do |dsid,ds|
+          if !ds.new_object?
+            mime_type = ds.attributes["mimeType"] ? ds.attributes["mimeType"] : ""
+            if mime_type.include?("pdf") || ds.label.include?("_TEXT.xml") || ds.label.include?("_METS.xml")
+             result[dsid] = ds
+            end 
+          end 
+        end
+      end
+    else
+      result = Hash[]
+      fedora_object.datastreams.each_pair do |dsid,ds|
+         if ds.attributes["mimeType"].include?("pdf")
+           result[dsid] = ds
+         end  
+       end
+    end 
+    # puts "downloadables result: #{result}"
+    return result    
+  end
+  
+  private
+  
+  def filter_datastreams_for_mime_type(datastreams_hash, mime_type)
+    result = Hash[]
+    datastreams_hash.each_pair do |dsid,ds|
+      ds_mime_type = ds.attributes["mimeType"] ? ds.attributes["mimeType"] : ""
+      if ds_mime_type == mime_type
+       result[dsid] = ds
+      end  
+    end
+    return result
+  end
+end

data/lib/hydra/rights_metadata.rb

@@ -0,0 +1,189 @@
+require "active-fedora"
+module Hydra
+class RightsMetadata < ActiveFedora::NokogiriDatastream       
+  
+  set_terminology do |t|
+    t.root(:path=>"rightsMetadata", :xmlns=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd") 
+    t.copyright {
+      t.machine {
+        t.uvalicense
+        t.cclicense   
+        t.license     
+      }
+      t.human_readable(:path=>"human")
+      t.license(:proxy=>[:machine, :license ])            
+      t.cclicense(:proxy=>[:machine, :cclicense ])                  
+    }
+    t.access {
+      t.human_readable(:path=>"human")
+      t.machine {
+        t.group
+        t.person
+      }
+      t.person(:proxy=>[:machine, :person])
+      t.group(:proxy=>[:machine, :group])
+      # accessor :access_person, :term=>[:access, :machine, :person]
+    }
+    t.discover_access(:ref=>[:access], :attributes=>{:type=>"discover"})
+    t.read_access(:ref=>[:access], :attributes=>{:type=>"read"})
+    t.edit_access(:ref=>[:access], :attributes=>{:type=>"edit"})
+    # A bug in OM prevnts us from declaring proxy terms at the root of a Terminology
+    # t.access_person(:proxy=>[:access,:machine,:person])
+    # t.access_group(:proxy=>[:access,:machine,:group])
+    
+    t.embargo {
+      t.human_readable(:path=>"human")
+      t.machine{
+        t.date(:type =>"release")
+      }
+      t.embargo_release_date(:proxy => [:machine, :date])
+    }    
+  end
+    
+  # Generates an empty Mods Article (used when you call ModsArticle.new without passing in existing xml)
+  def self.xml_template
+    builder = Nokogiri::XML::Builder.new do |xml|
+      xml.rightsMetadata(:version=>"0.1", "xmlns"=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1") {
+        xml.copyright {
+          xml.human
+          xml.machine {
+            xml.uvalicense "no"
+          }
+        }
+        xml.access(:type=>"discover") {
+          xml.human
+          xml.machine
+        }
+        xml.access(:type=>"read") {
+          xml.human 
+          xml.machine
+        }
+        xml.access(:type=>"edit") {
+          xml.human
+          xml.machine
+        }
+        xml.embargo{
+          xml.human
+          xml.machine
+        }        
+      }
+    end
+    return builder.doc
+  end
+    
+  # Returns the permissions for the selected person/group
+  # If new_access_level is provided, updates the selected person/group access_level to the one specified 
+  # A new_access_level of "none" will remove all access_levels for the selected person/group
+  # @param [Hash] selector hash in format {type => identifier}
+  # @param new_access_level (default nil)
+  # @return Hash in format {type => access_level}.  
+  # 
+  # ie. 
+  # permissions({:person=>"person123"})
+  # => {"person123"=>"edit"}
+  # permissions({:person=>"person123"}, "read")
+  # => {"person123"=>"read"}
+  # permissions({:person=>"person123"})
+  # => {"person123"=>"read"}
+  def permissions(selector, new_access_level=nil)
+    
+    type = selector.keys.first.to_sym
+    actor = selector.values.first
+    if new_access_level.nil?
+      xpath = self.class.terminology.xpath_for(:access, type, actor)
+      nodeset = self.find_by_terms(xpath)
+      if nodeset.empty?
+        return "none"
+      else
+        return nodeset.first.ancestors("access").first.attributes["type"].text
+      end
+    else
+      remove_all_permissions(selector)
+      unless new_access_level == "none" 
+        access_type_symbol = "#{new_access_level}_access".to_sym
+        result = self.update_values([access_type_symbol, type] => {"-1"=>actor})
+      end
+      self.dirty = true
+      return new_access_level
+    end
+      
+  end
+  
+  # Reports on which groups have which permissions
+  # @return Hash in format {group_name => group_permissions, group_name => group_permissions}
+  def groups
+    return quick_search_by_type(:group)
+  end
+  
+  # Reports on which groups have which permissions
+  # @return Hash in format {person_name => person_permissions, person_name => person_permissions}
+  def individuals
+    return quick_search_by_type(:person)
+  end
+  
+  # Updates permissions for all of the persons and groups in a hash
+  # @param ex. {"group"=>{"group1"=>"discover","group2"=>"edit"}, "person"=>{"person1"=>"read","person2"=>"discover"}}
+  # Currently restricts actor type to group or person.  Any others will be ignored
+  def update_permissions(params)
+    params.fetch("group", {}).each_pair {|group_id, access_level| self.permissions({"group"=>group_id}, access_level)}
+    params.fetch("person", {}).each_pair {|group_id, access_level| self.permissions({"person"=>group_id}, access_level)}
+  end
+  
+  # @param [Symbol] symbol (either :group or :person)
+  # @return 
+  # This method limits the response to known access levels.  Probably runs a bit faster than .permissions().
+  def quick_search_by_type(type)
+    result = {}
+    [{:discover_access=>"discover"},{:read_access=>"read"},{:edit_access=>"edit"}].each do |access_levels_hash|
+      access_level = access_levels_hash.keys.first
+      access_level_name = access_levels_hash.values.first
+      self.find_by_terms(*[access_level, type]).each do |entry|
+        result[entry.text] = access_level_name
+      end
+    end
+    return result
+  end
+
+  attr_reader :embargo_release_date
+  def embargo_release_date=(release_date)
+    release_date = release_date.to_s if release_date.is_a? Date
+    begin
+      Date.parse(release_date)
+    rescue 
+      return "INVALID DATE"
+    end
+    self.update_values({[:embargo,:machine,:date]=>release_date})
+  end
+  def embargo_release_date(opts={})
+    embargo_release_date = self.find_by_terms(*[:embargo,:machine,:date]).first ? self.find_by_terms(*[:embargo,:machine,:date]).first.text : nil
+    if opts[:format] && opts[:format] == :solr_date
+      embargo_release_date << "T23:59:59Z"
+    end
+    embargo_release_date
+  end
+  def under_embargo?
+    (embargo_release_date && Date.today < embargo_release_date.to_date) ? true : false
+  end
+
+  def to_solr(solr_doc=Hash.new)
+    super(solr_doc)
+    ::Solrizer::Extractor.insert_solr_field_value(solr_doc, "embargo_release_date_dt", embargo_release_date(:format=>:solr_date)) if embargo_release_date
+    solr_doc
+  end
+
+
+
+
+  
+  private
+  # Purge all access given group/person 
+  def remove_all_permissions(selector)
+    type = selector.keys.first.to_sym
+    actor = selector.values.first
+    xpath = self.class.terminology.xpath_for(:access, type, actor)
+    nodes_to_purge = self.find_by_terms(xpath)
+    nodes_to_purge.each {|node| node.remove}
+  end
+  
+end
+end

data/lib/hydra/superuser_attributes.rb

@@ -0,0 +1,12 @@
+module Hydra::SuperuserAttributes
+
+  def can_be_superuser?
+    Superuser.find_by_user_id(self.id) ? true : false
+  end
+
+  def is_being_superuser?(session=nil)
+    return false if session.nil?
+    session[:superuser_mode] ? true : false
+  end
+
+end

data/lib/hydra/testing_server.rb

@@ -0,0 +1,183 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Hydra 
+# A singleton class for starting/stopping a Jetty server for testing purposes
+# The behavior of TestSolrServer can be modified prior to start() by changing 
+# port, solr_home, and quiet properties.
+#
+# This class is based on Blacklight's TestSolrServer
+class TestingServer
+  require 'singleton'
+  include Singleton
+  require 'win32/process' if RUBY_PLATFORM =~ /mswin32/
+  attr_accessor :port, :jetty_home, :solr_home, :quiet, :fedora_home, :base_path
+
+  # configure the singleton with some defaults
+  def initialize(params = {})
+    @pid = nil
+    if defined?(Rails.root)
+      @base_path = Rails.root
+    else
+      @base_path = "."
+    end
+  end
+
+  class << self
+    def configure(params = {})
+      hydra_server = self.instance
+      hydra_server.quiet = params[:quiet].nil? ? true : params[:quiet]
+      if defined?(Rails.root)
+        base_path = Rails.root
+      else
+        base_path = "."
+      end
+      hydra_server.jetty_home = params[:jetty_home] || File.expand_path(File.join(base_path, 'jetty'))
+      hydra_server.solr_home = params[:solr_home]  || File.join( hydra_server.jetty_home, "solr")
+      hydra_server.fedora_home = params[:fedora_home] || File.join( hydra_server.jetty_home, "fedora","default")
+      hydra_server.port = params[:jetty_port] || 8888
+      return hydra_server
+    end
+    
+    def wrap(params = {})
+      error = false
+      hydra_server = self.configure(params)
+      begin
+        puts "starting Hydra jetty server on #{RUBY_PLATFORM}"
+        hydra_server.start
+        sleep params[:startup_wait] || 5
+        yield
+      rescue
+        error = true
+      ensure
+        puts "stopping Hydra jetty server"
+        hydra_server.stop
+      end
+
+      return error
+    end
+  end
+
+  def jetty_command
+    "java -Djetty.port=#{@port} -Dsolr.solr.home=#{@solr_home} -Dfedora.home=#{@fedora_home} -jar start.jar"
+  end
+ 
+  def start
+    puts "jetty_home: #{@jetty_home}"
+    puts "solr_home: #{@solr_home}"
+    puts "fedora_home: #{@fedora_home}"
+    puts "jetty_command: #{jetty_command}"
+    if pid
+      begin
+        Process.kill(0,pid)
+        raise("Server is already running with PID #{pid}")
+      rescue Errno::ESRCH
+        STDERR.puts("Removing stale PID file at #{pid_path}")
+        File.delete(pid_path)
+      end
+    end
+    Dir.chdir(@jetty_home) do
+      self.send "#{platform}_process".to_sym
+    end
+    mkpath(pid_dir) unless File.directory?(pid_dir)
+    begin
+      f = File.new(pid_path,  "w")
+    rescue Errno::ENOENT, Errno::EACCES
+      f = File.new(File.join(@base_path,'tmp',pid_file),"w")
+    end
+    f.puts "#{@pid}"
+    f.close
+  end
+  
+  def stop
+    puts "stopping"
+    if pid
+      begin
+        self.send "#{platform}_stop".to_sym
+      rescue Errno::ESRCH
+        STDERR.puts("Removing stale PID file at #{pid_path}")
+      end
+      FileUtils.rm(pid_path)
+    end
+  end
+  
+  def win_process
+    @pid = Process.create(
+          :app_name         => jetty_command,
+          :creation_flags   => Process::DETACHED_PROCESS,
+          :process_inherit  => false,
+          :thread_inherit   => true,
+          :cwd              => "#{@jetty_home}"
+       ).process_id
+  end
+
+  def platform
+    case RUBY_PLATFORM
+    when /mswin32/
+      return 'win'
+    else
+      return 'nix'
+    end
+  end
+
+  def nix_process
+    @pid = fork do
+      STDERR.close if @quiet
+      exec jetty_command
+    end
+  end
+
+  # stop a running solr server
+  def win_stop
+    Process.kill(1, @pid)
+  end
+
+  def nix_stop
+    Process.kill('TERM',pid)
+  end
+
+  def pid_path
+    File.join(pid_dir, pid_file)
+  end
+
+  def pid_file
+    @pid_file || 'hydra-jetty.pid'
+  end
+
+  def pid_dir
+    File.expand_path(@pid_dir || File.join(@base_path,'tmp','pids'))
+  end
+
+  def pid
+    @pid || File.open( pid_path ) { |f| return f.gets.to_i } if File.exist?(pid_path)
+  end
+
+end # class TestingServer
+end # module Hydra
+
+# 
+# puts "hello"
+# SOLR_PARAMS = {
+#   :quiet => ENV['SOLR_CONSOLE'] ? false : true,
+#   :jetty_home => ENV['SOLR_JETTY_HOME'] || File.expand_path('../../jetty'),
+#   :jetty_port => ENV['SOLR_JETTY_PORT'] || 8888,
+#   :solr_home => ENV['SOLR_HOME'] || File.expand_path('test')
+# }
+# 
+# # wrap functional tests with a test-specific Solr server
+# got_error = TestSolrServer.wrap(SOLR_PARAMS) do
+#   puts `ps aux | grep start.jar` 
+# end
+# 
+# raise "test failures" if got_error
+#