hyrax 1.1.1 → 2.0.0.beta1

data/app/controllers/concerns/hydra/batch_edit_behavior.rb

@@ -1,73 +0,0 @@
-module Hydra
-  module BatchEditBehavior
-    extend ActiveSupport::Concern
-
-    included do
-      include Hyrax::Collections::AcceptsBatches
-
-      before_action :filter_docs_with_access!, only: [:edit, :update, :destroy_collection]
-      before_action :check_for_empty!, only: [:edit, :update, :destroy_collection]
-    end
-
-    # fetch the documents that match the ids in the folder
-    def index
-      @response, @documents = get_solr_response_for_field_values("id", batch)
-    end
-
-    def state
-      session[:batch_edit_state] = params[:state]
-      render json: { "OK" => "OK" }
-    end
-
-    def edit; end
-
-    # pulled out to allow a user to override the default redirect
-    def after_update
-      redirect_to catalog_index_path
-    end
-
-    # called before the save of the document on update to do addition processes on the document beyond update_attributes
-    def update_document(obj)
-      type = obj.class.to_s.underscore.to_sym
-      obj.update_attributes(params[type].reject { |_k, v| v.blank? })
-    end
-
-    def update
-      batch.each do |doc_id|
-        obj = ActiveFedora::Base.find(doc_id, cast: true)
-        update_document(obj)
-        obj.save
-      end
-      flash[:notice] = "Batch update complete"
-      after_update
-    end
-
-    def all
-      self.batch = Hyrax::Collections::SearchService.new(session, current_user.user_key).last_search_documents.map(&:id)
-      respond_to do |format|
-        format.html { redirect_to edit_batch_edits_path }
-        format.js { render json: batch }
-      end
-    end
-
-    # pulled out to allow a user to override the default redirect
-    def after_destroy_collection
-      redirect_to catalog_index_path
-    end
-
-    def destroy_collection
-      batch.each do |doc_id|
-        obj = ActiveFedora::Base.find(doc_id, cast: true)
-        obj.destroy
-      end
-      flash[:notice] = "Batch delete complete"
-      after_destroy_collection
-    end
-
-    def check_for_empty!
-      return unless check_for_empty_batch?
-      redirect_back fallback_location: hyrax.batch_edits_path
-      false
-    end
-  end
-end

data/app/controllers/concerns/hyrax/batch_edits_controller_behavior.rb

@@ -1,84 +0,0 @@
-module Hyrax
-  module BatchEditsControllerBehavior
-    extend ActiveSupport::Concern
-    include Hyrax::Breadcrumbs
-
-    included do
-      before_action :build_breadcrumbs, only: :edit
-
-      # provides the help_text view method
-      helper PermissionsHelper
-    end
-
-    def edit
-      super
-      work = form_class.model_class.new
-      work.depositor = current_user.user_key
-      @form = form_class.new(work, current_user, batch)
-    end
-
-    def after_update
-      respond_to do |format|
-        format.json { head :no_content }
-        format.html { redirect_to_return_controller }
-      end
-    end
-
-    def after_destroy_collection
-      redirect_to_return_controller unless request.xhr?
-    end
-
-    def update_document(obj)
-      obj.attributes = work_params
-      obj.date_modified = Time.current.ctime
-      obj.visibility = params[:visibility]
-    end
-
-    def update
-      case params["update_type"]
-      when "update"
-        super
-      when "delete_all"
-        destroy_batch
-      end
-    end
-
-    protected
-
-      def add_breadcrumb_for_controller
-        add_breadcrumb I18n.t('hyrax.dashboard.my.works'), hyrax.dashboard_works_path
-      end
-
-      def _prefixes
-        # This allows us to use the templates in hyrax/base, while prefering
-        # our local paths. Thus we are unable to just override `self.local_prefixes`
-        @_prefixes ||= super + ['hyrax/base']
-      end
-
-      def destroy_batch
-        batch.each { |id| ActiveFedora::Base.find(id).destroy }
-        after_update
-      end
-
-      def form_class
-        Forms::BatchEditForm
-      end
-
-      def terms
-        form_class.terms
-      end
-
-      def work_params
-        work_params = params[form_class.model_name.param_key] || ActionController::Parameters.new
-        form_class.model_attributes(work_params)
-      end
-
-      def redirect_to_return_controller
-        if params[:return_controller]
-          redirect_to hyrax.url_for(controller: params[:return_controller], only_path: true)
-        else
-          redirect_to hyrax.dashboard_index_path
-        end
-      end
-  end
-end

data/app/controllers/concerns/hyrax/batch_uploads_controller_behavior.rb

@@ -1,69 +0,0 @@
-module Hyrax
-  module BatchUploadsControllerBehavior
-    extend ActiveSupport::Concern
-    include Hydra::Controller::ControllerBehavior
-    include Hyrax::CurationConcernController
-
-    included do
-      self.work_form_service = BatchUploadFormService
-      self.curation_concern_type = work_form_service.form_class.model_class # includes CanCan side-effects
-      # We use BatchUploadItem as a null stand-in curation_concern_type.
-      # The actual permission is checked dynamically during #create.
-    end
-
-    # The permissions to create a batch are not as important as the permissions for the concern being batched.
-    # @note we don't call `authorize!` directly, since `authorized_models` already checks `user.can? :create, ...`
-    def create
-      authenticate_user!
-      unsafe_pc = params.fetch(:batch_upload_item, {})[:payload_concern]
-      # Calling constantize on user params is disfavored (per brakeman), so we sanitize by matching it against an authorized model.
-      safe_pc = Hyrax::SelectTypeListPresenter.new(current_user).authorized_models.map(&:to_s).find { |x| x == unsafe_pc }
-      raise CanCan::AccessDenied, "Cannot create an object of class '#{unsafe_pc}'" unless safe_pc
-      # authorize! :create, safe_pc
-      create_update_job(safe_pc)
-      # Calling `#t` in a controller context does not mark _html keys as html_safe
-      flash[:notice] = view_context.t('hyrax.works.create.after_create_html', application_name: view_context.application_name)
-      redirect_after_update
-    end
-
-    # Gives the class of the form.
-    class BatchUploadFormService < Hyrax::WorkFormService
-      def self.form_class(_ = nil)
-        ::Hyrax::Forms::BatchUploadForm
-      end
-    end
-
-    protected
-
-      def build_form
-        super
-        @form.payload_concern = params[:payload_concern]
-      end
-
-      def redirect_after_update
-        if uploading_on_behalf_of?
-          redirect_to hyrax.dashboard_shares_path
-        else
-          redirect_to hyrax.dashboard_works_path
-        end
-      end
-
-      # @param [String] klass the name of the Hyrax Work Class being created by the batch
-      # @note Cannot use a proper Class here because it won't serialize
-      def create_update_job(klass)
-        operation = BatchCreateOperation.create!(user: current_user,
-                                                 operation_type: "Batch Create")
-        # ActionController::Parameters are not serializable, so cast to a hash
-        BatchCreateJob.perform_later(current_user,
-                                     params[:title].permit!.to_h,
-                                     params.fetch(:resource_type, {}).permit!.to_h,
-                                     params[:uploaded_files],
-                                     attributes_for_actor.to_h.merge!(model: klass),
-                                     operation)
-      end
-
-      def uploading_on_behalf_of?
-        params.fetch(hash_key_for_curation_concern).key?(:on_behalf_of)
-      end
-  end
-end

data/app/controllers/concerns/hyrax/contact_form_controller_behavior.rb

@@ -1,45 +0,0 @@
-module Hyrax
-  module ContactFormControllerBehavior
-    extend ActiveSupport::Concern
-    included do
-      before_action :build_contact_form
-      layout 'homepage'
-    end
-
-    def new; end
-
-    def create
-      # not spam and a valid form
-      if @contact_form.valid?
-        ContactMailer.contact(@contact_form).deliver_now
-        flash.now[:notice] = 'Thank you for your message!'
-        after_deliver
-        @contact_form = ContactForm.new
-      else
-        flash.now[:error] = 'Sorry, this message was not sent successfully. '
-        flash.now[:error] << @contact_form.errors.full_messages.map(&:to_s).join(", ")
-      end
-      render :new
-    rescue RuntimeError => e
-      logger.error("Contact form failed to send: #{e.inspect}")
-      flash.now[:error] = 'Sorry, this message was not delivered.'
-      render :new
-    end
-
-    # Override this method if you want to perform additional operations
-    # when a email is successfully sent, such as sending a confirmation
-    # response to the user.
-    def after_deliver; end
-
-    protected
-
-      def build_contact_form
-        @contact_form = Hyrax::ContactForm.new(contact_form_params)
-      end
-
-      def contact_form_params
-        return {} unless params.key?(:contact_form)
-        params.require(:contact_form).permit(:contact_method, :category, :name, :email, :subject, :message)
-      end
-  end
-end

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

@@ -1,241 +0,0 @@
-module Hyrax
-  module CurationConcernController
-    extend ActiveSupport::Concern
-    include Blacklight::Base
-    include Blacklight::AccessControls::Catalog
-
-    included do
-      copy_blacklight_config_from(::CatalogController)
-
-      class_attribute :_curation_concern_type, :show_presenter, :work_form_service, :search_builder_class
-      self.show_presenter = Hyrax::WorkShowPresenter
-      self.work_form_service = Hyrax::WorkFormService
-      self.search_builder_class = WorkSearchBuilder
-      attr_accessor :curation_concern
-      helper_method :curation_concern, :contextual_path
-
-      rescue_from WorkflowAuthorizationException, with: :render_unavailable
-    end
-
-    module ClassMethods
-      def curation_concern_type=(curation_concern_type)
-        load_and_authorize_resource class: curation_concern_type, instance_name: :curation_concern, except: [:show, :file_manager, :inspect_work]
-
-        # Load the fedora resource to get the etag.
-        # No need to authorize for the file manager, because it does authorization via the presenter.
-        load_resource class: curation_concern_type, instance_name: :curation_concern, only: :file_manager
-
-        self._curation_concern_type = curation_concern_type
-      end
-
-      def curation_concern_type
-        _curation_concern_type
-      end
-
-      def cancan_resource_class
-        Hyrax::ControllerResource
-      end
-    end
-
-    def new
-      build_form
-    end
-
-    def create
-      if actor.create(attributes_for_actor)
-        after_create_response
-      else
-        respond_to do |wants|
-          wants.html do
-            build_form
-            render 'new', status: :unprocessable_entity
-          end
-          wants.json { render_json_response(response_type: :unprocessable_entity, options: { errors: curation_concern.errors }) }
-        end
-      end
-    end
-
-    # Finds a solr document matching the id and sets @presenter
-    # @raise CanCan::AccessDenied if the document is not found or the user doesn't have access to it.
-    def show
-      respond_to do |wants|
-        wants.html { presenter && parent_presenter }
-        wants.json do
-          # load and authorize @curation_concern manually because it's skipped for html
-          @curation_concern = _curation_concern_type.find(params[:id]) unless curation_concern
-          authorize! :show, @curation_concern
-          render :show, status: :ok
-        end
-        additional_response_formats(wants)
-        wants.ttl do
-          render body: presenter.export_as_ttl, content_type: 'text/turtle'
-        end
-        wants.jsonld do
-          render body: presenter.export_as_jsonld, content_type: 'application/ld+json'
-        end
-        wants.nt do
-          render body: presenter.export_as_nt, content_type: 'application/n-triples'
-        end
-      end
-    end
-
-    def edit
-      build_form
-    end
-
-    def update
-      if actor.update(attributes_for_actor)
-        after_update_response
-      else
-        respond_to do |wants|
-          wants.html do
-            build_form
-            render 'edit', status: :unprocessable_entity
-          end
-          wants.json { render_json_response(response_type: :unprocessable_entity, options: { errors: curation_concern.errors }) }
-        end
-      end
-    end
-
-    def destroy
-      title = curation_concern.to_s
-      return unless actor.destroy
-      Hyrax.config.callback.run(:after_destroy, curation_concern.id, current_user)
-      after_destroy_response(title)
-    end
-
-    def file_manager
-      @form = Forms::FileManagerForm.new(curation_concern, current_ability)
-    end
-
-    def inspect_work
-      raise Hydra::AccessDenied unless current_ability.admin?
-      presenter
-    end
-
-    attr_writer :actor
-
-    protected
-
-      def build_form
-        @form = work_form_service.build(curation_concern, current_ability, self)
-      end
-
-      def actor
-        @actor ||= Hyrax::CurationConcern.actor(curation_concern, current_ability)
-      end
-
-      def presenter
-        @presenter ||= show_presenter.new(curation_concern_from_search_results, current_ability, request)
-      end
-
-      def parent_presenter
-        @parent_presenter ||=
-          begin
-            if params[:parent_id]
-              @parent_presenter ||= show_presenter.new(search_result_document(id: params[:parent_id]), current_ability, request)
-            end
-          end
-      end
-
-      # Include 'hyrax/base' in the search path for views, while prefering
-      # our local paths. Thus we are unable to just override `self.local_prefixes`
-      def _prefixes
-        @_prefixes ||= super + ['hyrax/base']
-      end
-
-      def after_create_response
-        respond_to do |wants|
-          wants.html { redirect_to contextual_path(curation_concern, parent_presenter) }
-          wants.json { render :show, status: :created, location: polymorphic_path([main_app, curation_concern]) }
-        end
-      end
-
-      def after_update_response
-        # TODO: visibility or lease/embargo status
-        if curation_concern.visibility_changed? && curation_concern.file_sets.present?
-          redirect_to main_app.confirm_hyrax_permission_path(curation_concern)
-        else
-          respond_to do |wants|
-            wants.html { redirect_to [main_app, curation_concern] }
-            wants.json { render :show, status: :ok, location: polymorphic_path([main_app, curation_concern]) }
-          end
-        end
-      end
-
-      def after_destroy_response(title)
-        flash[:notice] = "Deleted #{title}"
-        respond_to do |wants|
-          wants.html { redirect_to main_app.search_catalog_path }
-          wants.json { render_json_response(response_type: :deleted, message: "Deleted #{curation_concern.id}") }
-        end
-      end
-
-      def attributes_for_actor
-        raw_params = params[hash_key_for_curation_concern]
-        return {} unless raw_params
-        work_form_service.form_class(curation_concern).model_attributes(raw_params)
-      end
-
-      def hash_key_for_curation_concern
-        _curation_concern_type.model_name.param_key
-      end
-
-      # Override this method to add additional response
-      # formats to your local app
-      def additional_response_formats(_)
-        # nop
-      end
-
-      def contextual_path(presenter, parent_presenter)
-        ::Hyrax::ContextualPath.new(presenter, parent_presenter).show
-      end
-
-    private
-
-      def curation_concern_from_search_results
-        search_result_document(params)
-      end
-
-      # Only returns unsuppressed documents the user has read access to
-      def search_result_document(search_params)
-        _, document_list = search_results(search_params)
-        return document_list.first unless document_list.empty?
-        document_not_found!
-      end
-
-      def document_not_found!
-        doc = ::SolrDocument.find(params[:id])
-        raise WorkflowAuthorizationException if doc.suppressed?
-        raise CanCan::AccessDenied.new(nil, :show)
-      end
-
-      def render_unavailable
-        message = I18n.t("hyrax.workflow.unauthorized")
-        respond_to do |wants|
-          wants.html do
-            unavailable_presenter
-            flash[:notice] = message
-            render 'unavailable', status: :unauthorized
-          end
-          wants.json do
-            render plain: message, status: :unauthorized
-          end
-          additional_response_formats(wants)
-          wants.ttl do
-            render plain: message, status: :unauthorized
-          end
-          wants.jsonld do
-            render plain: message, status: :unauthorized
-          end
-          wants.nt do
-            render plain: message, status: :unauthorized
-          end
-        end
-      end
-
-      def unavailable_presenter
-        @presenter ||= show_presenter.new(::SolrDocument.find(params[:id]), current_ability, request)
-      end
-  end
-end