bulkrax 9.0.2 → 9.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab6b7a8920333f225336a80591a32f401aef2cfbe466d961c6f1f7a731757625
-  data.tar.gz: 6aa05fc7028e0f1a7f8eb40b2de8b23ba5108a254d0623bb9307a6dff2daf579
+  metadata.gz: 29af1006486f6d0a48b2ff2f9f0417ca1dd3fbf0cea791de156cf5e37ec19e53
+  data.tar.gz: b3f2d406e03c22e5ed6a7b2f1d075e1babbd46bf82c05fa96237e2fc56490fbc
 SHA512:
-  metadata.gz: 33fb1b5b369b6efcc535b80887c74e919e8b8b431b2199dbef35093319f58017d1bd34498d0c1c6df8c86f94eae4f117af2b88c2753eb0065db7630e8f480128
-  data.tar.gz: 214580d620b0c40edd3351ed315d041c86036a1453233a045b35b21991316aa9f1a397032d07d7d6a56a659aa871515c2e64535f238e02d8b591355c1b8f9760
+  metadata.gz: 43f29db766c379a8c1d5f03ec8584a0492cccdcdcc63b5cf2936fcf97ebd8115adcb8a104944ff082c2fc2e15691f104047a0396d74e00124e6f4eb22f33f71e
+  data.tar.gz: a7cbacf2d07dcd987bd7935485023d1a856dc0372ab2ef98f4cd0dc4c54297640ec8e401180dd2d366d69bbf469635881f589ae3b9a01ce5a4bb626b4e21dadb

data/app/assets/javascripts/bulkrax/datatables.js

@@ -3,6 +3,10 @@ Blacklight.onLoad(function() {
     $('#importer-show-table').DataTable( {
       'processing': true,
       'serverSide': true,
+      'width': '100%',
+      'autoWidth': false,
+      'scrollX': true,
+      'scrollCollapse': true,
       "ajax": window.location.href.replace(/(\/(importers|exporters)\/\d+)/, "$1/entry_table.json"),
       "pageLength": 30,
       "lengthMenu": [[30, 100, 200], [30, 100, 200]],
@@ -15,6 +19,14 @@ Blacklight.onLoad(function() {
         { "data": "errors", "orderable": false },
         { "data": "actions", "orderable": false }
       ],
+      drawCallback: function() {
+        // Remove the inline styles that DataTables adds to the scrollHeadInner and table elements
+        // it's not perfect but better than the style being applied
+        setTimeout(function() {
+          $('.dataTables_scrollHeadInner').removeAttr('style');
+          $('.table.table-striped.dataTable.no-footer').removeAttr('style');
+        }, 100);
+      },
       initComplete: function () {
         // Add entry class filter
         entrySelect.bind(this)()

data/app/factories/bulkrax/object_factory.rb

@@ -91,7 +91,7 @@ module Bulkrax
     # @note HEY WE'RE USING THIS FOR A WINGS CUSTOM QUERY.  BE CAREFUL WITH
     #       REMOVING IT.
     #
-    # @see # {Wings::CustomQueries::FindBySourceIdentifier#find_by_model_and_property_value}
+    # @see # {Wings::CustomQueries::FindBySourceIdentifier#find_by_property_value}
     def self.search_by_property(value:, klass:, field: nil, search_field: nil, name_field: nil, verify_property: false)
       return nil unless klass.respond_to?(:where)
       # We're not going to try to match nil nor "".

data/app/factories/bulkrax/valkyrie_object_factory.rb

@@ -38,12 +38,54 @@ module Bulkrax
       end
     end
 
+    # Customized create method for Valkyrie so that @object gets set
+    def create
+      attrs = transform_attributes
+      @object = klass.new
+      conditionally_set_reindex_extent
+      run_callbacks :save do
+        run_callbacks :create do
+          @object = if klass == Bulkrax.collection_model_class
+                      create_collection(attrs)
+                    elsif klass == Bulkrax.file_model_class
+                      create_file_set(attrs)
+                    else
+                      create_work(attrs)
+                    end
+        end
+      end
+
+      apply_depositor_metadata
+      log_created(@object)
+    end
+
+    # Customized update method for Valkyrie so that @object gets set
+    def update
+      raise "Object doesn't exist" unless object
+      conditionally_destroy_existing_files
+
+      attrs = transform_attributes(update: true)
+      run_callbacks :save do
+        @object = if klass == Bulkrax.collection_model_class
+                    update_collection(attrs)
+                  elsif klass == Bulkrax.file_model_class
+                    update_file_set(attrs)
+                  else
+                    update_work(attrs)
+                  end
+      end
+      apply_depositor_metadata
+      log_updated(@object)
+    end
+
     # TODO: the following module needs revisiting for Valkyrie work.
     #       proposal is to create Bulkrax::ValkyrieFileFactory.
     include Bulkrax::FileFactory
 
     self.file_set_factory_inner_workings_class = Bulkrax::ValkyrieObjectFactory::FileFactoryInnerWorkings
 
+    delegate :transactions, to: :class
+
     ##
     # When you want a different set of transactions you can change the
     # container.
@@ -55,24 +97,25 @@ module Bulkrax
       @transactions || Hyrax::Transactions::Container
     end
 
-    def transactions
-      self.class.transactions
-    end
-
     ##
     # @!group Class Method Interface
 
     ##
-    # @note This does not save either object.  We need to do that in another
-    #       loop.  Why?  Because we might be adding many items to the parent.
+    # When adding a child to a parent work, we save the parent.
+    # Locking appears inconsistent, so we are finding the parent and
+    # saving it with each child, but waiting until the end to reindex.
+    # To do this we are bypassing the save! method defined below
     def self.add_child_to_parent_work(parent:, child:)
+      parent = self.find(parent.id)
       return true if parent.member_ids.include?(child.id)
-
       parent.member_ids << child.id
-      parent.save
+      Hyrax.persister.save(resource: parent)
     end
 
+    ##
+    # The resource added to a collection can be either a work or another collection.
     def self.add_resource_to_collection(collection:, resource:, user:)
+      resource = self.find(resource.id)
       resource.member_of_collection_ids << collection.id
       save!(resource: resource, user: user)
     end
@@ -127,6 +170,8 @@ module Bulkrax
     end
 
     def self.publish(event:, **kwargs)
+      # It's a bit unclear what this should be if we can't rely on Hyrax.
+      raise NotImplementedError, "#{self}.#{__method__}" unless defined?(Hyrax)
       Hyrax.publisher.publish(event, **kwargs)
     end
 
@@ -139,19 +184,19 @@ module Bulkrax
     end
 
     def self.save!(resource:, user:)
-      if resource.respond_to?(:save!)
-        resource.save!
-      else
+      if defined?(Hyrax)
         result = Hyrax.persister.save(resource: resource)
         raise Valkyrie::Persistence::ObjectNotFoundError unless result
         Hyrax.index_adapter.save(resource: result)
         if result.collection?
-          publish('collection.metadata.updated', collection: result, user: user)
+          self.publish(event: 'collection.metadata.updated', collection: result, user: user)
         else
-          publish('object.metadata.updated', object: result, user: user)
+          self.publish(event: 'object.metadata.updated', object: result, user: user)
         end
-        resource
+      else
+        resource.save!
       end
+      resource
     end
 
     def self.update_index(resources:)
@@ -176,13 +221,12 @@ module Bulkrax
     # @return [Valkyrie::Resource] when a match is found, an instance of given
     #         :klass
     # rubocop:disable Metrics/ParameterLists
-    def self.search_by_property(value:, klass:, field: nil, name_field: nil, **)
+    def self.search_by_property(value:, field: nil, name_field: nil, search_field:, **)
       name_field ||= field
       raise "Expected named_field or field got nil" if name_field.blank?
       return if value.blank?
-
       # Return nil or a single object.
-      Hyrax.query_service.custom_query.find_by_model_and_property_value(model: klass, property: name_field, value: value)
+      Hyrax.query_service.custom_queries.find_by_property_value(property: name_field, value: value, search_field: search_field)
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -212,7 +256,7 @@ module Bulkrax
 
       Hyrax.persister.delete(resource: obj)
       Hyrax.index_adapter.delete(resource: obj)
-      self.class.publish(event: 'object.deleted', object: obj, user: user)
+      Hyrax.publisher.publish('object.deleted', object: obj, user: user)
     end
 
     def run!
@@ -231,7 +275,7 @@ module Bulkrax
 
       @object.depositor = @user.email
       object = Hyrax.persister.save(resource: @object)
-      self.class.publish(event: "object.metadata.updated", object: object, user: @user)
+      Hyrax.publisher.publish("object.metadata.updated", object: object, user: @user)
       object
     end
 
@@ -337,7 +381,7 @@ module Bulkrax
     end
 
     def find_by_id
-      Hyrax.query_service.find_by(id: attributes[:id]) if attributes.key? :id
+      find(id: attributes[:id]) if attributes.key? :id
     end
 
     ##
@@ -433,7 +477,6 @@ module Bulkrax
       remote_files.map do |r|
         file_path = download_file(r["url"])
         next unless file_path
-
         create_uploaded_file(file_path, r["file_name"])
       end.compact
     end
@@ -449,8 +492,7 @@ module Bulkrax
         file.rewind
         file.path
       rescue => e
-        Rails.logger.debug "Failed to download file from #{url}: #{e.message}"
-        nil
+        raise "Failed to download file from #{url}: #{e.message}"
       end
     end
 
@@ -460,8 +502,7 @@ module Bulkrax
       file.close
       uploaded_file
     rescue => e
-      Rails.logger.debug "Failed to create Hyrax::UploadedFile for #{file_name}: #{e.message}"
-      nil
+      raise "Failed to create Hyrax::UploadedFile for #{file_name}: #{e.message}"
     end
 
     # @Override Destroy existing files with Hyrax::Transactions

data/app/jobs/bulkrax/create_relationships_job.rb

@@ -44,7 +44,7 @@ module Bulkrax
 
     queue_as Bulkrax.config.ingest_queue_name
 
-    attr_accessor :user, :importer_run, :errors
+    attr_accessor :user, :importer_run, :errors, :importer_run_id, :ability, :number_of_successes, :number_of_failures
     ##
     # @param parent_identifier [String] Work/Collection ID or Bulkrax::Entry source_identifiers
     # @param importer_run [Bulkrax::ImporterRun] current importer run (needed to properly update counters)
@@ -57,72 +57,52 @@ module Bulkrax
     #
     # rubocop:disable Metrics/MethodLength
     def perform(parent_identifier:, importer_run_id: nil, run_user: nil, failure_count: 0) # rubocop:disable Metrics/AbcSize
-      importer_run = Bulkrax::ImporterRun.find(importer_run_id) if importer_run_id
-      user = run_user || importer_run&.user
-      ability = Ability.new(user)
-
-      parent_entry, parent_record = find_record(parent_identifier, importer_run_id)
-
-      number_of_successes = 0
-      number_of_failures = 0
-      errors = []
+      @importer_run_id = importer_run_id
+      @importer_run = Bulkrax::ImporterRun.find(@importer_run_id) if @importer_run_id
+      @user = run_user || importer_run&.user
+      @ability = Ability.new(@user)
+
+      @number_of_successes = 0
+      @number_of_failures = 0
+      @errors = []
       @parent_record_members_added = false
-      @child_members_added = []
 
+      parent_entry, parent_record = find_record(parent_identifier, @importer_run_id)
       if parent_record
-        conditionally_acquire_lock_for(parent_record.id) do
-          ActiveRecord::Base.uncached do
-            Bulkrax::PendingRelationship.where(parent_id: parent_identifier)
-                                        .ordered.find_each do |rel|
-              process(relationship: rel, importer_run_id: importer_run_id, parent_record: parent_record, ability: ability)
-              number_of_successes += 1
-              @parent_record_members_added = true
-            rescue => e
-              number_of_failures += 1
-              rel.set_status_info(e, importer_run)
-              errors << e
-            end
-          end
-
-          # save record if members were added
-          if @parent_record_members_added
-            Bulkrax.object_factory.save!(resource: parent_record, user: user)
-            Bulkrax.object_factory.publish(event: 'object.membership.updated', object: parent_record)
-            Bulkrax.object_factory.update_index(resources: @child_members_added)
-          end
+        # Works and collections are different breeds of animals:
+        # - works know both their children (file_sets and child works) in member_ids
+        # - works and collections know their parents (collections) in member_of_collection_ids
+        # We need to handle the two differently by locking the records appropriately to avoid race condition errors.
+        if parent_record.is_a?(Bulkrax.collection_model_class)
+          process_parent_as_collection(parent_record: parent_record, parent_identifier: parent_identifier)
+        else
+          process_parent_as_work(parent_record: parent_record, parent_identifier: parent_identifier)
         end
       else
-        # In moving the check of the parent record "up" we've exposed a hidden reporting foible.
-        # Namely we were reporting one error per child record when the parent record was itself
-        # unavailable.
-        #
-        # We have chosen not to duplicate that "number of errors" as it does not seem like the
-        # correct pattern for reporting a singular error (the previous pattern being one error per
-        # child who's parent is not yet created).
-        number_of_failures = 1
-        errors = ["Parent record not yet available for creating relationships with children records."]
+        @number_of_failures = 1
+        @errors = ["Parent record #{parent_identifier} not yet available for creating relationships with children records."]
       end
 
-      if errors.present?
+      if @errors.present?
         # rubocop:disable Rails/SkipsModelValidations
-        ImporterRun.update_counters(importer_run_id, failed_relationships: number_of_failures)
+        ImporterRun.update_counters(@importer_run_id, failed_relationships: @number_of_failures)
         # rubocop:enable Rails/SkipsModelValidations
 
-        parent_entry&.set_status_info(errors.last, importer_run)
+        parent_entry&.set_status_info(@errors.last, importer_run)
         failure_count += 1
 
         if failure_count < max_failure_count
           reschedule(
             parent_identifier: parent_identifier,
-            importer_run_id: importer_run_id,
-            run_user: run_user,
+            importer_run_id: @importer_run_id,
+            run_user: @user,
             failure_count: failure_count
           )
         end
-        return errors # stop current job from continuing to run after rescheduling
+        return @errors # stop current job from continuing to run after rescheduling
       else
         # rubocop:disable Rails/SkipsModelValidations
-        ImporterRun.update_counters(importer_run_id, processed_relationships: number_of_successes)
+        ImporterRun.update_counters(@importer_run_id, processed_relationships: @number_of_successes)
         # rubocop:enable Rails/SkipsModelValidations
       end
     end
@@ -132,6 +112,8 @@ module Bulkrax
 
     ##
     # We can use Hyrax's lock manager when we have one available.
+    # However it's not certain that this is actually working, so to be
+    # as safe as possible, we will reload resources before we update.
     if defined?(::Hyrax)
       include Hyrax::Lockable
 
@@ -151,46 +133,111 @@ module Bulkrax
       alias conditionally_acquire_lock_for acquire_lock_for
     end
 
-    def process(relationship:, importer_run_id:, parent_record:, ability:)
-      raise "#{relationship} needs a child to create relationship" if relationship.child_id.nil?
-      raise "#{relationship} needs a parent to create relationship" if relationship.parent_id.nil?
-
-      _child_entry, child_record = find_record(relationship.child_id, importer_run_id)
-      raise "#{relationship} could not find child record" unless child_record
-
-      raise "Cannot add child collection (ID=#{relationship.child_id}) to parent work (ID=#{relationship.parent_id})" if child_record.collection? && parent_record.work?
+    # When the parent is a collection, we save the relationship on each child.
+    # The parent does not need to be saved, as the relationship is stored on the child.
+    # but we do reindex the parent after all the children are added.
+    def process_parent_as_collection(parent_record:, parent_identifier:)
+      ActiveRecord::Base.uncached do
+        Bulkrax::PendingRelationship.where(parent_id: parent_identifier, importer_run_id: @importer_run_id)
+                                    .ordered.find_each do |rel|
+          raise "#{rel} needs a child to create relationship" if rel.child_id.nil?
+          raise "#{rel} needs a parent to create relationship" if rel.parent_id.nil?
+          add_to_collection(relationship: rel, parent_record: parent_record, ability: ability)
+          @number_of_successes += 1
+          @parent_record_members_added = true
+        rescue => e
+          rel.update(status_message: e.message)
+          @number_of_failures += 1
+          @errors << e
+        end
+      end
 
-      ability.authorize!(:edit, child_record)
+      # if collection members were added, we reindex the collection
+      # The collection members have already saved the relationships
+      # To index the parent, we want to make sure we have the latest version of the parent,
+      # because another job may have updated it in the meantime.
+      return unless @parent_record_members_added
+      reloaded_parent = Bulkrax.object_factory.find(parent_record.id)
+      Bulkrax.object_factory.update_index(resources: [reloaded_parent])
+      Bulkrax.object_factory.publish(event: 'object.membership.updated', object: reloaded_parent, user: @user)
+    end
 
-      # We could do this outside of the loop, but that could lead to odd counter failures.
-      ability.authorize!(:edit, parent_record)
+    # When the parent is a work, we save the relationship on the parent.
+    # We prefer to save all of the member relationships and then save the parent once. Concurrent
+    # jobs may be trying to save the parent at the same time, so we need to lock the parent
+    # record while we are adding the children to it.
+    # However the locking appears to not be working so as a workaround we will save each member as we go,
+    # but only index the parent once at the end.
+    def process_parent_as_work(parent_record:, parent_identifier:)
+      conditionally_acquire_lock_for(parent_record.id.to_s) do
+        ActiveRecord::Base.uncached do
+          Bulkrax::PendingRelationship.where(parent_id: parent_identifier, importer_run_id: @importer_run_id)
+                                      .ordered.find_each do |rel|
+            raise "#{rel} needs a child to create relationship" if rel.child_id.nil?
+            raise "#{rel} needs a parent to create relationship" if rel.parent_id.nil?
+            add_to_work(relationship: rel, parent_record: parent_record, ability: ability)
+            self.number_of_successes += 1
+            @parent_record_members_added = true
+          rescue => e
+            rel.update(status_message: e.message)
+            @number_of_failures += 1
+            @errors << e
+          end
+        end
 
-      if parent_record.is_a?(Bulkrax.collection_model_class)
-        add_to_collection(child_record, parent_record)
-      else
-        add_to_work(child_record, parent_record)
+        # save record if members were added
+        if @parent_record_members_added
+          reloaded_parent = Bulkrax.object_factory.find(parent_record.id)
+          Bulkrax.object_factory.update_index(resources: [reloaded_parent])
+          Bulkrax.object_factory.publish(event: 'object.membership.updated', object: reloaded_parent, user: @user)
+        end
       end
-
-      Bulkrax.object_factory.update_index_for_file_sets_of(resource: child_record) if update_child_records_works_file_sets?
-
-      relationship.destroy
     end
 
-    def add_to_collection(child_record, parent_record)
-      Bulkrax.object_factory.add_resource_to_collection(
-        collection: parent_record,
-        resource: child_record,
-        user: user
-      )
+    # NOTE: the child changes are saved in the object factory.
+    def add_to_collection(relationship:, parent_record:, ability:)
+      ActiveRecord::Base.uncached do
+        _child_entry, child_record = find_record(relationship.child_id, @importer_run_id)
+        raise "#{relationship} could not find child record" unless child_record
+        raise "Cannot add child collection (ID=#{relationship.child_id}) to parent work (ID=#{relationship.parent_id})" if child_record.collection? && parent_record.work?
+        ability.authorize!(:edit, child_record)
+        # We could do this outside of the loop, but that could lead to odd counter failures.
+        ability.authorize!(:edit, parent_record)
+        # It is important to lock the child records as they are the ones being saved.
+        # However, locking doesn't seem to be working so we will reload the child record before saving.
+        # This is a workaround for the fact that the lock manager doesn't seem to be working.
+        conditionally_acquire_lock_for(child_record.id.to_s) do
+          Bulkrax.object_factory.add_resource_to_collection(
+            collection: parent_record,
+            resource: child_record,
+            user: @user
+          )
+        end
+        relationship.destroy
+      end
     end
 
-    def add_to_work(child_record, parent_record)
-      # NOTE: The .add_child_to_parent_work should not persist changes to the
-      #       child nor parent.  We'll do that elsewhere in this loop.
-      Bulkrax.object_factory.add_child_to_parent_work(
+    # NOTE: we only update the parent's member_ids and prefer to not save the parent until all children are added.
+    # However, the locking appears to be working so as a workaround we will save each member as we go.
+    # This is a workaround for the fact that the lock manager doesn't seem to be working.
+    # To avoid having to reload the parent, we return the updated parent to the calling method.
+    def add_to_work(relationship:, parent_record:, ability:)
+      _child_entry, child_record = find_record(relationship.child_id, @importer_run_id)
+      raise "#{relationship} could not find child record" unless child_record
+      raise "Cannot add child collection (ID=#{relationship.child_id}) to parent work (ID=#{relationship.parent_id})" if child_record.collection? && parent_record.work?
+
+      ability.authorize!(:edit, child_record)
+      # We could do this outside of the loop, but that could lead to odd counter failures.
+      ability.authorize!(:edit, parent_record)
+      updated_parent = Bulkrax.object_factory.add_child_to_parent_work(
         parent: parent_record,
         child: child_record
       )
+      # default is false for this... do not typically need to index file sets of child records
+      Bulkrax.object_factory.update_index_for_file_sets_of(resource: child_record) if update_child_records_works_file_sets?
+      relationship.destroy
+
+      updated_parent
     end
 
     def reschedule(**kargs)

data/app/jobs/bulkrax/importer_job.rb

@@ -30,6 +30,7 @@ module Bulkrax
       return unless parser.file? && parser.zip?
 
       parser.unzip(parser.parser_fields['import_file_path'])
+      parser.remove_spaces_from_filenames
     end
 
     def update_current_run_counters(importer)

data/app/matchers/bulkrax/application_matcher.rb

@@ -16,8 +16,9 @@ module Bulkrax
 
     def result(_parser, content)
       return nil if self.excluded == true || Bulkrax.reserved_properties.include?(self.to)
+      # rubocop:disable Style/RedundantParentheses
       return nil if self.if && (!self.if.is_a?(Array) && self.if.length != 2)
-
+      # rubocop:enable Style/RedundantParentheses
       if self.if
         return unless content.send(self.if[0], Regexp.new(self.if[1]))
       end

data/app/models/bulkrax/importer.rb

@@ -237,8 +237,16 @@ module Bulkrax
     # end
 
     # If the import data is zipped, unzip it to this path
-    def importer_unzip_path
+    def importer_unzip_path(mkdir: false)
       @importer_unzip_path ||= File.join(parser.base_path, "import_#{path_string}")
+      return @importer_unzip_path if Dir.exist?(@importer_unzip_path) || mkdir == true
+
+      # turns "tmp/imports/tenant/import_1_20250122035229_1" to "tmp/imports/tenant/import_1_20250122035229"
+      base_importer_unzip_path = @importer_unzip_path.split('_')[0...-1].join('_')
+
+      # If we don't have an existing unzip path, we'll try and find it.
+      # Just in case there are multiple paths, we sort by the number at the end of the path and get the last one
+      @importer_unzip_path = Dir.glob(base_importer_unzip_path + '*').sort_by { |path| path.split(base_importer_unzip_path).last[1..-1].to_i }.last
     end
 
     def errored_entries_csv_path

data/app/models/bulkrax/status.rb

@@ -23,7 +23,7 @@ module Bulkrax
     end
 
     def latest?
-      # TODO: remove if statment when we stop supporting Hyrax < 4
+      # TODO: remove if statement when we stop supporting Hyrax < 4
       self.id == if Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('6.0.0')
                    self.class.where(statusable_id: self.statusable_id, statusable_type: self.statusable_type).order('id desc').pick(:id)
                  else

data/app/parsers/bulkrax/application_parser.rb

@@ -432,7 +432,7 @@ module Bulkrax
 
       Zip::File.open(file_to_unzip) do |zip_file|
         zip_file.each do |entry|
-          entry_path = File.join(importer_unzip_path, entry.name)
+          entry_path = File.join(importer_unzip_path(mkdir: true), entry.name)
           FileUtils.mkdir_p(File.dirname(entry_path))
           zip_file.extract(entry, entry_path) unless File.exist?(entry_path)
         end
@@ -440,12 +440,27 @@ module Bulkrax
     end
 
     def untar(file_to_untar)
-      Dir.mkdir(importer_unzip_path) unless File.directory?(importer_unzip_path)
+      Dir.mkdir(importer_unzip_path(mkdir: true)) unless File.directory?(importer_unzip_path(mkdir: true))
       command = "tar -xzf #{Shellwords.escape(file_to_untar)} -C #{Shellwords.escape(importer_unzip_path)}"
       result = system(command)
       raise "Failed to extract #{file_to_untar}" unless result
     end
 
+    # File names referenced in CSVs have spaces replaced with underscores
+    # @see Bulkrax::CsvParser#file_paths
+    def remove_spaces_from_filenames
+      files = Dir.glob(File.join(importer_unzip_path, 'files', '*'))
+      files_with_spaces = files.select { |f| f.split('/').last.match?(' ') }
+      return if files_with_spaces.blank?
+
+      files_with_spaces.map! { |path| Pathname.new(path) }
+      files_with_spaces.each do |path|
+        filename = path.basename
+        filename_without_spaces = filename.to_s.tr(' ', '_')
+        path.rename(File.join(path.dirname, filename_without_spaces))
+      end
+    end
+
     def zip
       FileUtils.mkdir_p(exporter_export_zip_path)
 

data/app/parsers/bulkrax/csv_parser.rb

@@ -341,7 +341,16 @@ module Bulkrax
         file_mapping = Bulkrax.field_mappings.dig(self.class.to_s, 'file', :from)&.first&.to_sym || :file
         next if r[file_mapping].blank?
 
-        r[file_mapping].split(Bulkrax.multi_value_element_split_on).map do |f|
+        split_value = Bulkrax.field_mappings.dig(self.class.to_s, :file, :split)
+        split_pattern = case split_value
+                        when Regexp
+                          split_value
+                        when String
+                          Regexp.new(split_value)
+                        else
+                          Bulkrax.multi_value_element_split_on
+                        end
+        r[file_mapping].split(split_pattern).map do |f|
           file = File.join(path_to_files, f.tr(' ', '_'))
           if File.exist?(file) # rubocop:disable Style/GuardClause
             file
@@ -360,6 +369,10 @@ module Bulkrax
       @path_to_files = File.join(
           zip? ? importer_unzip_path : File.dirname(import_file_path), 'files', filename
         )
+
+      return @path_to_files if File.exist?(@path_to_files)
+
+      File.join(importer_unzip_path, 'files', filename) if file? && zip?
     end
 
     private
@@ -379,9 +392,15 @@ module Bulkrax
     # We expect a single CSV at the top level of the zip in the CSVParser
     # but we are willing to go look for it if need be
     def real_import_file_path
-      return Dir["#{importer_unzip_path}/**/*.csv"].first if file? && zip?
+      return Dir["#{importer_unzip_path}/**/*.csv"].reject { |path| in_files_dir?(path) }.first if file? && zip?
 
       parser_fields['import_file_path']
     end
+
+    # If there are CSVs that are meant to be attachments in the files directory,
+    # we don't want to consider them as the import CSV
+    def in_files_dir?(path)
+      File.dirname(path).ends_with?('files')
+    end
   end
 end

data/app/parsers/bulkrax/oai_dc_parser.rb

@@ -61,8 +61,6 @@ module Bulkrax
       ['contributor', 'coverage', 'creator', 'date', 'description', 'format', 'identifier', 'language', 'publisher', 'relation', 'rights', 'source', 'subject', 'title', 'type']
     end
 
-    delegate :list_sets, to: :client
-
     def create_objects(types = [])
       types.each do |object_type|
         send("create_#{object_type.pluralize}")

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

@@ -6,7 +6,7 @@ module Hyrax
     # @see https://github.com/samvera/valkyrie/wiki/Queries#custom-queries
     class FindBySourceIdentifier
       def self.queries
-        [:find_by_model_and_property_value]
+        [:find_by_property_value]
       end
 
       def initialize(query_service:)
@@ -18,30 +18,25 @@ module Hyrax
       delegate :orm_class, to: :resource_factory
 
       ##
-      # @param model [Class, #internal_resource]
       # @param property [#to_s] the name of the property we're attempting to
       #        query.
       # @param value [#to_s] the propety's value that we're trying to match.
       #
       # @return [NilClass] when no record was found
       # @return [Valkyrie::Resource] when a record was found
-      #
-      # @note This is not a real estate transaction nor a Zillow lookup.
-      def find_by_model_and_property_value(model:, property:, value:)
-        sql_query = sql_for_find_by_model_and_property_value
-        # NOTE: Do we need to ask the model for it's internal_resource?
-        # TODO: no => undefined method `internal_resource' for Image:Class
-        query_service.run_query(sql_query, model, property, value).first
+      def find_by_property_value(property:, value:, **)
+        sql_query = sql_for_find_by_property_value
+        query_service.run_query(sql_query, property, value.to_s).first
       end
 
       private
 
-      def sql_for_find_by_model_and_property_value
+      def sql_for_find_by_property_value
         # NOTE: This is querying the first element of the property, but we might
         # want to check all of the elements.
         <<-SQL
           SELECT * FROM orm_resources
-          WHERE internal_resource = ? AND metadata -> ? ->> 0 = ?
+          WHERE metadata -> ? ->> 0 = ?
           LIMIT 1;
         SQL
       end

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

@@ -6,7 +6,7 @@ module Wings
       # Custom query override specific to Wings
 
       def self.queries
-        [:find_by_model_and_property_value]
+        [:find_by_property_value]
       end
 
       attr_reader :query_service
@@ -16,11 +16,14 @@ module Wings
         @query_service = query_service
       end
 
-      def find_by_model_and_property_value(model:, property:, value:, use_valkyrie: Hyrax.config.use_valkyrie?)
-        # 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.
-        af_object = Bulkrax::ObjectFactory.search_by_property(value: value, klass: model, field: property)
+      # rubocop:disable Lint/UnusedMethodArgument
+      def find_by_property_value(property:, value:, search_field:, use_valkyrie: Hyrax.config.use_valkyrie?)
+        # rubocop:enable Lint/UnusedMethodArgument
+        # 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)
 
         return if af_object.blank?
         return af_object unless use_valkyrie

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

@@ -33,14 +33,16 @@
 
     <p class='bulkrax-p-align'>
       <% if @importer.present? %>
-	<%# TODO Consider how to account for Bulkrax.collection_model_class %>
+	    <%# TODO Consider how to account for Bulkrax.collection_model_class %>
         <% factory_record = @entry.factory.find %>
-        <% if factory_record.present? && @entry.factory_class %>
-          <strong><%= @entry.factory_class.model_name.human %> Link:</strong>
-          <% if defined?(Hyrax) && @entry.factory_class.model_name.human == 'Collection' %>
-            <%= link_to @entry.factory_class.model_name.human, hyrax.polymorphic_path(factory_record) %>
+        <% 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 @entry.factory_class.model_name.human, main_app.polymorphic_path(factory_record) %>
+            <%= link_to factory_record_class_human, main_app.polymorphic_path(factory_record) %>
           <% end %>
         <% else %>
           <strong>Item Link:</strong> Item has not yet been imported successfully

data/app/views/bulkrax/importers/_bagit_fields.html.erb

@@ -35,7 +35,7 @@
           input_html: { class: 'form-control' } ,
           required: false
           %>
-    <%= fi.input :override_rights_statement, as: :boolean, hint: 'If checked, always use the selected rights statment. If unchecked, use rights or rights_statement from the record and only use the provided value if dc:rights is blank.', input_html: { checked: (importer.parser_fields['override_rights_statement'] == "1") } %>
+    <%= fi.input :override_rights_statement, as: :boolean, hint: 'If checked, always use the selected rights statement. If unchecked, use rights or rights_statement from the record and only use the provided value if dc:rights is blank.', input_html: { checked: (importer.parser_fields['override_rights_statement'] == "1") } %>
   <% end %>
   <h4>Bag or Bags to Import:</h4>
   <p>File upload and Cloud File upload must be a Zip file containing a single BagIt Bag, or a folder containing multiple BagIt Bags.</p>

data/app/views/bulkrax/importers/_csv_fields.html.erb

@@ -20,7 +20,7 @@
           input_html: { class: 'form-control' },
           required: false
           %>
-    <%= fi.input :override_rights_statement, as: :boolean, hint: 'If checked, always use the selected rights statment. If unchecked, use rights or rights_statement from the record and only use the provided value if dc:rights is blank.', input_html: { checked: (importer.parser_fields['override_rights_statement'] == "1") } %>
+    <%= fi.input :override_rights_statement, as: :boolean, hint: 'If checked, always use the selected rights statement. If unchecked, use rights or rights_statement from the record and only use the provided value if dc:rights is blank.', input_html: { checked: (importer.parser_fields['override_rights_statement'] == "1") } %>
   <% end %>
   <h4>Add CSV or ZIP File to Import:</h4>
   <%# accept a single file upload; data files and bags will need to be added another way %>

data/app/views/bulkrax/importers/_oai_fields.html.erb

@@ -26,7 +26,7 @@
           input_html: { class: 'form-control' },
           required: false
           %>
-    <%= fi.input :override_rights_statement, as: :boolean, hint: 'If checked, always use the selected rights statment. If unchecked, use dc:rights from the record and only use the provided value if dc:rights is blank.', input_html: { checked: (importer.parser_fields['override_rights_statement'] == "1") } %>
+    <%= fi.input :override_rights_statement, as: :boolean, hint: 'If checked, always use the selected rights statement. If unchecked, use dc:rights from the record and only use the provided value if dc:rights is blank.', input_html: { checked: (importer.parser_fields['override_rights_statement'] == "1") } %>
   <% end %>
   <%= fi.input :thumbnail_url, required: false, as: :string, input_html: { value: importer.parser_fields['thumbnail_url'] } %>
   <div class="help-block well well-sm">

data/app/views/bulkrax/importers/_xml_fields.html.erb

@@ -41,7 +41,7 @@
           item_helper: rights_statements.method(:include_current_value),
           input_html: { class: 'form-control' },
           required: false %>
-    <%= fi.input :override_rights_statement, as: :boolean, hint: 'If checked, always use the selected rights statment. If unchecked, use rights or rights_statement from the record and only use the provided value if dc:rights is blank.', input_html: { checked: (importer.parser_fields['override_rights_statement'] == "1") } %>
+    <%= fi.input :override_rights_statement, as: :boolean, hint: 'If checked, always use the selected rights statement. If unchecked, use rights or rights_statement from the record and only use the provided value if dc:rights is blank.', input_html: { checked: (importer.parser_fields['override_rights_statement'] == "1") } %>
   <% end %>
   <h4>XML and files to Import:</h4>
   <p>File upload and Cloud File upload MUST be a either a single XML file (for metadata only import) OR a Zip file containing the XML files and data files, each in a separate folder.</p>

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

@@ -1,10 +1,10 @@
-<div class="col-xs-12 main-header">
+<div class="col-xs-12 main-header d-flex justify-content-between align-items-center">
   <h1><span class="fa fa-cloud-upload" aria-hidden="true"></span> Importer: <%= @importer.name %></h1>
   <div class="pull-right">
-    <%= link_to 'Download Original File', importer_original_file_path(@importer.id), class: 'btn btn-primary', data: { turbolinks: false } if @importer.original_file %>
+    <%= link_to 'Download Original File', importer_original_file_path(@importer.id), class: 'btn btn-primary text-nowrap', data: { turbolinks: false } if @importer.original_file %>
     <% if @importer.failed_entries? %>
-      <%= link_to 'Export Errored Entries', importer_export_errors_path(@importer.id), class: 'btn btn-primary', data: { turbolinks: false }%>
-      <%= link_to 'Upload Corrected Entries', importer_upload_corrected_entries_path(@importer.id), class: 'btn btn-primary' if @importer.parser.is_a?(Bulkrax::CsvParser) %>
+      <%= link_to 'Export Errored Entries', importer_export_errors_path(@importer.id), class: 'btn btn-primary text-nowrap', data: { turbolinks: false }%>
+      <%= link_to 'Upload Corrected Entries', importer_upload_corrected_entries_path(@importer.id), class: 'btn btn-primary text-nowrap' if @importer.parser.is_a?(Bulkrax::CsvParser) %>
     <% end %>
   </div>
 </div>

data/app/views/bulkrax/shared/_entries_tab.html.erb

@@ -12,5 +12,5 @@
       </tr>
     </thead>
   </table>
-  <div id='importer-entry-classes' class='hidden'><%= [item.parser.entry_class.to_s, item.parser.collection_entry_class.to_s, item.parser.file_set_entry_class.to_s].compact.join('|') %></div>
+  <div id='importer-entry-classes' class='hidden d-none'><%= [item.parser.entry_class.to_s, item.parser.collection_entry_class.to_s, item.parser.file_set_entry_class.to_s].compact.join('|') %></div>
 </div>

data/config/locales/bulkrax.en.yml

@@ -1,9 +1,9 @@
 en:
-  helpers: 
-    action: 
+  helpers:
+    action:
       importer:
         new: "New"
-      exporter: 
+      exporter:
         new: "New"
   bulkrax:
     admin:
@@ -75,6 +75,8 @@ en:
         identifier: Identifier
         entry_id: Entry ID
         status: Status
+        type: Type
+        updated_at: Updated At
         errors: Errors
         status_set_at: Status Set At
         actions: Actions

data/lib/bulkrax/engine.rb

@@ -35,7 +35,7 @@ module Bulkrax
         ActionController::Base.view_paths = paths.uniq
 
         custom_query_strategies = {
-          find_by_model_and_property_value: :find_single_or_nil
+          find_by_property_value: :find_single_or_nil
         }
 
         if defined?(::Goddess::CustomQueryContainer)

data/lib/bulkrax/version.rb

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

data/lib/generators/bulkrax/templates/bin/importer

@@ -16,7 +16,7 @@ def main(opts = {})
   headers['Authorization'] = "Token: #{opts.delete(:auth_token)}"
   params = build_params(opts)
 
-  logger.info("POST to #{url} - PARAMS #{params}")
+  Rails.logger.info("POST to #{url} - PARAMS #{params}")
 
   conn = Faraday.new(
     url: url,
@@ -92,10 +92,6 @@ def build_url(importer_id, url, port = nil)
   return url
 end
 
-def logger
-  Rails.logger
-end
-
 def version
   puts "Bulkrax #{Bulkrax::VERSION}"
   puts "Slop #{Slop::VERSION}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bulkrax
 version: !ruby/object:Gem::Version
-  version: 9.0.2
+  version: 9.1.0
 platform: ruby
 authors:
 - Rob Kaufman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-17 00:00:00.000000000 Z
+date: 2025-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails