hyrax 0.0.0 → 1.0.0.rc1

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

@@ -0,0 +1,95 @@
+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 [Sipity::Workflow] workflow
+      # @param [Hash] actions_configuration 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(workflow:, actions_configuration:, &block)
+        new(workflow: workflow, actions_configuration: actions_configuration, &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 = extract_new_state_names
+          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
+
+        # @note Not all states are things that we tansition_to; They can be transitioned from_states as well.
+        def extract_new_state_names
+          (
+            actions_configuration.map { |a| a.fetch(:transition_to, nil) } +
+            actions_configuration.map { |a| a.fetch(:from_states, []).map { |fs| fs.fetch(:names, nil) } }
+          ).flatten.compact.uniq
+        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,102 @@
+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!
+        build_workflow_attributes
+        build_strategy_state_entries
+        build_transition_to_state
+        build_email_generator
+        build_action_methods
+      end
+
+      private
+
+        def build_workflow_attributes
+          return unless config.key?(:attributes)
+          action_attributes = config.fetch(:attributes).stringify_keys
+          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_transition_to_state
+          return unless config.key?(:transition_to)
+          name = config.fetch(:transition_to).to_s
+          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
+
+        def build_strategy_state_entries
+          config.fetch(:from_states, []).each do |entry|
+            build_from_state(entry.fetch(:names), entry.fetch(:roles))
+          end
+        end
+
+        # @param [Array] state_names
+        # @param [Array] state_roles
+        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_action_methods
+          return unless config.key?(:methods)
+          method_list = Array.wrap(config.fetch(:methods))
+          MethodGenerator.call(action: action, list: method_list)
+        end
+
+        def build_email_generator
+          send(email_generator_method_name, workflow: workflow, config: config)
+        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,57 @@
+module Hyrax
+  module Workflow
+    # Responsible for coordinating the behavior of an action taken within a 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_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,78 @@
+module Hyrax
+  module Workflow
+    # Responsible for:
+    #
+    # * Creating a workflow entity
+    # * Assigning specific roles to the entity (but not the workflow)
+    # * Running the deposit_action
+    #
+    # @see Hyrax::Workflow::WorkflowActionService
+    # @see Hyrax::Workflow::PermissionGenerator
+    # @see Hyrax::RoleRegistry
+    class WorkflowFactory
+      class_attribute :depositing_role
+      self.depositing_role = Hyrax::RoleRegistry::DEPOSITING
+      # @api public
+      #
+      # @param work [#to_global_id]
+      # @param attributes [Hash]
+      # @param user [User]
+      # @return [TrueClass]
+      def self.create(work, attributes, user)
+        new(work, attributes, user).create
+      end
+
+      # @param work [#to_global_id, #active_workflow]
+      # @param user [User]
+      # @param attributes [Hash]
+      def initialize(work, attributes, user)
+        @work = work
+        @attributes = attributes
+        @user = user
+      end
+
+      attr_reader :work, :attributes, :user
+      private :work, :attributes, :user
+
+      # Creates a Sipity::Entity for the work.
+      # The Sipity::Entity acts as a proxy to a work within a workflow
+      # @return [TrueClass]
+      def create
+        entity = create_workflow_entity!
+        assign_specific_roles_to(entity: entity)
+        run_workflow_action!
+        true
+      end
+
+      private
+
+        def create_workflow_entity!
+          Sipity::Entity.create!(proxy_for_global_id: work.to_global_id.to_s,
+                                 workflow: work.active_workflow,
+                                 workflow_state: nil)
+        end
+
+        def assign_specific_roles_to(entity:)
+          Hyrax::Workflow::PermissionGenerator.call(agents: user,
+                                                    entity: entity,
+                                                    roles: depositing_role,
+                                                    workflow: work.active_workflow)
+        end
+
+        def run_workflow_action!
+          subject = WorkflowActionInfo.new(work, user)
+          Workflow::WorkflowActionService.run(subject: subject,
+                                              action: find_deposit_action)
+        end
+
+        # 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: work.active_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,180 @@
+module Hyrax
+  module Workflow
+    # Responsible for loading workflows from a data source.
+    #
+    # @see .load_workflows
+    # @see .generate_from_json_file
+    class WorkflowImporter
+      class_attribute :default_logger
+      self.default_logger = Rails.logger
+      class_attribute :path_to_workflow_files
+      self.path_to_workflow_files = Rails.root.join('config', 'workflows', '*.json')
+
+      class << self
+        def clear_load_errors!
+          self.load_errors = []
+        end
+
+        attr_reader :load_errors
+
+        private
+
+          attr_writer :load_errors
+      end
+
+      # @api public
+      # Load all of the workflows for the given permission_template
+      #
+      # @param [Hyrax::PermissionTemplate] permission_template
+      # @param [#info, #debug, #warning, #fatal] logger - By default this is Hyrax::Workflow::WorkflowImporter.default_logger
+      # @return [TrueClass] if one or more workflows were loaded
+      # @return [FalseClass] if no workflows were loaded
+      # @note I'd like to deprecate .load_workflows but for now that is beyond the scope of what I'm after. So I will use its magic instead
+      def self.load_workflow_for(permission_template:, logger: default_logger)
+        workflow_config_filenames = Dir.glob(path_to_workflow_files)
+        if workflow_config_filenames.none?
+          logger.info("Unable to load workflows for #{permission_template.class} ID=#{permission_template.id}. No workflows were found in #{path_to_workflow_files}")
+          return false
+        end
+        workflow_config_filenames.each do |config|
+          logger.info "Loading permission_template ID=#{permission_template.id} with workflow config #{config}"
+          generate_from_json_file(path: config, permission_template: permission_template, logger: default_logger)
+        end
+        true
+      end
+
+      # @api public
+      #
+      # Load all the workflows in config/workflows/*.json for each of the permission templates
+      # @param  [#each] permission_templates - An enumerator of permission templates (by default Hyrax::PermissionTemplate.all)
+      # @return [TrueClass]
+      def self.load_workflows(permission_templates: Hyrax::PermissionTemplate.all, **kwargs)
+        clear_load_errors!
+        Array.wrap(permission_templates).each do |permission_template|
+          load_workflow_for(permission_template: permission_template, **kwargs)
+        end
+        true
+      end
+
+      # @api public
+      #
+      # Responsible for generating the work type and corresponding processing entries based on given pathname or JSON document.
+      #
+      # @param [#read or String] path - the location on the file system that can be read
+      # @param [Hyrax::PermissionTemplate] permission_template - the permission_template that will be associated with each of these entries
+      # @return [Array<Sipity::Workflow>]
+      def self.generate_from_json_file(path:, permission_template:, **keywords)
+        contents = path.respond_to?(:read) ? path.read : File.read(path)
+        data = JSON.parse(contents)
+        generate_from_hash(data: data, permission_template: permission_template, **keywords)
+      end
+
+      # @api public
+      #
+      # Responsible for generating the work type and corresponding processing entries based on given pathname or JSON document.
+      #
+      # @param [#deep_symbolize_keys] data - the configuration information from which we will generate all the data entries
+      # @param [Hyrax::PermissionTemplate] permission_template - the permission_template that will be associated with each of these entries
+      # @return [Array<Sipity::Workflow>]
+      def self.generate_from_hash(data:, permission_template:, **keywords)
+        importer = new(data: data, permission_template: permission_template, **keywords)
+        workflows = importer.call
+        self.load_errors ||= []
+        load_errors.concat(importer.errors)
+        workflows
+      end
+
+      # @param [#deep_symbolize_keys] data - the configuration information from which we will generate all the data entries
+      # @param [Hyrax::PermissionTemplate] permission_template - the permission_template that will be associated with each of these entries
+      # @param [#call] schema - The schema in which you will validate the data
+      # @param [#call] validator - The validation service for the given data and schema
+      # @param [#debug, #info, #fatal, #warning] logger - The logger to capture any meaningful output
+      def initialize(data:, permission_template:, schema: default_schema, validator: default_validator, logger: default_logger)
+        self.data = data
+        self.schema = schema
+        self.validator = validator
+        self.permission_template = permission_template
+        @logger = logger
+        validate!
+      end
+
+      private
+
+        attr_reader :data, :logger
+
+        def data=(input)
+          @data = input.deep_symbolize_keys
+        end
+
+        attr_accessor :validator, :permission_template, :schema
+
+        def default_validator
+          SchemaValidator.method(:call)
+        end
+
+        def default_schema
+          Hyrax::Workflow::WorkflowSchema
+        end
+
+        def validate!
+          validator.call(data: data, schema: schema, logger: logger)
+        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), permission_template: permission_template)
+          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.allows_access_grant = configuration.fetch(:allows_access_grant, nil)
+          workflow.save!
+          logger.info(%(Loaded Sipity::Workflow "#{workflow.name}" for #{permission_template.class} ID=#{permission_template.id}))
+          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:, logger:)
+            result = schema.call(data)
+            return true if result.success?
+            message = result.messages(full: true).inspect
+            logger.error(message)
+            raise message
+          end
+        end
+    end
+  end
+end