curation_concerns 1.6.3 → 1.7.0.beta1

data/app/forms/curation_concerns/forms/workflow_responsibility_form.rb

@@ -0,0 +1,42 @@
+module CurationConcerns
+  module Forms
+    class WorkflowResponsibilityForm
+      def initialize(params = {})
+        model_instance.workflow_role_id = params[:workflow_role_id]
+        if params[:user_id]
+          user = ::User.find(params[:user_id])
+          model_instance.agent = user.to_sipity_agent
+        end
+      end
+
+      def model_instance
+        @model ||= Sipity::WorkflowResponsibility.new
+      end
+
+      def to_model
+        model_instance
+      end
+
+      delegate :model_name, :to_key, :workflow_role_id, :persisted?, :save!, to: :model_instance
+
+      def user_id
+        nil
+      end
+
+      def user_options
+        ::User.all
+      end
+
+      # The select options for choosing a responsibility
+      def workflow_role_options
+        Sipity::WorkflowRole.all.map { |wf_role| [label(wf_role), wf_role.id] }
+      end
+
+      private
+
+        def label(wf_role)
+          "#{wf_role.workflow.name} - #{wf_role.role.name}"
+        end
+    end
+  end
+end

data/app/helpers/curation_concerns/charts_helper.rb

@@ -0,0 +1,23 @@
+module CurationConcerns
+  module ChartsHelper
+    # @example A chart with a drilldown
+    #   {
+    #     "First" => {
+    #       "Second" => 3,
+    #       "Third" => 3
+    #     }
+    #   }
+    # @example A chart without a drilldown
+    #   {
+    #     "First" => 3,
+    #     "Second" => 4
+    #   }
+    def hash_to_chart(data)
+      data = ::CurationConcerns::ChartData.new(data)
+      {
+        drilldown: { series: data.drilldown },
+        series: data.series
+      }
+    end
+  end
+end

data/app/helpers/curation_concerns/main_app_helpers.rb

@@ -8,5 +8,6 @@ module CurationConcerns::MainAppHelpers
   include CurationConcerns::EmbargoHelper
   include CurationConcerns::LeaseHelper
   include CurationConcerns::CollectionsHelper
+  include CurationConcerns::ChartsHelper
   include CurationConcerns::RightsHelper
 end

data/app/helpers/curation_concerns/url_helper.rb

@@ -3,11 +3,8 @@ module CurationConcerns
     # override Blacklight so we can use our 'curation_concern' namespace
     # We may also pass in a ActiveFedora document instead of a SolrDocument
     def url_for_document(doc, _options = {})
-      if doc.collection?
-        doc
-      else
-        polymorphic_path([main_app, doc])
-      end
+      return doc if doc.collection?
+      [main_app, doc]
     end
 
     # generated models get registered as curation concerns and need a

data/app/indexers/curation_concerns/indexes_workflow.rb

@@ -0,0 +1,44 @@
+module CurationConcerns
+  module IndexesWorkflow
+    STORED_BOOL = Solrizer::Descriptor.new(:boolean, :stored, :indexed)
+    # Adds thumbnail indexing to the solr document
+    def generate_solr_document
+      super.tap do |solr_doc|
+        index_suppressed(solr_doc)
+        index_workflow_fields(solr_doc)
+      end
+    end
+
+    # Write the suppressed status into the solr_document
+    # @params [Hash] solr_document the solr document to add the field to
+    def index_suppressed(solr_document)
+      solr_document[suppressed_field] = object.suppressed?
+    end
+
+    # Write the workflow roles and state so one can see where the document moves to next
+    # @params [Hash] solr_document the solr document to add the field to
+    def index_workflow_fields(solr_document)
+      return unless object.persisted?
+      entity = PowerConverter.convert_to_sipity_entity(object)
+      return if entity.nil?
+      solr_document[workflow_role_field] = workflow_roles(entity).map { |role| "#{entity.workflow.name}-#{role}" }
+      solr_document[workflow_state_name_field] = entity.workflow_state.name if entity.workflow_state
+    end
+
+    def workflow_state_name_field
+      @workflow_state_name_field ||= Solrizer.solr_name('workflow_state_name', :symbol)
+    end
+
+    def workflow_role_field
+      @workflow_role_field ||= Solrizer.solr_name('actionable_workflow_roles', :symbol)
+    end
+
+    def workflow_roles(entity)
+      CurationConcerns::Workflow::PermissionQuery.scope_roles_associated_with_the_given_entity(entity: entity)
+    end
+
+    def suppressed_field
+      @suppressed_field ||= Solrizer.solr_name('suppressed', STORED_BOOL)
+    end
+  end
+end

data/app/indexers/curation_concerns/work_indexer.rb

@@ -1,13 +1,12 @@
 module CurationConcerns
   class WorkIndexer < ActiveFedora::IndexingService
     include IndexesThumbnails
-    STORED_BOOL = Solrizer::Descriptor.new(:boolean, :stored, :indexed)
+    include IndexesWorkflow
 
     def generate_solr_document
       super.tap do |solr_doc|
         solr_doc[Solrizer.solr_name('member_ids', :symbol)] = object.member_ids
         Solrizer.set_field(solr_doc, 'generic_type', 'Work', :facetable)
-        solr_doc[Solrizer.solr_name('suppressed', STORED_BOOL)] = object.suppressed?
       end
     end
   end

data/app/jobs/import_export_job.rb

@@ -0,0 +1,46 @@
+require 'open3'
+
+class ImportExportJob < ActiveJob::Base
+  attr_reader :mode
+  include Open3
+
+  # @param [String] uri of the resource
+  # @option opts [String] desc_dir location of descriptions
+  # @option opts [String] bin_dir location of binaries
+  # @option opts [String] profile BagIt profile
+  # @option opts [String] mode import or export mode
+  # Notes:
+  #   * the Fedora import-export tool is not release yet
+  #   * current parameters are undergoing changes
+  #   * import features are not yet available
+  #   * exporting bags is not yet supported
+  def perform(uri, options = {})
+    @mode = options.fetch(:mode, "export")
+    call(uri,
+         options.fetch(:desc_dir, CurationConcerns.config.descriptions_directory),
+         options.fetch(:bin_dir, CurationConcerns.config.binaries_directory),
+         options.fetch(:profile, nil))
+  end
+
+  private
+
+    def call(uri, desc_dir, bin_dir, _profile = nil)
+      command = "java -jar #{CurationConcerns.config.import_export_jar_file_path} --mode #{mode} --resource #{uri} --descDir #{desc_dir} --binDir #{bin_dir}"
+      internal_call(command)
+    end
+
+    def internal_call(command)
+      stdin, stdout, stderr, wait_thr = popen3(command)
+      begin
+        out = stdout.read
+        err = stderr.read
+        exit_status = wait_thr.value
+        raise "Fedora command failed: \"#{command}\"\n#{err}" unless exit_status.success?
+        out
+      ensure
+        stdin.close
+        stdout.close
+        stderr.close
+      end
+    end
+end

data/app/models/concerns/curation_concerns/ability.rb

@@ -28,11 +28,13 @@ module CurationConcerns
     end
 
     def admin_permissions
+      can :read, :admin_dashboard
       alias_action :edit, to: :update
       alias_action :show, to: :read
       alias_action :discover, to: :read
 
       can :manage, curation_concerns_models
+      can :manage, Sipity::WorkflowResponsibility
     end
 
     # Override this method in your ability model if you use a different group

data/app/models/concerns/curation_concerns/permissions/writable.rb

@@ -9,6 +9,13 @@ module CurationConcerns
 
       included do
         validate :paranoid_permissions
+
+        class_attribute :paranoid_edit_permissions
+        self.paranoid_edit_permissions =
+          [
+            { key: :edit_groups, message: 'Public cannot have edit access', condition: ->(obj) { obj.edit_groups.include?('public') } },
+            { key: :edit_groups, message: 'Registered cannot have edit access', condition: ->(obj) { obj.edit_groups.include?('registered') } }
+          ]
       end
 
       def paranoid_permissions
@@ -21,14 +28,6 @@ module CurationConcerns
         end
         valid
       end
-
-      def paranoid_edit_permissions
-        [
-          { key: :edit_users, message: 'Depositor must have edit access', condition: ->(obj) { !obj.edit_users.include?(obj.depositor) } },
-          { key: :edit_groups, message: 'Public cannot have edit access', condition: ->(obj) { obj.edit_groups.include?('public') } },
-          { key: :edit_groups, message: 'Registered cannot have edit access', condition: ->(obj) { obj.edit_groups.include?('registered') } }
-        ]
-      end
     end
   end
 end

data/app/models/concerns/curation_concerns/publishable.rb

@@ -1,4 +1,5 @@
 module CurationConcerns
+  # Workflow considerations
   module Publishable
     extend ActiveSupport::Concern
 
@@ -15,5 +16,10 @@ module CurationConcerns
     def suppressed?
       state_workflow.new(state).pending?
     end
+
+    def to_sipity_entity
+      raise "Can't create an entity until the model has been persisted" unless persisted?
+      @sipity_entity ||= Sipity::Entity.find_by(proxy_for_global_id: to_global_id.to_s)
+    end
   end
 end

data/app/models/concerns/curation_concerns/solr_document_behavior.rb

@@ -38,6 +38,10 @@ module CurationConcerns
       def to_partial_path
         @model._to_partial_path
       end
+
+      def to_global_id
+        URI::GID.build app: GlobalID.app, model_name: model_name.name, model_id: @id
+      end
     end
     ##
     # Offer the source (ActiveFedora-based) model to Rails for some of the
@@ -162,6 +166,10 @@ module CurationConcerns
                       end
     end
 
+    def workflow_state
+      first(Solrizer.solr_name('workflow_state_name', :symbol))
+    end
+
     private
 
       def date_field(field_name)

data/app/models/concerns/curation_concerns/user.rb

@@ -2,6 +2,7 @@ module CurationConcerns::User
   extend ActiveSupport::Concern
   included do
     delegate :can?, :cannot?, to: :ability
+    has_one :sipity_agent, as: :proxy_for, dependent: :destroy, class_name: 'Sipity::Agent'
   end
 
   # Redefine this for more intuitive keys in Redis
@@ -10,6 +11,10 @@ module CurationConcerns::User
     user_key.gsub(/\./, '-dot-')
   end
 
+  def to_sipity_agent
+    sipity_agent || create_sipity_agent!
+  end
+
   private
 
     def ability

data/app/models/curation_concerns/group.rb

@@ -0,0 +1,23 @@
+module CurationConcerns
+  class Group
+    def initialize(name)
+      @name = name
+    end
+
+    attr_reader :name
+
+    def to_sipity_agent
+      sipity_agent || create_sipity_agent!
+    end
+
+    private
+
+      def sipity_agent
+        Sipity::Agent.find_by(proxy_for_id: name, proxy_for_type: self.class.name)
+      end
+
+      def create_sipity_agent!
+        Sipity::Agent.create!(proxy_for_id: name, proxy_for_type: self.class.name)
+      end
+  end
+end

data/app/models/curation_concerns/workflow_action_info.rb

@@ -0,0 +1,13 @@
+module CurationConcerns
+  # A simple data object for holding a user, work and their workflow proxies
+  class WorkflowActionInfo
+    def initialize(work, user)
+      @work = work
+      @user = user
+      @entity = PowerConverter.convert(work, to: :sipity_entity)
+      @agent = PowerConverter.convert(user, to: :sipity_agent)
+    end
+
+    attr_reader :entity, :agent, :user, :work
+  end
+end

data/app/models/sipity/agent.rb

@@ -0,0 +1,21 @@
+module Sipity
+  # A proxy for something that can take an action.
+  #
+  # * A User can be an agent
+  # * A Group can be an agent (though Group is outside the scope of this system)
+  class Agent < ActiveRecord::Base
+    self.table_name = 'sipity_agents'
+
+    ENTITY_LEVEL_AGENT_RELATIONSHIP = 'entity_level'.freeze
+    WORKFLOW_LEVEL_AGENT_RELATIONSHIP = 'workflow_level'.freeze
+
+    belongs_to :proxy_for, polymorphic: true
+    has_many :workflow_responsibilities, dependent: :destroy, class_name: 'Sipity::WorkflowResponsibility'
+    has_many :entity_specific_responsibilities, dependent: :destroy, class_name: 'Sipity::EntitySpecificResponsibility'
+
+    has_many :comments,
+             foreign_key: :agent_id,
+             dependent: :destroy,
+             class_name: 'Sipity::Comment'
+  end
+end

data/app/models/sipity/comment.rb

@@ -0,0 +1,13 @@
+module Sipity
+  # Represents a "comment" placed by the given :agent in regards to the give :entity
+  class Comment < ActiveRecord::Base
+    self.table_name = 'sipity_comments'
+
+    belongs_to :agent, class_name: 'Sipity::Agent'
+    belongs_to :entity, class_name: 'Sipity::Entity'
+
+    def name_of_commentor
+      agent.proxy_for.to_s
+    end
+  end
+end

data/app/models/sipity/entity.rb

@@ -0,0 +1,32 @@
+module Sipity
+  # A proxy for the entity that is being processed.
+  # By using a proxy, we need not worry about polluting the proxy's concerns
+  # with things related to processing.
+  #
+  # The goal is to keep this behavior separate, so that we can possibly
+  # extract the information.
+  class Entity < ActiveRecord::Base
+    self.table_name = 'sipity_entities'
+
+    belongs_to :workflow, class_name: 'Sipity::Workflow'
+    belongs_to :workflow_state, class_name: 'Sipity::WorkflowState'
+
+    has_many :entity_specific_responsibilities, dependent: :destroy, class_name: 'Sipity::EntitySpecificResponsibility'
+
+    has_many :comments,
+             foreign_key: :entity_id,
+             dependent: :destroy,
+             class_name: 'Sipity::Comment'
+
+    def workflow_state_name
+      workflow_state.name if workflow_state
+    end
+
+    # Defines the method #workflow_name
+    delegate :name, to: :workflow, prefix: :workflow
+
+    def proxy_for
+      @proxy_for ||= GlobalID::Locator.locate(proxy_for_global_id)
+    end
+  end
+end

data/app/models/sipity/entity_specific_responsibility.rb

@@ -0,0 +1,21 @@
+module Sipity
+  # In what capacity can an agent act upon the given entity?
+  #
+  # This is an analogue to the Sipity::WorkflowResponsibility, but
+  # the responsibility only applies to the given entity.
+  #
+  # @example
+  #   An Advisor for a given Student would have an
+  #   EntitySpecificResponsibility to review an ETD submitted by the
+  #   given Student.
+  #   The Graduate School Reviewer would have a WorkflowResponsibility
+  #   to review all ETDs submitted.
+  #
+  # @see Sipity::WorkflowResponsibility
+  class EntitySpecificResponsibility < ActiveRecord::Base
+    self.table_name = 'sipity_entity_specific_responsibilities'
+    belongs_to :entity, class_name: 'Sipity::Entity'
+    belongs_to :workflow_role, class_name: 'Sipity::WorkflowRole'
+    belongs_to :agent, class_name: 'Sipity::Agent'
+  end
+end

data/app/models/sipity/method.rb

@@ -0,0 +1,5 @@
+module Sipity
+  class Method < ActiveRecord::Base
+    self.table_name = 'sipity_workflow_methods'
+  end
+end

data/app/models/sipity/notifiable_context.rb

@@ -0,0 +1,26 @@
+module Sipity
+  # A bridge for defining the "contexts" in which emails are sent.
+  #
+  # When an object enters a new state, we want to be able to define what are
+  # the emails that should be sent.
+  #
+  # In Sipity this could be modeled by defining a NotifiableContext for a
+  # WorkflowState and Email.
+  #
+  # @example
+  #   workflow_state = Sipity::WorkflowState.new
+  #   notification = Sipity::Notification.new
+  #
+  #   Sipity::NotifiableContext.new(
+  #     scope_for_notification: workflow_state,
+  #     reason_for_notification: 'on_enter',
+  #     notification: notification
+  #   )
+  class NotifiableContext < ActiveRecord::Base
+    self.table_name = 'sipity_notifiable_contexts'
+    belongs_to :scope_for_notification, polymorphic: true
+    belongs_to :notification, class_name: 'Sipity::Notification'
+
+    REASON_ACTION_IS_TAKEN = 'action_is_taken'.freeze
+  end
+end

data/app/models/sipity/notification.rb

@@ -0,0 +1,28 @@
+module Sipity
+  # Responsible for defining a notification that is associated with a given
+  # context; I believe the context is something that will be triggered via
+  # an action however, I don't believe this needs to be a "hard"
+  # relationship. It is instead a polymorphic relationship.
+  class Notification < ActiveRecord::Base
+    self.table_name = 'sipity_notifications'
+
+    has_many :notifiable_contexts,
+             dependent: :destroy,
+             foreign_key: :notification_id,
+             class_name: 'Sipity::NotifiableContext'
+
+    has_many :recipients,
+             dependent: :destroy,
+             foreign_key: :notification_id,
+             class_name: 'Sipity::NotificationRecipient'
+
+    NOTIFICATION_TYPE_EMAIL = 'email'.freeze
+
+    # TODO: There are other types, but for now, we are assuming just emails to send.
+    enum(notification_type: { NOTIFICATION_TYPE_EMAIL => NOTIFICATION_TYPE_EMAIL })
+
+    def self.valid_notification_types
+      notification_types.keys
+    end
+  end
+end

data/app/models/sipity/notification_recipient.rb

@@ -0,0 +1,17 @@
+module Sipity
+  # Responsible for defining who receives what email and in what capacity
+  # (eg to:, cc:, bcc:)
+  class NotificationRecipient < ActiveRecord::Base
+    self.table_name = 'sipity_notification_recipients'
+    belongs_to :notification, class_name: 'Sipity::Notification'
+    belongs_to :role, class_name: 'Sipity::Role'
+
+    enum(
+      recipient_strategy: {
+        'to' => 'to',
+        'cc' => 'cc',
+        'bcc' => 'bcc'
+      }
+    )
+  end
+end

data/app/models/sipity/role.rb

@@ -0,0 +1,43 @@
+module Sipity
+  # A role is a responsibility to do things. That is to take actions. It is
+  # easy to conflate a person's role with the groups to which they belong.
+  # A group is a set of people. The association of group with role
+  # indicates that the set of people have the same responsibilities.
+  #
+  # By separating Group and Role, we expose a more rich system in which we
+  # can talk about group membership separate from the group's
+  # responsibility.
+  #
+  # Another way to think of it is that a Group is a marco that expands to
+  # represent people. A Role is a macro that expands to represent
+  # responsibilities. In keeping them separate we can model more rich
+  # relationships.
+  #
+  # @note Roles should be verbs. They are what you do.
+  #
+  # @note This model representes the "roles" that users of the system can
+  #   have. It is not the "role" that they had in relation to the scholarly
+  #   work that is being deposited (i.e. co-author on a paper).
+  #
+  # @see Sipity::Agent
+  class Role < ActiveRecord::Base
+    self.table_name = 'sipity_roles'
+
+    has_many :workflow_roles,
+             dependent: :destroy,
+             class_name: 'Sipity::WorkflowRole'
+
+    has_many :email_recipients,
+             dependent: :destroy,
+             foreign_key: :role_id,
+             class_name: 'Sipity::NotificationRecipient'
+
+    def self.[](name)
+      find_or_create_by!(name: name.to_s)
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/app/models/sipity/workflow.rb

@@ -0,0 +1,19 @@
+module Sipity
+  # A named workflow for processing an entity. Originally I had thought of
+  # calling this a Type, but once I extracted the Processing submodule,
+  # type felt to much of a noun, not conveying potentiality. Workflow
+  # conveys "things will happen" because of this.
+  class Workflow < ActiveRecord::Base
+    self.table_name = 'sipity_workflows'
+
+    has_many :entities, dependent: :destroy, class_name: 'Sipity::Entity'
+    has_many :workflow_states, dependent: :destroy, class_name: 'Sipity::WorkflowState'
+    has_many :workflow_actions, dependent: :destroy, class_name: 'Sipity::WorkflowAction'
+    has_many :workflow_roles, dependent: :destroy, class_name: 'Sipity::WorkflowRole'
+
+    DEFAULT_INITIAL_WORKFLOW_STATE = 'new'.freeze
+    def initial_workflow_state
+      workflow_states.find_or_create_by!(name: DEFAULT_INITIAL_WORKFLOW_STATE)
+    end
+  end
+end

data/app/models/sipity/workflow_action.rb

@@ -0,0 +1,25 @@
+module Sipity
+  # A named thing that happens within the bounds of a :workflow.
+  #
+  # When a Sipity::WorkflowAction is taken, it may:
+  # * Advance the state to a new Sipity::WorkflowState (as defined by
+  #   the :resulting_workflow_state relation)
+  # * Deliver one or more notifications (as defined by the
+  #   :notifiable_contexts relation)
+  #
+  # @see CurationConcerns::Forms::WorkflowActionForm
+  class WorkflowAction < ActiveRecord::Base
+    self.table_name = 'sipity_workflow_actions'
+
+    belongs_to :workflow, class_name: 'Sipity::Workflow'
+    belongs_to :resulting_workflow_state, class_name: 'Sipity::WorkflowState'
+
+    has_many :workflow_state_actions, dependent: :destroy, class_name: 'Sipity::WorkflowStateAction'
+    has_many :triggered_methods, dependent: :destroy, class_name: 'Sipity::Method'
+
+    has_many :notifiable_contexts,
+             dependent: :destroy,
+             as: :scope_for_notification,
+             class_name: 'Sipity::NotifiableContext'
+  end
+end

data/app/models/sipity/workflow_responsibility.rb

@@ -0,0 +1,23 @@
+module Sipity
+  # In what capacity can an agent act upon all entities for the given
+  # Workflow
+  #
+  # This is an analogue to the Sipity::EntitySpecificResponsibility, but
+  # the responsibility only applies to all entities for the given
+  # Workflow
+  #
+  # @example
+  #   An Advisor for a given Student would have an
+  #   EntitySpecificResponsibility to review an ETD submitted by the
+  #   given Student.
+  #   The Graduate School Reviewer would have a WorkflowResponsibility
+  #   to review all ETDs submitted.
+  #
+  # @see Sipity::Role for discussion of roles
+  # @see Sipity::EntitySpecificResponsibility
+  class WorkflowResponsibility < ActiveRecord::Base
+    self.table_name = 'sipity_workflow_responsibilities'
+    belongs_to :agent, class_name: 'Sipity::Agent'
+    belongs_to :workflow_role, class_name: 'Sipity::WorkflowRole'
+  end
+end

data/app/models/sipity/workflow_role.rb

@@ -0,0 +1,13 @@
+module Sipity
+  # For a given processing workflow, what roles have a part to play in
+  # the processing?
+  class WorkflowRole < ActiveRecord::Base
+    self.table_name = 'sipity_workflow_roles'
+
+    belongs_to :role, class_name: 'Sipity::Role'
+    belongs_to :workflow, class_name: 'Sipity::Workflow'
+    has_many :workflow_responsibilities, dependent: :destroy, class_name: 'Sipity::WorkflowResponsibility'
+    has_many :workflow_state_action_permissions, dependent: :destroy, class_name: 'Sipity::WorkflowStateActionPermission'
+    has_many :entity_specific_responsibilities, dependent: :destroy, class_name: 'Sipity::EntitySpecificResponsibility'
+  end
+end

data/app/models/sipity/workflow_state.rb

@@ -0,0 +1,26 @@
+module Sipity
+  # Throughout the workflow process, a processed entity may have numerous
+  # states.
+  class WorkflowState < ActiveRecord::Base
+    self.table_name = 'sipity_workflow_states'
+
+    belongs_to :workflow, class_name: 'Sipity::Workflow'
+    has_many :originating_workflow_state_actions,
+             dependent: :destroy,
+             class_name: 'Sipity::WorkflowStateAction',
+             foreign_key: :originating_workflow_state_id
+
+    has_many :resulting_workflow_actions,
+             dependent: :destroy,
+             class_name: 'Sipity::WorkflowAction',
+             foreign_key: :resulting_workflow_state_id
+
+    # TODO: What should be done with entities in the given state if the WorkflowState is destroyed?
+    has_many :entities, class_name: 'Sipity::Workflow'
+
+    has_many :notifiable_contexts,
+             dependent: :destroy,
+             as: :scope_for_notification,
+             class_name: 'Sipity::NotifiableContext'
+  end
+end