bulkrax 1.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cad330885f5f4d2dce25c989ebc7552b49b2212b68434d5def942fff61ad23a
-  data.tar.gz: 2b1e71044b26ff6ab9b25822ee969a7e886e095bbd2147b9b240406634e8f832
+  metadata.gz: 5a5ca12cf97da052d9855404c783d52e41679587332ac72aac25d85237cf8231
+  data.tar.gz: 449209843d001cdac64dd4073db130920bb62a3193b2eefd53b94f2ec15f6a08
 SHA512:
-  metadata.gz: 18e70353c64be13d686ff1da35d01c932422da49f9fd0ebf08470fdc0edc9333a9b51633b158cfaedf020ae5e3830574eb192a69ba498dff81e92847de4235f7
-  data.tar.gz: 6502ec16bc63aefed3c678ec062d3bc923c159260ac39278e692f4628bfe05acd675d49193b92c9e42f2ab50976d48c3d608d77f8db1d45774a664fd74b09bce
+  metadata.gz: 296ef3a7a7af8765aaae12353bec7ecfb35a97546955520ac544269525adfe459f3e686886fefbff54c91ba09f7da20c3b6b8c62bcb3fc7be6970f7967defa17
+  data.tar.gz: e7a13f384940a89d42c5efb5d52b8e940939c103dceb35890e08cb56ee020c2c664d1bb4d57945ae9d7afb2acd822385861e004ab7d69c776a0816d688cf66e1

data/README.md

@@ -16,7 +16,7 @@ gem 'bulkrax', git: 'https://github.com/samvera-labs/bulkrax.git'
 
 And then execute:
 ```bash
-$ bundle update
+$ bundle install
 $ rails generate bulkrax:install
 ```
 

data/app/controllers/bulkrax/exporters_controller.rb

@@ -51,9 +51,12 @@ module Bulkrax
       if @exporter.save
         if params[:commit] == 'Create and Export'
           # Use perform now for export
-          Bulkrax::ExporterJob.perform_now(@exporter.id)
+          Bulkrax::ExporterJob.perform_later(@exporter.id)
+          message = 'Exporter was successfully created. A download link will appear once it completes.'
+        else
+          message = 'Exporter was successfully created.'
         end
-        redirect_to exporters_path, notice: 'Exporter was successfully created.'
+        redirect_to exporters_path, notice: message
       else
         render :new
       end
@@ -63,8 +66,13 @@ module Bulkrax
     def update
       field_mapping_params
       if @exporter.update(exporter_params)
-        Bulkrax::ExporterJob.perform_now(@exporter.id) if params[:commit] == 'Update and Re-Export All Items'
-        redirect_to exporters_path, notice: 'Exporter was successfully updated.'
+        if params[:commit] == 'Update and Re-Export All Items'
+          Bulkrax::ExporterJob.perform_later(@exporter.id)
+          message = 'Exporter was successfully updated. A download link will appear once it completes.'
+        else
+          'Exporter was successfully updated.'
+        end
+        redirect_to exporters_path, notice: message
       else
         render :edit
       end

data/app/controllers/bulkrax/importers_controller.rb

@@ -37,6 +37,7 @@ module Bulkrax
 
         @work_entries = @importer.entries.where(type: @importer.parser.entry_class.to_s).page(params[:work_entries_page]).per(30)
         @collection_entries = @importer.entries.where(type: @importer.parser.collection_entry_class.to_s).page(params[:collections_entries_page]).per(30)
+        @file_set_entries = @importer.entries.where(type: @importer.parser.file_set_entry_class.to_s).page(params[:file_set_entries_page]).per(30)
       end
     end
 
@@ -113,23 +114,9 @@ module Bulkrax
       if @importer.update(importer_params)
         files_for_import(file, cloud_files) unless file.nil? && cloud_files.nil?
         # do not perform the import
-        if params[:commit] == 'Update Importer'
-        # do nothing
-        # OAI-only - selective re-harvest
-        elsif params[:commit] == 'Update and Harvest Updated Items'
-          Bulkrax::ImporterJob.perform_later(@importer.id, true)
-        elsif params[:commit] == 'Update Metadata and Files'
-          @importer.parser_fields['update_files'] = true
-          @importer.save
-          Bulkrax::ImporterJob.perform_later(@importer.id)
-          # Perform a full metadata and files re-import; do the same for an OAI re-harvest of all items
-        elsif params[:commit] == ('Update and Replace Files' || 'Update and Re-Harvest All Items')
-          @importer.parser_fields['replace_files'] = true
-          @importer.save
-          Bulkrax::ImporterJob.perform_later(@importer.id)
-        # In all other cases, perform a metadata-only re-import
-        else
-          Bulkrax::ImporterJob.perform_later(@importer.id)
+        unless params[:commit] == 'Update Importer'
+          set_files_parser_fields
+          Bulkrax::ImporterJob.send(@importer.parser.perform_method, @importer.id, update_harvest)
         end
         if api_request?
           json_response('updated', :ok, 'Importer was successfully updated.')
@@ -310,6 +297,25 @@ module Bulkrax
         redirect_to path, notice: message
       end
     end
+
+    # update methods (for commit deciphering)
+    def update_harvest
+      # OAI-only - selective re-harvest
+      params[:commit] == 'Update and Harvest Updated Items'
+    end
+
+    def set_files_parser_fields
+      if params[:commit] == 'Update Metadata and Files'
+        @importer.parser_fields['update_files'] = true
+      elsif params[:commit] == ('Update and Replace Files' || 'Update and Re-Harvest All Items')
+        @importer.parser_fields['replace_files'] = true
+      elsif params[:commit] == 'Update and Harvest Updated Items'
+        return
+      else
+        @importer.parser_fields['metadata_only'] = true
+      end
+      @importer.save
+    end
   end
   # rubocop:enable Metrics/ClassLength
 end

data/app/factories/bulkrax/object_factory.rb

@@ -4,16 +4,24 @@ module Bulkrax
   class ObjectFactory
     extend ActiveModel::Callbacks
     include Bulkrax::FileFactory
+    include DynamicRecordLookup
+
     define_model_callbacks :save, :create
-    attr_reader :attributes, :object, :source_identifier_value, :klass, :replace_files, :update_files, :work_identifier
+    attr_reader :attributes, :object, :source_identifier_value, :klass, :replace_files, :update_files, :work_identifier, :collection_field_mapping, :related_parents_parsed_mapping
 
     # rubocop:disable Metrics/ParameterLists
-    def initialize(attributes:, source_identifier_value:, work_identifier:, replace_files: false, user: nil, klass: nil, update_files: false)
+    def initialize(attributes:, source_identifier_value:, work_identifier:, collection_field_mapping:, related_parents_parsed_mapping: nil, replace_files: false, user: nil, klass: nil, update_files: false)
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       @attributes = ActiveSupport::HashWithIndifferentAccess.new(attributes)
       @replace_files = replace_files
       @update_files = update_files
       @user = user || User.batch_user
       @work_identifier = work_identifier
+      @collection_field_mapping = collection_field_mapping
+      @related_parents_parsed_mapping = related_parents_parsed_mapping
       @source_identifier_value = source_identifier_value
       @klass = klass || Bulkrax.default_work_type.constantize
     end
@@ -28,7 +36,7 @@ module Bulkrax
       arg_hash = { id: attributes[:id], name: 'UPDATE', klass: klass }
       @object = find
       if object
-        object.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX
+        object.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX if object.respond_to?(:reindex_extent)
         ActiveSupport::Notifications.instrument('import.importer', arg_hash) { update }
       else
         ActiveSupport::Notifications.instrument('import.importer', arg_hash.merge(name: 'CREATE')) { create }
@@ -41,20 +49,27 @@ module Bulkrax
       self.run
       # Create the error exception if the object is not validly saved for some reason
       raise ActiveFedora::RecordInvalid, object if !object.persisted? || object.changed?
+      object
     end
 
     def update
       raise "Object doesn't exist" unless object
-      destroy_existing_files if @replace_files && klass != Collection
+      destroy_existing_files if @replace_files && ![Collection, FileSet].include?(klass)
       attrs = attribute_update
       run_callbacks :save do
-        klass == Collection ? update_collection(attrs) : work_actor.update(environment(attrs))
+        if klass == Collection
+          update_collection(attrs)
+        elsif klass == FileSet
+          update_file_set(attrs)
+        else
+          work_actor.update(environment(attrs))
+        end
       end
       log_updated(object)
     end
 
     def find
-      return find_by_id if attributes[:id]
+      return find_by_id if attributes[:id].present?
       return search_by_identifier if attributes[work_identifier].present?
     end
 
@@ -84,10 +99,16 @@ module Bulkrax
     def create
       attrs = create_attributes
       @object = klass.new
-      object.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX
+      object.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX if object.respond_to?(:reindex_extent)
       run_callbacks :save do
         run_callbacks :create do
-          klass == Collection ? create_collection(attrs) : work_actor.create(environment(attrs))
+          if klass == Collection
+            create_collection(attrs)
+          elsif klass == FileSet
+            create_file_set(attrs)
+          else
+            work_actor.create(environment(attrs))
+          end
         end
       end
       log_created(object)
@@ -121,52 +142,62 @@ module Bulkrax
     end
 
     def create_collection(attrs)
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       attrs = collection_type(attrs)
-      object.members = members
-      object.member_of_collections = member_of_collections
+      persist_collection_memberships(parent: object, child: find_collection(attributes[:child_collection_id])) if attributes[:child_collection_id].present?
+      persist_collection_memberships(parent: find_collection(attributes[collection_field_mapping]), child: object) if attributes[collection_field_mapping].present?
       object.attributes = attrs
       object.apply_depositor_metadata(@user)
       object.save!
     end
 
     def update_collection(attrs)
-      object.members = members
-      object.member_of_collections = member_of_collections
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      persist_collection_memberships(parent: object, child: find_collection(attributes[:child_collection_id])) if attributes[:child_collection_id].present?
+      persist_collection_memberships(parent: find_collection(attributes[collection_field_mapping]), child: object) if attributes[collection_field_mapping].present?
       object.attributes = attrs
       object.save!
     end
 
-    # Collections don't respond to member_of_collections_attributes or member_of_collection_ids=
-    #   or member_ids=
-    # Add them directly with members / member_of_collections
-    # collection should be in the form  { id: collection_id }
-    # and collections [{ id: collection_id }]
-    # member_ids comes from
-    # @todo - consider performance implications although we wouldn't expect a Collection to be a member of many Collections
-    def members
-      ms = object.members.to_a
-      [:children].each do |atat|
-        next if attributes[atat].blank?
-        ms.concat(
-          Array.wrap(
-            find_collection(attributes[atat])
-          )
-        )
-      end
-      ms.flatten.compact.uniq
-    end
-
-    def member_of_collections
-      ms = object.member_of_collection_ids.to_a.map { |id| find_collection(id) }
-      [:collection, :collections].each do |atat|
-        next if attributes[atat].blank?
-        ms.concat(
-          Array.wrap(
-            find_collection(attributes[atat])
-          )
-        )
+    # This method is heavily inspired by Hyrax's AttachFilesToWorkJob
+    def create_file_set(attrs)
+      work = find_record(attributes[related_parents_parsed_mapping].first)
+      work_permissions = work.permissions.map(&:to_hash)
+      file_set_attrs = attrs.slice(*object.attributes.keys)
+      object.assign_attributes(file_set_attrs)
+
+      attrs['uploaded_files'].each do |uploaded_file_id|
+        uploaded_file = ::Hyrax::UploadedFile.find(uploaded_file_id)
+        next if uploaded_file.file_set_uri.present?
+
+        actor = ::Hyrax::Actors::FileSetActor.new(object, @user)
+        uploaded_file.update(file_set_uri: actor.file_set.uri)
+        actor.file_set.permissions_attributes = work_permissions
+        actor.create_metadata
+        actor.create_content(uploaded_file)
+        actor.attach_to_work(work)
       end
-      ms.flatten.compact.uniq
+
+      object.save!
+    end
+
+    def update_file_set(attrs)
+      file_set_attrs = attrs.slice(*object.attributes.keys)
+      actor = ::Hyrax::Actors::FileSetActor.new(object, @user)
+
+      actor.update_metadata(file_set_attrs)
+    end
+
+    # Add child to parent's #member_collections
+    # Add parent to child's #member_of_collections
+    def persist_collection_memberships(parent:, child:)
+      ::Hyrax::Collections::NestedCollectionPersistenceService.persist_nested_collection_for(parent: parent, child: child)
     end
 
     def find_collection(id)
@@ -192,32 +223,22 @@ module Bulkrax
     # which is used by Hyrax::Actors::AddAsMemberOfCollectionsActor
     def create_attributes
       return transform_attributes if klass == Collection
-      if attributes[:collection].present?
-        transform_attributes.except(:collection).merge(member_of_collections_attributes: { 0 => { id: collection.id } })
-      elsif attributes[:collections].present?
-        collection_ids = attributes[:collections].each.with_index.each_with_object({}) do |(element, index), ids|
-          ids[index] = { id: element }
-        end
-        transform_attributes.except(:collections).merge(member_of_collections_attributes: collection_ids)
-      else
-        transform_attributes
-      end
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      transform_attributes.except(:collections, :collection, collection_field_mapping)
     end
 
     # Strip out the :collection key, and add the member_of_collection_ids,
     # which is used by Hyrax::Actors::AddAsMemberOfCollectionsActor
     def attribute_update
       return transform_attributes.except(:id) if klass == Collection
-      if attributes[:collection].present?
-        transform_attributes.except(:id).except(:collection).merge(member_of_collections_attributes: { "0" => { id: collection.id } })
-      elsif attributes[:collections].present?
-        collection_ids = attributes[:collections].each.with_index.each_with_object({}) do |(element, index), ids|
-          ids[index.to_s] = element
-        end
-        transform_attributes.except(:id).except(:collections).merge(member_of_collections_attributes: collection_ids)
-      else
-        transform_attributes.except(:id)
-      end
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      transform_attributes.except(:id, :collections, :collection, collection_field_mapping)
     end
 
     # Override if we need to map the attributes from the parser in
@@ -230,7 +251,7 @@ module Bulkrax
 
     # Regardless of what the Parser gives us, these are the properties we are prepared to accept.
     def permitted_attributes
-      klass.properties.keys.map(&:to_sym) + %i[id edit_users edit_groups read_groups visibility work_members_attributes admin_set_id]
+      klass.properties.keys.map(&:to_sym) + %i[id edit_users edit_groups read_groups visibility work_members_attributes admin_set_id member_of_collections_attributes]
     end
   end
 end

data/app/jobs/bulkrax/create_relationships_job.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  # Responsible for creating parent-child relationships between Works and Collections.
+  #
+  # Handles three kinds of relationships:
+  # - Work to Collection
+  # - Collection to Collection
+  # - Work to Work
+  #
+  # These can be established from either side of the relationship (i.e. from parent to child or from child to parent).
+  # This job only creates one relationship at a time. If a record needs multiple parents or children or both, individual
+  # jobs should be run for each of those relationships.
+  #
+  # NOTE: In the context of this job, "record" is used to generically refer
+  #       to either an instance of a Work or an instance of a Collection.
+  # NOTE: In the context of this job, "identifier" is used to generically refer
+  #       to either a record's ID or an Bulkrax::Entry's source_identifier.
+  class CreateRelationshipsJob < ApplicationJob
+    include DynamicRecordLookup
+
+    queue_as :import
+
+    attr_accessor :base_entry, :child_record, :parent_record, :importer_run
+
+    # @param entry_identifier [String] source_identifier of the base Bulkrax::Entry the job was triggered from (see #build_for_importer)
+    # @param parent_identifier [String] Work/Collection ID or Bulkrax::Entry source_identifier
+    # @param child_identifier [String] Work/Collection ID or Bulkrax::Entry source_identifier
+    # @param importer_run [Bulkrax::ImporterRun] current importer run (needed to properly update counters)
+    #
+    # The entry_identifier is used to lookup the @base_entry for the job (a.k.a. the entry the job was called from).
+    # The @base_entry defines the context of the relationship (e.g. "this entry (@base_entry) should have a parent").
+    # Whether the @base_entry is the parent or the child in the relationship is determined by the presence of a
+    # parent_identifier or child_identifier param. For example, if a parent_identifier is passed, we know @base_entry
+    # is the child in the relationship, and vice versa if a child_identifier is passed.
+    def perform(entry_identifier:, parent_identifier: nil, child_identifier: nil, importer_run:)
+      @base_entry = Entry.find_by(identifier: entry_identifier)
+      @importer_run = importer_run
+      if parent_identifier.present?
+        @child_record = find_record(entry_identifier)
+        @parent_record = find_record(parent_identifier)
+      elsif child_identifier.present?
+        @parent_record = find_record(entry_identifier)
+        @child_record = find_record(child_identifier)
+      else
+        raise ::StandardError, %("#{entry_identifier}" needs either a child or a parent to create a relationship)
+      end
+
+      if @child_record.blank? || @parent_record.blank?
+        reschedule(
+          entry_identifier: entry_identifier,
+          parent_identifier: parent_identifier,
+          child_identifier: child_identifier,
+          importer_run: importer_run
+        )
+        return false # stop current job from continuing to run after rescheduling
+      end
+
+      create_relationship
+    rescue ::StandardError => e
+      base_entry.status_info(e)
+      importer_run.increment!(:failed_relationships) # rubocop:disable Rails/SkipsModelValidations
+    end
+
+    private
+
+    def create_relationship
+      if parent_record.is_a?(::Collection) && child_record.is_a?(::Collection)
+        collection_parent_collection_child
+      elsif parent_record.is_a?(::Collection) && curation_concern?(child_record)
+        collection_parent_work_child
+      elsif curation_concern?(parent_record) && child_record.is_a?(::Collection)
+        raise ::StandardError, 'a Collection may not be assigned as a child of a Work'
+      else
+        work_parent_work_child
+      end
+    end
+
+    def user
+      @user ||= importer_run.importer.user
+    end
+
+    # Work-Collection membership is added to the child as member_of_collection_ids
+    # This is adding the reverse relationship, from the child to the parent
+    def collection_parent_work_child
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      attrs = { id: child_record.id, member_of_collections_attributes: { 0 => { id: parent_record.id } } }
+      ObjectFactory.new(
+        attributes: attrs,
+        source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
+        work_identifier: base_entry.parser.work_identifier,
+        collection_field_mapping: base_entry.parser.collection_field_mapping,
+        replace_files: false,
+        user: user,
+        klass: child_record.class
+      ).run
+      # TODO: add counters for :processed_parents and :failed_parents
+      importer_run.increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+    end
+
+    # Collection-Collection membership is added to the as member_ids
+    def collection_parent_collection_child
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      attrs = { id: parent_record.id, child_collection_id: child_record.id }
+      ObjectFactory.new(
+        attributes: attrs,
+        source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
+        work_identifier: base_entry.parser.work_identifier,
+        collection_field_mapping: base_entry.parser.collection_field_mapping,
+        replace_files: false,
+        user: user,
+        klass: parent_record.class
+      ).run
+      # TODO: add counters for :processed_parents and :failed_parents
+      importer_run.increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+    end
+
+    # Work-Work membership is added to the parent as member_ids
+    def work_parent_work_child
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      attrs = {
+        id: parent_record.id,
+        work_members_attributes: { 0 => { id: child_record.id } }
+      }
+      ObjectFactory.new(
+        attributes: attrs,
+        source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
+        work_identifier: base_entry.parser.work_identifier,
+        collection_field_mapping: base_entry.parser.collection_field_mapping,
+        replace_files: false,
+        user: user,
+        klass: parent_record.class
+      ).run
+      # TODO: add counters for :processed_parents and :failed_parents
+      importer_run.increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+    end
+
+    def reschedule(entry_identifier:, parent_identifier:, child_identifier:, importer_run:)
+      CreateRelationshipsJob.set(wait: 10.minutes).perform_later(
+        entry_identifier: entry_identifier,
+        parent_identifier: parent_identifier,
+        child_identifier: child_identifier,
+        importer_run: importer_run
+      )
+    end
+  end
+end

data/app/jobs/bulkrax/delete_work_job.rb

@@ -8,8 +8,12 @@ module Bulkrax
     def perform(entry, importer_run)
       work = entry.factory.find
       work&.delete
-      importer_run.increment!(:deleted_records)
-      importer_run.decrement!(:enqueued_records)
+      ImporterRun.find(importer_run.id).increment!(:deleted_records)
+      ImporterRun.find(importer_run.id).decrement!(:enqueued_records)
+      entry.save!
+      entry.importer.current_run = ImporterRun.find(importer_run.id)
+      entry.importer.record_status
+      entry.status_info("Deleted", ImporterRun.find(importer_run.id))
     end
     # rubocop:enable Rails/SkipsModelValidations
   end

data/app/jobs/bulkrax/export_work_job.rb

@@ -26,12 +26,14 @@ module Bulkrax
         # rubocop:enable Rails/SkipsModelValidations
       end
       exporter_run = ExporterRun.find(args[1])
-      return if exporter_run.enqueued_records.positive?
+      return entry if exporter_run.enqueued_records.positive?
       if exporter_run.failed_records.positive?
         exporter_run.exporter.status_info('Complete (with failures)')
       else
         exporter_run.exporter.status_info('Complete')
       end
+
+      return entry
     end
   end
 end

data/app/jobs/bulkrax/exporter_job.rb

@@ -8,6 +8,7 @@ module Bulkrax
       exporter = Exporter.find(exporter_id)
       exporter.export
       exporter.write
+      exporter.save
       true
     end
   end

data/app/jobs/bulkrax/{import_work_collection_job.rb → import_collection_job.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Bulkrax
-  class ImportWorkCollectionJob < ApplicationJob
+  class ImportCollectionJob < ApplicationJob
     queue_as :import
 
     # rubocop:disable Rails/SkipsModelValidations
@@ -11,9 +11,11 @@ module Bulkrax
         entry.build
         entry.save
         add_user_to_permission_template!(entry)
+        ImporterRun.find(args[1]).increment!(:processed_records)
         ImporterRun.find(args[1]).increment!(:processed_collections)
         ImporterRun.find(args[1]).decrement!(:enqueued_records)
       rescue => e
+        ImporterRun.find(args[1]).increment!(:failed_records)
         ImporterRun.find(args[1]).increment!(:failed_collections)
         ImporterRun.find(args[1]).decrement!(:enqueued_records)
         raise e
@@ -28,7 +30,7 @@ module Bulkrax
       collection          = entry.factory.find
       permission_template = Hyrax::PermissionTemplate.find_or_create_by!(source_id: collection.id)
 
-      Hyrax::PermissionTemplateAccess.create!(
+      Hyrax::PermissionTemplateAccess.find_or_create_by!(
         permission_template_id: permission_template.id,
         agent_id: user.user_key,
         agent_type: 'user',

data/app/jobs/bulkrax/import_file_set_job.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  class MissingParentError < ::StandardError; end
+  class ImportFileSetJob < ApplicationJob
+    include DynamicRecordLookup
+
+    queue_as :import
+
+    def perform(entry_id, importer_run_id)
+      entry = Entry.find(entry_id)
+      parent_identifier = entry.raw_metadata[entry.related_parents_raw_mapping]&.strip
+
+      validate_parent!(parent_identifier)
+
+      entry.build
+      if entry.succeeded?
+        # rubocop:disable Rails/SkipsModelValidations
+        ImporterRun.find(importer_run_id).increment!(:processed_records)
+        ImporterRun.find(importer_run_id).increment!(:processed_file_sets)
+      else
+        ImporterRun.find(importer_run_id).increment!(:failed_records)
+        ImporterRun.find(importer_run_id).increment!(:failed_file_sets)
+        # rubocop:enable Rails/SkipsModelValidations
+      end
+      ImporterRun.find(importer_run_id).decrement!(:enqueued_records) # rubocop:disable Rails/SkipsModelValidations
+      entry.save!
+
+    rescue MissingParentError => e
+      # try waiting for the parent record to be created
+      entry.import_attempts += 1
+      entry.save!
+      if entry.import_attempts < 5
+        ImportFileSetJob
+          .set(wait: (entry.import_attempts + 1).minutes)
+          .perform_later(entry_id, importer_run_id)
+      else
+        ImporterRun.find(importer_run_id).decrement!(:enqueued_records) # rubocop:disable Rails/SkipsModelValidations
+        entry.status_info(e)
+      end
+    end
+
+    private
+
+    attr_reader :parent_record
+
+    def validate_parent!(parent_identifier)
+      # if parent_identifier is missing, it will be caught by #validate_presence_of_parent!
+      return if parent_identifier.blank?
+
+      find_parent_record(parent_identifier)
+      check_parent_exists!(parent_identifier)
+      check_parent_is_a_work!(parent_identifier)
+    end
+
+    def check_parent_exists!(parent_identifier)
+      raise MissingParentError, %(Unable to find a record with the identifier "#{parent_identifier}") if parent_record.blank?
+    end
+
+    def check_parent_is_a_work!(parent_identifier)
+      error_msg = %(A record with the ID "#{parent_identifier}" was found, but it was a #{parent_record.class}, which is not an valid/available work type)
+      raise ::StandardError, error_msg unless curation_concern?(parent_record)
+    end
+
+    def find_parent_record(parent_identifier)
+      @parent_record ||= find_record(parent_identifier)
+    end
+  end
+end

data/app/jobs/bulkrax/import_work_job.rb

@@ -10,11 +10,13 @@ module Bulkrax
       entry.build
       if entry.status == "Complete"
         ImporterRun.find(args[1]).increment!(:processed_records)
+        ImporterRun.find(args[1]).increment!(:processed_works)
         ImporterRun.find(args[1]).decrement!(:enqueued_records) unless ImporterRun.find(args[1]).enqueued_records <= 0 # rubocop:disable Style/IdenticalConditionalBranches
       else
         # do not retry here because whatever parse error kept you from creating a work will likely
         # keep preventing you from doing so.
         ImporterRun.find(args[1]).increment!(:failed_records)
+        ImporterRun.find(args[1]).increment!(:failed_works)
         ImporterRun.find(args[1]).decrement!(:enqueued_records) unless ImporterRun.find(args[1]).enqueued_records <= 0 # rubocop:disable Style/IdenticalConditionalBranches
       end
       entry.save!