hyrax 2.0.3 → 2.1.0.beta1

data/app/models/concerns/hyrax/with_events.rb

@@ -8,16 +8,22 @@ module Hyrax
       self.class.name
     end
 
-    def event_store
-      RedisEventStore
-    end
-
     def events(size = -1)
-      event_store.for(stream[:event]).fetch(size)
+      event_stream.fetch(size)
     end
 
     def log_event(event_id)
-      event_store.for(stream[:event]).push(event_id)
+      event_stream.push(event_id)
     end
+
+    private
+
+      def event_store
+        RedisEventStore
+      end
+
+      def event_stream
+        event_store.for(stream[:event])
+      end
   end
 end

data/app/models/concerns/hyrax/work_behavior.rb

@@ -9,6 +9,7 @@ module Hyrax
     include Hydra::WithDepositor
     include Solrizer::Common
     include HasRepresentative
+    include HasRendering
     include WithFileSets
     include Naming
     include CoreMetadata
@@ -20,6 +21,7 @@ module Hyrax
     include ProxyDeposit
     include Works::Metadata
     include WithEvents
+    include Hyrax::CollectionNesting
 
     included do
       property :owner, predicate: RDF::URI.new('http://opaquenamespace.org/ns/hydra/owner'), multiple: false
@@ -28,7 +30,7 @@ module Hyrax
       self.indexer = WorkIndexer
     end
 
-    # TODO: Move this into ActiveFedora
+    # TODO: This can be removed when we upgrade to ActiveFedora 12.0
     def etag
       raise "Unable to produce an etag for a unsaved object" unless persisted?
       ldp_source.head.etag

data/app/models/hyrax/batch_create_operation.rb

@@ -10,7 +10,7 @@ module Hyrax
 
     def batch_failure_message
       return unless Hyrax.config.callback.set?(:after_batch_create_failure)
-      Hyrax.config.callback.run(:after_batch_create_failure, user)
+      Hyrax.config.callback.run(:after_batch_create_failure, user, rollup_messages)
     end
   end
 end

data/app/models/hyrax/collection_type.rb

@@ -0,0 +1,155 @@
+module Hyrax
+  class CollectionType < ActiveRecord::Base
+    self.table_name = 'hyrax_collection_types'
+    validates :title, presence: true, uniqueness: true
+    validates :machine_id, presence: true, uniqueness: true
+    before_save :ensure_no_settings_changes_for_admin_set_type
+    before_save :ensure_no_settings_changes_for_user_collection_type
+    before_save :ensure_no_settings_changes_if_collections_exist
+    before_destroy :ensure_no_collections
+    has_many :collection_type_participants, class_name: 'Hyrax::CollectionTypeParticipant', foreign_key: 'hyrax_collection_type_id', dependent: :destroy
+
+    USER_COLLECTION_MACHINE_ID    = 'user_collection'.freeze
+    USER_COLLECTION_DEFAULT_TITLE = I18n.t('hyrax.collection_type.default_title').freeze
+
+    ADMIN_SET_MACHINE_ID = 'admin_set'.freeze
+    ADMIN_SET_DEFAULT_TITLE = I18n.t('hyrax.collection_type.admin_set_title').freeze
+
+    def title=(value)
+      super
+      assign_machine_id
+    end
+
+    class_attribute :collection_type_settings_methods, instance_writer: false
+    self.collection_type_settings_methods = [:nestable?, :discoverable?, :sharable?, :share_applies_to_new_works?,
+                                             :allow_multiple_membership?, :require_membership?, :assigns_workflow?,
+                                             :assigns_visibility?]
+
+    # These are provided as a convenience method based on prior design discussions.
+    alias_attribute :discovery, :discoverable
+    alias_attribute :sharing, :sharable
+    alias_attribute :multiple_membership, :allow_multiple_membership
+    alias_attribute :workflow, :assigns_workflow
+    alias_attribute :visibility, :assigns_visibility
+
+    # Find the collection type associated with the Global Identifier (gid)
+    # @param [String] gid - Global Identifier for this collection_type (e.g. gid://internal/hyrax-collectiontype/3)
+    # @return [Hyrax::CollectionType] if record matching gid is found, an instance of Hyrax::CollectionType with id = the model_id portion of the gid (e.g. 3)
+    # @return [False] if record matching gid is not found
+    def self.find_by_gid(gid)
+      find(GlobalID.new(gid).model_id)
+    rescue ActiveRecord::RecordNotFound, URI::InvalidURIError
+      false
+    end
+
+    # Find the collection type associated with the Global Identifier (gid)
+    # @param [String] gid - Global Identifier for this collection_type (e.g. gid://internal/hyrax-collectiontype/3)
+    # @return [Hyrax::CollectionType] an instance of Hyrax::CollectionType with id = the model_id portion of the gid (e.g. 3)
+    # @raise [ActiveRecord::RecordNotFound] if record matching gid is not found
+    def self.find_by_gid!(gid)
+      result = find_by_gid(gid)
+      raise ActiveRecord::RecordNotFound, "Couldn't find Hyrax::CollectionType matching GID '#{gid}'" unless result
+      result
+    end
+
+    # Return the Global Identifier for this collection type.
+    # @return [String] Global Identifier (gid) for this collection_type (e.g. gid://internal/hyrax-collectiontype/3)
+    def gid
+      URI::GID.build(app: GlobalID.app, model_name: model_name.name.parameterize.to_sym, model_id: id).to_s if id
+    end
+
+    def collections
+      return [] unless gid
+      ActiveFedora::Base.where(collection_type_gid_ssim: gid.to_s)
+    end
+
+    # @return [Boolean] True if there is at least one collection of this type
+    def collections?
+      collections.count > 0
+    end
+
+    # @return [Boolean] True if this is the Admin Set type
+    def admin_set?
+      machine_id == ADMIN_SET_MACHINE_ID
+    end
+
+    # @return [Boolean] True if this is the User Collection type
+    def user_collection?
+      machine_id == USER_COLLECTION_MACHINE_ID
+    end
+
+    # @return [Boolean] True if there is at least one collection type that has nestable? true
+    def self.any_nestable?
+      where(nestable: true).any?
+    end
+
+    # Find or create the default type (i.e., user collection) as defined by:
+    #
+    # * USER_COLLECTION_MACHINE_ID
+    # * USER_COLLECTION_DEFAULT_TITLE
+    # * Hyrax::CollectionTypes::CreateService::USER_COLLECTION_OPTIONS
+    #
+    # @see Hyrax::CollectionTypes::CreateService
+    #
+    # @return [Hyrax::CollectionType] where machine_id = USER_COLLECTION_MACHINE_ID
+    def self.find_or_create_default_collection_type
+      find_by(machine_id: USER_COLLECTION_MACHINE_ID) || Hyrax::CollectionTypes::CreateService.create_user_collection_type
+    end
+
+    # Find or create the Admin Set collection type as defined by:
+    #
+    # * ADMIN_SET_MACHINE_ID
+    # * ADMIN_SET_DEFAULT_TITLE
+    # * Hyrax::CollectionTypes::CreateService::ADMIN_SET_OPTIONS
+    #
+    # @see Hyrax::CollectionTypes::CreateService
+    #
+    # @return [Hyrax::CollectionType] where machine_id = ADMIN_SET_MACHINE_ID
+    def self.find_or_create_admin_set_type
+      find_by(machine_id: ADMIN_SET_MACHINE_ID) || Hyrax::CollectionTypes::CreateService.create_admin_set_type
+    end
+
+    private
+
+      def assign_machine_id
+        # FIXME: This method allows for the possibility of collisions
+        self.machine_id ||= title.parameterize.underscore.to_sym if title.present?
+      end
+
+      def ensure_no_collections
+        return true unless collections?
+        errors[:base] << I18n.t('hyrax.admin.collection_types.errors.not_empty')
+        throw :abort
+      end
+
+      def ensure_no_settings_changes_for_admin_set_type
+        return true unless admin_set? && exists_for_machine_id?(ADMIN_SET_MACHINE_ID)
+        return true unless collection_type_settings_changed?
+        errors[:base] << I18n.t('hyrax.admin.collection_types.errors.no_settings_change_for_admin_sets')
+        throw :abort
+      end
+
+      def ensure_no_settings_changes_for_user_collection_type
+        return true unless user_collection? && exists_for_machine_id?(USER_COLLECTION_MACHINE_ID)
+        return true unless collection_type_settings_changed?
+        errors[:base] << I18n.t('hyrax.admin.collection_types.errors.no_settings_change_for_user_collections')
+        throw :abort
+      end
+
+      def ensure_no_settings_changes_if_collections_exist
+        return true unless collections?
+        return true unless collection_type_settings_changed?
+        errors[:base] << I18n.t('hyrax.admin.collection_types.errors.no_settings_change_if_not_empty')
+        throw :abort
+      end
+
+      def collection_type_settings_changed?
+        (changes.keys & ['nestable', 'discoverable', 'sharable', 'share_applies_to_new_works', 'allow_multiple_membership',
+                         'require_membership', 'assigns_workflow', 'assigns_visibility']).any?
+      end
+
+      def exists_for_machine_id?(machine_id)
+        Hyrax::CollectionType.exists?(machine_id: machine_id)
+      end
+  end
+end

data/app/models/hyrax/collection_type_participant.rb

@@ -0,0 +1,39 @@
+module Hyrax
+  class CollectionTypeParticipant < ActiveRecord::Base
+    self.table_name = 'collection_type_participants'
+    belongs_to :hyrax_collection_type, class_name: 'CollectionType', foreign_key: 'hyrax_collection_type_id'
+
+    MANAGE_ACCESS = 'manage'.freeze
+    CREATE_ACCESS = 'create'.freeze
+
+    GROUP_TYPE = 'group'.freeze
+    USER_TYPE = 'user'.freeze
+
+    validates :agent_id, presence: true
+    validates :agent_type, presence: true, inclusion: { in: [GROUP_TYPE, USER_TYPE],
+                                                        message: "%<value>s is not a valid agent type.  Accepts: #{GROUP_TYPE}, #{USER_TYPE}" }
+    validates :access, presence: true, inclusion: { in: [MANAGE_ACCESS, CREATE_ACCESS],
+                                                    message: "%<value>s is not a valid access.  Accepts: #{MANAGE_ACCESS}, #{CREATE_ACCESS}" }
+    validates :hyrax_collection_type_id, presence: true
+
+    def manager?
+      access == MANAGE_ACCESS
+    end
+
+    def creator?
+      access == CREATE_ACCESS
+    end
+
+    def label
+      return agent_id unless agent_type == GROUP_TYPE
+      case agent_id
+      when ::Ability.registered_group_name
+        I18n.t('hyrax.admin.admin_sets.form_participant_table.registered_users')
+      when ::Ability.admin_group_name
+        I18n.t('hyrax.admin.admin_sets.form_participant_table.admin_users')
+      else
+        agent_id
+      end
+    end
+  end
+end

data/app/models/hyrax/operation.rb

@@ -41,6 +41,18 @@ module Hyrax
       end
     end
 
+    # Roll up messages for an operation and all of its children
+    def rollup_messages
+      [].tap do |messages|
+        messages << message if message.present?
+        if children
+          children.pluck(:message).uniq.each do |child_message|
+            messages << child_message if child_message.present?
+          end
+        end
+      end
+    end
+
     # Mark this operation as a SUCCESS. If this is a child operation, roll up to
     # the parent any failures.
     #
@@ -58,10 +70,10 @@ module Hyrax
     # Mark this operation as a FAILURE. If this is a child operation, roll up to
     # the parent any failures.
     #
-    # @param [String, nil] message - record any failure message
+    # @param [String, nil] message record any failure message
     # @see Hyrax::Operation::FAILURE
     # @see #rollup_status
-    # @note This will run any registered :success callbacks
+    # @note This will run any registered :failure callbacks
     # @todo Where are these callbacks defined? Document this
     def fail!(message = nil)
       run_callbacks :failure do

data/app/models/hyrax/permission_template.rb

@@ -28,11 +28,33 @@ module Hyrax
     # In a perfect world, there would be a join table that enforced uniqueness on the ID.
     has_one :active_workflow, -> { where(active: true) }, class_name: 'Sipity::Workflow', foreign_key: :permission_template_id
 
+    # A bit of an analogue for a `belongs_to :source_model` as it crosses from Fedora to the DB
+    # @return [AdminSet | Collection]
+    # @raise [ActiveFedora::ObjectNotFoundError] when neither an AdminSet or Collection is found
+    def source_model
+      admin_set
+    rescue ActiveFedora::ObjectNotFoundError
+      collection
+    end
+
     # A bit of an analogue for a `belongs_to :admin_set` as it crosses from Fedora to the DB
     # @return [AdminSet]
     # @raise [ActiveFedora::ObjectNotFoundError] when the we cannot find the AdminSet
     def admin_set
-      AdminSet.find(admin_set_id)
+      return AdminSet.find(source_id) if AdminSet.exists?(source_id)
+      raise ActiveFedora::ObjectNotFoundError
+    rescue ActiveFedora::ActiveFedoraError # TODO: remove the rescue when active_fedora issue #1276 is fixed
+      raise ActiveFedora::ObjectNotFoundError
+    end
+
+    # A bit of an analogue for a `belongs_to :collection` as it crosses from Fedora to the DB
+    # @return [Collection]
+    # @raise [ActiveFedora::ObjectNotFoundError] when the we cannot find the Collection
+    def collection
+      return Collection.find(source_id) if Collection.exists?(source_id)
+      raise ActiveFedora::ObjectNotFoundError
+    rescue ActiveFedora::ActiveFedoraError # TODO: remove the rescue when active_fedora issue #1276 is fixed
+      raise ActiveFedora::ObjectNotFoundError
     end
 
     # Valid Release Period values

data/app/models/hyrax/permission_template_access.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
 module Hyrax
+  # Models a single grant of access to an agent (user or group) on a PermissionTemplate
   class PermissionTemplateAccess < ActiveRecord::Base
     self.table_name = 'permission_template_accesses'
     belongs_to :permission_template
-    before_destroy :check_if_admin_group
+
+    # An agent should only have any particular level of access once.
+    validates :access, uniqueness: {
+      scope: [:agent_id, :agent_type, :permission_template_id]
+    }
 
     VIEW = 'view'.freeze
     DEPOSIT = 'deposit'.freeze
@@ -18,6 +23,22 @@ module Hyrax
       }
     )
 
+    # @api public
+    #
+    # The permissions template access a given user has.
+    #
+    # @param access [Array<String>] one or more types of access (e.g. Hyrax::PermissionTemplateAccess::MANAGE, Hyrax::PermissionTemplateAccess::DEPOSIT, Hyrax::PermissionTemplateAccess::VIEW)
+    # @param ability [Ability] the ability coming from cancan ability check
+    # @return [ActiveRecord::Relation] relation of templates for which the user has specified roles
+    def self.for_user(ability:, access:)
+      PermissionTemplateAccess.where(
+        user_where(access: access, ability: ability)
+      ).or(
+        PermissionTemplateAccess
+          .where(group_where(access: access, ability: ability))
+      )
+    end
+
     def label
       return agent_id unless agent_type == 'group'
       case agent_id
@@ -34,12 +55,40 @@ module Hyrax
       agent_type == 'group' && agent_id == ::Ability.admin_group_name
     end
 
-    private
+    # @api private
+    #
+    # Generate the user where clause hash for joining the permissions tables
+    #
+    # @param access [Array<String>] one or more types of access (e.g. Hyrax::PermissionTemplateAccess::MANAGE, Hyrax::PermissionTemplateAccess::DEPOSIT, Hyrax::PermissionTemplateAccess::VIEW)
+    # @param ability [Ability] the cancan ability
+    # @return [Hash] the where clause hash to pass to joins for users
+    # @note Several checks get the user's groups from the user's ability.  The same values can be retrieved directly from a passed in ability.
+    #   If calling from Abilities, pass the ability.  If you try to get the ability from the user, you end up in an infinit loop.
+    def self.user_where(access:, ability:)
+      where_clause = {}
+      where_clause[:agent_type] = 'user'
+      where_clause[:agent_id] = ability.current_user.user_key
+      where_clause[:access] = access
+      where_clause
+    end
+    private_class_method :user_where
 
-      def check_if_admin_group
-        return true unless admin_group?
-        errors[:base] << I18n.t('hyrax.admin.admin_sets.form.permission_destroy_errors.admin_group')
-        throw :abort
-      end
+    # @api private
+    #
+    # Generate the group where clause hash for joining the permissions tables
+    #
+    # @param access [Array<String>] one or more types of access (e.g. Hyrax::PermissionTemplateAccess::MANAGE, Hyrax::PermissionTemplateAccess::DEPOSIT, Hyrax::PermissionTemplateAccess::VIEW)
+    # @param ability [Ability] the cancan ability
+    # @return [Hash] the where clause hash to pass to joins for groups
+    # @note Several checks get the user's groups from the user's ability.  The same values can be retrieved directly from a passed in ability.
+    #   If calling from Abilities, pass the ability.  If you try to get the ability from the user, you end up in an infinit loop.
+    def self.group_where(access:, ability:)
+      where_clause = {}
+      where_clause[:agent_type] = 'group'
+      where_clause[:agent_id] = ability.user_groups
+      where_clause[:access] = access
+      where_clause
+    end
+    private_class_method :group_where
   end
 end

data/app/models/hyrax/uploaded_file.rb

@@ -5,7 +5,10 @@ module Hyrax
     self.table_name = 'uploaded_files'
     mount_uploader :file, UploadedFileUploader
     alias uploader file
-    has_many :job_io_wrappers, inverse_of: 'uploaded_file', class_name: 'JobIoWrapper'
+    has_many :job_io_wrappers,
+             inverse_of: 'uploaded_file',
+             class_name: 'JobIoWrapper',
+             dependent: :destroy
     belongs_to :user, class_name: '::User'
 
     before_destroy :remove_file!

data/app/models/sipity/workflow.rb

@@ -29,7 +29,7 @@ module Sipity
       workflows = Sipity::Workflow.arel_table
       Sipity::Workflow.where(active: true).where(
         workflows[:permission_template_id].in(
-          templates.project(templates[:id]).where(templates[:admin_set_id].eq(admin_set_id))
+          templates.project(templates[:id]).where(templates[:source_id].eq(admin_set_id))
         )
       ).first!
     end
@@ -37,14 +37,16 @@ module Sipity
     # @api public
     #
     # Within the given permission_template scope:
-    #   * Deactivate the current active workflow (if one exists)
-    #   * Activate the specified workflow_id
+    #   * Activate the specified workflow_id or workflow_name
+    #   * Deactivate the other workflows
+    #
+    # TODO: Resolve https://github.com/samvera/hyrax/issues/2151 as the documentation is aspirational and not reality
     #
     # @param permission_template [Hyrax::PermissionTemplate] The scope for activation of the workflow id
     # @param workflow_id [Integer] The workflow_id within the given permission_template that should be activated
     # @param workflow_name [String] The name of the workflow within the given permission template that should be activated
     # @return [TrueClass]
-    # @raise [ActiveRecord::RecordNotFound] When we have a mismatch on permission template and workflow id
+    # @raise [ActiveRecord::RecordNotFound] When we have a mismatch on permission template and workflow id or workflow name
     # @raise [RuntimeError] When you don't specify a workflow_id or workflow_name
     def self.activate!(permission_template:, workflow_id: nil, workflow_name: nil)
       raise "You must specify a workflow_id or workflow_name to activate!" if workflow_id.blank? && workflow_name.blank?