bulkrax 6.0.1 → 8.0.0

data/app/controllers/concerns/bulkrax/datatables_behavior.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  # rubocop:disable Metrics/ModuleLength
+  module DatatablesBehavior
+    extend ActiveSupport::Concern
+
+    def table_per_page
+      per_page = params[:length].to_i
+      per_page < 1 ? 30 : per_page
+    end
+
+    def order_value(column)
+      params['columns']&.[](column)&.[]('data')
+    end
+
+    def table_order
+      "#{order_value(params&.[]('order')&.[]('0')&.[]('column'))} #{params&.[]('order')&.[]('0')&.[]('dir')}" if params&.[]('order')&.[]('0')&.[]('column').present?
+    end
+
+    # convert offset to page number
+    def table_page
+      params[:start].blank? ? 1 : (params[:start].to_i / params[:length].to_i) + 1
+    end
+
+    def entry_table_search
+      return @entry_table_search if @entry_table_search
+      return @entry_table_search = false if params['search']&.[]('value').blank?
+
+      table_search_value = params['search']&.[]('value')&.downcase
+
+      ['identifier', 'id', 'status_message', 'type', 'updated_at'].map do |col|
+        column = Bulkrax::Entry.arel_table[col]
+        column = Arel::Nodes::NamedFunction.new('CAST', [column.as('text')])
+        column = Arel::Nodes::NamedFunction.new('LOWER', [column])
+        @entry_table_search = if @entry_table_search
+                                @entry_table_search.or(column.matches("%#{table_search_value}%"))
+                              else
+                                column.matches("%#{table_search_value}%")
+                              end
+      end
+
+      @entry_table_search
+    end
+
+    def importer_table_search
+      return @importer_table_search if @importer_table_search
+      return @importer_table_search = false if params['search']&.[]('value').blank?
+
+      table_search_value = params['search']&.[]('value')&.downcase
+
+      ['name', 'id', 'status_message', 'last_error_at', 'last_succeeded_at', 'updated_at'].map do |col|
+        column = Bulkrax::Importer.arel_table[col]
+        column = Arel::Nodes::NamedFunction.new('CAST', [column.as('text')])
+        column = Arel::Nodes::NamedFunction.new('LOWER', [column])
+        @importer_table_search = if @importer_table_search
+                                   @importer_table_search.or(column.matches("%#{table_search_value}%"))
+                                 else
+                                   column.matches("%#{table_search_value}%")
+                                 end
+      end
+
+      @importer_table_search
+    end
+
+    def exporter_table_search
+      return @exporter_table_search if @exporter_table_search
+      return @exporter_table_search = false if params['search']&.[]('value').blank?
+
+      table_search_value = params['search']&.[]('value')&.downcase
+
+      ['name', 'status_message', 'created_at'].map do |col|
+        column = Bulkrax::Exporter.arel_table[col]
+        column = Arel::Nodes::NamedFunction.new('CAST', [column.as('text')])
+        column = Arel::Nodes::NamedFunction.new('LOWER', [column])
+        @exporter_table_search = if @exporter_table_search
+                                   @exporter_table_search.or(column.matches("%#{table_search_value}%"))
+                                 else
+                                   column.matches("%#{table_search_value}%")
+                                 end
+      end
+
+      @exporter_table_search
+    end
+
+    def format_importers(importers)
+      result = importers.map do |i|
+        {
+          name: view_context.link_to(i.name, view_context.importer_path(i)),
+          status_message: status_message_for(i),
+          last_imported_at: i.last_imported_at&.strftime("%b %d, %Y"),
+          next_import_at: i.next_import_at&.strftime("%b %d, %Y"),
+          enqueued_records: i.last_run&.enqueued_records,
+          processed_records: i.last_run&.processed_records || 0,
+          failed_records: i.last_run&.failed_records || 0,
+          deleted_records: i.last_run&.deleted_records,
+          total_collection_entries: i.last_run&.total_collection_entries,
+          total_work_entries: i.last_run&.total_work_entries,
+          total_file_set_entries: i.last_run&.total_file_set_entries,
+          actions: importer_util_links(i)
+        }
+      end
+      {
+        data: result,
+        recordsTotal: Bulkrax::Importer.count,
+        recordsFiltered: Bulkrax::Importer.count
+      }
+    end
+
+    def format_exporters(exporters)
+      result = exporters.map do |e|
+        {
+          name: view_context.link_to(e.name, view_context.exporter_path(e)),
+          status_message: status_message_for(e),
+          created_at: e.created_at,
+          download: download_zip(e),
+          actions: exporter_util_links(e)
+        }
+      end
+      {
+        data: result,
+        recordsTotal: Bulkrax::Exporter.count,
+        recordsFiltered: Bulkrax::Exporter.count
+      }
+    end
+
+    def format_entries(entries, item)
+      result = entries.map do |e|
+        {
+          identifier: view_context.link_to(e.identifier, view_context.item_entry_path(item, e)),
+          id: e.id,
+          status_message: status_message_for(e),
+          type: e.type,
+          updated_at: e.updated_at,
+          errors: e.latest_status&.error_class&.present? ? view_context.link_to(e.latest_status.error_class, view_context.item_entry_path(item, e), title: e.latest_status.error_message) : "",
+          actions: entry_util_links(e, item)
+        }
+      end
+      {
+        data: result,
+        recordsTotal: item.entries.size,
+        recordsFiltered: item.entries.size
+      }
+    end
+
+    def entry_util_links(e, item)
+      links = []
+      links << view_context.link_to(view_context.raw('<span class="fa fa-info-circle"></span>'), view_context.item_entry_path(item, e))
+      links << "<a class='fa fa-repeat' data-toggle='modal' data-target='#bulkraxItemModal' data-entry-id='#{e.id}'></a>" if view_context.an_importer?(item)
+      links << view_context.link_to(view_context.raw('<span class="fa fa-trash"></span>'), view_context.item_entry_path(item, e), method: :delete, data: { confirm: 'This will delete the entry and any work associated with it. Are you sure?' })
+      links.join(" ")
+    end
+
+    def status_message_for(e)
+      if e.status_message == "Complete"
+        "<td><span class='fa fa-check' style='color: green;'></span> #{e.status_message}</td>"
+      elsif e.status_message == "Pending"
+        "<td><span class='fa fa-ellipsis-h' style='color: blue;'></span> #{e.status_message}</td>"
+      elsif e.status_message == "Skipped"
+        "<td><span class='fa fa-step-forward' style='color: yellow;'></span> #{e.status_message}</td>"
+      else
+        "<td><span class='fa fa-remove' style='color: #{e.status == 'Deleted' ? 'green' : 'red'};'></span> #{e.status_message}</td>"
+      end
+    end
+
+    def importer_util_links(i)
+      links = []
+      links << view_context.link_to(view_context.raw('<span class="fa fa-info-circle"></span>'), importer_path(i))
+      links << view_context.link_to(view_context.raw('<span class="fa fa-pencil"></span>'), edit_importer_path(i))
+      links << view_context.link_to(view_context.raw('<span class="fa fa-remove"></span>'), i, method: :delete, data: { confirm: 'Are you sure?' })
+      links.join(" ")
+    end
+
+    def exporter_util_links(i)
+      links = []
+      links << view_context.link_to(view_context.raw('<span class="fa fa-info-circle"></span>'), exporter_path(i))
+      links << view_context.link_to(view_context.raw('<span class="fa fa-pencil"></span>'), edit_exporter_path(i), data: { turbolinks: false })
+      links << view_context.link_to(view_context.raw('<span class="fa fa-remove"></span>'), i, method: :delete, data: { confirm: 'Are you sure?' })
+      links.join(" ")
+    end
+
+    def download_zip(e)
+      return unless File.exist?(e.exporter_export_zip_path)
+
+      options_html = e.exporter_export_zip_files.flatten.map do |file_name|
+        "<option value='#{CGI.escapeHTML(file_name)}'>#{CGI.escapeHTML(file_name)}</option>"
+      end.join
+
+      form_html = "<form class='simple_form edit_exporter' id='edit_exporter_#{e.id}' action='#{view_context.exporter_download_path(e)}' accept-charset='UTF-8' method='get'>"
+      form_html += "<input name='utf8' type='hidden' value='✓'>"
+      form_html += "<select class='btn btn-default form-control' style='width: 200px' name='exporter[exporter_export_zip_files]' id='exporter_#{e.id}_exporter_export_zip_files'>"
+      form_html += options_html
+      form_html += "</select>\n" # add newline here to add a space between the dropdown and the download button
+      form_html += "<input type='submit' name='commit' value='Download' class='btn btn-default'>"
+      form_html += "</form>"
+
+      form_html
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end

data/app/factories/bulkrax/object_factory.rb

@@ -1,153 +1,171 @@
 # frozen_string_literal: true
 
 module Bulkrax
-  class ObjectFactory # rubocop:disable Metrics/ClassLength
-    extend ActiveModel::Callbacks
+  # rubocop:disable Metrics/ClassLength
+  class ObjectFactory < ObjectFactoryInterface
     include Bulkrax::FileFactory
-    include DynamicRecordLookup
 
-    # @api private
-    #
-    # These are the attributes that we assume all "work type" classes (e.g. the given :klass) will
-    # have in addition to their specific attributes.
-    #
-    # @return [Array<Symbol>]
-    # @see #permitted_attributes
-    class_attribute :base_permitted_attributes,
-      default: %i[id edit_users edit_groups read_groups visibility work_members_attributes admin_set_id]
+    ##
+    # @!group Class Method Interface
 
-    # @return [Boolean]
-    #
-    # @example
-    #   Bulkrax::ObjectFactory.transformation_removes_blank_hash_values = true
-    #
-    # @see #transform_attributes
-    # @see https://github.com/samvera-labs/bulkrax/pull/708 For discussion concerning this feature
-    # @see https://github.com/samvera-labs/bulkrax/wiki/Interacting-with-Metadata For documentation
-    #      concerning default behavior.
-    class_attribute :transformation_removes_blank_hash_values, default: false
+    ##
+    # @note This does not save either object.  We need to do that in another
+    #       loop.  Why?  Because we might be adding many items to the parent.
+    def self.add_child_to_parent_work(parent:, child:)
+      return true if parent.ordered_members.to_a.include?(child_record)
 
-    define_model_callbacks :save, :create
-    attr_reader :attributes, :object, :source_identifier_value, :klass, :replace_files, :update_files, :work_identifier, :work_identifier_search_field, :related_parents_parsed_mapping, :importer_run_id
+      parent.ordered_members << child
+    end
 
-    # rubocop:disable Metrics/ParameterLists
-    def initialize(attributes:, source_identifier_value:, work_identifier:, work_identifier_search_field:, related_parents_parsed_mapping: nil, replace_files: false, user: nil, klass: nil, importer_run_id: nil, update_files: false)
-      @attributes = ActiveSupport::HashWithIndifferentAccess.new(attributes)
-      @replace_files = replace_files
-      @update_files = update_files
-      @user = user || User.batch_user
-      @work_identifier = work_identifier
-      @work_identifier_search_field = work_identifier_search_field
-      @related_parents_parsed_mapping = related_parents_parsed_mapping
-      @source_identifier_value = source_identifier_value
-      @klass = klass || Bulkrax.default_work_type.constantize
-      @importer_run_id = importer_run_id
+    def self.add_resource_to_collection(collection:, resource:, user:)
+      collection.try(:reindex_extent=, Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX) if
+        defined?(Hyrax::Adapters::NestingIndexAdapter)
+      resource.member_of_collections << collection
+      save!(resource: resource, user: user)
     end
-    # rubocop:enable Metrics/ParameterLists
 
-    # update files is set, replace files is set or this is a create
-    def with_files
-      update_files || replace_files || !object
+    def self.update_index_for_file_sets_of(resource:)
+      resource.file_sets.each(&:update_index) if resource.respond_to?(:file_sets)
     end
 
-    def run
-      arg_hash = { id: attributes[:id], name: 'UPDATE', klass: klass }
-      @object = find
-      if object
-        object.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX if object.respond_to?(:reindex_extent)
-        ActiveSupport::Notifications.instrument('import.importer', arg_hash) { update }
-      else
-        ActiveSupport::Notifications.instrument('import.importer', arg_hash.merge(name: 'CREATE')) { create }
-      end
-      yield(object) if block_given?
-      object
+    ##
+    # @see Bulkrax::ObjectFactoryInterface
+    def self.export_properties
+      # TODO: Consider how this may or may not work for Valkyrie
+      properties = Bulkrax.curation_concerns.map { |work| work.properties.keys }.flatten.uniq.sort
+      properties.reject { |prop| Bulkrax.reserved_properties.include?(prop) }
     end
 
-    def run!
-      self.run
-      # Create the error exception if the object is not validly saved for some reason
-      raise ActiveFedora::RecordInvalid, object if !object.persisted? || object.changed?
-      object
+    def self.field_multi_value?(field:, model:)
+      return false unless field_supported?(field: field, model: model)
+      return false unless model.singleton_methods.include?(:properties)
+
+      model&.properties&.[](field)&.[]("multiple")
     end
 
-    def update
-      raise "Object doesn't exist" unless object
-      destroy_existing_files if @replace_files && ![Collection, FileSet].include?(klass)
-      attrs = transform_attributes(update: true)
-      run_callbacks :save do
-        if klass == Collection
-          update_collection(attrs)
-        elsif klass == FileSet
-          update_file_set(attrs)
-        else
-          update_work(attrs)
-        end
-      end
-      object.apply_depositor_metadata(@user) && object.save! if object.depositor.nil?
-      log_updated(object)
+    def self.field_supported?(field:, model:)
+      model.method_defined?(field) && model.properties[field].present?
+    end
+
+    def self.file_sets_for(resource:)
+      return [] if resource.blank?
+      return [resource] if resource.is_a?(Bulkrax.file_model_class)
+
+      resource.file_sets
     end
 
-    def find
-      found = find_by_id if attributes[:id].present?
-      return found if found.present?
-      return search_by_identifier if attributes[work_identifier].present?
+    ##
+    #
+    # @see Bulkrax::ObjectFactoryInterface
+    def self.find(id)
+      ActiveFedora::Base.find(id)
+    rescue ActiveFedora::ObjectNotFoundError => e
+      raise ObjectFactoryInterface::ObjectNotFoundError, e.message
     end
 
-    def find_by_id
-      klass.find(attributes[:id]) if klass.exists?(attributes[:id])
+    def self.find_or_create_default_admin_set
+      # NOTE: Hyrax 5+ removed this method
+      AdminSet.find_or_create_default_admin_set_id
     end
 
-    def find_or_create
-      o = find
-      return o if o
-      run(&:save!)
+    def self.publish(**)
+      return true
     end
 
-    def search_by_identifier
-      query = { work_identifier_search_field =>
-                source_identifier_value }
-      # Query can return partial matches (something6 matches both something6 and something68)
-      # so we need to weed out any that are not the correct full match. But other items might be
-      # in the multivalued field, so we have to go through them one at a time.
-      match = klass.where(query).detect { |m| m.send(work_identifier).include?(source_identifier_value) }
+    ##
+    # @param value [String]
+    # @param klass [Class, #where]
+    # @param field [String, Symbol] A convenience parameter where we pass the
+    #        same value to search_field and name_field.
+    # @param search_field [String, Symbol] the Solr field name
+    #        (e.g. "title_tesim")
+    # @param name_field [String] the ActiveFedora::Base property name
+    #        (e.g. "title")
+    # @param verify_property [TrueClass] when true, verify that the given :klass
+    #
+    # @return [NilClass] when no object is found.
+    # @return [ActiveFedora::Base] when a match is found, an instance of given
+    #         :klass
+    # rubocop:disable Metrics/ParameterLists
+    #
+    # @note HEY WE'RE USING THIS FOR A WINGS CUSTOM QUERY.  BE CAREFUL WITH
+    #       REMOVING IT.
+    #
+    # @see # {Wings::CustomQueries::FindBySourceIdentifier#find_by_model_and_property_value}
+    def self.search_by_property(value:, klass:, field: nil, search_field: nil, name_field: nil, verify_property: false)
+      return nil unless klass.respond_to?(:where)
+      # We're not going to try to match nil nor "".
+      return if value.blank?
+      return if verify_property && !klass.properties.keys.include?(search_field)
+
+      search_field ||= field
+      name_field ||= field
+      raise "You must provide either (search_field AND name_field) OR field parameters" if search_field.nil? || name_field.nil?
+      # NOTE: Query can return partial matches (something6 matches both
+      # something6 and something68) so we need to weed out any that are not the
+      # correct full match. But other items might be in the multivalued field,
+      # so we have to go through them one at a time.
+      #
+      # A ssi field is string, so we're looking at exact matches.
+      # A tesi field is text, so partial matches work.
+      #
+      # We need to wrap the result in an Array, else we might have a scalar that
+      # will result again in partial matches.
+      match = klass.where(search_field => value).detect do |m|
+        # Don't use Array.wrap as we likely have an ActiveTriples::Relation
+        # which defiantly claims to be an Array yet does not behave consistently
+        # with an Array.  Hopefully the name_field is not a Date or Time object,
+        # Because that too will be a mess.
+        Array(m.send(name_field)).include?(value)
+      end
       return match if match
     end
+    # rubocop:enable Metrics/ParameterLists
+
+    def self.query(q, **kwargs)
+      ActiveFedora::SolrService.query(q, **kwargs)
+    end
 
-    # An ActiveFedora bug when there are many habtm <-> has_many associations means they won't all get saved.
-    # https://github.com/projecthydra/active_fedora/issues/874
-    # 2+ years later, still open!
-    def create
-      attrs = transform_attributes
-      @object = klass.new
-      object.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX if defined?(Hyrax::Adapters::NestingIndexAdapter) && object.respond_to?(:reindex_extent)
-      run_callbacks :save do
-        run_callbacks :create do
-          if klass == Collection
-            create_collection(attrs)
-          elsif klass == FileSet
-            create_file_set(attrs)
-          else
-            create_work(attrs)
-          end
-        end
+    def self.clean!
+      super do
+        ActiveFedora::Cleaner.clean!
       end
-      object.apply_depositor_metadata(@user) && object.save! if object.depositor.nil?
-      log_created(object)
     end
 
-    def log_created(obj)
-      msg = "Created #{klass.model_name.human} #{obj.id}"
-      Rails.logger.info("#{msg} (#{Array(attributes[work_identifier]).first})")
+    def self.solr_name(field_name)
+      if defined?(Hyrax)
+        Hyrax.index_field_mapper.solr_name(field_name)
+      else
+        ActiveFedora.index_field_mapper.solr_name(field_name)
+      end
+    end
+
+    def self.ordered_file_sets_for(object)
+      object&.ordered_members.to_a.select(&:file_set?)
+    end
+
+    def self.save!(resource:, **)
+      resource.save!
     end
 
-    def log_updated(obj)
-      msg = "Updated #{klass.model_name.human} #{obj.id}"
-      Rails.logger.info("#{msg} (#{Array(attributes[work_identifier]).first})")
+    def self.update_index(resources: [])
+      Array(resources).each(&:update_index)
     end
+    # @!endgroup Class Method Interface
+    ##
 
-    def log_deleted_fs(obj)
-      msg = "Deleted All Files from #{obj.id}"
-      Rails.logger.info("#{msg} (#{Array(attributes[work_identifier]).first})")
+    def find_by_id
+      return false if attributes[:id].blank?
+      # Rails / Ruby upgrade, we moved from :exists? to :exist?  However we want to continue (for a
+      # bit) to support older versions.
+      method_name = klass.respond_to?(:exist?) ? :exist? : :exists?
+      klass.find(attributes[:id]) if klass.send(method_name, attributes[:id])
+    rescue Valkyrie::Persistence::ObjectNotFoundError
+      false
+    end
+
+    def delete(_user)
+      find&.delete
     end
 
     private
@@ -238,52 +256,6 @@ module Bulkrax
       update == true ? actor.update_content(tmp_file) : actor.create_content(tmp_file, from_url: true)
       tmp_file.close
     end
-
-    def clean_attrs(attrs)
-      # avoid the "ArgumentError: Identifier must be a string of size > 0 in order to be treeified" error
-      # when setting object.attributes
-      attrs.delete('id') if attrs['id'].blank?
-      attrs
-    end
-
-    def collection_type(attrs)
-      return attrs if attrs['collection_type_gid'].present?
-
-      attrs['collection_type_gid'] = Hyrax::CollectionType.find_or_create_default_collection_type.to_global_id.to_s
-      attrs
-    end
-
-    # Override if we need to map the attributes from the parser in
-    # a way that is compatible with how the factory needs them.
-    def transform_attributes(update: false)
-      @transform_attributes = attributes.slice(*permitted_attributes)
-      @transform_attributes.merge!(file_attributes(update_files)) if with_files
-      @transform_attributes = remove_blank_hash_values(@transform_attributes) if transformation_removes_blank_hash_values?
-      update ? @transform_attributes.except(:id) : @transform_attributes
-    end
-
-    # Regardless of what the Parser gives us, these are the properties we are prepared to accept.
-    def permitted_attributes
-      klass.properties.keys.map(&:to_sym) + base_permitted_attributes
-    end
-
-    # Return a copy of the given attributes, such that all values that are empty or an array of all
-    # empty values are fully emptied.  (See implementation details)
-    #
-    # @param attributes [Hash]
-    # @return [Hash]
-    #
-    # @see https://github.com/emory-libraries/dlp-curate/issues/1973
-    def remove_blank_hash_values(attributes)
-      dupe = attributes.dup
-      dupe.each do |key, values|
-        if values.is_a?(Array) && values.all? { |value| value.is_a?(String) && value.empty? }
-          dupe[key] = []
-        elsif values.is_a?(String) && values.empty?
-          dupe[key] = nil
-        end
-      end
-      dupe
-    end
   end
+  # rubocop:enable Metrics/ClassLength
 end