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'));