bulkrax 4.3.0 → 5.0.0

data/app/models/bulkrax/xml_entry.rb

@@ -4,7 +4,7 @@ require 'nokogiri'
 module Bulkrax
   # Generic XML Entry
   class XmlEntry < Entry
-    serialize :raw_metadata, JSON
+    serialize :raw_metadata, Bulkrax::NormalizedJson
 
     def self.fields_from_data(data); end
 
@@ -43,15 +43,14 @@ module Bulkrax
       raise StandardError, "Missing source identifier (#{source_identifier})" if self.raw_metadata[source_identifier].blank?
       self.parsed_metadata = {}
       self.parsed_metadata[work_identifier] = [self.raw_metadata[source_identifier]]
-      xml_elements.each do |element_name|
-        elements = record.xpath("//*[name()='#{element_name}']")
-        next if elements.blank?
-        elements.each do |el|
-          el.children.map(&:content).each do |content|
-            add_metadata(element_name, content) if content.present?
-          end
-        end
-      end
+
+      # 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_visibility
       add_rights_statement
       add_admin_set_id
@@ -63,11 +62,54 @@ module Bulkrax
       self.parsed_metadata
     end
 
-    # Grab the class from the real parser
-    def xml_elements
+    def establish_factory_class
+      model_field_names = parser.model_field_mappings
+
+      each_candidate_metadata_node_name_and_content(elements: parser.model_field_mappings) do |name, content|
+        next unless model_field_names.include?(name)
+        add_metadata(name, content)
+      end
+    end
+
+    def add_metadata_from_record
+      each_candidate_metadata_node_name_and_content do |name, content|
+        add_metadata(name, content)
+      end
+    end
+
+    def each_candidate_metadata_node_name_and_content(elements: field_mapping_from_values_for_xml_element_names)
+      elements.each do |name|
+        # NOTE: the XML element name's case matters
+        nodes = record.xpath("//*[name()='#{name}']")
+        next if nodes.empty?
+
+        nodes.each do |node|
+          node.children.each do |content|
+            next if content.to_s.blank?
+
+            yield(name, content.to_s)
+          end
+        end
+      end
+    end
+
+    # Returns the explicitly declared "from" key's value of each parser's element's value.  (Yes, I
+    # would like a proper class for the thing I just tried to describe.)
+    #
+    # @return [Array<String>]
+    #
+    # @todo Additionally, we may want to revisit the XML parser fundamental logic; namely we only
+    #       parse nodes that are explicitly declared with in the `from`.  This is a bit different
+    #       than other parsers, in that they will make assumptions about each encountered column (in
+    #       the case of CSV) or node (in the case of OAI).  tl;dr - Here there be dragons.
+    def field_mapping_from_values_for_xml_element_names
       Bulkrax.field_mappings[self.importerexporter.parser_klass].map do |_k, v|
         v[:from]
       end.flatten.compact.uniq
     end
+
+    # Included for potential downstream adopters
+    alias xml_elements field_mapping_from_values_for_xml_element_names
+    deprecation_deprecate xml_elements: "Use '#{self}#field_mapping_from_values_for_xml_element_names' instead"
   end
 end

data/app/models/concerns/bulkrax/file_factory.rb

@@ -45,9 +45,15 @@ module Bulkrax
     end
 
     def new_remote_files
-      return if object.is_a? FileSet
-
-      @new_remote_files ||= if object.present? && object.file_sets.present?
+      @new_remote_files ||= if object.is_a? FileSet
+                              parsed_remote_files.select do |file|
+                                # is the url valid?
+                                is_valid = file[:url]&.match(URI::ABS_URI)
+                                # does the file already exist
+                                is_existing = object.import_url && object.import_url == file[:url]
+                                is_valid && !is_existing
+                              end
+                            elsif object.present? && object.file_sets.present?
                               parsed_remote_files.select do |file|
                                 # is the url valid?
                                 is_valid = file[:url]&.match(URI::ABS_URI)

data/app/models/concerns/bulkrax/file_set_entry_behavior.rb

@@ -6,7 +6,14 @@ module Bulkrax
       ::FileSet
     end
 
+    def file_reference
+      return 'file' if parsed_metadata&.[]('file')&.map(&:present?)&.any?
+      return 'remote_files' if parsed_metadata&.[]('remote_files')&.map(&:present?)&.any?
+    end
+
     def add_path_to_file
+      return unless file_reference == 'file'
+
       parsed_metadata['file'].each_with_index do |filename, i|
         next if filename.blank?
 
@@ -22,7 +29,7 @@ module Bulkrax
     end
 
     def validate_presence_of_filename!
-      return if parsed_metadata&.[]('file')&.map(&:present?)&.any?
+      return if parsed_metadata&.[](file_reference)&.map(&:present?)&.any?
 
       raise StandardError, 'File set must have a filename'
     end

data/app/models/concerns/bulkrax/import_behavior.rb

@@ -117,23 +117,30 @@ module Bulkrax
       Bulkrax.qa_controlled_properties.each do |field|
         next if parsed_metadata[field].blank?
 
-        parsed_metadata[field].each_with_index do |value, i|
-          next if value.blank?
-
-          if (validated_uri_value = validate_value(value, field))
-            parsed_metadata[field][i] = validated_uri_value
-          else
-            debug_msg = %(Unable to locate active authority ID "#{value}" in config/authorities/#{field.pluralize}.yml)
-            Rails.logger.debug(debug_msg)
-            error_msg = %("#{value}" is not a valid and/or active authority ID for the :#{field} field)
-            raise ::StandardError, error_msg
+        if multiple?(field)
+          parsed_metadata[field].each_with_index do |value, i|
+            next if value.blank?
+            parsed_metadata[field][i] = sanitize_controlled_uri_value(field, value)
           end
+        else
+          parsed_metadata[field] = sanitize_controlled_uri_value(field, parsed_metadata[field])
         end
       end
 
       true
     end
 
+    def sanitize_controlled_uri_value(field, value)
+      if (validated_uri_value = validate_value(value, field))
+        validated_uri_value
+      else
+        debug_msg = %(Unable to locate active authority ID "#{value}" in config/authorities/#{field.pluralize}.yml)
+        Rails.logger.debug(debug_msg)
+        error_msg = %("#{value}" is not a valid and/or active authority ID for the :#{field} field)
+        raise ::StandardError, error_msg
+      end
+    end
+
     # @param value [String] value to validate
     # @param field [String] name of the controlled property
     # @return [String, nil] validated URI value or nil
@@ -165,15 +172,16 @@ module Bulkrax
     end
 
     def factory
-      @factory ||= Bulkrax::ObjectFactory.new(attributes: self.parsed_metadata,
-                                              source_identifier_value: identifier,
-                                              work_identifier: parser.work_identifier,
-                                              related_parents_parsed_mapping: parser.related_parents_parsed_mapping,
-                                              replace_files: replace_files,
-                                              user: user,
-                                              klass: factory_class,
-                                              importer_run_id: importerexporter.last_run.id,
-                                              update_files: update_files)
+      of = Bulkrax.object_factory || Bulkrax::ObjectFactory
+      @factory ||= of.new(attributes: self.parsed_metadata,
+                          source_identifier_value: identifier,
+                          work_identifier: parser.work_identifier,
+                          related_parents_parsed_mapping: parser.related_parents_parsed_mapping,
+                          replace_files: replace_files,
+                          user: user,
+                          klass: factory_class,
+                          importer_run_id: importerexporter.last_run.id,
+                          update_files: update_files)
     end
 
     def factory_class

data/app/parsers/bulkrax/application_parser.rb

@@ -2,6 +2,9 @@
 require 'zip'
 
 module Bulkrax
+  # An abstract class that establishes the API for Bulkrax's import and export parsing.
+  #
+  # @abstract Subclass the Bulkrax::ApplicationParser to create a parser that handles a specific format (e.g. CSV, Bagit, XML, etc).
   class ApplicationParser # rubocop:disable Metrics/ClassLength
     attr_accessor :importerexporter, :headers
     alias importer importerexporter
@@ -12,14 +15,21 @@ module Bulkrax
       :exporter_export_path, :exporter_export_zip_path, :importer_unzip_path, :validate_only,
       to: :importerexporter
 
+    # @todo Convert to `class_attribute :parser_fiels, default: {}`
     def self.parser_fields
       {}
     end
 
+    # @return [TrueClass,FalseClass] this parser does or does not support exports.
+    #
+    # @todo Convert to `class_attribute :export_supported, default: false, instance_predicate: true` and `self << class; alias export_supported? export_supported; end`
     def self.export_supported?
       false
     end
 
+    # @return [TrueClass,FalseClass] this parser does or does not support imports.
+    #
+    # @todo Convert to `class_attribute :import_supported, default: false, instance_predicate: true` and `self << class; alias import_supported? import_supported; end`
     def self.import_supported?
       true
     end
@@ -29,49 +39,76 @@ module Bulkrax
       @headers = []
     end
 
-    # @api
+    # @api public
+    # @abstract Subclass and override {#entry_class} to implement behavior for the parser.
     def entry_class
-      raise StandardError, 'must be defined'
+      raise NotImplementedError, 'must be defined'
     end
 
-    # @api
+    # @api public
+    # @abstract Subclass and override {#collection_entry_class} to implement behavior for the parser.
     def collection_entry_class
-      raise StandardError, 'must be defined'
+      raise NotImplementedError, 'must be defined'
     end
 
-    # @api
+    # @api public
+    # @abstract Subclass and override {#file_set_entry_class} to implement behavior for the parser.
+    def file_set_entry_class
+      raise NotImplementedError, 'must be defined'
+    end
+
+    # @api public
+    # @abstract Subclass and override {#records} to implement behavior for the parser.
     def records(_opts = {})
-      raise StandardError, 'must be defined'
+      raise NotImplementedError, 'must be defined'
     end
 
+    # @return [Symbol] the name of the identifying property in the source system from which we're
+    # importing (e.g. is *not* this application that mounts *this* Bulkrax engine).
+    #
+    # @see #work_identifier
+    # @see https://github.com/samvera-labs/bulkrax/wiki/CSV-Importer#source-identifier Bulkrax Wiki regarding source identifier
     def source_identifier
       @source_identifier ||= get_field_mapping_hash_for('source_identifier')&.values&.first&.[]('from')&.first&.to_sym || :source_identifier
     end
 
+    # @return [Symbol] the name of the identifying property for the system which we're importing
+    #         into (e.g. the application that mounts *this* Bulkrax engine)
+    # @see #source_identifier
     def work_identifier
       @work_identifier ||= get_field_mapping_hash_for('source_identifier')&.keys&.first&.to_sym || :source
     end
 
+    # @return [String]
     def generated_metadata_mapping
       @generated_metadata_mapping ||= 'generated'
     end
 
+    # @return [String, NilClass]
+    # @see #related_parents_raw_mapping
     def related_parents_raw_mapping
       @related_parents_raw_mapping ||= get_field_mapping_hash_for('related_parents_field_mapping')&.values&.first&.[]('from')&.first
     end
 
+    # @return [String]
+    # @see #related_parents_field_mapping
     def related_parents_parsed_mapping
       @related_parents_parsed_mapping ||= (get_field_mapping_hash_for('related_parents_field_mapping')&.keys&.first || 'parents')
     end
 
+    # @return [String, NilClass]
+    # @see #related_children_parsed_mapping
     def related_children_raw_mapping
       @related_children_raw_mapping ||= get_field_mapping_hash_for('related_children_field_mapping')&.values&.first&.[]('from')&.first
     end
 
+    # @return [String]
+    # @see #related_children_raw_mapping
     def related_children_parsed_mapping
       @related_children_parsed_mapping ||= (get_field_mapping_hash_for('related_children_field_mapping')&.keys&.first || 'children')
     end
 
+    # @api private
     def get_field_mapping_hash_for(key)
       return instance_variable_get("@#{key}_hash") if instance_variable_get("@#{key}_hash").present?
 
@@ -85,6 +122,7 @@ module Bulkrax
       instance_variable_get("@#{key}_hash")
     end
 
+    # @return [Array<String>]
     def model_field_mappings
       model_mappings = Bulkrax.field_mappings[self.class.to_s]&.dig('model', :from) || []
       model_mappings |= ['model']
@@ -92,6 +130,7 @@ module Bulkrax
       model_mappings
     end
 
+    # @return [String]
     def perform_method
       if self.validate_only
         'perform_now'
@@ -100,29 +139,55 @@ module Bulkrax
       end
     end
 
+    # The visibility of the record.  Acceptable values are: "open", "embaro", "lease", "authenticated", "restricted".  The default is "open"
+    #
+    # @return [String]
+    # @see https://github.com/samvera/hydra-head/blob/main/hydra-access-controls/app/models/concerns/hydra/access_controls/access_right.rb Hydra::AccessControls::AccessRight for details on the range of values.
+    # @see https://github.com/samvera/hyrax/blob/bd2bcffc33e183904be2c175367648815f25bc2b/app/services/hyrax/visibility_intention.rb Hyrax::VisibilityIntention for how we process the visibility.
     def visibility
       @visibility ||= self.parser_fields['visibility'] || 'open'
     end
 
+    # @api public
+    #
+    # @param types [Array<Symbol>] the types of objects that we'll create.
+    #
+    # @see Bulkrax::Importer::DEFAULT_OBJECT_TYPES
+    # @see #create_collections
+    # @see #create_works
+    # @see #create_file_sets
+    # @see #create_relationships
+    def create_objects(types = [])
+      types.each do |object_type|
+        send("create_#{object_type.pluralize}")
+      end
+    end
+
+    # @abstract Subclass and override {#create_collections} to implement behavior for the parser.
     def create_collections
-      raise StandardError, 'must be defined' if importer?
+      raise NotImplementedError, 'must be defined' if importer?
     end
 
+    # @abstract Subclass and override {#create_works} to implement behavior for the parser.
     def create_works
-      raise StandardError, 'must be defined' if importer?
+      raise NotImplementedError, 'must be defined' if importer?
     end
 
+    # @abstract Subclass and override {#create_file_sets} to implement behavior for the parser.
     def create_file_sets
-      raise StandardError, 'must be defined' if importer?
+      raise NotImplementedError, 'must be defined' if importer?
     end
 
+    # @abstract Subclass and override {#create_relationships} to implement behavior for the parser.
     def create_relationships
-      raise StandardError, 'must be defined' if importer?
+      raise NotImplementedError, 'must be defined' if importer?
     end
 
     # Optional, define if using browse everything for file upload
     def retrieve_cloud_files(files); end
 
+    # @param file [#path, #original_filename] the file object that with the relevant data for the
+    #        import.
     def write_import_file(file)
       path = File.join(path_for_import, file.original_filename)
       FileUtils.mv(
@@ -133,6 +198,8 @@ module Bulkrax
     end
 
     # Base path for imported and exported files
+    # @param [String]
+    # @return [String] the base path for files that this parser will "parse"
     def base_path(type = 'import')
       # account for multiple versions of hyku
       is_multitenant = ENV['HYKU_MULTITENANT'] == 'true' || ENV['SETTINGS__MULTITENANCY__ENABLED'] == 'true'
@@ -141,41 +208,48 @@ module Bulkrax
 
     # Path where we'll store the import metadata and files
     #  this is used for uploaded and cloud files
+    # @return [String]
     def path_for_import
       @path_for_import = File.join(base_path, importerexporter.path_string)
       FileUtils.mkdir_p(@path_for_import) unless File.exist?(@path_for_import)
       @path_for_import
     end
 
+    # @abstract Subclass and override {#setup_export_file} to implement behavior for the parser.
     def setup_export_file
-      raise StandardError, 'must be defined' if exporter?
+      raise NotImplementedError, 'must be defined' if exporter?
     end
 
+    # @abstract Subclass and override {#write_files} to implement behavior for the parser.
     def write_files
-      raise StandardError, 'must be defined' if exporter?
+      raise NotImplementedError, 'must be defined' if exporter?
     end
 
+    # @return [TrueClass,FalseClass]
     def importer?
       importerexporter.is_a?(Bulkrax::Importer)
     end
 
+    # @return [TrueClass,FalseClass]
     def exporter?
       importerexporter.is_a?(Bulkrax::Exporter)
     end
 
     # @param limit [Integer] limit set on the importerexporter
     # @param index [Integer] index of current iteration
-    # @return [boolean]
+    # @return [TrueClass,FalseClass]
     def limit_reached?(limit, index)
       return false if limit.nil? || limit.zero? # no limit
       index >= limit
     end
 
     # Override to add specific validations
+    # @return [TrueClass,FalseClass]
     def valid_import?
       true
     end
 
+    # @return [TrueClass,FalseClass]
     def record_has_source_identifier(record, index)
       if record[source_identifier].blank?
         if Bulkrax.fill_in_blank_source_identifiers.present?
@@ -199,6 +273,7 @@ module Bulkrax
     end
     # rubocop:enable Rails/SkipsModelValidations
 
+    # @return [Array<String>]
     def required_elements
       if Bulkrax.fill_in_blank_source_identifiers
         ['title']
@@ -287,12 +362,14 @@ module Bulkrax
     end
 
     # Path for the import
+    # @return [String]
     def import_file_path
       @import_file_path ||= real_import_file_path
     end
 
     private
 
+    # @return [String]
     def real_import_file_path
       return importer_unzip_path if file? && zip?
       parser_fields['import_file_path']

data/app/parsers/bulkrax/csv_parser.rb

@@ -180,7 +180,7 @@ module Bulkrax
     end
 
     def current_work_ids
-      ActiveSupport::Deprication.warn('Bulkrax::CsvParser#current_work_ids will be replaced with #current_record_ids in version 3.0')
+      ActiveSupport::Deprecation.warn('Bulkrax::CsvParser#current_work_ids will be replaced with #current_record_ids in version 3.0')
       current_record_ids
     end
 
@@ -196,10 +196,13 @@ module Bulkrax
         @collection_ids = ActiveFedora::SolrService.query("has_model_ssim:Collection #{extra_filters}", method: :post, rows: 2_147_483_647).map(&:id)
         @file_set_ids = ActiveFedora::SolrService.query("has_model_ssim:FileSet #{extra_filters}", method: :post, rows: 2_147_483_647).map(&:id)
       when 'collection'
-        @work_ids = ActiveFedora::SolrService.query("member_of_collection_ids_ssim:#{importerexporter.export_source + extra_filters} AND has_model_ssim:(#{Hyrax.config.curation_concerns.join(' OR ')})", method: :post, rows: 2_000_000_000).map(&:id)
+        @work_ids = ActiveFedora::SolrService.query(
+"member_of_collection_ids_ssim:#{importerexporter.export_source + extra_filters} AND has_model_ssim:(#{Hyrax.config.curation_concerns.join(' OR ')})", method: :post, rows: 2_000_000_000
+).map(&:id)
         # get the parent collection and child collections
         @collection_ids = ActiveFedora::SolrService.query("id:#{importerexporter.export_source} #{extra_filters}", method: :post, rows: 2_147_483_647).map(&:id)
-        @collection_ids += ActiveFedora::SolrService.query("has_model_ssim:Collection AND member_of_collection_ids_ssim:#{importerexporter.export_source}", method: :post, rows: 2_147_483_647).map(&:id)
+        @collection_ids += ActiveFedora::SolrService.query("has_model_ssim:Collection AND member_of_collection_ids_ssim:#{importerexporter.export_source}", method: :post,
+                                                                                                                                                            rows: 2_147_483_647).map(&:id)
         find_child_file_sets(@work_ids)
       when 'worktype'
         @work_ids = ActiveFedora::SolrService.query("has_model_ssim:#{importerexporter.export_source + extra_filters}", method: :post, rows: 2_000_000_000).map(&:id)
@@ -234,7 +237,7 @@ module Bulkrax
         instance_variable_set(instance_var, ActiveFedora::SolrService.post(
           extra_filters.to_s,
           fq: [
-            %(#{::Solrizer.solr_name(work_identifier)}:("#{complete_entry_identifiers.join('" OR "')}")),
+            %(#{solr_name(work_identifier)}:("#{complete_entry_identifiers.join('" OR "')}")),
             "has_model_ssim:(#{models_to_search.join(' OR ')})"
           ],
           fl: 'id',
@@ -243,6 +246,10 @@ module Bulkrax
       end
     end
 
+    def solr_name(base_name)
+      Module.const_defined?(:Solrizer) ? ::Solrizer.solr_name(base_name) : ::ActiveFedora.index_field_mapper.solr_name(base_name)
+    end
+
     def create_new_entries
       current_record_ids.each_with_index do |id, index|
         break if limit_reached?(limit, index)
@@ -440,7 +447,7 @@ module Bulkrax
         file_mapping = Bulkrax.field_mappings.dig(self.class.to_s, 'file', :from)&.first&.to_sym || :file
         next if r[file_mapping].blank?
 
-        r[file_mapping].split(/\s*[:;|]\s*/).map do |f|
+        r[file_mapping].split(Bulkrax.multi_value_element_split_on).map do |f|
           file = File.join(path_to_files, f.tr(' ', '_'))
           if File.exist?(file) # rubocop:disable Style/GuardClause
             file
@@ -468,7 +475,7 @@ module Bulkrax
       entry_uid ||= if Bulkrax.fill_in_blank_source_identifiers.present?
                       Bulkrax.fill_in_blank_source_identifiers.call(self, records.find_index(collection_hash))
                     else
-                      collection_hash[:title].split(/\s*[;|]\s*/).first
+                      collection_hash[:title].split(Bulkrax.multi_value_element_split_on).first
                     end
 
       entry_uid

data/app/parsers/bulkrax/oai_dc_parser.rb

@@ -13,8 +13,7 @@ module Bulkrax
     def client
       @client ||= OAI::Client.new(importerexporter.parser_fields['base_url'],
                                   headers: headers,
-                                  parser: 'libxml',
-                                  metadata_prefix: importerexporter.parser_fields['metadata_prefix'])
+                                  parser: 'libxml')
     rescue StandardError
       raise OAIError
     end
@@ -32,6 +31,7 @@ module Bulkrax
     end
 
     def records(opts = {})
+      opts[:metadata_prefix] ||= importerexporter.parser_fields['metadata_prefix']
       opts[:set] = collection_name unless collection_name == 'all'
 
       opts[:from] = importerexporter&.last_imported_at&.strftime("%Y-%m-%d") if importerexporter.last_imported_at && only_updates

data/app/parsers/bulkrax/xml_parser.rb

@@ -12,6 +12,12 @@ module Bulkrax
     # @todo not yet supported
     def create_collections; end
 
+    # @todo not yet supported
+    def file_set_entry_class; end
+
+    # @todo not yet supported
+    def create_file_sets; end
+
     # TODO: change to differentiate between collection and work records when adding ability to import collection metadata
     def works_total
       total

data/app/services/bulkrax/remove_relationships_for_importer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+module Bulkrax
+  # This module is rather destructive; it will break relationships between the works, file sets, and
+  # collections that were imported via an importer.  You probably don't want to run this on your
+  # data, except in the case where you have been testing a Bulkrax::Importer, the parsers and
+  # mappings.  Then, you might have relationships that you want to remove.
+  #
+  # tl;dr - Caution this will break things!
+  class RemoveRelationshipsForImporter
+    # @api public
+    #
+    # Remove the relationships of the works and collections for all of the Bulkrax::Entry records
+    # associated with the given Bulkrax::Importer.
+    #
+    # @param importer [Bulkrax::Importer]
+    # @param with_progress_bar [Boolean]
+    def self.break_relationships_for!(importer:, with_progress_bar: false)
+      entries = importer.entries.select(&:succeeded?)
+      progress_bar = build_progress_bar_for(with_progress_bar: with_progress_bar, entries: entries)
+      new(progress_bar: progress_bar, entries: entries).break_relationships!
+    end
+
+    # @api private
+    #
+    # A null object that conforms to this class's use of a progress bar.
+    module NullProgressBar
+      def self.increment; end
+    end
+
+    # @api private
+    #
+    # @return [#increment]
+    def self.build_progress_bar_for(with_progress_bar:, entries:)
+      return NullProgressBar unless with_progress_bar
+
+      begin
+        require 'ruby-progressbar'
+        ProgessBar.create(total: entries.count)
+      rescue LoadError
+        Rails.logger.info("Using NullProgressBar because ProgressBar is not available due to a LoadError.")
+      end
+    end
+
+    # @param entries [#each]
+    # @param progress_bar [#increment]
+    def initialize(entries:, progress_bar:)
+      @progress_bar = progress_bar
+      @entries = entries
+    end
+
+    attr_reader :entries, :progress_bar
+
+    def break_relationships!
+      entries.each do |entry|
+        progress_bar.increment
+
+        obj = entry.factory.find
+        next if obj.is_a?(FileSet) # FileSets must be attached to a Work
+
+        if obj.is_a?(Collection)
+          remove_relationships_from_collection(obj)
+        else
+          remove_relationships_from_work(obj)
+        end
+
+        obj.try(:reindex_extent=, Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX)
+        obj.save!
+      end
+    end
+
+    def remove_relationships_from_collection(collection)
+      # Remove child work relationships
+      collection.member_works.each do |work|
+        change = work.member_of_collections.delete(collection)
+        work.save! if change.present?
+      end
+
+      # Remove parent collection relationships
+      collection.member_of_collections.each do |parent_col|
+        Hyrax::Collections::NestedCollectionPersistenceService
+          .remove_nested_relationship_for(parent: parent_col, child: collection)
+      end
+
+      # Remove child collection relationships
+      collection.member_collections.each do |child_col|
+        Hyrax::Collections::NestedCollectionPersistenceService
+          .remove_nested_relationship_for(parent: collection, child: child_col)
+      end
+    end
+
+    def remove_relationships_from_work(work)
+      # Remove parent collection relationships
+      work.member_of_collections = []
+
+      # Remove parent work relationships
+      work.member_of_works.each do |parent_work|
+        parent_work.members.delete(work)
+        parent_work.save!
+      end
+
+      # Remove child work relationships
+      work.member_works.each do |child_work|
+        work.member_works.delete(child_work)
+      end
+    end
+  end
+end