class.ilBasicNode.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/classes/nodes/class.ilBaseNode.php';
 
class ilBasicNode extends ilBaseNode
{
        private $is_forward_condition_node;
 
        public $is_forward_condition_event;
 
        public $ident;
 
        public function __construct(ilWorkflow $context)
        {
                $this->context = $context;
                $this->detectors = array();
                $this->emitters = array();
                $this->activities = array();
                $this->active = false;
                $this->is_forward_condition_node = false;
                $this->is_forward_condition_event = false;
                $this->ident = strtoupper(substr(md5(spl_object_hash($this)),0,6));
        }
 
        public function activate()
        {
                if ($this->isActive())
                {
                        return;
                }
                
                $this->active = true;
 
                foreach($this->detectors as $detector)
                {
                        $detector->onActivate();
                }
                $this->onActivate();
                $this->attemptTransition();
        }
 
        public function deactivate()
        {
                $this->active = false;
                foreach($this->detectors as $detector)
                {
                        $detector->onDeactivate();
                }
                $this->onDeactivate();
        }
 
        public function checkTransitionPreconditions()
        {
                // queries the $detectors if their conditions are met.
                $isPreconditionMet = true;
                foreach ($this->detectors as $detector)
                {
                        if ($isPreconditionMet == true)
                        {
                                $isPreconditionMet = $detector->getDetectorState();
                        }
                }
                return $isPreconditionMet;
        }
 
        public function attemptTransition()
        {
                if ($this->checkTransitionPreconditions() == true)
                {
                        $this->executeTransition();
                        return true;
                }
                else
                {
                        return false;
                }
        }
 
        private function executeActivities()
        {
                if (count($this->activities) != 0)
                {
                        foreach ($this->activities as $activity)
                        {
                                $activity->execute();
                        }
                }
        }
 
        private function executeEmitters()
        {
                if (count($this->emitters) != 0)
                {
                        foreach ($this->emitters as $emitter)
                        {
                                $emitter->emit();
                        }
                }
        }
 
        public function executeTransition()
        {
                $this->deactivate();
                $this->executeActivities();
                $this->pingbackToPredecessorNodes();
                $this->executeEmitters();
        }
 
        public function notifyDetectorSatisfaction(ilDetector $detector)
        {
                if ($this->isActive())
                {
                        $this->attemptTransition();
                }
        }
 
        public function isForwardConditionNode()
        {
                return $this->is_forward_condition_node;
        }
 
        public function setIsForwardConditionNode($is_forward_condition_node)
        {
                $this->is_forward_condition_node = $is_forward_condition_node;
        }
 
        public function deactivateForwardConditionNodes(ilNode $activated_node)
        {
                if($this->is_forward_condition_node)
                {
                        foreach ($this->emitters as $emitter)
                        {
                                $target_detector = $emitter->getTargetDetector();
 
                                $target_node = $target_detector->getContext();
 
                                if ($target_node === $activated_node)
                                {
                                        continue;
                                }
                                $target_node->deactivate();
                        }
                }
        }
 
        public function pingbackToPredecessorNodes()
        {
                foreach ($this->detectors as $detector)
                {
                        $source_node = $detector->getSourceNode();
                        if ($source_node && $source_node->is_forward_condition_node)
                        {
                                $source_node->deactivateForwardConditionNodes( $this );
                        }
                }
        }
}