Export from date range

app/controllers/bulkrax/exporters_controller.rb

@@ -92,14 +92,20 @@ def set_exporter
       # Only allow a trusted parameters through.
       def exporter_params
         params[:exporter][:export_source] = params[:exporter]["export_source_#{params[:exporter][:export_from]}".to_sym]
-        params.fetch(:exporter).permit(:name, :user_id, :export_source, :export_from, :export_type, :parser_klass, :limit, field_mapping: {})
+        if params[:exporter][:date_filter] == "1"
+          params.fetch(:exporter).permit(:name, :user_id, :export_source, :export_from, :export_type,
+                                       :parser_klass, :limit, :start_date, :finish_date, :work_visibility, field_mapping: {})
+        else
+          params.fetch(:exporter).permit(:name, :user_id, :export_source, :export_from, :export_type,
+                                         :parser_klass, :limit, :work_visibility, field_mapping: {}).merge(start_date:nil, finish_date:nil)
+        end
       end
 
       # Add the field_mapping from the Bulkrax configuration
       def field_mapping_params
         # @todo replace/append once mapping GUI is in place
-        fields = Bulkrax.parsers.map { |m| m[:partial] if m[:class_name] == params[:exporter][:parser_klass] }.compact.first
-        @exporter.field_mapping = Bulkrax.field_mappings[fields.to_sym] if fields
+        field_mapping_key = Bulkrax.parsers.map { |m| m[:class_name] if m[:class_name] == params[:exporter][:parser_klass] }.compact.first
+        @exporter.field_mapping = Bulkrax.field_mappings[field_mapping_key] if field_mapping_key
       end
 
       def add_exporter_breadcrumbs

app/models/bulkrax/csv_entry.rb

@@ -83,8 +83,8 @@ def build_export_metadata
       self.parsed_metadata['model'] = hyrax_record.has_model.first
       mapping.each do |key, value|
         next if Bulkrax.reserved_properties.include?(key) && !field_supported?(key)
-        next unless hyrax_record.respond_to?(key)
-        data = hyrax_record.send(key)
+        next unless hyrax_record.respond_to?(value['from']&.first.to_s)
+        data = hyrax_record.send(value['from'].first)
         if data.is_a?(ActiveTriples::Relation)
           self.parsed_metadata[key] = data.map { |d| prepare_export_data(d) }.join('; ').to_s unless value[:excluded]
         else

app/models/bulkrax/exporter.rb

@@ -46,6 +46,19 @@ def export_source_worktype
       self.export_source if self.export_from == 'worktype'
     end
 
+    def date_filter
+      self.start_date.present? || self.finish_date.present?
+    end
+
+    def work_status_list
+      [
+          ["Any", ""],
+          [I18n.t('hyrax.visibility.open.text'), Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC],
+          [I18n.t('hyrax.visibility.restricted.text'), Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE],
+          [I18n.t('hyrax.visibility.authenticated.text', institution: I18n.t('hyrax.institution_name')), Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED]
+      ]
+    end
+
     # If field_mapping is empty, setup a default based on the export_properties
     def mapping
       @mapping ||= self.field_mapping ||

app/parsers/bulkrax/csv_parser.rb

@@ -103,35 +103,52 @@ def create_parent_child_relationships
       super
     end
 
+    def extra_filters
+      output = ""
+      if importerexporter.start_date.present?
+        start_dt = importerexporter.start_date.to_datetime.strftime('%FT%TZ')
+        finish_dt = importerexporter.finish_date.present? ? importerexporter.finish_date.to_datetime.end_of_day.strftime('%FT%TZ') : "NOW"
+        output += " AND system_modified_dtsi:[#{start_dt} TO #{finish_dt}]"
+      end
+      output += importerexporter.work_visibility.present? ? " AND visibility_ssi:#{importerexporter.work_visibility}" : ""
+      output
+    end
+
+    def current_entry_ids
+      case importerexporter.export_from
+      when 'collection'
+        ActiveFedora::SolrService.query("member_of_collection_ids_ssim:#{importerexporter.export_source}"+extra_filters, rows: 2_000_000_000).map(&:id)
+      when 'worktype'
+        ActiveFedora::SolrService.query("has_model_ssim:#{importerexporter.export_source}"+extra_filters, rows: 2_000_000_000).map(&:id)
+      when 'importer'
+        importer = Bulkrax::Importer.find(importerexporter.export_source)
+        importer_ids = importer.entries.where(type: importer.parser.entry_class.to_s, last_error: [nil, {}, '']).map(&:identifier)
+        ActiveFedora::SolrService.query("doc_id_tesim:(#{importer_ids.join(" OR ")})"+extra_filters, rows:2_000_000_000).map(&:id)
+      end
+    end
+
+=begin
     def create_from_importer
-      importer = Bulkrax::Importer.find(importerexporter.export_source)
-      non_errored_entries = importer.entries.where(type: importer.parser.entry_class.to_s, last_error: [nil, {}, ''])
-      non_errored_entries.each_with_index do |entry, index|
+      current_entry_ids.each_with_index do |entry, index|
         break if limit_reached?(limit, index)
         query = "#{ActiveFedora.index_field_mapper.solr_name(Bulkrax.system_identifier_field)}:\"#{entry.identifier}\""
         work_id = ActiveFedora::SolrService.query(query, fl: 'id', rows: 1).first['id']
         new_entry = find_or_create_entry(entry_class, work_id, 'Bulkrax::Exporter')
         Bulkrax::ExportWorkJob.perform_now(new_entry.id, current_run.id)
       end
     end
+=end
 
-    def create_from_collection
-      work_ids = ActiveFedora::SolrService.query("member_of_collection_ids_ssim:#{importerexporter.export_source}", rows: 2_000_000_000).map(&:id)
-      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)
-      end
-    end
-
-    def create_from_worktype
-      work_ids = ActiveFedora::SolrService.query("has_model_ssim:#{importerexporter.export_source}", rows: 2_000_000_000).map(&:id)
-      work_ids.each_with_index do |wid, index|
+    def create_new_entries
+      current_entry_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)
       end
     end
+    alias_method :create_from_collection, :create_new_entries
+    alias_method :create_from_importer, :create_new_entries
+    alias_method :create_from_worktype, :create_new_entries
 
     def entry_class
       CsvEntry
@@ -181,7 +198,7 @@ def retrieve_cloud_files(files)
 
     def write_files
       CSV.open(setup_export_file, "w", headers: export_headers, write_headers: true) do |csv|
-        importerexporter.entries.each do |e|
+        importerexporter.entries.where(identifier: current_entry_ids)[0..limit||total].each do |e|
           csv << e.parsed_metadata
         end
       end

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

@@ -60,6 +60,23 @@
     hint: 'leave blank or 0 for all records',
     label: t('bulkrax.exporter.labels.limit') %>
 
+  <%= form.input :date_filter,
+                 as: :boolean,
+                 label: t('bulkrax.exporter.labels.filter_by__date') %>
+  <div id="date_filter_picker" class="hidden">
+    <%= form.input :start_date,
+                   as: :date,
+                   label: t('bulkrax.exporter.labels.start_date') %>
+
+    <%= form.input :finish_date,
+                   as: :date,
+                   label: t('bulkrax.exporter.labels.finish_date') %>
+  </div>
+  <%= form.input :work_visibility,
+                 collection: form.object.work_status_list,
+                 label: t('bulkrax.exporter.labels.status') %>
+
+
   <%= 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') %>
@@ -85,5 +102,16 @@
       var selectedVal = $('.exporter_export_from option:selected').val();
       hideUnhide(selectedVal);
     });
+
+    // get the date filter option and show the corresponding date selectors
+    $('.exporter_date_filter').change(function() {
+        if($('.exporter_date_filter').find(".boolean").is(":checked"))
+            $('#date_filter_picker').removeClass('hidden');
+        else
+            $('#date_filter_picker').addClass('hidden');
+    });
+
+    if($('.exporter_date_filter').find(".boolean").is(":checked"))
+        $('#date_filter_picker').removeClass('hidden');
   });
 </script>

db/migrate/20201106014204_add_date_filter_and_status_to_bulkrax_exporters.rb

@@ -0,0 +1,7 @@
+class AddDateFilterAndStatusToBulkraxExporters < ActiveRecord::Migration[5.1]
+  def change
+    add_column :bulkrax_exporters, :start_date, :date
+    add_column :bulkrax_exporters, :finish_date, :date
+    add_column :bulkrax_exporters, :work_visibility, :string
+  end
+end