hydra-file-access 5.0.0.pre1

data/lib/hydra/controller/file_assets_behavior.rb

@@ -0,0 +1,140 @@
+# will move to lib/hydra/controller / file_assets_controller_behavior.rb in release 5.x
+module Hydra::Controller::FileAssetsBehavior
+  extend ActiveSupport::Concern
+  
+  included do
+    include Hydra::AccessControlsEnforcement
+    include Hydra::AssetsControllerHelper
+    include Hydra::Controller::UploadBehavior 
+    include Hydra::Controller::RepositoryControllerBehavior
+    include Blacklight::SolrHelper
+    include Hydra::SubmissionWorkflow
+    include Blacklight::Configurable
+    copy_blacklight_config_from(CatalogController)
+    prepend_before_filter :sanitize_update_params
+  end
+  
+  def index
+    if params[:layout] == "false"
+      layout = false
+    end
+
+    if params[:asset_id].nil?
+      @solr_result = FileAsset.find_with_conditions({})
+    else
+      container_uri = "info:fedora/#{params[:asset_id]}"
+      escaped_uri = container_uri.gsub(/(:)/, '\\:')
+      extra_controller_params =  {:q=>"is_part_of_s:#{escaped_uri}", :qt=>'standard'}
+      @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[:asset_id])
+      
+      # Including these lines for backwards compatibility (until we can use Rails3 callbacks)
+      @container =  ActiveFedora::Base.find(params[:asset_id], :cast=>true)
+      @solr_result = @container.parts(:response_format=>:solr)
+    end
+    
+    # Load permissions_solr_doc based on params[:asset_id]
+    load_permissions_from_solr(params[:asset_id])
+    
+    render :action=>params[:action], :layout=>layout
+  end
+  
+  def new
+    render :partial=>"new", :layout=>false
+  end
+  
+  # Creates and Saves a File Asset to contain the the Uploaded file 
+  # If container_id is provided:
+  # * the File Asset will use RELS-EXT to assert that it's a part of the specified container
+  # * the method will redirect to the container object's edit view after saving
+  def create
+    if params.has_key?(:number_of_files) and params[:number_of_files] != "0"
+      return redirect_to edit_catalog_path(params[:id], :wf_step => :files, :number_of_files => params[:number_of_files])
+    elsif params.has_key?(:number_of_files) and params[:number_of_files] == "0"
+      return redirect_to next_step(params[:id])
+    end
+    
+    if params.has_key?(:Filedata)
+      notice = process_files
+      flash[:notice] = notice.join("<br/>".html_safe) unless notice.blank?
+    else
+      flash[:notice] = "You must specify a file to upload."
+    end
+    
+    if params[:container_id]
+      redirect_to next_step(params[:container_id])
+    else
+      redirect_to catalog_index_path
+    end
+
+  end
+
+  def process_files
+    @file_assets = create_and_save_file_assets_from_params
+    notice = []
+    @file_assets.each do |file_asset|
+      apply_depositor_metadata(file_asset)
+
+      notice << render_to_string(:partial=>'hydra/file_assets/asset_saved_flash', :locals => { :file_asset => file_asset })
+        
+      if !params[:container_id].nil?
+        associate_file_asset_with_container(file_asset,'info:fedora/' + params[:container_id])
+      end
+
+      ## Apply any posted file metadata
+      unless params[:asset].nil?
+        logger.debug("applying submitted file metadata: #{@sanitized_params.inspect}")
+        apply_file_metadata
+      end
+      # If redirect_params has not been set, use {:action=>:index}
+      logger.debug "Created #{file_asset.pid}."
+    end
+    notice
+  end
+  
+  # Common destroy method for all AssetsControllers 
+  def destroy
+    ActiveFedora::Base.find(params[:id], :cast=>true).delete 
+
+    flash[:notice] = "Deleted #{params[:id]} from #{params[:container_id]}."
+    
+    if !params[:container_id].nil?
+      redirect_params = edit_catalog_path(params[:container_id], :anchor => "file_assets")
+    end
+    redirect_params ||= {:action => 'index', :q => nil , :f => nil}
+    
+    redirect_to redirect_params
+    
+  end
+  
+  
+  def show
+    begin
+      @file_asset = FileAsset.find(params[:id])
+    rescue ActiveFedora::ObjectNotFoundError
+      logger.warn("No such file asset: " + params[:id])
+      flash[:notice]= "No such file asset."
+      redirect_to(:action => 'index', :q => nil , :f => nil)
+      return
+    end
+    # get containing object for this FileAsset
+    pid = @file_asset.container_id
+    parent = ActiveFedora::Base.find(pid, :cast=>true)
+    @downloadable = false
+    # A FileAsset is downloadable iff the user has read or higher access to a parent
+
+    if can? :read, parent
+      # First try to use datastream_id value (set in FileAssetsHelper)
+      if @file_asset.datastreams.include?(datastream_id)
+        send_datastream @file_asset.datastreams[datastream_id]
+      elsif @file_asset.datastreams.include?("DS1")
+        send_datastream @file_asset.datastreams["DS1"]
+      end
+    else
+      raise Hydra::AccessDenied.new("You do not have sufficient access privileges to download this file.")
+    end
+  end
+end
+

data/lib/hydra/file_access/engine.rb

@@ -0,0 +1,12 @@
+module Hydra
+  module FileAccess
+    class Engine < Rails::Engine
+      # Load rake tasks
+      rake_tasks do
+        # Dir.glob(File.join(File.expand_path('../', File.dirname(__FILE__)),'railties', '*.rake')).each do |railtie|
+        #   load railtie
+        # end
+      end
+    end 
+  end
+end

data/lib/hydra/file_assets.rb

@@ -0,0 +1,11 @@
+# will move to lib/hydra/controller / file_assets_controller_behavior.rb in release 5.x
+require 'deprecation'
+module Hydra::FileAssets
+  extend ActiveSupport::Concern
+  
+  included do
+    Deprecation.warn Hydra::FileAssets, "Hydra::FileAssets was moved to Hydra::Controller::FileAssetsBehavior"
+    include Hydra::Controller::FileAssetsBehavior
+  end
+end
+

data/lib/hydra/submission_workflow.rb

@@ -0,0 +1,139 @@
+require "hydra"
+class Hydra::WorkflowError < StandardError; end;
+
+# will move to lib/hydra/workflow/submission_workflow in release 5.x
+module Hydra::SubmissionWorkflow
+  
+  # When in this module is incuded in a controller (e.g. responds to :before_filter) add the validate_worflow_step method to the before filter chain.
+  def self.included(base)
+    base.before_filter :validate_workflow_step if base.respond_to?(:before_filter)
+  end
+  
+  # To be used in a before_filter.  This will call a method with the #{af_model}_#{action_param}_validation.  If that method returns false then we will redirect back.  The controller method doing the validation should set an appropriate flash message.
+  def validate_workflow_step
+    unless model_config.nil?
+      # we may want to use the workflow name instead of or in addition to the action in the validation naming convention.
+      validation_method = "#{get_af_model_from_params}_#{params[:action]}_validation".to_sym
+      if self.respond_to?(validation_method) and self.send(validation_method) === false
+        redirect_to :back
+      end
+    end
+  end
+
+  # Returns the name field for the next step in the configuration for the current model given the current step.
+  def next_step_in_workflow(current_step)
+    unless model_config.nil?
+      if current_step.blank?
+        # The first edit step won't have a wf_step param so we will need to pass it off to the 2nd step.
+        return next_step_in_workflow(first_step_in_workflow)
+      else
+        model_config.each_with_index do |step,i|
+          return model_config[i+1][:name] if step[:name] == current_step.to_s and step != model_config.last
+        end
+      end
+    end
+    nil
+  end
+  
+  # Convenience method to return the first step of a models workflow.
+  def first_step_in_workflow
+    model_config.first[:name] unless model_config.nil?
+  end
+  
+  # Convenience method to return the last step of a models workflow.
+  def last_step_in_workflow
+    model_config.last[:name] unless model_config.nil?
+  end
+  
+  def next_step(id)
+    return_params = {:wf_step=>next_step_in_workflow(params[:wf_step])}
+    if params[:new_asset]
+      return_params[:new_asset] = true
+    end
+    if params[:wf_step] == last_step_in_workflow or params.has_key?(:finish)
+      return_params[:viewing_context] = "browse"
+      return_params[:action] = "show" 
+      return_params.delete(:wf_step)
+      return catalog_path(id, return_params)
+    end
+    return edit_catalog_path(id,return_params)
+  end
+  
+  # Convenience method to return the partial for any given step by name.
+  def workflow_partial_for_step(step)
+    find_workflow_step_by_name(step)[:edit_partial]
+  end
+  
+  # Convenience method to return an entire workflow step by name.
+  def find_workflow_step_by_name(name)
+    model_config.find{|config| config[:name] == name.to_s} unless model_config.nil?
+  end
+  
+  # Returns an array of display partials for steps previous to the given step.
+  def previous_show_partials(current_step)
+    previous_partials = []
+    # if there is no step then we are on the first step of the workflow and don't need to display anything.
+    return previous_partials if current_step.blank?
+    unless model_config.nil?
+      model_config.each do |config|
+        break if config[:name] == current_step.to_s
+        previous_partials << config[:show_partial]
+      end
+    end
+    previous_partials
+  end
+  
+  # Returns an array of all edit partials for the current content type.
+  def all_edit_partials
+    edit_partials = []
+    unless model_config.nil?
+      model_config.each do |config|
+        edit_partials << config[:edit_partial]
+      end
+    end
+    edit_partials
+  end
+  
+  # Will return the entire workflow configuration for the current model.
+  # We determing model first by seeing the @document object is a SolrDocument.  If it is we will determing from the has_model_s field.
+  # Otherwise we will attempt to determine by the parameters (content_type directly passed or the id of an object).
+  def model_config
+    # If we  can get it directly from solr get it there.
+    if !@document.nil? and @document.is_a?(SolrDocument)
+      _model = get_af_model_from_solr
+      return workflow_config[_model] if !_model.nil? and workflow_config.has_key?(_model)
+    
+    # If we can get the model from the params get it there.
+    elsif params.has_key?(:content_type) or params.has_key?(:id)
+      _model = get_af_model_from_params
+      return workflow_config[_model] if workflow_config.has_key?(_model) and _model
+    else 
+      nil #raise Hydra::WorkflowError
+    end
+  end
+  
+  # Reutrns a symbolized model name determined by parameters.
+  def get_af_model_from_params
+    if params.has_key?(:content_type)
+      return params[:content_type].pluralize.to_sym
+    elsif params[:id]
+      begin
+        af = ActiveFedora::Base.load_instance_from_solr(params[:id])
+        return "#{ActiveFedora::ContentModel.known_models_for( af ).first}".underscore.pluralize.to_sym
+      rescue ActiveFedora::ObjectNotFoundError => e 
+        nil
+      end
+    end
+  end
+  
+  # Convenience method to return the model from the @document objects has_model_s field.
+  def get_af_model_from_solr
+    @document[:has_model_s].first.gsub("info:fedora/afmodel:","").underscore.pluralize.to_sym
+  end
+
+  # The configuration hash.  This should probably live somewhere else and get read in so it can be properly configured at the application level.  But for now it's here.
+  def workflow_config
+    Hydra.config[:submission_workflow]
+  end
+
+end

data/lib/hydra/ui.rb

@@ -0,0 +1,6 @@
+# Modules, etc. to support Hydra default UI.
+module Hydra::UI
+  extend ActiveSupport::Autoload
+  autoload :Controller
+end
+

data/spec/.gitignore

@@ -0,0 +1 @@
+/internal

data/spec/controllers/file_assets_controller_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe Hydra::FileAssetsController do
+  include Devise::TestHelpers
+  before do
+    session[:user]='bob'
+  end
+
+  it "should be restful" do
+    { :get => "/hydra/file_assets" }.should route_to(:controller=>'hydra/file_assets', :action=>'index')
+    { :get => "/hydra/file_assets/3" }.should route_to(:controller=>'hydra/file_assets', :action=>'show', :id=>"3")
+    { :delete=> "/hydra/file_assets/3" }.should route_to(:controller=>'hydra/file_assets', :action=>'destroy', :id=>"3")
+    { :put=>"/hydra/file_assets/3" }.should route_to(:controller=>'hydra/file_assets', :action=>'update', :id=>"3")
+    { :get => "/hydra/file_assets/3/edit" }.should route_to(:controller=>'hydra/file_assets', :action=>'edit', :id=>"3")
+    { :get =>"/hydra/file_assets/new" }.should route_to(:controller=>'hydra/file_assets', :action=>'new')
+    { :post => "/hydra/file_assets" }.should route_to(:controller=>'hydra/file_assets', :action=>'create')
+    
+  end
+  
+  describe "index" do
+    
+    it "should find all file assets in the repo if no container_id is provided" do
+      ActiveFedora::SolrService.should_receive(:query).with("has_model_s:info\\:fedora/afmodel\\:FileAsset", {:sort=>["system_create_dt asc"]}).and_return("solr result")
+      controller.stub(:load_permissions_from_solr)
+      ActiveFedora::Base.should_receive(:new).never
+      xhr :get, :index
+      assigns[:solr_result].should == "solr result"
+    end
+    it "should find all file assets belonging to a given container object if asset_id is provided" do
+      pid = 'hydrangea:fixture_mods_article3'
+      xhr :get, :index, :asset_id=>pid
+      assigns[:response][:response][:docs].first["id"].should == "hydrangea:fixture_file_asset1"
+      assigns[:document_list].first.id.should == "hydrangea:fixture_file_asset1"
+      
+      assigns[:container_response][:response][:docs].first["id"].should == "hydrangea:fixture_mods_article3"
+      assigns[:document].id.should == "hydrangea:fixture_mods_article3"
+      assigns[:solr_result].first["id"].should == "hydrangea:fixture_file_asset1"
+      assigns[:container].should == ModsAsset.find('hydrangea:fixture_mods_article3')
+    end
+    
+  end
+
+  describe "new" do
+    it "should set :container_id to value of :container_id if available" do
+      xhr :get, :new, :asset_id=>"_PID_"
+      @controller.params[:asset_id].should == "_PID_"
+    end
+  end
+
+  describe "show" do
+    it "should redirect back if current_user does not have read or edit permissions" do
+      mock_user = double("User")
+      mock_user.stub(:email).and_return("fake_user@example.com")
+      mock_user.stub(:is_being_superuser?).and_return(false)
+      mock_user.stub(:persisted?).and_return(true)
+      mock_user.stub(:new_record?).and_return(false)
+      controller.stub(:current_user).and_return(mock_user)
+      request.env["HTTP_REFERER"] = "http://example.com/?q=search"
+      get(:show, :id=>"hydrangea:fixture_file_asset1")
+      response.should redirect_to(root_url)
+    end
+     it "should redirect to the login page if the user is not logged in" do
+      mock_user = double("User")
+      mock_user.stub(:email).and_return("fake_user@example.com")
+      mock_user.stub(:is_being_superuser?).and_return(false)
+      mock_user.stub(:persisted?).and_return(false)
+      mock_user.stub(:new_record?).and_return(true)
+      controller.stub(:current_user).and_return(mock_user)
+      request.env["HTTP_REFERER"] = "http://example.com/?q=search"
+      get(:show, :id=>"hydrangea:fixture_file_asset1")
+      response.should redirect_to("http://test.host/users/sign_in")
+      session['user_return_to'].should =~ /fixture_file_asset1/
+    end
+    it "should redirect to index view if the file does not exist" do
+      get(:show, :id=>"example:invalid_object")
+      response.should redirect_to(:action => 'index')
+    end
+  end
+  
+  describe "create" do
+    it "should create and save a file asset from the given params" do
+      mock_fa = double("FileAsset")
+      mock_file = double("File")
+      mock_fa.stub(:pid).and_return("foo:pid")
+      controller.should_receive(:create_and_save_file_assets_from_params).and_return([mock_fa])
+      xhr :post, :create, :Filedata=>[mock_file], :Filename=>"Foo File"
+    end
+    it "if container_id is provided, should associate the created file asset wtih the container" do
+      stub_fa = double("FileAsset")
+      stub_fa.stub(:pid).and_return("foo:pid")
+      stub_fa.stub(:label).and_return("Foo File")
+      mock_file = double("File")
+      controller.should_receive(:create_and_save_file_assets_from_params).and_return([stub_fa])
+      controller.should_receive(:associate_file_asset_with_container)      
+      xhr :post, :create, :Filedata=>[mock_file], :Filename=>"Foo File", :container_id=>"_PID_"
+    end
+    it "should redirect back to edit view if no Filedata is provided but container_id is provided" do
+      controller.should_receive(:model_config).at_least(:once).and_return(controller.workflow_config[:mods_assets])
+      xhr :post, :create, :container_id=>"_PID_", :wf_step=>"files"
+      response.should redirect_to edit_catalog_path("_PID_", :wf_step=>"permissions")
+      request.flash[:notice].should == "You must specify a file to upload."
+    end
+    it "should display a message that you need to select a file to upload if no Filedata is provided" do
+      xhr :post, :create
+      request.flash[:notice].include?("You must specify a file to upload.").should be_true
+    end
+    
+  end
+
+  describe "destroy" do
+    it "should delete the asset identified by pid" do
+      mock_obj = double("asset")
+      mock_obj.should_receive(:delete)
+      ActiveFedora::Base.should_receive(:find).with("__PID__", :cast=>true).and_return(mock_obj)
+      delete(:destroy, :id => "__PID__")
+    end
+    it "should remove container relationship and perform proper garbage collection" do
+      pending "relies on ActiveFedora implementing Base.file_objects_remove"
+      mock_container = mock("asset")
+      mock_container.should_receive(:file_objects_remove).with("_file_asset_pid_")
+      FileAsset.should_receive(:garbage_collect).with("_file_asset_pid_")
+      ActiveFedora::Base.should_receive(:find).with("_container_pid_", :cast=>true).and_return(mock_container)
+      delete(:destroy, :id => "_file_asset_pid_", :asset_id=>"_container_pid_")
+    end
+  end
+  
+  describe "integration tests - " do
+    before(:all) do
+      class TestObj < ActiveFedora::Base
+        include ActiveFedora::FileManagement
+      end
+
+      ActiveFedora::SolrService.register(ActiveFedora.solr_config[:url])
+      @test_container = TestObj.new
+      @test_container.add_relationship(:is_member_of, "info:fedora/foo:1")
+      @test_container.add_relationship(:has_collection_member, "info:fedora/foo:2")
+      @test_container.save
+      
+      @test_fa = FileAsset.new
+      @test_fa.add_relationship(:is_part_of, @test_container)
+      @test_fa.save
+    end
+
+    after(:all) do
+     @test_container.delete
+     @test_fa.delete
+     Object.send(:remove_const, :TestObj)
+    end
+
+    describe "index" do
+      it "should retrieve the container object and its file assets" do
+        #xhr :get, :index, :container_id=>@test_container.pid
+        get :index, {:asset_id=>@test_container.pid}
+        @controller.params[:asset_id].should_not be_nil
+        assigns(:solr_result).should_not be_nil
+        #puts assigns(:solr_result).inspect
+        assigns(:container).file_objects(:response_format=>:id_array).should include(@test_fa.pid)
+        assigns(:container).file_objects(:response_format=>:id_array).should include("foo:2")
+      end
+    end
+    
+    describe "create" do
+      before :each do
+        mock_user = double("User")
+        mock_user.stub(:user_key).and_return('user@example.com')
+        mock_warden = double("Warden")
+        mock_warden.stub(:authenticate).and_return(mock_user)
+        request.env['warden'] = mock_warden
+      end
+
+      it "should set is_part_of relationship on the new File Asset pointing back at the container" do
+        test_file = fixture_file_upload('spec/fixtures/small_file.txt', 'text/plain')
+        filename = "My File Name"
+        post :create, {:Filedata=>[test_file], :Filename=>filename, :container_id=>@test_container.pid}
+        assigns(:file_asset).ids_for_outbound(:is_part_of).should == [@test_container.pid] 
+        retrieved_fa = FileAsset.find(@test_fa.pid).ids_for_outbound(:is_part_of).should == [@test_container.pid]
+      end
+    end
+  end
+end