hyrax 5.1.0 → 5.3.0

data/app/services/hyrax/custom_queries/find_by_property_value.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module CustomQueries
+    ##
+    # Finds resources for arbitrary properties using the Solr index.
+    # @see https://github.com/samvera/valkyrie/wiki/Queries#custom-queries
+    class FindByPropertyValue
+      def self.queries
+        [:find_ids_by_property_pairs,
+         :find_many_by_property_pairs,
+         :find_many_by_property_value,
+         :find_by_property_value]
+      end
+
+      def initialize(query_service:, query_rows: 1_000)
+        @query_service = query_service
+        @query_rows = query_rows
+      end
+
+      ##
+      # Returns ids for resources matching all specified property/value pairs.
+      # @param pairs [Hash<String, String>] properties and values to match
+      # @param field_suffix Hash,Symbol which solr field suffix to use; Use a hash to set per field pair
+      # @param options Hash options to pass to solr
+      #
+      # @return [Array<String>] found ids, if any
+      def find_ids_by_property_pairs(pairs:, field_suffix: :ssim, **options)
+        options = { rows: @query_rows }.merge(options)
+        query = pairs.map do |k, v|
+          suffix = if field_suffix.is_a? Hash
+                     field_suffix[k] || :ssim
+                   else
+                     field_suffix
+                   end
+          "+#{k}_#{suffix}:\"#{RSolr.solr_escape(v)}\""
+        end
+        response = Hyrax::SolrService.query_result(query.join(' '), fl: 'id', **options)
+        response['response']['docs'].map { |doc| doc['id'] }
+      end
+
+      ##
+      # Returns resources matching all specified property/value pairs.
+      # @param pairs [Hash<String, String>] properties and values to match
+      # @param field_suffix Hash,Symbol which solr field suffix to use; Use a hash to set per field pair
+      # @param options Hash options to pass to solr
+      #
+      # @return [Array<Valkyrie::Resource>] found resources, if any
+      def find_many_by_property_pairs(pairs:, field_suffix: :ssim, **options)
+        found_ids = find_ids_by_property_pairs(pairs: pairs, field_suffix: field_suffix, **options)
+        @query_service.find_many_by_ids(ids: found_ids).to_a # Wings emits an Enumerator
+      end
+
+      ##
+      # Returns resources matching the specified property and value.
+      # @param property [#to_s] the name of the property we're attempting to query.
+      # @param value [#to_s] the property value we're trying to match.
+      # @param field_suffix Symbol which solr field suffix to use
+      # @param search_field String alt way to set property and suffix for compatibility
+      # @param options Hash options to pass to solr
+      #
+      # @return [Array<Valkyrie::Resource>] found resources, if any
+      def find_many_by_property_value(property:, value:, field_suffix: :ssim, search_field: nil, **options)
+        if search_field
+          search_field_array = search_field.split('_')
+          field_suffix = search_field_array.last
+          property = search_field_array[0...-1].join('_')
+        end
+        find_many_by_property_pairs(pairs: { property => value }, field_suffix: field_suffix, **options)
+      end
+
+      ##
+      # Returns one resource matching the specified property and value.
+      # @param property [#to_s] the name of the property we're attempting to query.
+      # @param value [#to_s] the property value we're trying to match.
+      # @param field_suffix Symbol which solr field suffix to use
+      # @param search_field String alt way to set property and suffix for compatibility
+      # @param options Hash options to pass to solr
+      #
+      # @return [NilClass] when no record was found
+      # @return [Valkyrie::Resource] when a resource was found
+      def find_by_property_value(property:, value:, field_suffix: :ssim, search_field: nil, **options)
+        options[:rows] = 1
+        find_many_by_property_value(property: property, value: value,
+                                    field_suffix: field_suffix, search_field: search_field, **options).first
+      end
+    end
+  end
+end

data/app/services/hyrax/custom_queries/find_ids_by_model.rb

@@ -8,8 +8,9 @@ module Hyrax
         [:find_ids_by_model]
       end
 
-      def initialize(query_service:)
+      def initialize(query_service:, query_rows: 1_000)
         @query_service = query_service
+        @query_rows = query_rows
       end
 
       attr_reader :query_service
@@ -23,14 +24,38 @@ module Hyrax
       #
       # @param model [Class]
       # @param ids [Enumerable<#to_s>, Symbol]
+      # @param use_solr [Boolean]
       #
       # @return [Enumerable<Valkyrie::ID>]
-      def find_ids_by_model(model:, ids: :all)
-        return query_service.find_all_of_model(model: model).map(&:id) if ids == :all
+      def find_ids_by_model(model:, ids: :all, use_solr: true)
+        if use_solr
+          query_solr(model, ids)
+        else
+          return query_service.find_all_of_model(model: model).map(&:id) if ids == :all
+          query_service.find_many_by_ids(ids: ids).select do |resource|
+            resource.is_a?(model)
+          end.map(&:id)
+        end
+      end
+
+      private
+
+      def query_solr(model, ids)
+        return enum_for(:query_solr, model, ids) unless block_given?
+        model_name = Hyrax::ModelRegistry.rdf_representations_from(Array(model)).first
+
+        solr_query = "_query_:\"{!raw f=has_model_ssim}#{model_name}\""
+        solr_response = Hyrax::SolrService.get(solr_query, fl: 'id', rows: @query_rows)['response']
+
+        loop do
+          response_docs = solr_response['docs']
+          response_docs.select! { |doc| ids.include?(doc['id']) } unless ids == :all
+
+          response_docs.each { |doc| yield doc['id'] }
 
-        query_service.find_many_by_ids(ids: ids).select do |resource|
-          resource.is_a?(model)
-        end.map(&:id)
+          break if (solr_response['start'] + solr_response['docs'].count) >= solr_response['numFound']
+          solr_response = Hyrax::SolrService.get(solr_query, fl: 'id', rows: @query_rows, start: solr_response['start'] + @query_rows)['response']
+        end
       end
     end
   end

data/app/services/hyrax/edit_permissions_service.rb

@@ -33,23 +33,24 @@ module Hyrax
     #    * use work the file_set is in
     #    No other object types are supported by this view.
     def self.build_service_object_from(form:, ability:)
-      if form.object.respond_to?(:model) && form.object.model.work?
+      obj = form.object
+      if obj.respond_to?(:model) && obj.model.work?
         # The provided form object is a work form.
-        new(object: form.object, ability: ability)
-      elsif form.object.respond_to?(:model) && form.object.model.file_set?
+        new(object: obj, ability: ability)
+      elsif obj.respond_to?(:model) && obj.model.file_set?
         # The provided form object is a FileSet form. For Valkyrie forms
         # (+Hyrax::Forms::FileSetForm+), +:in_works_ids+ is prepopulated onto
         # the form object itself. For +Hyrax::Forms::FileSetEditForm+, the
         # +:in_works+ method is present on the wrapped +:model+.
-        if form.object.is_a?(Hyrax::Forms::FileSetForm)
-          object_id = form.object.in_works_ids.first
-          new(object: Hyrax.query_service.find_by(id: object_id), ability: ability)
+        if obj.model.respond_to?(:in_works)
+          new(object: obj.model.in_works.first, ability: ability)
         else
-          new(object: form.object.model.in_works.first, ability: ability)
+          object_id = obj.in_works_ids.first
+          new(object: Hyrax.query_service.find_by(id: object_id), ability: ability)
         end
-      elsif form.object.file_set?
+      elsif obj.file_set?
         # The provided form object is a FileSet.
-        new(object: form.object.in_works.first, ability: ability)
+        new(object: obj.in_works.first, ability: ability)
       end
     end
 
@@ -170,7 +171,7 @@ module Hyrax
       unauthorized_managers = []
       unauthorized_collection_managers = []
       object_unauthorized_collection_ids.each do |id|
-        Hyrax::PermissionTemplate.find_by(source_id: id).access_grants.each do |grant|
+        Hyrax::PermissionTemplate.find_by(source_id: id)&.access_grants&.each do |grant|
           if grant.access == "manage"
             unauthorized_managers << grant.agent_id
             unauthorized_collection_managers += Array.wrap({ name: grant.agent_id }.merge(id: id))

data/app/services/hyrax/file_set_type_service.rb

@@ -8,9 +8,6 @@ module Hyrax
   # @note this service is for `Hyrax::FileSet` Valkyrie Resources. for
   #   ActiveFedora file sets see Hydra::Works::MimeTypes
   class FileSetTypeService
-    DEFAULT_AUDIO_TYPES = ['audio/mp3', 'audio/mpeg', 'audio/wav',
-                           'audio/x-wave', 'audio/x-wav', 'audio/ogg'].freeze
-
     ##
     # @!attribute [r] file_set
     #   @return [Hyrax::FileSet]
@@ -42,11 +39,22 @@ module Hyrax
       audio_types.include?(mime_type)
     end
 
+    ##
+    # @return [Boolean]
+    def video?
+      video_types.include?(mime_type)
+    end
+
     private
 
     def audio_types
       return ::FileSet.audio_mime_types if defined?(::FileSet) && ::FileSet.respond_to?(:audio_mime_types)
-      DEFAULT_AUDIO_TYPES
+      Hyrax.config.mime_types_map.fetch(:audio_mime_types)
+    end
+
+    def video_types
+      return ::FileSet.video_mime_types if defined?(::FileSet) && ::FileSet.respond_to?(:video_mime_types)
+      Hyrax.config.mime_types_map.fetch(:video_mime_types)
     end
   end
 end

data/app/services/hyrax/flexible_schema_validator_service.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Hyrax
+  class FlexibleSchemaValidatorService
+    DEFAULT_SCHEMA = Hyrax::Engine.root.join('config', 'metadata_profiles', 'm3_json_schema.json')
+    REQUIRED_CLASSES = [
+      Hyrax.config.admin_set_model,
+      Hyrax.config.collection_model,
+      Hyrax.config.file_set_model
+    ].map { |str| str.gsub(/^::/, '') }
+
+    attr_reader :profile, :schema, :schemer, :errors, :warnings
+
+    # Initializes a new FlexibleSchemaValidatorService.
+    #
+    # @param profile [Hash] the flexible metadata profile to validate
+    # @param schema [Pathname, String] the JSON schema to validate against.
+    #   Defaults to {DEFAULT_SCHEMA}.
+    # @return [void]
+    def initialize(profile:, schema: default_schema)
+      @profile = profile
+      @schema = schema
+      @schemer = JSONSchemer.schema(schema)
+      @errors = []
+      @warnings = []
+    end
+
+    # Execute all validation routines and populate {#errors} with any
+    # issues discovered.
+    #
+    # @return [void]
+    def validate!
+      validate_required_classes
+      validate_class_availability
+      validate_available_on_classes_defined
+      validate_existing_records_classes_defined
+      validate_schema
+      validate_label_prop
+      validate_core_metadata
+      validate_sort_properties
+      validate_redirects
+    end
+
+    # The default JSON schema used when no custom schema is provided.
+    #
+    # @return [Pathname]
+    def default_schema
+      DEFAULT_SCHEMA
+    end
+
+    # Classes that MUST be present in every flexible metadata profile.
+    #
+    # @return [Array<String>]
+    def required_classes
+      REQUIRED_CLASSES
+    end
+
+    private
+
+    # Validates core metadata requirements using the CoreMetadataValidator.
+    #
+    # This delegates to CoreMetadataValidator to check that essential metadata
+    # properties are properly configured across all classes in the profile.
+    #
+    # @return [void]
+    def validate_core_metadata
+      FlexibleSchemaValidators::CoreMetadataValidator.new(profile: profile, errors: @errors).validate!
+    end
+
+    # Runs JSON schema validation and translates resulting errors into
+    # user-friendly messages appended to {#errors}.
+    #
+    # @return [void]
+    def validate_schema
+      FlexibleSchemaValidators::SchemaValidator.new(schemer, profile, @errors).validate!
+    end
+
+    # Ensures that all required classes are defined in the profile.
+    #
+    # @return [void]
+    def validate_required_classes
+      missing_classes = clean_class_names(required_classes) - clean_class_names(profile['classes'].keys)
+      return if missing_classes.empty?
+
+      @errors << "Missing required classes: #{missing_classes.join(', ')}."
+    end
+
+    def clean_class_names(names)
+      names.map { |name| name.to_s.strip.gsub(/^::/, '') }
+    end
+
+    # Checks that any class referenced in the profile is a registered
+    # Hyrax curation concern type.
+    #
+    # @return [void]
+    def validate_class_availability
+      FlexibleSchemaValidators::ClassValidator.new(profile, required_classes, @errors).validate_availability!
+    end
+
+    # Validates that every class referenced under `available_on.class` is also
+    # defined in the profile's top-level `classes` section.
+    #
+    # @return [void]
+    def validate_available_on_classes_defined
+      FlexibleSchemaValidators::ClassValidator.new(profile, required_classes, @errors).validate_references!
+    end
+
+    # Delegates to {ExistingRecordsValidator} to ensure that no classes with
+    # existing repository records have been removed from the profile.
+    #
+    # @return [void]
+    def validate_existing_records_classes_defined
+      FlexibleSchemaValidators::ExistingRecordsValidator.new(profile, required_classes, @errors).validate!
+    end
+
+    # Validates that any properties needed to support sorting catalog search results.
+    #
+    # @return [void]
+    def validate_sort_properties
+      FlexibleSchemaValidators::SortPropertiesValidator.new(profile, @warnings).validate!
+    end
+
+    # Validates that the `redirects` property is declared on every work and
+    # collection class when both `Hyrax.config.redirects_enabled?` and
+    # `Flipflop.redirects?` are true. When either gate is closed, this
+    # validator is a no-op.
+    #
+    # @return [void]
+    def validate_redirects
+      FlexibleSchemaValidators::RedirectsValidator.new(
+        profile: profile, errors: @errors, warnings: @warnings
+      ).validate!
+    end
+
+    # Validates that a `label` property exists and that it is available on
+    # `Hyrax.config.file_set_model`.
+    #
+    # @return [void]
+    def validate_label_prop
+      label_prop = profile.dig('properties', 'label')
+      unless label_prop
+        @errors << "A `label` property is required."
+        return
+      end
+
+      available_on_classes = label_prop.dig('available_on', 'class')
+      file_set_model_name = Hyrax.config.file_set_model.gsub(/^::/, '')
+      return if available_on_classes&.include?(file_set_model_name)
+
+      @errors << "Label must be available on #{file_set_model_name}."
+    end
+  end
+end

data/app/services/hyrax/flexible_schema_validators/class_validator.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module FlexibleSchemaValidators
+    # Handles class-related validations for flexible metadata profiles
+    class ClassValidator
+      # @param profile [Hash] M3 profile data
+      # @param required_classes [Array<String>] Foundational classes that must be present
+      # @param errors [Array<String>] Array to append validation errors to
+      def initialize(profile, required_classes, errors)
+        @profile = profile
+        @required_classes = required_classes
+        @errors = errors
+      end
+
+      # Validates that referenced classes are registered Hyrax curation concern
+      # types and that Valkyrie models use the correct `...Resource` naming
+      # convention when applicable.
+      #
+      # @return [void]
+      def validate_availability!
+        classes_to_validate = all_profile_classes - @required_classes
+        invalid_classes = []
+        mismatched_valkyrie_classes = []
+
+        classes_to_validate.each do |klass|
+          validate_class(klass, invalid_classes, mismatched_valkyrie_classes)
+        end
+
+        report_mismatched_classes(mismatched_valkyrie_classes)
+        report_invalid_classes(invalid_classes)
+      end
+
+      # Validates that all classes referenced within property `available_on`
+      # definitions are themselves defined in the top-level `classes` section of
+      # the profile.
+      #
+      # @return [void]
+      def validate_references!
+        properties = @profile['properties'] || {}
+
+        referenced_classes = properties.values.flat_map do |prop|
+          prop.dig('available_on', 'class')
+        end.compact.uniq
+
+        undefined_classes = referenced_classes - @profile['classes'].keys
+
+        return if undefined_classes.empty?
+
+        @errors << "Classes referenced in `available_on` but not defined in `classes`: #{undefined_classes.join(', ')}."
+      end
+
+      private
+
+      # Gathers all unique class names from both the top-level `classes`
+      # definition and all `available_on` property references.
+      #
+      # @return [Array<String>]
+      def all_profile_classes
+        profile_classes = @profile.fetch('classes', {}).keys
+        properties = @profile['properties'] || {}
+        available_on_classes = properties.values.flat_map do |prop|
+          prop.dig('available_on', 'class')
+        end.compact
+
+        clean_class_names(profile_classes + available_on_classes).uniq
+      end
+
+      def clean_class_names(names)
+        names.map { |name| name.to_s.strip.gsub(/^::/, '') }
+      end
+
+      # Validates a single class, checking for registration as a curation concern
+      # and for Valkyrie naming mismatches using the Valkyrie resolver.
+      #
+      # @param klass [String] the class name to validate
+      # @param invalid_classes [Array<String>] an array to append invalid class errors to
+      # @param mismatched_valkyrie_classes [Array<Hash>] an array to append Valkyrie mismatch errors to
+      # @return [void]
+      def validate_class(klass, invalid_classes, mismatched_valkyrie_classes)
+        base_class_name = klass.gsub(/(?<=.)Resource$/, '')
+        unless Hyrax.config.registered_curation_concern_types.include?(base_class_name)
+          invalid_classes << klass
+          return
+        end
+
+        begin
+          expected_valkyrie_class = Valkyrie.config.resource_class_resolver.call(base_class_name)
+          expected_class_name = expected_valkyrie_class.to_s
+
+          mismatched_valkyrie_classes << { non_resource: klass, resource: expected_class_name } if klass != expected_class_name
+        rescue NameError
+          # This occurs if a registered concern doesn't have a loadable backing class,
+          # which is an invalid state.
+          invalid_classes << klass
+        end
+      end
+
+      # Appends a formatted error message for any Valkyrie naming mismatches.
+      #
+      # @param mismatched_classes [Array<Hash>]
+      # @return [void]
+      def report_mismatched_classes(mismatched_classes)
+        return if mismatched_classes.empty?
+
+        message = mismatched_classes.map do |mismatch|
+          "'#{mismatch[:non_resource]}' should be '#{mismatch[:resource]}'"
+        end.join(', ')
+        @errors << "Mismatched Valkyrie classes found: #{message}."
+      end
+
+      # Appends a formatted error message for any invalid classes.
+      #
+      # @param invalid_classes [Array<String>]
+      # @return [void]
+      def report_invalid_classes(invalid_classes)
+        return if invalid_classes.empty?
+
+        @errors << "Invalid classes: #{invalid_classes.join(', ')}."
+      end
+    end
+  end
+end