worthwhile 0.0.1.alpha → 0.0.1

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

@@ -0,0 +1,131 @@
+module Worthwhile::CurationConcernController
+  extend ActiveSupport::Concern
+  include Worthwhile::WithoutNamespace
+  include Blacklight::Catalog::SearchContext
+
+  included do
+    include Worthwhile::ThemedLayoutController
+    with_themed_layout '1_column'
+    helper Worthwhile::AbilityHelper
+
+    class_attribute :curation_concern_type
+    attr_accessor :curation_concern
+    helper_method :curation_concern
+    helper_method :contributor_agreement
+
+    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
+      Worthwhile::ControllerResource
+    end
+  end
+
+  def contributor_agreement
+    @contributor_agreement ||= Worthwhile::ContributorAgreement.new(curation_concern, current_user, params)
+  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_concern, 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_concern, 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 ||= Worthwhile::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_concern/base']
+    end
+
+    def after_create_response
+      respond_with([:curation_concern, curation_concern])
+    end
+
+    def after_update_response
+      if actor.visibility_changed?
+        redirect_to confirm_curation_concern_permission_path(curation_concern)
+      else
+        respond_with([:curation_concern, 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[hash_key_for_curation_concern]
+    end
+
+    def hash_key_for_curation_concern
+      self.class.curation_concern_type.name.underscore.to_sym
+    end
+end

data/app/controllers/concerns/worthwhile/files_controller.rb

@@ -0,0 +1,149 @@
+module Worthwhile
+  module FilesController
+    extend ActiveSupport::Concern
+    include Worthwhile::WithoutNamespace
+
+    included do
+      include Worthwhile::ThemedLayoutController
+      with_themed_layout '1_column'
+      load_and_authorize_resource class: Worthwhile::GenericFile
+      helper_method :curation_concern
+      include Worthwhile::ParentContainer
+    end
+
+    def curation_concern
+      @generic_file
+    end
+
+    # routed to /files/new
+    def new
+      @batch_noid = Sufia::Noid.noidify(Sufia::IdService.mint)
+    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 [:curation_concern, @generic_file.batch], notice: "The file has been deleted."
+    end
+
+    # routed to /files/:id (PUT)
+    def update
+      success = if wants_to_revert?
+        actor.revert_content(params[:revision], datastream_id)
+      elsif params.has_key? :files
+        actor.update_content(params[:files].first, datastream_id)
+      elsif params.has_key? :generic_file
+        actor.update_metadata(params[:generic_file], params[:generic_file][:visibility])
+      end
+
+      if success
+        redirect_to [:curation_concern, @generic_file], notice:
+          "The file #{view_context.link_to(@generic_file, [main_app, :curation_concern, @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
+
+    protected
+
+    def wants_to_revert?
+      params.has_key?(:revision) && params[:revision] != @generic_file.content.latest_version.versionID
+    end
+
+    def actor
+      @actor ||= ::CurationConcern::GenericFileActor.new(@generic_file, current_user, attributes)
+    end
+
+    def attributes
+      params[:generic_file]
+    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_concern/base
+      @_prefixes ||= super + ['curation_concern/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(namespaced_parent_id)
+      if actor.create_content(file, file.original_filename, datastream_id)
+        respond_to do |format|
+          format.html {
+            if request.xhr?
+              render json: [@generic_file.to_jq_upload], content_type: 'text/html', layout: false
+            else
+              redirect_to [:curation_concern, @generic_file.batch]
+            end
+          }
+          format.json {
+            render json: [@generic_file.to_jq_upload]
+          }
+        end
+      else
+        msg = @generic_file.errors.full_messages.join(', ')
+        flash[:error] = msg
+        json_error "Error creating generic file: #{msg}"
+      end
+    end
+
+    # The name of the datastream where we store the file data
+    def datastream_id
+      'content'
+    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/worthwhile/manages_embargoes.rb

@@ -0,0 +1,22 @@
+module Worthwhile
+  module ManagesEmbargoes
+    extend ActiveSupport::Concern
+
+    included do
+      include Worthwhile::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
+    end
+
+
+    def index
+      authorize! :discover, :embargo
+    end
+
+    def edit
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Worthwhile::ParentContainer
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :parent
+    before_filter :authorize_edit_parent_rights!, except: [:show]
+  end
+
+  def parent
+    @parent ||= new_or_create? ? ActiveFedora::Base.find(parent_id) : curation_concern.batch
+  end
+
+  def parent_id
+    @parent_id ||= new_or_create? ? namespaced_parent_id : curation_concern.batch_id
+  end
+
+  protected
+
+    def new_or_create?
+      ['create', 'new'].include? action_name
+    end
+
+    def namespaced_parent_id
+      Sufia::Noid.namespaceize(params[:parent_id])
+    end
+
+    def authorize_edit_parent_rights!
+      authorize! :edit, parent_id
+    end
+
+end

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

@@ -0,0 +1,31 @@
+# Copied from Curate
+module Worthwhile::ThemedLayoutController
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :theme
+    self.theme = 'curate_nd'
+    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/worthwhile/without_namespace.rb

@@ -0,0 +1,15 @@
+module Worthwhile
+  # 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] = Sufia::Noid.namespaceize(params[:id])
+      end
+  end
+end

data/app/controllers/curation_concern/generic_files_controller.rb

@@ -0,0 +1,6 @@
+module CurationConcern
+  class GenericFilesController < ApplicationController
+    include Worthwhile::FilesController
+  end
+end
+

data/app/controllers/curation_concern/generic_works_controller.rb

@@ -0,0 +1,6 @@
+module CurationConcern
+  class GenericWorksController < ApplicationController
+    include Worthwhile::CurationConcernController
+    set_curation_concern_type GenericWork
+  end
+end

data/app/controllers/curation_concern/linked_resources_controller.rb

@@ -0,0 +1,68 @@
+class CurationConcern::LinkedResourcesController < ApplicationController
+  include Worthwhile::ThemedLayoutController
+  include Worthwhile::WithoutNamespace
+  with_themed_layout '1_column'
+  respond_to(:html)
+
+  load_and_authorize_resource class: Worthwhile::LinkedResource, instance_name: :curation_concern
+  include Worthwhile::ParentContainer
+
+  def new
+    respond_with(curation_concern)
+  end
+
+  def create
+    curation_concern.batch = parent
+    if actor.create
+      respond_with([:curation_concern, parent])
+    else
+      respond_with([:curation_concern, curation_concern]) { |wants|
+        wants.html { render 'new', status: :unprocessable_entity }
+      }
+    end
+  end
+
+  def edit
+    respond_with(curation_concern)
+  end
+
+  def update
+    if actor.update
+      respond_with([:curation_concern, curation_concern.batch])
+    else
+      respond_with([:curation_concern, curation_concern]) { |wants|
+        wants.html { render 'edit', status: :unprocessable_entity }
+      }
+    end
+  end
+
+  def destroy
+    parent = curation_concern.batch
+    flash[:notice] = "Deleted #{curation_concern}"
+    curation_concern.destroy
+    respond_with([:curation_concern, parent])
+  end
+
+  def attach_action_breadcrumb
+    add_breadcrumb "#{parent.human_readable_type}", polymorphic_path([:curation_concern, parent])
+    super
+  end
+
+  attr_writer :actor
+  def actor
+    @actor ||= Worthwhile::CurationConcern.actor(curation_concern, current_user, params[:linked_resource])
+  end
+
+  def curation_concern
+    @curation_concern
+  end
+
+  helper_method :curation_concern
+
+  protected
+    def _prefixes
+      # This allows us to use the unauthorized template in curation_concern/base
+      @_prefixes ||= super + ['curation_concern/base']
+    end
+
+end