bulkrax 9.3.5 → 9.4.1

data/app/validators/bulkrax/csv_row/duplicate_identifier.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that each row has a unique source_identifier.
+    # Uses context[:seen_ids] (Hash: id => first_seen_row_number) to detect duplicates.
+    module DuplicateIdentifier
+      def self.call(record, row_index, context)
+        source_id = record[:source_identifier]
+        return if source_id.blank? && Bulkrax.fill_in_blank_source_identifiers.present?
+
+        source_id_label = context[:source_identifier] || 'source_identifier'
+        first_row = context[:seen_ids][source_id]
+
+        if first_row
+          add_duplicate_error(context, row_index, source_id, source_id_label, first_row)
+        else
+          context[:seen_ids][source_id] = row_index
+          add_existing_warning(context, row_index, source_id, source_id_label)
+        end
+      end
+
+      def self.add_duplicate_error(context, row_index, source_id, source_id_label, first_row)
+        context[:errors] << {
+          row: row_index,
+          source_identifier: source_id,
+          severity: 'error',
+          category: 'duplicate_source_identifier',
+          column: source_id_label,
+          value: source_id,
+          message: I18n.t('bulkrax.importer.guided_import.validation.duplicate_identifier_validator.errors.message',
+                          value: source_id,
+                          field: source_id_label,
+                          original_row: first_row),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.duplicate_identifier_validator.errors.suggestion',
+                             field: source_id_label)
+        }
+      end
+      private_class_method :add_duplicate_error
+
+      def self.add_existing_warning(context, row_index, source_id, source_id_label)
+        find_record = context[:find_record_by_source_identifier]
+        return unless find_record&.call(source_id)
+
+        context[:errors] << {
+          row: row_index,
+          source_identifier: source_id,
+          severity: 'warning',
+          category: 'existing_source_identifier',
+          column: source_id_label,
+          value: source_id,
+          message: I18n.t('bulkrax.importer.guided_import.validation.existing_source_identifier_validator.warnings.message',
+                          value: source_id,
+                          field: source_id_label),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.existing_source_identifier_validator.warnings.suggestion',
+                             field: source_id_label)
+        }
+      end
+      private_class_method :add_existing_warning
+    end
+  end
+end

data/app/validators/bulkrax/csv_row/missing_source_identifier.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that each row has a value for source_identifier unless
+    # fill_in_blank_source_identifiers is configured (in which case Bulkrax
+    # will generate one automatically).
+    module MissingSourceIdentifier
+      def self.call(record, row_index, context)
+        return if Bulkrax.fill_in_blank_source_identifiers.present?
+        return if record[:source_identifier].present?
+
+        source_id_label = context[:source_identifier] || 'source_identifier'
+
+        context[:errors] << {
+          row: row_index,
+          source_identifier: nil,
+          severity: 'error',
+          category: 'missing_source_identifier',
+          column: source_id_label,
+          value: nil,
+          message: I18n.t('bulkrax.importer.guided_import.validation.missing_source_identifier_validator.errors.message',
+                          field: source_id_label),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.missing_source_identifier_validator.errors.suggestion',
+                             field: source_id_label)
+        }
+      end
+    end
+  end
+end

data/app/validators/bulkrax/csv_row/parent_reference.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that any parent references in a row point to source identifiers
+    # that exist either elsewhere in the same CSV or as existing repository records.
+    # Uses context[:all_ids] (Set of all source identifiers) to validate references
+    # within the CSV, and context[:find_record_by_source_identifier] (callable) to
+    # look up existing records in the same way the importer does at runtime.
+    # Uses context[:parent_split_pattern] (String/Regexp, may be nil) for multi-value splitting.
+    module ParentReference
+      def self.call(record, row_index, context)
+        all_ids = context[:all_ids]
+        find_record = context[:find_record_by_source_identifier]
+
+        collect_parent_ids(record, context).each do |parent_id|
+          next if all_ids.include?(parent_id)
+          next if find_record&.call(parent_id)
+
+          context[:errors] << {
+            row: row_index,
+            source_identifier: record[:source_identifier],
+            severity: 'error',
+            category: 'invalid_parent_reference',
+            column: 'parent',
+            value: parent_id,
+            message: I18n.t('bulkrax.importer.guided_import.validation.parent_reference_validator.errors.message',
+                            value: parent_id,
+                            field: 'source_identifier'),
+            suggestion: I18n.t('bulkrax.importer.guided_import.validation.parent_reference_validator.errors.suggestion')
+          }
+        end
+      end
+
+      def self.collect_parent_ids(record, context)
+        split_pattern = context[:parent_split_pattern]
+        parent_column = context[:parent_column] || 'parents'
+
+        base_ids = if split_pattern
+                     record[:parent].to_s.split(split_pattern).map(&:strip).reject(&:blank?)
+                   elsif record[:parent].present?
+                     [record[:parent].to_s.strip]
+                   else
+                     []
+                   end
+
+        suffix_pattern = /\A#{Regexp.escape(parent_column)}_\d+\z/
+        suffix_ids = record[:raw_row]
+                     .select { |k, _| k.to_s.match?(suffix_pattern) }
+                     .values
+                     .map(&:to_s).map(&:strip).reject(&:blank?)
+
+        (base_ids + suffix_ids).uniq
+      end
+      private_class_method :collect_parent_ids
+    end
+  end
+end

data/app/validators/bulkrax/csv_row/required_values.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that each row provides a value for every required field of its model.
+    # Numeric suffixes on column names are normalised before checking
+    # (e.g. 'title_1' satisfies the 'title' requirement).
+    module RequiredValues
+      def self.call(record, row_index, context)
+        field_metadata = context[:field_metadata]
+        return if field_metadata.blank?
+
+        using_default = record[:model].blank?
+        model         = record[:model].presence || Bulkrax.default_work_type
+        metadata      = field_metadata[model]
+        return if metadata.blank?
+
+        add_default_work_type_warning(context, record, row_index, model) if using_default
+        add_missing_required_value_errors(context, record, row_index, metadata)
+      end
+
+      def self.add_default_work_type_warning(context, record, row_index, model)
+        # Suppress per-row warning when a file-level notice already covers all rows.
+        return if context[:notices]&.any? { |n| n[:field] == 'model' }
+
+        context[:errors] << {
+          row: row_index,
+          source_identifier: record[:source_identifier],
+          severity: 'warning',
+          category: 'default_work_type_used',
+          column: 'model',
+          value: nil,
+          message: I18n.t('bulkrax.importer.guided_import.validation.default_work_type_validator.warnings.message',
+                          default_work_type: model),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.default_work_type_validator.warnings.suggestion')
+        }
+      end
+      private_class_method :add_default_work_type_warning
+
+      def self.add_missing_required_value_errors(context, record, row_index, metadata)
+        (metadata[:required_terms] || []).each do |field|
+          next if record[:raw_row].any? { |key, value| normalize_header(key.to_s) == field && value.present? }
+
+          context[:errors] << {
+            row: row_index,
+            source_identifier: record[:source_identifier],
+            severity: 'error',
+            category: 'missing_required_value',
+            column: field,
+            value: nil,
+            message: I18n.t('bulkrax.importer.guided_import.validation.required_field_validator.errors.message', field: field),
+            suggestion: I18n.t('bulkrax.importer.guided_import.validation.required_field_validator.errors.suggestion', field: field)
+          }
+        end
+      end
+      private_class_method :add_missing_required_value_errors
+
+      def self.normalize_header(header)
+        header.sub(/_\d+\z/, '')
+      end
+    end
+  end
+end