bulkrax 4.3.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c636e3c53228a9cd6f2d45356f10b2339265f5f3f11b32bd6e523a01388b60b
-  data.tar.gz: 6eeb6679cc8e93f77926baa30f91b09c9cea173d7d4135c2be9e865b558d5056
+  metadata.gz: 49a1f0ccc806cf73a7872a634c8c2819dac62f98f0a9dc163e7ada8931d9b1fe
+  data.tar.gz: ecf5c8ad3e4864110665cfb5c6c5f6329e3b868414815bba163646db839400e7
 SHA512:
-  metadata.gz: 389a8059749407dc1a6d9326e60131934b9729aaf33f1a4802c72255550fdf7e71ad874c88969e244dccf81e80ad95eb09e30179425fb1313fc2383d7f7adc7a
-  data.tar.gz: c58567026f654f0577377babd2311f537c3155f6c71833255d13730dc32eed51ec9a0708f0283b925e09945b59d338a14ffdb9945e0375de5ff7be120ed62559
+  metadata.gz: df394e4fbbc6ca0a71eb595c075c5181d24098b1ab889ff185da10991ec01c2eaf60239658564838b67df4c0a421306de923d2eab4bbeffafb31321acb9ba1ff
+  data.tar.gz: 35b691e96d0e59f83efadc35364283239f7f741ab4bf9d859756dacc8483e380090512cd10bf3b6ec4ce81936d00c88eb4d1ed96742c384e0f3082028ffdcf45

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

@@ -1,10 +1,12 @@
 function hideUnhide(field) {
   var allSources = $('body').find('.export-source-option')
+  removeRequired(allSources)
   hide(allSources)
 
   if (field.length > 0) {
     var selectedSource = $('.' + field)
     unhideSelected(selectedSource)
+    addRequired(selectedSource)
   }
 
   if (field === 'collection') {
@@ -12,6 +14,16 @@ function hideUnhide(field) {
   }
 };
 
+function addRequired(selectedSource) {  
+  selectedSource.addClass('required').attr('required', 'required');
+  selectedSource.parent().addClass('required');
+}
+
+function removeRequired(allSources) {
+  allSources.removeClass('required').removeAttr('required');
+  allSources.parent().removeClass('required').removeAttr('required')
+};
+
 // hide all export_source
 function hide(allSources) {
   allSources.addClass('hidden');

data/app/controllers/bulkrax/entries_controller.rb

@@ -7,6 +7,7 @@ module Bulkrax
   class EntriesController < ApplicationController
     include Hyrax::ThemedLayoutController
     before_action :authenticate_user!
+    before_action :check_permissions
     with_themed_layout 'dashboard'
 
     def show
@@ -40,5 +41,9 @@ module Bulkrax
       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

@@ -7,6 +7,7 @@ module Bulkrax
     include Hyrax::ThemedLayoutController
     include Bulkrax::DownloadBehavior
     before_action :authenticate_user!
+    before_action :check_permissions
     before_action :set_exporter, only: [:show, :edit, :update, :destroy]
     with_themed_layout 'dashboard'
 
@@ -131,5 +132,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

@@ -14,6 +14,7 @@ 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'
 
@@ -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'
@@ -276,7 +280,7 @@ module Bulkrax
     def setup_client(url)
       return false if url.nil?
       headers = { from: Bulkrax.server_name }
-      @client ||= OAI::Client.new(url, headers: headers, parser: 'libxml', metadata_prefix: 'oai_dc')
+      @client ||= OAI::Client.new(url, headers: headers, parser: 'libxml')
     end
 
     # Download methods
@@ -316,6 +320,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)
@@ -159,28 +188,55 @@ module Bulkrax
       file_set_attrs = attrs.slice(*object.attributes.keys)
       object.assign_attributes(file_set_attrs)
 
-      attrs['uploaded_files'].each do |uploaded_file_id|
+      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)
+        create_file_set_actor(attrs, work, work_permissions, uploaded_file)
+      end
+      attrs['remote_files']&.each do |remote_file|
+        create_file_set_actor(attrs, work, work_permissions, nil, remote_file)
       end
 
       object.save!
     end
 
+    def create_file_set_actor(attrs, work, work_permissions, uploaded_file, remote_file = nil)
+      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(attrs)
+      actor.create_content(uploaded_file) if uploaded_file
+      actor.attach_to_work(work, attrs)
+      handle_remote_file(remote_file: remote_file, actor: actor, update: false) if remote_file
+    end
+
     def update_file_set(attrs)
       file_set_attrs = attrs.slice(*object.attributes.keys)
       actor = ::Hyrax::Actors::FileSetActor.new(object, @user)
-
+      attrs['remote_files']&.each do |remote_file|
+        handle_remote_file(remote_file: remote_file, actor: actor, update: true)
+      end
       actor.update_metadata(file_set_attrs)
     end
 
+    def handle_remote_file(remote_file:, actor:, update: false)
+      actor.file_set.label = remote_file['file_name']
+      actor.file_set.import_url = remote_file['url']
+
+      url = remote_file['url']
+      tmp_file = Tempfile.new(remote_file['file_name'].split('.').first)
+      tmp_file.binmode
+
+      URI.open(url) do |url_file|
+        tmp_file.write(url_file.read)
+      end
+
+      tmp_file.rewind
+      update == true ? actor.update_content(tmp_file) : actor.create_content(tmp_file, from_url: true)
+      tmp_file.close
+    end
+
     def clean_attrs(attrs)
       # avoid the "ArgumentError: Identifier must be a string of size > 0 in order to be treeified" error
       # when setting object.attributes
@@ -200,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/jobs/bulkrax/create_relationships_job.rb

@@ -81,7 +81,7 @@ module Bulkrax
     # 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.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX
+      parent_record.try(:reindex_extent=, Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX)
 
       parent_record.add_member_objects(child_work_ids)
       ImporterRun.find(importer_run_id).increment!(:processed_relationships, child_work_ids.count) # rubocop:disable Rails/SkipsModelValidations

data/app/jobs/bulkrax/import_file_set_job.rb

@@ -2,6 +2,7 @@
 
 module Bulkrax
   class MissingParentError < ::StandardError; end
+
   class ImportFileSetJob < ApplicationJob
     include DynamicRecordLookup
 

data/app/jobs/bulkrax/import_work_job.rb

@@ -5,30 +5,40 @@ module Bulkrax
     queue_as :import
 
     # rubocop:disable Rails/SkipsModelValidations
-    def perform(*args)
-      entry = Entry.find(args[0])
+    def perform(entry_id, run_id, time_to_live = 3, *)
+      entry = Entry.find(entry_id)
+      importer_run = ImporterRun.find(run_id)
       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
+        importer_run.increment!(:processed_records)
+        importer_run.increment!(:processed_works)
       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
+        importer_run.increment!(:failed_records)
+        importer_run.increment!(:failed_works)
       end
+      # Regardless of completion or not, we want to decrement the enqueued records.
+      importer_run.decrement!(:enqueued_records) unless importer_run.enqueued_records <= 0
+
       entry.save!
-      entry.importer.current_run = ImporterRun.find(args[1])
+      entry.importer.current_run = importer_run
       entry.importer.record_status
-    rescue Bulkrax::CollectionsCreatedError
-      reschedule(args[0], args[1])
+    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/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)
@@ -30,7 +34,7 @@ module Bulkrax
 
     def process_split
       if self.split.is_a?(TrueClass)
-        @result = @result.split(/\s*[:;|]\s*/) # default split by : ; |
+        @result = @result.split(Bulkrax.multi_value_element_split_on)
       elsif self.split
         result = @result.split(Regexp.new(self.split))
         @result = result.map(&:strip)
@@ -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
@@ -18,7 +18,7 @@ module Bulkrax
       raise StandardError, 'CSV path empty' if path.blank?
       CSV.read(path,
         headers: true,
-        header_converters: :symbol,
+        header_converters: ->(h) { h.to_sym },
         encoding: 'utf-8')
     end
 
@@ -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
@@ -81,7 +91,7 @@ module Bulkrax
     def add_file
       self.parsed_metadata['file'] ||= []
       if record['file']&.is_a?(String)
-        self.parsed_metadata['file'] = record['file'].split(/\s*[;|]\s*/)
+        self.parsed_metadata['file'] = record['file'].split(Bulkrax.multi_value_element_split_on)
       elsif record['file'].is_a?(Array)
         self.parsed_metadata['file'] = record['file']
       end
@@ -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
 
@@ -176,7 +188,7 @@ module Bulkrax
       data = hyrax_record.send(key.to_s)
       if data.is_a?(ActiveTriples::Relation)
         if value['join']
-          self.parsed_metadata[key_for_export(key)] = data.map { |d| prepare_export_data(d) }.join(' | ').to_s # TODO: make split char dynamic
+          self.parsed_metadata[key_for_export(key)] = data.map { |d| prepare_export_data(d) }.join(Bulkrax.multi_value_element_join_on).to_s
         else
           data.each_with_index do |d, i|
             self.parsed_metadata["#{key_for_export(key)}_#{i + 1}"] = prepare_export_data(d)
@@ -236,7 +248,7 @@ module Bulkrax
 
     def handle_join_on_export(key, values, join)
       if join
-        parsed_metadata[key] = values.join(' | ') # TODO: make split char dynamic
+        parsed_metadata[key] = values.join(Bulkrax.multi_value_element_join_on)
       else
         values.each_with_index do |value, i|
           parsed_metadata["#{key}_#{i + 1}"] = value
@@ -260,7 +272,7 @@ module Bulkrax
       return [] unless parent_field_mapping.present? && record[parent_field_mapping].present?
 
       identifiers = []
-      split_references = record[parent_field_mapping].split(/\s*[;|]\s*/)
+      split_references = record[parent_field_mapping].split(Bulkrax.multi_value_element_split_on)
       split_references.each do |c_reference|
         matching_collection_entries = importerexporter.entries.select do |e|
           (e.raw_metadata&.[](source_identifier) == c_reference) &&

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
 

data/app/models/bulkrax/importer.rb

@@ -58,17 +58,26 @@ module Bulkrax
 
     # If field_mapping is empty, setup a default based on the export_properties
     def mapping
+      # rubocop:disable Style/IfUnlessModifier
       @mapping ||= if self.field_mapping.blank? || self.field_mapping == [{}]
                      if parser.import_fields.present? || self.field_mapping == [{}]
-                       ActiveSupport::HashWithIndifferentAccess.new(
-                         parser.import_fields.reject(&:nil?).map do |m|
-                           Bulkrax.default_field_mapping.call(m)
-                         end.inject(:merge)
-                       )
+                       default_field_mapping
                      end
                    else
-                     self.field_mapping
+                     default_field_mapping.merge(self.field_mapping)
                    end
+
+      # rubocop:enable Style/IfUnlessModifier
+    end
+
+    def default_field_mapping
+      return self.field_mapping if parser.import_fields.nil?
+
+      ActiveSupport::HashWithIndifferentAccess.new(
+        parser.import_fields.reject(&:nil?).map do |m|
+          Bulkrax.default_field_mapping.call(m)
+        end.inject(:merge)
+      )
     end
 
     def parser_fields
@@ -143,17 +152,13 @@ module Bulkrax
       import_objects(['relationship'])
     end
 
+    DEFAULT_OBJECT_TYPES = %w[collection work file_set relationship].freeze
+
     def import_objects(types_array = nil)
       self.only_updates ||= false
-      types = types_array || %w[collection work file_set relationship]
-      if parser.class == Bulkrax::CsvParser
-        parser.create_objects(types)
-      else
-        types.each do |object_type|
-          self.save if self.new_record? # Object needs to be saved for statuses
-          parser.send("create_#{object_type.pluralize}")
-        end
-      end
+      self.save if self.new_record? # Object needs to be saved for statuses
+      types = types_array || DEFAULT_OBJECT_TYPES
+      parser.create_objects(types)
     rescue StandardError => e
       status_info(e)
     end

data/app/models/bulkrax/oai_entry.rb

@@ -5,7 +5,7 @@ require 'ostruct'
 
 module Bulkrax
   class OaiEntry < Entry
-    serialize :raw_metadata, JSON
+    serialize :raw_metadata, Bulkrax::NormalizedJson
 
     delegate :record, to: :raw_record
 
@@ -28,13 +28,16 @@ module Bulkrax
     def build_metadata
       self.parsed_metadata = {}
       self.parsed_metadata[work_identifier] = [record.header.identifier]
+      self.raw_metadata = { xml: record.metadata.to_s }
 
-      record.metadata.children.each do |child|
-        child.children.each do |node|
-          add_metadata(node.name, node.content)
-        end
-      end
-      add_metadata('thumbnail_url', thumbnail_url)
+      # We need to establish the #factory_class before we proceed with the metadata.  See
+      # https://github.com/samvera-labs/bulkrax/issues/702 for further details.
+      #
+      # tl;dr - if we don't have the right factory_class we might skip properties that are
+      # specifically assigned to the factory class
+      establish_factory_class
+      add_metadata_from_record
+      add_thumbnail_url
 
       add_visibility
       add_rights_statement
@@ -53,18 +56,48 @@ module Bulkrax
       end
     end
 
+    # To ensure we capture the correct parse data, we first need to establish the factory_class.
+    # @see https://github.com/samvera-labs/bulkrax/issues/702
+    def establish_factory_class
+      model_field_names = parser.model_field_mappings
+
+      each_candidate_metadata_node do |node|
+        next unless model_field_names.include?(node.name)
+        add_metadata(node.name, node.content)
+      end
+    end
+
+    def add_metadata_from_record
+      each_candidate_metadata_node do |node|
+        add_metadata(node.name, node.content)
+      end
+    end
+
+    # A method that you could override to better handle the shape of the record's metadata.
+    # @yieldparam node [Object<#name, #content>]
+    def each_candidate_metadata_node
+      record.metadata.children.each do |child|
+        child.children.each do |node|
+          yield(node)
+        end
+      end
+    end
+
+    def add_thumbnail_url
+      add_metadata('thumbnail_url', thumbnail_url)
+    end
+
     # Retrieve list of collections for the entry; add to collection_ids
     # If OAI-PMH doesn't return setSpec in the headers for GetRecord, use parser.collection_name
     #   in this case, if 'All' is selected, records will not be added to a collection.
     def find_collection_ids
       return self.collection_ids if collections_created?
       if sets.blank? || parser.collection_name != 'all'
-        # c = Collection.where(Bulkrax.system_identifier_field => importerexporter.unique_collection_identifier(parser.collection_name)).first
         collection = find_collection(importerexporter.unique_collection_identifier(parser.collection_name))
         self.collection_ids << collection.id if collection.present? && !self.collection_ids.include?(collection.id)
       else # All - collections should exist for all sets
         sets.each do |set|
-          c = Collection.find_by(work_identifier => importerexporter.unique_collection_identifier(set.content))
+          c = find_collection(importerexporter.unique_collection_identifier(set.content))
           self.collection_ids << c.id if c.present? && !self.collection_ids.include?(c.id)
         end
       end

data/app/models/bulkrax/rdf_entry.rb

@@ -3,7 +3,7 @@
 require 'rdf'
 module Bulkrax
   class RdfEntry < Entry
-    serialize :raw_metadata, JSON
+    serialize :raw_metadata, Bulkrax::NormalizedJson
 
     def self.read_data(path)
       RDF::Reader.open(path)