hyrax 0.0.0 → 1.0.0.rc1

data/lib/hyrax/arkivo/config.rb

@@ -0,0 +1,11 @@
+module Hyrax
+  module Arkivo
+    def self.config
+      @config ||= YAML.safe_load(ERB.new(IO.read(Rails.root.join('config', 'arkivo.yml'))).result).with_indifferent_access[Rails.env]
+    end
+
+    def self.new_subscription_url
+      '/api/subscription'
+    end
+  end
+end

data/lib/hyrax/arkivo/create_subscription_job.rb

@@ -0,0 +1,61 @@
+module Hyrax
+  module Arkivo
+    class SubscriptionError < RuntimeError
+    end
+
+    class CreateSubscriptionJob < ActiveJob::Base
+      attr_reader :user
+
+      def perform(user_key)
+        @user = ::User.find_by_user_key(user_key)
+        validate_user!
+
+        # post json to API
+        response = post_to_api
+        # parse results
+        subscription_path = response.headers['Location']
+        # create subscription
+        user.arkivo_subscription = subscription_path
+        user.save
+      end
+
+      private
+
+        def logger
+          ActiveFedora::Base.logger
+        end
+
+        def validate_user!
+          log_and_raise('User not found') if user.blank?
+          log_and_raise('User does not have an Arkivo token') if user.arkivo_token.blank?
+          log_and_raise('User has not yet connected with Zotero') if user.zotero_userid.blank?
+          log_and_raise('User already has a subscription') if user.arkivo_subscription.present?
+        end
+
+        def log_and_raise(message)
+          logger.error "*** Arkivo error: #{message}: #{user}"
+          raise SubscriptionError, message
+        end
+
+        def post_to_api
+          Faraday.new(url: Hyrax::Arkivo.config[:url]).post do |request|
+            request.url Hyrax::Arkivo.new_subscription_url
+            request.headers['Content-Type'] = 'application/json'
+            request.body = new_subscription_json
+          end
+        end
+
+        def new_subscription_json
+          {
+            url: Hyrax::Zotero.publications_url(@user.zotero_userid),
+            plugins: [
+              {
+                name: "hyrax",
+                options: { token: @user.arkivo_token }
+              }
+            ]
+          }.to_json
+        end
+    end
+  end
+end

data/lib/hyrax/arkivo/metadata_munger.rb

@@ -0,0 +1,54 @@
+module Hyrax
+  module Arkivo
+    CREATOR_TYPES = ['author', 'interviewer', 'director', 'scriptwriter',
+                     'inventor', 'composer', 'cartographer', 'programmer', 'artist',
+                     'bookAuthor'].freeze
+
+    CONTRIBUTOR_TYPES = ['contributor', 'editor', 'translator', 'seriesEditor',
+                         'interviewee', 'producer', 'castMember', 'sponsor', 'counsel',
+                         'attorneyAgent', 'recipient', 'performer', 'wordsBy', 'commenter',
+                         'presenter', 'guest', 'podcaster', 'reviewedAuthor', 'cosponsor'].freeze
+
+    class MetadataMunger
+      def initialize(metadata)
+        @metadata = metadata
+        @munged = {}
+      end
+
+      # @return [Hash]
+      def call
+        normalize_keys_and_values
+        rename_key(from: 'url', to: 'related_url')
+        rename_key(from: 'tags', to: 'keyword')
+        extract_creator_and_contributor_from_creators
+        @munged
+      end
+
+      private
+
+        def normalize_keys_and_values
+          # First, normalize camelCase symbols to underscore strings
+          @metadata.each do |key, value|
+            @munged[key.to_s.underscore] = Array.wrap(value)
+          end
+        end
+
+        def rename_key(from:, to:)
+          @munged[to] = @munged.delete(from) if @munged.key?(from)
+        end
+
+        def extract_creator_and_contributor_from_creators
+          creator_names = []
+          contributor_names = []
+          @munged['creators'].each do |entry|
+            entry['name'] ||= "#{entry.delete('lastName')}, #{entry.delete('firstName')}".strip
+            creator_names << entry['name'] if Hyrax::Arkivo::CREATOR_TYPES.include?(entry['creatorType'])
+            contributor_names << entry['name'] if Hyrax::Arkivo::CONTRIBUTOR_TYPES.include?(entry['creatorType'])
+          end
+          @munged['creator'] = creator_names if creator_names.present?
+          @munged['contributor'] = contributor_names if contributor_names.present?
+          @munged.delete('creators')
+        end
+    end
+  end
+end

data/lib/hyrax/arkivo/schema_validator.rb

@@ -0,0 +1,55 @@
+require 'json-schema'
+
+module Hyrax
+  module Arkivo
+    ITEM_SCHEMA = {
+      type: 'object',
+      properties: {
+        token: { type: 'string', required: true },
+        metadata: {
+          type: 'object',
+          required: true,
+          properties: {
+            title: { type: 'string', required: true },
+            rights: { type: 'string', required: true },
+            resourceType: { type: 'string' },
+            description: { type: 'string' },
+            publisher: { type: 'string' },
+            dateCreated: { type: 'string' },
+            basedNear: { type: 'string' },
+            identifier: { type: 'string' },
+            url: { type: 'string' },
+            language: { type: 'string' }
+          }
+        },
+        file: {
+          type: 'object',
+          required: true,
+          properties: {
+            base64: { type: 'string', required: true },
+            md5: { type: 'string', required: true },
+            filename: { type: 'string', required: true },
+            contentType: { type: 'string', required: true }
+          }
+        }
+      }
+    }.freeze
+
+    class InvalidItem < RuntimeError
+    end
+
+    class SchemaValidator
+      attr_reader :item
+
+      def initialize(item)
+        @item = item
+      end
+
+      def call
+        JSON::Validator.validate!(Hyrax::Arkivo::ITEM_SCHEMA, item, version: :draft3)
+      rescue JSON::Schema::ValidationError => exception
+        raise Hyrax::Arkivo::InvalidItem, exception.message
+      end
+    end
+  end
+end

data/lib/hyrax/callbacks.rb

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+require 'hyrax/callbacks/registry'
+
+module Hyrax
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      # Define class instance variable as endpoint to the
+      # Callback::Registry api.
+      @callback = Registry.new
+    end
+
+    module ClassMethods
+      # Reader for class instance variable containing callback definitions.
+      def callback
+        @callback
+      end
+    end
+
+    # Accessor to Callback::Registry api for instances.
+    def callback
+      self.class.callback
+    end
+  end
+end

data/lib/hyrax/callbacks/registry.rb

@@ -0,0 +1,48 @@
+module Hyrax
+  module Callbacks
+    class Registry
+      attr_reader :callbacks
+
+      def initialize
+        @callbacks = {}
+      end
+
+      # Enables a callback by specifying one or more hooks.
+      def enable(hook, *more_hooks)
+        ([hook] + more_hooks).each { |h| @callbacks[h] ||= nil }
+      end
+
+      # Returns all enabled callback hooks.
+      def enabled
+        @callbacks.keys
+      end
+
+      # Returns true if the callback hook has been enabled.
+      def enabled?(hook)
+        @callbacks.key? hook
+      end
+
+      # Defines a callback for a given hook.
+      def set(hook, &block)
+        raise NoBlockGiven, "a block is required when setting a callback" unless block_given?
+        @callbacks[hook] = proc(&block)
+      end
+
+      # Returns true if a callback has been defined for a given hook.
+      def set?(hook)
+        enabled?(hook) && @callbacks[hook].respond_to?(:call)
+      end
+
+      # Runs the callback defined for a given hook, with the arguments provided
+      def run(hook, *args)
+        raise NotEnabled unless enabled?(hook)
+        return nil unless set?(hook)
+        @callbacks[hook].call(*args)
+      end
+    end
+
+    # Custom exceptions
+    class NotEnabled < StandardError; end
+    class NoBlockGiven < StandardError; end
+  end
+end

data/lib/hyrax/collections.rb

@@ -0,0 +1,7 @@
+module Hyrax
+  module Collections
+    extend ActiveSupport::Autoload
+    autoload :SearchService
+    autoload :AcceptsBatches
+  end
+end

data/lib/hyrax/collections/accepts_batches.rb

@@ -0,0 +1,53 @@
+module Hyrax
+  module Collections
+    module AcceptsBatches
+      def batch
+        @batch ||= batch_ids_from_params
+      end
+
+      def batch=(val)
+        @batch = val
+      end
+
+      # Callback to be used in before_filter
+      def check_for_empty_batch?
+        batch.empty?
+      end
+
+      protected
+
+        def batch_ids_from_params
+          if params['batch_document_ids'].blank?
+            []
+          elsif params['batch_document_ids'] == 'all'
+            SearchService.new(session, current_user.user_key).last_search_documents.map(&:id)
+          else
+            params['batch_document_ids']
+          end
+        end
+
+        def filter_docs_with_read_access!
+          filter_docs_with_access!(:read)
+        end
+
+        def filter_docs_with_edit_access!
+          filter_docs_with_access!(:edit)
+        end
+
+        def filter_docs_with_access!(access_type = :edit)
+          no_permissions = []
+          if batch.empty?
+            flash[:notice] = 'Select something first'
+          else
+            batch.dup.each do |doc_id|
+              unless can?(access_type, doc_id)
+                batch.delete(doc_id)
+                no_permissions << doc_id
+              end
+            end
+            flash[:notice] = "You do not have permission to edit the documents: #{no_permissions.join(', ')}" unless no_permissions.empty?
+          end
+        end
+    end
+  end
+end

data/lib/hyrax/collections/search_service.rb

@@ -0,0 +1,57 @@
+module Hyrax
+  module Collections
+    class SearchService
+      include Blacklight::Configurable
+      include Blacklight::SearchHelper
+
+      def initialize(session, user_key)
+        @session = session
+        @user_key = user_key
+        self.class.copy_blacklight_config_from(::CatalogController)
+      end
+
+      # self.search_params_logic << :apply_gated_search
+
+      def last_search_documents
+        return [] if @session[:history].blank?
+        last_search_id = @session[:history].first
+        search = Search.find(last_search_id)
+        _, document_list = get_search_results(search.query_params, fl: 'id', rows: 1000)
+        document_list
+      end
+
+      # filter that sets up access-controlled lucene query in order to provide gated search behavior
+      # @param [Hash] solr_parameters the current solr parameters
+      # @param [Hash] _user_parameters the current user-submitted parameters
+      def apply_gated_search(solr_parameters, _user_parameters)
+        solr_parameters[:fq] ||= []
+
+        # Grant access to public content
+        user_access_filters = []
+        user_access_filters << "#{solr_access_control_suffix(:group)}:public"
+
+        # Grant access based on user id & role
+        unless @user_key.blank?
+          # for roles
+          ::User.group_service.roles(@user_key).each do |role|
+            user_access_filters << "#{solr_access_control_suffix(:group)}:#{escape_slashes(role)}"
+          end
+          # for individual person access
+          user_access_filters << "#{solr_access_control_suffix(:individual)}:#{escape_slashes(@user_key)}"
+        end
+        solr_parameters[:fq] << user_access_filters.join(' OR ')
+        solr_parameters
+      end
+
+      def escape_slashes(value)
+        value.gsub('/', '\/')
+      end
+
+      # @param [Symbol] key The permission type to return.  Must be `:group` or `:individual`
+      def solr_access_control_suffix(key)
+        raise ArgumentError, 'you must provide :group or :individual' unless [:group, :individual].include?(key)
+        Hydra.config[:permissions][:edit][key]
+      end
+    end
+  end
+end

data/lib/hyrax/configuration.rb

@@ -0,0 +1,434 @@
+require 'hyrax/callbacks'
+require 'hyrax/role_registry'
+
+module Hyrax
+  class Configuration
+    include Callbacks
+
+    def initialize
+      @registered_concerns = []
+      @role_registry = Hyrax::RoleRegistry.new
+      @default_active_workflow_name = DEFAULT_ACTIVE_WORKFLOW_NAME
+    end
+
+    DEFAULT_ACTIVE_WORKFLOW_NAME = 'default'.freeze
+    private_constant :DEFAULT_ACTIVE_WORKFLOW_NAME
+
+    # @api public
+    # When an admin set is created, we need to activate a workflow.
+    # The :default_active_workflow_name is the name of the workflow we will activate.
+    #
+    # @return [String]
+    # @see Sipity::Workflow
+    # @see AdminSet
+    # @note The active workflow for an admin set can be changed at a later point.
+    # @note Changing this value after other AdminSet(s) are created does not alter the already created AdminSet(s)
+    attr_accessor :default_active_workflow_name
+
+    # @return [Hyrax::RoleRegistry]
+    attr_reader :role_registry
+    private :role_registry
+    delegate :registered_role?, :persist_registered_roles!, to: :role_registry
+
+    # @api public
+    #
+    # Exposes a means to register application critical roles
+    #
+    # @example
+    #   Hyrax.config.register_roles do |registry|
+    #     registry.add(name: 'captaining', description: 'Grants captain duties')
+    #   end
+    #
+    # @yield [Hyrax::RoleRegistry]
+    # @return [TrueClass]
+    def register_roles
+      yield(@role_registry)
+      true
+    end
+
+    # Path on the local file system where derivatives will be stored
+    attr_writer :derivatives_path
+    def derivatives_path
+      @derivatives_path ||= Rails.root.join('tmp', 'derivatives')
+    end
+
+    # Path on the local file system where originals will be staged before being ingested into Fedora.
+    attr_writer :working_path
+    def working_path
+      @working_path ||= Rails.root.join('tmp', 'uploads')
+    end
+
+    attr_writer :enable_ffmpeg
+    def enable_ffmpeg
+      return @enable_ffmpeg unless @enable_ffmpeg.nil?
+      @enable_ffmpeg = false
+    end
+
+    attr_writer :ffmpeg_path
+    def ffmpeg_path
+      @ffmpeg_path ||= 'ffmpeg'
+    end
+
+    attr_writer :fits_message_length
+    def fits_message_length
+      @fits_message_length ||= 5
+    end
+
+    attr_writer :feature_config_path
+    def feature_config_path
+      @feature_config_path ||= Rails.root.join('config', 'features.yml')
+    end
+
+    attr_accessor :temp_file_base, :enable_local_ingest,
+                  :analytics, :analytic_start_date
+
+    attr_writer :display_microdata
+    def display_microdata?
+      return @display_microdata unless @display_microdata.nil?
+      @display_microdata = true
+    end
+    alias display_microdata display_microdata?
+    deprecation_deprecate display_microdata: "use display_microdata? instead"
+
+    attr_writer :microdata_default_type
+    def microdata_default_type
+      @microdata_default_type ||= 'http://schema.org/CreativeWork'
+    end
+
+    attr_writer :max_days_between_audits
+    def max_days_between_audits
+      @max_days_between_audits ||= 7
+    end
+
+    attr_writer :enable_noids
+    def enable_noids?
+      return @enable_noids unless @enable_noids.nil?
+      @enable_noids = true
+    end
+    alias enable_noids enable_noids?
+    deprecation_deprecate enable_noids: "use enable_noids? instead"
+
+    attr_writer :noid_template
+    def noid_template
+      @noid_template ||= '.reeddeeddk'
+    end
+
+    attr_writer :noid_minter_class
+    def noid_minter_class
+      @noid_minter_class ||= ActiveFedora::Noid::Minter::Db
+    end
+
+    attr_writer :minter_statefile
+    def minter_statefile
+      @minter_statefile ||= '/tmp/minter-state'
+    end
+
+    attr_writer :display_media_download_link
+    def display_media_download_link?
+      return @display_media_download_link unless @display_media_download_link.nil?
+      @display_media_download_link = true
+    end
+    alias display_media_download_link display_media_download_link?
+    deprecation_deprecate display_media_download_link: "use display_media_download_link? instead"
+
+    attr_writer :fits_path
+    def fits_path
+      @fits_path ||= 'fits.sh'
+    end
+
+    # Override characterization runner
+    attr_accessor :characterization_runner
+
+    # Attributes for the lock manager which ensures a single process/thread is mutating a ore:Aggregation at once.
+    # @!attribute [w] lock_retry_count
+    #   How many times to retry to acquire the lock before raising UnableToAcquireLockError
+    attr_writer :lock_retry_count
+    def lock_retry_count
+      @lock_retry_count ||= 600 # Up to 2 minutes of trying at intervals up to 200ms
+    end
+
+    # @!attribute [w] lock_time_to_live
+    #   How long to hold the lock in milliseconds
+    attr_writer :lock_time_to_live
+    def lock_time_to_live
+      @lock_time_to_live ||= 60_000 # milliseconds
+    end
+
+    # @!attribute [w] lock_retry_delay
+    #   Maximum wait time in milliseconds before retrying. Wait time is a random value between 0 and retry_delay.
+    attr_writer :lock_retry_delay
+    def lock_retry_delay
+      @lock_retry_delay ||= 200 # milliseconds
+    end
+
+    # @!attribute [w] ingest_queue_name
+    #   ActiveJob queue to handle ingest-like jobs.
+    attr_writer :ingest_queue_name
+    def ingest_queue_name
+      @ingest_queue_name ||= :default
+    end
+
+    # @!attribute [w] import_export_jar_file_path
+    #   Path to the jar file for the Fedora import/export tool
+    attr_writer :import_export_jar_file_path
+    def import_export_jar_file_path
+      @import_export_jar_file_path ||= "tmp/fcrepo-import-export.jar"
+    end
+
+    # @!attribute [w] descriptions_directory
+    #   Location where description files are exported
+    attr_writer :descriptions_directory
+    def descriptions_directory
+      @descriptions_directory ||= "tmp/descriptions"
+    end
+
+    # @!attribute [w] binaries_directory
+    #   Location where binary files are exported
+    attr_writer :binaries_directory
+    def binaries_directory
+      @binaries_directory ||= "tmp/binaries"
+    end
+
+    # @!attribute [w] dashboard_configuration
+    #   Configuration for dashboard rendering.
+    attr_writer :dashboard_configuration
+    # rubocop:disable Metrics/MethodLength
+    def dashboard_configuration
+      @dashboard_configuration ||= {
+        menu: {
+          index: {},
+          resource_details: {},
+          workflow: {},
+          workflow_roles: {}
+        },
+        actions: {
+          index: {
+            partials: [
+              "total_objects_charts",
+              "total_embargo_visibility"
+            ]
+          },
+          resource_details: {
+            partials: [
+              "total_objects"
+            ]
+          },
+          workflow: {
+            partials: [
+              "workflow"
+            ]
+          }
+        },
+        data_sources: {
+          resource_stats: Hyrax::ResourceStatisticsSource
+        }
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    callback.enable :after_create_concern, :after_create_fileset,
+                    :after_update_content, :after_revert_content,
+                    :after_update_metadata, :after_import_local_file_success,
+                    :after_import_local_file_failure, :after_audit_failure,
+                    :after_destroy, :after_import_url_success,
+                    :after_import_url_failure
+
+    # Registers the given curation concern model in the configuration
+    # @param [Array<Symbol>,Symbol] curation_concern_types
+    def register_curation_concern(*curation_concern_types)
+      Array.wrap(curation_concern_types).flatten.compact.each do |cc_type|
+        unless @registered_concerns.include?(cc_type)
+          @registered_concerns << cc_type
+        end
+      end
+    end
+
+    # The normalization done by this method must occur after the initialization process
+    # so it can take advantage of irregular inflections from config/initializers/inflections.rb
+    # @return [Array<String>] the class names of the registered curation concerns
+    def registered_curation_concern_types
+      @registered_concerns.map { |cc_type| normalize_concern_name(cc_type) }
+    end
+
+    # @return [Array<Class>] the registered curation concerns
+    def curation_concerns
+      registered_curation_concern_types.map(&:constantize)
+    end
+
+    # A configuration point for changing the behavior of the license service.
+    #
+    # @!attribute [w] license_service_class
+    #   A configuration point for changing the behavior of the license service.
+    #
+    #   @see Hyrax::LicenseService for implementation details
+    attr_writer :license_service_class
+    def license_service_class
+      @license_service_class ||= Hyrax::LicenseService
+    end
+
+    attr_writer :banner_image
+    def banner_image
+      @banner_image ||= "https://cloud.githubusercontent.com/assets/92044/18370978/88ecac20-75f6-11e6-8399-6536640ef695.jpg"
+    end
+
+    attr_writer :persistent_hostpath
+    def persistent_hostpath
+      @persistent_hostpath ||= "http://localhost/files/"
+    end
+
+    attr_writer :redis_namespace
+    def redis_namespace
+      @redis_namespace ||= "hyrax"
+    end
+
+    attr_writer :libreoffice_path
+    def libreoffice_path
+      @libreoffice_path ||= "soffice"
+    end
+
+    attr_writer :browse_everything
+    def browse_everything?
+      @browse_everything ||= nil
+    end
+    alias browse_everything browse_everything?
+    deprecation_deprecate browse_everything: "use browse_everything? instead"
+
+    attr_writer :analytics
+    def analytics?
+      @analytics ||= false
+    end
+    alias analytics analytics?
+    deprecation_deprecate analytics: "use analytics? instead"
+
+    attr_writer :citations
+    def citations?
+      @citations ||= false
+    end
+    alias citations citations?
+    deprecation_deprecate citations: "use citations? instead"
+
+    attr_writer :max_notifications_for_dashboard
+    def max_notifications_for_dashboard
+      @max_notifications_for_dashboard ||= 5
+    end
+
+    attr_writer :activity_to_show_default_seconds_since_now
+    def activity_to_show_default_seconds_since_now
+      @activity_to_show_default_seconds_since_now ||= 24 * 60 * 60
+    end
+
+    attr_writer :arkivo_api
+    def arkivo_api?
+      @arkivo_api ||= false
+    end
+    alias arkivo_api arkivo_api?
+    deprecation_deprecate arkivo_api: "use arkivo_api? instead"
+
+    def geonames_username=(username)
+      Qa::Authorities::Geonames.username = username
+    end
+
+    attr_writer :active_deposit_agreement_acceptance
+    def active_deposit_agreement_acceptance?
+      return true if @active_deposit_agreement_acceptance.nil?
+      @active_deposit_agreement_acceptance
+    end
+    alias active_deposit_agreement_acceptance active_deposit_agreement_acceptance?
+    deprecation_deprecate active_deposit_agreement_acceptance: "use active_deposit_agreement_acceptance? instead"
+
+    attr_writer :work_requires_files
+    def work_requires_files?
+      return true if @work_requires_files.nil?
+      @work_requires_files
+    end
+    alias work_requires_files work_requires_files?
+    deprecation_deprecate work_requires_files: "use work_requires_files? instead"
+
+    attr_writer :batch_user_key
+    def batch_user_key
+      @batch_user_key ||= 'batchuser@example.com'
+    end
+
+    attr_writer :audit_user_key
+    def audit_user_key
+      @audit_user_key ||= 'audituser@example.com'
+    end
+
+    # NOTE: This used to be called `working_path` in CurationConcerns
+    attr_writer :upload_path
+    def upload_path
+      @upload_path ||= ->() { Rails.root + 'tmp' + 'uploads' }
+    end
+
+    attr_writer :cache_path
+    def cache_path
+      @cache_path ||= ->() { Rails.root + 'tmp' + 'uploads' + 'cache' }
+    end
+
+    # Should a button with "Share my work" show on the front page to all users (even those not logged in)?
+    attr_writer :always_display_share_button
+    def always_display_share_button?
+      return true if @always_display_share_button.nil?
+      @always_display_share_button
+    end
+    alias always_display_share_button always_display_share_button?
+    deprecation_deprecate always_display_share_button: "use always_display_share_button? instead"
+
+    attr_writer :google_analytics_id
+    def google_analytics_id
+      @google_analytics_id ||= nil
+    end
+    alias google_analytics_id? google_analytics_id
+
+    # Defaulting analytic start date to whenever the file was uploaded by leaving it blank
+    attr_writer :analytic_start_date
+    attr_reader :analytic_start_date
+
+    attr_writer :permission_levels
+    def permission_levels
+      @permission_levels ||= { "Choose Access" => "none",
+                               "View/Download" => "read",
+                               "Edit" => "edit" }
+    end
+
+    attr_writer :owner_permission_levels
+    def owner_permission_levels
+      @owner_permission_levels ||= { "Edit Access" => "edit" }
+    end
+
+    attr_writer :translate_uri_to_id
+    def translate_uri_to_id
+      @translate_uri_to_id ||= ActiveFedora::Noid.config.translate_uri_to_id
+    end
+
+    attr_writer :translate_id_to_uri
+    def translate_id_to_uri
+      @translate_id_to_uri ||= ActiveFedora::Noid.config.translate_id_to_uri
+    end
+
+    attr_writer :contact_email
+    def contact_email
+      @contact_email ||= "repo-admin@example.org"
+    end
+
+    attr_writer :subject_prefix
+    def subject_prefix
+      @subject_prefix ||= "Contact form:"
+    end
+
+    attr_writer :model_to_create
+    # Returns a lambda that takes a hash of attributes and returns a string of the model
+    # name. This is called by the batch upload process
+    def model_to_create
+      @model_to_create ||= ->(_attributes) { Hyrax.primary_work_type.model_name.name }
+    end
+
+    private
+
+      # @param [Symbol, #to_s] model_name - symbol representing the model
+      # @return [String] the class name for the model
+      def normalize_concern_name(model_name)
+        model_name.to_s.camelize
+      end
+  end
+end