hyrax 3.0.2 → 3.1.0

data/app/services/hyrax/find_objects_via_solr_service.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 module Hyrax
+  # @deprecated This class is being replaced by Hyrax::SolrQueryService #get_objects method.
+  #
   # Methods in this class search solr to get the ids and then use the query service to find the objects.
   class FindObjectsViaSolrService
     class_attribute :solr_query_builder, :solr_service, :query_service
-    self.solr_query_builder = Hyrax::SolrQueryBuilderService
+    self.solr_query_builder = Hyrax::SolrQueryService
     self.solr_service = Hyrax::SolrService
     self.query_service = Hyrax.query_service
 
@@ -14,13 +16,15 @@ module Hyrax
       # @param join_with [String] the value we're joining the clauses with (default: ' OR ' for backward compatibility with ActiveFedora where)
       # @param type [String] The type of query to run. Either 'raw' or 'field' (default: 'field')
       # @param use_valkyrie [Boolean] if true, return Valkyrie resource(s); otherwise, return ActiveFedora object(s)
-      # @return [Array<ActiveFedora|Valkyrie::Resource>] objects matching the query
+      # @return [Array<ActiveFedora::Base|Valkyrie::Resource>] objects matching the query
       def find_for_model_by_field_pairs(model:, field_pairs:, join_with: ' OR ', type: 'field', use_valkyrie: Hyrax.config.use_valkyrie?)
-        return model.where(field_pairs).to_a unless use_valkyrie
-        query = solr_query_builder.construct_query_for_model(model, field_pairs, join_with, type)
-        results = solr_service.query(query)
-        ids = results.map(&:id)
-        query_service.find_many_by_ids(ids: ids).to_a
+        Deprecation.warn("'##{__method__}' will be removed in Hyrax 4.0.  " \
+                         "Instead, use 'Hyrax::SolrQueryService.new.with_model(...).with_field_pairs(...).get_objects'.")
+
+        solr_query_builder.new
+                          .with_model(model: model)
+                          .with_field_pairs(field_pairs: field_pairs, join_with: join_with, type: type)
+                          .get_objects(use_valkyrie: use_valkyrie).to_a
       end
     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,57 +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)
-      return [] if collection_ids.blank?
+    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 = {
-        :id => collection_ids,
-        Hyrax.config.collection_type_index_field.to_sym => collection_type_gids_that_disallow_multiple_membership
+        Hyrax.config.collection_type_index_field.to_sym => single_membership_collection_types_gids
       }
-      Hyrax::FindObjectsViaSolrService.find_for_model_by_field_pairs(model: ::Collection, field_pairs: field_pairs, use_valkyrie: true)
+      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
 
-    def collection_type_gids_that_disallow_multiple_membership
-      Hyrax::CollectionType.gids_that_do_not_allow_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 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)

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,16 +1,29 @@
 # 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])
@@ -21,14 +34,19 @@ module Hyrax
       # @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
 
@@ -41,9 +59,14 @@ module Hyrax
       # @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
-        construct_query(field_pairs, join_with, type)
+        Hyrax::SolrQueryService.new.with_field_pairs(field_pairs: field_pairs,
+                                                     join_with: join_with,
+                                                     type: type).build
       end
 
       private

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