bulkrax 1.0.2 → 2.1.0

data/app/jobs/bulkrax/importer_job.rb

@@ -6,17 +6,34 @@ module Bulkrax
 
     def perform(importer_id, only_updates_since_last_import = false)
       importer = Importer.find(importer_id)
+
       importer.current_run
+      unzip_imported_file(importer.parser)
       import(importer, only_updates_since_last_import)
+      update_current_run_counters(importer)
       schedule(importer) if importer.schedulable?
     end
 
     def import(importer, only_updates_since_last_import)
       importer.only_updates = only_updates_since_last_import || false
       return unless importer.valid_import?
+
       importer.import_collections
       importer.import_works
-      importer.create_parent_child_relationships unless importer.validate_only
+      importer.import_file_sets
+    end
+
+    def unzip_imported_file(parser)
+      return unless parser.file? && parser.zip?
+
+      parser.unzip(parser.parser_fields['import_file_path'])
+    end
+
+    def update_current_run_counters(importer)
+      importer.current_run.total_work_entries = importer.limit || importer.parser.works_total
+      importer.current_run.total_collection_entries = importer.parser.collections_total
+      importer.current_run.total_file_set_entries = importer.parser.file_sets_total
+      importer.current_run.save!
     end
 
     def schedule(importer)

data/app/matchers/bulkrax/application_matcher.rb

@@ -20,9 +20,9 @@ module Bulkrax
         return unless content.send(self.if[0], Regexp.new(self.if[1]))
       end
 
-      @result = content.to_s.gsub(/\s/, ' ') # remove any line feeds and tabs
-      @result.strip!
-      process_split
+      # @result will evaluate to an empty string for nil content values
+      @result = content.to_s.gsub(/\s/, ' ').strip # remove any line feeds and tabs
+      process_split if @result.present?
       @result = @result[0] if @result.is_a?(Array) && @result.size == 1
       process_parse
       return @result
@@ -66,14 +66,14 @@ module Bulkrax
     end
 
     def parse_subject(src)
-      string = src.to_s.strip.downcase
+      string = src.strip.downcase
       return if string.blank?
 
       string.slice(0, 1).capitalize + string.slice(1..-1)
     end
 
     def parse_types(src)
-      src.to_s.strip.titleize
+      src.strip.titleize
     end
 
     # Allow for mapping a model field to the work type or collection

data/app/models/bulkrax/csv_collection_entry.rb

@@ -6,14 +6,16 @@ module Bulkrax
       Collection
     end
 
-    def build_metadata
-      self.parsed_metadata = self.raw_metadata
-      add_local
-      return self.parsed_metadata
+    # Use identifier set by CsvParser#unique_collection_identifier, which falls back
+    # on the Collection's first title if record[source_identifier] is not present
+    def add_identifier
+      self.parsed_metadata[work_identifier] = [self.identifier].flatten
     end
 
-    def collections_created?
-      true
+    def add_collection_type_gid
+      return if self.parsed_metadata['collection_type_gid'].present?
+
+      self.parsed_metadata['collection_type_gid'] = ::Hyrax::CollectionType.find_or_create_default_collection_type.gid
     end
   end
 end

data/app/models/bulkrax/csv_entry.rb

@@ -14,59 +14,71 @@ module Bulkrax
     def self.read_data(path)
       raise StandardError, 'CSV path empty' if path.blank?
       CSV.read(path,
-               headers: true,
-               header_converters: :symbol,
-               encoding: 'utf-8')
+        headers: true,
+        header_converters: :symbol,
+        encoding: 'utf-8')
     end
 
     def self.data_for_entry(data, _source_id)
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       # If a multi-line CSV data is passed, grab the first row
       data = data.first if data.is_a?(CSV::Table)
       # model has to be separated so that it doesn't get mistranslated by to_h
       raw_data = data.to_h
-      raw_data[:model] = data[:model]
+      raw_data[:model] = data[:model] if data[:model].present?
       # If the collection field mapping is not 'collection', add 'collection' - the parser needs it
       raw_data[:collection] = raw_data[collection_field.to_sym] if raw_data.keys.include?(collection_field.to_sym) && collection_field != 'collection'
-      # If the children field mapping is not 'children', add 'children' - the parser needs it
-      raw_data[:children] = raw_data[collection_field.to_sym] if raw_data.keys.include?(children_field.to_sym) && children_field != 'children'
       return raw_data
     end
 
-    def self.collection_field
-      Bulkrax.collection_field_mapping[self.class.to_s] || 'collection'
-    end
+    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))
 
-    def self.children_field
-      Bulkrax.parent_child_field_mapping[self.to_s] || 'children'
-    end
+      self.parsed_metadata = {}
+      add_identifier
+      add_visibility
+      add_ingested_metadata
+      add_metadata_for_model
+      add_rights_statement
+      add_collections
+      add_local
 
-    def keys_without_numbers(keys)
-      keys.map { |key| key_without_numbers(key) }
+      self.parsed_metadata
     end
 
-    def key_without_numbers(key)
-      key.gsub(/_\d+/, '').sub(/^\d+_/, '')
+    def add_identifier
+      self.parsed_metadata[work_identifier] = [record[source_identifier]]
     end
 
-    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))
+    def add_metadata_for_model
+      if factory_class == Collection
+        add_collection_type_gid
+      elsif factory_class == FileSet
+        add_path_to_file
+        validate_presence_of_parent!
+      else
+        add_file unless importerexporter.metadata_only?
+        add_admin_set_id
+      end
+    end
 
-      self.parsed_metadata = {}
-      self.parsed_metadata[work_identifier] = [record[source_identifier]]
+    def add_ingested_metadata
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      # we do not want to sort the values in the record before adding the metadata.
+      # if we do, the factory_class will be set to the default_work_type for all values that come before "model" or "work type"
       record.each do |key, value|
-        next if key == 'collection'
+        next if self.parser.collection_field_mapping.to_s == key_without_numbers(key)
 
         index = key[/\d+/].to_i - 1 if key[/\d+/].to_i != 0
         add_metadata(key_without_numbers(key), value, index)
       end
-      add_file
-      add_visibility
-      add_rights_statement
-      add_admin_set_id
-      add_collections
-      add_local
-      self.parsed_metadata
     end
 
     def add_file
@@ -76,7 +88,11 @@ module Bulkrax
       elsif record['file'].is_a?(Array)
         self.parsed_metadata['file'] = record['file']
       end
-      self.parsed_metadata['file'] = self.parsed_metadata['file'].map { |f| path_to_file(f.tr(' ', '_')) }
+      self.parsed_metadata['file'] = self.parsed_metadata['file'].map do |f|
+        next if f.blank?
+
+        path_to_file(f.tr(' ', '_'))
+      end.compact
     end
 
     def build_export_metadata
@@ -86,10 +102,20 @@ module Bulkrax
       self.parsed_metadata[source_identifier] = hyrax_record.send(work_identifier)
       self.parsed_metadata['model'] = hyrax_record.has_model.first
       build_mapping_metadata
-      self.parsed_metadata['collections'] = hyrax_record.member_of_collection_ids.join('; ')
-      unless hyrax_record.is_a?(Collection)
-        self.parsed_metadata['file'] = hyrax_record.file_sets.map { |fs| filename(fs).to_s if filename(fs).present? }.compact.join('; ')
+
+      # TODO: fix the "send" parameter in the conditional below
+      # currently it returns: "NoMethodError - undefined method 'bulkrax_identifier' for #<Collection:0x00007fbe6a3b4248>"
+      if mapping['collection']&.[]('join')
+        self.parsed_metadata['collection'] = hyrax_record.member_of_collection_ids.join('; ')
+        #   self.parsed_metadata['collection'] = hyrax_record.member_of_collections.map { |c| c.send(work_identifier)&.first }.compact.uniq.join(';')
+      else
+        hyrax_record.member_of_collections.each_with_index do |collection, i|
+          self.parsed_metadata["collection_#{i + 1}"] = collection.id
+          #     self.parsed_metadata["collection_#{i + 1}"] = collection.send(work_identifier)&.first
+        end
       end
+
+      build_files unless hyrax_record.is_a?(Collection)
       self.parsed_metadata
     end
 
@@ -97,24 +123,51 @@ module Bulkrax
       mapping.each do |key, value|
         next if Bulkrax.reserved_properties.include?(key) && !field_supported?(key)
         next if key == "model"
+        next if value['excluded']
 
         object_key = key if value.key?('object')
         next unless hyrax_record.respond_to?(key.to_s) || object_key.present?
 
-        data = object_key.present? ? hyrax_record.send(value['object']) : hyrax_record.send(key.to_s)
         if object_key.present?
-          next self.parsed_metadata[key] = '' if data.empty?
-          data = data.first if data.is_a?(ActiveTriples::Relation)
+          build_object(value)
+        else
+          build_value(key, value)
+        end
+      end
+    end
+
+    def build_object(value)
+      data = hyrax_record.send(value['object'])
+      return if data.empty?
+
+      data = data.to_a if data.is_a?(ActiveTriples::Relation)
+      object_metadata(Array.wrap(data))
+    end
 
-          object_metadata(data, object_key)
-        elsif data.is_a?(ActiveTriples::Relation)
-          self.parsed_metadata[key] = data.map { |d| prepare_export_data(d) }.join('; ').to_s unless value[:excluded]
+    def build_value(key, value)
+      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
         else
-          self.parsed_metadata[key] = prepare_export_data(data)
+          data.each_with_index do |d, i|
+            self.parsed_metadata["#{key_for_export(key)}_#{i + 1}"] = prepare_export_data(d)
+          end
         end
+      else
+        self.parsed_metadata[key_for_export(key)] = prepare_export_data(data)
       end
     end
 
+    # On export the key becomes the from and the from becomes the destination. It is the opposite of the import because we are moving data the opposite direction
+    # metadata that does not have a specific Bulkrax entry is mapped to the key name, as matching keys coming in are mapped by the csv parser automatically
+    def key_for_export(key)
+      clean_key = key_without_numbers(key)
+      unnumbered_key = mapping[clean_key] ? mapping[clean_key]['from'].first : clean_key
+      # Bring the number back if there is one
+      "#{unnumbered_key}#{key.sub(clean_key, '')}"
+    end
+
     def prepare_export_data(datum)
       if datum.is_a?(ActiveTriples::Resource)
         datum.to_uri.to_s
@@ -123,30 +176,34 @@ module Bulkrax
       end
     end
 
-    def object_metadata(data, object_key)
-      data = convert_to_hash(data)
+    def object_metadata(data)
+      data = data.map { |d| eval(d) }.flatten # rubocop:disable Security/Eval
 
       data.each_with_index do |obj, index|
-        next unless obj[object_key]
-
-        next self.parsed_metadata["#{object_key}_#{index + 1}"] = prepare_export_data(obj[object_key]) unless obj[object_key].is_a?(Array)
+        next if obj.nil?
+        # allow the object_key to be valid whether it's a string or symbol
+        obj = obj.with_indifferent_access
 
-        obj[object_key].each_with_index do |_nested_item, nested_index|
-          self.parsed_metadata["#{object_key}_#{index + 1}_#{nested_index + 1}"] = prepare_export_data(obj[object_key][nested_index])
+        obj.each_key do |key|
+          if obj[key].is_a?(Array)
+            obj[key].each_with_index do |_nested_item, nested_index|
+              self.parsed_metadata["#{key_for_export(key)}_#{index + 1}_#{nested_index + 1}"] = prepare_export_data(obj[key][nested_index])
+            end
+          else
+            self.parsed_metadata["#{key_for_export(key)}_#{index + 1}"] = prepare_export_data(obj[key])
+          end
         end
       end
     end
 
-    def convert_to_hash(data)
-      # converts data from `'[{}]'` to `[{}]`
-      gsub_data = data.gsub(/\[{/, '{')
-                      .gsub(/}\]/, '}')
-                      .gsub('=>', ':')
-                      .gsub(/},\s?{/, "}},{{")
-                      .split("},{")
-      gsub_data = [gsub_data] if gsub_data.is_a?(String)
-
-      return gsub_data.map { |d| JSON.parse(d) }
+    def build_files
+      if mapping['file']&.[]('join')
+        self.parsed_metadata['file'] = hyrax_record.file_sets.map { |fs| filename(fs).to_s if filename(fs).present? }.compact.join('; ')
+      else
+        hyrax_record.file_sets.each_with_index do |fs, i|
+          self.parsed_metadata["file_#{i + 1}"] = filename(fs).to_s if filename(fs).present?
+        end
+      end
     end
 
     # In order for the existing exported hyrax_record, to be updated by a re-import
@@ -167,18 +224,28 @@ module Bulkrax
       Bulkrax::CsvMatcher
     end
 
+    def possible_collection_ids
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      @possible_collection_ids ||= record.inject([]) do |memo, (key, value)|
+        memo += value.split(/\s*[:;|]\s*/) if self.class.collection_field.to_s == key_without_numbers(key) && value.present?
+        memo
+      end || []
+    end
+
     def collections_created?
-      return true if record[self.class.collection_field].blank?
-      record[self.class.collection_field].split(/\s*[:;|]\s*/).length == self.collection_ids.length
+      possible_collection_ids.length == self.collection_ids.length
     end
 
-    def find_or_create_collection_ids
+    def find_collection_ids
       return self.collection_ids if collections_created?
-      valid_system_id(Collection)
-      if record[self.class.collection_field].present?
-        record[self.class.collection_field].split(/\s*[:;|]\s*/).each do |collection|
-          c = find_collection(collection)
-          self.collection_ids << c.id unless c.blank? || self.collection_ids.include?(c.id)
+      if possible_collection_ids.present?
+        possible_collection_ids.each do |collection_id|
+          c = find_collection(collection_id)
+          skip = c.blank? || self.collection_ids.include?(c.id)
+          self.collection_ids << c.id unless skip
         end
       end
       self.collection_ids

data/app/models/bulkrax/csv_file_set_entry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  class CsvFileSetEntry < CsvEntry
+    def factory_class
+      ::FileSet
+    end
+
+    def add_path_to_file
+      parsed_metadata['file'].each_with_index do |filename, i|
+        path_to_file = ::File.join(parser.path_to_files, filename)
+
+        parsed_metadata['file'][i] = path_to_file
+      end
+      raise ::StandardError, 'one or more file paths are invalid' unless parsed_metadata['file'].map { |file_path| ::File.file?(file_path) }.all?
+
+      parsed_metadata['file']
+    end
+
+    def validate_presence_of_parent!
+      return if parsed_metadata[related_parents_parsed_mapping]&.map(&:present?)&.any?
+
+      raise StandardError, 'File set must be related to at least one work'
+    end
+  end
+end

data/app/models/bulkrax/entry.rb

@@ -23,12 +23,22 @@ module Bulkrax
 
     attr_accessor :all_attrs
 
-    delegate :parser, :mapping, :replace_files, :update_files, to: :importerexporter
+    delegate :parser,
+      :mapping,
+      :replace_files,
+      :update_files,
+      :keys_without_numbers,
+      :key_without_numbers,
+      to: :importerexporter
 
     delegate :client,
-             :collection_name,
-             :user,
-             to: :parser
+      :collection_name,
+      :user,
+      :related_parents_raw_mapping,
+      :related_parents_parsed_mapping,
+      :related_children_raw_mapping,
+      :related_children_parsed_mapping,
+      to: :parser
 
     # Retrieve fields from the file
     # @param data - the source data
@@ -61,13 +71,13 @@ module Bulkrax
     end
 
     def self.collection_field
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       Bulkrax.collection_field_mapping[self.to_s]
     end
 
-    def self.children_field
-      Bulkrax.parent_child_field_mapping[self.to_s]
-    end
-
     def build
       return if type.nil?
       self.save if self.new_record? # must be saved for statuses
@@ -96,6 +106,7 @@ module Bulkrax
     end
 
     def find_collection(collection_identifier)
+      return unless Collection.properties.keys.include?(work_identifier)
       Collection.where(
         work_identifier => collection_identifier
       ).detect { |m| m.send(work_identifier).include?(collection_identifier) }

data/app/models/bulkrax/exporter.rb

@@ -14,7 +14,7 @@ module Bulkrax
     validates :name, presence: true
     validates :parser_klass, presence: true
 
-    delegate :write, :create_from_collection, :create_from_importer, :create_from_worktype, to: :parser
+    delegate :write, :create_from_collection, :create_from_importer, :create_from_worktype, :create_from_all, to: :parser
 
     def export
       current_run && setup_export_path
@@ -25,6 +25,8 @@ module Bulkrax
         create_from_importer
       when 'worktype'
         create_from_worktype
+      when 'all'
+        create_from_all
       end
     rescue StandardError => e
       status_info(e)
@@ -77,7 +79,8 @@ module Bulkrax
       [
         [I18n.t('bulkrax.exporter.labels.importer'), 'importer'],
         [I18n.t('bulkrax.exporter.labels.collection'), 'collection'],
-        [I18n.t('bulkrax.exporter.labels.worktype'), 'worktype']
+        [I18n.t('bulkrax.exporter.labels.worktype'), 'worktype'],
+        [I18n.t('bulkrax.exporter.labels.all'), 'all']
       ]
     end
 
@@ -105,18 +108,22 @@ module Bulkrax
     end
 
     def exporter_export_path
-      @exporter_export_path ||= File.join(Bulkrax.export_path, self.id.to_s, self.exporter_runs.last.id.to_s)
+      @exporter_export_path ||= File.join(parser.base_path('export'), self.id.to_s, self.exporter_runs.last.id.to_s)
     end
 
     def exporter_export_zip_path
-      @exporter_export_zip_path ||= File.join(Bulkrax.export_path, "export_#{self.id}_#{self.exporter_runs.last.id}.zip")
+      @exporter_export_zip_path ||= File.join(parser.base_path('export'), "export_#{self.id}_#{self.exporter_runs.last.id}.zip")
     rescue
-      @exporter_export_zip_path ||= File.join(Bulkrax.export_path, "export_#{self.id}_0.zip")
+      @exporter_export_zip_path ||= File.join(parser.base_path('export'), "export_#{self.id}_0.zip")
     end
 
     def export_properties
       properties = Hyrax.config.registered_curation_concern_types.map { |work| work.constantize.properties.keys }.flatten.uniq.sort
       properties.reject { |prop| Bulkrax.reserved_properties.include?(prop) }
     end
+
+    def metadata_only?
+      export_type == 'metadata'
+    end
   end
 end

data/app/models/bulkrax/importer.rb

@@ -18,8 +18,7 @@ module Bulkrax
     validates :admin_set_id, presence: true
     validates :parser_klass, presence: true
 
-    delegate :valid_import?, :create_parent_child_relationships,
-             :write_errored_entries_file, :visibility, to: :parser
+    delegate :valid_import?, :write_errored_entries_file, :visibility, to: :parser
 
     attr_accessor :only_updates, :file_style, :file
     attr_writer :current_run
@@ -97,7 +96,16 @@ module Bulkrax
     end
 
     def current_run
-      @current_run ||= self.importer_runs.create!(total_work_entries: self.limit || parser.total, total_collection_entries: parser.collections_total)
+      @current_run ||= if file? && zip?
+                         self.importer_runs.create!
+                       else
+                         entry_counts = {
+                           total_work_entries: self.limit || parser.works_total,
+                           total_collection_entries: parser.collections_total,
+                           total_file_set_entries: parser.file_sets_total
+                         }
+                         self.importer_runs.create!(entry_counts)
+                       end
     end
 
     def last_run
@@ -131,6 +139,13 @@ module Bulkrax
       status_info(e)
     end
 
+    def import_file_sets
+      self.save if self.new_record? # Object needs to be saved for statuses
+      parser.create_file_sets
+    rescue StandardError => e
+      status_info(e)
+    end
+
     # Prepend the base_url to ensure unique set identifiers
     # @todo - move to parser, as this is OAI specific
     def unique_collection_identifier(id)
@@ -149,11 +164,11 @@ module Bulkrax
 
     # If the import data is zipped, unzip it to this path
     def importer_unzip_path
-      @importer_unzip_path ||= File.join(Bulkrax.import_path, "import_#{path_string}")
+      @importer_unzip_path ||= File.join(parser.base_path, "import_#{path_string}")
     end
 
     def errored_entries_csv_path
-      @errored_entries_csv_path ||= File.join(Bulkrax.import_path, "import_#{path_string}_errored_entries.csv")
+      @errored_entries_csv_path ||= File.join(parser.base_path, "import_#{path_string}_errored_entries.csv")
     end
 
     def path_string
@@ -161,5 +176,9 @@ module Bulkrax
     rescue
       "#{self.id}_#{self.created_at.strftime('%Y%m%d%H%M%S')}"
     end
+
+    def metadata_only?
+      parser.parser_fields['metadata_only'] == true
+    end
   end
 end

data/app/models/bulkrax/oai_entry.rb

@@ -26,6 +26,10 @@ module Bulkrax
     end
 
     def build_metadata
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       self.parsed_metadata = {}
       self.parsed_metadata[work_identifier] = [record.header.identifier]
 
@@ -56,7 +60,7 @@ module Bulkrax
     # 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_or_create_collection_ids
+    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

data/app/models/bulkrax/rdf_entry.rb

@@ -14,6 +14,10 @@ module Bulkrax
     end
 
     def self.data_for_entry(data, source_id)
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       reader = data
       format = reader.class.format.to_sym
       collections = []
@@ -22,7 +26,7 @@ module Bulkrax
       data = RDF::Writer.for(format).buffer do |writer|
         reader.each_statement do |statement|
           collections << statement.object.to_s if collection_field.present? && collection_field == statement.predicate.to_s
-          children << statement.object.to_s if children_field.present? && children_field == statement.predicate.to_s
+          children << statement.object.to_s if related_children_parsed_mapping.present? && related_children_parsed_mapping == statement.predicate.to_s
           delete = statement.object.to_s if /deleted/.match?(statement.predicate.to_s)
           writer << statement
         end
@@ -37,12 +41,13 @@ module Bulkrax
       }
     end
 
-    def self.collection_field
-      Bulkrax.collection_field_mapping[self.to_s]
-    end
+    def self.related_children_parsed_mapping
+      return @related_children_parsed_mapping if @related_children_parsed_mapping.present?
+
+      rdf_related_children_field_mapping = Bulkrax.field_mappings['Bulkrax::RdfParser']&.select { |_, h| h.key?('related_children_field_mapping') }
+      return if rdf_related_children_field_mapping.blank?
 
-    def self.children_field
-      Bulkrax.parent_child_field_mapping[self.to_s]
+      @related_children_parsed_mapping = rdf_related_children_field_mapping&.keys&.first
     end
 
     def record
@@ -50,6 +55,10 @@ module Bulkrax
     end
 
     def build_metadata
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       raise StandardError, 'Record not found' if record.nil?
       raise StandardError, "Missing source identifier (#{source_identifier})" if self.raw_metadata[source_identifier].blank?
 
@@ -76,7 +85,7 @@ module Bulkrax
       self.raw_metadata['collection'].length == self.collection_ids.length
     end
 
-    def find_or_create_collection_ids
+    def find_collection_ids
       return self.collection_ids if collections_created?
       if self.raw_metadata['collection'].present?
         self.raw_metadata['collection'].each do |collection|

data/app/models/bulkrax/xml_entry.rb

@@ -39,6 +39,10 @@ module Bulkrax
     end
 
     def build_metadata
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       raise StandardError, 'Record not found' if record.nil?
       raise StandardError, "Missing source identifier (#{source_identifier})" if self.raw_metadata[source_identifier].blank?
       self.parsed_metadata = {}