hyrax 3.0.1 → 3.0.2

data/app/presenters/hyrax/admin_set_options_presenter.rb

@@ -4,8 +4,9 @@ module Hyrax
   class AdminSetOptionsPresenter
     ##
     # @param [Hyrax::AdminSetService] service
-    def initialize(service)
+    def initialize(service, current_ability: service.context.current_ability)
       @service = service
+      @current_ability = current_ability
     end
 
     # Return AdminSet selectbox options based on access type
@@ -49,6 +50,17 @@ module Hyrax
 
     # Does the workflow for the currently selected permission template allow sharing?
     def sharing?(permission_template:)
+      # This short-circuit builds on a stated "promise" in the UI of
+      # editing an admin set:
+      #
+      # > Managers of this administrative set can edit the set
+      # > metadata, participants, and release and visibility
+      # > settings. Managers can also edit work metadata, add to or
+      # > remove files from a work, and add new works to the set.
+      return true if @current_ability.can?(:manage, permission_template)
+
+      # Otherwise, we check if the workflow was setup, active, and
+      # allows_access_grants.
       wf = workflow(permission_template: permission_template)
       return false unless wf
       wf.allows_access_grant?

data/app/presenters/hyrax/pcdm_member_presenter_factory.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+module Hyrax
+  ##
+  # constructs presenters for the pcdm:members of an Object, omitting those
+  # not readable by a provided +Ability+.
+  #
+  # this implementation builds the presenters without recourse to the request
+  # context and ActiveFedora-specific index structures (i.e. no `list_source`
+  # or `proxy_in_ssi`).
+  #
+  # @see MemberPresenterFactory
+  class PcdmMemberPresenterFactory
+    class_attribute :file_presenter_class, :work_presenter_class
+    self.file_presenter_class = FileSetPresenter
+    self.work_presenter_class = WorkShowPresenter
+
+    attr_reader :ability, :object
+
+    ##
+    # @param [#member_ids] object
+    # @param [::Ability] ability
+    def initialize(object, ability)
+      @object = object
+      @ability = ability
+    end
+
+    ##
+    # @return [Array<FileSetPresenter, WorkShowPresenter>]
+    # @return [Enumerator<FileSetPresenter>]
+    def file_set_presenters
+      return enum_for(:file_set_presenters) unless block_given?
+
+      results = query_docs(generic_type: "FileSet")
+
+      object.member_ids.each do |id|
+        id = id.to_s
+        indx = results.index { |doc| id == doc['id'] }
+        next if indx.nil?
+        hash = results.delete_at(indx)
+        yield presenter_for(document: ::SolrDocument.new(hash), ability: ability)
+      end
+    end
+
+    ##
+    # @note defaults to using `object.member_ids`. passing a specific set of
+    #   ids is supported for compatibility with {MemberPresenterFactory}, but
+    #   we recommend making sparing use of this feature.
+    #
+    # @overload member_presenters
+    #   @return [Enumerator<FileSetPresenter, WorkShowPresenter>]
+    #   @raise [ArgumentError] if an unindexed id is passed
+    # @overload member_presenters
+    #   @param [Array<#to_s>] ids
+    #   @return [Enumerator<FileSetPresenter, WorkShowPresenter>]
+    #   @raise [ArgumentError] if an unindexed id is passed
+    def member_presenters(ids = object.member_ids)
+      return enum_for(:member_presenters, ids) unless block_given?
+
+      results = query_docs(ids: ids)
+
+      ids.each do |id|
+        id = id.to_s
+        indx = results.index { |doc| id == doc['id'] }
+        raise(ArgumentError, "Could not find an indexed document for id: #{id}") if
+          indx.nil?
+        hash = results.delete_at(indx)
+        yield presenter_for(document: ::SolrDocument.new(hash), ability: ability)
+      end
+    end
+
+    ##
+    # @return [Array<#to_s>]
+    def ordered_ids
+      object.member_ids
+    end
+
+    ##
+    # @return [Array<WorkShowPresenter>]
+    def work_presenters
+      return enum_for(:work_presenters) unless block_given?
+
+      results = query_docs(generic_type: "Work")
+
+      object.member_ids.each do |id|
+        id = id.to_s
+        indx = results.index { |doc| id == doc['id'] }
+        next if indx.nil?
+        hash = results.delete_at(indx)
+        yield presenter_for(document: ::SolrDocument.new(hash), ability: ability)
+      end
+    end
+
+    ##
+    # @param [::SolrDocument] document
+    # @param [::Ability] ability
+    #
+    # @return
+    def presenter_for(document:, ability:)
+      case document['has_model_ssim'].first
+      when Hyrax::FileSet.name
+        Hyrax::FileSetPresenter.new(document, ability)
+      else
+        Hyrax::WorkShowPresenter.new(document, ability)
+      end
+    end
+
+    private
+
+    def query_docs(generic_type: nil, ids: object.member_ids)
+      query = "{!terms f=id}#{ids.join(',')}"
+      query += "{!term f=generic_type_si}#{generic_type}" if generic_type
+
+      Hyrax::SolrService
+        .post(query, rows: 10_000)
+        .fetch('response')
+        .fetch('docs')
+    end
+  end
+end

data/app/presenters/hyrax/work_show_presenter.rb

@@ -94,7 +94,7 @@ module Hyrax
       return nil if representative_id.blank?
       @representative_presenter ||=
         begin
-          result = member_presenters_for([representative_id]).first
+          result = member_presenters([representative_id]).first
           return nil if result.try(:id) == id
           result.try(:representative_presenter) || result
         end
@@ -181,9 +181,13 @@ module Hyrax
       paginated_item_list(page_array: authorized_item_ids)
     end
 
+    ##
+    # @deprecated use `#member_presenters(ids)` instead
+    #
     # @param [Array<String>] ids a list of ids to build presenters for
     # @return [Array<presenter_class>] presenters for the array of ids (not filtered by class)
     def member_presenters_for(an_array_of_ids)
+      Deprecation.warn("Use `#member_presenters` instead.")
       member_presenters(an_array_of_ids)
     end
 

data/app/search_builders/hyrax/collection_member_search_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Hyrax
   # This search builder requires that a accessor named "collection" exists in the scope
-  class CollectionMemberSearchBuilder < ::SearchBuilder
+  class CollectionMemberSearchBuilder < ::Hyrax::CollectionSearchBuilder
     include Hyrax::FilterByType
     attr_writer :collection, :search_includes_models
 
@@ -41,6 +41,11 @@ module Hyrax
       solr_parameters[:fq] << "#{collection_membership_field}:#{collection.id}"
     end
 
+    # This overrides the models in FilterByType
+    def models
+      work_classes + collection_classes
+    end
+
     private
 
     def only_works?

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 # Added to allow for the My controller to show only things I have edit access to
-class Hyrax::My::CollectionsSearchBuilder < ::SearchBuilder
+class Hyrax::My::CollectionsSearchBuilder < ::Hyrax::CollectionSearchBuilder
   include Hyrax::My::SearchBuilderBehavior
   include Hyrax::FilterByType
 

data/app/search_builders/hyrax/nested_collections_parent_search_builder.rb

@@ -2,7 +2,7 @@
 module Hyrax
   ##
   # Searches for all collections that are parents of a given collection.
-  class NestedCollectionsParentSearchBuilder < ::SearchBuilder
+  class NestedCollectionsParentSearchBuilder < ::Hyrax::CollectionSearchBuilder
     include Hyrax::FilterByType
     attr_reader :child, :page, :limit
 

data/app/search_builders/hyrax/single_collection_search_builder.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Hyrax
-  class SingleCollectionSearchBuilder < ::SearchBuilder
+  class SingleCollectionSearchBuilder < ::Hyrax::CollectionSearchBuilder
     include SingleResult
   end
 end

data/app/services/hyrax/contextual_path.rb

@@ -11,7 +11,7 @@ module Hyrax
 
     def show
       if parent_presenter
-        polymorphic_path([:hyrax, :parent, presenter.model_name.singular],
+        polymorphic_path([:hyrax, :parent, presenter.model_name.singular.to_sym],
                          parent_id: parent_presenter.id,
                          id: presenter.id)
       else

data/app/services/hyrax/edit_permissions_service.rb

@@ -158,38 +158,64 @@ module Hyrax
     # find all of the work's collections a user can manage
     # @return [Array] of collection ids
     def object_managed_collection_ids
-      @object_managed_collection_ids ||= object_member_of & managed_collection_ids
+      @object_managed_collection_ids ||= object_member_of_ids & managed_collection_ids
     end
 
-    # find all of the work's collections a user cannot manage
-    # note: if the collection type doesn't include "sharing_applies_to_new_works", we don't limit access
+    # find all of the work's collections a user cannot manage note: if
+    # the collection type doesn't include
+    # "sharing_applies_to_new_works", we don't limit access
+    #
     # @return [Array] of collection ids with limited access
     def object_unauthorized_collection_ids
       @object_unauthorized_collection_ids ||= begin
-                                                limited_access = []
-                                                unauthorized_collection_ids = object_member_of - object_managed_collection_ids
-                                                if unauthorized_collection_ids.any?
-                                                  unauthorized_collection_ids.each do |id|
-                                                    # TODO: Can we instead use a SOLR query?  This seems to be somewhat expensive.  However, as this is
-                                                    # used in administration instead of user front-end displays, I'm not as concerned.
-                                                    collection = ActiveFedora::Base.find(id)
-                                                    limited_access << id if (collection.instance_of? AdminSet) || collection.share_applies_to_new_works?
-                                                  end
+                                                unauthorized_collection_ids = object_member_of_ids - object_managed_collection_ids
+                                                qualified_resources = Hyrax.query_service.find_many_by_ids(ids: unauthorized_collection_ids).select do |resource|
+                                                  qualifies_as_unauthorized_collection?(resource: resource)
                                                 end
-                                                limited_access
+                                                qualified_resources.map { |resource| resource.id.to_s }
                                               end
     end
 
+    # Does the given resource qualify as a collection the current user cannot manage.
+    #
+    # @see {#object_unauthorized_collection_ids}
+    #
+    # @param resource [Valkyrie::Resource, AdminSet, Collection, #collection_type_gid, #share_applies_to_new_works?]
+    #     the given resource, hopefully a collection-like thing
+    #     (e.g. AdminSet, Hyrax::AdminSet, Hyrax::PcdmCollection,
+    #     Collection)
+    #
+    # @return [Boolean]
+    #
+    # @todo Refactor inner working of code as there's lots of branching logic with potential hidden assumptions.
+    def qualifies_as_unauthorized_collection?(resource:)
+      case resource
+      when AdminSet, Hyrax::AdministrativeSet
+        # Prior to this refactor, we looked at AdminSet only; However with the advent of the
+        # Hyrax::AdministrativeSet, we need to test both cases.
+        true
+      else
+        if resource.respond_to?(:share_applies_to_new_works?)
+          # The Collection model has traditionally delegated #share_applies_to_new_works? to
+          # the underlying collection_type
+          # (see https://github.com/samvera/hyrax/blob/696da5db/spec/models/collection_spec.rb#L189)
+          resource.share_applies_to_new_works?
+        elsif resource.respond_to?(:collection_type_gid)
+          # This is likely a Hyrax::PcdmCollection object, which means we don't have the delegation
+          # behavior.  Instead we'll query the collection type directly.
+          collection_type = CollectionType.find_by_gid(resource.collection_type_gid)
+          collection_type&.share_applies_to_new_works?
+        else
+          # How might we get here?
+          false
+        end
+      end
+    end
+
     # find all of the collection ids an object is a member of
     # @return [Array] array of collection ids
-    def object_member_of
-      @object_member_of ||= begin
-                              belongs_to = []
-                              # get all of work's collection ids from the form
-                              belongs_to += @object.member_of_collection_ids
-                              belongs_to << @object.admin_set_id if @object.admin_set_id.present?
-                              belongs_to
-                            end
+    def object_member_of_ids
+      @object_member_of_ids ||= (@object.member_of_collection_ids + [@object.admin_set_id]).select(&:present?)
     end
 
     # The list of all collections this user has manage rights on

data/app/services/hyrax/find_objects_via_solr_service.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Hyrax
+  # 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_service = Hyrax::SolrService
+    self.query_service = Hyrax.query_service
+
+    class << self
+      # Find objects matching search criteria.
+      # @param model [Class] if not using Valkyrie, this is expected to be an ActiveFedora::Base object that supports #where
+      # @param field_pairs [Hash] a list of pairs of property name and values
+      # @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
+      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
+      end
+    end
+  end
+end

data/app/services/hyrax/multiple_membership_checker.rb

@@ -53,7 +53,11 @@ module Hyrax
     def single_membership_collections(collection_ids)
       return [] if collection_ids.blank?
 
-      ::Collection.where(:id => collection_ids, Hyrax.config.collection_type_index_field.to_sym => collection_type_gids_that_disallow_multiple_membership)
+      field_pairs = {
+        :id => collection_ids,
+        Hyrax.config.collection_type_index_field.to_sym => collection_type_gids_that_disallow_multiple_membership
+      }
+      Hyrax::FindObjectsViaSolrService.find_for_model_by_field_pairs(model: ::Collection, field_pairs: field_pairs, use_valkyrie: true)
     end
 
     def collection_type_gids_that_disallow_multiple_membership
@@ -74,7 +78,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/solr_query_builder_service.rb

@@ -14,9 +14,9 @@ module Hyrax
       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']])
@@ -32,6 +32,20 @@ module Hyrax
         ' 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\""
+      def construct_query_for_model(model, field_pairs, join_with = default_join_with, type = 'field')
+        field_pairs["has_model_ssim"] = model.to_s
+        construct_query(field_pairs, join_with, type)
+      end
+
       private
 
       # @param [Array<Array>] pairs a list of (key, value) pairs. The value itself may

data/app/services/hyrax/visibility_intention.rb

@@ -54,7 +54,7 @@ module Hyrax
     ##
     # @return [Boolean]
     def valid_embargo?
-      wants_embargo? && release_date.present?
+      wants_embargo? && release_date.present? && a_valid_date?(release_date)
     end
 
     ##
@@ -66,7 +66,7 @@ module Hyrax
     ##
     # @return [Boolean]
     def valid_lease?
-      wants_lease? && release_date.present?
+      wants_lease? && release_date.present? && a_valid_date?(release_date)
     end
 
     ##
@@ -74,5 +74,23 @@ module Hyrax
     def wants_lease?
       visibility == LEASE_REQUEST
     end
+
+    private
+
+    ##
+    # @param date [Object]
+    # @return [Boolean]
+    # @note If we don't have a valid date, we really can't have a
+    # valid release_date
+    def a_valid_date?(date)
+      return true if date.is_a?(Date)
+      return true if date.is_a?(Time)
+      Date.parse(date)
+      # In Ruby 2.7.x, Date::Error descends from ArgumentError; Once
+      # we stop supporting pre-2.7, we can switch this to the more
+      # narrow Date::Error
+    rescue ArgumentError
+      false
+    end
   end
 end