iiif_print 1.1.0 → 2.0.1

data/lib/iiif_print/persistence_layer/valkyrie_adapter.rb

@@ -0,0 +1,183 @@
+module IiifPrint
+  module PersistenceLayer
+    class ValkyrieAdapter < AbstractAdapter
+      ##
+      # @param object [Valkyrie::Resource]
+      # @return [Array<Valkyrie::Resource>]
+      def self.object_in_works(object)
+        Array.wrap(Hyrax.custom_queries.find_parent_work(resource: object))
+      end
+
+      ##
+      # @param object [Valkyrie::Resource]
+      # @return [Array<Valkyrie::Resource>]
+      def self.object_ordered_works(object)
+        child_file_sets = Hyrax.custom_queries.find_child_file_sets(resource: object).to_a
+        child_works = Hyrax.custom_queries.find_child_works(resource: object).to_a
+        child_works + child_file_sets
+      end
+
+      ##
+      # @param work_type [Class<Valkyrie::Resource>]
+      # @return the indexer for the given :work_type
+      def self.decorate_with_adapter_logic(work_type:)
+        work_type.send(:include, Hyrax::Schema(:child_works_from_pdf_splitting)) unless work_type.included_modules.include?(Hyrax::Schema(:child_works_from_pdf_splitting))
+        # TODO: Use `Hyrax::ValkyrieIndexer.indexer_class_for` once changes are merged.
+        indexer = "#{work_type}Indexer".constantize
+        indexer.send(:include, Hyrax::Indexer(:child_works_from_pdf_splitting)) unless indexer.included_modules.include?(Hyrax::Indexer(:child_works_from_pdf_splitting))
+        indexer
+      end
+
+      ##
+      # @param work_type [Class<ActiveFedora::Base>]
+      # @return form for the given :work_type
+      def self.decorate_form_with_adapter_logic(work_type:)
+        form = "#{work_type}Form".constantize
+        form.send(:include, Hyrax::FormFields(:child_works_from_pdf_splitting)) unless form.included_modules.include?(Hyrax::FormFields(:child_works_from_pdf_splitting))
+        form
+      end
+
+      ##
+      # Return the immediate parent of the given :file_set.
+      #
+      # @param file_set [Hyrax::FileMetadata or FileSet]
+      # @return [#work?, Hydra::PCDM::Work]
+      # @return [NilClass] when no parent is found.
+      def self.parent_for(file_set)
+        file_set = Hyrax.query_service.find_by(id: file_set.file_set_id) if file_set.is_a?(Hyrax::FileMetadata)
+        Hyrax.query_service.find_parents(resource: file_set).first
+      end
+
+      ##
+      # Return the parent's parent of the given :file_set.
+      #
+      # @param file_set [Hyrax::FileMetadata or FileSet]
+      # @return [#work?, Hydra::PCDM::Work]
+      # @return [NilClass] when no grand parent is found.
+      def self.grandparent_for(file_set)
+        parent = parent_for(file_set)
+        return nil unless parent
+        Hyrax.query_service.find_parents(resource: parent).first
+      end
+
+      def self.solr_construct_query(*args)
+        Hyrax::SolrQueryBuilderService.construct_query(*args)
+      end
+
+      def self.clean_for_tests!
+        # For Fedora backed repositories, we'll want to consider some cleaning mechanism.  For
+        # database backed repositories, we can rely on the database_cleaner gem.
+        raise NotImplementedError
+      end
+
+      def self.solr_query(query, **args)
+        Hyrax::SolrService.query(query, **args)
+      end
+
+      def self.solr_name(field_name)
+        Hyrax.config.index_field_mapper.solr_name(field_name.to_s)
+      end
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def self.destroy_children_split_from(file_set:, work:, model:, user:)
+        # rubocop:enable Lint/UnusedMethodArgument
+        # look for child records by the file set id they were split from
+        Hyrax.query_service.find_inverse_references_by(resource: file_set, property: :split_from_pdf_id, model: model).each do |child|
+          Hyrax.persister.delete(resource: child)
+          Hyrax.indexing_service.delete(resource: child)
+          Hyrax.publisher.publish('object.deleted', object: child, user: user)
+        end
+        true
+      end
+
+      def self.pdf?(file_set)
+        file_set.original_file&.pdf?
+      end
+
+      ##
+      # Add a child record as a member of a parent record
+      #
+      # @param model [child_record] a Valkyrie::Resource model
+      # @param model [parent_record] a Valkyrie::Resource model
+      # @return [TrueClass]
+      def self.create_relationship_between(child_record:, parent_record:)
+        return true if parent_record.member_ids.include?(child_record.id)
+        parent_record.member_ids << child_record.id
+        true
+      end
+
+      ##
+      # find a work by title
+      # We should only find one, but there is no guarantee of that
+      # @param title [String]
+      # @param model [String] a Valkyrie::Resource model
+      # @return [Array<Valkyrie::Resource]
+      def self.find_by_title_for(title:, model:)
+        work_type = model.constantize
+        # TODO: This creates a hard dependency on Bulkrax because that is where this custom query is defined
+        #       Is this adequate?
+        Array.wrap(Hyrax.query_service.custom_query.find_by_model_and_property_value(model: work_type,
+                                                                                     property: :title,
+                                                                                     value: title))
+      end
+
+      ##
+      # find a work or file_set
+      #
+      # @param id [String]
+      def self.find_by(id:)
+        Hyrax.query_service.find_by(id: id)
+      end
+
+      ##
+      # save a work
+      #
+      # @param object [Array<Valkyrie::Resource]
+      def self.save(object:)
+        Hyrax.persister.save(resource: object)
+        Hyrax.index_adapter.save(resource: object)
+
+        Hyrax.publisher.publish('object.membership.updated', object: object, user: object.depositor)
+      end
+
+      ##
+      # reindex an array of works and their file_sets
+      #
+      # @param objects [Array<Valkyrie::Resource]
+      # @return [TrueClass]
+      def self.index_works(objects:)
+        objects.each do |work|
+          Hyrax.index_adapter.save(resource: work)
+          Hyrax.custom_queries.find_child_file_sets(resource: work).each do |file_set|
+            Hyrax.index_adapter.save(resource: file_set)
+          end
+        end
+        true
+      end
+
+      ##
+      # Performs an extra step to create the Hyrax::Metadata objects
+      # for derivatives.
+      #
+      # @param []
+      # @return [TrueClass]
+      def self.copy_derivatives_from_data_store(stream:, directives:)
+        Hyrax::ValkyriePersistDerivatives.call(stream, directives)
+      end
+
+      ##
+      # Extract text from the derivatives
+      #
+      # @param [Hyrax::FileSet] a Valkyrie fileset
+      # @return [String] Text from fileset's file
+      def self.extract_text_for(file_set:)
+        fm = Hyrax.custom_queries.find_many_file_metadata_by_use(resource: file_set,
+        use: Hyrax::FileMetadata::Use.uri_for(use: :extracted_file))
+        return if fm.empty?
+        text_fm = fm.find { |t| t.mime_type == Marcel::MimeType.for(extension: 'txt') }
+        return if text_fm.nil?
+        text_fm.content
+      end
+    end
+  end
+end

data/lib/iiif_print/persistence_layer.rb

@@ -0,0 +1,118 @@
+module IiifPrint
+  ##
+  # The PersistenceLayer module provides the namespace for other adapters:
+  #
+  # - {IiifPrint::PersistenceLayer::ActiveFedoraAdapter}
+  # - {IiifPrint::PersistenceLayer::ValkyrieAdapter}
+  #
+  # And the defining interface in the {IiifPrint::PersistenceLayer::AbstractAdapter}
+  module PersistenceLayer
+    # @abstract
+    class AbstractAdapter
+      ##
+      # @param object [Object]
+      # @return [Array<Object>]
+      def self.object_in_works(object)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @param object [Object]
+      # @return [Array<Object>]
+      def self.object_ordered_works(object)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @param work_type [Class]
+      # @return the corresponding indexer for the work_type
+      def self.decorate_with_adapter_logic(work_type:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @param work_type [Class]
+      # @return the corresponding indexer for the work_type
+      def self.decorate_form_with_adapter_logic(work_type:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @param file_set [Object]
+      # @param work [Object]
+      # @param model [Class] The class name for which we'll split children.
+      def self.destroy_children_split_from(file_set:, work:, model:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.parent_for(*)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.grandparent_for(*)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.solr_field_query(*)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.clean_for_tests!
+        return false unless Rails.env.test?
+        yield
+      end
+
+      ##
+      # @abstract
+      def self.solr_query(*args)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.solr_name(*args)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.pdf?(_file_set)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.create_relationship_between(child_record:, parent_record:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.find_by_title_for(title:, model:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.find_by(id:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.save(object:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.index_works(objects:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.copy_derivatives_from_data_store(stream:, directives:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.extract_text_for(file_set:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+    end
+  end
+end

data/lib/iiif_print/split_pdfs/base_splitter.rb

@@ -27,6 +27,17 @@ module IiifPrint
         new(path).to_a
       end
 
+      ##
+      # @api public
+      #
+      # Added to allow for fine-tuning of splitting decision such as tenant-based omission
+      # @see https://github.com/samvera/hyku/blob/main/app/services/iiif_print/tenant_config.rb
+      #
+      # @return [Boolean] returns false to not limit the splitting of PDFs
+      def self.never_split_pdfs?
+        false
+      end
+
       class_attribute :image_extension
       class_attribute :compression, default: nil
       class_attribute :quality, default: nil

data/lib/iiif_print/split_pdfs/child_work_creation_from_pdf_service.rb

@@ -29,9 +29,10 @@ module IiifPrint
         return :no_pdfs_to_split_for_import_url if import_url && !pdfs?(paths: [import_url])
 
         file_locations = if import_url
+                           # TODO: Fix this logic, currently unsupported in Bulkrax
                            [Hyrax::WorkingDirectory.find_or_retrieve(file.id, file_set.id)]
                          else
-                           pdf_paths(files: [file.try(:id)&.to_s].compact)
+                           pdf_paths(file: file)
                          end
         return :no_pdfs_to_split if file_locations.empty?
 
@@ -57,15 +58,21 @@ module IiifPrint
       # Load an array of paths to pdf files
       # @param [Array > Hyrax::Upload file ids]
       # @return [Array > String] file paths to temp directory
-      def self.pdf_paths(files:)
-        return [] if files.all?(&:empty?) # assumes an array
+      def self.pdf_paths(file:)
+        return [] unless file
 
-        upload_ids = filter_file_ids(files)
-        return [] if upload_ids.empty?
+        if file.class < Valkyrie::Resource
+          # assuming that if one PDF is uploaded to a Valkyrie resource then all of them should be
+          paths = [Hyrax.storage_adapter.file_path(file.file_identifier)]
+          pdfs_only_for(paths)
+        else
+          upload_ids = filter_file_ids(file.id.to_s)
+          return [] if upload_ids.empty?
 
-        uploads = Hyrax::UploadedFile.find(upload_ids)
-        paths = uploads.map(&method(:upload_path))
-        pdfs_only_for(paths)
+          uploads = Hyrax::UploadedFile.find(upload_ids)
+          paths = uploads.map(&method(:upload_path))
+          pdfs_only_for(paths)
+        end
       end
 
       ##
@@ -75,8 +82,11 @@ module IiifPrint
       # @param [GenericWork, etc] A valid type of hyrax work
       # @return [Boolean]
       def self.iiif_print_split?(work:)
+        config = work.try(:iiif_print_config)
+        return false unless config
+        return false if config.pdf_splitter_service.try(:never_split_pdfs?)
         # defined only if work has include IiifPrint.model_configuration with pdf_split_child_model
-        return true if work.try(:iiif_print_config)&.pdf_split_child_model
+        return true if config&.pdf_split_child_model
         false
       end
 

data/lib/iiif_print/split_pdfs/destroy_pdf_child_works_service.rb

@@ -7,26 +7,15 @@ module IiifPrint
       ## @api public
       # @param file_set [FileSet] What is the containing file set for the provided file.
       # @param work [Hydra::PCDM::Work] Parent of the fileset being deleted
-      def self.conditionally_destroy_spawned_children_of(file_set:, work:)
+      def self.conditionally_destroy_spawned_children_of(file_set:, work:, user: nil)
         child_model = work.try(:iiif_print_config)&.pdf_split_child_model
         return unless child_model
-        return unless file_set.class.pdf_mime_types.include?(file_set.mime_type)
+        return unless IiifPrint.pdf?(file_set)
 
+        # NOTE: The IiifPrint::PendingRelationship is an ActiveRecord object; hence we don't need to
+        # leverage an adapter.
         IiifPrint::PendingRelationship.where(parent_id: work.id, file_id: file_set.id).find_each(&:destroy)
-        destroy_spawned_children(model: child_model, file_set: file_set, work: work)
-      end
-
-      private_class_method def self.destroy_spawned_children(model:, file_set:, work:)
-        # look first for children by the file set id they were split from
-        children = model.where(split_from_pdf_id: file_set.id)
-        if children.blank?
-          # find works where file name and work `to_param` are both in the title
-          children = model.where(title: file_set.label).where(title: work.to_param)
-        end
-        return if children.blank?
-        children.each do |rcd|
-          rcd.destroy(eradicate: true)
-        end
+        IiifPrint.destroy_children_split_from(file_set: file_set, work: work, model: child_model, user: user)
       end
     end
   end

data/lib/iiif_print/text_extraction_derivative_service.rb

@@ -28,13 +28,15 @@ module IiifPrint
 
       ocr_derivatives.each do |extension, method_name|
         path = prepare_path(extension.to_s)
-        write(content: ocr.public_send(method_name), path: path)
+        write(content: ocr.public_send(method_name), path: path, extension: extension)
       end
     end
 
-    def write(content:, path:)
+    def write(content:, path:, extension:)
+      mime_type = mime_type_for(extension)
       File.open(path, 'w') do |outfile|
         outfile.write(content)
+        IiifPrint.copy_derivatives_from_data_store(stream: content, directives: { url: path, container: 'extracted_text', mime_type: mime_type })
       end
     end
 

data/lib/iiif_print/text_formats_from_alto_service.rb

@@ -4,9 +4,10 @@ module IiifPrint
   #   NOTE: to keep this from conflicting with TextExtractionDerivativeService,
   #         this class should be invoked by it, not PluggableDerivativeService.
   class TextFormatsFromALTOService < BaseDerivativeService
-    self.target_extension = 'tiff'.freeze
+    self.target_extension = 'txt'.freeze
 
     def save_derivative(destination, data)
+      mime_type = mime_type_for(destination)
       # Load/prepare base of "pairtree" dir structure for extension, fileset
       prepare_path(destination)
       #
@@ -17,6 +18,7 @@ module IiifPrint
       # Write data as UTF-8 encoded text
       File.open(save_path, "w:UTF-8") do |f|
         f.write(data)
+        IiifPrint.copy_derivatives_from_data_store(stream: data, directives: { url: file_set.id.to_s, container: 'extracted_text', mime_type: mime_type })
       end
     end
 

data/lib/iiif_print/tiff_derivative_service.rb

@@ -32,7 +32,9 @@ module IiifPrint
       source_path += '[0]' if @source_path.ends_with?('pdf')
       template = use_color? ? COLOR_CMD : GRAY_CMD
       template = MONO_CMD if one_bit?
-      format(template, source_file: source_path, out_file: @dest_path)
+      data = format(template, source_file: source_path, out_file: @dest_path)
+      IiifPrint.copy_derivatives_from_data_store(stream: data, directives: { url: file_set.id.to_s, container: 'service_file', mime_type: mime_type_for(target_extension) })
+      data
     end
 
     def create_derivatives(filename)

data/lib/iiif_print/version.rb

@@ -1,3 +1,3 @@
 module IiifPrint
-  VERSION = '1.1.0'.freeze
+  VERSION = '2.0.1'.freeze
 end

data/lib/iiif_print.rb

@@ -14,14 +14,14 @@ require "iiif_print/tiff_derivative_service"
 require "iiif_print/lineage_service"
 require "iiif_print/metadata"
 require "iiif_print/works_controller_behavior"
-require "iiif_print/jobs/application_job"
 require "iiif_print/blacklight_iiif_search/annotation_decorator"
-require "iiif_print/jobs/child_works_from_pdf_job"
-require "iiif_print/jobs/request_split_pdf_job"
 require "iiif_print/split_pdfs/base_splitter"
 require "iiif_print/split_pdfs/child_work_creation_from_pdf_service"
 require "iiif_print/split_pdfs/derivative_rodeo_splitter"
 require "iiif_print/split_pdfs/destroy_pdf_child_works_service"
+require "iiif_print/persistence_layer"
+require "iiif_print/persistence_layer/active_fedora_adapter"
+require "iiif_print/persistence_layer/valkyrie_adapter"
 
 # rubocop:disable Metrics/ModuleLength
 module IiifPrint
@@ -44,46 +44,45 @@ module IiifPrint
   end
 
   class << self
-    delegate :skip_splitting_pdf_files_that_end_with_these_texts, to: :config
-  end
-
-  ##
-  # Return the immediate parent of the given :file_set.
-  #
-  # @param file_set [FileSet]
-  # @return [#work?, Hydra::PCDM::Work]
-  # @return [NilClass] when no parent is found.
-  def self.parent_for(file_set)
-    # fallback to Fedora-stored relationships if work's aggregation of
-    #   file set is not indexed in Solr
-    file_set.parent || file_set.member_of.find(&:work?)
-  end
+    delegate(
+      :persistence_adapter,
+      :skip_splitting_pdf_files_that_end_with_these_texts,
+      to: :config
+    )
 
-  ##
-  # Return the parent's parent of the given :file_set.
-  #
-  # @param file_set [FileSet]
-  # @return [#work?, Hydra::PCDM::Work]
-  # @return [NilClass] when no grand parent is found.
-  def self.grandparent_for(file_set)
-    parent_of_file_set = parent_for(file_set)
-    # HACK: This is an assumption about the file_set structure, namely that an image page split from
-    # a PDF is part of a file set that is a child of a work that is a child of a single work.  That
-    # is, it only has one grand parent.  Which is a reasonable assumption for IIIF Print but is not
-    # valid when extended beyond IIIF Print.  That is GenericWork does not have a parent method but
-    # does have a parents method.
-    parent_of_file_set.try(:parent_works).try(:first) ||
-      parent_of_file_set.try(:parents).try(:first) ||
-      parent_of_file_set&.member_of&.find(&:work?)
+    delegate(
+      :clean_for_tests!,
+      :copy_derivatives_from_data_store,
+      :create_relationship_between,
+      :destroy_children_split_from,
+      :extract_text_for,
+      :find_by,
+      :find_by_title_for,
+      :grandparent_for,
+      :index_works,
+      :object_in_works,
+      :object_ordered_works,
+      :parent_for,
+      :pdf?,
+      :save,
+      :solr_construct_query,
+      :solr_name,
+      :solr_query,
+      to: :persistence_adapter
+    )
   end
 
+  # NOTE: We use lambdas so we can have default values but also provide a lazy configuration.
+  # There are certainly better ways but this is the least intrusive refactor from prior state.
   DEFAULT_MODEL_CONFIGURATION = {
     # Split a PDF into individual page images and create a new child work for each image.
-    pdf_splitter_job: IiifPrint::Jobs::ChildWorksFromPdfJob,
-    pdf_splitter_service: IiifPrint::SplitPdfs::PagesToJpgsSplitter,
-    derivative_service_plugins: [
-      IiifPrint::TextExtractionDerivativeService
-    ]
+    pdf_splitter_job: -> { IiifPrint::Jobs::ChildWorksFromPdfJob },
+    pdf_splitter_service: -> { IiifPrint::SplitPdfs::PagesToJpgsSplitter },
+    derivative_service_plugins: lambda {
+                                  [
+                                    IiifPrint::TextExtractionDerivativeService
+                                  ]
+                                }
   }.freeze
 
   # This is the record level configuration for PDF split handling.
@@ -127,23 +126,55 @@ module IiifPrint
   # @see IiifPrint::DEFAULT_MODEL_CONFIGURATION
   # @todo Because not every job will split PDFs and write to a child model. May want to introduce
   #       an alternative splitting method to create new filesets on the existing work instead of new child works.
+  # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
   def self.model_configuration(**kwargs)
     Module.new do
-      def iiif_print_config?
-        true
+      extend ActiveSupport::Concern
+
+      included do
+        work_type = self # In this case self is the class we're mixing the new module into.
+
+        # Ensure that the work_type and corresponding indexer are properly decorated for IiifPrint
+        indexer = if defined?(Valkyrie::Resource) && work_type < Valkyrie::Resource
+                    IiifPrint::PersistenceLayer::ValkyrieAdapter.decorate_with_adapter_logic(work_type: work_type)
+                  elsif work_type < ActiveFedora::Base
+                    IiifPrint::PersistenceLayer::ActiveFedoraAdapter.decorate_with_adapter_logic(work_type: work_type)
+                  else
+                    raise "Unable to mix '.model_configuration' into #{work_type}"
+                  end
+
+        # Ensure that the work_type and corresponding indexer are properly decorated for IiifPrint
+        if defined?(Valkyrie::Resource) && work_type < Valkyrie::Resource
+          IiifPrint::PersistenceLayer::ValkyrieAdapter.decorate_form_with_adapter_logic(work_type: work_type)
+        elsif work_type < ActiveFedora::Base
+          IiifPrint::PersistenceLayer::ActiveFedoraAdapter.decorate_form_with_adapter_logic(work_type: work_type)
+        else
+          raise "Unable to mix '.model_configuration' into #{work_type}"
+        end
+
+        # Deriving lineage of objects is a potentially complicated thing.  We provide a default
+        # service but each work_type's indexer can be configured by amending it's
+        # {.iiif_print_lineage_service}.
+        indexer.class_attribute(:iiif_print_lineage_service, default: IiifPrint::LineageService) unless indexer.respond_to?(:iiif_print_lineage_service)
+        work_type::GeneratedResourceSchema.send(:include, IiifPrint::SetChildFlag) if work_type.const_defined?(:GeneratedResourceSchema)
       end
 
       # We don't know what you may want in your configuration, but from this gems implementation,
       # we're going to provide the defaults to ensure that it works.
       DEFAULT_MODEL_CONFIGURATION.each_pair do |key, default_value|
-        kwargs[key] ||= default_value
+        kwargs[key] ||= default_value.call
       end
 
       define_method(:iiif_print_config) do
         @iiif_print_config ||= ModelConfig.new(**kwargs)
       end
+
+      def iiif_print_config?
+        true
+      end
     end
   end
+  # rubocop:enable Metrics/MethodLength
 
   # @api public
   #
@@ -262,11 +293,15 @@ module IiifPrint
     locations = locations.select { |location| split_for_path_suffix?(location, skip_these_endings: skip_these_endings) }
     return :no_pdfs_for_splitting if locations.empty?
 
+    # Hyrax::FileSet ids are Valkyrie::ID's which can't be passed, so we call id on that and get the string id
+    file_set_id = file_set.id.try(:id) || file_set.id
+    work_admin_set_id = work.admin_set_id.try(:id) || work.admin_set_id
+
     work.try(:iiif_print_config)&.pdf_splitter_job&.perform_later(
-      file_set,
+      file_set_id,
       locations,
       user,
-      work.admin_set_id,
+      work_admin_set_id,
       0 # A no longer used parameter; but we need to preserve the method signature (for now)
     )
   end
@@ -288,4 +323,4 @@ module IiifPrint
     !path.downcase.end_with?(*skip_these_endings.map(&:downcase))
   end
 end
-# rubocop:enable Metrics/ModuleLength
+# rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity