hyrax 3.3.0 → 3.4.2

data/app/controllers/hyrax/dashboard/collections_controller.rb

@@ -43,13 +43,10 @@ module Hyrax
       # The search builder to find the collections' members
       self.membership_service_class = Collections::CollectionMemberSearchService
 
-      load_and_authorize_resource except: [:index],
+      load_and_authorize_resource except: [:index, :create],
                                   instance_name: :collection,
                                   class: Hyrax.config.collection_model
 
-      skip_load_resource only: :create if
-        Hyrax.config.collection_class < ActiveFedora::Base
-
       def deny_collection_access(exception)
         if exception.action == :edit
           redirect_to(url_for(action: 'show'), alert: 'You do not have sufficient privileges to edit this document')
@@ -83,95 +80,66 @@ module Hyrax
 
       def edit
         form
+        collection_type
       end
 
       def after_create
-        if @collection.is_a?(ActiveFedora::Base)
-          form
-          set_default_permissions
-          # if we are creating the new collection as a subcollection (via the nested collections controller),
-          # we pass the parent_id through a hidden field in the form and link the two after the create.
-          link_parent_collection(params[:parent_id]) unless params[:parent_id].nil?
-        end
-        respond_to do |format|
-          Hyrax::SolrService.commit
-          format.html { redirect_to edit_dashboard_collection_path(@collection), notice: t('hyrax.dashboard.my.action.collection_create_success') }
-          format.json { render json: @collection, status: :created, location: dashboard_collection_path(@collection) }
-        end
+        Deprecation.warn("Method `#after_create` will be removed in Hyrax 4.0.")
+        after_create_response # call private method for processing
       end
 
       def after_create_error
-        form
-        respond_to do |format|
-          format.html { render action: 'new' }
-          format.json { render json: @collection.errors, status: :unprocessable_entity }
-        end
+        Deprecation.warn("Method `#after_create_error` will be removed in Hyrax 4.0.")
+        after_create_errors("") # call private method for processing
       end
 
       def create
-        return valkyrie_create if @collection.is_a?(Valkyrie::Resource)
         # Manual load and authorize necessary because Cancan will pass in all
         # form attributes. When `permissions_attributes` are present the
         # collection is saved without a value for `has_model.`
         @collection = Hyrax.config.collection_class.new
         authorize! :create, @collection
-        # Coming from the UI, a collection type gid should always be present.  Coming from the API, if a collection type gid is not specified,
-        # use the default collection type (provides backward compatibility with versions < Hyrax 2.1.0)
-        @collection.collection_type_gid = params[:collection_type_gid].presence || default_collection_type.to_global_id
-        @collection.attributes = collection_params.except(:members, :parent_id, :collection_type_gid)
-        @collection.apply_depositor_metadata(current_user.user_key)
-        @collection.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE unless @collection.discoverable?
-        if @collection.save
-          after_create
-          add_members_to_collection unless batch.empty?
+
+        case @collection
+        when ActiveFedora::Base
+          create_active_fedora_collection
         else
-          after_create_error
+          create_valkyrie_collection
         end
       end
 
       def after_update
-        respond_to do |format|
-          format.html { redirect_to update_referer, notice: t('hyrax.dashboard.my.action.collection_update_success') }
-          format.json { render json: @collection, status: :updated, location: dashboard_collection_path(@collection) }
-        end
+        Deprecation.warn("Method `#after_update` will be removed in Hyrax 4.0.")
+        after_update_response # call private method for processing
       end
 
       def after_update_error
-        form
-        respond_to do |format|
-          format.html { render action: 'edit' }
-          format.json { render json: @collection.errors, status: :unprocessable_entity }
-        end
+        Deprecation.warn("Method `#after_update_error` will be removed in Hyrax 4.0.")
+        after_update_errors(@collection.errors) # call private method for processing
       end
 
       def update
-        unless params[:update_collection].nil?
-          process_banner_input
-          process_logo_input
-        end
-
-        process_member_changes
-
-        return valkyrie_update if @collection.is_a?(Valkyrie::Resource)
-
-        @collection.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE unless @collection.discoverable?
-        # we don't have to reindex the full graph when updating collection
-        @collection.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX
-        if @collection.update(collection_params.except(:members))
-          after_update
+        case @collection
+        when ActiveFedora::Base
+          update_active_fedora_collection
         else
-          after_update_error
+          update_valkyrie_collection
         end
       end
 
+      def process_branding
+        process_banner_input
+        process_logo_input
+      end
+
       def after_destroy(_id)
         # leaving id to avoid changing the method's parameters prior to release
         respond_to do |format|
           format.html do
-            redirect_to my_collections_path,
+            redirect_to hyrax.my_collections_path,
                         notice: t('hyrax.dashboard.my.action.collection_delete_success')
           end
-          format.json { head :no_content, location: my_collections_path }
+          format.json { head :no_content, location: hyrax.my_collections_path }
         end
       end
 
@@ -188,8 +156,7 @@ module Hyrax
       def destroy
         case @collection
         when Valkyrie::Resource
-          Hyrax.persister.delete(resource: @collection)
-          after_destroy(params[:id])
+          valkyrie_destroy
         else
           if @collection.destroy
             after_destroy(params[:id])
@@ -217,28 +184,82 @@ module Hyrax
 
       private
 
-      def valkyrie_create
-        form.validate(collection_params) &&
-          @collection = transactions['change_set.create_collection']
-                        .with_step_args(
-                          'change_set.set_user_as_depositor' => { user: current_user },
-                          'change_set.add_to_collections' => { collection_ids: Array(params[:parent_id]) },
-                          'collection_resource.apply_collection_type_permissions' => { user: current_user }
+      def create_active_fedora_collection
+        # Coming from the UI, a collection type gid should always be present.  Coming from the API, if a collection type gid is not specified,
+        # use the default collection type (provides backward compatibility with versions < Hyrax 2.1.0)
+        @collection.collection_type_gid = params[:collection_type_gid].presence || default_collection_type.to_global_id
+        @collection.attributes = collection_params.except(:members, :parent_id, :collection_type_gid)
+        @collection.apply_depositor_metadata(current_user.user_key)
+        @collection.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE unless @collection.discoverable?
+        if @collection.save
+          after_create_response
+        else
+          after_create_errors(@collection.errors)
+        end
+      end
+
+      def create_valkyrie_collection
+        return after_create_errors(form_err_msg(form)) unless form.validate(collection_params)
+
+        result =
+          transactions['change_set.create_collection']
+          .with_step_args(
+            'change_set.set_user_as_depositor' => { user: current_user },
+            'change_set.add_to_collections' => { collection_ids: Array(params[:parent_id]) },
+            'collection_resource.apply_collection_type_permissions' => { user: current_user }
+          )
+          .call(form)
+
+        @collection = result.value_or { return after_create_errors(result.failure.first) }
+        after_create_response
+      end
+
+      def update_active_fedora_collection
+        process_member_changes
+        process_branding
+
+        @collection.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE unless @collection.discoverable?
+        # we don't have to reindex the full graph when updating collection
+        @collection.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX
+        if @collection.update(collection_params.except(:members))
+          after_update_response
+        else
+          after_update_errors(@collection.errors)
+        end
+      end
+
+      def update_valkyrie_collection
+        return after_update_errors(form_err_msg(form)) unless form.validate(collection_params)
+
+        result = transactions['change_set.update_collection']
+                 .with_step_args(
+                          'collection_resource.save_collection_banner' => { update_banner_file_ids: params["banner_files"],
+                                                                            banner_unchanged_indicator: params["banner_unchanged"] },
+                          'collection_resource.save_collection_logo' => { update_logo_file_ids: params["logo_files"],
+                                                                          alttext_values: params["alttext"],
+                                                                          linkurl_values: params["linkurl"] }
                         )
-                        .call(form)
-                        .value_or { return after_create_error }
+                 .call(form)
+        @collection = result.value_or { return after_update_errors(result.failure.first) }
 
-        after_create
-        add_members_to_collection unless batch.empty?
-        @collection
+        process_member_changes
+        after_update_response
+      end
+
+      def valkyrie_destroy
+        if transactions['collection_resource.destroy'].call(@collection).success?
+          after_destroy(params[:id])
+        else
+          after_destroy_error(params[:id])
+        end
       end
 
-      def valkyrie_update
-        form.validate(collection_params) &&
-          @collection = transactions['change_set.update_collection']
-                        .call(form)
-                        .value_or { return after_update_error }
-        after_update
+      def form_err_msg(form)
+        errmsg = []
+        form.errors.messages.each do |fld, err|
+          errmsg << "#{fld} #{err.to_sentence}"
+        end
+        errmsg.to_sentence
       end
 
       def default_collection_type
@@ -332,7 +353,10 @@ module Hyrax
       def process_logo_records(uploaded_file_ids)
         public_files = []
         uploaded_file_ids.each_with_index do |ufi, i|
-          if ufi.include?('public')
+          # If the user has chosen a new logo, the ufi will be an integer
+          # If the logo was previously chosen, the ufi will be a path
+          # If it is a path, update the rec, else create a new rec
+          if !ufi.match(/\D/).nil?
             update_logo_info(ufi, params["alttext"][i], verify_linkurl(params["linkurl"][i]))
             public_files << ufi
           else # brand new one, insert in the database
@@ -367,9 +391,7 @@ module Hyrax
       end
 
       def presenter
-        @presenter ||= begin
-          presenter_class.new(curation_concern, current_ability)
-        end
+        @presenter ||= presenter_class.new(curation_concern, current_ability)
       end
 
       def curation_concern
@@ -490,7 +512,9 @@ module Hyrax
         @form ||=
           case @collection
           when Valkyrie::Resource
-            Hyrax::Forms::ResourceForm.for(@collection)
+            form = Hyrax::Forms::ResourceForm.for(@collection)
+            form.prepopulate!
+            form
           else
             form_class.new(@collection, current_ability, repository)
           end
@@ -553,6 +577,75 @@ module Hyrax
       def valid_url?(url)
         (url =~ URI.regexp(['http', 'https']))
       end
+
+      def after_create_response
+        if @collection.is_a?(ActiveFedora::Base)
+          form
+          set_default_permissions
+          # if we are creating the new collection as a subcollection (via the nested collections controller),
+          # we pass the parent_id through a hidden field in the form and link the two after the create.
+          link_parent_collection(params[:parent_id]) unless params[:parent_id].nil?
+        end
+        respond_to do |format|
+          Hyrax::SolrService.commit
+          format.html { redirect_to edit_dashboard_collection_path(@collection), notice: t('hyrax.dashboard.my.action.collection_create_success') }
+          format.json { render json: @collection, status: :created, location: dashboard_collection_path(@collection) }
+        end
+        add_members_to_collection unless batch.empty?
+      end
+
+      def after_create_errors_for_active_fedora(errors)
+        form
+        respond_to do |format|
+          format.html do
+            flash[:error] = errors.to_s
+            render action: 'new'
+          end
+          format.json { render json: @collection.errors, status: :unprocessable_entity }
+        end
+      end
+
+      def after_create_errors(errors) # for valkyrie
+        return after_create_errors_for_active_fedora(errors) if @collection.is_a? ActiveFedora::Base
+        respond_to do |wants|
+          wants.html do
+            flash[:error] = errors.to_s
+            render 'new', status: :unprocessable_entity
+          end
+          wants.json do
+            render_json_response(response_type: :unprocessable_entity, options: { errors: errors })
+          end
+        end
+      end
+
+      def after_update_response
+        respond_to do |format|
+          format.html { redirect_to update_referer, notice: t('hyrax.dashboard.my.action.collection_update_success') }
+          format.json { render json: @collection, status: :updated, location: dashboard_collection_path(@collection) }
+        end
+      end
+
+      def after_update_errors_for_active_fedora(errors)
+        form
+        respond_to do |format|
+          format.html do
+            flash[:error] = errors.to_s
+            render action: 'edit'
+          end
+          format.json { render json: @collection.errors, status: :unprocessable_entity }
+        end
+      end
+
+      def after_update_errors(errors) # for valkyrie
+        return after_update_errors_for_active_fedora(errors) if @collection.is_a? ActiveFedora::Base
+        respond_to do |wants|
+          wants.html do
+            flash[:error] = errors.to_s
+            render 'edit', status: :unprocessable_entity
+          end
+          wants.json { render_json_response(response_type: :unprocessable_entity, options: { errors: errors }) }
+        end
+      end
     end
   end
 end

data/app/controllers/hyrax/single_use_links_viewer_controller.rb

@@ -75,7 +75,7 @@ module Hyrax
 
     def render_single_use_error(exception)
       logger.error("Rendering PAGE due to exception: #{exception.inspect} - #{exception.backtrace if exception.respond_to? :backtrace}")
-      render 'single_use_error', layout: "error", status: 404
+      render 'single_use_error', layout: "error", status: :not_found
     end
 
     def _prefixes

data/app/forms/hyrax/forms/administrative_set_form.rb

@@ -6,6 +6,20 @@ module Hyrax
     # @api public
     # @see https://github.com/samvera/valkyrie/wiki/ChangeSets-and-Dirty-Tracking
     class AdministrativeSetForm < Valkyrie::ChangeSet
+      ##
+      # @api private
+      AdminSetMembersPopulator = lambda do |_options|
+        self.member_ids =
+          if model.new_record
+            []
+          else
+            Hyrax
+              .query_service
+              .find_inverse_references_by(property: :admin_set_id, resource: model)
+              .map(&:id)
+          end
+      end
+
       property :title, required: true, primary: true
       property :description, primary: true
 
@@ -13,7 +27,11 @@ module Hyrax
       property :date_modified, readable: false
       property :date_uploaded, readable: false
 
-      property :depositor
+      property :creator
+
+      validates :title, presence: true
+
+      property :member_ids, virtual: true, default: [], prepopulator: AdminSetMembersPopulator
 
       class << self
         def model_class

data/app/forms/hyrax/forms/batch_edit_form.rb

@@ -65,7 +65,7 @@ module Hyrax
       def initialize_combined_fields
         # For each of the files in the batch, set the attributes to be the concatenation of all the attributes
         batch_document_ids.each_with_object({}) do |doc_id, combined_attributes|
-          work = ActiveFedora::Base.find(doc_id)
+          work = Hyrax.query_service.find_by(id: doc_id)
           terms.each do |field|
             combined_attributes[field] ||= []
             combined_attributes[field] = (combined_attributes[field] + work[field].to_a).uniq

data/app/forms/hyrax/forms/collection_form.rb

@@ -9,7 +9,7 @@ module Hyrax
       attr_reader :scope
 
       delegate :id, :depositor, :permissions, :human_readable_type, :member_ids, :nestable?,
-               :alternative_title, to: :model
+               :alternative_title, :visibility, to: :model
 
       class_attribute :membership_service_class
 

data/app/forms/hyrax/forms/dashboard/nest_collection_form.rb

@@ -26,11 +26,11 @@ module Hyrax
                        context:,
                        query_service: default_query_service,
                        persistence_service: default_persistence_service)
-          self.parent = parent || (parent_id.present? && Hyrax.config.collection_class.find(parent_id))
-          self.child = child || (child_id.present? && Hyrax.config.collection_class.find(child_id))
           self.context = context
           self.query_service = query_service
           self.persistence_service = persistence_service
+          self.parent = parent || (parent_id.present? && find_parent(parent_id))
+          self.child = child || (child_id.present? && find_child(child_id))
         end # rubocop:enable Metrics/ParameterLists
 
         attr_accessor :parent, :child
@@ -83,7 +83,7 @@ module Hyrax
         # rerouting to new_dashboard_collection_path to add the new collection as
         # a child. Since we don't yet have a child collection, the valid? option can't be used here.
         def validate_add
-          if parent.try(:nestable?)
+          if nestable?(parent)
             nesting_within_maximum_depth
           else
             errors.add(:parent, :cannot_have_child_nested)
@@ -116,15 +116,30 @@ module Hyrax
         end
 
         def parent_and_child_can_be_nested
-          if parent.try(:nestable?) && child.try(:nestable?)
+          if nestable?(parent) && nestable?(child)
             return true if query_service.parent_and_child_can_nest?(parent: parent, child: child, scope: context)
             errors.add(:parent, :cannot_have_child_nested)
             errors.add(:child, :cannot_nest_in_parent)
           else
-            errors.add(:parent, :is_not_nestable) unless parent.try(:nestable?)
-            errors.add(:child, :is_not_nestable) unless child.try(:nestable?)
+            errors.add(:parent, :is_not_nestable) unless nestable?(parent)
+            errors.add(:child, :is_not_nestable) unless nestable?(child)
           end
         end
+
+        def find_parent(parent_id)
+          Hyrax.query_service.find_by(id: parent_id)
+        end
+
+        def find_child(child_id)
+          Hyrax.query_service.find_by(id: child_id)
+        end
+
+        def nestable?(collection)
+          return false if collection.blank?
+          return collection.nestable? if collection.respond_to? :nestable?
+          collection_type = Hyrax::CollectionType.find_by_gid!(collection.collection_type_gid)
+          collection_type.nestable?
+        end
       end
     end
   end

data/app/forms/hyrax/forms/pcdm_collection_form.rb

@@ -6,7 +6,32 @@ module Hyrax
     # @api public
     # @see https://github.com/samvera/valkyrie/wiki/ChangeSets-and-Dirty-Tracking
     class PcdmCollectionForm < Valkyrie::ChangeSet # rubocop:disable Metrics/ClassLength
-      property :title, required: true, primary: true
+      include Hyrax::FormFields(:core_metadata)
+
+      BannerInfoPrepopulator = lambda do |_options|
+        self.banner_info ||= begin
+          banner_info = CollectionBrandingInfo.where(collection_id: id.to_s, role: "banner")
+          banner_file = File.split(banner_info.first.local_path).last unless banner_info.empty?
+          alttext = banner_info.first.alt_text unless banner_info.empty?
+          file_location = banner_info.first.local_path unless banner_info.empty?
+          relative_path = "/" + banner_info.first.local_path.split("/")[-4..-1].join("/") unless banner_info.empty?
+          { file: banner_file, full_path: file_location, relative_path: relative_path, alttext: alttext }
+        end
+      end
+
+      LogoInfoPrepopulator = lambda do |_options|
+        self.logo_info ||= begin
+          logos_info = CollectionBrandingInfo.where(collection_id: id.to_s, role: "logo")
+
+          logos_info.map do |logo_info|
+            logo_file = File.split(logo_info.local_path).last
+            relative_path = "/" + logo_info.local_path.split("/")[-4..-1].join("/")
+            alttext = logo_info.alt_text
+            linkurl = logo_info.target_url
+            { file: logo_file, full_path: logo_info.local_path, relative_path: relative_path, alttext: alttext, linkurl: linkurl }
+          end
+        end
+      end
 
       property :human_readable_type, writable: false
       property :date_modified, readable: false
@@ -14,12 +39,15 @@ module Hyrax
 
       property :depositor, required: true
       property :collection_type_gid, required: true
+      property :visibility, default: VisibilityIntention::PRIVATE
 
       property :member_of_collection_ids, default: [], type: Valkyrie::Types::Array
 
-      validates :title, presence: true
       validates :collection_type_gid, presence: true
 
+      property :banner_info, virtual: true, prepopulator: BannerInfoPrepopulator
+      property :logo_info, virtual: true, prepopulator: LogoInfoPrepopulator
+
       class << self
         def model_class
           Hyrax::PcdmCollection

data/app/forms/hyrax/forms/permission_template_form.rb

@@ -7,16 +7,12 @@ module Hyrax
       self.model_class = PermissionTemplate
       self.terms = []
       delegate :access_grants, :access_grants_attributes=, :release_date, :release_period, :visibility, to: :model
-      delegate :available_workflows, :active_workflow, :source_model, to: :model
-
-      # @return [#to_s] the primary key of the associated admin_set or collection
-      # def source_id (because you might come looking for this method)
-      delegate :id, to: :source_model, prefix: :source
+      delegate :available_workflows, :active_workflow, :source, :source_id, to: :model
 
       ##
-      # @deprecated  use PermissionTemplate#reset_access_controls instead.
+      # @deprecated  use PermissionTemplate#reset_access_controls_for instead.
       def reset_access_controls!
-        Deprecation.warn("reset_access_controls! is deprecated; use PermissionTemplate#reset_access_controls instead.")
+        Deprecation.warn("reset_access_controls! is deprecated; use PermissionTemplate#reset_access_controls_for instead.")
         source_model.reset_access_controls!
       end
 
@@ -73,8 +69,8 @@ module Hyrax
       # Copy this access to the permissions of the Admin Set or Collection and to
       # the WorkflowResponsibilities of the active workflow if this is an Admin Set
       def update_access(remove_agent: false)
-        source_model.reset_access_controls!
-        update_workflow_responsibilities(remove_agent: remove_agent) if source_model.is_a?(AdminSet)
+        model.reset_access_controls_for(collection: source)
+        update_workflow_responsibilities(remove_agent: remove_agent) if source.is_a?(Hyrax::AdministrativeSet)
       end
 
       # This method is used to revoke access to a Collection or Admin Set and its workflows
@@ -85,6 +81,18 @@ module Hyrax
         update_access(remove_agent: true)
       end
 
+      ##
+      # A bit of an analogue for a `belongs_to :source_model` as it crosses from Fedora to the DB
+      # @return [AdminSet, ::Collection]
+      # @raise [Hyrax::ObjectNotFoundError] when neither an AdminSet or Collection is found
+      # @note This method will eventually be replaced by #source which returns a Hyrax::Resource
+      #   object.  Many methods are equally able to process both Hyrax::Resource and
+      #   ActiveFedora::Base.  Only call this method if you need the ActiveFedora::Base object.
+      # @see #source
+      def source_model # rubocop:disable Rails/Delegate
+        model.source_model
+      end
+
       private
 
       # @return [String]

data/app/forms/hyrax/forms/resource_form.rb

@@ -33,7 +33,7 @@ module Hyrax
     class ResourceForm < Hyrax::ChangeSet # rubocop:disable Metrics/ClassLength
       ##
       # @api private
-      InWorksPopulator = lambda do |_options|
+      InWorksPrepopulator = lambda do |_options|
         self.in_works_ids =
           if persisted?
             Hyrax.query_service
@@ -52,7 +52,7 @@ module Hyrax
       #   with `etag`-driven, application-side lock checks. for non-wings adapters
       #   we want to move away from application side lock validation and rely
       #   on the adapter/database features instead.
-      LockKeyPopulator = lambda do |_options|
+      LockKeyPrepopulator = lambda do |_options|
         if Hyrax.config.disable_wings || !Hyrax.metadata_adapter.is_a?(Wings::Valkyrie::MetadataAdapter)
           Hyrax.logger.info "trying to prepopulate a lock token for " \
                             "#{self.class.inspect}, but optimistic locking isn't " \
@@ -95,10 +95,12 @@ module Hyrax
       property :visibility_during_lease, virtual: true, prepopulator: ->(_opts) { self.visibility_during_lease = model.lease&.visibility_during_lease }
 
       # pcdm relationships
-      property :admin_set_id, prepopulator: ->(_opts) { self.admin_set_id = AdminSet::DEFAULT_ID }
-      property :in_works_ids, virtual: true, prepopulator: InWorksPopulator
+      property :admin_set_id, prepopulator: ->(_opts) { self.admin_set_id = Hyrax::AdminSetCreateService.find_or_create_default_admin_set.id.to_s }
+      property :in_works_ids, virtual: true, prepopulator: InWorksPrepopulator
       property :member_ids, default: [], type: Valkyrie::Types::Array
       property :member_of_collection_ids, default: [], type: Valkyrie::Types::Array
+      property :member_of_collections_attributes, virtual: true, populator: :in_collections_populator
+      validates_with CollectionMembershipValidator
 
       property :representative_id, type: Valkyrie::Types::String
       property :thumbnail_id, type: Valkyrie::Types::String
@@ -112,7 +114,7 @@ module Hyrax
       # the model is disabled
       #
       # @see https://github.com/samvera/valkyrie/wiki/Optimistic-Locking
-      property :version, virtual: true, prepopulator: LockKeyPopulator
+      property :version, virtual: true, prepopulator: LockKeyPrepopulator
 
       # backs the child work search element;
       # @todo: look for a way for the view template not to depend on this
@@ -131,6 +133,8 @@ module Hyrax
           "#{resource.class.name}Form".constantize.new(resource)
         rescue NameError => _err
           case resource
+          when Hyrax::AdministrativeSet
+            Hyrax::Forms::AdministrativeSetForm.new(resource)
           when Hyrax::FileSet
             Hyrax::Forms::FileSetForm.new(resource)
           when Hyrax::PcdmCollection
@@ -204,6 +208,20 @@ module Hyrax
 
       private
 
+      def in_collections_populator(fragment:, **_options)
+        adds = []
+        deletes = []
+        fragment.each do |_, h|
+          if h["_destroy"] == "true"
+            deletes << Valkyrie::ID.new(h["id"])
+          else
+            adds << Valkyrie::ID.new(h["id"])
+          end
+        end
+
+        self.member_of_collection_ids = ((member_of_collection_ids + adds) - deletes).uniq
+      end
+
       # https://trailblazer.to/2.1/docs/reform.html#reform-populators-populator-collections
       def permission_populator(collection:, index:, **)
         Hyrax::Forms::Permission.new(collection[index])

data/app/forms/hyrax/forms/widgets/admin_set_visibility.rb

@@ -6,7 +6,7 @@ module Hyrax
         # Visibility options for permission templates
         def options
           i18n_prefix = "hyrax.admin.admin_sets.form_visibility.visibility"
-          # Note: Visibility 'varies' = '' implies no constraints
+          # NOTE: Visibility 'varies' = '' implies no constraints
           [[Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC, I18n.t('.everyone', scope: i18n_prefix)],
            ['', I18n.t('.varies', scope: i18n_prefix)],
            [Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED, I18n.t('.institution', scope: i18n_prefix)],