iiif_print 1.0.0 → 2.0.0

data/README.md

@@ -35,9 +35,9 @@ IiifPrint supports:
 * OCR keyword match highlighting
 * viewer with page navigation and deep zooming
 * splitting of PDFs to LZW compressed TIFFs for viewing
-* configuring how the manifest canvases are sorted in the viewer
 * adding metadata fields to the manifest with faceted search links and external links
 * excluding specified work types to be found in the catalog search
+* external IIIF image urls that work with services such as serverless-iiif or cantaloup
 
 A complete list of features can be found [here](https://github.com/scientist-softserv/iiif_print/wiki/Features-List).
 
@@ -86,15 +86,43 @@ IiifPrint easily integrates with your Hyrax 2.x applications.
 * In `config/routes.rb`, it adds `concerns :iiif_search` in the `resources :solr_documents` block
 * Adds `config/initializers/iiif_print.rb`
 * Adds three migrations, `CreateIiifPrintDerivativeAttachments`, `CreateIiifPrintIngestFileRelations`, and `CreateIiifPrintPendingRelationships`
-* In `solr/conf/schema.xml`, it adds Blacklight IIIF Search autocomplete config
-* In `solr/conf/solrconfig.xml`, it adds Blacklight IIIF Search autocomplete config
-* Adds `solr/lib/solr-tokenizing_suggester-7.x.jar`
 
 (It may be helpful to run `git diff` after installation to see all the changes made by the installer.)
 
+## Catalog to Universal Viewer search:
+To enable a feature where the UV automatically picks up the search from the catalog, do the following:
+* Add `highlight: urlDataProvider.get('q'),` into your uv.html in the `<script>` section.
+```js
+uv = createUV('#uv', {
+    root: '.',
+    iiifResourceUri: urlDataProvider.get('manifest'),
+    configUri: 'uv-config.json',
+    collectionIndex: Number(urlDataProvider.get('c', 0)),
+    manifestIndex: Number(urlDataProvider.get('m', 0)),
+    sequenceIndex: Number(urlDataProvider.get('s', 0)),
+    canvasIndex: Number(urlDataProvider.get('cv', 0)),
+    rangeId: urlDataProvider.get('rid', 0),
+    rotation: Number(urlDataProvider.get('r', 0)),
+    xywh: urlDataProvider.get('xywh', ''),
+    embedded: true,
+    highlight: urlDataProvider.get('q'), // <-- here's a good spot
+    locales: formattedLocales
+}, urlDataProvider);
+```
+
+* Make sure to remove your application's `app/helpers/hyrax/iiif_helper.rb` and `app/views/hyrax/base/iiif_viewers/_universal_viewer.html.erb` (if exists)
+
 ## Configuration to enable IiifPrint features
 **NOTE: WorkTypes and models are used synonymously here.**
 
+### Persistence Layer Adapter
+
+We created IiifPrint with an assumption of ActiveFedora.  However, as Hyrax now supports Valkyrie, we need an alternate approach.  We introduced `IiifPrint::Configuration#persistence_layer` as a configuration option.  By default it will use `ActiveFedora` methods; but you can switch adapters to use Valkyrie instead.  (See `IiifPrint::PersistentLayer` for more details).
+
+### IIIF URL configuration
+
+If you set EXTERNAL_IIIF_URL in your environment, then IiifPrint will use that URL as the root for your IIIF URLs. It will also switch from using the file set ID to using the SHA1 of the file as the identifier. This enables using serverless_iiif or Cantaloupe (refered to as the service) by pointing the service to the same S3 bucket that FCREPO writes the uploaded files to. By setting it up that way you do not need the service to connect to FCREPO or Hyrax at all, both natively support connecting to an S3 bucket to get their data.
+
 ### Model level configurations
 
 In `app/models/{work_type}.rb` add `include IiifPrint.model_configuration` to any work types which require IiifPrint processing features (such as PDF splitting or OCR derivatives). See [lib/iiif_print.rb](./lib/iiif_print.rb) for details on configuration options.
@@ -126,10 +154,6 @@ IiifPrint.config do |config|
   # Add configurable solr field key for searching, default key is: 'human_readable_type_sim' if
   # another key is used, make sure to adjust the config.excluded_model_name_solr_field_values to match
   config.excluded_model_name_solr_field_key = 'some_solr_field_key'
-
-  # Configure how the manifest sorts the canvases, by default it sorts by `:title`, but a different
-  # model property may be desired such as :date_published
-  config.sort_iiif_manifest_canvases_by = :date_published
 end
 ```
 
@@ -146,7 +170,7 @@ TO ENABLE OCR Search (from the UV and catalog search)
       }
     end
 ```
-* Set `config.search_builder_class = IiifPrint::CatalogSearchBuilder` to remove works from the catalog search results if `is_child_bsi: true` 
+* Set `config.search_builder_class = IiifPrint::CatalogSearchBuilder` to remove works from the catalog search results if `is_child_bsi: true`
 * Ensure that all text search is configured in default_solr_params config block:
 ```rb
     config.default_solr_params = {
@@ -156,6 +180,75 @@ TO ENABLE OCR Search (from the UV and catalog search)
     }
 ```
 
+To remove child works from recent works on homepage
+### homepage_controller.rb
+* In the HomepageController, change the search_builder_class to remove works from recent_documents if `is_child_bsi: true`
+```rb
+    require "iiif_print/homepage_search_builder"
+
+    def search_builder_class
+      IiifPrint::HomepageSearchBuilder
+    end
+```
+
+### Skipping Certain File Suffixes for PDF Splitting
+
+By default when a work is configured for splitting PDFs, we will split all PDFs.  However, in some cases you don't want to split based on the file name's suffix.  In that case, configure code as follows:
+
+```ruby
+IiifPrint.config do |config|
+  config.skip_splitting_pdf_files_that_end_with_these_texts = ['.reader.pdf']
+end
+```
+
+### Derivative Rodeo Configuration
+
+The Derivative Rodeo is used in two ways:
+
+- Configuring the `Hyrax::DerivativeService` by adding `IiifPrint::DerivativeRodeoService`
+- Enable Derivative Rodeo PDF Splitting service by `IiifPrint.model_configuration`
+
+#### Configuring Hyrax::Derivative
+
+In the application initializer:
+
+```ruby
+      Hyrax::DerivativeService.services = [
+        IiifPrint::DerivativeRodeoService,
+        Hyrax::FileSetDerivativesService]
+```
+
+#### Enabling Derivative Rodeo PDF Splitting
+
+The [IiifPrint.model\_configuration  method](./lib/iiif_print.rb) allows for specifying the `pdf\_splitter\_service` as below:
+
+```ruby
+class Book < ActiveFedora::Base
+  include IiifPrint.model_configuration(
+            pdf_splitter_service: IiifPrint::SplitPdfs::DerivativeRodeoSplitter
+          )
+end
+```
+
+#### Pre-Process Location
+
+The [DerivativeRodeo](https://github.com/scientist-softserv/derivative_rodeo) allows for specifying a location where you've done pre-processing (e.g. you ran splitting and derivative generation in AWS's Lambda).
+
+By default the preprocess location is S3, as that is where SoftServ has been running pre-processing.  However that default may not be adequate for local development.
+
+#### Conditional Derivative Generation
+
+The [IiifPrint::DerivativeRodeoService][./app/services/iiif_print/derivative_rodeo_service.rb] provides a means of specifying the derivatives to generate via two configuration points:
+
+- `IiifPrint::DerivativeRodeoService.named_derivatives_and_generators_by_type`
+- `IiifPrint::DerivativeRodeoService.named_derivatives_and_generators_filter`
+
+In the case of `named_derivatives_and_generators_by_type`, we're saying all mime categories will generate these derivatives.
+
+In the case of `named_derivatives_and_generators_filter`, we're providing a point where we can specify for each file_set and filename the specific derivatives to accept/reject/append to the named derivative generation.
+
+See their examples for further configuration guidance.
+
 # Ingesting Content
 
 IiifPrint supports a range of different ingest workflows:

data/Rakefile

@@ -35,4 +35,10 @@ end
 Dir.glob('tasks/*.rake').each { |r| import r }
 Dir.glob('lib/tasks/*.rake').each { |r| import r }
 
+# Adding the copy_authorities here so it runs the same in CI
+desc "Generate the engine_cart, copy authorities, and run tests"
+task prepare_and_run_tests: ['engine_cart:generate', 'engine_cart:copy_authorities'] do
+  puts "Running CI tests"
+end
+
 task default: :ci

data/app/actors/iiif_print/actors/cleanup_file_sets_actor_decorator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# override Hyrax to remove splitting upon work delete
+module IiifPrint
+  module Actors
+    # Responsible for removing FileSets related to the given curation concern.
+    module CleanupFileSetsActorDecorator
+      # @param [Hyrax::Actors::Environment] env
+      # @return [Boolean] true if destroy was successful
+      def destroy(env)
+        file_sets = env.curation_concern.file_sets
+        file_sets.each do |file_set|
+          # we destroy the children before the file_set, because we need the parent relationship
+          IiifPrint::SplitPdfs::DestroyPdfChildWorksService.conditionally_destroy_spawned_children_of(
+            file_set: file_set,
+            work: env.curation_concern
+          )
+        end
+        # and now back to your regularly scheduled programming
+        super
+      end
+    end
+  end
+end

data/app/actors/iiif_print/actors/file_set_actor_decorator.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-# override to add PDF splitting for file sets
+# override to add PDF splitting for file sets and remove splitting upon fileset delete
+
+# Depending on whether we have an uploaded file or a remote url, the sequence of calling
+# attach_to_work and create_content will switch.
 module IiifPrint
   module Actors
     module FileSetActorDecorator
@@ -9,48 +12,47 @@ module IiifPrint
         super
 
         if from_url
-          # we have everything we need... queue the job
-          parent = parent_for(file_set: @file_set)
-
-          if service.iiif_print_split?(work: parent) && service.pdfs?(paths: [file_set.import_url])
-            service.queue_job(
-              work: parent,
-              file_locations: [file.path],
-              user: @user,
-              admin_set_id: parent.admin_set_id
-            )
-          end
+          # in this case, the file that came in is a temp file, and we need to use the actual file.
+          # the file was attached to the file_set in Hyrax::ImportUrlJob so we can just access it.
+          args = { file_set: file_set, file: file_set.files.first, import_url: file_set.import_url, user: @user }
+          returned_value = service.conditionally_enqueue(**args)
+          Rails.logger.info("Result of #{returned_value} for conditional enqueueing of #{args.inspect}")
+          true
         else
           # we don't have the parent yet... save the paths for later use
-          @pdf_paths = service.pdf_paths(files: [file.id.to_s])
+          @file = file
         end
       end
 
-      # Prior to Hyrax v3.1.0, this method did not exist
-      # @param file_set [FileSet]
-      # @return [ActiveFedora::Base]
-      def parent_for(file_set:)
-        file_set.parent
-      end
-
       # Override to add PDF splitting
       def attach_to_work(work, file_set_params = {})
         # Locks to ensure that only one process is operating on the list at a time.
         super
 
-        return if @pdf_paths.blank?
-        return unless service.iiif_print_split?(work: work)
-        service.queue_job(
-          work: work,
-          file_locations: @pdf_paths,
-          user: @user,
-          admin_set_id: work.admin_set_id
-        )
+        # when we are importing a remote_url, this method is called before the file is attached.
+        # We want to short-circuit the process and prevent unnecessarily confusing logging.
+        return unless @file
+
+        args = { file_set: file_set, work: work, file: @file, user: @user }
+        returned_value = service.conditionally_enqueue(**args)
+        Rails.logger.info("Result of #{returned_value} for conditional enqueueing of #{args.inspect}")
+        true
       end
 
       def service
         IiifPrint::SplitPdfs::ChildWorkCreationFromPdfService
       end
+
+      # Clean up children when removing the fileset
+      def destroy
+        # we destroy the children before the file_set, because we need the parent relationship
+        IiifPrint::SplitPdfs::DestroyPdfChildWorksService.conditionally_destroy_spawned_children_of(
+          file_set: file_set,
+          work: IiifPrint.parent_for(file_set)
+        )
+        # and now back to your regularly scheduled programming
+        super
+      end
     end
   end
 end

data/app/controllers/iiif_print/split_pdfs_controller.rb

@@ -0,0 +1,38 @@
+module IiifPrint
+  # Responsible for coordinating the request to resplit a PDF.
+  class SplitPdfsController < ApplicationController
+    before_action :authenticate_user!
+
+    def create
+      @file_set = FileSet.where(id: params[:file_set_id]).first
+      authorize_create_split_request!(@file_set)
+      IiifPrint::Jobs::RequestSplitPdfJob.perform_later(file_set: @file_set, user: current_user)
+      respond_to do |wants|
+        wants.html { redirect_to polymorphic_path([main_app, @file_set]), notice: t("iiif_print.file_set.split_submitted", id: @file_set.id) }
+        wants.json { render json: { id: @file_set.id, to_param: @file_set.to_param }, status: :ok }
+      end
+    end
+
+    private
+
+    ##
+    # @param file_set [FileSet]
+    def authorize_create_split_request!(file_set)
+      # NOTE: Duplicates logic of Hyrax: https://github.com/samvera/hyrax/blob/b334e186e77691d7da8ed59ff27f091be1c2a700/app/controllers/hyrax/file_sets_controller.rb#L234-L241
+      #
+      # Namely if we don't have a file_set we need not proceed.
+      raise CanCan::AccessDenied unless file_set
+
+      ##
+      # Rely on CanCan's authorize! method.  We could add the :split_pdf action to the ability
+      # class.  But we're pigging backing on the idea that you can do this if you can edit the work.
+      authorize!(:edit, file_set)
+      raise "Expected #{file_set.class} ID=#{file_set.id} #to_param=#{file_set.to_param} to be a PDF.  Instead found mime_type of #{file_set.mime_type}." unless file_set.pdf?
+
+      work = IiifPrint.parent_for(file_set)
+      raise WorkNotConfiguredToSplitFileSetError.new(file_set: file_set, work: work) unless work&.iiif_print_config&.pdf_splitter_job&.presence
+
+      true
+    end
+  end
+end

data/app/helpers/iiif_print/iiif_helper_decorator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# OVERRIDE Hyrax v2.9.6 add #uv_search_param
+
+module IiifPrint
+  module IiifHelperDecorator
+    def iiif_viewer_display(work_presenter, locals = {})
+      render iiif_viewer_display_partial(work_presenter),
+             locals.merge(presenter: work_presenter)
+    end
+
+    def iiif_viewer_display_partial(work_presenter)
+      'hyrax/base/iiif_viewers/' + work_presenter.iiif_viewer.to_s
+    end
+
+    def universal_viewer_base_url
+      "#{request&.base_url}#{IiifPrint.config.uv_base_path}"
+    end
+
+    def universal_viewer_config_url
+      "#{request&.base_url}#{IiifPrint.config.uv_config_path}"
+    end
+
+    # Extract query param from search
+    def uv_search_param
+      search_params = current_search_session.try(:query_params) || {}
+      q = search_params['q'].presence || ''
+
+      "&q=#{url_encode(q)}" if q.present?
+    end
+  end
+end

data/app/helpers/iiif_print/iiif_print_helper_behavior.rb

@@ -0,0 +1,23 @@
+module IiifPrint::IiifPrintHelperBehavior
+  ##
+  # print the ocr snippets. if more than one, separate with <br/>
+  #
+  # @param options [Hash] options hash provided by Blacklight
+  # @return [String] snippets HTML to be rendered
+  # rubocop:disable Rails/OutputSafety
+  def render_ocr_snippets(options = {})
+    snippets = options[:value]
+    return if snippets.blank?
+
+    snippets_content = [content_tag('div',
+                                    "... #{snippets.first} ...".html_safe,
+                                    class: 'ocr_snippet first_snippet')]
+    if snippets.length > 1
+      snippets_content << render(partial: 'catalog/snippets_more',
+                                 locals: { snippets: snippets.drop(1),
+                                           options: options })
+    end
+    snippets_content.join("\n").html_safe
+  end
+  # rubocop:enable Rails/OutputSafety
+end

data/app/helpers/iiif_print_helper.rb

@@ -41,24 +41,4 @@ module IiifPrintHelper
     end
     hl_matches.uniq.sort.join(' ')
   end
-
-  ##
-  # print the ocr snippets. if more than one, separate with <br/>
-  #
-  # @param options [Hash] options hash provided by Blacklight
-  # @return [String] snippets HTML to be rendered
-  # rubocop:disable Rails/OutputSafety
-  def render_ocr_snippets(options = {})
-    snippets = options[:value]
-    snippets_content = [content_tag('div',
-                                    "... #{snippets.first} ...".html_safe,
-                                    class: 'ocr_snippet first_snippet')]
-    if snippets.length > 1
-      snippets_content << render(partial: 'catalog/snippets_more',
-                                 locals: { snippets: snippets.drop(1),
-                                           options: options })
-    end
-    snippets_content.join("\n").html_safe
-  end
-  # rubocop:enable Rails/OutputSafety
 end

data/app/indexers/concerns/iiif_print/child_work_indexer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module IiifPrint
+  module ChildWorkIndexer
+    def to_solr
+      super.tap do |index_document|
+        index_solr_doc(index_document)
+      end
+    end
+
+    def generate_solr_document
+      super.tap do |solr_doc|
+        index_solr_doc(solr_doc)
+      end
+    end
+
+    private
+
+    def index_solr_doc(solr_doc)
+      object ||= @object || resource
+      solr_doc['is_child_bsi'] ||= object.try(:is_child)
+      solr_doc['split_from_pdf_id_ssi'] ||= object.try(:split_from_pdf_id)
+      solr_doc['is_page_of_ssim'] = iiif_print_lineage_service.ancestor_ids_for(object)
+      solr_doc['member_ids_ssim'] = iiif_print_lineage_service.descendent_member_ids_for(object)
+    end
+  end
+end

data/app/indexers/concerns/iiif_print/file_set_indexer.rb

@@ -2,28 +2,56 @@
 
 module IiifPrint
   module FileSetIndexer
-    # Why `.decorate`?  In my tests for Rails 5.2, I'm not able to use the prepended nor included
-    # blocks to assign a class_attribute when I "prepend" a module to the base class.  This method
-    # allows me to handle that behavior.
-    #
-    # @param base [Class]
-    # @return [Class] the given base, now decorated in all of it's glory
-    def self.decorate(base)
-      base.prepend(self)
-      base.class_attribute :iiif_print_lineage_service, default: IiifPrint::LineageService
-      base
+    def to_solr
+      super.tap do |index_document|
+        index_solr_doc(index_document)
+      end
     end
 
     def generate_solr_document
       super.tap do |solr_doc|
-        # only UV viewable images should have is_page_of, it is only used for iiif search
-        solr_doc['is_page_of_ssim'] = iiif_print_lineage_service.ancestor_ids_for(object) if object.mime_type&.match(/image/)
-        # index for full text search
-        text = IiifPrint::Data::WorkDerivatives.data(from: object, of_type: 'txt')
-        text = text.tr("\n", ' ').squeeze(' ')
-        solr_doc['all_text_timv'] = text
-        solr_doc['all_text_tsimv'] = text
+        index_solr_doc(solr_doc)
       end
     end
+
+    private
+
+    def index_solr_doc(solr_doc)
+      object ||= @object || resource
+      # only UV viewable images should have is_page_of, it is only used for iiif search
+      solr_doc['is_page_of_ssim'] = IiifPrint::LineageService.ancestor_ids_for(object) if image?(object)
+      # index for full text search
+      solr_doc['all_text_tsimv'] = solr_doc['all_text_timv'] = all_text(object)
+      solr_doc['digest_ssim'] = find_checksum(object)
+    end
+
+    def image?(object)
+      mime_type = object.try(:mime_type) || object.original_file.try(:mime_type)
+      mime_type&.match(/image/)
+    end
+
+    def find_checksum(object)
+      file = object.original_file
+      return unless file
+
+      digest ||= if file.is_a?(Hyrax::FileMetadata)
+                   Array.wrap(file.checksum).first
+                 else # file is a Hydra::PCDM::File (ActiveFedora)
+                   file.digest.first
+                 end
+      return unless digest
+
+      digest.to_s
+    end
+
+    def all_text(object)
+      file = object.original_file
+      return unless file
+
+      text = IiifPrint.extract_text_for(file_set: object)
+      return text if text.blank?
+
+      text.tr("\n", ' ').squeeze(' ')
+    end
   end
 end

data/{lib → app/jobs}/iiif_print/jobs/application_job.rb

@@ -2,7 +2,8 @@ module IiifPrint
   module Jobs
     # TODO: Consider inheriting from ::Application job.  That means we would have the upstreams
     # based job behavior.
-    class ApplicationJob < ActiveJob::Base
+    class ApplicationJob < ::ApplicationJob
+      queue_as ::IiifPrint.config.ingest_queue_name
     end
   end
 end

data/app/jobs/iiif_print/jobs/child_works_from_pdf_job.rb

@@ -0,0 +1,153 @@
+require 'iiif_print/jobs/application_job'
+
+module IiifPrint
+  module Jobs
+    # @deprecated
+    class ChildWorksFromPdfJob < IiifPrint::Jobs::ApplicationJob
+      ##
+      # Break a pdf into individual pages
+      #
+      # @param candidate_for_parency [FileSet, Hydra::PCDM::Work]
+      # @param pdf_paths: [<Array => String>] paths to pdfs
+      # @param user: [User]
+      # @param admin_set_id: [<String>]
+      # rubocop:disable Metrics/MethodLength
+      def perform(id, pdf_paths, user, admin_set_id, *)
+        candidate_for_parency = IiifPrint.find_by(id: id)
+
+        ##
+        # We know that we have cases where parent_work is nil, this will definitely raise an
+        # exception; which is fine because we were going to do it later anyway.
+        @parent_work = if candidate_for_parency.work?
+                         pdf_file_set = nil
+                         candidate_for_parency
+                       else
+                         # We likely have a file set
+                         pdf_file_set = candidate_for_parency
+                         IiifPrint.parent_for(candidate_for_parency)
+                       end
+        @child_admin_set_id = admin_set_id
+        child_model = @parent_work.iiif_print_config.pdf_split_child_model
+
+        # When working with remote files, we have put the PDF file into the correct path before submitting this job.
+        # However, there seem to be cases where we still don't have the file when we get here, so to be sure, we
+        # re-do the same command that was previously used to prepare the file path. If the file is already here, it
+        # simply returns the path, but if not it will copy the file there, giving us one more chance to have what we need.
+        pdf_paths = [Hyrax::WorkingDirectory.find_or_retrieve(pdf_file_set.original_file.id, pdf_file_set.id, pdf_paths.first)] if pdf_file_set
+        # handle each input pdf (when input is a file set, we will only have one).
+        pdf_paths.each do |original_pdf_path|
+          split_pdf(original_pdf_path, user, child_model, pdf_file_set)
+        end
+
+        # Link newly created child works to the parent
+        # @param user: [User] user
+        # @param parent_id: [<String>] parent work id
+        # @param parent_model: [<String>] parent model
+        # @param child_model: [<String>] child model
+        IiifPrint::Jobs::CreateRelationshipsJob.set(wait: 10.minutes).perform_later(
+          user: user,
+          parent_id: @parent_work.id.to_s,
+          parent_model: @parent_work.class.to_s,
+          child_model: child_model.to_s
+        )
+
+        # TODO: clean up image_files and pdf_paths
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Metrics/MethodLength
+      def split_pdf(original_pdf_path, user, child_model, pdf_file_set)
+        user = User.find_by_user_key(user) unless user.is_a?(User)
+        image_files = @parent_work.iiif_print_config.pdf_splitter_service.call(original_pdf_path)
+
+        # give as much info as possible if we don't have image files to work with.
+        if image_files.blank?
+          raise "#{@parent_work.class} (ID=#{@parent_work.id} " \
+                "to_param:#{@parent_work.to_param}) " \
+                "original_pdf_path #{original_pdf_path.inspect} " \
+                "pdf_file_set #{pdf_file_set.inspect}"
+        end
+
+        @split_from_pdf_id = pdf_file_set&.id.to_s
+        prepare_import_data(original_pdf_path, image_files, user)
+
+        # submit the job to create all the child works for one PDF
+        # @param [User] user
+        # @param [Hash<String => String>] titles
+        # @param [Hash<String => String>] resource_types (optional)
+        # @param [Array<String>] uploaded_files Hyrax::UploadedFile IDs
+        # @param [Hash] attributes attributes to apply to all works, including :model
+        # @param [Hyrax::BatchCreateOperation] operation
+        operation = Hyrax::BatchCreateOperation.create!(
+          user: user,
+          operation_type: "PDF Batch Create"
+        )
+        BatchCreateJob.perform_later(user,
+                                     @child_work_titles,
+                                     {},
+                                     @uploaded_files,
+                                     attributes.merge!(model: child_model.to_s, split_from_pdf_id: @split_from_pdf_id).with_indifferent_access,
+                                     operation)
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/ParameterLists
+
+      # rubocop:disable Metrics/MethodLength
+      def prepare_import_data(original_pdf_path, image_files, user)
+        @uploaded_files = []
+        @child_work_titles = {}
+        number_of_pages_in_pdf = image_files.size
+        image_files.each_with_index do |image_path, page_number|
+          file_id = create_uploaded_file(user, image_path).to_s
+
+          child_title = IiifPrint.config.unique_child_title_generator_function.call(
+            original_pdf_path: original_pdf_path,
+            image_path: image_path,
+            parent_work: @parent_work,
+            page_number: page_number,
+            page_padding: number_of_digits(nbr: number_of_pages_in_pdf)
+          )
+
+          @uploaded_files << file_id
+          @child_work_titles[file_id] = child_title
+          # save child work info to create the member relationships
+          PendingRelationship.create!(child_title: child_title,
+                                      parent_id: @parent_work.id,
+                                      child_order: child_title,
+                                      parent_model: @parent_work.class,
+                                      child_model: @parent_work.iiif_print_config.pdf_split_child_model,
+                                      file_id: @split_from_pdf_id)
+
+          begin
+            # Clean up the temporary image path.
+            FileUtils.rm_f(image_path) if File.exist?(image_path)
+          rescue
+            # If we can't delete, let's move on.  Maybe it was already cleaned-up.
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def number_of_digits(nbr:)
+        nbr.to_s.size
+      end
+
+      def create_uploaded_file(user, path)
+        # TODO: Could we create a remote path?
+        uf = Hyrax::UploadedFile.new
+        uf.user_id = user.try(:id) || user
+        uf.file = CarrierWave::SanitizedFile.new(path)
+        uf.save!
+        uf.id
+      end
+
+      # TODO: what attributes do we need to fill in from the parent work? What about AllinsonFlex?
+      def attributes
+        IiifPrint.config.child_work_attributes_function.call(parent_work: @parent_work, admin_set_id: @child_admin_set_id)
+      end
+    end
+  end
+end