curation_concerns 0.1.0

data/app/controllers/concerns/curation_concerns/collections_controller_behavior.rb

@@ -0,0 +1,76 @@
+module CurationConcerns
+  module CollectionsControllerBehavior
+    extend ActiveSupport::Concern
+    include Hydra::CollectionsControllerBehavior
+
+    included do
+      before_filter :filter_docs_with_read_access!, except: :show
+      self.search_params_logic += [:add_access_controls_to_solr_params, :add_advanced_parse_q_to_solr]
+      layout "curation_concerns/1_column"
+    end
+
+    def new
+      super
+      form
+    end
+
+    def edit
+      super
+      form
+    end
+
+    def show
+      super
+      presenter
+    end
+
+    protected
+
+    def presenter
+      @presenter ||= presenter_class.new(@collection)
+    end
+
+    def presenter_class
+      CurationConcerns::CollectionPresenter
+    end
+
+    def collection_member_search_builder_class
+      CurationConcerns::SearchBuilder
+    end
+
+    def collection_params
+      form_class.model_attributes(
+        params.require(:collection).permit(:title, :description, :members, part_of: [],
+          contributor: [], creator: [], publisher: [], date_created: [], subject: [],
+          language: [], rights: [], resource_type: [], identifier: [], based_near: [],
+          tag: [], related_url: [])
+      )
+    end
+
+    def query_collection_members
+      flash[:notice]=nil if flash[:notice] == "Select something first"
+      params[:q] = params[:cq]
+      super
+    end
+
+    def after_destroy(id)
+      respond_to do |format|
+        format.html { redirect_to collections_path, notice: 'Collection was successfully deleted.' }
+        format.json { render json: {id: id}, status: :destroyed, location: @collection }
+      end
+    end
+
+    def form
+      @form ||= form_class.new(@collection)
+    end
+
+    def form_class
+      CurationConcerns::Forms::CollectionEditForm
+    end
+
+    # Include 'catalog' and 'curation_concerns/base' in the search path for views
+    def _prefixes
+      @_prefixes ||= super + ['catalog', 'curation_concerns/base']
+    end
+  end
+end

data/app/controllers/concerns/curation_concerns/curation_concern_controller.rb

@@ -0,0 +1,125 @@
+module CurationConcerns::CurationConcernController
+  extend ActiveSupport::Concern
+  include Blacklight::Catalog::SearchContext
+
+  included do
+    include CurationConcerns::ThemedLayoutController
+    with_themed_layout '1_column'
+    helper CurationConcerns::AbilityHelper
+
+    class_attribute :curation_concern_type
+    attr_accessor :curation_concern
+    helper_method :curation_concern
+
+    respond_to :html
+  end
+
+  module ClassMethods
+    def set_curation_concern_type(curation_concern_type)
+      load_and_authorize_resource class: curation_concern_type, instance_name: :curation_concern
+      self.curation_concern_type = curation_concern_type
+    end
+
+    def cancan_resource_class
+      CurationConcerns::ControllerResource
+    end
+  end
+
+  def new
+  end
+
+  def create
+    # return unless verify_acceptance_of_user_agreement!
+    if actor.create
+      after_create_response
+    else
+      setup_form
+      respond_with(:curation_concerns, curation_concern) do |wants|
+        wants.html { render 'new', status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def show
+  end
+
+  def edit
+  end
+
+  def update
+    if actor.update
+      after_update_response
+    else
+      setup_form
+      respond_with(:curation_concerns, curation_concern) do |wants|
+        wants.html { render 'edit', status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def destroy
+    title = curation_concern.to_s
+    curation_concern.destroy
+    after_destroy_response(title)
+  end
+
+  attr_writer :actor
+
+  protected
+    def actor
+      @actor ||= CurationConcerns::CurationConcern.actor(curation_concern, current_user, attributes_for_actor)
+    end
+
+    # Override setup_form in concrete controllers to get the form ready for display
+    def setup_form
+      if curation_concern.respond_to?(:contributor) && curation_concern.contributor.blank?
+        curation_concern.contributor << current_user.name
+      end
+    end
+
+    # def verify_acceptance_of_user_agreement!
+    #   return true if contributor_agreement.is_being_accepted?
+    #   # Calling the new action to make sure we are doing our best to preserve
+    #   # the input values; Its a stretch but hopefully it'll work
+    #   self.new
+    #   respond_with(:curation_concern, curation_concern) do |wants|
+    #     wants.html {
+    #       flash.now[:error] = "You must accept the contributor agreement"
+    #       render 'new', status: :conflict
+    #     }
+    #   end
+    #   false
+    # end
+
+    def _prefixes
+      @_prefixes ||= super + ['curation_concerns/base']
+    end
+
+    def after_create_response
+      respond_with(main_app, :curation_concerns, curation_concern)
+    end
+
+    def after_update_response
+      #TODO visibility or lease/embargo status
+      if actor.visibility_changed?
+        redirect_to main_app.confirm_curation_concerns_permission_path(curation_concern)
+      else
+        respond_with(main_app, :curation_concerns, curation_concern)
+      end
+    end
+
+    def after_destroy_response(title)
+      flash[:notice] = "Deleted #{title}"
+      respond_with { |wants|
+        wants.html { redirect_to main_app.catalog_index_path }
+      }
+    end
+
+    def attributes_for_actor
+      params.fetch(hash_key_for_curation_concern, {}).permit!
+    end
+
+    def hash_key_for_curation_concern
+      self.class.curation_concern_type.name.underscore.to_sym
+    end
+end

data/app/controllers/concerns/curation_concerns/download_behavior.rb

@@ -0,0 +1,60 @@
+# Overrides Hydra::Controller::DownloadBehavior to accommodate the fact that PCDM Objects#files uses direct containment instead of basic containment
+module CurationConcerns
+  module DownloadBehavior
+    extend ActiveSupport::Concern
+    include Hydra::Controller::DownloadBehavior
+
+    module ClassMethods
+      def default_content_path
+        :original_file
+      end
+    end
+
+
+    # Customize the :download ability in your Ability class, or override this method
+    def authorize_download!
+      # authorize! :download, file # can't use this because Hydra::Ability#download_permissions assumes that files are in Basic Container (and thus include the asset's uri)
+      authorize! :read, asset
+    end
+
+    # Overrides Hydra::Controller::DownloadBehavior#load_file, which is hard-coded to assume files are in BasicContainer (PCDM Objects use direct containment)
+    # Override this method to change which file is shown.
+    # Loads the file specified by the HTTP parameter `:file_id`.
+    # If this object does not have a file by that name, return the default file
+    # as returned by {#default_file}
+    # @return [ActiveFedora::File] the file
+    def load_file
+      file_reference = params[:file]
+      # f = asset.attached_files[file_path] if file_path   # can't use this because attached_files assumes basic containment
+      f = asset.send(file_reference) if valid_file_reference?(file_reference)
+      f ||= default_file
+      raise "Unable to find a file for #{asset}" if f.nil?
+      f
+    end
+
+    def default_file
+      if asset.class.respond_to?(:default_file_path)
+        default_file_reference = asset.class.default_file_path
+      else
+        default_file_reference = DownloadsController.default_content_path
+      end
+      if valid_file_reference?(default_file_reference)
+        return asset.send(default_file_reference)
+      else
+        return nil
+      end
+    end
+
+    private
+
+    def valid_file_reference?(file_reference)
+      return false if file_reference.nil?
+      # the second part of this is covering the fact that directly_contains_one isn't implemented yet, so :original_file, :thumbnail,:extracted_text are not singular associations (yet)
+      singular_associations.include?(file_reference.to_sym) || [:original_file, :thumbnail,:extracted_text].include?(file_reference.to_sym)
+    end
+
+    def singular_associations
+      asset.association_cache.select {|key,assoc| assoc.kind_of?(ActiveFedora::Associations::SingularAssociation)}.keys
+    end
+  end
+end

data/app/controllers/concerns/curation_concerns/embargoes_controller_behavior.rb

@@ -0,0 +1,44 @@
+module CurationConcerns
+  module EmbargoesControllerBehavior
+    extend ActiveSupport::Concern
+
+    included do
+      skip_before_filter :normalize_identifier, only: :update
+
+      def destroy
+        update_files = !curation_concern.under_embargo? # embargo expired
+        remove_embargo(curation_concern)
+        flash[:notice] = curation_concern.embargo_history.last
+        if update_files
+          redirect_to confirm_curation_concerns_permission_path(curation_concern)
+        else
+          redirect_to edit_embargo_path(curation_concern)
+        end
+      end
+
+      def update
+        filter_docs_with_edit_access!
+        copy_visibility = params[:embargoes].values.map { |h| h[:copy_visibility] }
+        batch.each do |id|
+          ActiveFedora::Base.find(id).tap do |curation_concern|
+            remove_embargo(curation_concern)
+            curation_concern.copy_visibility_to_files if copy_visibility.include?(id)
+          end
+        end
+        redirect_to embargoes_path
+      end
+    end
+
+    protected
+
+    def _prefixes
+      # This allows us to use the unauthorized template in curation_concerns/base
+      @_prefixes ||= super + ['curation_concerns/base']
+    end
+    def remove_embargo(work)
+      work.embargo_visibility! # If the embargo has lapsed, update the current visibility.
+      work.deactivate_embargo!
+      work.save
+    end
+  end
+end

data/app/controllers/concerns/curation_concerns/generic_files_controller_behavior.rb

@@ -0,0 +1,149 @@
+module CurationConcerns
+  module GenericFilesControllerBehavior
+    extend ActiveSupport::Concern
+
+    included do
+      include CurationConcerns::ThemedLayoutController
+      with_themed_layout '1_column'
+      load_and_authorize_resource class: ::GenericFile
+      helper_method :curation_concern
+      include CurationConcerns::ParentContainer
+    end
+
+    def curation_concern
+      @generic_file
+    end
+
+    # routed to /files/new
+    def new
+    end
+
+    # routed to /files/:id/edit
+    def edit
+      # @generic_file.initialize_fields
+      @groups = current_user.groups
+    end
+
+    # routed to /files (POST)
+    def create
+      create_from_upload(params)
+    end
+
+    def create_from_upload(params)
+      # check error condition No files
+      return json_error("Error! No file to save") if !params.has_key?(:files)
+
+      file = params[:files].detect {|f| f.respond_to?(:original_filename) }
+      if !file
+        json_error "Error! No file for upload", 'unknown file', :status => :unprocessable_entity
+      elsif (empty_file?(file))
+        json_error "Error! Zero Length File!", file.original_filename
+      else
+        process_file(file)
+      end
+    rescue RSolr::Error::Http => error
+      logger.error "GenericFilesController::create rescued #{error.class}\n\t#{error.to_s}\n #{error.backtrace.join("\n")}\n\n"
+      json_error "Error occurred while creating generic file."
+    ensure
+      # remove the tempfile (only if it is a temp file)
+      file.tempfile.delete if file.respond_to?(:tempfile)
+    end
+
+    # routed to /files/:id
+    def show
+    end
+
+    def destroy
+      @generic_file.destroy
+      redirect_to [main_app, :curation_concerns, @generic_file.generic_works.first], notice: "The file has been deleted."
+    end
+
+    # routed to /files/:id (PUT)
+    def update
+      success = if wants_to_revert?
+        actor.revert_content(params[:revision])
+      elsif params.has_key? :files
+        actor.update_content(params[:files].first)
+      elsif params.has_key? :generic_file
+        update_metadata
+      end
+      if success
+        redirect_to [main_app, :curation_concerns, @generic_file], notice:
+          "The file #{view_context.link_to(@generic_file, [main_app, :curation_concerns, @generic_file])} has been updated."
+      else
+        render action: 'edit'
+      end
+    rescue RSolr::Error::Http => error
+      flash[:error] = error.message
+      logger.error "GenericFilesController::update rescued #{error.class}\n\t#{error.message}\n #{error.backtrace.join("\n")}\n\n"
+      render action: 'edit'
+    end
+
+    # this is provided so that implementing application can override this behavior and map params to different attributes
+    def update_metadata
+      # attrs_without_visibility_info = actor.interpret_visibility(attributes)
+      file_attributes = CurationConcerns::Forms::GenericFileEditForm.model_attributes(attributes)
+      actor.update_metadata(file_attributes, attributes)
+    end
+
+    protected
+
+    def wants_to_revert?
+      params.has_key?(:revision) && params[:revision] != @generic_file.latest_content_version.label
+    end
+
+    def actor
+      @actor ||= ::CurationConcerns::GenericFileActor.new(@generic_file, current_user)
+    end
+
+    def attributes
+      # params.fetch(:generic_file, {}).dup  # use a copy of the hash so that original params stays untouched when interpret_visibility modifies things
+      params.fetch(:generic_file, {}).permit!.dup  # use a copy of the hash so that original params stays untouched when interpret_visibility modifies things
+    end
+
+    def json_error(error, name=nil, additional_arguments={})
+      args = {:error => error}
+      args[:name] = name if name
+      render additional_arguments.merge({:json => [args]})
+    end
+
+    def _prefixes
+      # This allows us to use the unauthorized and form_permission template in curation_concerns/base
+      @_prefixes ||= super + ['curation_concerns/base']
+    end
+
+    def empty_file?(file)
+      (file.respond_to?(:tempfile) && file.tempfile.size == 0) || (file.respond_to?(:size) && file.size == 0)
+    end
+
+    def process_file(file)
+      update_metadata_from_upload_screen
+      actor.create_metadata(params[:batch_id], parent_id, params[:generic_file])
+      if actor.create_content(file)
+        respond_to do |format|
+          format.html {
+            if request.xhr?
+              render 'jq_upload', formats: 'json', content_type: 'text/html'
+            else
+              redirect_to [main_app, :curation_concerns, @generic_file.generic_works.first]
+            end
+          }
+          format.json {
+            render 'jq_upload'
+          }
+        end
+      else
+        msg = @generic_file.errors.full_messages.join(', ')
+        flash[:error] = msg
+        json_error "Error creating generic file: #{msg}"
+      end
+    end
+
+    # this is provided so that implementing application can override this behavior and map params to different attributes
+    def update_metadata_from_upload_screen
+      # Relative path is set by the jquery uploader when uploading a directory
+      @generic_file.relative_path = params[:relative_path] if params[:relative_path]
+    end
+
+  end
+end

data/app/controllers/concerns/curation_concerns/leases_controller_behavior.rb

@@ -0,0 +1,36 @@
+module CurationConcerns
+  module LeasesControllerBehavior
+    extend ActiveSupport::Concern
+
+    included do
+      skip_before_filter :normalize_identifier, only: :update
+
+      def destroy
+        curation_concern.lease_visibility! # If the lease has lapsed, update the current visibility.
+        curation_concern.deactivate_lease!
+        saved = curation_concern.save
+        CurationConcerns.queue.push(VisibilityCopyWorker.new(curation_concern.id)) if saved
+        flash[:notice] = curation_concern.lease_history.last
+        redirect_to edit_lease_path(curation_concern)
+      end
+
+      def update
+        filter_docs_with_edit_access!
+        batch.each do |id|
+          ActiveFedora::Base.find(id).tap do |curation_concern|
+            curation_concern.deactivate_lease!
+            curation_concern.save
+          end
+        end
+        redirect_to leases_path
+      end
+    end
+
+    protected
+
+    def _prefixes
+      # This allows us to use the unauthorized template in curation_concerns/base
+      @_prefixes ||= super + ['curation_concerns/base']
+    end
+  end
+end

data/app/controllers/concerns/curation_concerns/manages_embargoes.rb

@@ -0,0 +1,26 @@
+module CurationConcerns
+  module ManagesEmbargoes
+    extend ActiveSupport::Concern
+
+    included do
+      include CurationConcerns::ThemedLayoutController
+      with_themed_layout '1_column'
+
+      attr_accessor :curation_concern
+      helper_method :curation_concern
+      load_and_authorize_resource class: ActiveFedora::Base, instance_name: :curation_concern
+
+      def deny_access(exception)
+        redirect_to root_path, alert: exception.message
+      end
+    end
+
+
+    def index
+      authorize! :discover, :embargo
+    end
+
+    def edit
+    end
+  end
+end

data/app/controllers/concerns/curation_concerns/parent_container.rb

@@ -0,0 +1,33 @@
+module CurationConcerns::ParentContainer
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :parent
+    # before_filter :authorize_edit_parent_rights!, except: [:show]  # Not sure we actually want this enforced any more (was originally in worthwhile), especially since GenericFiles and GenericWorks (which are PCDM::Objects)can belong to multiple parents
+  end
+
+  def parent
+    @parent ||= new_or_create? ? ActiveFedora::Base.find(parent_id) : curation_concern.parent_objects.first  # parent_objects method is inherited from Hydra::PCDM::ObjectBehavior
+  end
+
+  def parent_id
+    @parent_id ||= new_or_create? ? params[:parent_id] : curation_concern.generic_works.parent_objects.first.id
+  end
+
+  protected
+
+    def new_or_create?
+      ['create', 'new'].include? action_name
+    end
+
+    def namespaced_parent_id
+      # Sufia::Noid.namespaceize(params[:parent_id])
+    end
+
+    # restricts edit access so that you can only edit a record if you can also edit its parent.
+
+    def authorize_edit_parent_rights!
+      authorize! :edit, parent_id
+    end
+
+end

data/app/controllers/concerns/curation_concerns/themed_layout_controller.rb

@@ -0,0 +1,31 @@
+# Copied from Curate
+module CurationConcerns::ThemedLayoutController
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :theme
+    self.theme = 'curation_concerns'
+    helper_method :theme
+    helper_method :show_site_actions?
+    helper_method :show_site_search?
+  end
+
+  module ClassMethods
+    def with_themed_layout(view_name = nil)
+      if view_name
+        layout("#{theme}/#{view_name}")
+      else
+        layout(theme)
+      end
+    end
+  end
+
+  def show_site_actions?
+    true
+  end
+
+  def show_site_search?
+    true
+  end
+
+end

data/app/controllers/concerns/curation_concerns/without_namespace.rb

@@ -0,0 +1,15 @@
+module CurationConcerns
+  # Including WithoutNamespace on a controller allows us to prepend the default namespace to the params[:id]
+  module WithoutNamespace
+    extend ActiveSupport::Concern
+
+    included do
+      prepend_before_filter :normalize_identifier, except: [:index, :create, :new]
+    end
+
+    protected
+      def normalize_identifier
+        params[:id] = CurationConcerns::Noid.namespaceize(params[:id])
+      end
+  end
+end

data/app/controllers/curation_concerns/application_controller.rb

@@ -0,0 +1,7 @@
+module CurationConcerns
+  # Inherit from the host app's ApplicationController
+  # This will configure e.g. the layout used by the host
+  class ApplicationController < ::ApplicationController
+    include CurationConcerns::ApplicationControllerBehavior
+  end
+end

data/app/controllers/curation_concerns/classify_concerns_controller.rb

@@ -0,0 +1,35 @@
+module CurationConcerns
+  class ClassifyConcernsController < ApplicationController
+    include CurationConcerns::ThemedLayoutController
+    with_themed_layout '1_column'
+    respond_to :html
+    before_filter :authenticate_user!
+    load_and_authorize_resource
+
+    add_breadcrumb 'Submit a work', lambda {|controller| controller.request.path }
+
+    def classify_concern
+      @classify_concern
+    end
+    helper_method :classify_concern
+
+    def new
+      respond_with(classify_concern)
+    end
+
+    def create
+      classify_concern.attributes = params[:classify_concern]
+      if classify_concern.valid?
+        respond_with(classify_concern) do |wants|
+          wants.html do
+            redirect_to new_polymorphic_path(
+              [:curation_concerns, classify_concern.curation_concern_class]
+            )
+          end
+        end
+      else
+        respond_with(classify_concern)
+      end
+    end
+  end
+end

data/app/controllers/curation_concerns/generic_files_controller.rb

@@ -0,0 +1,13 @@
+module CurationConcerns
+  class GenericFilesController < ApplicationController
+    include CurationConcerns::GenericFilesControllerBehavior
+
+    def generic_file_params
+      if params.has_key?(:generic_file)
+        params.require(:generic_file).permit!
+      end
+    end
+
+  end
+end
+

data/app/controllers/curation_concerns/permissions_controller.rb

@@ -0,0 +1,19 @@
+class CurationConcerns::PermissionsController < ApplicationController
+  include CurationConcerns::CurationConcernController
+  with_themed_layout '1_column'
+  self.curation_concern_type = ActiveFedora::Base
+
+  def confirm
+  end
+
+  def copy
+    CurationConcerns.queue.push(VisibilityCopyWorker.new(curation_concern.id))
+    flash_message = 'Updating file permissions. This may take a few minutes. You may want to refresh your browser or return to this record later to see the updated file permissions.'
+    redirect_to polymorphic_path([main_app, :curation_concerns, curation_concern]), notice: flash_message
+  end
+
+  def curation_concern
+    @curation_concern ||= self.curation_concern_type.find(params[:id], cast: true)
+  end
+
+end

data/app/controllers/downloads_controller.rb

@@ -0,0 +1,4 @@
+class DownloadsController < ApplicationController
+  include CurationConcerns::DownloadBehavior
+
+end

data/app/controllers/embargoes_controller.rb

@@ -0,0 +1,5 @@
+class EmbargoesController < ApplicationController
+  include CurationConcerns::ManagesEmbargoes
+  include CurationConcerns::EmbargoesControllerBehavior
+  include Hydra::Collections::AcceptsBatches
+end