class.ilBaseWorkflow.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2016 ILIAS open source, Extended GPL, see docs/LICENSE */
 
require_once './Services/WorkflowEngine/interfaces/ilExternalDetector.php';
require_once './Services/WorkflowEngine/interfaces/ilWorkflow.php';
require_once './Services/WorkflowEngine/classes/nodes/class.ilBasicNode.php';
 
abstract class ilBaseWorkflow implements ilWorkflow
{
        protected $nodes;
 
        protected $detectors;
 
        protected $start_node;
 
        protected $active;
 
        protected $db_id;
 
        protected $workflow_type;
 
        protected $workflow_content;
 
        protected $workflow_class;
 
        protected $workflow_location;
 
        protected $workflow_subject_type;
 
        protected $workflow_subject_identifier;
 
        protected $workflow_context_type;
 
        protected $workflow_context_identifier;
 
        protected $instance_vars = array();
 
        protected $data_inputs;
 
        protected $data_outputs;
 
        protected $require_data_persistence = false;
 
        public function __construct()
        {
        }
 
        public function startWorkflow()
        {
                // Write the workflow to the database, so detectors find a parent id to save with them.
                require_once './Services/WorkflowEngine/classes/utils/class.ilWorkflowDbHelper.php';
                $this->active = true;
                ilWorkflowDbHelper::writeWorkflow($this);
                $this->onStartWorkflow();
 
                // Figure out, if there is a start-node set - or nodes at all.
                if ($this->start_node == null)
                {
                        if (count($this->nodes) != 0)
                        {
                                $this->start_node = $this->nodes[0];
                        } else {
                                //ilWorkflowDbHelper::deleteWorkflow($this);
                                throw new Exception ('No start_node, no node, no start. Doh.');
                        }
                }
                $this->start_node->activate();
                ilWorkflowDbHelper::writeWorkflow($this);
        }
 
        public function stopWorkflow()
        {
                $this->active = false;
                foreach ($this->nodes as $node)
                {
                        $node->deactivate();
                }
                $this->onStopWorkflow();
        }
 
        public function onStartWorkflow()
        {
                return;
        }
 
        public function onStopWorkflow()
        {
                return;
        }
 
        public function onWorkflowFinished()
        {
                return;
        }
 
        public function isActive()
        {
                return (bool)$this->active;
        }
 
        public function handleEvent($params)
        {
                $active_nodes_available = false;
                // Hier nur an aktive Nodes dispatchen.
                foreach ((array)$this->detectors as $detector)
                {
                        $node = $detector->getContext();
                        if ($node->isActive())
                        {
                                $detector->trigger($params);
                                $node = $detector->getContext();
                                if ($node->isActive())
                                {
                                        $active_nodes_available = true;
                                }
                        }
                }
 
                if ($active_nodes_available == false)
                {
                        $this->active = false;
                        $this->onWorkflowFinished();
                }
        }
 
        public function registerDetector(ilDetector $detector)
        {
                $reflection_class = new ReflectionClass($detector);
                if (in_array('ilExternalDetector', $reflection_class->getInterfaceNames()))
                {
                        $this->detectors[] = $detector;
                }
        }
 
        public function getWorkflowData()
        {
                return array('type' => $this->workflow_type, 'content' => $this->workflow_content);
        }
 
        public function getWorkflowSubject()
        {
                return array('type' => $this->workflow_subject_type, 'identifier' => $this->workflow_subject_identifier);
        }
 
        public function getWorkflowContext()
        {
                return array('type' => $this->workflow_context_type, 'identifier' => $this->workflow_context_identifier);
        }
 
        public function setDbId($id)
        {
                $this->db_id = $id;
        }
 
        public function getDbId()
        {
                if ($this->db_id != null)
                {
                        return $this->db_id;
                } 
                else
                {
                        require_once './Services/WorkflowEngine/exceptions/ilWorkflowObjectStateException.php';
                        throw new ilWorkflowObjectStateException('No database ID set.');
                }
        }
 
        public function hasDbId()
        {
                if ($this->db_id == null)
                {
                        return false;
                }
                return true;
        }
 
        public function setStartNode(ilNode $node)
        {
                $this->start_node = $node;
        }
 
        public function addNode(ilNode $node)
        {
                $this->nodes[] = $node;
        }
 
        public function setWorkflowClass($class)
        {
                $this->workflow_class = $class;
        }
 
        public function getWorkflowClass()
        {
                return $this->workflow_class;
        }
 
        public function setWorkflowLocation($path)
        {
                $this->workflow_location = $path;
        }
 
        public function getWorkflowLocation()
        {
                return $this->workflow_location;
        }
 
        public function getNodes()
        {
                return $this->nodes;
        }
 
        public static function autoload($class_name)
        {
                switch(true)
                {
                        case strtolower(substr($class_name, strlen($class_name) - 8, 8)) == 'activity':
                                $componentDirectory = 'activities';
                                break;
 
                        case strtolower(substr($class_name, strlen($class_name) - 8, 8)) == 'detector':
                                $componentDirectory = 'detectors';
                                break;
 
                        case strtolower(substr($class_name, strlen($class_name) - 7, 7)) == 'emitter':
                                $componentDirectory = 'emitters';
                                break;
 
                        case strtolower(substr($class_name, strlen($class_name) - 4, 4)) == 'node':
                                $componentDirectory = 'node';
                                break;
                                
                        default:
                                return;
                }
 
                $filename = './Services/WorkflowEngine/classes/' . $componentDirectory . '/class.'.$class_name.'.php';
                if(file_exists($filename))
                {
                        require_once $filename;
                }
        }
 
        public function isDataPersistenceRequired()
        {
                return $this->require_data_persistence;
        }
 
        public function resetDataPersistenceRequirement()
        {
                $this->require_data_persistence = false;
        }
 
        #region InstanceVars
 
        /*
         * Instancevars work like this:
         * array(
         *      'id' => 'string',
         *      'name' => 'string',
         *      'value' => mixed
         * );
         * 
         */
 
        public function defineInstanceVar($id, $name, $reference = false, $reference_target = '',
                                                                          $type = 'mixed', $role = 'undefined')
        {
                $this->instance_vars[] = array(
                        'id' => $id, 
                        'name' => $name, 
                        'value' => null, 
                        'reference' => $reference, 
                        'target' => $reference_target,
                        'type' => $type,
                        'role' => $role
                );
        }
 
        public function hasInstanceVarByName($name)
        {
                foreach($this->instance_vars as $instance_var)
                {
                        if($instance_var['name'] == $name)
                        {
                                return true;
                        }
                }
                return false;
        }
 
        public function hasInstanceVarById($id)
        {
                foreach($this->instance_vars as $instance_var)
                {
                        if($instance_var['id'] == $id)
                        {
                                return true;
                        }
                }
                return false;
        }
 
        public function getInstanceVarByName($name)
        {
                foreach($this->instance_vars as &$instance_var)
                {
                        if($instance_var['name'] == $name)
                        {
                                if($instance_var['reference'] === true)
                                {
                                        return $this->getInstanceVarByName($instance_var['target']);
                                }
                                else
                                {
                                        return $instance_var['value'];
                                }
                        }
                }
                return false;
        }
 
        public function getInstanceVarById($id)
        {
                foreach($this->instance_vars as $instance_var)
                {
                        if($instance_var['id'] == $id)
                        {
                                if($instance_var['reference'] === true)
                                {
                                        return $this->getInstanceVarById($instance_var['target']);
                                }
                                else
                                {
                                        return $instance_var['value'];
                                }
                        }
                }
                return false;
        }
 
        public function setInstanceVarByName($name, $value)
        {
                foreach($this->instance_vars as &$instance_var)
                {
                        if($instance_var['name'] == $name)
                        {
                                if($instance_var['reference'] === true)
                                {
                                        $this->setInstanceVarById($instance_var['target'], $value);
                                } 
                                else 
                                {
                                        $instance_var['value'] = $value;
                                }
                        }
                }
        }
 
        public function setInstanceVarById($id, $value)
        {
                foreach($this->instance_vars as &$instance_var)
                {
                        if($instance_var['id'] == $id)
                        {
                                if($instance_var['reference'] === true)
                                {
                                        $this->setInstanceVarById($instance_var['target'], $value);
                                }
                                else
                                {
                                        $instance_var['value'] = $value;
                                        return;
                                }
                        }
                }
        }
 
        public function setInstanceVarByRole($role, $value)
        {
                foreach($this->instance_vars as &$instance_var)
                {
                        if($instance_var['role'] == $role)
                        {
                                if($instance_var['reference'] === true)
                                {
                                        $this->setInstanceVarById($instance_var['target'], $value);
                                }
                                else
                                {
                                        $instance_var['value'] = $value;
                                        return;
                                }
                        }
                }
        }
 
        public function getInstanceVars()
        {
                return (array) $this->instance_vars;
        }
 
        public function flushInstanceVars()
        {
                $this->instance_vars = array();
        }
 
        #endregion
 
        #region Data IO
 
        public function defineInputVar($name)
        {
                $this->data_inputs[$name] = null;
                $this->require_data_persistence = true;
        }
 
        public function defineOutputVar($name)
        {
                $this->data_outputs[$name] = null;
                $this->require_data_persistence = true;
        }
 
        public function readInputVar($name)
        {
                if($this->data_inputs[$name])
                {
                        return $this->data_inputs[$name];
                }
                return null;
        }
 
        public function hasInputVar($name)
        {
                return array_key_exists($name, (array)$this->data_inputs);
        }
 
        public function hasOutputVar($name)
        {
                return array_key_exists($name, (array)$this->data_outputs);
        }
 
        public function writeInputVar($name, $value)
        {
                $this->data_inputs[$name] = $value;
                $this->require_data_persistence = true;
        }
 
        public function readOutputVar($name)
        {
                if($this->data_outputs[$name])
                {
                        return $this->data_outputs[$name];
                }
                return null;
        }
 
        public function writeOutputVar($name, $value)
        {
                $this->data_outputs[$name] = $value;
                $this->require_data_persistence = true;
        }
 
        public function getInputVars()
        {
                return (array)$this->data_inputs;
        }
 
        public function getOutputVars()
        {
                return (array)$this->data_outputs;
        }
 
        public function registerInputVar($name, $definition)
        {
                $definition['name'] = $name;
                $this->data_inputs[$name] = $definition;
        }
 
        public function registerOutputVar($name)
        {
                $this->data_outputs[] = $name;
        }
 
        #endregion
}
 
spl_autoload_register(array('ilBaseWorkflow', 'autoload'));