hyrax 2.0.3 → 2.1.0.beta1

data/app/presenters/hyrax/work_show_presenter.rb

@@ -2,6 +2,7 @@ module Hyrax
   class WorkShowPresenter
     include ModelProxy
     include PresentsAttributes
+
     attr_accessor :solr_document, :current_ability, :request
 
     class_attribute :collection_presenter_class
@@ -38,7 +39,7 @@ module Hyrax
     delegate :title, :date_created, :description,
              :creator, :contributor, :subject, :publisher, :language, :embargo_release_date,
              :lease_expiration_date, :license, :source, :rights_statement, :thumbnail_id, :representative_id,
-             :member_of_collection_ids, to: :solr_document
+             :rendering_ids, :member_of_collection_ids, to: :solr_document
 
     def workflow
       @workflow ||= WorkflowPresenter.new(solr_document, current_ability)
@@ -54,12 +55,21 @@ module Hyrax
       Hyrax::Engine.routes.url_helpers.download_url(representative_presenter, host: request.host)
     end
 
+    # @return [Boolean] render the UniversalViewer
+    def universal_viewer?
+      representative_id.present? &&
+        representative_presenter.present? &&
+        representative_presenter.image? &&
+        Hyrax.config.iiif_image_server?
+    end
+
     # @return FileSetPresenter presenter for the representative FileSets
     def representative_presenter
       return nil if representative_id.blank?
       @representative_presenter ||=
         begin
           result = member_presenters([representative_id]).first
+          return nil if result.try(:id) == id
           if result.respond_to?(:representative_presenter)
             result.representative_presenter
           else
@@ -138,10 +148,51 @@ module Hyrax
       Hyrax::Engine.routes.url_helpers.stats_work_path(self)
     end
 
+    def model
+      solr_document.to_model
+    end
+
     delegate :member_presenters, :file_set_presenters, :work_presenters, to: :member_presenter_factory
 
+    def manifest_url
+      manifest_helper.polymorphic_url([:manifest, self])
+    end
+
+    # IIIF rendering linking property for inclusion in the manifest
+    #  Called by the `iiif_manifest` gem to add a 'rendering' (eg. a link a download for the resource)
+    #
+    # @return [Array] array of rendering hashes
+    def sequence_rendering
+      renderings = []
+      if solr_document.rendering_ids.present?
+        solr_document.rendering_ids.each do |file_set_id|
+          renderings << manifest_helper.build_rendering(file_set_id)
+        end
+      end
+      renderings.flatten
+    end
+
+    # IIIF metadata for inclusion in the manifest
+    #  Called by the `iiif_manifest` gem to add metadata
+    #
+    # @return [Array] array of metadata hashes
+    def manifest_metadata
+      metadata = []
+      Hyrax.config.iiif_metadata_fields.each do |field|
+        metadata << {
+          'label' => I18n.t("simple_form.labels.defaults.#{field}"),
+          'value' => Array.wrap(send(field))
+        }
+      end
+      metadata
+    end
+
     private
 
+      def manifest_helper
+        @manifest_helper ||= ManifestHelper.new(request.base_url)
+      end
+
       def featured?
         if @featured.nil?
           @featured = FeaturedWork.where(work_id: solr_document.id).exists?

data/app/renderers/hyrax/renderers/attribute_renderer.rb

@@ -25,7 +25,7 @@ module Hyrax
 
         return markup if values.blank? && !options[:include_empty]
         markup << %(<tr><th>#{label}</th>\n<td><ul class='tabular'>)
-        attributes = microdata_object_attributes(field).merge(class: "attribute #{field}")
+        attributes = microdata_object_attributes(field).merge(class: "attribute attribute-#{field}")
         Array(values).each do |value|
           markup << "<li#{html_attributes(attributes)}>#{attribute_value_to_html(value.to_s)}</li>"
         end

data/app/renderers/hyrax/renderers/license_attribute_renderer.rb

@@ -11,7 +11,7 @@ module Hyrax
         def attribute_value_to_html(value)
           begin
             parsed_uri = URI.parse(value)
-          rescue
+          rescue URI::InvalidURIError
             nil
           end
           if parsed_uri.nil?

data/app/renderers/hyrax/renderers/rights_statement_attribute_renderer.rb

@@ -11,13 +11,14 @@ module Hyrax
         def attribute_value_to_html(value)
           begin
             parsed_uri = URI.parse(value)
-          rescue
+          rescue URI::InvalidURIError
             nil
           end
           if parsed_uri.nil?
             ERB::Util.h(value)
           else
-            %(<a href=#{ERB::Util.h(value)} target="_blank">#{Hyrax.config.rights_statement_service_class.new.label(value)}</a>)
+            label = Hyrax.config.rights_statement_service_class.new.label(value) { value }
+            %(<a href=#{ERB::Util.h(value)} target="_blank">#{label}</a>)
           end
         end
     end

data/app/search_builders/hyrax/admin_admin_set_member_search_builder.rb

@@ -5,10 +5,19 @@ module Hyrax
     self.default_processor_chain += [:in_admin_set]
     self.default_processor_chain -= [:only_active_works]
 
+    attr_reader :collection
+
+    # @param [scope] Typically the controller object
+    # @param [Collection]
+    def initialize(scope:, collection:)
+      @collection = collection
+      super(scope)
+    end
+
     # include filters into the query to only include the admin_set members (regardless of status)
     def in_admin_set(solr_parameters)
       solr_parameters[:fq] ||= []
-      solr_parameters[:fq] << "{!term f=isPartOf_ssim}#{blacklight_params.fetch('id')}"
+      solr_parameters[:fq] << "{!term f=isPartOf_ssim}#{collection.id}"
     end
   end
 end

data/app/search_builders/hyrax/admin_set_search_builder.rb

@@ -33,7 +33,14 @@ module Hyrax
       ["{!terms f=id}#{admin_set_ids_for_deposit.join(',')}"]
     end
 
-    delegate :admin_set_ids_for_deposit, to: :current_ability
-    private :admin_set_ids_for_deposit
+    private
+
+      # IDs of admin_sets into which a user can deposit.
+      #
+      # @return [Array<String>] IDs of admin_sets into which the user can deposit
+      # @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.
+      def admin_set_ids_for_deposit
+        Hyrax::Collections::PermissionsService.source_ids_for_deposit(ability: current_ability)
+      end
   end
 end

data/app/search_builders/hyrax/collection_member_search_builder.rb

@@ -1,27 +1,40 @@
 module Hyrax
   # This search builder requires that a accessor named "collection" exists in the scope
-  # TODO it would be better to pass collection_id in.
   class CollectionMemberSearchBuilder < ::SearchBuilder
     include Hyrax::FilterByType
+    attr_reader :collection, :search_includes_models
 
     class_attribute :collection_membership_field
-    self.collection_membership_field = 'member_of_collection_ids_ssim'
+    self.collection_membership_field = 'nesting_collection__parent_ids_ssim'
 
     # Defines which search_params_logic should be used when searching for Collection members
     self.default_processor_chain += [:member_of_collection]
 
-    delegate :collection, to: :scope
+    # @param [scope] Typically the controller object
+    # @param [Symbol] :works, :collections, (anything else retrieves both)
+    def initialize(scope:,
+                   collection:,
+                   search_includes_models: :works)
+      @collection = collection
+      @search_includes_models = search_includes_models
+      super(scope)
+    end
 
     # include filters into the query to only include the collection memebers
     def member_of_collection(solr_parameters)
       solr_parameters[:fq] ||= []
-      solr_parameters[:fq] << "#{collection_membership_field}:#{collection_id}"
+      solr_parameters[:fq] << "#{collection_membership_field}:#{collection.id}"
     end
 
-    private
-
-      def collection_id
-        collection.id || raise("Collection does not have an identifier")
+    # This overrides the models in FilterByType
+    def models
+      case search_includes_models
+      when :collections
+        collection_classes
+      when :works
+        work_classes
+      else super # super includes both works and collections
       end
+    end
   end
 end

data/app/search_builders/hyrax/collection_search_builder.rb

@@ -6,9 +6,17 @@ module Hyrax
   # @see https://github.com/samvera/hyrax/blob/master/app/search_builders/hyrax/README.md SearchBuilders README
   # @note the default_processor_chain defined by Blacklight::Solr::SearchBuilderBehavior provides many possible points of override
   #
+  # Allows :deposit as a valid type
   class CollectionSearchBuilder < ::SearchBuilder
     include FilterByType
 
+    attr_reader :access
+
+    # Overrides Hydra::AccessControlsEnforcement
+    def discovery_permissions
+      @discovery_permissions = extract_discovery_permissions(@access)
+    end
+
     # @return [String] Solr field name indicating default sort order
     def sort_field
       Solrizer.solr_name('title', :sortable)
@@ -19,11 +27,40 @@ module Hyrax
       collection_classes
     end
 
+    def with_access(access)
+      @access = access
+      super(access)
+    end
+
     # Sort results by title if no query was supplied.
     # This overrides the default 'relevance' sort.
     def add_sorting_to_solr(solr_parameters)
       return if solr_parameters[:q]
       solr_parameters[:sort] ||= "#{sort_field} asc"
     end
+
+    # If :deposit access is requested, check to see which collections the user has
+    # deposit or manage access to.
+    # @return [Array<String>] a list of filters to apply to the solr query
+    def gated_discovery_filters(permission_types = discovery_permissions, ability = current_ability)
+      return super unless permission_types.include?("deposit")
+      ["{!terms f=id}#{collection_ids_for_deposit.join(',')}"]
+    end
+
+    private
+
+      def collection_ids_for_deposit
+        Hyrax::Collections::PermissionsService.collection_ids_for_deposit(ability: current_ability)
+      end
+
+      ACCESS_LEVELS_FOR_LEVEL = ActiveSupport::HashWithIndifferentAccess.new(
+        edit: ["edit"],
+        deposit: ["deposit"],
+        read: ["edit", "read"]
+      ).freeze
+      def extract_discovery_permissions(access)
+        access = :read if access.blank?
+        ACCESS_LEVELS_FOR_LEVEL.fetch(access)
+      end
   end
 end

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

@@ -0,0 +1,42 @@
+module Hyrax
+  module Dashboard
+    class CollectionsSearchBuilder < Hyrax::CollectionSearchBuilder
+      include Hyrax::Dashboard::ManagedSearchFilters
+
+      self.solr_access_filters_logic += [:apply_collection_deposit_permissions]
+      self.default_processor_chain += [:show_only_managed_collections_for_non_admins]
+
+      # This overrides the models in FilterByType
+      def models
+        [::AdminSet, ::Collection]
+      end
+
+      # adds a filter to exclude collections and admin sets created by the
+      # current user if the current user is not an admin.
+      # @param [Hash] solr_parameters
+      def show_only_managed_collections_for_non_admins(solr_parameters)
+        return if current_ability.admin?
+        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
+
+      # Include all admin sets and collections the user has deposit permission for.
+      # @return [Array{String}] values are lucence syntax term queries suitable for :fq
+      def apply_collection_deposit_permissions(_permission_types, _ability = current_ability)
+        collection_ids = collection_ids_for_deposit
+        return [] if collection_ids.empty?
+        ["{!terms f=id}#{collection_ids.join(',')}"]
+      end
+
+      private
+
+        def collection_ids_for_deposit
+          Hyrax::Collections::PermissionsService.source_ids_for_deposit(ability: current_ability)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Hyrax
+  module Dashboard
+    module ManagedSearchFilters
+      extend ActiveSupport::Concern
+
+      # This includes collection/admin the user can manage and view.
+      def discovery_permissions
+        @discovery_permissions ||= %w[edit read]
+      end
+
+      # Override to exclude 'public' and 'registered' groups from read access.
+      def apply_group_permissions(permission_types, ability = current_ability)
+        groups = ability.user_groups
+        return [] if groups.empty?
+        permission_types.map do |type|
+          field = solr_field_for(type, 'group')
+          user_groups = type == 'read' ? groups - ['public', 'registered'] : groups
+          next if user_groups.empty?
+          "({!terms f=#{field}}#{user_groups.join(',')})" # parens required to properly OR the clauses together.
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+module Hyrax
+  module Dashboard
+    # Responsible for searching for collections of the same type that are not the given collection
+    class NestedCollectionsSearchBuilder < ::Hyrax::CollectionSearchBuilder
+      # @param access [Symbol] :edit, :read, :discover - With the given :access what all can
+      # @param collection [Collection]
+      # @param scope [Object] Typically a controller that responds to #current_ability, #blackligh_config
+      # @param nesting_attributes [NestingAttributes] an object encapsulating nesting attributes of the collection
+      # @param nest_direction [Symbol] (:as_parent or :as_child) the direction we are adding nesting to this collection
+      def initialize(access:, collection:, scope:, nesting_attributes:, nest_direction:)
+        super(scope)
+        @collection = collection
+        @discovery_permissions = extract_discovery_permissions(access)
+        @nesting_attributes = nesting_attributes
+        @nest_direction = nest_direction
+      end
+
+      # Override for Hydra::AccessControlsEnforcement
+      attr_reader :discovery_permissions
+      self.default_processor_chain += [:with_pagination, :show_only_other_collections_of_the_same_collection_type]
+
+      def with_pagination(solr_parameters)
+        solr_parameters[:rows] = 1000
+      end
+
+      def show_only_other_collections_of_the_same_collection_type(solr_parameters)
+        solr_parameters[:fq] ||= []
+        solr_parameters[:fq] += [
+          "-" + ActiveFedora::SolrQueryBuilder.construct_query_for_ids(limit_ids),
+          ActiveFedora::SolrQueryBuilder.construct_query(Collection.collection_type_gid_document_field_name => @collection.collection_type_gid)
+        ]
+        solr_parameters[:fq] += limit_clause if limit_clause # add limits to prevent illegal nesting arrangements
+      end
+
+      # If :deposit access is requested, check to see which collections the user has
+      # deposit or manage access to.
+      # @return [Array<String>] a list of filters to apply to the solr query
+      def gated_discovery_filters(permission_types = discovery_permissions, ability = current_ability)
+        return super unless permission_types.include?("deposit")
+        ["{!terms f=id}#{collection_ids_for_deposit.join(',')}"]
+      end
+
+      private
+
+        def collection_ids_for_deposit
+          Hyrax::Collections::PermissionsService.collection_ids_for_deposit(ability: current_ability)
+        end
+
+        # My intention in this implementation is that if I need at least edit access on the queried document,
+        # then I must have one of the following access-levels
+        ACCESS_LEVELS_FOR_LEVEL = ActiveSupport::HashWithIndifferentAccess.new(
+          edit: ["edit"],
+          deposit: ["deposit"],
+          read: ["edit", "read"],
+          discover: ["edit", "discover", "read"]
+        ).freeze
+        def extract_discovery_permissions(access)
+          ACCESS_LEVELS_FOR_LEVEL.fetch(access)
+        end
+
+        def limit_ids
+          # exclude current collection from returned list
+          limit_ids = [@collection.id]
+          # cannot add a parent that is already a parent
+          limit_ids += @nesting_attributes.parents if @nesting_attributes.parents && @nest_direction == :as_parent
+          limit_ids
+        end
+
+        # remove collections from list in order to to prevent illegal nesting arrangements
+        def limit_clause
+          case @nest_direction
+          when :as_parent
+            eligible_to_be_a_parent
+          when :as_child
+            eligible_to_be_a_child
+          end
+        end
+
+        # To be eligible to be a parent collection of child "Collection G":
+        # 1) cannot have any pathnames containing Collection G's ID
+        # 2) cannot already be Collection G's direct parent
+        # => this is handled through limit_ids method
+        def eligible_to_be_a_parent
+          # Using a !lucene query allows us to get items using a wildcard query, a feature not supported via AF query builder.
+          ["-_query_:\"{!lucene df=#{Samvera::NestingIndexer.configuration.solr_field_name_for_storing_pathnames}}*#{@collection.id}*\""]
+        end
+
+        # To be eligible to be a child collection of parent "Collection F":
+        # 1) Cannot have any pathnames containing any of Collection F's pathname or ancestors
+        # 2) cannot already be Collection F's direct child
+        def eligible_to_be_a_child
+          exclude_path = []
+          exclude_path << exclude_if_paths_contain_collection
+          exclude_path << exclude_if_already_parent
+        end
+
+        def exclude_if_paths_contain_collection
+          # 1) Exclude any pathnames containing any of Collection F's pathname or ancestors
+          array_to_exclude = [] + @nesting_attributes.pathnames unless @nesting_attributes.pathnames.nil?
+          array_to_exclude += @nesting_attributes.ancestors unless @nesting_attributes.ancestors.nil?
+          # build a unique string containing all of Collection F's pathnames and ancestors
+          exclude_list = ""
+          unless array_to_exclude.nil?
+            array_to_exclude.uniq.each do |element|
+              exclude_list += ' ' unless exclude_list.empty?
+              exclude_list += element.to_s
+            end
+          end
+          # Using a !lucene query allows us to get items which match any individual element
+          # from the list. Building the query via the AF builder created a !field query which
+          # only searches the field for an exact string and doesn't allow an "OR" connection
+          # between the elements.
+          return "-_query_:\"{!lucene q.op=OR df=#{Samvera::NestingIndexer.configuration.solr_field_name_for_storing_pathnames}}#{exclude_list}\"" unless exclude_list.empty?
+          ""
+        end
+
+        def exclude_if_already_parent
+          # 2) Exclude any of Collection F's direct children
+          "-" + ActiveFedora::SolrQueryBuilder.construct_query(Samvera::NestingIndexer.configuration.solr_field_name_for_storing_parent_ids => @collection.id)
+        end
+    end
+  end
+end