bulkrax 9.3.4 → 9.4.0

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Detects circular parent-child relationships in the CSV.
+    # A circular reference occurs when following the parent chain from any record
+    # eventually leads back to itself (e.g. A→B→C→A).
+    #
+    # The validator builds a directed graph (child → parents) from all records on
+    # first invocation and caches the set of all record ids involved in any cycle.
+    # Subsequent per-row calls simply check membership in that set.
+    #
+    # Requires context key:
+    #   :relationship_graph  – Hash { source_identifier => [parent_ids] } built by
+    #                          run_row_validators before iterating rows.
+    module CircularReference
+      def self.call(record, row_index, context)
+        cycle_ids = context[:circular_reference_ids] ||= detect_cycle_ids(context[:relationship_graph] || {})
+        return unless cycle_ids.include?(record[:source_identifier])
+
+        context[:errors] << {
+          row: row_index,
+          source_identifier: record[:source_identifier],
+          severity: 'error',
+          category: 'circular_reference',
+          column: 'parents',
+          value: record[:source_identifier],
+          message: I18n.t('bulkrax.importer.guided_import.validation.circular_reference_validator.errors.message',
+                          value: record[:source_identifier]),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.circular_reference_validator.errors.suggestion')
+        }
+      end
+
+      # Returns the set of all source identifiers that participate in at least one cycle.
+      # Uses recursive DFS with a per-branch ancestry set to detect back-edges.
+      def self.detect_cycle_ids(graph)
+        all_nodes = graph.keys.to_set | graph.values.flatten.to_set
+        visited   = Set.new
+        cycle_ids = Set.new
+
+        all_nodes.each do |node|
+          next if visited.include?(node)
+          dfs(node, graph, visited, [], cycle_ids)
+        end
+
+        cycle_ids
+      end
+      private_class_method :detect_cycle_ids
+
+      def self.dfs(node, graph, visited, ancestors, cycle_ids) # rubocop:disable Metrics/MethodLength
+        visited.add(node)
+        ancestors.push(node)
+
+        (graph[node] || []).each do |neighbor|
+          if ancestors.include?(neighbor)
+            # Back-edge found: mark every node in the cycle path
+            cycle_start = ancestors.index(neighbor)
+            ancestors[cycle_start..].each { |n| cycle_ids.add(n) }
+            cycle_ids.add(neighbor)
+          elsif !visited.include?(neighbor)
+            dfs(neighbor, graph, visited, ancestors, cycle_ids)
+          end
+        end
+
+        ancestors.pop
+      end
+      private_class_method :dfs
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that controlled vocabulary values in each row are valid according
+    # to the QA authority for that field.
+    module ControlledVocabulary
+      def self.call(record, row_index, context) # rubocop:disable Metrics/MethodLength
+        field_metadata = context[:field_metadata]
+        return if field_metadata.blank?
+
+        model = record[:model]
+        metadata = field_metadata[model]
+        return if metadata.blank?
+
+        controlled_terms = metadata[:controlled_vocab_terms] || []
+        return if controlled_terms.blank?
+
+        controlled_terms.each do |field|
+          value = record[:raw_row][field]
+          next if value.blank?
+
+          authority = load_authority(field)
+          next if authority.nil?
+
+          term = authority.find(value)
+          next unless term.blank? || term.dig('active') == false
+
+          context[:errors] << {
+            row: row_index,
+            source_identifier: record[:source_identifier],
+            severity: 'error',
+            category: 'invalid_controlled_value',
+            column: field,
+            value: value,
+            message: I18n.t('bulkrax.importer.guided_import.validation.controlled_vocabulary_validator.errors.message',
+                            value: value, field: field),
+            suggestion: suggestion(value, authority)
+          }
+        end
+      end
+
+      def self.load_authority(field)
+        Qa::Authorities::Local.subauthority_for(field.pluralize)
+      rescue Qa::InvalidSubAuthority
+        begin
+          Qa::Authorities::Local.subauthority_for(field)
+        rescue Qa::InvalidSubAuthority
+          nil
+        end
+      end
+      private_class_method :load_authority
+
+      def self.suggestion(value, authority)
+        suggestion = DidYouMean::SpellChecker.new(dictionary: dictionary_for(authority)).correct(value).first
+        return fallback_suggestion if suggestion.nil?
+
+        I18n.t('bulkrax.importer.guided_import.validation.did_you_mean', suggestion: suggestion)
+      end
+      private_class_method :suggestion
+
+      def self.fallback_suggestion
+        I18n.t('bulkrax.importer.guided_import.validation.controlled_vocabulary_validator.errors.suggestion')
+      end
+      private_class_method :fallback_suggestion
+
+      def self.dictionary_for(authority)
+        authority.all.filter_map { |term| term['label'] if term['active'] == true }.uniq
+      end
+      private_class_method :dictionary_for
+    end
+  end
+end

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

data/app/views/bulkrax/entries/_parsed_metadata.html.erb

@@ -2,7 +2,7 @@
   <div class="accordion-container">
     <div class="accordion-heading" role="tab" id="parsed-metadata-heading">
       <a class="accordion-title" role="button" data-toggle="collapse" data-target="#parsed-metadata-show" aria-expanded="true" aria-controls="parsed-metadata-show">
-        Parsed Metadata:
+        <%= t('bulkrax.entry.labels.parsed_metadata') %>:
       </a>
       <a role="button" data-toggle="collapse" data-target="#parsed-metadata-show" aria-expanded="true" aria-controls="parsed-metadata-show">
         <div class="accordion-icon fa fa-times-circle" aria-hidden="true"></div>

data/app/views/bulkrax/entries/_raw_metadata.html.erb

@@ -2,7 +2,7 @@
   <div class="accordion-container">
     <div class="accordion-heading" role="tab" id="raw-metadata-heading">
       <a class="accordion-title" role="button" data-toggle="collapse" data-target="#raw-metadata-show" aria-expanded="true" aria-controls="raw-metadata-show">
-        Raw Metadata:
+        <%= t('bulkrax.entry.labels.raw_metadata') %>:
       </a>
       <a role="button" data-toggle="collapse" data-target="#raw-metadata-show" aria-expanded="true" aria-controls="raw-metadata-show">
         <div class="accordion-icon fa fa-times-circle" aria-hidden="true"></div>

data/app/views/bulkrax/entries/show.html.erb

@@ -13,7 +13,7 @@
 
     <p class='bulkrax-p-align'>
       <strong><%= t('bulkrax.importer.labels.type') %>:</strong>
-      <%= @entry.factory_class || 'Unknown' %>
+      <%= @entry.factory_class || t('bulkrax.entry.labels.unknown') %>
     </p>
     <%= render partial: 'raw_metadata'%>
 
@@ -39,29 +39,29 @@
           <% if factory_record.present? %>
             <% factory_record_class = factory_record.class %>
             <% factory_record_class_human = factory_record_class.model_name.human %>
-            <strong><%= factory_record_class_human %> Link:</strong>
+            <strong><%= t('bulkrax.entry.labels.record_link', record_type: factory_record_class_human) %>:</strong>
             <% if defined?(Hyrax) && factory_record_class_human == 'Collection' %>
               <%= link_to factory_record_class_human, hyrax.polymorphic_path(factory_record) %>
             <% else %>
               <%= link_to factory_record_class_human, main_app.polymorphic_path(factory_record) %>
             <% end %>
           <% else %>
-            <strong>Item Link:</strong> Item has not yet been imported successfully
+            <strong><%= t('bulkrax.entry.labels.item_link') %>:</strong> <%= t('bulkrax.entry.labels.item_not_imported') %>
           <% end %>
         <% rescue => e %>
-          <strong>Item Link:</strong> Unable to retrieve item (<%= e.message %>)
+          <strong><%= t('bulkrax.entry.labels.item_link') %>:</strong> <%= t('bulkrax.entry.labels.item_link_error', message: e.message) %>
         <% end %>
       <% else %>
         <% record = @entry&.hyrax_record %>
         <% if record.present? && @entry.factory_class %>
-          <strong><%= record.model_name.human %> Link:</strong>
+          <strong><%= t('bulkrax.entry.labels.record_link', record_type: record.model_name.human) %>:</strong>
           <% if defined?(Hyrax) && record.model_name.human == "Collection" %>
             <%= link_to record.model_name.human, hyrax.polymorphic_path(record) %>
           <% else %>
             <%= link_to record.model_name.human, main_app.polymorphic_path(record) %>
           <% end %>
         <% else %>
-          <strong>Item Link:</strong> No item associated with this entry or class unknown
+          <strong><%= t('bulkrax.entry.labels.item_link') %>:</strong> <%= t('bulkrax.entry.labels.item_no_association') %>
         <% end %>
       <% end %>
     </p>

data/app/views/bulkrax/exporters/_form.html.erb

@@ -1,7 +1,7 @@
 <div class="panel-body card-body">
   <% if exporter.errors.any? %>
     <div id="error_explanation">
-      <h2><%= pluralize(exporter.errors.count, "error") %> prohibited this exporter from being saved:</h2>
+      <h2><%= t('bulkrax.exporter.validations.errors_prohibited', count: exporter.errors.count) %></h2>
 
       <ul>
         <% exporter.errors.full_messages.each do |message| %>
@@ -11,35 +11,31 @@
     </div>
   <% end %>
 
-  <%= form.input :name, label: t('bulkrax.exporter.labels.name'), input_html: { class: 'form-control' } %>
+  <%= form.input :name, input_html: { class: 'form-control' } %>
 
   <%= form.hidden_field :user_id, value: current_user.id %>
 
   <%= form.input :export_type,
-    collection:  form.object.export_type_list,
-    label: t('bulkrax.exporter.labels.export_type'),
+    collection: form.object.export_type_list,
     required: true,
-    prompt: 'Please select an export type',
+    prompt: t('bulkrax.exporter.prompts.export_type'),
     input_html: { class: 'form-control' } %>
 
   <%= form.input :export_from,
     collection: form.object.export_from_list,
-    label: t('bulkrax.exporter.labels.export_from'),
     required: true,
-    prompt: 'Please select an export source',
+    prompt: t('bulkrax.exporter.prompts.export_from'),
     input_html: { class: 'form-control' } %>
 
   <%= form.input :export_source_importer,
-    label: t('bulkrax.exporter.labels.importer'),
     required: true,
-    prompt: 'Select from the list',
+    prompt: t('bulkrax.exporter.prompts.select_from_list'),
     label_html: { class: 'importer export-source-option d-none hidden' },
     input_html: { class: 'importer export-source-option d-none hidden form-control' },
-    collection:  form.object.importers_list.sort %>
+    collection: form.object.importers_list.sort %>
 
   <%= form.input :export_source_collection,
-    prompt: 'Start typing ...',
-    label: t('bulkrax.exporter.labels.collection'),
+    prompt: t('bulkrax.exporter.prompts.start_typing'),
     required: true,
     placeholder: @collection&.title&.first,
     label_html: { class: 'collection export-source-option d-none hidden' },
@@ -53,61 +49,41 @@
   %>
 
   <%= form.input :export_source_worktype,
-    label: t('bulkrax.exporter.labels.worktype'),
     required: true,
-    prompt: 'Select from the list',
+    prompt: t('bulkrax.exporter.prompts.select_from_list'),
     label_html: { class: 'worktype export-source-option d-none hidden' },
     input_html: { class: 'worktype export-source-option d-none hidden form-control' },
     collection: Bulkrax.curation_concerns.map { |cc| [cc.to_s, cc.to_s] } %>
 
   <%= form.input :limit,
     as: :integer,
-    hint: 'leave blank or 0 for all records',
-    label: t('bulkrax.exporter.labels.limit'),
     input_html: { class: 'form-control' } %>
 
-  <%= form.input :generated_metadata?,
-                 as: :boolean,
-                 label: t('bulkrax.exporter.labels.generated_metadata'),
-                 hint: t('bulkrax.exporter.hints.generated_metadata') %>
+  <%= form.input :generated_metadata?, as: :boolean %>
 
-  <%= form.input :include_thumbnails?,
-                 as: :boolean,
-                 label: t('bulkrax.exporter.labels.include_thumbnails'),
-                 hint: t('bulkrax.exporter.hints.include_thumbnails') %>
+  <%= form.input :include_thumbnails?, as: :boolean %>
 
-  <%= form.input :date_filter,
-                 as: :boolean,
-                 label: t('bulkrax.exporter.labels.filter_by_date') %>
+  <%= form.input :date_filter, as: :boolean %>
 
   <div id="date_filter_picker" class="d-none hidden">
-    <%= form.input :start_date,
-                   as: :date,
-                   label: t('bulkrax.exporter.labels.start_date'),
-                   input_html: { class: 'form-control' } %>
-
-    <%= form.input :finish_date,
-                   as: :date,
-                   label: t('bulkrax.exporter.labels.finish_date'),
-                   input_html: { class: 'form-control' } %>
+    <%= form.input :start_date, as: :date, input_html: { class: 'form-control' } %>
+
+    <%= form.input :finish_date, as: :date, input_html: { class: 'form-control' } %>
   </div>
   <% if defined?(::Hyrax) %>
     <%= form.input :work_visibility,
-                   collection: form.object.work_visibility_list,
-                  label: t('bulkrax.exporter.labels.visibility'),
-                  input_html: { class: 'form-control' } %>
+      collection: form.object.work_visibility_list,
+      input_html: { class: 'form-control' } %>
   <% end %>
 
   <% if defined?(::Hyrax) %>
     <%= form.input :workflow_status,
-                  collection: form.object.workflow_status_list,
-                  label: t('bulkrax.exporter.labels.status'),
-                  input_html: { class: 'form-control' } %>
+      collection: form.object.workflow_status_list,
+      input_html: { class: 'form-control' } %>
   <% end %>
 
   <%= form.input :parser_klass,
     collection: Bulkrax.parsers.map {|p| [p[:name], p[:class_name], {'data-partial' => p[:partial]}] if p[:class_name].constantize.export_supported? }.compact,
-    label: t('bulkrax.exporter.labels.export_format'),
     input_html: { class: 'form-control' } %>
 </div>
 

data/app/views/bulkrax/exporters/edit.html.erb

@@ -9,9 +9,9 @@
         <%= render 'form', exporter: @exporter, form: form %>
         <div class="panel-footer card-footer bulkrax-card-footer">
           <div class='pull-right'>
-            <%= form.button :submit, value: 'Update Exporter', class: 'btn btn-primary' %>
+            <%= form.button :submit, value: t('helpers.action.exporter.update'), class: 'btn btn-primary' %>
             |
-            <%= form.button :submit, value: 'Update and Re-Export All Items', class: 'btn btn-primary' %>
+            <%= form.button :submit, value: t('helpers.action.exporter.update_and_re_export'), class: 'btn btn-primary' %>
             |
             <% cancel_path = form.object.persisted? ? exporter_path(form.object) : exporters_path %>
             <%= link_to t('bulkrax.cancel'), cancel_path, class: 'btn btn-default ' %>

data/app/views/bulkrax/exporters/index.html.erb

@@ -17,11 +17,11 @@
       <table id='exporters-table' class="table table-striped">
         <thead>
           <tr>
-            <th scope="col">Name</th>
-            <th scope="col">Status</th>
-            <th scope="col">Date Exported</th>
-            <th scope="col">Downloadable Files</th>
-            <th scope="col">Actions</th>
+            <th scope="col"><%= t('bulkrax.table_header.labels.name') %></th>
+            <th scope="col"><%= t('bulkrax.table_header.labels.status') %></th>
+            <th scope="col"><%= t('bulkrax.table_header.labels.date_exported') %></th>
+            <th scope="col"><%= t('bulkrax.table_header.labels.downloadable_files') %></th>
+            <th scope="col"><%= t('bulkrax.table_header.labels.actions') %></th>
           </tr>
         </thead>
       </table>

data/app/views/bulkrax/exporters/new.html.erb

@@ -9,12 +9,10 @@
         <%= render 'form', exporter: @exporter, form: form %>
         <div class="panel-footer card-footer bulkrax-card-footer">
           <div class='pull-right'>
-            <%= form.button :submit, value: 'Create and Export', class: 'btn btn-primary' %>
-            |
-            <%= form.button :submit, value: 'Create', class: 'btn btn-primary' %>
-            |
+            <%= submit_tag t('helpers.action.exporter.create_and_export'), class: 'btn btn-primary me-2' %>
+            <%= submit_tag t('helpers.action.exporter.create'), class: 'btn btn-default me-2' %>
             <% cancel_path = form.object.persisted? ? exporter_path(form.object) : exporters_path %>
-            <%= link_to t('bulkrax.cancel'), cancel_path, class: 'btn btn-default ' %>
+            <%= link_to t('bulkrax.cancel'), cancel_path, class: 'btn btn-default' %>
           </div>
         </div>
       <% end %>

data/app/views/bulkrax/exporters/show.html.erb

@@ -11,7 +11,7 @@
       <%= simple_form_for @exporter, method: :get, url: exporter_download_path(@exporter), html: { class: 'form-inline bulkrax-p-align' } do |form| %>
         <strong>Download:</strong>
         <%= render 'downloads', exporter: @exporter, form: form %>
-        <%= form.button :submit, value: 'Download', data: { disable_with: false } %>
+        <%= form.button :submit, value: t('helpers.action.exporter.download'), data: { disable_with: false } %>
       <% end %>
     <% end %>
 
@@ -101,9 +101,9 @@
         <%= render partial: 'bulkrax/shared/entries_tab', locals: { item: @exporter } %>
       </div>
       <br>
-      <%= link_to 'Edit', edit_exporter_path(@exporter) %>
+      <%= link_to t('helpers.action.exporter.edit'), edit_exporter_path(@exporter) %>
       |
-      <%= link_to 'Back', exporters_path %>
+      <%= link_to t('helpers.action.exporter.back'), exporters_path %>
     </div>
   </div>
 </div>