hyrax 2.0.3 → 2.1.0.beta1

data/app/search_builders/hyrax/dashboard/works_search_builder.rb

@@ -0,0 +1,18 @@
+module Hyrax
+  module Dashboard
+    class WorksSearchBuilder < Hyrax::WorksSearchBuilder
+      include Hyrax::Dashboard::ManagedSearchFilters
+
+      self.default_processor_chain += [:show_only_managed_works_for_non_admins]
+
+      # Adds a filter to exclude works created by the current user if the
+      # current user is not an admin.
+      # @param [Hash] solr_parameters
+      def show_only_managed_works_for_non_admins(solr_parameters)
+        return if current_ability.admin?
+        solr_parameters[:fq] ||= []
+        solr_parameters[:fq] << '-' + ActiveFedora::SolrQueryBuilder.construct_query_for_rel(depositor: current_user_key)
+      end
+    end
+  end
+end

data/app/search_builders/hyrax/filter_suppressed_with_roles.rb

@@ -13,7 +13,7 @@ module Hyrax
     # workflow actions on the work corresponding to the SolrDocument
     # with id = `blacklight_params[:id]`
     def only_active_works(solr_parameters)
-      return if user_has_active_workflow_role?
+      return if user_has_active_workflow_role? || depositor?
       super
     end
 
@@ -29,5 +29,9 @@ module Hyrax
         # The current_work doesn't have a sipity workflow entity
         false
       end
+
+      def depositor?
+        current_work[DepositSearchBuilder.depositor_field].first == current_ability.current_user.user_key
+      end
   end
 end

data/app/search_builders/hyrax/my/collections_search_builder.rb

@@ -1,8 +1,25 @@
 # Added to allow for the My controller to show only things I have edit access to
-class Hyrax::My::CollectionsSearchBuilder < Hyrax::My::SearchBuilder
+class Hyrax::My::CollectionsSearchBuilder < ::SearchBuilder
+  include Hyrax::My::SearchBuilderBehavior
   include Hyrax::FilterByType
 
-  def only_collections?
-    true
+  self.default_processor_chain += [:show_only_collections_deposited_by_current_user]
+
+  # adds a filter to the solr_parameters that filters the collections and admin sets
+  # the current user has deposited
+  # @param [Hash] solr_parameters
+  def show_only_collections_deposited_by_current_user(solr_parameters)
+    clauses = [
+      ActiveFedora::SolrQueryBuilder.construct_query_for_rel(depositor: current_user_key),
+      ActiveFedora::SolrQueryBuilder.construct_query_for_rel(has_model: ::AdminSet.to_s, creator: current_user_key)
+    ]
+    solr_parameters[:fq] ||= []
+    solr_parameters[:fq] += ["(#{clauses.join(' OR ')})"]
+  end
+
+  # This overrides the models in FilterByType
+  # @return [Array<Class>] a list of classes to include
+  def models
+    [::AdminSet, ::Collection]
   end
 end

data/app/search_builders/hyrax/nested_collections_parent_search_builder.rb

@@ -0,0 +1,27 @@
+module Hyrax
+  # Searches for all collections that are parents of a given collection.
+  class NestedCollectionsParentSearchBuilder < ::SearchBuilder
+    include Hyrax::FilterByType
+    attr_reader :child, :page, :limit
+
+    # @param [scope] Typically the controller object
+    # @param [child] The child collection
+    def initialize(scope:, child:, page:)
+      @child = child
+      @page = page
+      super(scope)
+    end
+
+    # Filters the query to only include the parent collections
+    def parent_collections_only(solr_parameters)
+      solr_parameters[:fq] ||= []
+      solr_parameters[:fq] << ActiveFedora::SolrQueryBuilder.construct_query_for_ids(child.member_of_collection_ids)
+    end
+    self.default_processor_chain += [:parent_collections_only]
+
+    def with_pagination(solr_parameters)
+      solr_parameters[:page] = page
+    end
+    self.default_processor_chain += [:with_pagination]
+  end
+end

data/app/search_builders/hyrax/search_filters.rb

@@ -4,6 +4,14 @@ module Hyrax
     include Hyrax::FilterByType
     include FilterSuppressed
 
+    # TODO: move this to Hydra::AccessControlsEnforcement
+    # @param access [String] what access level to set. Either 'read' or 'edit'
+    # @return [SearchBuilder]
+    def with_access(access)
+      @discovery_permissions = Array.wrap(access)
+      self
+    end
+
     # Override Hydra::AccessControlsEnforcement (or Hydra::PolicyAwareAccessControlsEnforcement)
     # Allows admin users to see everything (don't apply any gated_discovery_filters for those users)
     def gated_discovery_filters(permission_types = discovery_permissions, ability = current_ability)

data/app/services/hyrax/adapters/nesting_index_adapter.rb

@@ -0,0 +1,192 @@
+module Hyrax
+  module Adapters
+    module NestingIndexAdapter
+      # @!group Providing interface for a Samvera::NestingIndexer::Adapter
+
+      # @api public
+      # @param id [String]
+      # @return Samvera::NestingIndexer::Document::PreservationDocument
+      def self.find_preservation_document_by(id:)
+        # Not everything is guaranteed to have library_collection_ids
+        # If it doesn't have it, what do we do?
+        parent_ids = find_preservation_parent_ids_for(id: id)
+        Samvera::NestingIndexer::Documents::PreservationDocument.new(id: id, parent_ids: parent_ids)
+      end
+
+      # @api public
+      # @param id [String]
+      # @return Samvera::NestingIndexer::Document::PreservationDocument
+      def self.find_preservation_parent_ids_for(id:)
+        # Not everything is guaranteed to have library_collection_ids
+        # If it doesn't have it, what do we do?
+        fedora_object = ActiveFedora::Base.uncached do
+          fedora_object = ActiveFedora::Base.find(id)
+        end
+
+        if fedora_object.respond_to?(:member_of_collection_ids)
+          fedora_object.member_of_collection_ids
+        else
+          []
+        end
+      end
+
+      # @api public
+      # @param id [String]
+      # @return Samvera::NestingIndexer::Documents::IndexDocument
+      def self.find_index_document_by(id:)
+        solr_document = find_solr_document_by(id: id)
+        coerce_solr_document_to_index_document(original_solr_document: solr_document, id: id)
+      end
+
+      # @api public
+      # @deprecated
+      # @yield Samvera::NestingIndexer::Document::PreservationDocument
+      # rubocop:disable Lint/UnusedMethodArgument
+      def self.each_preservation_document(&block)
+        raise NotImplementedError
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      # @api public
+      # @yieldparam id [String]
+      # @yieldparam parent_id [Array<String>]
+      # Samvera::NestingIndexer.reindex_all!
+      # rubocop:disable Lint/UnusedMethodArgument
+      def self.each_perservation_document_id_and_parent_ids(&block)
+        ActiveFedora::Base.descendant_uris(ActiveFedora.fedora.base_uri, exclude_uri: true).each do |uri|
+          id = ActiveFedora::Base.uri_to_id(uri)
+          object = ActiveFedora::Base.find(id)
+          parent_ids = object.try(:member_of_collection_ids) || []
+
+          # note: we do not yield when the object has parents. Calling the nested indexer for the
+          # top id will reindex all descendants as well.
+          if object.try(:use_nested_reindexing?)
+            yield(id, parent_ids) if parent_ids.empty?
+          else
+            Rails.logger.info "Re-indexing via to_solr ... #{id}"
+            ActiveFedora::SolrService.add(object.to_solr, commit: true)
+          end
+        end
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      # @api public
+      # @deprecated
+      #
+      # From the given parameters, we will need to add them to the underlying SOLR document for the object
+      #
+      # @param id [String]
+      # @param parent_ids [Array<String>]
+      # @param ancestors [Array<String>]
+      # @param pathnames [Array<String>]
+      # @return Hash - the attributes written to the indexing layer
+      # rubocop:disable Lint/UnusedMethodArgument
+      def self.write_document_attributes_to_index_layer(id:, parent_ids:, ancestors:, pathnames:, deepest_nested_depth:)
+        raise NotImplementedError, "This method is deprecated as of v1.0.0 of samvera-nesting_indexer, prefer instead .write_nesting_document_to_index_layer"
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      # @api public
+      #
+      # From the nesting_document, we will need to add the nesting attributes to the underlying SOLR document for the object
+      #
+      # @param nesting_document [Samvera::NestingIndexer::Documents::IndexDocument]
+      # @return Hash - the attributes written to the indexing layer
+      def self.write_nesting_document_to_index_layer(nesting_document:)
+        solr_doc = ActiveFedora::Base.uncached do
+          ActiveFedora::Base.find(nesting_document.id).to_solr # What is the current state of the solr document
+        end
+
+        # Now add the details from the nesting indexer to the document
+        add_nesting_attributes(
+          solr_doc: solr_doc,
+          ancestors: nesting_document.ancestors,
+          parent_ids: nesting_document.parent_ids,
+          pathnames: nesting_document.pathnames,
+          depth: nesting_document.deepest_nested_depth
+        )
+      end
+
+      # @api public
+      #
+      # @param solr_doc [SolrDocument]
+      # @param ancestors [Array]
+      # @param parent_ids [Array]
+      # @param pathnames [Array]
+      # @param depth [Array] the object's deepest nesting depth
+      # @return solr_doc [SolrDocument]
+      def self.add_nesting_attributes(solr_doc:, ancestors:, parent_ids:, pathnames:, depth:)
+        solr_doc[solr_field_name_for_storing_ancestors] = ancestors
+        solr_doc[solr_field_name_for_storing_parent_ids] = parent_ids
+        solr_doc[solr_field_name_for_storing_pathnames] = pathnames
+        solr_doc[solr_field_name_for_deepest_nested_depth] = depth
+        ActiveFedora::SolrService.add(solr_doc, commit: true)
+        solr_doc
+      end
+
+      # @api public
+      # @param document [Samvera::NestingIndexer::Documents::IndexDocument]
+      # @param solr_field_name_for_ancestors [String] The SOLR field name we use to find children
+      # @yield Samvera::NestingIndexer::Documents::IndexDocument
+      def self.each_child_document_of(document:, &block)
+        raw_child_solr_documents_of(parent_document: document).each do |solr_document|
+          child_document = coerce_solr_document_to_index_document(original_solr_document: solr_document, id: solr_document.fetch('id'))
+          block.call(child_document)
+        end
+      end
+      # @!endgroup
+
+      # @!group Supporting methods for interface implementation
+
+      # @api private
+      # @todo Need to implement retrieving parent_ids, pathnames, and ancestors from the given document
+      def self.coerce_solr_document_to_index_document(original_solr_document:, id:)
+        Samvera::NestingIndexer::Documents::IndexDocument.new(
+          id: id,
+          parent_ids: original_solr_document.fetch(solr_field_name_for_storing_parent_ids) { [] },
+          pathnames: original_solr_document.fetch(solr_field_name_for_storing_pathnames) { [] },
+          ancestors: original_solr_document.fetch(solr_field_name_for_storing_ancestors) { [] }
+        )
+      end
+      private_class_method :coerce_solr_document_to_index_document
+
+      # @api private
+      def self.find_solr_document_by(id:)
+        query = ActiveFedora::SolrQueryBuilder.construct_query_for_ids([id])
+        document = ActiveFedora::SolrService.query(query, rows: 1).first
+        raise "Unable to find SolrDocument with ID=#{id}" if document.nil?
+        document
+      end
+      private_class_method :find_solr_document_by
+
+      # @api private
+      def self.nesting_configuration
+        @nesting_configuration ||= Samvera::NestingIndexer.configuration
+      end
+
+      class << self
+        delegate :solr_field_name_for_storing_pathnames, :solr_field_name_for_storing_ancestors, :solr_field_name_for_storing_parent_ids, to: :nesting_configuration
+      end
+
+      # <dynamicField name="*_isi" type="int" stored="true" indexed="true" multiValued="false"/>
+      SOLR_FIELD_NAME_FOR_DEEPEST_NESTED_DEPTH = 'nesting_collection__deepest_nested_depth_isi'.freeze
+
+      def self.solr_field_name_for_deepest_nested_depth
+        SOLR_FIELD_NAME_FOR_DEEPEST_NESTED_DEPTH
+      end
+
+      # @api private
+      # @param parent_document [Curate::Indexer::Documents::IndexDocument]
+      # @return [Hash] A raw response document from SOLR
+      # @todo What is the appropriate suffix to apply to the solr_field_name?
+      def self.raw_child_solr_documents_of(parent_document:)
+        # query Solr for all of the documents included as a member_of_collection parent.
+        child_query = ActiveFedora::SolrQueryBuilder.construct_query(member_of_collection_ids_ssim: parent_document.id)
+        ActiveFedora::SolrService.query(child_query)
+      end
+      private_class_method :raw_child_solr_documents_of
+
+      # @!endgroup
+    end
+  end
+end

data/app/services/hyrax/admin_set_create_service.rb

@@ -53,7 +53,6 @@ module Hyrax
     # Creates an admin set, setting the creator and the default access controls.
     # @return [TrueClass, FalseClass] true if it was successful
     def create
-      admin_set.edit_groups = [admin_group_name]
       admin_set.creator = [creating_user.user_key] if creating_user
       admin_set.save.tap do |result|
         if result
@@ -84,7 +83,9 @@ module Hyrax
       end
 
       def create_permission_template
-        PermissionTemplate.create!(admin_set_id: admin_set.id, access_grants_attributes: access_grants_attributes)
+        permission_template = PermissionTemplate.create!(source_id: admin_set.id, access_grants_attributes: access_grants_attributes)
+        admin_set.reset_access_controls!
+        permission_template
       end
 
       def create_workflows_for(permission_template:)

data/app/services/hyrax/admin_set_member_service.rb

@@ -0,0 +1,40 @@
+module Hyrax
+  # Responsible for retrieving admin set's members
+  class AdminSetMemberService
+    attr_reader :scope, :params, :collection
+    delegate :repository, to: :scope
+
+    # @param scope [#repository] Typically acontroller object which responds to :repository
+    # @param [Collection] an collection of type admin set
+    # @param [ActionController::Parameters] query params
+    def initialize(scope:, collection:, params:)
+      @scope = scope
+      @collection = collection
+      @params = params
+    end
+
+    # @api public
+    #
+    # All members of the given admin_set
+    # @return [Blacklight::Solr::Response]
+    def available_member_works
+      query_solr(query_builder: members_search_builder, query_params: params)
+    end
+
+    private
+
+      # @api public
+      #
+      # set up a member search builder admin set members
+      # @return [AdminAdminSetMemberSearchBuilder] new or existing
+      def members_search_builder
+        @members_search_builder ||= Hyrax::AdminAdminSetMemberSearchBuilder.new(scope: scope, collection: collection)
+      end
+
+      # @api private
+      #
+      def query_solr(query_builder:, query_params:)
+        repository.search(query_builder.with(query_params).query)
+      end
+  end
+end

data/app/services/hyrax/batch_create_failure_service.rb

@@ -1,12 +1,13 @@
 module Hyrax
   class BatchCreateFailureService < AbstractMessageService
-    attr_reader :user
-    def initialize(user)
+    attr_reader :user, :messages
+    def initialize(user, messages)
       @user = user
+      @messages = messages.to_sentence
     end
 
     def message
-      "The batch create for #{user} failed"
+      "The batch create for #{user} failed: #{messages}"
     end
 
     def subject

data/app/services/hyrax/collection_types/create_service.rb

@@ -0,0 +1,143 @@
+module Hyrax
+  module CollectionTypes
+    # @api public
+    #
+    # Responsible for creating a CollectionType. If no params are given,the default user collection is assumed as defined by:
+    #
+    # * Hyrax::CollectionType::USER_COLLECTION_MACHINE_ID
+    # * Hyrax::CollectionType::USER_COLLECTION_DEFAULT_TITLE
+    # * DEFAULT_OPTIONS
+    #
+    # @see Hyrax:CollectionType
+    #
+    class CreateService
+      DEFAULT_OPTIONS = {
+        description: '',
+        nestable: true,
+        discoverable: true,
+        sharable: true,
+        share_applies_to_new_works: true,
+        allow_multiple_membership: true,
+        require_membership: false,
+        assigns_workflow: false,
+        assigns_visibility: false,
+        participants: [{ agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE, agent_id: ::Ability.admin_group_name, access: Hyrax::CollectionTypeParticipant::MANAGE_ACCESS },
+                       { agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE, agent_id: ::Ability.registered_group_name, access: Hyrax::CollectionTypeParticipant::CREATE_ACCESS }]
+      }.freeze
+
+      USER_COLLECTION_MACHINE_ID = Hyrax::CollectionType::USER_COLLECTION_MACHINE_ID
+      USER_COLLECTION_TITLE = Hyrax::CollectionType::USER_COLLECTION_DEFAULT_TITLE
+      USER_COLLECTION_OPTIONS = {
+        description: I18n.t('hyrax.collection_types.create_service.default_description'),
+        nestable: true,
+        discoverable: true,
+        sharable: true,
+        share_applies_to_new_works: false,
+        allow_multiple_membership: true,
+        require_membership: false,
+        assigns_workflow: false,
+        assigns_visibility: false,
+        participants: [{ agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE, agent_id: ::Ability.admin_group_name, access: Hyrax::CollectionTypeParticipant::MANAGE_ACCESS },
+                       { agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE, agent_id: ::Ability.registered_group_name, access: Hyrax::CollectionTypeParticipant::CREATE_ACCESS }]
+      }.freeze
+
+      ADMIN_SET_MACHINE_ID = Hyrax::CollectionType::ADMIN_SET_MACHINE_ID
+      ADMIN_SET_TITLE = Hyrax::CollectionType::ADMIN_SET_DEFAULT_TITLE
+      ADMIN_SET_OPTIONS = {
+        description: I18n.t('hyrax.collection_types.create_service.admin_set_description'),
+        nestable: false,
+        discoverable: false,
+        sharable: true,
+        share_applies_to_new_works: true,
+        allow_multiple_membership: false,
+        require_membership: true,
+        assigns_workflow: true,
+        assigns_visibility: true,
+        participants: [{ agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE, agent_id: ::Ability.admin_group_name, access: Hyrax::CollectionTypeParticipant::MANAGE_ACCESS },
+                       { agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE, agent_id: ::Ability.admin_group_name, access: Hyrax::CollectionTypeParticipant::CREATE_ACCESS }]
+      }.freeze
+
+      # @api public
+      #
+      # Create a new collection type.
+      #
+      # @param machine_id [String]
+      # @param title [String] short tag identifying the collection type
+      # @param options [Hash] options to override DEFAULT_OPTIONS
+      # @option options [String] :description a description to show the user when selecting the collection type
+      # @option options [Boolean] :nestable if true, collections of this type can be nested
+      # @option options [Boolean] :discoverable if true, collections of this type can be marked Public and found in search results
+      # @option options [Boolean] :sharable if true, collections of this type can have participants added for :manage, :deposit, or :view access
+      # @option options [Boolean] :share_applies_to_new_works if true, share participant permissions are applied to new works created in the collection
+      # @option options [Boolean] :allow_multiple_membership if true, works can be members of multiple collections of this type
+      # @option options [Boolean] :require_membership if true, all works must belong to at least one collection of this type.  When combined
+      #   with allow_multiple_membership=false, works can belong to one and only one collection of this type.
+      # @option options [Boolean] :assigns_workflow if true, collections of this type can be used to assign a workflow to a work
+      # @option options [Boolean] :assigns_visibility if true, collections of this type can be used to assign initial visibility to a work
+      # @return [Hyrax::CollectionType] the newly created collection type instance
+      def self.create_collection_type(machine_id:, title:, options: {})
+        opts = DEFAULT_OPTIONS.merge(options).except(:participants)
+        ct = Hyrax::CollectionType.create!(opts.merge(machine_id: machine_id, title: title))
+        participants = options[:participants].presence || DEFAULT_OPTIONS[:participants]
+        add_participants(ct.id, participants)
+        ct
+      end
+
+      # @api public
+      #
+      # Create admin set collection type.
+      #
+      # @return [Hyrax::CollectionType] the newly created admin set collection type instance
+      def self.create_admin_set_type
+        create_collection_type(machine_id: ADMIN_SET_MACHINE_ID, title: ADMIN_SET_TITLE, options: ADMIN_SET_OPTIONS)
+      end
+
+      # @api public
+      #
+      # Create user collection type.
+      #
+      # @return [Hyrax::CollectionType] the newly created user collection type instance
+      def self.create_user_collection_type
+        create_collection_type(machine_id: USER_COLLECTION_MACHINE_ID, title: USER_COLLECTION_TITLE, options: USER_COLLECTION_OPTIONS)
+      end
+
+      # @api public
+      #
+      # Add the default participants to a collection_type.
+      #
+      # @param collection_type_id [Integer] the id of the collection type
+      # @note Several checks get the user's groups from the user's ability.  The same values can be retrieved directly from a passed in ability.
+      #   If calling from Abilities, pass the ability.  If you try to get the ability from the user, you end up in an infinit loop.
+      def self.add_default_participants(collection_type_id)
+        return unless collection_type_id
+        default_participants = [{  agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE,
+                                   agent_id: ::Ability.admin_group_name,
+                                   access: Hyrax::CollectionTypeParticipant::MANAGE_ACCESS },
+                                { agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE,
+                                  agent_id: ::Ability.registered_group_name,
+                                  access: Hyrax::CollectionTypeParticipant::CREATE_ACCESS }]
+        add_participants(collection_type_id, default_participants)
+      end
+
+      # @api public
+      #
+      # Add a participants to a collection_type.
+      #
+      # @param collection_type_id [Integer] the id of the collection type
+      # @param participants [Array<Hash>] each element holds agent_type, agent_id, and access for a participant to be added
+      def self.add_participants(collection_type_id, participants)
+        return unless collection_type_id && participants.count > 0
+        participants.each do |p|
+          begin
+            agent_type = p.fetch(:agent_type)
+            agent_id = p.fetch(:agent_id)
+            access = p.fetch(:access)
+            Hyrax::CollectionTypeParticipant.create!(hyrax_collection_type_id: collection_type_id, agent_type: agent_type, agent_id: agent_id, access: access)
+          rescue => e # rubocop:disable Lint/RescueWithoutErrorClass
+            Rails.logger.error "Participant not created for collection type #{collection_type_id}: #{agent_type}, #{agent_id}, #{access} -- reason: #{e.class.name} - #{e.message}\n"
+          end
+        end
+      end
+    end
+  end
+end