bulkrax 1.0.0

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module API
+    private
+
+    def api_request?
+      true if request.headers['Content-Type'] == 'application/json'
+    end
+
+    def token_authenticate!
+      return true if request.headers['Authorization'] == "Token: #{ENV['BULKRAX_API_TOKEN']}"
+      return json_response('invalid', :unauthorized, "Please supply the authorization token")
+    end
+
+    def json_response(method, status = :ok, message = nil)
+      case method
+      when 'index'
+        render json: @importers, status: status
+      when 'new', 'edit'
+        render json: message, status: :method_not_allowed
+      when 'destroy', 'invalid'
+        render json: message, status: status
+      else
+        render json: message || @importer, status: status
+      end
+    end
+  end
+end

data/app/factories/bulkrax/object_factory.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  class ObjectFactory
+    extend ActiveModel::Callbacks
+    include Bulkrax::FileFactory
+    define_model_callbacks :save, :create
+    attr_reader :attributes, :object, :source_identifier_value, :klass, :replace_files, :update_files, :work_identifier
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(attributes:, source_identifier_value:, work_identifier:, replace_files: false, user: nil, klass: 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
+      @source_identifier_value = source_identifier_value
+      @klass = klass || Bulkrax.default_work_type.constantize
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def run
+      arg_hash = { id: attributes[:id], name: 'UPDATE', klass: klass }
+      @object = find
+      if object
+        object.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX
+        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
+    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?
+    end
+
+    def update
+      raise "Object doesn't exist" unless object
+      destroy_existing_files if @replace_files && klass != Collection
+      attrs = attribute_update
+      run_callbacks :save do
+        klass == Collection ? update_collection(attrs) : work_actor.update(environment(attrs))
+      end
+      log_updated(object)
+    end
+
+    def find
+      return find_by_id if attributes[:id]
+      return search_by_identifier if attributes[work_identifier].present?
+    end
+
+    def find_by_id
+      klass.find(attributes[:id]) if klass.exists?(attributes[:id])
+    end
+
+    def find_or_create
+      o = find
+      return o if o
+      run(&:save!)
+    end
+
+    def search_by_identifier
+      query = { work_identifier =>
+                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) }
+      return match if match
+    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 = create_attributes
+      @object = klass.new
+      object.reindex_extent = Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX
+      run_callbacks :save do
+        run_callbacks :create do
+          klass == Collection ? create_collection(attrs) : work_actor.create(environment(attrs))
+        end
+      end
+      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})")
+    end
+
+    def log_updated(obj)
+      msg = "Updated #{klass.model_name.human} #{obj.id}"
+      Rails.logger.info("#{msg} (#{Array(attributes[work_identifier]).first})")
+    end
+
+    def log_deleted_fs(obj)
+      msg = "Deleted All Files from #{obj.id}"
+      Rails.logger.info("#{msg} (#{Array(attributes[work_identifier]).first})")
+    end
+
+    private
+
+    # @param [Hash] attrs the attributes to put in the environment
+    # @return [Hyrax::Actors::Environment]
+    def environment(attrs)
+      Hyrax::Actors::Environment.new(object, Ability.new(@user), attrs)
+    end
+
+    def work_actor
+      Hyrax::CurationConcern.actor
+    end
+
+    def create_collection(attrs)
+      attrs = collection_type(attrs)
+      object.members = members
+      object.member_of_collections = member_of_collections
+      object.attributes = attrs
+      object.apply_depositor_metadata(@user)
+      object.save!
+    end
+
+    def update_collection(attrs)
+      object.members = members
+      object.member_of_collections = member_of_collections
+      object.attributes = attrs
+      object.save!
+    end
+
+    # Collections don't respond to member_of_collections_attributes or member_of_collection_ids=
+    #   or member_ids=
+    # Add them directly with members / member_of_collections
+    # collection should be in the form  { id: collection_id }
+    # and collections [{ id: collection_id }]
+    # member_ids comes from
+    # @todo - consider performance implications although we wouldn't expect a Collection to be a member of many Collections
+    def members
+      ms = object.members.to_a
+      [:children].each do |atat|
+        next if attributes[atat].blank?
+        ms.concat(
+          Array.wrap(
+            find_collection(attributes[atat])
+          )
+        )
+      end
+      ms.flatten.compact.uniq
+    end
+
+    def member_of_collections
+      ms = object.member_of_collection_ids.to_a.map { |id| find_collection(id) }
+      [:collection, :collections].each do |atat|
+        next if attributes[atat].blank?
+        ms.concat(
+          Array.wrap(
+            find_collection(attributes[atat])
+          )
+        )
+      end
+      ms.flatten.compact.uniq
+    end
+
+    def find_collection(id)
+      case id
+      when Hash
+        Collection.find(id[:id])
+      when String
+        Collection.find(id)
+      when Array
+        id.map { |i| find_collection(i) }
+      else
+        []
+      end
+    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.gid
+      attrs
+    end
+
+    # Strip out the :collection key, and add the member_of_collection_ids,
+    # which is used by Hyrax::Actors::AddAsMemberOfCollectionsActor
+    def create_attributes
+      return transform_attributes if klass == Collection
+      if attributes[:collection].present?
+        transform_attributes.except(:collection).merge(member_of_collections_attributes: { 0 => { id: collection.id } })
+      elsif attributes[:collections].present?
+        collection_ids = attributes[:collections].each.with_index.each_with_object({}) do |(element, index), ids|
+          ids[index] = { id: element }
+        end
+        transform_attributes.except(:collections).merge(member_of_collections_attributes: collection_ids)
+      else
+        transform_attributes
+      end
+    end
+
+    # Strip out the :collection key, and add the member_of_collection_ids,
+    # which is used by Hyrax::Actors::AddAsMemberOfCollectionsActor
+    def attribute_update
+      return transform_attributes.except(:id) if klass == Collection
+      if attributes[:collection].present?
+        transform_attributes.except(:id).except(:collection).merge(member_of_collections_attributes: { 0 => { id: collection.id } })
+      elsif attributes[:collections].present?
+        collection_ids = attributes[:collections].each.with_index.each_with_object({}) do |(element, index), ids|
+          ids[index] = element
+        end
+        transform_attributes.except(:id).except(:collections).merge(member_of_collections_attributes: collection_ids)
+      else
+        transform_attributes.except(:id)
+      end
+    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
+      attributes.slice(*permitted_attributes)
+                .merge(file_attributes(update_files))
+    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) + %i[id edit_users edit_groups read_groups visibility work_members_attributes admin_set_id]
+    end
+  end
+end

data/app/helpers/bulkrax/application_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require 'coderay'
+
+module Bulkrax
+  module ApplicationHelper
+    include ::Hyrax::HyraxHelperBehavior
+
+    def coderay(value, opts)
+      CodeRay
+        .scan(value, :ruby)
+        .html(opts)
+        .html_safe # rubocop:disable Rails/OutputSafety
+    end
+  end
+end

data/app/helpers/bulkrax/exporters_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module ExportersHelper
+  end
+end

data/app/helpers/bulkrax/importers_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module ImportersHelper
+    # borrowd from batch-importer https://github.com/samvera-labs/hyrax-batch_ingest/blob/main/app/controllers/hyrax/batch_ingest/batches_controller.rb
+    def available_admin_sets
+      # Restrict available_admin_sets to only those current user can desposit to.
+      @available_admin_sets ||= Hyrax::Collections::PermissionsService.source_ids_for_deposit(ability: current_ability, source_type: 'admin_set').map do |admin_set_id|
+        [AdminSet.find(admin_set_id).title.first, admin_set_id]
+      end
+    end
+  end
+end

data/app/helpers/bulkrax/validation_helper.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module ValidationHelper
+    def valid_create_params?
+      check_admin_set
+      check_user
+      return true if valid_importer? &&
+                     valid_commit? &&
+                     valid_name? &&
+                     valid_parser_klass? &&
+                     valid_parser_fields?
+    end
+
+    def valid_update_params?
+      check_admin_set
+      check_user
+      return valid_commit?
+    end
+
+    def check_admin_set
+      if params[:importer][:admin_set_id].blank?
+        params[:importer][:admin_set_id] = AdminSet::DEFAULT_ID
+      else
+        AdminSet.find(params[:importer][:admin_set_id])
+      end
+      return true
+    rescue ActiveFedora::ObjectNotFoundError
+      logger.warn("AdminSet #{params[:importer][:admin_set_id]} not found. Using default admin set.")
+      params[:importer][:admin_set_id] = AdminSet::DEFAULT_ID
+      return true
+    end
+
+    def check_user
+      if params[:importer][:user_id].blank?
+        params[:importer][:user_id] = User.batch_user.id
+      else
+        User.find(params[:importer][:user_id])
+      end
+      return true
+    rescue ActiveRecord::RecordNotFound
+      logger.warn("User #{params[:importer][:user_id]} not found. Using default batch_user.")
+      params[:importer][:user_id] = User.batch_user.id
+      return true
+    end
+
+    def return_value(method, status, message)
+      @return_value ||= [method, status, message]
+    end
+
+    def return_json_response
+      json_response(@return_value[0], @return_value[1], @return_value[2])
+    end
+
+    def valid_importer?
+      return true if params[:importer].present?
+      return_value('invalid',
+                   :unprocessable_entity,
+                   "Missing required parameters")
+      return false
+    end
+
+    def valid_commit?
+      return true if params[:commit].present? && valid_commit_message?(params[:commit])
+      return_value('invalid',
+                   :unprocessable_entity,
+                   "[:commit] is required")
+      return false
+    end
+
+    def valid_name?
+      return true if params[:importer][:name].present?
+      return_value('invalid',
+                   :unprocessable_entity,
+                   "[:importer][:name] is required")
+      return false
+    end
+
+    def valid_parser_klass?
+      return true if params[:importer][:parser_klass].present?
+      return_value('invalid',
+                   :unprocessable_entity,
+                   "[:importer][:parser_klass] is required")
+      return false
+    end
+
+    def valid_parser_fields?
+      if params[:importer][:parser_fields].present?
+        case params[:importer][:parser_klass]
+        when 'Bulkrax::OaiParser'
+          return valid_oai?
+        when 'Bulkrax::CsvParser'
+          return valid_csv?
+        when 'Bulkrax::BagitParser'
+          return valid_bagit?
+        else
+          return_value('invalid',
+                       :unprocessable_entity,
+                       "#{params[:importer][:parser_klass]} not recognised")
+          return false
+        end
+      else
+        return_value('invalid',
+                     :unprocessable_entity,
+                     "params[:importer][:parser_fields] is required")
+        return false
+      end
+    end
+
+    def valid_bagit?
+      return true if params[:importer][:parser_fields][:metadata_format].present? &&
+                     params[:importer][:parser_fields][:metadata_file_name].present? &&
+                     params[:importer][:parser_fields][:import_file_path].present?
+      return_value('invalid',
+                   :unprocessable_entity,
+                   "[:importer][:parser_fields] [:metadata_format], [:metadata_file_name] and [:import_file_path] are required")
+      return false
+    end
+
+    def valid_csv?
+      return true if params[:importer][:parser_fields][:import_file_path].present?
+      return_value('invalid',
+                   :unprocessable_entity,
+                   "[:importer][:parser_fields] [:import_file_path] is required")
+      return false
+    end
+
+    def valid_oai?
+      return true if params[:base_url].present? &&
+                     params[:importer][:parser_fields][:set].present? &&
+                     params[:importer][:parser_fields][:collection_name].present?
+      return_value('invalid',
+                   :unprocessable_entity,
+                   "[:base_url], [:importer][:parser_fields][:set] and [:importer][:parser_fields][:collection_name] are required")
+      return false
+    end
+
+    def valid_commit_message?(commit)
+      # @todo - manual list because this line causes the importer script to fail - why?
+      # Bulkrax.api_definition['bulkrax']['importer']['commit']['valid_values'].include?(commit)
+      [
+        "Create",
+        "Create and Import",
+        "Update Importer",
+        "Update and Re-Import (update metadata and replace files)",
+        "Update and Harvest Updated Items",
+        "Update and Re-Harvest All Items",
+        "Update and Re-Import (update metadata only)",
+        "Update and Import (importer has not yet been run)"
+      ].include?(commit)
+    end
+  end
+end