bulkrax 1.0.1 → 2.0.2

data/app/parsers/bulkrax/csv_parser.rb

@@ -2,31 +2,47 @@
 
 require 'csv'
 module Bulkrax
-  class CsvParser < ApplicationParser
+  class CsvParser < ApplicationParser # rubocop:disable Metrics/ClassLength
     include ErroredEntries
     def self.export_supported?
       true
     end
 
-    def initialize(importerexporter)
-      @importerexporter = importerexporter
+    def records(_opts = {})
+      file_for_import = only_updates ? parser_fields['partial_import_file_path'] : import_file_path
+      # data for entry does not need source_identifier for csv, because csvs are read sequentially and mapped after raw data is read.
+      csv_data = entry_class.read_data(file_for_import)
+      importer.parser_fields['total'] = csv_data.count
+      importer.save
+      @records ||= csv_data.map { |record_data| entry_class.data_for_entry(record_data, nil) }
     end
 
     def collections
-      # does the CSV contain a collection column?
-      return [] unless import_fields.include?(:collection)
+      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.'
+      )
       # retrieve a list of unique collections
-      records.map { |r| r[:collection].split(/\s*[;|]\s*/) if r[:collection].present? }.flatten.compact.uniq
+      records.map do |r|
+        collections = []
+        r[collection_field_mapping].split(/\s*[;|]\s*/).each { |title| collections << { title: title, from_collection_field_mapping: true } } if r[collection_field_mapping].present?
+        model_field_mappings.each do |model_mapping|
+          collections << r if r[model_mapping.to_sym]&.downcase == 'collection'
+        end
+        collections
+      end.flatten.compact.uniq
     end
 
     def collections_total
       collections.size
     end
 
-    def records(_opts = {})
-      file_for_import = only_updates ? parser_fields['partial_import_file_path'] : import_file_path
-      # data for entry does not need source_identifier for csv, because csvs are read sequentially and mapped after raw data is read.
-      @records ||= entry_class.read_data(file_for_import).map { |record_data| entry_class.data_for_entry(record_data, nil) }
+    def works
+      records - collections
+    end
+
+    def works_total
+      works.size
     end
 
     # We could use CsvEntry#fields_from_data(data) but that would mean re-reading the data
@@ -44,8 +60,9 @@ module Bulkrax
     end
 
     def valid_import?
-      error_alert = "Missing at least one required element, missing element(s) are: #{missing_elements(import_fields).join(', ')}"
-      raise StandardError, error_alert unless required_elements?(import_fields)
+      import_strings = keys_without_numbers(import_fields.map(&:to_s))
+      error_alert = "Missing at least one required element, missing element(s) are: #{missing_elements(import_strings).join(', ')}"
+      raise StandardError, error_alert unless required_elements?(import_strings)
 
       file_paths.is_a?(Array)
     rescue StandardError => e
@@ -56,26 +73,46 @@ module Bulkrax
     def create_collections
       collections.each_with_index do |collection, index|
         next if collection.blank?
-        metadata = {
-          title: [collection],
-          work_identifier => [collection],
-          visibility: 'open',
-          collection_type_gid: Hyrax::CollectionType.find_or_create_default_collection_type.gid
-        }
-        new_entry = find_or_create_entry(collection_entry_class, collection, 'Bulkrax::Importer', metadata)
-        ImportWorkCollectionJob.perform_now(new_entry.id, current_run.id)
+        break if records.find_index(collection).present? && limit_reached?(limit, records.find_index(collection))
+        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.'
+        )
+
+        ## BEGIN
+        # Add required metadata to collections being imported using the collection_field_mapping, which only have a :title
+        # TODO: Remove once collection_field_mapping is removed
+        metadata = if collection.delete(:from_collection_field_mapping)
+                     uci = unique_collection_identifier(collection)
+                     {
+                       title: [collection[:title]],
+                       work_identifier => uci,
+                       source_identifier => uci,
+                       visibility: 'open',
+                       collection_type_gid: ::Hyrax::CollectionType.find_or_create_default_collection_type.gid
+                     }
+                   end
+        collection_hash = metadata.presence || collection
+        ## END
+
+        new_entry = find_or_create_entry(collection_entry_class, collection_hash[source_identifier], 'Bulkrax::Importer', collection_hash)
+        # TODO: add support for :delete option
+        ImportCollectionJob.perform_now(new_entry.id, current_run.id)
         increment_counters(index, true)
       end
+      importer.record_status
+    rescue StandardError => e
+      status_info(e)
     end
 
     def create_works
-      records.each_with_index do |record, index|
-        next unless record_has_source_identifier(record, index)
-        break if limit_reached?(limit, index)
+      works.each_with_index do |work, index|
+        next unless record_has_source_identifier(work, records.find_index(work))
+        break if limit_reached?(limit, records.find_index(work))
 
-        seen[record[source_identifier]] = true
-        new_entry = find_or_create_entry(entry_class, record[source_identifier], 'Bulkrax::Importer', record.to_h.compact)
-        if record[:delete].present?
+        seen[work[source_identifier]] = true
+        new_entry = find_or_create_entry(entry_class, work[source_identifier], 'Bulkrax::Importer', work.to_h)
+        if work[:delete].present?
           DeleteWorkJob.send(perform_method, new_entry, current_run)
         else
           ImportWorkJob.send(perform_method, new_entry.id, current_run.id)
@@ -99,10 +136,6 @@ module Bulkrax
       path
     end
 
-    def create_parent_child_relationships
-      super
-    end
-
     def extra_filters
       output = ""
       if importerexporter.start_date.present?
@@ -117,6 +150,8 @@ module Bulkrax
 
     def current_work_ids
       case importerexporter.export_from
+      when 'all'
+        ActiveFedora::SolrService.query("has_model_ssim:(#{Hyrax.config.curation_concerns.join(' OR ')}) #{extra_filters}", rows: 2_147_483_647).map(&:id)
       when 'collection'
         ActiveFedora::SolrService.query("member_of_collection_ids_ssim:#{importerexporter.export_source + extra_filters}", rows: 2_000_000_000).map(&:id)
       when 'worktype'
@@ -126,9 +161,16 @@ module Bulkrax
         complete_statuses = Bulkrax::Status.latest_by_statusable
                                            .includes(:statusable)
                                            .where('bulkrax_statuses.statusable_id IN (?) AND bulkrax_statuses.statusable_type = ? AND status_message = ?', entry_ids, 'Bulkrax::Entry', 'Complete')
-        complete_entry_identifiers = complete_statuses.map { |s| s.statusable&.identifier }
 
-        ActiveFedora::SolrService.query("#{work_identifier}_tesim:(#{complete_entry_identifiers.join(' OR ')})#{extra_filters}", rows: 2_000_000_000).map(&:id)
+        complete_entry_identifiers = complete_statuses.map { |s| s.statusable&.identifier&.gsub(':', '\:') }
+        extra_filters = extra_filters.presence || '*:*'
+
+        ActiveFedora::SolrService.get(
+          extra_filters.to_s,
+          fq: "#{work_identifier}_sim:(#{complete_entry_identifiers.join(' OR ')})",
+          fl: 'id',
+          rows: 2_000_000_000
+        )['response']['docs'].map { |obj| obj['id'] }
       end
     end
 
@@ -136,12 +178,18 @@ module Bulkrax
       current_work_ids.each_with_index do |wid, index|
         break if limit_reached?(limit, index)
         new_entry = find_or_create_entry(entry_class, wid, 'Bulkrax::Exporter')
-        Bulkrax::ExportWorkJob.perform_now(new_entry.id, current_run.id)
+        begin
+          entry = Bulkrax::ExportWorkJob.perform_now(new_entry.id, current_run.id)
+        rescue => e
+          Rails.logger.info("#{e.message} was detected during export")
+        end
+        self.headers |= entry.parsed_metadata.keys if entry
       end
     end
     alias create_from_collection create_new_entries
     alias create_from_importer create_new_entries
     alias create_from_worktype create_new_entries
+    alias create_from_all create_new_entries
 
     def entry_class
       CsvEntry
@@ -154,19 +202,11 @@ module Bulkrax
     # See https://stackoverflow.com/questions/2650517/count-the-number-of-lines-in-a-file-without-reading-entire-file-into-memory
     #   Changed to grep as wc -l counts blank lines, and ignores the final unescaped line (which may or may not contain data)
     def total
-      if importer?
-        return @total if @total&.positive?
-        # windows enocded
-        @total = `grep -c ^M #{real_import_file_path}`.to_i - 1
-        # unix encoded
-        @total = `grep -vc ^$ #{real_import_file_path}`.to_i - 1 if @total < 1
-      elsif exporter?
-        @total = importerexporter.entries.count
-      else
-        @total = 0
-      end
-      return @total
-    rescue StandardErrorr
+      @total = importer.parser_fields['total'] || 0 if importer?
+      @total = importerexporter.entries.count if exporter?
+
+      return @total || 0
+    rescue StandardError
       @total = 0
     end
 
@@ -201,32 +241,58 @@ module Bulkrax
       end
     end
 
-    def key_allowed(key)
-      !Bulkrax.reserved_properties.include?(key) &&
-        new_entry(entry_class, 'Bulkrax::Exporter').field_supported?(key) &&
+    def export_key_allowed(key)
+      new_entry(entry_class, 'Bulkrax::Exporter').field_supported?(key) &&
         key != source_identifier.to_s
     end
 
     # All possible column names
     def export_headers
-      headers = ['id']
-      headers << source_identifier.to_s
-      headers << 'model'
-      headers << 'collections'
-      importerexporter.mapping.each_key { |key| headers << key if key_allowed(key) }
-      headers << 'file'
+      headers = sort_headers(self.headers)
+
+      # we don't want access_control_id exported and we want file at the end
+      headers.delete('access_control_id') if headers.include?('access_control_id')
+
+      # add the headers below at the beginning or end to maintain the preexisting export behavior
+      headers.prepend('model')
+      headers.prepend(source_identifier.to_s)
+      headers.prepend('id')
+
       headers.uniq
     end
 
+    def object_names
+      return @object_names if @object_names
+
+      @object_names = mapping.values.map { |value| value['object'] }
+      @object_names.uniq!.delete(nil)
+
+      @object_names
+    end
+
+    def sort_headers(headers)
+      # converting headers like creator_name_1 to creator_1_name so they get sorted by numerical order
+      # while keeping objects grouped together
+      headers.sort_by do |item|
+        number = item.match(/\d+/)&.[](0) || 0.to_s
+        sort_number = number.rjust(4, "0")
+        object_prefix = object_names.detect { |o| item.match(/^#{o}/) } || item
+        remainder = item.gsub(/^#{object_prefix}_/, '').gsub(/_#{number}/, '')
+        "#{object_prefix}_#{sort_number}_#{remainder}"
+      end
+    end
+
     # in the parser as it is specific to the format
     def setup_export_file
-      File.join(importerexporter.exporter_export_path, 'export.csv')
+      File.join(importerexporter.exporter_export_path, "export_#{importerexporter.export_source}_from_#{importerexporter.export_from}.csv")
     end
 
     # Retrieve file paths for [:file] mapping in records
     #  and check all listed files exist.
     def file_paths
       raise StandardError, 'No records were found' if records.blank?
+      return [] if importerexporter.metadata_only?
+
       @file_paths ||= records.map do |r|
         file_mapping = Bulkrax.field_mappings.dig(self.class.to_s, 'file', :from)&.first&.to_sym || :file
         next if r[file_mapping].blank?
@@ -245,23 +311,31 @@ module Bulkrax
     # Retrieve the path where we expect to find the files
     def path_to_files
       @path_to_files ||= File.join(
-        File.file?(import_file_path) ? File.dirname(import_file_path) : import_file_path,
+        zip? ? importer_unzip_path : File.dirname(import_file_path),
         'files'
       )
     end
 
     private
 
+    def unique_collection_identifier(collection_hash)
+      entry_uid = collection_hash[source_identifier]
+      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
+                    end
+
+      entry_uid
+    end
+
     # Override to return the first CSV in the path, if a zip file is supplied
     # We expect a single CSV at the top level of the zip in the CSVParser
     # but we are willing to go look for it if need be
     def real_import_file_path
-      if file? && zip?
-        unzip(parser_fields['import_file_path'])
-        return Dir["#{importer_unzip_path}/**/*.csv"].first
-      else
-        parser_fields['import_file_path']
-      end
+      return Dir["#{importer_unzip_path}/**/*.csv"].first if file? && zip?
+
+      parser_fields['import_file_path']
     end
   end
 end

data/app/parsers/bulkrax/oai_dc_parser.rb

@@ -75,7 +75,7 @@ module Bulkrax
 
         new_entry = collection_entry_class.where(importerexporter: importerexporter, identifier: unique_collection_identifier, raw_metadata: metadata).first_or_create!
         # perform now to ensure this gets created before work imports start
-        ImportWorkCollectionJob.perform_now(new_entry.id, importerexporter.current_run.id)
+        ImportCollectionJob.perform_now(new_entry.id, importerexporter.current_run.id)
         increment_counters(index, true)
       end
     end
@@ -119,7 +119,10 @@ module Bulkrax
       end
     end
 
-    def create_parent_child_relationships; end
+    # TODO: change to differentiate between collection and work records when adding ability to import collection metadata
+    def works_total
+      total
+    end
 
     def total
       @total ||= records(quick: true).doc.find(".//resumptionToken").to_a.first.attributes["completeListSize"].to_i

data/app/parsers/bulkrax/xml_parser.rb

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

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

@@ -32,7 +32,7 @@
     prompt: 'Select from the list',
     label_html: { class: 'importer export-source-option hidden' },
     input_html: { class: 'importer export-source-option hidden' },
-    collection:  form.object.importers_list %>
+    collection:  form.object.importers_list.sort %>
 
   <%= form.input :export_source_collection,
     prompt: 'Start typing ...',

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

@@ -7,6 +7,13 @@
 <div class='panel panel-default'>
   <div class='panel-body'>
 
+    <% if File.exist?(@exporter.exporter_export_zip_path) %>
+      <p class='bulkrax-p-align'>
+        <strong>Download:</strong>
+        <%= link_to raw('<span class="glyphicon glyphicon-download"></span>'), exporter_download_path(@exporter) %>
+      </p>
+    <% end %>
+
     <p class='bulkrax-p-align'>
       <strong><%= t('bulkrax.exporter.labels.name') %>:</strong>
       <%= @exporter.name %>
@@ -50,8 +57,9 @@
       <strong><%= t('bulkrax.exporter.labels.limit') %>:</strong>
       <%= @exporter.limit %>
     </p>
+    <%= render partial: 'bulkrax/shared/bulkrax_errors', locals: {item: @exporter} %>
 
-  <%= render partial: 'bulkrax/shared/bulkrax_field_mapping', locals: {item: @exporter} %>
+    <%= render partial: 'bulkrax/shared/bulkrax_field_mapping', locals: {item: @exporter} %>
 
     <%# Currently, no parser-specific fields exist on Exporter,
         thus there's no real reason to always show this field %>
@@ -116,6 +124,10 @@
       <%= page_entries_info(@work_entries) %><br>
       <%= paginate(@work_entries, param_name: :work_entries_page) %>
       <br>
+      <% if File.exist?(@exporter.exporter_export_zip_path) %>
+        <%= link_to 'Download', exporter_download_path(@exporter) %>
+        |
+      <% end %>
       <%= link_to 'Edit', edit_exporter_path(@exporter) %>
       |
       <%= link_to 'Back', exporters_path %>

data/app/views/bulkrax/importers/_edit_form_buttons.html.erb

@@ -1,16 +1,47 @@
+<div class="modal fade" id="bulkraxModal" tabindex="-1" role="dialog" aria-labelledby="bulkraxModalLabel">
+  <div class="modal-dialog" role="document">
+    <div class="modal-content">
+      <div class="modal-body">
+        <h5>Options for Updating the Importer</h5>
+        <hr />
 
-<%# If we can know the parser, we can vary the buttons here %>
+        <% if @importer.importer_runs.blank? %>
+          <p>Only update the values in the importer form. Do not import metadata or files for any works or collections.</p>
+          <%= form.button :submit, value: 'Update Importer', class: 'btn btn-primary' %>
+          <hr />
+          <p>Update the values in the importer form and run the importer for the first time.</p>
+          <%= form.button :submit, value: 'Update and Import', class: 'btn btn-primary' %>
+        <% elsif @importer.parser_klass.include?('Oai') %>
+          <p>Only update the values in the importer form. Do not update metadata or files for any works or collections.</p>
+            <%= form.button :submit, value: 'Update Importer', class: 'btn btn-primary' %>
+          <hr />
+          <p>Update the values in the importer form and update items that have changed at the source.</p>
+            <%= form.button :submit, value: 'Update and Harvest Updated Items', class: 'btn btn-primary' %>
+          <hr />
+          <p>Update the values in the importer form and recreate all items from the source.</p>
+            <%= form.button :submit, value: 'Update and Re-Harvest All Items', class: 'btn btn-primary' %>
+        <% else %>
+          <p>Only update the values in the importer form. Do not update metadata or files for any works or collections.</p>
+            <%= form.button :submit, value: 'Update Importer', class: 'btn btn-primary' %>
+          <hr />
+          <p>Update the values in the importer form and update the metadata for all works. Do not update any files.</p>
+            <%= form.button :submit, value: 'Update Metadata', class: 'btn btn-primary' %>
+          <hr />
+          <p>Update the values in the importer form and update the metadata and files for all works. Creates new versions of the files and retains the old versions.</p>
+            <%= form.button :submit, value: 'Update Metadata and Files', class: 'btn btn-primary' %>
+          <hr />
+          <p>Update the values in the importer form and update the metadata. Completely removes all files attached to works for this importer and recreates the files from scratch.</p>
+          <%= form.button :submit,
+                          value: 'Update and Replace Files',
+                          class: 'btn btn-primary',
+                          data: {confirm: "Are you sure? This will remove all files before adding them from the import."} %>
+        <% end %>
+        <hr />
 
-<% if @importer.importer_runs.blank? %>
-	<%= form.button :submit, value: 'Update Importer', class: 'btn btn-primary' %>
-	| <%= form.button :submit, value: 'Update and Import (importer has not yet been run)', class: 'btn btn-primary' %>
-<% elsif @importer.parser_klass.include?('Oai') %> 
-	<%= form.button :submit, value: 'Update Importer', class: 'btn btn-primary' %>
-	| <%= form.button :submit, value: 'Update and Harvest Updated Items', class: 'btn btn-primary' %>
-	| <%= form.button :submit, value: 'Update and Re-Harvest All Items', class: 'btn btn-primary' %>
-<% else %>
-	<%= form.button :submit, value: 'Update Importer', class: 'btn btn-primary' %>
-	| <%= form.button :submit, value: 'Update and Re-Import (update metadata only)', class: 'btn btn-primary' %>
-  | <%= form.button :submit, value: 'Update All (update metadata and update files)', class: 'btn btn-primary' %>
-	| <%= form.button :submit, value: 'Update and Re-Import (update metadata and replace files)', class: 'btn btn-primary', data: {confirm: "Are you sure? This will remove all files before adding them from the import."} %>
-<% end %>
+      </div>
+      <div class="modal-footer">
+        <button type="button" class="btn btn-default" data-dismiss="modal"><%= t('helpers.action.cancel') %></button>
+      </div>
+    </div>
+  </div>
+</div>

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

@@ -5,10 +5,12 @@
 <div class="row">
   <div class="col-md-12">
     <div class="panel panel-default tabs">
+
       <%= simple_form_for @importer, html: { multipart: true } do |form| %>
         <%= render 'form', importer: @importer, form: form %>
         <div class="panel-footer">
           <div class='pull-right'>
+            <%= link_to 'Update Importer', '#bulkraxModal', class: "btn btn-primary", data: { toggle: 'modal' } %>
             <%= render 'edit_form_buttons', form: form %>
            <% cancel_path = form.object.persisted? ? importer_path(form.object) : importers_path %>
             | <%= link_to t('.cancel'), cancel_path, class: 'btn btn-default ' %>

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

@@ -31,23 +31,21 @@
           </thead>
           <tbody>
             <% @importers.each do |importer| %>
-            <tr>
-              <th scope="row"><%= link_to importer.name, importer_path(importer) %></th>
-              <td>
-                <%= importer.status %>
-              </td>
-              <td><%= importer.last_imported_at.strftime("%b %d, %Y") if importer.last_imported_at %></td>
-              <td><%= importer.next_import_at.strftime("%b %d, %Y") if importer.next_import_at %></td>
-              <td><%= importer.importer_runs.last&.enqueued_records %></td>
-              <td><%= (importer.importer_runs.last&.processed_collections || 0) + (importer.importer_runs.last&.processed_records || 0)  %></td>
-              <td><%= (importer.importer_runs.last&.failed_collections || 0) + (importer.importer_runs.last&.failed_records || 0)  %></td>
-              <td><%= importer.importer_runs.last&.deleted_records %></td>
-              <td><%= importer.importer_runs.last&.total_collection_entries %></td>
-              <td><%= importer.importer_runs.last&.total_work_entries %></td>
-              <td><%= link_to raw('<span class="glyphicon glyphicon-info-sign"></span>'), importer_path(importer) %></td>
-              <td><%= link_to raw('<span class="glyphicon glyphicon-pencil"></span>'), edit_importer_path(importer) %></td>
-              <td><%= link_to raw('<span class="glyphicon glyphicon-remove"></span>'), importer, method: :delete, data: { confirm: 'Are you sure?' } %></td>
-            </tr>
+              <tr>
+                <th scope="row"><%= link_to importer.name, importer_path(importer) %></th>
+                <td><%= importer.status %></td>
+                <td><%= importer.last_imported_at.strftime("%b %d, %Y") if importer.last_imported_at %></td>
+                <td><%= importer.next_import_at.strftime("%b %d, %Y") if importer.next_import_at %></td>
+                <td><%= importer.importer_runs.last&.enqueued_records %></td>
+                <td><%= (importer.importer_runs.last&.processed_collections || 0) + (importer.importer_runs.last&.processed_records || 0) %></td>
+                <td><%= (importer.importer_runs.last&.failed_collections || 0) + (importer.importer_runs.last&.failed_records || 0) %></td>
+                <td><%= importer.importer_runs.last&.deleted_records %></td>
+                <td><%= importer.importer_runs.last&.total_collection_entries %></td>
+                <td><%= importer.importer_runs.last&.total_work_entries %></td>
+                <td><%= link_to raw('<span class="glyphicon glyphicon-info-sign"></span>'), importer_path(importer) %></td>
+                <td><%= link_to raw('<span class="glyphicon glyphicon-pencil"></span>'), edit_importer_path(importer) %></td>
+                <td><%= link_to raw('<span class="glyphicon glyphicon-remove"></span>'), importer, method: :delete, data: { confirm: 'Are you sure?' } %></td>
+              </tr>
             <% end %>
           </tbody>
         </table>

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

@@ -101,8 +101,10 @@
                   <td><%= e.id %></td>
                   <% if e.status == "Complete" %>
                     <td><span class="glyphicon glyphicon-ok" style="color: green;"></span> <%= e.status %></td>
+                  <% elsif e.status == "Pending" %>
+                    <td><span class="glyphicon glyphicon-option-horizontal" style="color: blue;"></span> <%= e.status %></td>
                   <% else %>
-                    <td><span class="glyphicon glyphicon-remove" style="color: red;"></span> <%= e.status %></td>
+                    <td><span class="glyphicon glyphicon-remove" style="color: <%= e.status == 'Deleted' ? 'green' : 'red' %>;"></span> <%= e.status %></td>
                   <% end %>
                   <% if e.last_error.present? %>
                     <td><%= link_to e.last_error.dig("error_class"), bulkrax.importer_entry_path(@importer.id, e.id) %></td>
@@ -137,8 +139,10 @@
                   <td><%= e.id %></td>
                   <% if e.status == "Complete" %>
                     <td><span class="glyphicon glyphicon-ok" style="color: green;"></span> <%= e.status %></td>
+                  <% elsif e.status == "Pending" %>
+                    <td><span class="glyphicon glyphicon-option-horizontal" style="color: blue;"></span> <%= e.status %></td>
                   <% else %>
-                    <td><span class="glyphicon glyphicon-remove" style="color: red;"></span> <%= e.status %></td>
+                    <td><span class="glyphicon glyphicon-remove" style="color: <%= e.status == 'Deleted' ? 'green' : 'red' %>;"></span> <%= e.status %></td>
                   <% end %>
                   <% if e.last_error.present? %>
                     <td><%= link_to e.last_error.dig("error_class"), bulkrax.importer_entry_path(@importer.id, e.id) %></td>

data/config/locales/bulkrax.en.yml

@@ -6,6 +6,7 @@ en:
         importers: Importers
     exporter:
       labels:
+        all: All
         collection: Collection
         export_format: Export Format
         export_from: Export From

data/db/migrate/20190731114016_change_importer_and_exporter_to_polymorphic.rb

@@ -6,7 +6,11 @@ end
 
 class ChangeImporterAndExporterToPolymorphic < ActiveRecord::Migration[5.1]
   def change
-    rename_column :bulkrax_entries, :importer_id, :importerexporter_id if column_exists?(:bulkrax_entries, :importer_id)
+    if column_exists?(:bulkrax_entries, :importer_id)
+      remove_foreign_key :bulkrax_entries, column: :importer_id
+      remove_index :bulkrax_entries, :importer_id
+      rename_column :bulkrax_entries, :importer_id, :importerexporter_id
+    end
     add_column :bulkrax_entries, :importerexporter_type, :string, after: :id, default: 'Bulkrax::Importer' unless column_exists?(:bulkrax_entries, :importerexporter_type)
   end
 end

data/db/migrate/20211004170708_change_bulkrax_statuses_error_message_column_type_to_text.rb

@@ -0,0 +1,5 @@
+class ChangeBulkraxStatusesErrorMessageColumnTypeToText < ActiveRecord::Migration[5.1]
+  def change
+    change_column :bulkrax_statuses, :error_message, :text
+  end
+end

data/db/migrate/20211203195233_rename_children_counters_to_relationships.rb

@@ -0,0 +1,6 @@
+class RenameChildrenCountersToRelationships < ActiveRecord::Migration[5.2]
+  def change
+    rename_column :bulkrax_importer_runs, :processed_children, :processed_relationships
+    rename_column :bulkrax_importer_runs, :failed_children, :failed_relationships
+  end
+end

data/lib/bulkrax/engine.rb

@@ -25,7 +25,7 @@ module Bulkrax
     config.after_initialize do
       my_engine_root = Bulkrax::Engine.root.to_s
       paths = ActionController::Base.view_paths.collect(&:to_s)
-      hyrax_path = paths.detect { |path| path.match('/hyrax-') }
+      hyrax_path = paths.detect { |path| path.match(/\/hyrax-[\d\.]+.*/) }
       paths = if hyrax_path
                 paths.insert(paths.index(hyrax_path), my_engine_root + '/app/views')
               else

data/lib/bulkrax/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bulkrax
-  VERSION = '1.0.1'
+  VERSION = '2.0.2'
 end