bulkrax 1.0.2 → 2.1.0

data/app/parsers/bulkrax/csv_parser.rb

@@ -2,31 +2,61 @@
 
 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 - file_sets
+    end
+
+    def works_total
+      works.size
+    end
+
+    def file_sets
+      records.map do |r|
+        file_sets = []
+        model_field_mappings.each do |model_mapping|
+          file_sets << r if r[model_mapping.to_sym]&.downcase == 'fileset'
+        end
+        file_sets
+      end.flatten.compact.uniq
+    end
+
+    def file_sets_total
+      file_sets.size
     end
 
     # We could use CsvEntry#fields_from_data(data) but that would mean re-reading the data
@@ -44,8 +74,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 +87,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)
-        increment_counters(index, true)
+        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, collection: 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)
@@ -87,6 +138,20 @@ module Bulkrax
       status_info(e)
     end
 
+    def create_file_sets
+      file_sets.each_with_index do |file_set, index|
+        next unless record_has_source_identifier(file_set, records.find_index(file_set))
+        break if limit_reached?(limit, records.find_index(file_set))
+
+        new_entry = find_or_create_entry(file_set_entry_class, file_set[source_identifier], 'Bulkrax::Importer', file_set.to_h)
+        ImportFileSetJob.perform_later(new_entry.id, current_run.id)
+        increment_counters(index, file_set: true)
+      end
+      importer.record_status
+    rescue StandardError => e
+      status_info(e)
+    end
+
     def write_partial_import_file(file)
       import_filename = import_file_path.split('/').last
       partial_import_filename = "#{File.basename(import_filename, '.csv')}_corrected_entries.csv"
@@ -99,10 +164,6 @@ module Bulkrax
       path
     end
 
-    def create_parent_child_relationships
-      super
-    end
-
     def extra_filters
       output = ""
       if importerexporter.start_date.present?
@@ -117,6 +178,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 +189,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 +206,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
@@ -151,22 +227,18 @@ module Bulkrax
       CsvCollectionEntry
     end
 
+    def file_set_entry_class
+      CsvFileSetEntry
+    end
+
     # 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 +273,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 +343,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,8 +75,8 @@ 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)
-        increment_counters(index, true)
+        ImportCollectionJob.perform_now(new_entry.id, importerexporter.current_run.id)
+        increment_counters(index, collection: 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

@@ -57,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 %>

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

@@ -24,6 +24,7 @@
               <th scope="col">Entries Deleted Upstream</th>
               <th scope="col">Total Collection Entries</th>
               <th scope="col">Total Work Entries</th>
+              <th scope="col">Total File Set Entries</th>
               <th scope="col"></th>
               <th scope="col"></th>
               <th scope="col"></th>
@@ -31,23 +32,22 @@
           </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.last_run&.enqueued_records %></td>
+                <td><%= (importer.last_run&.processed_records || 0) %></td>
+                <td><%= (importer.last_run&.failed_records || 0) %></td>
+                <td><%= importer.last_run&.deleted_records %></td>
+                <td><%= importer.last_run&.total_collection_entries %></td>
+                <td><%= importer.last_run&.total_work_entries %></td>
+                <td><%= importer.last_run&.total_file_set_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

@@ -56,14 +56,19 @@
 
     <%= render partial: 'bulkrax/shared/bulkrax_field_mapping', locals: {item: @importer} %>
 
-    <p class="bulkrax-p-align">
+    <p class="bulkrax-p-align" title="<%= @importer.last_run&.processed_works %> processed, <%= @importer.last_run&.failed_works %> failed">
       <strong>Total Works:</strong>
-      <%= @importer.importer_runs.last&.total_work_entries %>
+      <%= @importer.last_run&.total_work_entries %>
     </p>
 
-    <p class="bulkrax-p-align">
+    <p class="bulkrax-p-align" title="<%= @importer.last_run&.processed_collections %> processed, <%= @importer.last_run&.failed_collections %> failed">
       <strong>Total Collections:</strong>
-      <%= @importer.importer_runs.last&.total_collection_entries %>
+      <%= @importer.last_run&.total_collection_entries %>
+    </p>
+
+    <p class="bulkrax-p-align" title="<%= @importer.last_run&.processed_file_sets %> processed, <%= @importer.last_run&.failed_file_sets %> failed">
+      <strong>Total File Sets:</strong>
+      <%= @importer.last_run&.total_file_set_entries %>
     </p>
 
     <div class="bulkrax-nav-tab-bottom-margin">
@@ -71,6 +76,7 @@
       <ul class="bulkrax-nav-tab-top-margin tab-nav nav nav-tabs" role="tablist">
         <li role="presentation" class='active'><a href="#work-entries" aria-controls="work-entries" role="tab" data-toggle="tab">Work Entries</a></li>
         <li role="presentation"><a href="#collection-entries" aria-controls="collection-entries" role="tab" data-toggle="tab">Collection Entries</a></li>
+        <li role="presentation"><a href="#file-set-entries" aria-controls="file-set-entries" role="tab" data-toggle="tab">File Set Entries</a></li>
       </ul>
       <!-- Tab panes -->
       <div class="tab-content outline">
@@ -101,8 +107,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 +145,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>
@@ -154,6 +164,42 @@
           <%= page_entries_info(@collection_entries) %><br />
           <%= paginate(@collection_entries, theme: 'blacklight', param_name: :collections_entries_page, params: {anchor: 'collection-entries'}) %>
         </div>
+        <div role="tabpanel" class="tab-pane bulkrax-nav-tab-table-left-align" id="file-set-entries">
+          <table class='table table-striped'>
+            <thead>
+              <tr>
+                <th>Identifier</th>
+                <th>Entry ID</th>
+                <th>Status</th>
+                <th>Errors</th>
+                <th>Status Set At</th>
+                <th>Actions</th>
+              </tr>
+            </thead>
+            <tbody>
+              <% @file_set_entries.each do |e| %>
+                <tr>
+                  <td><%= link_to e.identifier, bulkrax.importer_entry_path(@importer.id, e.id) %></td>
+                  <td><%= e.id %></td>
+                  <% if e.status == "Complete" %>
+                    <td><span class="glyphicon glyphicon-ok" style="color: green;"></span> <%= e.status %></td>
+                  <% else %>
+                    <td><span class="glyphicon glyphicon-remove" style="color: 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>
+                  <% else %>
+                    <td></td>
+                  <% end %>
+                  <td><%= e.status_at %></td>
+                  <td><%= link_to raw('<span class="glyphicon glyphicon-info-sign"></span>'), bulkrax.importer_entry_path(@importer.id, e.id) %></td>
+                </tr>
+              <% end %>
+            </tbody>
+          </table>
+          <%= page_entries_info(@file_set_entries) %><br />
+          <%= paginate(@file_set_entries, theme: 'blacklight', param_name: :file_set_entries_page, params: {anchor: 'file-set-entries'}) %>
+        </div>
       </div>
     </div>
 

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/db/migrate/20211220195027_add_file_set_counters_to_importer_runs.rb

@@ -0,0 +1,7 @@
+class AddFileSetCountersToImporterRuns < ActiveRecord::Migration[5.2]
+  def change
+    add_column :bulkrax_importer_runs, :processed_file_sets, :integer, default: 0 unless column_exists?(:bulkrax_importer_runs, :processed_file_sets)
+    add_column :bulkrax_importer_runs, :failed_file_sets, :integer, default: 0 unless column_exists?(:bulkrax_importer_runs, :failed_file_sets)
+    add_column :bulkrax_importer_runs, :total_file_set_entries, :integer, default: 0 unless column_exists?(:bulkrax_importer_runs, :total_file_set_entries)
+  end
+end

data/db/migrate/20220118001339_add_import_attempts_to_entries.rb

@@ -0,0 +1,5 @@
+class AddImportAttemptsToEntries < ActiveRecord::Migration[5.2]
+  def change
+    add_column :bulkrax_entries, :import_attempts, :integer, default: 0 unless column_exists?(:bulkrax_entries, :import_attempts)
+  end
+end

data/db/migrate/20220119213325_add_work_counters_to_importer_runs.rb

@@ -0,0 +1,6 @@
+class AddWorkCountersToImporterRuns < ActiveRecord::Migration[5.2]
+  def change
+    add_column :bulkrax_importer_runs, :processed_works, :integer, default: 0 unless column_exists?(:bulkrax_importer_runs, :processed_works)
+    add_column :bulkrax_importer_runs, :failed_works, :integer, default: 0 unless column_exists?(:bulkrax_importer_runs, :failed_works)
+  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.2'
+  VERSION = '2.1.0'
 end