bulkrax 9.3.5 → 9.4.1

data/app/parsers/concerns/bulkrax/csv_parser/csv_validation_helpers.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  class CsvParser < ApplicationParser
+    # Private helper methods for CsvValidation.
+    module CsvValidationHelpers # rubocop:disable Metrics/ModuleLength
+      include CsvValidationHierarchy
+
+      # Resolve a symbol key from mappings for use as a record hash key.
+      # Returns a Symbol matching the parser's symbol-keyed record hash.
+      def resolve_validation_key(mapping_manager, key: nil, flag: nil, default:)
+        options = mapping_manager.resolve_column_name(key: key, flag: flag, default: default.to_s)
+        options.first&.to_sym || default
+      end
+
+      # Parse rows from a CsvEntry.read_data result into the canonical record shape.
+      # CsvEntry.read_data returns CSV::Row objects with symbol headers; blank rows
+      # are already filtered by CsvWrapper.
+      def parse_validation_rows(raw_csv, source_id_key, parent_key, children_key, file_key)
+        raw_csv.map do |row|
+          # CSV::Row#to_h converts symbol headers → string-keyed hash
+          row_hash = row.to_h.transform_keys(&:to_s)
+          {
+            source_identifier: row[source_id_key],
+            model: row[:model],
+            parent: row[parent_key],
+            children: row[children_key],
+            file: row[file_key],
+            raw_row: row_hash
+          }
+        end
+      rescue StandardError => e
+        Rails.logger.error("CsvParser.validate_csv: error parsing rows – #{e.message}")
+        []
+      end
+
+      def build_validation_field_metadata(all_models, field_analyzer)
+        all_models.each_with_object({}) do |model, hash|
+          field_list = field_analyzer.find_or_create_field_list_for(model_name: model)
+          hash[model] = {
+            properties: field_list.dig(model, 'properties') || [],
+            required_terms: field_list.dig(model, 'required_terms') || [],
+            controlled_vocab_terms: field_list.dig(model, 'controlled_vocab_terms') || []
+          }
+        end
+      end
+
+      def build_valid_validation_headers(mapping_manager, field_analyzer, all_models, mappings, field_metadata)
+        svc = Bulkrax::CsvParser::ValidationContext.new(
+          mapping_manager: mapping_manager,
+          field_analyzer: field_analyzer,
+          all_models: all_models,
+          mappings: mappings
+        )
+        all_cols = CsvTemplate::ColumnBuilder.new(svc).all_columns
+        all_cols - CsvTemplate::CsvBuilder::IGNORED_PROPERTIES
+      rescue StandardError => e
+        Rails.logger.error("CsvParser.validate_csv: error building valid headers – #{e.message}")
+        standard = %w[model source_identifier parents children file]
+        model_fields = field_metadata.values.flat_map { |m| m[:properties] }
+                                            .map { |prop| mapping_manager.key_to_mapped_column(prop) }
+        (standard + model_fields).uniq
+      end
+
+      def find_missing_required_headers(headers, field_metadata, mapping_manager)
+        csv_keys = headers.map { |h| mapping_manager.mapped_to_key(h).sub(/_\d+\z/, '') }.uniq
+        missing = []
+        field_metadata.each do |model, meta|
+          (meta[:required_terms] || []).each do |field|
+            missing << { model: model, field: field } unless csv_keys.include?(field)
+          end
+        end
+        missing.uniq
+      end
+
+      def find_unrecognized_validation_headers(headers, valid_headers)
+        checker = DidYouMean::SpellChecker.new(dictionary: valid_headers)
+        headers
+          .reject { |h| h.blank? || valid_headers.include?(h) || valid_headers.include?(h.sub(/_\d+\z/, '')) }
+          .index_with { |h| checker.correct(h).first }
+      end
+
+      def find_empty_column_positions(headers, raw_csv)
+        headers.each_with_index.filter_map do |h, i|
+          next if h.present?
+          has_data = raw_csv.any? { |row| row.fields[i].present? }
+          i + 1 if has_data
+        end
+      end
+
+      # Adds a missing source_identifier entry to missing_required when the column
+      # is absent and fill_in_blank_source_identifiers is not configured.
+      def append_missing_source_id!(missing_required, headers, source_id_key, all_models)
+        return if headers.map(&:to_s).include?(source_id_key.to_s)
+        return if Bulkrax.fill_in_blank_source_identifiers.present?
+
+        all_models.each { |model| missing_required << { model: model, field: source_id_key.to_s } }
+      end
+
+      # Adds a file-level notice when the model column is absent or every row has a blank
+      # model value, indicating that the default work type will be used for all rows.
+      # When this notice is present the per-row default_work_type_used warnings are
+      # suppressed in the formatter — no need to repeat the same message for every row.
+      def append_missing_model_notice!(notices, headers, csv_data)
+        default_model = Bulkrax.default_work_type
+        return if default_model.blank?
+
+        model_column_present = headers.map(&:to_s).include?('model')
+        all_rows_blank = model_column_present && csv_data.all? { |r| r[:model].blank? }
+
+        return if model_column_present && !all_rows_blank
+
+        key_suffix = all_rows_blank ? 'column_empty' : 'column_missing'
+        base_key   = 'bulkrax.importer.guided_import.validation.default_work_type_notice'
+        notices << {
+          field: 'model',
+          default_work_type: default_model,
+          message: I18n.t("#{base_key}.message_#{key_suffix}", default_work_type: default_model),
+          suggestion: I18n.t("#{base_key}.suggestion_#{key_suffix}")
+        }
+      end
+
+      def apply_rights_statement_validation_override!(result, missing_required)
+        only_rights = missing_required.present? &&
+                      missing_required.all? { |h| h[:field].to_s == 'rights_statement' }
+        return unless only_rights && !result[:isValid]
+        return if result[:headers].blank?
+        return if result[:missingFiles]&.any?
+
+        result[:isValid]     = true
+        result[:hasWarnings] = true
+      end
+
+      # Assembles the final result hash returned to the guided import UI.
+      def assemble_result(headers:, missing_required:, header_issues:, row_errors:, csv_data:, file_validator:, collections:, works:, file_sets:, notices: []) # rubocop:disable Metrics/ParameterLists
+        row_error_entries   = row_errors.select { |e| e[:severity] == 'error' }
+        row_warning_entries = row_errors.select { |e| e[:severity] == 'warning' }
+        has_errors   = missing_required.any? || headers.blank? || csv_data.empty? ||
+                       file_validator.missing_files.any? || row_error_entries.any?
+        has_warnings = header_issues[:unrecognized].any? || header_issues[:empty_columns].any? ||
+                       file_validator.possible_missing_files? || row_warning_entries.any? || notices.any?
+
+        {
+          headers: headers,
+          missingRequired: missing_required,
+          notices: notices,
+          unrecognized: header_issues[:unrecognized],
+          emptyColumns: header_issues[:empty_columns],
+          rowCount: csv_data.length,
+          isValid: !has_errors,
+          hasWarnings: has_warnings,
+          rowErrors: row_errors,
+          collections: collections,
+          works: works,
+          fileSets: file_sets,
+          totalItems: csv_data.length,
+          fileReferences: file_validator.count_references,
+          missingFiles: file_validator.missing_files,
+          foundFiles: file_validator.found_files_count,
+          zipIncluded: file_validator.zip_included?
+        }
+      end
+
+      # Builds the find_record lambda used by row validators and hierarchy extraction.
+      def build_find_record
+        all_mappings = Bulkrax.field_mappings['Bulkrax::CsvParser'] || {}
+        work_identifier = all_mappings.find { |_k, v| v['source_identifier'] == true }&.first || 'source'
+        work_identifier_search = Array.wrap(all_mappings.dig(work_identifier, 'search_field')).first&.to_s ||
+                                 "#{work_identifier}_sim"
+        ->(id) { find_record_by_source_identifier(id, work_identifier, work_identifier_search) }
+      end
+
+      # Attempt to locate an existing repository record by its identifier.
+      # The identifier may be a repository object ID or a source_identifier property value.
+      # Checks the repository directly (by ID, then by Solr property search) — a Bulkrax
+      # Entry record alone is not sufficient, as the object may never have been created.
+      #
+      # @param identifier [String]
+      # @param work_identifier [String] the source_identifier property name (e.g. "source")
+      # @param work_identifier_search [String] the Solr field for source_identifier (e.g. "source_sim")
+      # @return [Boolean] true if a matching repository object is found
+      def find_record_by_source_identifier(identifier, work_identifier, work_identifier_search)
+        return false if identifier.blank?
+
+        return true if Bulkrax.object_factory.find_or_nil(identifier).present?
+
+        [Bulkrax.collection_model_class, *Bulkrax.curation_concerns].any? do |klass|
+          Bulkrax.object_factory.search_by_property(
+            value: identifier,
+            klass: klass,
+            search_field: work_identifier_search,
+            name_field: work_identifier
+          ).present?
+        end
+      rescue StandardError
+        false
+      end
+
+      # Returns the raw CSV column name (String) for a relationship field.
+      # Looks for the mapping entry flagged with +flag+ and returns its first +from+ value,
+      # falling back to +default+ when none is found.
+      def resolve_relationship_column(mappings, flag, default)
+        entry = mappings.find { |_k, v| v.is_a?(Hash) && v[flag] }
+        entry&.last&.dig('from')&.first || default
+      end
+
+      def resolve_parent_split_pattern(mappings)
+        split_val = mappings.dig('parents', 'split') || mappings.dig(:parents, :split)
+        return nil if split_val.blank?
+        return Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON if split_val == true
+
+        split_val
+      end
+
+      def resolve_children_split_pattern(mappings)
+        split_val = mappings.dig('children', 'split') || mappings.dig(:children, :split)
+        return nil if split_val.blank?
+        return Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON if split_val == true
+
+        split_val
+      end
+
+      # Builds a graph of { source_identifier => [parent_ids] } from all CSV records.
+      # Used by CircularReference validator to detect cycles across the whole CSV.
+      #
+      # Parent edges are collected from both directions:
+      #   - explicit parent declarations (parents / parents_N columns)
+      #   - inverted child declarations (children / children_N columns), mirroring
+      #     the normalisation done in importers_stepper.js#normalizeRelationships
+      def build_relationship_graph(csv_data, mappings)
+        parent_column   = resolve_relationship_column(mappings, 'related_parents_field_mapping', 'parents')
+        children_column = resolve_relationship_column(mappings, 'related_children_field_mapping', 'children')
+        parent_suffix   = /\A#{Regexp.escape(parent_column)}_\d+\z/
+        children_suffix = /\A#{Regexp.escape(children_column)}_\d+\z/
+
+        graph = build_parent_edges(csv_data, parent_suffix, resolve_parent_split_pattern(mappings))
+        invert_child_edges(graph, csv_data, children_suffix, resolve_children_split_pattern(mappings))
+        graph
+      end
+
+      def build_parent_edges(csv_data, suffix_pattern, split_pattern)
+        csv_data.each_with_object({}) do |record, graph|
+          id = record[:source_identifier]
+          next if id.blank?
+
+          base_ids = split_or_single(record[:parent], split_pattern)
+          suffix_ids = suffixed_values(record[:raw_row], suffix_pattern)
+          graph[id] = (base_ids + suffix_ids).uniq
+        end
+      end
+
+      def invert_child_edges(graph, csv_data, suffix_pattern, split_pattern)
+        csv_data.each do |record|
+          id = record[:source_identifier]
+          next if id.blank?
+
+          child_ids = split_or_single(record[:children], split_pattern) +
+                      suffixed_values(record[:raw_row], suffix_pattern)
+          child_ids.each do |child_id|
+            graph[child_id] ||= []
+            graph[child_id] << id unless graph[child_id].include?(id)
+          end
+        end
+      end
+
+      def split_or_single(value, split_pattern)
+        if split_pattern
+          value.to_s.split(split_pattern).map(&:strip).reject(&:blank?)
+        elsif value.present?
+          [value.to_s.strip]
+        else
+          []
+        end
+      end
+
+      def suffixed_values(raw_row, suffix_pattern)
+        raw_row.select { |k, _| k.to_s.match?(suffix_pattern) }
+               .values.map(&:to_s).map(&:strip).reject(&:blank?)
+      end
+    end
+  end
+end

data/app/parsers/concerns/bulkrax/csv_parser/csv_validation_hierarchy.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  class CsvParser < ApplicationParser
+    # Hierarchy-building helpers for CsvValidation. Handles extracting and
+    # categorising items from parsed CSV data for the guided import tree view.
+    module CsvValidationHierarchy
+      def extract_validation_items(csv_data, all_ids = Set.new, find_record = nil, parent_split_pattern: nil, child_split_pattern: '|')
+        child_to_parents = build_child_to_parents_map(csv_data, child_split_pattern: child_split_pattern)
+        collections = []
+        works       = []
+        file_sets   = []
+
+        csv_data.each do |item|
+          categorise_validation_item(item, child_to_parents, all_ids, collections, works, file_sets, find_record,
+                                     parent_split_pattern: parent_split_pattern, child_split_pattern: child_split_pattern)
+        end
+
+        [collections, works, file_sets]
+      end
+
+      def build_child_to_parents_map(csv_data, child_split_pattern: '|')
+        Hash.new { |h, k| h[k] = [] }.tap do |map|
+          csv_data.each do |item|
+            next if item[:source_identifier].blank?
+
+            collect_relationship_ids(item[:children], item[:raw_row], 'children', split_pattern: child_split_pattern).each do |child_id|
+              map[child_id] << item[:source_identifier]
+            end
+          end
+        end
+      end
+
+      def categorise_validation_item(item, child_to_parents, all_ids, collections, works, file_sets, find_record = nil, parent_split_pattern: nil, child_split_pattern: '|') # rubocop:disable Metrics/ParameterLists
+        item_id   = item[:source_identifier]
+        model_str = item[:model].to_s
+
+        opts = { type: nil, find_record: find_record, parent: parent_split_pattern, child: child_split_pattern }
+        if model_str.casecmp('collection').zero? || model_str.casecmp('collectionresource').zero?
+          collections << build_item_hash(item, child_to_parents, all_ids, opts.merge(type: 'collection'))
+        elsif model_str.casecmp('fileset').zero? || model_str.casecmp('hyrax::fileset').zero?
+          file_sets << { id: item_id, title: item[:raw_row]['title'] || item_id, type: 'file_set' }
+        else
+          works << build_item_hash(item, child_to_parents, all_ids, opts.merge(type: 'work'))
+        end
+      end
+
+      def build_item_hash(item, child_to_parents, all_ids, opts = {}) # rubocop:disable Metrics/MethodLength
+        type = opts[:type]
+        find_record = opts[:find_record]
+        item_id  = item[:source_identifier]
+        title    = item[:raw_row]['title'] || item_id
+        parents  = collect_relationship_ids(item[:parent],   item[:raw_row], 'parents',  split_pattern: opts[:parent])
+        children = collect_relationship_ids(item[:children], item[:raw_row], 'children', split_pattern: opts[:child] || '|')
+
+        {
+          id: item_id,
+          title: title,
+          type: type,
+          existing: find_record&.call(item_id) || false,
+          parentIds: (resolvable_ids(parents, all_ids) + resolvable_ids(child_to_parents[item_id] || [], all_ids)).uniq,
+          childIds: resolvable_ids(children, all_ids),
+          existingParentIds: external_ids(parents, all_ids, find_record),
+          existingChildIds: external_ids(children, all_ids, find_record)
+        }
+      end
+
+      def parse_relationship_field(value, split_pattern: '|')
+        return [] if value.blank?
+        value.to_s.split(split_pattern).map(&:strip).reject(&:blank?)
+      end
+
+      def collect_relationship_ids(base_value, raw_row, column, split_pattern: '|')
+        base_ids = parse_relationship_field(base_value, split_pattern: split_pattern)
+        suffix_pattern = /\A#{Regexp.escape(column)}_\d+\z/
+        suffix_ids = raw_row
+                     .select { |k, _| k.to_s.match?(suffix_pattern) }
+                     .values
+                     .map(&:to_s).map(&:strip).reject(&:blank?)
+        (base_ids + suffix_ids).uniq
+      end
+
+      def resolvable_ids(ids, all_ids)
+        ids.select { |id| all_ids.include?(id) }
+      end
+
+      # Returns ids from the list that are NOT in the CSV but exist in the repository.
+      def external_ids(ids, all_ids, find_record)
+        return [] if find_record.nil?
+
+        ids.reject { |id| all_ids.include?(id) }
+           .select { |id| find_record.call(id) }
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/column_builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Builds column headers for CSV
+    class ColumnBuilder
+      def initialize(service)
+        @service = service
+        @descriptor = CsvTemplate::ColumnDescriptor.new
+      end
+
+      def all_columns
+        required_columns + property_columns
+      end
+
+      def required_columns
+        mapped_core_columns +
+          relationship_columns +
+          file_columns
+      end
+
+      private
+
+      def mapped_core_columns
+        @descriptor.core_columns.map do |column|
+          @service.mapping_manager.key_to_mapped_column(column)
+        end
+      end
+
+      def property_columns
+        field_lists = @service.all_models.map do |m|
+          @service.field_analyzer.find_or_create_field_list_for(model_name: m)
+        end
+
+        properties = field_lists
+                     .flat_map { |item| item.values.flat_map { |config| config["properties"] || [] } }
+                     .uniq
+                     .map { |property| @service.mapping_manager.key_to_mapped_column(property) }
+                     .uniq
+
+        (properties - required_columns).sort
+      end
+
+      def relationship_columns
+        [
+          @service.mapping_manager.find_by_flag("related_children_field_mapping", 'children'),
+          @service.mapping_manager.find_by_flag("related_parents_field_mapping", 'parents')
+        ]
+      end
+
+      def file_columns
+        CsvTemplate::ColumnDescriptor::COLUMN_DESCRIPTIONS[:files].flat_map do |property_hash|
+          property_hash.keys.map do |key|
+            @service.mapping_manager.key_to_mapped_column(key)
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/column_descriptor.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Manages column descriptions and metadata
+    class ColumnDescriptor
+      COLUMN_DESCRIPTIONS = {
+        include_first: [
+          { "model" => "The work types configured in your repository are listed below.\nIf left blank, your default work type, #{Bulkrax.default_work_type}, is used." },
+          { "source_identifier" => "This must be a unique identifier.\nIt can be alphanumeric with some special characters (e.g. hyphens, colons), and URLs are also supported." },
+          { "id" => "This column would optionally be included only if it is a re-import, i.e. for updating or deleting records.\nThis is a key identifier used by the system, which you wouldn't have for new imports." },
+          { "rights_statement" => "Rights statement URI for the work.\nIf not included, uses the value specified on the bulk import configuration screen." }
+        ],
+        visibility: [
+          { "visibility" => "Uses the value specified on the bulk import configuration screen if not added here.\nValid options: open, authenticated, restricted, embargo, lease" },
+          { "embargo_release_date" => "Required for embargo (yyyy-mm-dd)" },
+          { "visibility_during_embargo" => "Required for embargo" },
+          { "visibility_after_embargo" => "Required for embargo" },
+          { "lease_expiration_date" => "Required for lease (yyyy-mm-dd)" },
+          { "visibility_during_lease" => "Required for lease" },
+          { "visibility_after_lease" => "Required for lease" }
+        ],
+        files: [
+          { "file" => "Use filenames exactly matching those in your files folder.\nZip your CSV and files folder together and attach this to your importer." },
+          { "remote_files" => "Use the URLs to remote files to be attached to the work." }
+        ],
+        relationships: [
+          { "parents" => "The source_identifier or id of work or collection to be attached as parent." },
+          { "children" => "The source_identifier or id of work or file to be attached as child." }
+        ],
+        other: [
+          { "hide_from_catalog_search" => "Set to 1 to hide the collection from catalog search results." },
+          { "show_pdf_download_button" => "Set to 1 to show a PDF download link on the work's page." },
+          { "show_pdf_viewer" => "Set to 1 to show a PDF viewer on the work's page." },
+          { "video_embed" => "A valid URL to a hosted video that can appear in an iframe, beginning with 'http://' or 'https://'." }
+        ]
+      }.freeze
+
+      def core_columns
+        extract_column_names(:include_first) + extract_column_names(:visibility)
+      end
+
+      def find_description_for(column)
+        COLUMN_DESCRIPTIONS.each_value do |group|
+          prop = group.find { |hash| hash.key?(column) }
+          return prop[column] if prop
+        end
+        nil
+      end
+
+      private
+
+      def extract_column_names(group)
+        COLUMN_DESCRIPTIONS[group].map { |hash| hash.keys.first }
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/csv_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Builds CSV content
+    class CsvBuilder
+      IGNORED_PROPERTIES = %w[
+        admin_set_id alternate_ids
+        bulkrax_identifier
+        collection_type_gid contexts created_at
+        date date_modified date_uploaded depositor
+        embargo embargo_id
+        file_ids
+        has_model head
+        internal_resource is_child
+        lease lease_id
+        member_ids member_of_collection_ids modified_date
+        new_record
+        on_behalf_of owner proxy_depositor
+        rendering_ids representative_id
+        schema_version split_from_pdf_id state tail
+        thumbnail_id
+        updated_at
+      ].freeze
+
+      def initialize(service)
+        @service = service
+        @column_builder = CsvTemplate::ColumnBuilder.new(service)
+        @row_builder = CsvTemplate::RowBuilder.new(service)
+        @header_row = nil
+        @required_headings = []
+      end
+
+      def write_to_file(file_path)
+        FileUtils.mkdir_p(File.dirname(file_path))
+        CSV.open(file_path, "w") { |csv| write_rows(csv) }
+      end
+
+      def generate_string
+        CSV.generate { |csv| write_rows(csv) }
+      end
+
+      private
+
+      def write_rows(csv)
+        csv_rows.each { |row| csv << row }
+      end
+
+      def csv_rows
+        @header_row = fill_header_row
+        rows = [
+          @header_row,
+          @row_builder.build_explanation_row(@header_row),
+          *@row_builder.build_model_rows(@header_row)
+        ]
+        remove_empty_columns(rows)
+      end
+
+      def fill_header_row
+        @required_headings = @column_builder.required_columns
+        all_columns = @column_builder.all_columns
+        filtered = all_columns - IGNORED_PROPERTIES
+        @required_headings = @column_builder.required_columns & filtered
+        filtered
+      end
+
+      def remove_empty_columns(rows)
+        return rows if rows.empty?
+
+        columns = rows.transpose
+        non_empty_columns = columns.select { |col| keep_column?(col) }
+        non_empty_columns.transpose
+      end
+
+      def keep_column?(column)
+        heading = column[0]
+        return true if @required_headings.include?(heading)
+
+        column[2..-1].any? { |value| !value.nil? && value != "" && value != "---" }
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/explanation_builder.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Builds explanations for CSV columns
+    class ExplanationBuilder
+      def initialize(service)
+        @service = service
+        @descriptor = CsvTemplate::ColumnDescriptor.new
+        @split_formatter = CsvTemplate::SplitFormatter.new
+      end
+
+      def build_explanations(header_row)
+        header_row.map do |column|
+          { column => build_explanation(column) }
+        end
+      end
+
+      private
+
+      def build_explanation(column)
+        mapping_key = @service.mapping_manager.mapped_to_key(column)
+
+        column_description = source_identifier_description(column) || @descriptor.find_description_for(column)
+        controlled_vocab_info = controlled_vocab_text(mapping_key)
+        split_info = split_text(mapping_key, controlled_vocab_info)
+
+        components = [
+          column_description,
+          controlled_vocab_info,
+          split_info
+        ].compact
+
+        components.join("\n")
+      end
+
+      def source_identifier_description(column)
+        return unless @service.mapping_manager.mapped_to_key(column) == 'source_identifier'
+        return if Bulkrax.fill_in_blank_source_identifiers.blank?
+        "Will be auto-generated if left blank.\nProviding one allows round-tripping and deduplication across imports."
+      end
+
+      def controlled_vocab_text(field_name)
+        vocab_terms = @service.field_analyzer.controlled_vocab_terms
+        return unless vocab_terms.include?(field_name) || field_name == 'based_near'
+        'This property uses a controlled vocabulary.'
+      end
+
+      def split_text(mapping_key, controlled_vocab_info)
+        return nil if controlled_vocab_info.present? && !mapping_key.in?(%w[location resource_type])
+        split_value = @service.mapping_manager.split_value_for(mapping_key)
+        return nil unless split_value
+        @split_formatter.format(split_value)
+      end
+    end
+  end
+end