hyrax 5.2.0 → 5.3.0

data/app/services/hyrax/schema_loader.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # @api private
+  #
+  # This is a simple yaml config-driven schema loader
+  #
+  # @see config/metadata/basic_metadata.yaml for an example configuration
+  class SchemaLoader
+    class UndefinedSchemaError < ArgumentError; end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [Hash<Symbol, Dry::Types::Type>] a map from attribute names to
+    #   types
+    def attributes_for(schema:, version: 1, contexts: nil)
+      definitions(schema, version, contexts).each_with_object({}) do |definition, hash|
+        hash[definition.name] = definition.type.meta(definition.config)
+      end
+    end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [Hash{Symbol => Hash{Symbol => Object}}]
+    def form_definitions_for(schema:, version: 1, contexts: nil)
+      definitions(schema, version, contexts).each_with_object({}) do |definition, hash|
+        next if definition.form_options.empty?
+
+        hash[definition.name] = definition.form_options
+      end
+    end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [{Symbol => Symbol}] a map from index keys to attribute names
+    def index_rules_for(schema:, version: 1, contexts: nil)
+      definitions(schema, version, contexts).each_with_object({}) do |definition, hash|
+        definition.index_keys.each do |key|
+          hash[key] = definition.name
+        end
+      end
+    end
+
+    def current_version
+      1
+    end
+
+    ##
+    # @api private
+    class AttributeDefinition
+      ##
+      # @!attr_reader :config
+      #   @return [Hash<String, Object>]
+      # @!attr_reader :name
+      #   @return [#to_sym]
+      attr_reader :config, :name
+
+      ##
+      # @param [#to_sym] name
+      # @param [Hash<String, Object>] config
+      def initialize(name, config)
+        @config = config
+        @name   = (config['name'] || name).to_sym
+      end
+
+      ##
+      # @return [Hash{Symbol => Object}]
+      def form_options
+        config.fetch('form', {})&.symbolize_keys || {}
+      end
+
+      ##
+      # @return [Enumerable<Symbol>]
+      def index_keys
+        (config.fetch('indexing', nil) || config.fetch('index_keys', []))&.reject { |k| ['facetable', 'stored_searchable', 'admin_only', 'editor_only'].include?(k) }&.map(&:to_sym) || []
+      end
+
+      ##
+      # @return [Hash{Symbol => Object}]
+      def view_options
+        # prefer display_label over view:label for labels, make available in the view
+        @view_options = config.fetch('view', {})&.with_indifferent_access || {}
+        Deprecation.warn('view: label is deprecated, use display_label instead') if @view_options[:label].present?
+        @view_options.delete(:label)
+        @view_options[:display_label] = display_label
+        @view_options[:admin_only] = admin_only?
+        @view_options[:editor_only] = editor_only?
+        @view_options
+      end
+
+      def display_label
+        return @display_label if @display_label
+        @display_label = config.fetch('display_label', {})&.with_indifferent_access || {}
+        @display_label = { default: @display_label } if @display_label.is_a?(String)
+        @display_label
+      end
+
+      def admin_only?
+        @admin_only ||= config.fetch('admin_only', false) || config['indexing']&.include?('admin_only')
+      end
+
+      def editor_only?
+        @editor_only ||= config.fetch('editor_only', false) || config['indexing']&.include?('editor_only')
+      end
+
+      ##
+      # @return [Dry::Types::Type]
+      def type
+        member_type = type_for(config['type'])
+        wrapper_type = multiple? ? Valkyrie::Types::Array.constructor(&Coerce) : Identity
+        wrapper_type.of(member_type)
+      end
+
+      # Cleans up the input before the type system sees it: drops the
+      # "no value provided" placeholder dry-types uses internally, then
+      # removes blanks. Wraps a bare Hash in a one-element array; using
+      # `Array(hash)` would surprise-flatten it into [[:k, v], ...] pairs.
+      # Valkyrie's JSONValueMapper unwraps single-element arrays on read,
+      # so the type sees a hash here when there was originally one entry.
+      Coerce = lambda do |value|
+        return [] if value.equal?(Dry::Types::Undefined)
+        wrapped = value.is_a?(::Hash) ? [value] : Array(value)
+        wrapped.reject { |v| v.equal?(Dry::Types::Undefined) }.select(&:present?)
+      end
+
+      # Determine whether this attribute allows multiple values.
+      def multiple?
+        return config['multiple'] if config.key?('multiple')
+        return true if config.key?('data_type') && config['data_type'] == 'array'
+        return false unless (card = config['cardinality'])
+
+        max = card['maximum']
+        max.nil? || max.to_i > 1
+      end
+
+      ##
+      # @api private
+      #
+      # Single-value wrapper that matches the multi-value branch's cleanup:
+      # strips the dry-types Undefined placeholder and coerces blank strings to nil.
+      # Booleans, numbers, and other types pass through unchanged.
+      #
+      # @example
+      #   Identity.of(Valkyrie::Types::String) # => Valkyrie::Types::String with blank-string → nil coercion
+      class Identity
+        def self.of(type)
+          type.constructor do |value|
+            next nil if value.equal?(Dry::Types::Undefined)
+            value.is_a?(String) ? value.presence : value
+          end
+        end
+      end
+
+      private
+
+      ##
+      # Resolves a `type:` value from a schema YAML to a Dry::Types::Type.
+      #
+      # Recognized values:
+      #   - `id`, `uri`, `date_time` — Valkyrie type shortcuts.
+      #   - `hash` — for attributes whose entries carry multiple sub-fields
+      #     (e.g. redirects, with path / canonical / sequence). Use this
+      #     instead of nesting a Valkyrie::Resource. See
+      #     `documentation/redirects.md` for a worked example.
+      #   - Any primitive Valkyrie type, looked up under `Valkyrie::Types::*`
+      #     by classified name (e.g. `string` → `Valkyrie::Types::String`).
+      #
+      # Raises `ArgumentError` if nothing matches.
+      #
+      # @param [String]
+      # @return [Dry::Types::Type]
+      def type_for(type)
+        case type
+        when 'id'
+          Valkyrie::Types::ID
+        when 'uri'
+          Valkyrie::Types::URI
+        when 'date_time'
+          Valkyrie::Types::DateTime
+        when 'hash'
+          Dry::Types['hash']
+        else
+          "Valkyrie::Types::#{type.classify}".safe_constantize ||
+            raise(ArgumentError, "Unrecognized type: #{type}")
+        end
+      end
+    end
+
+    class UndefinedSchemaError < ArgumentError; end
+
+    private
+
+    def definitions(_schema_name, _version, _contexts)
+      raise NotImplementedError, 'Implement #definitions in a child class'
+    end
+
+    def config_search_paths
+      Hyrax.config.schema_loader_config_search_paths
+    end
+  end
+end

data/app/services/hyrax/search_service.rb

@@ -10,7 +10,7 @@ module Hyrax
 
     def method_missing(method_name, *arguments, &block)
       if scope&.respond_to?(method_name)
-        Deprecation.warn(self.class, "Calling `#{method_name}` on scope " \
+        Deprecation.warn("Calling `#{method_name}` on scope " \
           'is deprecated and will be removed in Blacklight 8. Call #to_h first if you ' \
           ' need to use hash methods (or, preferably, use your own SearchState implementation)')
         scope&.public_send(method_name, *arguments, &block)

data/app/services/hyrax/simple_schema_loader.rb

@@ -7,41 +7,13 @@ module Hyrax
   # This is a simple yaml config-driven schema loader
   #
   # @see config/metadata/basic_metadata.yaml for an example configuration
-  class SimpleSchemaLoader
-    ##
-    # @param [Symbol] schema
-    #
-    # @return [Hash<Symbol, Dry::Types::Type>] a map from attribute names to
-    #   types
-    def attributes_for(schema:)
-      definitions(schema).each_with_object({}) do |definition, hash|
-        hash[definition.name] = definition.type.meta(definition.config)
-      end
-    end
-
-    ##
-    # @param [Symbol] schema
-    #
-    # @return [Hash{Symbol => Hash{Symbol => Object}}]
-    def form_definitions_for(schema:)
-      definitions(schema).each_with_object({}) do |definition, hash|
-        next if definition.form_options.empty?
-
-        hash[definition.name] = definition.form_options
-      end
-    end
-
-    ##
-    # @param [Symbol] schema
-    #
-    # @return [{Symbol => Symbol}] a map from index keys to attribute names
-    def index_rules_for(schema:)
-      definitions(schema).each_with_object({}) do |definition, hash|
-        definition.index_keys.each do |key|
-          hash[key] = definition.name
-        end
+  class SimpleSchemaLoader < Hyrax::SchemaLoader
+    def view_definitions_for(schema:, version: 1, contexts: nil) # rubocop:disable Lint/UnusedMethodArgument
+      schema.each_with_object({}) do |property, metadata|
+        view_options = property.meta['view']
+        metadata[property.name.to_s] = view_options.with_indifferent_access unless view_options.nil?
       end
-    end
+    end # rubocop:enable Lint/UnusedMethodArgument
 
     def permissive_schema_for_valkrie_adapter
       metadata_files.each_with_object({}) do |schema_name, ret_hsh|
@@ -49,95 +21,12 @@ module Hyrax
       end
     end
 
-    ##
-    # @api private
-    class AttributeDefinition
-      ##
-      # @!attr_reader :config
-      #   @return [Hash<String, Object>]
-      # @!attr_reader :name
-      #   @return [#to_sym]
-      attr_reader :config, :name
-
-      ##
-      # @param [#to_sym] name
-      # @param [Hash<String, Object>] config
-      def initialize(name, config)
-        @config = config
-        @name   = name.to_sym
-      end
-
-      ##
-      # @return [Hash{Symbol => Object}]
-      def form_options
-        config.fetch('form', {}).symbolize_keys
-      end
-
-      ##
-      # @return [Enumerable<Symbol>]
-      def index_keys
-        config.fetch('index_keys', []).map(&:to_sym)
-      end
-
-      ##
-      # @return [Dry::Types::Type]
-      def type
-        collection_type = if config['multiple']
-                            Valkyrie::Types::Array.constructor { |v| Array(v).select(&:present?) }
-                          else
-                            Identity
-                          end
-        collection_type.of(type_for(config['type']))
-      end
-
-      ##
-      # @api private
-      #
-      # This class acts as a Valkyrie/Dry::Types collection with typed members,
-      # but instead of wrapping the given type with itself as the collection type
-      # (as in `Valkyrie::Types::Array.of(MyType)`), it returns the given type.
-      #
-      # @example
-      #   Identity.of(Valkyrie::Types::String) # => Valkyrie::Types::String
-      #
-      class Identity
-        ##
-        # @param [Dry::Types::Type]
-        # @return [Dry::Types::Type] the type passed in
-        def self.of(type)
-          type
-        end
-      end
-
-      private
-
-      ##
-      # Maps a configuration string value to a `Valkyrie::Type`.
-      #
-      # @param [String]
-      # @return [Dry::Types::Type]
-      def type_for(type)
-        case type
-        when 'id'
-          Valkyrie::Types::ID
-        when 'uri'
-          Valkyrie::Types::URI
-        when 'date_time'
-          Valkyrie::Types::DateTime
-        else
-          "Valkyrie::Types::#{type.capitalize}".constantize
-        end
-      end
-    end
-
-    class UndefinedSchemaError < ArgumentError; end
-
     private
 
     ##
     # @param [#to_s] schema_name
     # @return [Enumerable<AttributeDefinition]
-    def definitions(schema_name)
+    def definitions(schema_name, _version, _contexts = nil)
       schema_config(schema_name)['attributes'].map do |name, config|
         AttributeDefinition.new(name, config)
       end
@@ -147,6 +36,8 @@ module Hyrax
     # @param [#to_s] schema_name
     # @return [Hash]
     def schema_config(schema_name)
+      raise(UndefinedSchemaError, "No schema defined: #{schema_name}") if disabled_schemas.include?(schema_name.to_s)
+
       schema_config_path = config_paths(schema_name).find { |path| File.exist? path }
       raise(UndefinedSchemaError, "No schema defined: #{schema_name}") unless schema_config_path
 
@@ -157,14 +48,24 @@ module Hyrax
       config_search_paths.collect { |root_path| root_path.to_s + "/config/metadata/#{schema_name}.yaml" }
     end
 
-    def config_search_paths
-      Hyrax.config.simple_schema_loader_config_search_paths
-    end
-
     def metadata_files
       file_name_arr = []
       config_search_paths.each { |root_path| file_name_arr += Dir.entries(root_path.to_s + "/config/metadata/") }
-      file_name_arr.reject { |fn| !fn.include?('.yaml') }.uniq.map { |y| y.gsub('.yaml', '') }
+      file_name_arr
+        .reject { |fn| !fn.include?('.yaml') }
+        .uniq
+        .map { |y| y.gsub('.yaml', '') }
+        .reject { |schema_name| disabled_schemas.include?(schema_name) }
+    end
+
+    # Names of schemas in `config/metadata/` that the host app has not
+    # opted in to. {#metadata_files} skips them and {#schema_config}
+    # raises `UndefinedSchemaError` for them, so they behave as if the
+    # YAML did not exist.
+    def disabled_schemas
+      disabled = []
+      disabled << 'redirects' unless Hyrax.config.redirects_enabled?
+      disabled
     end
 
     def predicate_pairs(ret_hsh, schema_name)
@@ -179,10 +80,10 @@ module Hyrax
     end
 
     def multiple_predicate_message(name, existing, incoming)
-      message =  "The attribute of #{name} has been assigned a predicate multiple times " \
-                 "within the metadata YAMLs. Please be aware that once the attribute's " \
-                 "predicate value is first assigned, any other value will be ignored. " \
-                 "The existing value is #{existing} preventing the use of #{incoming}"
+      message = "The attribute of #{name} has been assigned a predicate multiple times " \
+        "within the metadata YAMLs. Please be aware that once the attribute's " \
+        "predicate value is first assigned, any other value will be ignored. " \
+        "The existing value is #{existing} preventing the use of #{incoming}"
       Hyrax.logger.warn(message)
     end
   end

data/app/services/hyrax/solr_service.rb

@@ -6,7 +6,7 @@ module Hyrax
   #
   # This class replaces `ActiveFedora::SolrService`, which is deprecated for
   # internal use.
-  class SolrService
+  class SolrService # rubocop:disable Metrics/ClassLength
     COMMIT_PARAMS = { softCommit: true }.freeze
 
     ##
@@ -39,7 +39,7 @@ module Hyrax
 
     def instance
       # Deprecation warning for calling from outside of the Hyrax::SolrService class
-      Deprecation.warn(self, rsolr_call_warning) unless caller[1].include?("#{self.class.name.underscore}.rb")
+      Deprecation.warn(rsolr_call_warning) unless caller[1].include?("#{self.class.name.underscore}.rb")
 
       @old_service.instance
     end
@@ -125,6 +125,43 @@ module Hyrax
       end
     end
 
+    # Pages through a caller-supplied Solr search, returning matching
+    # documents as a single Array. The block is yielded once with (0, 0) as
+    # a count probe, then once per page with (rows, start) where rows is
+    # bounded by Hyrax.config.solr_rows_per_request. Results are truncated
+    # to Hyrax.config.solr_max_results; when numFound exceeds the cap, a
+    # warning is logged and only the first solr_max_results docs are
+    # returned. The block must return a response object responding to
+    # +response['numFound']+ and +documents+.
+    #
+    # @return [Array] matching documents, truncated at solr_max_results
+    def self.fetch_all
+      rows_per_request = Hyrax.config.solr_rows_per_request
+      target = fetch_all_target(yield(0, 0))
+      return [] if target.zero?
+
+      documents = []
+      (0...target).step(rows_per_request) do |start|
+        rows = [rows_per_request, target - start].min
+        documents.concat(yield(rows, start).documents)
+      end
+      documents
+    end
+
+    # @api private
+    # Returns the number of documents to fetch, capped at
+    # Hyrax.config.solr_max_results. Logs a warning when truncating.
+    def self.fetch_all_target(count_response)
+      total = count_response.response['numFound'].to_i
+      max = Hyrax.config.solr_max_results
+      return total if total <= max
+
+      Hyrax.logger.warn("Hyrax::SolrService.fetch_all truncated: numFound=#{total} exceeds " \
+                        "Hyrax.config.solr_max_results=#{max}. Returning the first #{max} documents.")
+      max
+    end
+    private_class_method :fetch_all_target
+
     # Wraps rsolr :delete_by_query
     def delete_by_query(query, **args)
       connection.delete_by_query(query, params: args)

data/app/services/hyrax/tolerant_select_service.rb

@@ -6,10 +6,12 @@ module Hyrax
   class TolerantSelectService < QaSelectService
     ##
     # @return [Boolean] indicates whether the term is active;
-    #   false if the term is inactive or does not exist; defaults to true when
-    #   no key is given
+    #   false if the term is inactive or is not present in the authority;
+    #   defaults to true when the term is present but no `active:` key is given.
     def active?(id)
-      authority.find(id)&.fetch('active', true)
+      result = authority.find(id)
+      return false if result.blank?
+      result.fetch('active', true)
     end
 
     ##

data/app/services/hyrax/valkyrie_upload.rb

@@ -38,7 +38,7 @@ class Hyrax::ValkyrieUpload
     @file_set_file_service = file_set_file_service
   end
 
-  def upload(filename:, file_set:, io:, use: Hyrax::FileMetadata::Use::ORIGINAL_FILE, user: nil, mime_type: nil, skip_derivatives: false) # rubocop:disable Metrics/AbcSize
+  def upload(filename:, file_set:, io:, use: Hyrax::FileMetadata::Use::ORIGINAL_FILE, user: nil, mime_type: nil, skip_derivatives: false) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
     return version_upload(file_set: file_set, io: io, user: user) if use == Hyrax::FileMetadata::Use::ORIGINAL_FILE && file_set.original_file_id && storage_adapter.supports?(:versions)
     streamfile = storage_adapter.upload(file: io, original_filename: filename, resource: file_set)
     file_metadata = Hyrax::FileMetadata(streamfile)
@@ -50,7 +50,7 @@ class Hyrax::ValkyrieUpload
 
     if use == Hyrax::FileMetadata::Use::ORIGINAL_FILE
       # Set file set label.
-      reset_title = file_set.title.first == file_set.label
+      reset_title = (file_set.title.first == file_set.label || (file_set.title.blank? && file_set.label.blank?))
       # set title to label if that's how it was before this characterization
       file_set.title = file_metadata.original_filename if reset_title
       # always set the label to the original_name

data/app/services/hyrax/visibility_propagator.rb

@@ -13,7 +13,10 @@ module Hyrax
       when ActiveFedora::Base # ActiveFedora
         FileSetVisibilityPropagator.new(source: source)
       when Hyrax::Resource # Valkyrie
-        ResourceVisibilityPropagator.new(source: source)
+        # Due to performance issues for a Hyrax::Resource in Fedora 6,
+        # use a job that copies both permissions and visibility instead
+        # of reloading and iterating again.
+        ResourcePermissionsVisibilityPropagator.new(source: source)
       else
         NullVisibilityPropagator.new(source: source)
       end

data/app/services/hyrax/work_uploads_handler.rb

@@ -68,7 +68,9 @@ module Hyrax
     #   (for job retries). this is for legacy/AttachFilesToWorkJob
     #   compatibility, but could stand for a robust reimplementation.
     #
-    # @param [Enumberable<Hyrax::UploadedFile>] files  files to add
+    # @param [Enumerable<Hyrax::UploadedFile>] files  files to add
+    #
+    # @param [Enumerable<Hash>] file_set_params additional parameters for each file_set
     #
     # @return [WorkFileSetManager] self
     # @raise [ArgumentError] if any of the uploaded files are not an
@@ -76,21 +78,24 @@ module Hyrax
     def add(files:, file_set_params: [])
       validate_files(files) &&
         @files = Array.wrap(files).reject { |f| f.file_set_uri.present? }
-      @file_set_params = file_set_params
+      @file_set_params = file_set_params || []
       self
     end
 
     ##
     # @api public
     #
-    # Create filesets for each added file
+    # Create filesets for each added file, and add some additional metadata passed in file_set_params
+    # Additional metadata will only be set if it is not overriden by the `file_set_args` hash, and if it is a valid part of the schema
     #
     # @return [Boolean] true if all requested files were attached
     def attach
       return true if Array.wrap(files).empty? # short circuit to avoid aquiring a lock we won't use
 
       acquire_lock_for(work.id) do
-        event_payloads = files.each_with_object([]) { |file, arry| arry << make_file_set_and_ingest(file) }
+        event_payloads = files.each_with_object([]).with_index do |(file, arry), index|
+          arry << make_file_set_and_ingest(file, @file_set_params[index] || {})
+        end
         @persister.save(resource: work)
         Hyrax.publisher.publish('object.metadata.updated', object: work, user: files.first.user)
         event_payloads.each do |payload|
@@ -104,8 +109,8 @@ module Hyrax
 
     ##
     # @api private
-    def make_file_set_and_ingest(file)
-      file_set = @persister.save(resource: Hyrax::FileSet.new(file_set_args(file)))
+    def make_file_set_and_ingest(file, file_set_params = {})
+      file_set = @persister.save(resource: Hyrax.config.valkyrie_file_set_class.new(file_set_args(file, file_set_params)))
       Hyrax.publisher.publish('object.deposited', object: file_set, user: file.user)
       file.add_file_set!(file_set)
 
@@ -133,14 +138,17 @@ module Hyrax
     ##
     # @api private
     #
+    # @note the second hash overrides values in the first hash
+    #
+    #
     # @return [Hash{Symbol => Object}]
-    def file_set_args(file)
+    def file_set_args(file, file_set_params = {})
       { depositor: file.user.user_key,
-        creator: file.user.user_key,
+        creator: Array.wrap(file.user.user_key),
         date_uploaded: file.created_at,
         date_modified: Hyrax::TimeService.time_in_utc,
         label: file.uploader.filename,
-        title: file.uploader.filename }
+        title: Array.wrap(file.uploader.filename) }.merge(file_set_params)
     end
 
     ##

data/app/services/hyrax/workflow/workflow_factory.rb

@@ -50,9 +50,10 @@ module Hyrax
       private
 
       def create_workflow_entity!
-        Sipity::Entity.find_or_create_by!(proxy_for_global_id: Hyrax::GlobalID(work).to_s,
-                                          workflow: workflow_for(work),
-                                          workflow_state: nil)
+        entity = Sipity::Entity.find_by(proxy_for_global_id: Hyrax::GlobalID(work).to_s)
+        entity || Sipity::Entity.create!(proxy_for_global_id: Hyrax::GlobalID(work).to_s,
+                                         workflow: workflow_for(work),
+                                         workflow_state: nil)
       end
 
       def assign_specific_roles_to(entity:)
@@ -63,7 +64,7 @@ module Hyrax
       end
 
       def run_workflow_action!(action:)
-        subject = WorkflowActionInfo.new(work, user)
+        subject = Hyrax::WorkflowActionInfo.new(work, user)
         Workflow::WorkflowActionService.run(subject: subject,
                                             action: action)
       end

data/app/services/migrate_resource_service.rb

@@ -25,7 +25,13 @@ class MigrateResourceService
   end
 
   def resource_form
-    @resource_form ||= Hyrax::Forms::ResourceForm.for(resource: resource)
+    # needs to validate the form to prevent potential frozen errors in custom transaction steps
+    @resource_form ||= begin
+      form_params = resource.attributes.to_h.with_indifferent_access
+      form = Hyrax::Forms::ResourceForm.for(resource: resource)
+      form.validate(form_params)
+      form
+    end
   end
 
   def model_events(model)

data/app/uploaders/hyrax/uploaded_file_uploader.rb

@@ -4,11 +4,11 @@ module Hyrax
     # Override the directory where uploaded files will be stored.
     # This is a sensible default for uploaders that are meant to be mounted:
     def store_dir
-      (configured_upload_path / model.class.to_s.underscore / mounted_as.to_s / model.id.to_s).to_s
+      (configured_upload_path / model.class.name.underscore / mounted_as.to_s / model.id.to_s).to_s
     end
 
     def cache_dir
-      (configured_cache_path / model.class.to_s.underscore / mounted_as.to_s / model.id.to_s).to_s
+      (configured_cache_path / model.class.name.underscore / mounted_as.to_s / model.id.to_s).to_s
     end
 
     private

data/app/utils/hyrax/data_destroyers/collection_branding_destroyer.rb

@@ -20,7 +20,7 @@ module Hyrax
 
           logger.info("Destroying collection branding...")
 
-          Hyrax::CollectionBrandingInfo.destroy_all
+          CollectionBrandingInfo.destroy_all
           logger.info("   collection branding -- DESTROYED")
         end
       end

data/app/utils/hyrax/required_data_seeder.rb

@@ -14,6 +14,7 @@ module Hyrax
     end
 
     def generate_seed_data
+      Hyrax::RequiredDataSeeders::FlexibleProfileSeeder.generate_seeds(logger: logger) if Hyrax.config.flexible?
       Hyrax::RequiredDataSeeders::CollectionTypeSeeder.generate_seeds(logger: logger)
       Hyrax::RequiredDataSeeders::CollectionSeeder.generate_seeds(logger: logger)
     end

data/app/utils/hyrax/required_data_seeders/collection_type_seeder.rb

@@ -20,7 +20,7 @@ module Hyrax
           logger.info("   #{as_ct.title} -- FOUND OR CREATED")
 
           user_ct = Hyrax::CollectionType.find_or_create_default_collection_type
-          set_badge_color(user_ct, '#0099cc')
+          set_badge_color(user_ct, '#007EA8')
           logger.info("   #{user_ct.title} -- FOUND OR CREATED")
         end