hyrax 3.0.0 → 3.2.0

data/app/services/hyrax/listeners/metadata_index_listener.rb

@@ -15,10 +15,17 @@ module Hyrax
       # Re-index the resource.
       #
       # @param event [Dry::Event]
-      def on_object_metadata_updated(event)
-        log_non_resource(event) && return unless
-          event[:object].is_a?(Valkyrie::Resource)
+      def on_collection_metadata_updated(event)
+        return unless resource? event[:collection]
+        Hyrax.index_adapter.save(resource: event[:collection])
+      end
 
+      ##
+      # Re-index the resource.
+      #
+      # @param event [Dry::Event]
+      def on_object_metadata_updated(event)
+        return unless resource? event[:object]
         Hyrax.index_adapter.save(resource: event[:object])
       end
 
@@ -27,17 +34,26 @@ module Hyrax
       #
       # @param event [Dry::Event]
       def on_object_deleted(event)
-        log_non_resource(event.payload) && return unless
-          event.payload[:object].is_a?(Valkyrie::Resource)
-
+        return unless resource?(event.payload[:object])
         Hyrax.index_adapter.delete(resource: event[:object])
       end
 
       private
 
-      def log_non_resource(event)
-        Hyrax.logger.info('Skipping object reindex because the object ' \
-                          "#{event[:object]} was not a Valkyrie::Resource.")
+      def resource?(resource)
+        return true if resource.is_a? Valkyrie::Resource
+        log_non_resource(resource)
+        false
+      end
+
+      def log_non_resource(resource)
+        generic_type = resource_generic_type(resource)
+        Hyrax.logger.info("Skipping #{generic_type} reindex because the " \
+                          "#{generic_type} #{resource} was not a Valkyrie::Resource.")
+      end
+
+      def resource_generic_type(resource)
+        resource.try(:collection?) ? 'collection' : 'object'
       end
     end
   end

data/app/services/hyrax/listeners/object_lifecycle_listener.rb

@@ -8,7 +8,7 @@ module Hyrax
       ##
       # @param event [Dry::Event]
       def on_object_deleted(event)
-        ContentDeleteEventJob.perform_later(event[:id], event[:user])
+        ContentDeleteEventJob.perform_later(event[:id].to_s, event[:user])
       end
 
       ##

data/app/services/hyrax/listeners/trophy_cleanup_listener.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module Listeners
+    ##
+    # Listens for object deleted events and cleans up associated members
+    class TrophyCleanupListener
+      def on_object_deleted(event)
+        Trophy.where(work_id: event[:id]).destroy_all
+      rescue StandardError => err
+        Hyrax.logger.warn "Failed to delete trophies for #{event[:id]}. " \
+                          'These trophies might be orphaned.' \
+                          "\n\t#{err.message}"
+      end
+    end
+  end
+end

data/app/services/hyrax/listeners.rb

@@ -14,9 +14,11 @@ module Hyrax
     autoload :BatchNotificationListener
     autoload :FileSetLifecycleListener
     autoload :FileSetLifecycleNotificationListener
+    autoload :MemberCleanupListener
     autoload :MetadataIndexListener
     autoload :ObjectLifecycleListener
     autoload :ProxyDepositListener
+    autoload :TrophyCleanupListener
     autoload :WorkflowListener
   end
 end

data/app/services/hyrax/multiple_membership_checker.rb

@@ -6,8 +6,7 @@ module Hyrax
   class MultipleMembershipChecker
     attr_reader :item
 
-    # @param [#member_of_collection_ids] item an object that belongs to
-    #   collections
+    # @param [#member_of_collection_ids] item an object that belongs to collections
     def initialize(item:)
       @item = item
     end
@@ -20,53 +19,78 @@ module Hyrax
     # `allow_multiple_membership` as `false` require that its members do not
     # also belong to other collections of the same type.
     #
-    # There are two contexts in which memberships are checked: when doing a
-    # wholesale replacement and when making an incremental change, such as
-    # adding a single collection membership to an object. In the former case,
-    # `#check` only scans the passed-in collection identifiers. In the latter,
-    # `#check` must also scan the collections to which an object currently
-    # belongs for potential conflicts.
-    #
     # @param collection_ids [Array<String>] a list of collection identifiers
-    # @param include_current_members [Boolean] a flag to also scan an object's
-    #   current collection memberships
+    # @param include_current_members [Boolean] if true, include item's existing
+    #   collections in check; else if false, check passed in collections only
+    #   * use `false` when collection_ids includes proposed new collections and existing
+    #     collections (@see Hyrax::Actors::CollectionsMembershipActor #valid_membership?)
+    #   * use `true` when collection_ids includes proposed new collections only
+    #     (@see Hyrax::Collections::CollectionMemberService #add_member)
     #
     # @return [nil, String] nil if no conflicts; an error message string if so
     def check(collection_ids:, include_current_members: false)
-      # short-circuit if no single membership types have been created
-      return if collection_type_gids_that_disallow_multiple_membership.blank?
-      # short-circuit if no new single_membership_collections passed in
-      new_single_membership_collections = single_membership_collections(collection_ids)
-      return if new_single_membership_collections.blank?
-      collections_to_check = new_single_membership_collections
-      # No need to check current members when coming in from the ActorStack, which does a wholesale collection membership replacement
-      collections_to_check |= single_membership_collections(item.member_of_collection_ids) if include_current_members
-      problematic_collections = collections_to_check.uniq(&:id)
-                                                    .group_by(&:collection_type_gid)
-                                                    .select { |_gid, list| list.count > 1 }
-      return if problematic_collections.blank?
+      return unless single_membership_collection_types_exist?
+
+      proposed_single_membership_collections = filter_to_single_membership_collections(collection_ids)
+      return if proposed_single_membership_collections.blank?
+
+      collections_to_check = collections_to_check(proposed_single_membership_collections,
+                                                  include_current_members)
+      problematic_collections = check_collections(collections_to_check)
       build_error_message(problematic_collections)
     end
 
     private
 
-    def single_membership_collections(collection_ids)
+    def single_membership_collection_types_exist?
+      single_membership_collection_types_gids.present?
+    end
+
+    def single_membership_collection_types_gids
+      @single_membership_collection_types_gids ||=
+        Hyrax::CollectionType.gids_that_do_not_allow_multiple_membership&.map(&:to_s)
+    end
+
+    def filter_to_single_membership_collections(collection_ids)
       return [] if collection_ids.blank?
+      field_pairs = {
+        Hyrax.config.collection_type_index_field.to_sym => single_membership_collection_types_gids
+      }
+      Hyrax::SolrQueryService.new
+                             .with_generic_type(generic_type: "Collection")
+                             .with_ids(ids: Array[collection_ids])
+                             .with_field_pairs(field_pairs: field_pairs, join_with: ' OR ')
+                             .get_objects(use_valkyrie: true).to_a
+    end
 
-      ::Collection.where(:id => collection_ids, Hyrax.config.collection_type_index_field.to_sym => collection_type_gids_that_disallow_multiple_membership)
+    def collections_to_check(proposed, include_current_members)
+      # ActorStack does a wholesale collection membership replacement, such that
+      # proposed collections include existing and new collections.  Parameter
+      # `include_current_members` will be false when coming from the actor stack
+      # to prevent member items being passed in and then added here as well.
+      return proposed unless include_current_members
+      proposed | filter_to_single_membership_collections(item.member_of_collection_ids)
     end
 
-    def collection_type_gids_that_disallow_multiple_membership
-      Hyrax::CollectionType.gids_that_do_not_allow_multiple_membership
+    def check_collections(collections_to_check)
+      # uniq insures we include a collection only once when it is in the list multiple
+      # group_by groups collections of the same collection type together
+      # select keeps only collection type groups that have more than one collection
+      #   of the single collection type
+      collections_to_check.uniq(&:id)
+                          .group_by(&:collection_type_gid)
+                          .select { |_gid, list| list.count > 1 }
     end
 
     def build_error_message(problematic_collections)
+      return if problematic_collections.blank?
       error_message_clauses = problematic_collections.map do |gid, list|
         I18n.t('hyrax.admin.collection_types.multiple_membership_checker.error_type_and_collections',
                type: collection_type_title_from_gid(gid),
                collections: collection_titles_from_list(list))
       end
-      "#{I18n.t('hyrax.admin.collection_types.multiple_membership_checker.error_preamble')}#{error_message_clauses.join('; ')}"
+      "#{I18n.t('hyrax.admin.collection_types.multiple_membership_checker.error_preamble')}" \
+        "#{error_message_clauses.join('; ')}"
     end
 
     def collection_type_title_from_gid(gid)
@@ -74,7 +98,7 @@ module Hyrax
     end
 
     def collection_titles_from_list(collection_list)
-      collection_list.each do |collection|
+      collection_list.map do |collection|
         collection.title.first
       end.to_sentence
     end

data/app/services/hyrax/permission_manager.rb

@@ -143,7 +143,7 @@ module Hyrax
     def groups_for(mode:)
       Enumerator.new do |yielder|
         acl.permissions.each do |permission|
-          next unless permission.mode == mode
+          next unless permission.mode.to_sym == mode
           next unless permission.agent.starts_with?(Hyrax::Group.name_prefix)
           yielder << permission.agent.gsub(Hyrax::Group.name_prefix, '')
         end
@@ -154,7 +154,7 @@ module Hyrax
       groups = groups.map(&:to_s)
 
       acl.permissions.each do |permission|
-        next unless permission.mode == mode
+        next unless permission.mode.to_sym == mode
         next unless permission.agent.starts_with?(Hyrax::Group.name_prefix)
 
         group_name = permission.agent.gsub(Hyrax::Group.name_prefix, '')
@@ -175,7 +175,7 @@ module Hyrax
       end
 
       acl.permissions.each do |permission|
-        next unless permission.mode == mode
+        next unless permission.mode.to_sym == mode
         next if permission.agent.starts_with?(Hyrax::Group.name_prefix)
         next if users.include? permission.agent
 
@@ -189,7 +189,7 @@ module Hyrax
     def users_for(mode:)
       Enumerator.new do |yielder|
         acl.permissions.each do |permission|
-          next unless permission.mode == mode
+          next unless permission.mode.to_sym == mode
           next if permission.agent.starts_with?(Hyrax::Group.name_prefix)
           yielder << permission.agent
         end

data/app/services/hyrax/persist_derivatives.rb

@@ -18,7 +18,6 @@ module Hyrax
     # Open the output file to write and yield the block to the
     # file. It makes the directories in the path if necessary.
     def self.output_file(directives, &blk)
-      # name = derivative_path_factory.derivative_path_for_reference(object, destination_name)
       raise ArgumentError, "No :url was provided in the transcoding directives" unless directives.key?(:url)
       uri = URI(directives.fetch(:url))
       raise ArgumentError, "Must provide a file uri" unless uri.scheme == 'file'
@@ -27,7 +26,10 @@ module Hyrax
       File.open(uri.path, 'wb', &blk)
     end
 
+    ##
+    # @deprecated
     def self.derivative_path_factory
+      Deprecation.warn("Use 'Hyrax::DerivativePath' instead.")
       DerivativePath
     end
   end

data/app/services/hyrax/resource_status.rb

@@ -36,6 +36,13 @@ module Hyrax
       self.resource = resource
     end
 
+    ##
+    # @param [#state] resource
+    # @return [Boolean]
+    def self.inactive?(resource:)
+      new(resource: resource).inactive?
+    end
+
     ##
     # @return [Boolean]
     # @raise [NoMethodError] if the resource doesn't have a state attribute

data/app/services/hyrax/search_service.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
-# SearchService returns search results from the repository
 module Hyrax
-  # Copied from Blacklight 7
+  ##
+  # Returns search results from the repository.
+  #
+  # @note Adapted from Blacklight 7
   class SearchService
     def initialize(config:, user_params: nil, search_builder_class: config.search_builder_class, **context)
       @blacklight_config = config

data/app/services/hyrax/solr_query_builder_service.rb

@@ -1,37 +1,74 @@
 # frozen_string_literal: true
 module Hyrax
+  ##
+  # @deprecated
+  # This class is being replaced by Hyrax::SolrQueryService.
+  #
   # Methods in this class are from/based on ActiveFedora::SolrQueryBuilder
+  #
+  # @see Hyrax::SolrQueryService
   class SolrQueryBuilderService
     class << self
       # Construct a solr query for a list of ids
       # This is used to get a solr response based on the list of ids in an object's RELS-EXT relationhsips
       # If the id_array is empty, defaults to a query of "id:NEVER_USE_THIS_ID", which will return an empty solr response
       # @param [Array] id_array the ids that you want included in the query
+      # @return [String] a solr query
+      # @example
+      #   construct_query_for_ids(['a1', 'b2'])
+      #   # => "{!terms f=id}a1,b2"
+      # @deprecated
       def construct_query_for_ids(id_array)
+        Deprecation.warn("'##{__method__}' will be removed in Hyrax 4.0.  " \
+                         "Instead, use 'Hyrax::SolrQueryService.new.with_ids'.")
         ids = id_array.reject(&:blank?)
         return "id:NEVER_USE_THIS_ID" if ids.empty?
-        "{!terms f=#{Hyrax.config.id_field}}#{ids.join(',')}"
+        Hyrax::SolrQueryService.new.with_ids(ids: id_array).build
       end
 
       # Construct a solr query from a list of pairs (e.g. [field name, values])
-      # @param [Array<Array>] field_pairs a list of pairs of property name and values
-      # @param [String] join_with ('AND') the value we're joining the clauses with
-      # @param [String] type ('field') The type of query to run. Either 'raw' or 'field'
+      # @param [Hash] field_pairs a list of pairs of property name and values
+      # @param [String] join_with the value we're joining the clauses with (default: ' AND ')
+      # @param [String] type of query to run. Either 'raw' or 'field' (default: 'field')
       # @return [String] a solr query
       # @example
       #   construct_query([['library_id_ssim', '123'], ['owner_ssim', 'Fred']])
       #   # => "_query_:\"{!field f=library_id_ssim}123\" AND _query_:\"{!field f=owner_ssim}Fred\""
+      # @deprecated
       def construct_query(field_pairs, join_with = default_join_with, type = 'field')
-        clauses = pairs_to_clauses(field_pairs, type)
-        return "" if clauses.count.zero?
-        return clauses.first if clauses.count == 1
-        "(#{clauses.join(join_with)})"
+        Deprecation.warn("'##{__method__}' will be removed in Hyrax 4.0.  " \
+                         "Instead, use 'Hyrax::SolrQueryService.new.with_field_pairs'.")
+        Hyrax::SolrQueryService.new.with_field_pairs(field_pairs: field_pairs,
+                                                     join_with: join_with,
+                                                     type: type).build
       end
 
+      # @deprecated
       def default_join_with
+        Deprecation.warn("'##{__method__}' will be removed in Hyrax 4.0.  " \
+                         "There will not be a replacement for this method. See Hyrax::SolrQueryService which is replacing this class.")
         ' AND '
       end
 
+      # Construct a solr query from a list of pairs (e.g. [field name, values]) including the model (e.g. Collection, Monograph)
+      # @param [Class] model class
+      # @param [Hash] field_pairs a list of pairs of property name and values
+      # @param [String] join_with the value we're joining the clauses with (default: ' AND ')
+      # @param [String] type of query to run. Either 'raw' or 'field' (default: 'field')
+      # @return [String] a solr query
+      # @example
+      #   construct_query(Collection, [['library_id_ssim', '123'], ['owner_ssim', 'Fred']])
+      #   # => "_query_:\"{!field f=has_model_ssim}Collection\" AND _query_:\"{!field f=library_id_ssim}123\" AND _query_:\"{!field f=owner_ssim}Fred\""
+      # @deprecated
+      def construct_query_for_model(model, field_pairs, join_with = default_join_with, type = 'field')
+        Deprecation.warn("'##{__method__}' will be removed in Hyrax 4.0.  " \
+                         "Instead, use 'Hyrax::SolrQueryService.new.with_model'.")
+        field_pairs["has_model_ssim"] = model.to_s
+        Hyrax::SolrQueryService.new.with_field_pairs(field_pairs: field_pairs,
+                                                     join_with: join_with,
+                                                     type: type).build
+      end
+
       private
 
       # @param [Array<Array>] pairs a list of (key, value) pairs. The value itself may

data/app/services/hyrax/solr_query_service.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+module Hyrax
+  ##
+  # Supports building and executing a solr query.
+  #
+  # @note Methods in this class are providing functionality previously supported by
+  #   ActiveFedora::SolrQueryBuilder.
+  class SolrQueryService < ::SearchBuilder # rubocop:disable Metrics/ClassLength
+    class_attribute :query_service
+    self.query_service = Hyrax.query_service
+
+    attr_reader :query, :solr_service
+
+    def initialize(query: [], solr_service: Hyrax::SolrService)
+      @query = query
+      @solr_service = solr_service
+    end
+
+    ##
+    # @api private
+    # @see Blacklight::Configuration#document_model
+    #
+    # @return [Class] the model class to use for solr documents
+    def self.document_model
+      CatalogController.blacklight_config.document_model
+    end
+
+    ##
+    # @return [Hash] the results returned from solr for the current query
+    def get
+      solr_service.get(build)
+    end
+
+    ##
+    # @return [Enumerable<SolrDocument>]
+    def solr_documents
+      get['response']['docs'].map { |doc| self.class.document_model.new(doc) }
+    end
+
+    ##
+    # @return [Array<String>] ids of documents matching the current query
+    def get_ids # rubocop:disable Naming/AccessorMethodName
+      results = get
+      results['response']['docs'].map { |doc| doc['id'] }
+    end
+
+    ##
+    # @return [Array<Valkyrie::Resource|ActiveFedora::Base>] objects matching the current query
+    def get_objects(use_valkyrie: Hyrax.config.use_valkyrie?)
+      ids = get_ids
+      return ids.map { |id| ActiveFedora::Base.find(id) } unless use_valkyrie
+      query_service.find_many_by_ids(ids: ids)
+    end
+
+    ##
+    # @return [Integer] the number of results that match the query in solr
+    def count
+      solr_service.count(build)
+    end
+
+    ##
+    # @return [String] the combined query that can be submitted to solr
+    def build
+      return 'id:NEVER_USE_THIS_ID' if @query.blank? # forces this method to always return a valid solr query
+      @query.join(' AND ')
+    end
+
+    ##
+    # @return [Hyrax::SolrQueryService] the existing service with the query reset to empty
+    def reset
+      @query = []
+      self
+    end
+
+    ##
+    # @param ids [Array] id_array the ids that you want included in the query
+    # @return [Hyrax::SolrQueryService] the existing service with id query appended
+    def with_ids(ids: [])
+      ids = ids.reject(&:blank?)
+      raise ArgumentError, "Expected there to be at least one non-blank id." if ids.blank?
+      id_query = construct_query_for_ids(ids)
+      @query += [id_query]
+      self
+    end
+
+    ##
+    # @param model [#to_s] a class from the model (e.g. Hyrax::Work, Hyrax::FileSet, etc.)
+    # @return [SolrQueryService] the existing service with model query appended
+    def with_model(model:)
+      model_query = construct_query_for_model(model)
+      @query += [model_query]
+      self
+    end
+
+    ##
+    # @param generic_type [String] (Default: Work)
+    # @return [SolrQueryService] the existing service with model query appended
+    def with_generic_type(generic_type: 'Work')
+      # TODO: Generic type was originally stored as `sim`.  Since it is never multi-valued, it is moving to being stored
+      #       as `si`.  Until a migration is created to correct existing solr docs, this query searches in both fields.
+      field_pairs = { generic_type_si: generic_type, generic_type_sim: generic_type }
+      type_query = construct_query_for_pairs(field_pairs, ' OR ', 'field')
+      @query += [type_query]
+      self
+    end
+
+    ##
+    # @param field_pairs [Hash] a list of pairs of property name and values (e.g. { field1: values, field2: values })
+    # @param join_with [String] the connector used to join the field pairs (default: ' AND ')
+    # @param type [String] type of query to run. Either 'raw' or 'field' (default: 'field')
+    # @return [SolrQueryService] the existing service with field_pair query appended
+    def with_field_pairs(field_pairs: {}, join_with: default_join_with, type: 'field')
+      pairs_query = construct_query_for_pairs(field_pairs, join_with, type)
+      return self if pairs_query.blank?
+      @query += [pairs_query]
+      self
+    end
+
+    ##
+    # @param ability [???] the user's abilities
+    # @param action [Symbol] the action the user is taking (e.g. :index, :edit, :show, etc.) (default: :index)
+    # @return [SolrQueryService] the existing service with access filters query appended
+    def accessible_by(ability:, action: :index)
+      access_filters_query = construct_query_for_ability(ability, action)
+      @query += [access_filters_query] if access_filters_query.present?
+      self
+    end
+
+    private
+
+    # Construct a solr query for a list of ids
+    # @param [Array] ids to be included in the query
+    # @return [String] a solr query
+    # @example
+    #   construct_query_for_ids(['id1', 'id2'])
+    #   # => "{!terms f=id}id1,id2"
+    def construct_query_for_ids(ids)
+      "{!terms f=#{Hyrax.config.id_field}}#{ids.join(',')}"
+    end
+
+    # Construct a solr query from a list of pairs (e.g. { field1: values, field2: values })
+    # @param [Hash] field_pairs a list of pairs of property name and values
+    # @param [String] join_with the value we're joining the clauses with (default: ' AND ')
+    # @param [String] type of query to run. Either 'raw' or 'field' (default: 'field')
+    # @return [String] a solr query
+    # @example
+    #   construct_query([['library_id_ssim', '123'], ['owner_ssim', 'Fred']])
+    #   # => "_query_:\"{!field f=library_id_ssim}123\" AND _query_:\"{!field f=owner_ssim}Fred\""
+    def construct_query_for_pairs(field_pairs, join_with = default_join_with, type = 'field')
+      clauses = pairs_to_clauses(field_pairs, type)
+      return "" if clauses.count.zero?
+      return clauses.first if clauses.count == 1
+      "(#{clauses.join(join_with)})"
+    end
+
+    # Construct a solr query from the model (e.g. Collection, Monograph)
+    # @param [Class] model class
+    # @return [String] a solr query
+    # @example
+    #   construct_query_for_model(Monograph)
+    #   # => "_query_:\"{!field f=has_model_ssim}Monograph\""
+    def construct_query_for_model(model)
+      field_pairs = { "has_model_ssim" => model.to_s }
+      construct_query_for_pairs(field_pairs)
+    end
+
+    # Construct a solr query based on a User's abilities and the action they taking
+    # @param ability [???] the user's abilities
+    # @param action [Symbol] the action the user is taking (e.g. :index, :edit, :show, etc.) (default: :index)
+    # @return [String] a solr query
+    # @example
+    #   construct_query_for_ability(user, :edit)
+    #   # => "(({!terms f=edit_access_group_ssim}public,user_group_A}) OR " \
+    #           "edit_access_person_ssim:#{user@example.com})"
+    def construct_query_for_ability(ability, action)
+      permission_types = case action
+                         when :index then [:discover, :read, :edit]
+                         when :show, :read then [:read, :edit]
+                         when :update, :edit, :create, :new, :destroy then [:edit]
+                         end
+      filters = gated_discovery_filters(permission_types, ability).join(' OR ')
+      return "" if filters.blank?
+      "(#{filters})"
+    end
+
+    def default_join_with
+      ' AND '
+    end
+
+    # @param [Array<Array>] pairs a list of (key, value) pairs. The value itself may
+    # @param [String] type  The type of query to run. Either 'raw' or 'field'
+    # @return [Hash] a list of solr clauses
+    def pairs_to_clauses(pairs, type)
+      pairs.flat_map do |field, value|
+        condition_to_clauses(field, value, type)
+      end
+    end
+
+    # @param [String] field
+    # @param [String, Array<String>] values
+    # @param [String] type The type of query to run. Either 'raw' or 'field'
+    # @return [Array<String>]
+    def condition_to_clauses(field, values, type)
+      values = Array(values)
+      values << nil if values.empty?
+      values.map do |value|
+        if value.present?
+          query_clause(type, field, value)
+        else
+          # Check that the field is not present. In SQL: "WHERE field IS NULL"
+          "-#{field}:[* TO *]"
+        end
+      end
+    end
+
+    # Create a raw query clause suitable for sending to solr as an fq element
+    # @param [String] type The type of query to run. Either 'raw' or 'field'
+    # @param [String] key
+    # @param [String] value
+    def query_clause(type, key, value)
+      "_query_:\"{!#{type} f=#{key}}#{value.gsub('"', '\"')}\""
+    end
+  end
+end

data/app/services/hyrax/solr_service.rb

@@ -37,7 +37,8 @@ module Hyrax
                                    'Use `Hyrax.config.solr_select_path` instead'
       end
 
-      delegate :add, :commit, :count, :delete, :get, :instance, :ping, :post, :query, :delete_by_query, :search_by_id, to: :new
+      delegate :add, :commit, :count, :delete, :get, :instance, :ping, :post,
+               :query, :delete_by_query, :search_by_id, :wipe!, to: :new
     end
 
     # Wraps rsolr get
@@ -100,6 +101,12 @@ module Hyrax
       connection.delete_by_id(id, params: COMMIT_PARAMS)
     end
 
+    # Deletes all solr documents
+    def wipe!
+      delete_by_query("*:*")
+      commit
+    end
+
     # Wraps rsolr add
     # @return [Hash] the hash straight form rsolr
     def add(solr_doc, commit: true)
@@ -133,7 +140,7 @@ module Hyrax
     # valkyrie indexers used here would, at minimum, need to provide a
     # functioning `rsolr` connection.
     def valkyrie_index
-      Valkyrie::IndexingAdapter.find(:solr_index)
+      Hyrax.index_adapter
     end
 
     ##

data/app/services/hyrax/statistics/collections/over_time.rb

@@ -6,7 +6,8 @@ module Hyrax
         private
 
         def relation
-          ::Collection
+          AbstractTypeRelation
+            .new(allowable_types: [Hyrax.config.collection_class])
         end
       end
     end

data/app/services/hyrax/statistics/depositors/summary.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
-# Gather information about the depositors who have contributed to the repository
 module Hyrax
   module Statistics
     module Depositors
+      ##
+      # Gather information about the depositors who have contributed to the repository
       class Summary
         include Blacklight::SearchHelper