test_hyrax 0.0.1.alpha

data/app/services/hyrax/workflow/sipity_actions_generator.rb

@@ -0,0 +1,87 @@
+module Hyrax
+  module Workflow
+    # Responsible for creating database entries for the given workflow's actions
+    class SipityActionsGenerator
+      # @api public
+      #
+      # Responsible for creating database entries for the given workflow's actions
+      #
+      # @param workflow [Sipity::Workflow]
+      # @param actions_configuration [Hash] as defined in Hyrax::Workflow::WorkflowSchema
+      # @return [Sipity::Workflow]
+      # @raise [Hyrax::Workflow::InvalidStateRemovalException] Trying to remove a state that is in use
+      def self.call(**keywords, &block)
+        new(**keywords, &block).call
+      end
+
+      def initialize(workflow:, actions_configuration:)
+        self.workflow = workflow
+        self.actions_configuration = actions_configuration
+      end
+
+      private
+
+        attr_accessor :workflow
+
+        attr_reader :actions_configuration
+
+        def actions_configuration=(input)
+          @actions_configuration = Array.wrap(input)
+        end
+
+      public
+
+      # @return [Sipity::Workflow]
+      # @raise [Hyrax::Workflow::InvalidStateRemovalException] Trying to remove a state that is in use
+      def call
+        generate_state_diagram!
+        workflow
+      end
+
+      private
+
+        def generate_state_diagram!
+          # look for old states that need to be removed and validate the states can be removed.
+          unused_states_to_remove = validate_states_to_be_removed
+
+          # remove any actions that will no longer be needed by the workflow
+          remove_unused_actions!
+
+          actions_configuration.each do |configuration|
+            Array.wrap(configuration.fetch(:name)).each do |name|
+              StateMachineGenerator.generate_from_schema(workflow: workflow, name: name, **configuration.except(:name))
+            end
+          end
+
+          # remove any states that are no longer needed by the workflow
+          #  Note I am doing this after the update so nothing is still linking to the
+          #       state to keep it from being deleted.
+          unused_states_to_remove.each(&:destroy)
+        end
+
+        def validate_states_to_be_removed
+          new_state_names = actions_configuration.map { |a| a[:transition_to] }.flatten
+          states_to_remove = []
+          states_that_cannot_be_destroyed = []
+          workflow.workflow_states.each do |state|
+            next if new_state_names.include?(state.name)
+            states_to_remove << state
+            states_that_cannot_be_destroyed << state if state.entities.count > 0 # Choosing count so we pre-warm the query
+          end
+          if states_that_cannot_be_destroyed.any?
+            exception_message = "Cannot delete one or more states because they have one or more entities associated with them."
+            raise InvalidStateRemovalException.new(exception_message, states_that_cannot_be_destroyed)
+          end
+          states_to_remove
+        end
+
+        def remove_unused_actions!
+          # clear any actions from the workflow that do not exists in the new configuration
+          new_action_names = actions_configuration.map { |a| a[:name] }.flatten
+          workflow.workflow_actions.each do |workflow_action|
+            workflow_action.destroy unless new_action_names.include?(workflow_action.name)
+          end
+        end
+    end
+  end
+end

data/app/services/hyrax/workflow/state_machine_generator.rb

@@ -0,0 +1,99 @@
+module Hyrax
+  module Workflow
+    # Imports a single action for a workflow, including all of the adjacent states,
+    # permissions and notifications
+    class StateMachineGenerator
+      def self.generate_from_schema(workflow:, name:, **keywords)
+        new(
+          workflow: workflow, action_name: name, config: keywords,
+          email_generator_method_name: :schema_based_email_generator_method
+        ).call
+      end
+
+      def initialize(workflow:, action_name:, config:, email_generator_method_name: :schema_based_email_generator_method)
+        self.workflow = workflow
+        self.action_name = action_name
+        self.config = config
+        self.email_generator_method_name = email_generator_method_name
+      end
+
+      private
+
+        attr_accessor :workflow, :action_name, :config, :email_generator_method_name
+
+        def create_workflow_action!
+          @action = Sipity::WorkflowAction.find_or_create_by!(workflow: workflow, name: action_name.to_s)
+        end
+
+      public
+
+      attr_reader :action
+
+      def call
+        create_workflow_action!
+
+        if config.key?(:attributes)
+          build_attributes(config.fetch(:attributes).stringify_keys)
+        end
+
+        # Strategy State
+        config.fetch(:from_states, []).each do |entry|
+          build_from_state(entry.fetch(:names), entry.fetch(:roles))
+        end
+
+        # Transitions
+        if config.key?(:transition_to)
+          build_transitions(config.fetch(:transition_to).to_s)
+        end
+
+        send(email_generator_method_name, workflow: workflow, config: config)
+
+        # Methods
+        return unless config.key?(:methods)
+        build_methods(Array.wrap(config.fetch(:methods)))
+      end
+
+      def build_attributes(action_attributes)
+        action_attributes.delete('presentation_sequence') # TODO: remove this line when we want to support presentation_sequence
+        existing_action_attributes = action.attributes.slice(*action_attributes.keys)
+        return if action_attributes == existing_action_attributes
+        action.update_attributes!(action_attributes)
+      end
+
+      def build_transitions(name)
+        transition_to_state = Sipity::WorkflowState.find_or_create_by!(workflow: workflow, name: name)
+        return if action.resulting_workflow_state == transition_to_state
+        action.resulting_workflow_state = transition_to_state
+        action.save!
+      end
+
+      # @params state_names[Array]
+      # @params roles [Array]
+      def build_from_state(state_names, state_roles)
+        Array.wrap(state_names).each do |state_name|
+          workflow_state = Sipity::WorkflowState.find_or_create_by!(workflow: workflow, name: state_name.to_s)
+          PermissionGenerator.call(
+            actors: [],
+            roles: state_roles,
+            workflow_state: workflow_state,
+            action_names: action_name,
+            workflow: workflow
+          )
+        end
+      end
+
+      def build_methods(method_list)
+        MethodGenerator.call(action: action, list: method_list)
+      end
+
+      def schema_based_email_generator_method(workflow:, config:)
+        Array.wrap(config.fetch(:notifications, [])).each do |configuration|
+          notification_configuration = NotificationConfigurationParameter.build_from_workflow_action_configuration(
+            workflow_action: action_name, config: configuration
+          )
+          NotificationGenerator.call(workflow: workflow, notification_configuration: notification_configuration)
+        end
+      end
+    end
+  end
+end

data/app/services/hyrax/workflow/status_list_service.rb

@@ -0,0 +1,65 @@
+module Hyrax
+  module Workflow
+    # Finds a list of works that we can perform a workflow action on
+    class StatusListService
+      # @param context [#current_user, #logger]
+      # @param filter_condition [String] a solr filter
+      def initialize(context, filter_condition)
+        @context = context
+        @filter_condition = filter_condition
+      end
+
+      attr_reader :context
+
+      # TODO: We will want to paginate this
+      # @return [Array<StatusRow>] a list of results that the given user can take action on.
+      def each
+        return enum_for(:each) unless block_given?
+        solr_documents.each do |doc|
+          yield doc
+        end
+      end
+
+      # TODO: Make this private for version 1.0
+      def user
+        context.current_user
+      end
+
+      private
+
+        delegate :logger, to: :context
+
+        # @return [Hash<String,SolrDocument>] a hash of id to solr document
+        def solr_documents
+          search_solr.map { |result| ::SolrDocument.new(result) }
+        end
+
+        def search_solr
+          actionable_roles = roles_for_user
+          logger.debug("Actionable roles for #{user.user_key} are #{actionable_roles}")
+          return [] if actionable_roles.empty?
+          WorkRelation.new.search_with_conditions(query(actionable_roles), rows: 1000)
+        end
+
+        def query(actionable_roles)
+          ["{!terms f=actionable_workflow_roles_ssim}#{actionable_roles.join(',')}",
+           @filter_condition]
+        end
+
+        # @return [Array<String>] the list of workflow-role combinations this user has
+        def roles_for_user
+          Sipity::Workflow.all.flat_map do |wf|
+            workflow_roles_for_user_and_workflow(wf).map do |wf_role|
+              "#{wf.name}-#{wf_role.role.name}"
+            end
+          end
+        end
+
+        # @param workflow [Sipity::Workflow]
+        # @return [ActiveRecord::Relation<Sipity::WorkflowRole>]
+        def workflow_roles_for_user_and_workflow(workflow)
+          Hyrax::Workflow::PermissionQuery.scope_processing_workflow_roles_for_user_and_workflow(user: user, workflow: workflow)
+        end
+    end
+  end
+end

data/app/services/hyrax/workflow/workflow_action_service.rb

@@ -0,0 +1,56 @@
+module Hyrax
+  module Workflow
+    class WorkflowActionService
+      def self.run(subject:, action:, comment: nil)
+        new(subject: subject, action: action, comment: comment).run
+      end
+
+      def initialize(subject:, action:, comment:)
+        @subject = subject
+        @action = action
+        @comment_text = comment
+      end
+
+      attr_reader :subject, :action, :comment_text
+
+      def run
+        update_sipity_workflow_state
+        comment = create_sipity_comment
+        handle_sipity_notifications(comment: comment)
+        handle_additional_sipity_workflow_action_processing(comment: comment)
+        subject.work.update_index # So that the new actions and state are written into solr.
+      end
+
+      protected
+
+        def update_sipity_workflow_state
+          return true unless action.resulting_workflow_state_id.present?
+          subject.entity.update!(workflow_state_id: action.resulting_workflow_state_id)
+        end
+
+        def create_sipity_comment
+          return true unless comment_text.present?
+          Sipity::Comment.create!(entity: subject.entity, agent: subject.agent, comment: comment_text)
+        end
+
+        def handle_sipity_notifications(comment:)
+          Hyrax::Workflow::NotificationService.deliver_on_action_taken(
+            entity: subject.entity,
+            comment: comment,
+            action: action,
+            user: subject.user
+          )
+        end
+
+        # Run any configured custom methods
+        def handle_additional_sipity_workflow_action_processing(comment:)
+          Hyrax::Workflow::ActionTakenService.handle_action_taken(
+            target: subject.work,
+            comment: comment,
+            action: action,
+            user: subject.user
+          )
+        end
+    end
+  end
+end

data/app/services/hyrax/workflow/workflow_by_admin_set_strategy.rb

@@ -0,0 +1,15 @@
+module Hyrax
+  module Workflow
+    class WorkflowByAdminSetStrategy
+      def initialize(_work, attributes)
+        @admin_set_id = attributes[:admin_set_id] if attributes[:admin_set_id].present?
+      end
+
+      # @return [String] The name of the workflow by admin_set to use
+      def workflow_name
+        return 'default' unless @admin_set_id
+        Hyrax::PermissionTemplate.find_by!(admin_set_id: @admin_set_id).workflow_name
+      end
+    end
+  end
+end

data/app/services/hyrax/workflow/workflow_by_model_name_strategy.rb

@@ -0,0 +1,14 @@
+module Hyrax
+  module Workflow
+    class WorkflowByModelNameStrategy
+      def initialize(work, _attributes)
+        @work = work
+      end
+
+      # @return [String] The name of the workflow to use
+      def workflow_name
+        'default'
+      end
+    end
+  end
+end

data/app/services/hyrax/workflow/workflow_factory.rb

@@ -0,0 +1,64 @@
+module Hyrax
+  module Workflow
+    class WorkflowFactory
+      class_attribute :workflow_strategy
+      self.workflow_strategy = DefaultWorkflowStrategy
+
+      # @param work [#to_global_id]
+      # @param attributes [Hash]
+      # @param strategy [#name] strategy for finding which workflow to use. Defaults to an instance of DefaultWorkflowStrategy
+      # @return [TrueClass]
+      def self.create(work, attributes, user, strategy = nil)
+        strategy ||= workflow_strategy.new(work, attributes)
+        new(work, attributes, user, strategy).create
+      end
+
+      # @param work [#to_global_id]
+      # @param attributes [Hash]
+      # @param strategy [#name] strategy for finding which workflow to use
+      def initialize(work, attributes, user, strategy)
+        @work = work
+        @attributes = attributes
+        @user = user
+        @strategy = strategy
+      end
+
+      attr_reader :work, :attributes, :user, :strategy
+      private :work, :attributes, :strategy
+
+      # Creates a Sipity::Entity for the work.
+      # The Sipity::Entity acts as a proxy to a work within a workflow
+      # @return [TrueClass]
+      def create
+        Sipity::Entity.create!(proxy_for_global_id: work.to_global_id.to_s,
+                               workflow: workflow,
+                               workflow_state: nil)
+
+        subject = WorkflowActionInfo.new(work, user)
+        Workflow::WorkflowActionService.run(subject: subject,
+                                            action: find_deposit_action)
+        true
+      end
+
+      # This tells us which workflow to use. If no workflow is found with the expected name
+      # then load the workflows in config/workflows/*.json and try again.
+      # @return [Sipity::Workflow]
+      def workflow
+        @workflow ||= Sipity::Workflow.find_by(name: workflow_name) ||
+                      (Hyrax::Workflow::WorkflowImporter.load_workflows &&
+                       Sipity::Workflow.find_by!(name: workflow_name))
+      end
+
+      delegate :workflow_name, to: :strategy
+
+      # Find an action that has no starting state. This is the deposit action.
+      # # @return [Sipity::WorkflowAction]
+      def find_deposit_action
+        actions_that_lead_to_states = Sipity::WorkflowStateAction.all.pluck(:workflow_action_id)
+        relation = Sipity::WorkflowAction.where(workflow: workflow)
+        relation = relation.where('id NOT IN (?)', actions_that_lead_to_states) if actions_that_lead_to_states.any?
+        relation.first!
+      end
+    end
+  end
+end

data/app/services/hyrax/workflow/workflow_importer.rb

@@ -0,0 +1,144 @@
+module Hyrax
+  module Workflow
+    # Responsible for loading workflows from a data source.
+    #
+    # @see .load_workflows
+    # @see .generate_from_json_file
+    class WorkflowImporter
+      class << self
+        def clear_load_errors!
+          self.load_errors = []
+        end
+
+        attr_reader :load_errors
+
+        private
+
+          attr_writer :load_errors
+      end
+
+      # @api public
+      #
+      # Load all the workflows in config/workflows/*.json
+      # @return [TrueClass]
+      def self.load_workflows
+        clear_load_errors!
+        Dir.glob(Rails.root.join('config', 'workflows', '*.json')) do |config|
+          Rails.logger.info "Loading workflow: #{config}"
+          generate_from_json_file(path: config)
+        end
+        true
+      end
+
+      # @api public
+      #
+      # Responsible for generating the work type and corresponding processing entries based on given pathname or JSON document.
+      #
+      # @return [Array<Sipity::Workflow>]
+      def self.generate_from_json_file(path:, **keywords)
+        contents = path.respond_to?(:read) ? path.read : File.read(path)
+        data = JSON.parse(contents)
+        generate_from_hash(data: data, **keywords)
+      end
+
+      # @api public
+      #
+      # Responsible for generating the work type and corresponding processing entries based on given pathname or JSON document.
+      #
+      # @return [Array<Sipity::Workflow>]
+      def self.generate_from_hash(data:, **keywords)
+        importer = new(data: data, **keywords)
+        workflows = importer.call
+        self.load_errors ||= []
+        load_errors.concat(importer.errors)
+        workflows
+      end
+
+      # @param data [#deep_symbolize_keys] the configuration information from which we will generate all the data entries
+      # @param schema [#call] The schema in which you will validate the data
+      # @param validator [#call] The validation service for the given data and schema
+      def initialize(data:, schema: default_schema, validator: default_validator)
+        self.data = data
+        self.schema = schema
+        self.validator = validator
+        validate!
+      end
+
+      private
+
+        attr_reader :data
+
+        def data=(input)
+          @data = input.deep_symbolize_keys
+        end
+
+        attr_accessor :validator
+
+        def default_validator
+          SchemaValidator.method(:call)
+        end
+
+        attr_accessor :schema
+
+        def default_schema
+          Hyrax::Workflow::WorkflowSchema
+        end
+
+        def validate!
+          validator.call(data: data, schema: schema)
+        end
+
+      public
+
+      attr_accessor :errors
+
+      def call
+        self.errors = []
+        Array.wrap(data.fetch(:workflows)).map do |configuration|
+          begin
+            find_or_create_from(configuration: configuration)
+          rescue InvalidStateRemovalException => e
+            e.states.each do |state|
+              error = I18n.t('hyrax.workflow.load.state_error', workflow_name: state.workflow.name, state_name: state.name, entity_count: state.entities.count)
+              Rails.logger.error(error)
+              errors << error
+            end
+            Sipity::Workflow.find_by(name: configuration[:name])
+          end
+        end
+      end
+
+      private
+
+        def find_or_create_from(configuration:)
+          workflow = Sipity::Workflow.find_or_initialize_by(name: configuration.fetch(:name))
+          generate_state_diagram!(workflow: workflow, actions_configuration: configuration.fetch(:actions))
+
+          find_or_create_workflow_permissions!(
+            workflow: workflow, workflow_permissions_configuration: configuration.fetch(:workflow_permissions, [])
+          )
+          workflow.label = configuration.fetch(:label, nil)
+          workflow.description = configuration.fetch(:description, nil)
+          workflow.save!
+          workflow
+        end
+
+        extend Forwardable
+        def_delegator WorkflowPermissionsGenerator, :call, :find_or_create_workflow_permissions!
+        def_delegator SipityActionsGenerator, :call, :generate_state_diagram!
+
+        module SchemaValidator
+          # @param data [Hash]
+          # @param schema [#call]
+          #
+          # @return true if the data validates from the schema
+          # @raise Exceptions::InvalidSchemaError if the data does not validate against the schema
+          def self.call(data:, schema:)
+            validation = schema.call(data)
+            return true unless validation.messages.present?
+            raise validation.messages.inspect
+          end
+        end
+    end
+  end
+end