bulkrax 4.4.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d53012e0252f8033f5da334d5336c134deb3a6221040cfe4c1c6c01bb473d617
-  data.tar.gz: e986a3506c073aa533c4ea303a123e8866d2bf7ac6d8ab6df3949682f61b6c05
+  metadata.gz: 490e0f170cc1128c00c467c3cc344db627d027a3b857d53dfa33b97805567d4b
+  data.tar.gz: 7290801bacea707b7398e674a17acf56e7a770cfb3bea20958169588a4404175
 SHA512:
-  metadata.gz: 8ea20593d1164f62fdfda2dbe84bd8cc4e199a65d7e85eea0b68b27e71aeff7579f1b0059042f55eec1c7ab36f8dec9db406ad58cc3a315b29b8e4900f7cb450
-  data.tar.gz: 89a03cd842d855d48f8c4952b6e9a6daea757e80cb8c0f9ee370b59f90e434b39dfb548deb1757f36463914bd5cccbcf1df6c5ffd9102bb5f0d54b5b7ea6476f
+  metadata.gz: a6f5486405e2d2eb7f6c0c49b17ed0926e55a701368e42c93db9b009a5f663682ec4141fe1dd58d0dde132fa747010ada7cd22187b81d60a7e8b6b23cbf2e24d
+  data.tar.gz: d56a8780ef074d412ac7406d3f3ddb39b34b17bbe43c61a64bebe06f39952a1d62cbf2dbd01a7012bcd776686def03c5a5e6c556cc1384284c2dea8a89f3eec2

data/app/controllers/bulkrax/entries_controller.rb

@@ -5,9 +5,10 @@ require_dependency "oai"
 
 module Bulkrax
   class EntriesController < ApplicationController
-    include Hyrax::ThemedLayoutController
+    include Hyrax::ThemedLayoutController if defined?(::Hyrax)
     before_action :authenticate_user!
-    with_themed_layout 'dashboard'
+    before_action :check_permissions
+    with_themed_layout 'dashboard' if defined?(::Hyrax)
 
     def show
       if params[:importer_id].present?
@@ -22,6 +23,7 @@ module Bulkrax
       @importer = Importer.find(params[:importer_id])
       @entry = Entry.find(params[:id])
 
+      return unless defined?(::Hyrax)
       add_breadcrumb t(:'hyrax.controls.home'), main_app.root_path
       add_breadcrumb t(:'hyrax.dashboard.breadcrumbs.admin'), hyrax.dashboard_path
       add_breadcrumb 'Importers', bulkrax.importers_path
@@ -34,11 +36,16 @@ module Bulkrax
       @exporter = Exporter.find(params[:exporter_id])
       @entry = Entry.find(params[:id])
 
+      return unless defined?(::Hyrax)
       add_breadcrumb t(:'hyrax.controls.home'), main_app.root_path
       add_breadcrumb t(:'hyrax.dashboard.breadcrumbs.admin'), hyrax.dashboard_path
       add_breadcrumb 'Exporters', bulkrax.exporters_path
       add_breadcrumb @exporter.name, bulkrax.exporter_path(@exporter.id)
       add_breadcrumb @entry.id
     end
+
+    def check_permissions
+      raise CanCan::AccessDenied unless current_ability.can_import_works? || current_ability.can_export_works?
+    end
   end
 end

data/app/controllers/bulkrax/exporters_controller.rb

@@ -4,23 +4,26 @@ require_dependency "bulkrax/application_controller"
 
 module Bulkrax
   class ExportersController < ApplicationController
-    include Hyrax::ThemedLayoutController
+    include Hyrax::ThemedLayoutController if defined?(::Hyrax)
     include Bulkrax::DownloadBehavior
     before_action :authenticate_user!
+    before_action :check_permissions
     before_action :set_exporter, only: [:show, :edit, :update, :destroy]
-    with_themed_layout 'dashboard'
+    with_themed_layout 'dashboard' if defined?(::Hyrax)
 
     # GET /exporters
     def index
       @exporters = Exporter.all
 
-      add_exporter_breadcrumbs
+      add_exporter_breadcrumbs if defined?(::Hyrax)
     end
 
     # GET /exporters/1
     def show
-      add_exporter_breadcrumbs
-      add_breadcrumb @exporter.name
+      if defined?(::Hyrax)
+        add_exporter_breadcrumbs
+        add_breadcrumb @exporter.name
+      end
 
       @work_entries = @exporter.entries.where(type: @exporter.parser.entry_class.to_s).page(params[:work_entries_page]).per(30)
       @collection_entries = @exporter.entries.where(type: @exporter.parser.collection_entry_class.to_s).page(params[:collections_entries_page]).per(30)
@@ -30,16 +33,18 @@ module Bulkrax
     # GET /exporters/new
     def new
       @exporter = Exporter.new
-
+      return unless defined?(::Hyrax)
       add_exporter_breadcrumbs
       add_breadcrumb 'New'
     end
 
     # GET /exporters/1/edit
     def edit
-      add_exporter_breadcrumbs
-      add_breadcrumb @exporter.name, bulkrax.exporter_path(@exporter.id)
-      add_breadcrumb 'Edit'
+      if defined?(::Hyrax)
+        add_exporter_breadcrumbs
+        add_breadcrumb @exporter.name, bulkrax.exporter_path(@exporter.id)
+        add_breadcrumb 'Edit'
+      end
 
       # Correctly populate export_source_collection input
       @collection = Collection.find(@exporter.export_source) if @exporter.export_source.present? && @exporter.export_from == 'collection'
@@ -131,5 +136,9 @@ module Bulkrax
     def file_path
       "#{@exporter.exporter_export_zip_path}/#{params['exporter']['exporter_export_zip_files']}"
     end
+
+    def check_permissions
+      raise CanCan::AccessDenied unless current_ability.can_export_works?
+    end
   end
 end

data/app/controllers/bulkrax/importers_controller.rb

@@ -6,7 +6,7 @@ require_dependency 'oai'
 module Bulkrax
   # rubocop:disable Metrics/ClassLength
   class ImportersController < ApplicationController
-    include Hyrax::ThemedLayoutController
+    include Hyrax::ThemedLayoutController if defined?(::Hyrax)
     include Bulkrax::DownloadBehavior
     include Bulkrax::API
     include Bulkrax::ValidationHelper
@@ -14,15 +14,16 @@ module Bulkrax
     protect_from_forgery unless: -> { api_request? }
     before_action :token_authenticate!, if: -> { api_request? }, only: [:create, :update, :delete]
     before_action :authenticate_user!, unless: -> { api_request? }
+    before_action :check_permissions
     before_action :set_importer, only: [:show, :edit, :update, :destroy]
-    with_themed_layout 'dashboard'
+    with_themed_layout 'dashboard' if defined?(::Hyrax)
 
     # GET /importers
     def index
       @importers = Importer.all
       if api_request?
         json_response('index')
-      else
+      elsif defined?(::Hyrax)
         add_importer_breadcrumbs
       end
     end
@@ -31,7 +32,7 @@ module Bulkrax
     def show
       if api_request?
         json_response('show')
-      else
+      elsif defined?(::Hyrax)
         add_importer_breadcrumbs
         add_breadcrumb @importer.name
 
@@ -46,7 +47,7 @@ module Bulkrax
       @importer = Importer.new
       if api_request?
         json_response('new')
-      else
+      elsif defined?(::Hyrax)
         add_importer_breadcrumbs
         add_breadcrumb 'New'
       end
@@ -56,7 +57,7 @@ module Bulkrax
     def edit
       if api_request?
         json_response('edit')
-      else
+      elsif defined?(::Hyrax)
         add_importer_breadcrumbs
         add_breadcrumb @importer.name, bulkrax.importer_path(@importer.id)
         add_breadcrumb 'Edit'
@@ -76,6 +77,9 @@ module Bulkrax
       @importer = Importer.new(importer_params)
       field_mapping_params
       @importer.validate_only = true if params[:commit] == 'Create and Validate'
+      # the following line is needed to handle updating remote files of a FileSet
+      # on a new import otherwise it only gets updated during the update path
+      @importer.parser_fields['update_files'] = true if params[:commit] == 'Create and Import'
       if @importer.save
         files_for_import(file, cloud_files)
         if params[:commit] == 'Create and Import'
@@ -155,6 +159,7 @@ module Bulkrax
     # GET /importer/1/upload_corrected_entries
     def upload_corrected_entries
       @importer = Importer.find(params[:importer_id])
+      return unless defined?(::Hyrax)
       add_breadcrumb t(:'hyrax.controls.home'), main_app.root_path
       add_breadcrumb t(:'hyrax.dashboard.breadcrumbs.admin'), hyrax.dashboard_path
       add_breadcrumb 'Importers', bulkrax.importers_path
@@ -316,6 +321,10 @@ module Bulkrax
       end
       @importer.save
     end
+
+    def check_permissions
+      raise CanCan::AccessDenied unless current_ability.can_import_works?
+    end
   end
   # rubocop:enable Metrics/ClassLength
 end

data/app/factories/bulkrax/object_factory.rb

@@ -6,6 +6,27 @@ module Bulkrax
     include Bulkrax::FileFactory
     include DynamicRecordLookup
 
+    # @api private
+    #
+    # These are the attributes that we assume all "work type" classes (e.g. the given :klass) will
+    # have in addition to their specific attributes.
+    #
+    # @return [Array<Symbol>]
+    # @see #permitted_attributes
+    class_attribute :base_permitted_attributes,
+      default: %i[id edit_users edit_groups read_groups visibility work_members_attributes admin_set_id]
+
+    # @return [Boolean]
+    #
+    # @example
+    #   Bulkrax::ObjectFactory.transformation_removes_blank_hash_values = true
+    #
+    # @see #transform_attributes
+    # @see https://github.com/samvera-labs/bulkrax/pull/708 For discussion concerning this feature
+    # @see https://github.com/samvera-labs/bulkrax/wiki/Interacting-with-Metadata For documentation
+    #      concerning default behavior.
+    class_attribute :transformation_removes_blank_hash_values, default: false
+
     define_model_callbacks :save, :create
     attr_reader :attributes, :object, :source_identifier_value, :klass, :replace_files, :update_files, :work_identifier, :related_parents_parsed_mapping, :importer_run_id
 
@@ -58,7 +79,7 @@ module Bulkrax
         elsif klass == FileSet
           update_file_set(attrs)
         else
-          work_actor.update(environment(attrs))
+          update_work(attrs)
         end
       end
       object.apply_depositor_metadata(@user) && object.save! if object.depositor.nil?
@@ -104,7 +125,7 @@ module Bulkrax
           elsif klass == FileSet
             create_file_set(attrs)
           else
-            work_actor.create(environment(attrs))
+            create_work(attrs)
           end
         end
       end
@@ -139,6 +160,14 @@ module Bulkrax
       Hyrax::CurationConcern.actor
     end
 
+    def create_work(attrs)
+      work_actor.create(environment(attrs))
+    end
+
+    def update_work(attrs)
+      work_actor.update(environment(attrs))
+    end
+
     def create_collection(attrs)
       attrs = clean_attrs(attrs)
       attrs = collection_type(attrs)
@@ -227,12 +256,32 @@ module Bulkrax
     def transform_attributes(update: false)
       @transform_attributes = attributes.slice(*permitted_attributes)
       @transform_attributes.merge!(file_attributes(update_files)) if with_files
+      @transform_attributes = remove_blank_hash_values(@transform_attributes) if transformation_removes_blank_hash_values?
       update ? @transform_attributes.except(:id) : @transform_attributes
     end
 
     # 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) + base_permitted_attributes
+    end
+
+    # Return a copy of the given attributes, such that all values that are empty or an array of all
+    # empty values are fully emptied.  (See implementation details)
+    #
+    # @param attributes [Hash]
+    # @return [Hash]
+    #
+    # @see https://github.com/emory-libraries/dlp-curate/issues/1973
+    def remove_blank_hash_values(attributes)
+      dupe = attributes.dup
+      dupe.each do |key, values|
+        if values.is_a?(Array) && values.all? { |value| value.is_a?(String) && value.empty? }
+          dupe[key] = []
+        elsif values.is_a?(String) && values.empty?
+          dupe[key] = nil
+        end
+      end
+      dupe
     end
   end
 end

data/app/helpers/bulkrax/application_helper.rb

@@ -3,7 +3,7 @@ require 'coderay'
 
 module Bulkrax
   module ApplicationHelper
-    include ::Hyrax::HyraxHelperBehavior
+    include ::Hyrax::HyraxHelperBehavior if defined?(::Hyrax)
 
     def coderay(value, opts)
       CodeRay

data/app/helpers/bulkrax/importers_helper.rb

@@ -2,9 +2,9 @@
 
 module Bulkrax
   module ImportersHelper
-    # borrowd from batch-importer https://github.com/samvera-labs/hyrax-batch_ingest/blob/main/app/controllers/hyrax/batch_ingest/batches_controller.rb
+    # borrowed from batch-importer https://github.com/samvera-labs/hyrax-batch_ingest/blob/main/app/controllers/hyrax/batch_ingest/batches_controller.rb
     def available_admin_sets
-      # Restrict available_admin_sets to only those current user can desposit to.
+      # Restrict available_admin_sets to only those current user can deposit to.
       @available_admin_sets ||= Hyrax::Collections::PermissionsService.source_ids_for_deposit(ability: current_ability, source_type: 'admin_set').map do |admin_set_id|
         [AdminSet.find(admin_set_id).title.first, admin_set_id]
       end

data/app/jobs/bulkrax/create_relationships_job.rb

@@ -17,12 +17,29 @@ module Bulkrax
   # 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
+    ##
+    # @api public
+    # @since v5.0.1
+    #
+    # Once we've created the relationships, should we then index the works's file_sets to ensure
+    # that we have the proper indexed values.  This can help set things like `is_page_of_ssim` for
+    # IIIF manifest and search results of file sets.
+    #
+    # @note As of v5.0.1 the default behavior is to not perform this.  That preserves past
+    #       implementations.  However, we might determine that we want to change the default
+    #       behavior.  Which would likely mean a major version change.
+    #
+    # @example
+    #   # In config/initializers/bulkrax.rb
+    #   Bulkrax::CreateRelationshipsJob.update_child_records_works_file_sets = true
+    #
+    # @see https://github.com/scientist-softserv/louisville-hyku/commit/128a9ef
+    class_attribute :update_child_records_works_file_sets, default: false
+
     include DynamicRecordLookup
 
     queue_as :import
 
-    attr_accessor :child_records, :child_entry, :parent_record, :parent_entry, :importer_run_id
-
     # @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)
     #
@@ -31,82 +48,81 @@ module Bulkrax
     # 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.
+    #
+    # rubocop:disable Metrics/MethodLength
     def perform(parent_identifier:, importer_run_id:) # rubocop:disable Metrics/AbcSize
-      pending_relationships = Bulkrax::PendingRelationship.find_each.select do |rel|
-        rel.importer_run_id == importer_run_id && rel.parent_id == parent_identifier
-      end.sort_by(&:order)
-
-      @importer_run_id = importer_run_id
-      @parent_entry, @parent_record = find_record(parent_identifier, importer_run_id)
-      @child_records = { works: [], collections: [] }
-      pending_relationships.each do |rel|
-        raise ::StandardError, %("#{rel}" needs either a child or a parent to create a relationship) if rel.child_id.nil? || rel.parent_id.nil?
-        @child_entry, child_record = find_record(rel.child_id, importer_run_id)
-        if child_record
-          child_record.is_a?(::Collection) ? @child_records[:collections] << child_record : @child_records[:works] << child_record
+      importer_run = Bulkrax::ImporterRun.find(importer_run_id)
+      ability = Ability.new(importer_run.user)
+
+      parent_entry, parent_record = find_record(parent_identifier, importer_run_id)
+
+      number_of_successes = 0
+      number_of_failures = 0
+      errors = []
+
+      ActiveRecord::Base.uncached do
+        Bulkrax::PendingRelationship.where(parent_id: parent_identifier, importer_run_id: importer_run_id)
+                                    .ordered.find_each do |rel|
+          process(relationship: rel, importer_run_id: importer_run_id, parent_record: parent_record, ability: ability)
+          number_of_successes += 1
+        rescue => e
+          number_of_failures += 1
+          errors << e
         end
       end
 
-      if (child_records[:collections].blank? && child_records[:works].blank?) || parent_record.nil?
+      # save record if members were added
+      parent_record.save! if @parent_record_members_added
+
+      # rubocop:disable Rails/SkipsModelValidations
+      if errors.present?
+        importer_run.increment!(:failed_relationships, number_of_failures)
+        parent_entry&.set_status_info(errors.last, importer_run)
+
+        # TODO: This can create an infinite job cycle, consider a time to live tracker.
         reschedule({ parent_identifier: parent_identifier, importer_run_id: importer_run_id })
         return false # stop current job from continuing to run after rescheduling
+      else
+        Bulkrax::ImporterRun.find(importer_run_id).increment!(:processed_relationships, number_of_successes)
       end
-      @parent_entry ||= Bulkrax::Entry.where(identifier: parent_identifier,
-                                             importerexporter_id: ImporterRun.find(importer_run_id).importer_id,
-                                             importerexporter_type: "Bulkrax::Importer").first
-      create_relationships
-      pending_relationships.each(&:destroy)
-    rescue ::StandardError => e
-      parent_entry ? parent_entry.status_info(e) : child_entry.status_info(e)
-      Bulkrax::ImporterRun.find(importer_run_id).increment!(:failed_relationships) # rubocop:disable Rails/SkipsModelValidations
+      # rubocop:enable Rails/SkipsModelValidations
     end
+    # rubocop:enable Metrics/MethodLength
 
     private
 
-    def create_relationships
-      if parent_record.is_a?(::Collection)
-        collection_parent_work_child unless child_records[:works].empty?
-        collection_parent_collection_child unless child_records[:collections].empty?
-      else
-        work_parent_work_child unless child_records[:works].empty?
-        raise ::StandardError, 'a Collection may not be assigned as a child of a Work' if child_records[:collections].present?
-      end
-    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?
 
-    def user
-      @user ||= Bulkrax::ImporterRun.find(importer_run_id).importer.user
-    end
+      _child_entry, child_record = find_record(relationship.child_id, importer_run_id)
+      raise "#{relationship} could not find child record" unless child_record
 
-    # 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
-      child_work_ids = child_records[:works].map(&:id)
-      parent_record.try(:reindex_extent=, Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX)
+      raise "Cannot add child collection (ID=#{relationship.child_id}) to parent work (ID=#{relationship.parent_id})" if child_record.collection? && parent_record.work?
 
-      parent_record.add_member_objects(child_work_ids)
-      ImporterRun.find(importer_run_id).increment!(:processed_relationships, child_work_ids.count) # rubocop:disable Rails/SkipsModelValidations
+      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)
+
+      parent_record.is_a?(Collection) ? add_to_collection(child_record, parent_record) : add_to_work(child_record, parent_record)
+
+      child_record.file_sets.each(&:update_index) if update_child_records_works_file_sets? && child_record.respond_to?(:file_sets)
+      relationship.destroy
     end
 
-    # Collection-Collection membership is added to the as member_ids
-    def collection_parent_collection_child
-      child_records[:collections].each do |child_record|
-        ::Hyrax::Collections::NestedCollectionPersistenceService.persist_nested_collection_for(parent: parent_record, child: child_record)
-        ImporterRun.find(importer_run_id).increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
-      end
+    def add_to_collection(child_record, parent_record)
+      child_record.member_of_collections << parent_record
+      child_record.save!
     end
 
-    # Work-Work membership is added to the parent as member_ids
-    def work_parent_work_child
-      records_hash = {}
-      child_records[:works].each_with_index do |child_record, i|
-        records_hash[i] = { id: child_record.id }
-      end
-      attrs = { work_members_attributes: records_hash }
-      parent_record.try(:reindex_extent=, Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX)
-      env = Hyrax::Actors::Environment.new(parent_record, Ability.new(user), attrs)
+    def add_to_work(child_record, parent_record)
+      return true if parent_record.ordered_members.to_a.include?(child_record)
 
-      Hyrax::CurationConcern.actor.update(env)
-      ImporterRun.find(importer_run_id).increment!(:processed_relationships, child_records[:works].count) # rubocop:disable Rails/SkipsModelValidations
+      parent_record.ordered_members << child_record
+      @parent_record_members_added = true
+      # TODO: Do we need to save the child record?
+      child_record.save!
     end
 
     def reschedule(parent_identifier:, importer_run_id:)

data/app/jobs/bulkrax/delete_job.rb

@@ -13,7 +13,7 @@ module Bulkrax
       entry.save!
       entry.importer.current_run = ImporterRun.find(importer_run.id)
       entry.importer.record_status
-      entry.status_info("Deleted", ImporterRun.find(importer_run.id))
+      entry.set_status_info("Deleted", ImporterRun.find(importer_run.id))
     end
     # rubocop:enable Rails/SkipsModelValidations
   end

data/app/jobs/bulkrax/export_work_job.rb

@@ -29,9 +29,9 @@ module Bulkrax
       return entry if exporter_run.enqueued_records.positive?
 
       if exporter_run.failed_records.positive?
-        exporter_run.exporter.status_info('Complete (with failures)')
+        exporter_run.exporter.set_status_info('Complete (with failures)')
       else
-        exporter_run.exporter.status_info('Complete')
+        exporter_run.exporter.set_status_info('Complete')
       end
 
       return entry

data/app/jobs/bulkrax/import_file_set_job.rb

@@ -2,6 +2,7 @@
 
 module Bulkrax
   class MissingParentError < ::StandardError; end
+
   class ImportFileSetJob < ApplicationJob
     include DynamicRecordLookup
 
@@ -40,7 +41,7 @@ module Bulkrax
         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)
+        entry.set_status_info(e)
       end
     end
 

data/app/jobs/bulkrax/import_work_job.rb

@@ -5,7 +5,7 @@ module Bulkrax
     queue_as :import
 
     # rubocop:disable Rails/SkipsModelValidations
-    def perform(entry_id, run_id, *)
+    def perform(entry_id, run_id, time_to_live = 3, *)
       entry = Entry.find(entry_id)
       importer_run = ImporterRun.find(run_id)
       entry.build
@@ -24,13 +24,21 @@ module Bulkrax
       entry.save!
       entry.importer.current_run = importer_run
       entry.importer.record_status
-    rescue Bulkrax::CollectionsCreatedError
-      reschedule(entry_id, run_id)
+    rescue Bulkrax::CollectionsCreatedError => e
+      Rails.logger.warn("#{self.class} entry_id: #{entry_id}, run_id: #{run_id} encountered #{e.class}: #{e.message}")
+      # You get 3 attempts at the above perform before we have the import exception cascade into
+      # the Sidekiq retry ecosystem.
+      # rubocop:disable Style/IfUnlessModifier
+      if time_to_live <= 1
+        raise "Exhauted reschedule limit for #{self.class} entry_id: #{entry_id}, run_id: #{run_id}.  Attemping retries"
+      end
+      # rubocop:enable Style/IfUnlessModifier
+      reschedule(entry_id, run_id, time_to_live)
     end
     # rubocop:enable Rails/SkipsModelValidations
 
-    def reschedule(entry_id, run_id)
-      ImportWorkJob.set(wait: 1.minute).perform_later(entry_id, run_id)
+    def reschedule(entry_id, run_id, time_to_live)
+      ImportWorkJob.set(wait: 1.minute).perform_later(entry_id, run_id, time_to_live - 1)
     end
   end
 end

data/app/jobs/bulkrax/importer_job.rb

@@ -13,7 +13,7 @@ module Bulkrax
       update_current_run_counters(importer)
       schedule(importer) if importer.schedulable?
     rescue CSV::MalformedCSVError => e
-      importer.status_info(e)
+      importer.set_status_info(e)
     end
 
     def import(importer, only_updates_since_last_import)

data/app/matchers/bulkrax/application_matcher.rb

@@ -6,6 +6,10 @@ module Bulkrax
   class ApplicationMatcher
     attr_accessor :to, :from, :parsed, :if, :split, :excluded, :nested_type
 
+    # New parse methods will need to be added here; you'll also want to define a corresponding
+    # "parse_#{field}" method.
+    class_attribute :parsed_fields, instance_writer: false, default: ['remote_files', 'language', 'subject', 'types', 'model', 'resource_type', 'format_original']
+
     def initialize(args)
       args.each do |k, v|
         send("#{k}=", v)
@@ -38,8 +42,6 @@ module Bulkrax
     end
 
     def process_parse
-      # New parse methods will need to be added here
-      parsed_fields = ['remote_files', 'language', 'subject', 'types', 'model', 'resource_type', 'format_original']
       # This accounts for prefixed matchers
       parser = parsed_fields.find { |field| to&.include? field }
 

data/app/models/bulkrax/csv_entry.rb

@@ -7,7 +7,7 @@ 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
-    serialize :raw_metadata, JSON
+    serialize :raw_metadata, Bulkrax::NormalizedJson
 
     def self.fields_from_data(data)
       data.headers.flatten.compact.uniq
@@ -36,10 +36,14 @@ module Bulkrax
 
     def build_metadata
       raise StandardError, 'Record not found' if record.nil?
-      raise StandardError, "Missing required elements, missing element(s) are: #{importerexporter.parser.missing_elements(keys_without_numbers(record.keys)).join(', ')}" unless importerexporter.parser.required_elements?(keys_without_numbers(record.keys))
+      unless importerexporter.parser.required_elements?(keys_without_numbers(record.keys))
+        raise StandardError,
+"Missing required elements, missing element(s) are: #{importerexporter.parser.missing_elements(keys_without_numbers(record.keys)).join(', ')}"
+      end
 
       self.parsed_metadata = {}
       add_identifier
+      establish_factory_class
       add_ingested_metadata
       # TODO(alishaevn): remove the collections stuff entirely and only reference collections via the new parents code
       add_collections
@@ -56,6 +60,12 @@ module Bulkrax
       self.parsed_metadata[work_identifier] = [record[source_identifier]]
     end
 
+    def establish_factory_class
+      parser.model_field_mappings.each do |key|
+        add_metadata('model', record[key]) if record.key?(key)
+      end
+    end
+
     def add_metadata_for_model
       if factory_class == Collection
         add_collection_type_gid
@@ -107,7 +117,9 @@ module Bulkrax
     # Metadata required by Bulkrax for round-tripping
     def build_system_metadata
       self.parsed_metadata['id'] = hyrax_record.id
-      self.parsed_metadata[source_identifier] = hyrax_record.send(work_identifier)
+      source_id = hyrax_record.send(work_identifier)
+      source_id = source_id.to_a.first if source_id.is_a?(ActiveTriples::Relation)
+      self.parsed_metadata[source_identifier] = source_id
       self.parsed_metadata[key_for_export('model')] = hyrax_record.has_model.first
     end
 

data/app/models/bulkrax/entry.rb

@@ -4,6 +4,7 @@ module Bulkrax
   # Custom error class for collections_created?
   class CollectionsCreatedError < RuntimeError; end
   class OAIError < RuntimeError; end
+
   class Entry < ApplicationRecord
     include Bulkrax::HasMatchers
     include Bulkrax::ImportBehavior
@@ -15,7 +16,7 @@ module Bulkrax
     alias importer importerexporter
     alias exporter importerexporter
 
-    serialize :parsed_metadata, JSON
+    serialize :parsed_metadata, Bulkrax::NormalizedJson
     # Do not serialize raw_metadata as so we can support xml or other formats
     serialize :collection_ids, Array