bulkrax 9.1.0 → 9.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29af1006486f6d0a48b2ff2f9f0417ca1dd3fbf0cea791de156cf5e37ec19e53
-  data.tar.gz: b3f2d406e03c22e5ed6a7b2f1d075e1babbd46bf82c05fa96237e2fc56490fbc
+  metadata.gz: fb04fb1689c90c0cb7b96d0fbab95f371e4e4718509638812e62b0bffa1cc9e0
+  data.tar.gz: b3df0b413a151f7c49c6a39e07a705ec0e8c87d181a66de2a0ae75d567297f08
 SHA512:
-  metadata.gz: 43f29db766c379a8c1d5f03ec8584a0492cccdcdcc63b5cf2936fcf97ebd8115adcb8a104944ff082c2fc2e15691f104047a0396d74e00124e6f4eb22f33f71e
-  data.tar.gz: a7cbacf2d07dcd987bd7935485023d1a856dc0372ab2ef98f4cd0dc4c54297640ec8e401180dd2d366d69bbf469635881f589ae3b9a01ce5a4bb626b4e21dadb
+  metadata.gz: 89a766b0116729946c1ffba1252362fff3f29fd57ab774aebab39fa5b6f2b207a511de3da801b47bce7352a8ef2ca2e3811f306ca0f701ef592acd2a66103f34
+  data.tar.gz: b559f0441c55c23a64568d95d1bcb533dc5b11cf12c9ad8aaed3ab852a0f9ea88b1e9140968b6272af54d05d2edae3ff3dadb5433e07fa6c55d90e615f42447d

data/README.md

@@ -208,6 +208,32 @@ We encourage everyone to help improve this project.  Bug reports and pull reques
 
 This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](https://contributor-covenant.org) code of conduct.
 
+### Running tests
+- The tests use sqlite as the database, so no extra dependencies are required. 
+- Ensure you are using a supported version of Ruby (`ruby -v` should be greater or equal to 2.7) 
+- If you are using a ruby version earlier than 3.0.0, install bundler explicitly (newer versions of ruby will automatically install an appropriate bundler version)
+```bash
+/path/to/ruby/install/bin/gem install bundler -v '~> 2.4.0'
+```
+- Decide on your version of Hyrax to test against and export it to your environment, then bundle install. The Hyrax version should be greater or equal to 2.3.
+```bash
+export HYRAX_VERSION="~> 4.0.0"
+bundle install
+```
+- Run the test migrations
+```bash
+bundle exec bin/rails db:migrate RAILS_ENV=test
+```
+- Run the tests
+```bash
+bundle exec rspec
+```
+
+- Run the style checker / linter
+```bash
+bundle exec rubocop
+```
+
 ## Questions
 Questions can be sent to support@notch8.com. Please make sure to include "Bulkrax" in the subject line of your email.
 

data/app/assets/javascripts/bulkrax/importers.js.erb

@@ -15,7 +15,10 @@ function prepBulkrax(event) {
   // Initialize the uploader only if hyraxUploader is defined
   if (typeof $.fn.hyraxUploader === 'function') {
     // Initialize the uploader
-    $('.fileupload-bulkrax').hyraxUploader({ maxNumberOfFiles: 1 });
+    $('.fileupload-bulkrax').hyraxUploader({ 
+      maxNumberOfFiles: 1,
+      maxFileSize: <%= (defined?(Hyrax) && Hyrax.config.uploader[:maxFileSize]) || 524288000 %>
+    });
 
     // Function to toggle 'required' attribute based on uploaded files
     function toggleRequiredAttribute() {

data/app/factories/bulkrax/object_factory.rb

@@ -28,6 +28,40 @@ module Bulkrax
       resource.file_sets.each(&:update_index) if resource.respond_to?(:file_sets)
     end
 
+    ##
+    # @return [String] the name of the model class for the given resource/object.
+    def self.model_name(resource:)
+      resource.has_model.first
+    end
+
+    ##
+    # A thumbnail is linked to a work rather than the file set itself.
+    # @return [File or FileMetadata] the thumbnail file for the given resource
+    def self.thumbnail_for(resource:)
+      return nil unless resource.respond_to?(:thumbnail)
+      return resource.thumbnail if resource.thumbnail.present?
+      return nil unless resource.respond_to?(:parent) && resource.parent.present?
+      return nil unless resource.parent.respond_to?(:thumbnail)
+      resource.parent.thumbnail
+    end
+
+    ##
+    # @input [Fileset]
+    # @return [File] the original file.
+    def self.original_file(fileset:)
+      fileset.try(:original_file)
+    end
+
+    ##
+    # #input [Fileset or FileMetadata]
+    # @return [String] the file name for the given fileset
+    def self.filename_for(fileset:)
+      file = original_file(fileset: fileset)
+      file.file_name.first
+    rescue NoMethodError
+      nil
+    end
+
     ##
     # @see Bulkrax::ObjectFactoryInterface
     def self.export_properties
@@ -166,7 +200,7 @@ module Bulkrax
 
     def delete(_user)
       obj = find
-      return false unless obj
+      raise ObjectFactoryInterface::ObjectNotFoundError, "Object not found to delete" unless obj
 
       obj.delete(eradicate: true)
     end

data/app/factories/bulkrax/object_factory_interface.rb

@@ -209,6 +209,32 @@ module Bulkrax
     end
     # rubocop:enable Metrics/ParameterLists
 
+    ##
+    # @return [String] the name of the model class for the given resource/object.
+    def self.model_name(resource:)
+      raise NotImplementedError, "#{self}.#{__method__}"
+    end
+
+    ##
+    # @return [File or FileMetadata] the thumbnail file for the given resource
+    def self.thumbnail_for(resource:)
+      raise NotImplementedError, "#{self}.#{__method__}"
+    end
+
+    ##
+    # @input [Fileset or FileMetadata]
+    # @return [File or FileMetadata] the original file
+    def self.original_file(fileset:)
+      raise NotImplementedError, "#{self}.#{__method__}"
+    end
+
+    ##
+    # #input [Fileset or FileMetadata]
+    # @return [String] the file name for the given fileset
+    def self.filename_for(fileset:)
+      raise NotImplementedError, "#{self}.#{__method__}"
+    end
+
     ##
     # @api private
     #

data/app/factories/bulkrax/valkyrie_object_factory.rb

@@ -155,7 +155,7 @@ module Bulkrax
       Hyrax.query_service.find_by(id: id)
       # Because Hyrax is not a hard dependency, we need to transform the Hyrax exception into a
       # common exception so that callers can handle a generalize exception.
-    rescue Hyrax::ObjectNotFoundError => e
+    rescue Hyrax::ObjectNotFoundError, Valkyrie::Persistence::ObjectNotFoundError => e
       raise ObjectFactoryInterface::ObjectNotFoundError, e.message
     end
 
@@ -210,6 +210,46 @@ module Bulkrax
       update_index(resources: file_sets)
     end
 
+    ##
+    # If we always want the valkyrized resource name, even for unmigrated objects, we can
+    # simply use resource.model_name.name. At this point, we are differentiating
+    # to help identify items which have been migrated to Valkyrie vs those which have not.
+    #
+    # @return [String] the name of the model class for the given resource/object.
+    def self.model_name(resource:)
+      resource.class.to_s
+    end
+
+    ##
+    # @return [File or FileMetadata] the thumbnail file for the given resource
+    def self.thumbnail_for(resource:)
+      # recursive call to parent if resource is a fileset - we want the work's thumbnail
+      return thumbnail_for(resource: resource&.parent) if resource.is_a?(Bulkrax.file_model_class)
+
+      return nil unless resource.respond_to?(:thumbnail_id) && resource.thumbnail_id.present?
+      Bulkrax.object_factory.find(resource.thumbnail_id.to_s)
+    rescue Bulkrax::ObjectFactoryInterface::ObjectNotFoundError
+      nil
+    end
+
+    ##
+    # @input [Fileset or FileMetadata]
+    # @return [FileMetadata] the original file
+    def self.original_file(fileset:)
+      fileset.try(:original_file) || fileset
+    end
+
+    ##
+    # #input [Fileset or FileMetadata]
+    # @return [String] the file name for the given fileset
+    def self.filename_for(fileset:)
+      file = original_file(fileset: fileset)
+      return nil unless file
+      file.original_filename
+    rescue NoMethodError
+      nil
+    end
+
     ##
     # @param value [String]
     # @param klass [Class, #where]
@@ -252,7 +292,7 @@ module Bulkrax
 
     def delete(user)
       obj = find
-      return false unless obj
+      raise ObjectFactoryInterface::ObjectNotFoundError, "Object not found to delete" unless obj
 
       Hyrax.persister.delete(resource: obj)
       Hyrax.index_adapter.delete(resource: obj)
@@ -292,6 +332,7 @@ module Bulkrax
 
     def create_file_set(attrs)
       # TODO: Make it work for Valkyrie
+      raise NotImplementedError, __method__.to_s
     end
 
     def create_work(attrs)
@@ -381,7 +422,7 @@ module Bulkrax
     end
 
     def find_by_id
-      find(id: attributes[:id]) if attributes.key? :id
+      self.class.find(attributes[:id]) if attributes.key? :id
     end
 
     ##

data/app/jobs/bulkrax/delete_job.rb

@@ -6,6 +6,17 @@ module Bulkrax
 
     def perform(entry, importer_run)
       user = importer_run.importer.user
+
+      # When we delete, we don't go through the build process.
+      # However, we need the identifier to be set for the entry.
+      # This enables us to delete based on the ID, not just the source_identifier.
+      if entry.respond_to?(:build_metadata_for_delete) &&
+         entry.parsed_metadata.nil? &&
+         entry.raw_metadata.present?
+        entry.build_metadata_for_delete
+        entry.save!
+      end
+
       entry.factory.delete(user)
 
       # rubocop:disable Rails/SkipsModelValidations

data/app/models/bulkrax/csv_entry.rb

@@ -5,6 +5,23 @@ module Bulkrax
   # We do too much in these entry classes. We need to extract the common logic from the various
   # entry models into a module that can be shared between them.
   class CsvEntry < Entry # rubocop:disable Metrics/ClassLength
+    class CsvPathError < StandardError
+      def initialize(message)
+        super(message)
+      end
+    end
+
+    class RecordNotFound < StandardError
+      def initialize(message)
+        super(message)
+      end
+    end
+
+    class MissingMetadata < StandardError
+      def initialize(message)
+        super(message)
+      end
+    end
     serialize :raw_metadata, Bulkrax::NormalizedJson
 
     def self.fields_from_data(data)
@@ -16,7 +33,7 @@ module Bulkrax
     # there's a risk that this reads the whole file into memory and could cause a memory leak
     # we strip any special characters out of the headers. looking at you Excel
     def self.read_data(path)
-      raise StandardError, 'CSV path empty' if path.blank?
+      raise CsvPathError, 'CSV path empty' if path.blank?
       options = {
         headers: true,
         header_converters: ->(h) { h.to_s.gsub(/[^\w\d\. -]+/, '').strip.to_sym },
@@ -85,10 +102,18 @@ module Bulkrax
       self.parsed_metadata
     end
 
+    # limited metadata is needed for delete jobs
+    def build_metadata_for_delete
+      self.parsed_metadata = {}
+      establish_factory_class
+      add_ingested_metadata
+      self.parsed_metadata
+    end
+
     def validate_record
-      raise StandardError, 'Record not found' if record.nil?
+      raise RecordNotFound, 'Record not found' if record.nil?
       unless importerexporter.parser.required_elements?(record)
-        raise StandardError, "Missing required elements, missing element(s) are: "\
+        raise MissingMetadata, "Missing required elements, missing element(s) are: "\
 "#{importerexporter.parser.missing_elements(record).join(', ')}"
       end
     end
@@ -160,7 +185,7 @@ module Bulkrax
       source_id = source_id.to_a if source_id.is_a?(ActiveTriples::Relation)
       source_id = Array.wrap(source_id).first
       self.parsed_metadata[source_identifier] = source_id
-      model_name = hyrax_record.respond_to?(:to_rdf_representation) ? hyrax_record.to_rdf_representation : hyrax_record.has_model.first
+      model_name = Bulkrax.object_factory.model_name(resource: hyrax_record)
       self.parsed_metadata[key_for_export('model')] = model_name
     end
 
@@ -179,9 +204,13 @@ module Bulkrax
 
     def build_relationship_metadata
       # Includes all relationship methods for all exportable record types (works, Collections, FileSets)
+      # @TODO: this logic assumes that the relationships are all available via a method that can be called
+      #        on the object. With Valkyrie, this is only true for Hyrax-based models which include the
+      #        ArResource module. We need to consider reworking this logic into an object factory method
+      #        that can handle different types of models.
       relationship_methods = {
-        related_parents_parsed_mapping => %i[member_of_collection_ids member_of_work_ids in_work_ids],
-        related_children_parsed_mapping => %i[member_collection_ids member_work_ids file_set_ids]
+        related_parents_parsed_mapping => %i[member_of_collection_ids member_of_work_ids in_work_ids parent],
+        related_children_parsed_mapping => %i[member_collection_ids member_work_ids file_set_ids member_ids]
       }
 
       relationship_methods.each do |relationship_key, methods|
@@ -189,7 +218,9 @@ module Bulkrax
 
         values = []
         methods.each do |m|
-          values << hyrax_record.public_send(m) if hyrax_record.respond_to?(m)
+          value = hyrax_record.public_send(m) if hyrax_record.respond_to?(m)
+          value_id = value.try(:id)&.to_s || value # get the id if it's an object
+          values << value_id if value_id.present?
         end
         values = values.flatten.uniq
         next if values.blank?
@@ -316,11 +347,11 @@ module Bulkrax
 
     def build_thumbnail_files
       return unless importerexporter.include_thumbnails
+      thumbnail = Bulkrax.object_factory.thumbnail_for(resource: hyrax_record)
+      return unless thumbnail
 
+      filenames = map_file_sets(Array.wrap(thumbnail))
       thumbnail_mapping = 'thumbnail_file'
-      file_sets = Array.wrap(hyrax_record.thumbnail)
-
-      filenames = map_file_sets(file_sets)
       handle_join_on_export(thumbnail_mapping, filenames, false)
     end
 

data/app/models/concerns/bulkrax/export_behavior.rb

@@ -26,25 +26,38 @@ module Bulkrax
 
     # Prepend the file_set id to ensure a unique filename and also one that is not longer than 255 characters
     def filename(file_set)
-      return if file_set.original_file.blank?
-      if file_set.original_file.respond_to?(:original_filename) # valkyrie
-        fn = file_set.original_file.original_filename
-        mime = ::Marcel::MimeType.for(file_set.original_file.file.io)
-      else # original non valkyrie version
-        fn = file_set.original_file.file_name.first
-        mime = ::Marcel::MimeType.for(declared_type: file_set.original_file.mime_type)
-      end
-      ext_mime = ::Marcel::MimeType.for(name: fn)
+      # return if there are no files on the fileset
+      return if Bulkrax.object_factory.original_file(fileset: file_set).blank?
+
+      fn = Bulkrax.object_factory.filename_for(fileset: file_set)
+      file = Bulkrax.object_factory.original_file(fileset: file_set)
+      ext = file_extension(file: file, filename: fn)
+
+      # Prepend the file_set id to ensure a unique filename
+      filename = File.basename(fn, ".*")
+      # Skip modification if file already has ID or we're in metadata-only mode
       if fn.include?(file_set.id) || importerexporter.metadata_only?
-        filename = "#{fn}.#{mime.to_sym}"
-        filename = fn if mime.to_s == ext_mime.to_s
+        # keep filename as is
       else
-        filename = "#{file_set.id}_#{fn}.#{mime.to_sym}"
-        filename = "#{file_set.id}_#{fn}" if mime.to_s == ext_mime.to_s
+        filename = "#{file_set.id}_#{filename}"
       end
-      # Remove extention truncate and reattach
-      ext = File.extname(filename)
+      filename = ext.present? ? "#{filename}.#{ext}" : fn
+
+      # Remove extension, truncate and reattach
       "#{File.basename(filename, ext)[0...(220 - ext.length)]}#{ext}"
     end
+
+    ##
+    # Generate the appropriate file extension based on the mime type of the file
+    # @return [String] the file extension for the given file
+    def file_extension(file:, filename:)
+      declared_mime = ::Marcel::MimeType.for(declared_type: file.mime_type)
+      # validate the declared mime type
+      declared_mime = ::Marcel::MimeType.for(name: filename) if declared_mime.nil? || declared_mime == "application/octet-stream"
+      # convert the mime type to a file extension
+      Mime::Type.lookup(declared_mime).symbol.to_s
+    rescue Mime::Type::InvalidMimeType
+      nil
+    end
   end
 end

data/app/models/concerns/bulkrax/file_set_entry_behavior.rb

@@ -2,6 +2,15 @@
 
 module Bulkrax
   module FileSetEntryBehavior
+    class FileNameError < StandardError
+    end
+
+    class OrphanFileSetError < StandardError
+    end
+
+    class FilePathError < StandardError
+    end
+
     extend ActiveSupport::Concern
 
     included do
@@ -21,11 +30,11 @@ module Bulkrax
 
         path_to_file = parser.path_to_files(filename: filename)
 
-        parsed_metadata['file'][i] = path_to_file
+        parsed_metadata['file'][i] = path_to_file if path_to_file.present?
       end
       parsed_metadata['file'].delete('')
 
-      raise ::StandardError, "one or more file paths are invalid: #{parsed_metadata['file'].join(', ')}" unless parsed_metadata['file'].map { |file_path| ::File.file?(file_path) }.all?
+      raise FilePathError, "one or more file paths are invalid: #{parsed_metadata['file'].join(', ')}" unless parsed_metadata['file'].map { |file_path| ::File.file?(file_path) }.all?
 
       parsed_metadata['file']
     end
@@ -33,13 +42,13 @@ module Bulkrax
     def validate_presence_of_filename!
       return if parsed_metadata&.[](file_reference)&.map(&:present?)&.any?
 
-      raise StandardError, 'File set must have a filename'
+      raise FileNameError, 'File set must have a filename'
     end
 
     def validate_presence_of_parent!
       return if parsed_metadata[related_parents_parsed_mapping]&.map(&:present?)&.any?
 
-      raise StandardError, 'File set must be related to at least one work'
+      raise OrphanFileSetError, 'File set must be related to at least one work'
     end
 
     def parent_jobs

data/app/models/concerns/bulkrax/importer_exporter_behavior.rb

@@ -56,7 +56,7 @@ module Bulkrax
 
       returning_value = false
       File.open(filename) do |file|
-        mime_type = ::Marcel::MimeType.for(file)
+        mime_type = ::Marcel::MimeType.for(name: file)
         returning_value = mime_type.include?('application/zip') || mime_type.include?('application/gzip')
       end
       returning_value

data/app/parsers/bulkrax/application_parser.rb

@@ -209,8 +209,11 @@ module Bulkrax
     def rebuild_entries(types_array = nil)
       index = 0
       (types_array || %w[collection work file_set relationship]).each do |type|
-        # works are not gurneteed to have Work in the type
-
+        # works are not guaranteed to have Work in the type
+        if type.eql?('relationship')
+          ScheduleRelationshipsJob.set(wait: 5.minutes).perform_later(importer_id: importerexporter.id)
+          next
+        end
         importer.entries.where(rebuild_entry_query(type, parser_fields['entry_statuses'])).find_each do |e|
           seen[e.identifier] = true
           e.status_info('Pending', importer.current_run)

data/app/parsers/bulkrax/csv_parser.rb

@@ -38,7 +38,7 @@ module Bulkrax
             #       We aren't right now because so many Bulkrax users are in between Fedora and Valkyrie
             if model.casecmp('collection').zero? || model.casecmp('collectionresource').zero?
               @collections << r
-            elsif model.casecmp('fileset').zero?
+            elsif model.casecmp('fileset').zero? || model.casecmp('hyrax::fileset').zero?
               @file_sets << r
             else
               @works << r
@@ -248,14 +248,22 @@ module Bulkrax
       if file_sets.nil? # for valkyrie
         file_sets = record.respond_to?(:file_sets) ? record.file_sets : record.members&.select(&:file_set?)
       end
-      file_sets << record.thumbnail if exporter.include_thumbnails && record.thumbnail.present? && record.work?
+
+      if importerexporter.include_thumbnails?
+        thumbnail = Bulkrax.object_factory.thumbnail_for(resource: record)
+        file_sets << thumbnail if thumbnail.present?
+      end
+
       file_sets.each do |fs|
         path = File.join(exporter_export_path, folder_count, 'files')
         FileUtils.mkdir_p(path) unless File.exist? path
+
+        original_file = Bulkrax.object_factory.original_file(fileset: fs)
+        next if original_file.blank?
         file = filename(fs)
-        next if file.blank? || fs.original_file.blank?
 
-        io = fs.original_file.respond_to?(:uri) ? open(fs.original_file.uri) : fs.original_file.file.io
+        io = original_file.respond_to?(:uri) ? open(original_file.uri) : original_file.file.io
+
         File.open(File.join(path, file), 'wb') do |f|
           f.write(io.read)
           f.close
@@ -263,6 +271,8 @@ module Bulkrax
       end
     rescue Ldp::Gone
       return
+    rescue StandardError => e
+      raise StandardError, "Unable to retrieve files for identifier #{identifier} - #{e.message}"
     end
 
     def export_key_allowed(key)
@@ -372,6 +382,7 @@ module Bulkrax
 
       return @path_to_files if File.exist?(@path_to_files)
 
+      # TODO: This method silently returns nil if there is no file & no zip file
       File.join(importer_unzip_path, 'files', filename) if file? && zip?
     end
 

data/app/parsers/bulkrax/xml_parser.rb

@@ -103,7 +103,7 @@ module Bulkrax
     end
 
     def good_file_type?(path)
-      %w[.xml .xls .xsd].include?(File.extname(path)) || ::Marcel::MimeType.for(path).include?('application/xml')
+      %w[.xml .xls .xsd].include?(File.extname(path)) || ::Marcel::MimeType.for(path: path).include?('application/xml')
     end
 
     def total

data/app/services/bulkrax/factory_class_finder.rb

@@ -66,27 +66,68 @@ module Bulkrax
       entry.default_work_type.constantize
     end
 
+    private
+
     ##
     # @api private
     # @return [String]
     def name
-      fc = if entry.parsed_metadata&.[]('model').present?
-             Array.wrap(entry.parsed_metadata['model']).first
-           elsif entry.importerexporter&.mapping&.[]('work_type').present?
-             # Because of delegation's nil guard, we're reaching rather far into the implementation
-             # details.
-             Array.wrap(entry.parsed_metadata['work_type']).first
-           else
-             entry.default_work_type
-           end
-
-      # Let's coerce this into the right shape; we're not mutating the string because it might well
-      # be frozen.
-      fc = fc.tr(' ', '_')
-      fc = fc.downcase if fc.match?(/[-_]/)
-      fc.camelcase
+      # Try each strategy in order until one returns a value
+      fc = find_factory_class_name || entry.default_work_type
+
+      # Normalize the string format
+      normalize_class_name(fc)
     rescue
       entry.default_work_type
     end
+
+    ##
+    # Try each strategy in sequence to find a factory class name
+    # @return [String, nil] the factory class name or nil if none found
+    def find_factory_class_name
+      prioritized_strategies = [
+        :model_from_parsed_metadata,
+        :work_type_from_parsed_metadata,
+        :model_from_raw_metadata,
+        :model_from_mapped_field
+      ]
+
+      # Return the first non-nil result
+      prioritized_strategies.each do |strategy|
+        result = send(strategy)
+        return result if result.present?
+      end
+
+      nil
+    end
+
+    def model_from_parsed_metadata
+      Array.wrap(entry.parsed_metadata['model']).first if entry.parsed_metadata&.[]('model').present?
+    end
+
+    def work_type_from_parsed_metadata
+      Array.wrap(entry.parsed_metadata['work_type']).first if entry.importerexporter&.mapping&.[]('work_type').present?
+    end
+
+    def model_from_raw_metadata
+      Array.wrap(entry.raw_metadata&.[]('model'))&.first if entry.raw_metadata&.[]('model').present?
+    end
+
+    def model_from_mapped_field
+      return nil unless entry.parser.model_field_mappings.any? { |field| entry.raw_metadata&.[](field).present? }
+      field = entry.parser.model_field_mappings.find { |f| entry.raw_metadata&.[](f).present? }
+      Array.wrap(entry.raw_metadata[field]).first
+    end
+
+    ##
+    # Normalize a class name string to proper format
+    # @param name [String] the class name to normalize
+    # @return [String] the normalized class name
+    def normalize_class_name(name)
+      name = name.to_s
+      name = name.tr(' ', '_')
+      name = name.downcase if name.match?(/[-_]/)
+      name.camelcase
+    end
   end
 end

data/app/services/wings/custom_queries/find_by_source_identifier.rb

@@ -22,8 +22,14 @@ module Wings
         # NOTE: This is using the Bulkrax::ObjectFactory (e.g. the one envisioned for ActiveFedora).
         # In doing this, we avoid the situation where Bulkrax::ValkyrieObjectFactory calls this custom query.
 
-        # This is doing a solr search so we have to use the search_field instead of the property
-        af_object = Bulkrax::ObjectFactory.search_by_property(value: value, klass: ActiveFedora::Base, field: search_field)
+        # This is doing a solr search first, so we have to use the search_field instead of the property for "field"
+        # If it cannot find the object in Solr, it falls back to an ActiveFedora search, if the object is an ActiveFedora object
+        af_object = Bulkrax::ObjectFactory.search_by_property(
+          value: value,
+          klass: ActiveFedora::Base,
+          field: search_field,
+          name_field: property
+        )
 
         return if af_object.blank?
         return af_object unless use_valkyrie

data/app/views/bulkrax/entries/show.html.erb

@@ -34,18 +34,22 @@
     <p class='bulkrax-p-align'>
       <% if @importer.present? %>
 	    <%# TODO Consider how to account for Bulkrax.collection_model_class %>
-        <% factory_record = @entry.factory.find %>
-        <% if factory_record.present? %>
-          <% factory_record_class = factory_record.class %>
-          <% factory_record_class_human = factory_record_class.model_name.human %>
-          <strong><%= factory_record_class_human %> Link:</strong>
-          <% if defined?(Hyrax) && factory_record_class_human == 'Collection' %>
-            <%= link_to factory_record_class_human, hyrax.polymorphic_path(factory_record) %>
+        <% begin %>
+          <% factory_record = @entry.factory.find rescue nil %>
+          <% if factory_record.present? %>
+            <% factory_record_class = factory_record.class %>
+            <% factory_record_class_human = factory_record_class.model_name.human %>
+            <strong><%= factory_record_class_human %> Link:</strong>
+            <% if defined?(Hyrax) && factory_record_class_human == 'Collection' %>
+              <%= link_to factory_record_class_human, hyrax.polymorphic_path(factory_record) %>
+            <% else %>
+              <%= link_to factory_record_class_human, main_app.polymorphic_path(factory_record) %>
+            <% end %>
           <% else %>
-            <%= link_to factory_record_class_human, main_app.polymorphic_path(factory_record) %>
+            <strong>Item Link:</strong> Item has not yet been imported successfully
           <% end %>
-        <% else %>
-          <strong>Item Link:</strong> Item has not yet been imported successfully
+        <% rescue => e %>
+          <strong>Item Link:</strong> Unable to retrieve item (<%= e.message %>)
         <% end %>
       <% else %>
         <% record = @entry&.hyrax_record %>

data/lib/bulkrax/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bulkrax
-  VERSION = '9.1.0'
+  VERSION = '9.2.0'
 end

data/lib/bulkrax.rb

@@ -107,11 +107,8 @@ module Bulkrax
       # Hyrax::FileSet.try(:internal_resource) || 'hi'
       # => #<Dry::Types::Result::Failure input=:internal_resource error=...
       # ```
-      if collection_model_class.respond_to?(:internal_resource)
-        collection_model_class.internal_resource
-      else
-        collection_model_class.to_s
-      end
+      instance = collection_model_class.new
+      instance.respond_to?(:internal_resource) ? instance.internal_resource : collection_model_class.to_s
     end
 
     def file_model_class
@@ -130,11 +127,8 @@ module Bulkrax
       # Hyrax::FileSet.try(:internal_resource) || 'hi'
       # => #<Dry::Types::Result::Failure input=:internal_resource error=...
       # ```
-      if file_model_class.respond_to?(:internal_resource)
-        file_model_class.internal_resource
-      else
-        file_model_class.to_s
-      end
+      instance = file_model_class.new
+      instance.respond_to?(:internal_resource) ? instance.internal_resource : file_model_class.to_s
     end
 
     def curation_concerns
@@ -154,7 +148,8 @@ module Bulkrax
         # Hyrax::FileSet.try(:internal_resource) || 'hi'
         # => #<Dry::Types::Result::Failure input=:internal_resource error=...
         # ```
-        cc.respond_to?(:internal_resource) ? cc.internal_resource : cc.to_s
+        instance = cc.new
+        instance.respond_to?(:internal_resource) ? instance.internal_resource : cc.to_s
       end.uniq
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bulkrax
 version: !ruby/object:Gem::Version
-  version: 9.1.0
+  version: 9.2.0
 platform: ruby
 authors:
 - Rob Kaufman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-29 00:00:00.000000000 Z
+date: 2025-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.1.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.1.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: bagit
   requirement: !ruby/object:Gem::Requirement
@@ -345,7 +351,6 @@ files:
 - app/factories/bulkrax/object_factory.rb
 - app/factories/bulkrax/object_factory_interface.rb
 - app/factories/bulkrax/valkyrie_object_factory.rb
-- app/factories/bulkrax/valkyrize-hyku.code-workspace
 - app/helpers/bulkrax/application_helper.rb
 - app/helpers/bulkrax/exporters_helper.rb
 - app/helpers/bulkrax/importers_helper.rb

data/app/factories/bulkrax/valkyrize-hyku.code-workspace

@@ -1,19 +0,0 @@
-{
-  "folders": [
-    {
-      "path": "../../../../../hyku"
-    },
-    {
-      "path": "../../../../hyrax"
-    },
-    {
-      "path": "../../.."
-    },
-    {
-      "path": "../../../../iiif_print"
-    }
-  ],
-  "settings": {
-    "github.copilot.inlineSuggest.enable": true
-  }
-}