class.ilConditionHandler.php

Go to the documentation of this file.

<?php
 
/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */
 
class ilConditionHandler
{
    const OPERATOR_PASSED = 'passed';
    const OPERATOR_FINISHED = 'finished';
    const OPERATOR_NOT_FINISHED = 'not_finished';
    const OPERATOR_NOT_MEMBER = 'not_member';
    const OPERATOR_FAILED = 'failed';
    const OPERATOR_LP = 'learning_progress';
    const OPERATOR_ACCREDITED_OR_PASSED = 'accredited_or_passed';
    
    const UNIQUE_CONDITIONS = 1;
    const SHARED_CONDITIONS = 0;
    
    public $db;
    public $lng;
    
 
    public $error_message;
 
    public $target_obj_id;
    public $target_ref_id;
    public $target_type;
    public $trigger_obj_id;
    public $trigger_ref_id;
    public $trigger_type;
    public $operator;
    public $value;
    public $validation;
    
 
    private $obligatory = true;
    private $hidden_status = false;
 
    public $conditions;
    public static $cond_for_target_cache = array();
    public static $cond_target_rows = array();
 
 
    public function __construct()
    {
        global $ilDB,$lng;
 
        $this->db =&$ilDB;
        $this->lng =&$lng;
        $this->validation = true;
    }
 
    public static function _isReferenceHandlingOptional($a_type)
    {
        switch ($a_type) {
            case 'st':
                return true;
            
            default:
                return false;
        }
    }
    
    public static function lookupHiddenStatusByTarget($a_target_ref_id)
    {
        global $ilDB;
        
        $query = 'SELECT hidden_status FROM conditions ' .
                'WHERE target_ref_id = ' . $ilDB->quote($a_target_ref_id, 'integer');
        $res = $ilDB->query($query);
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            return $row->hidden_status;
        }
        return false;
    }
    
    public static function _adjustMovedObjectConditions($a_ref_id)
    {
        global $tree;
        
        if ($tree->checkForParentType($a_ref_id, 'crs')) {
            // Nothing to do
            return true;
        }
        
        // Need another implementation that has better performance
        $childs = $tree->getSubTree($tree->getNodeData($a_ref_id), false);
        $conditions = self::_getDistinctTargetRefIds();
        
        foreach (array_intersect($conditions, $childs) as $target_ref) {
            if (!$tree->checkForParentType($target_ref, 'crs')) {
                self::_deleteTargetConditionsByRefId($target_ref);
            }
        }
        return true;
    }
    
    public static function _getDistinctTargetRefIds()
    {
        global $ilDB;
        
        $query = "SELECT DISTINCT target_ref_id ref FROM conditions ";
        $res = $ilDB->query($query);
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $ref_ids[] = $row->ref;
        }
        return $ref_ids ? $ref_ids : array();
    }
    
    public static function _deleteTargetConditionsByRefId($a_target_ref_id)
    {
        global $ilDB;
        
        $query = "DELETE FROM conditions " .
            "WHERE target_ref_id = " . $ilDB->quote($a_target_ref_id, 'integer') . " " .
            "AND target_type != 'st' ";
        $res = $ilDB->manipulate($query);
        return true;
    }
 
    public function setReferenceHandlingType($a_type)
    {
        return $this->condition_reference_type = $a_type;
    }
    
    public function getReferenceHandlingType()
    {
        return (int) $this->condition_reference_type;
    }
 
    // SET GET
    public function setErrorMessage($a_msg)
    {
        $this->error_message = $a_msg;
    }
    public function getErrorMessage()
    {
        return $this->error_message;
    }
 
    public function setTargetRefId($a_target_ref_id)
    {
        return $this->target_ref_id = $a_target_ref_id;
    }
    
    public function getTargetRefId()
    {
        return $this->target_ref_id;
    }
    
    public function setTargetObjId($a_target_obj_id)
    {
        return $this->target_obj_id = $a_target_obj_id;
    }
    
    public function getTargetObjId()
    {
        return $this->target_obj_id;
    }
 
    public function setTargetType($a_target_type)
    {
        return $this->target_type = $a_target_type;
    }
    
    public function getTargetType()
    {
        return $this->target_type;
    }
    
    public function setTriggerRefId($a_trigger_ref_id)
    {
        return $this->trigger_ref_id = $a_trigger_ref_id;
    }
    
    public function getTriggerRefId()
    {
        return $this->trigger_ref_id;
    }
 
    public function setTriggerObjId($a_trigger_obj_id)
    {
        return $this->trigger_obj_id = $a_trigger_obj_id;
    }
    
    public function getTriggerObjId()
    {
        return $this->trigger_obj_id;
    }
 
    public function setTriggerType($a_trigger_type)
    {
        return $this->trigger_type = $a_trigger_type;
    }
    
    public function getTriggerType()
    {
        return $this->trigger_type;
    }
    
    public function setOperator($a_operator)
    {
        return $this->operator = $a_operator;
    }
    
    public function getOperator()
    {
        return $this->operator;
    }
    
    public function setValue($a_value)
    {
        return $this->value = $a_value;
    }
    
    public function getValue()
    {
        return $this->value;
    }
    
    public function setObligatory($a_obl)
    {
        $this->obligatory = $a_obl;
    }
 
    public function getObligatory()
    {
        return (bool) $this->obligatory;
    }
    
    public function setHiddenStatus($a_status)
    {
        $this->hidden_status = $a_status;
    }
    
    public function getHiddenStatus()
    {
        return $this->hidden_status;
    }
 
 
    public function enableAutomaticValidation($a_validate = true)
    {
        $this->validation = $a_validate;
    }
 
    public function getTriggerTypes()
    {
        global $objDefinition;
        
        $trigger_types =  array('crs','exc','tst','sahs', 'svy', 'lm', 'iass', 'prg');
 
        foreach ($objDefinition->getPlugins() as $p_type => $p_info) {
            if (@include_once $p_info['location'] . '/class.ilObj' . $p_info['class_name'] . 'Access.php') {
                include_once './Services/AccessControl/interfaces/interface.ilConditionHandling.php';
                $name = 'ilObj' . $p_info['class_name'] . 'Access';
                $reflection = new ReflectionClass($name);
                if ($reflection->implementsInterface('ilConditionHandling')) {
                    $trigger_types[] = $p_type;
                }
            }
        }
        
        
        $active_triggers = array();
        foreach ($trigger_types as $type) {
            if (count($this->getOperatorsByTargetType($type))) {
                $active_triggers[] = $type;
            }
        }
        
        
        
        
        return $active_triggers;
    }
 
 
    public function getOperatorsByTargetType($a_type)
    {
        global $objDefinition;
        
        switch ($a_type) {
            case 'crsg':
                return array('not_member');
        }
        
        $class = $objDefinition->getClassName($a_type);
        $location = $objDefinition->getLocation($a_type);
        $full_class = "ilObj" . $class . "Access";
        include_once($location . "/class." . $full_class . ".php");
        
        include_once './Services/AccessControl/interfaces/interface.ilConditionHandling.php';
        
        $reflection = new ReflectionClass($full_class);
        if (!$reflection->implementsInterface('ilConditionHandling')) {
            return array();
        }
        
        
        $operators = call_user_func(
            array($full_class, 'getConditionOperators'),
            $a_type
        );
        
        // Add operator lp
        include_once("Services/Tracking/classes/class.ilObjUserTracking.php");
        if (ilObjUserTracking::_enabledLearningProgress()) {
            // only if object type has lp
            include_once("Services/Object/classes/class.ilObjectLP.php");
            if (ilObjectLP::isSupportedObjectType($a_type)) {
                array_unshift($operators, self::OPERATOR_LP);
            }
        }
        return $operators;
    }
 
    public function storeCondition()
    {
        global $ilDB;
        
        // first insert, then validate: it's easier to check for circles if the new condition is in the db table
        $next_id = $ilDB->nextId('conditions');
        $query = 'INSERT INTO conditions (condition_id,target_ref_id,target_obj_id,target_type,' .
            'trigger_ref_id,trigger_obj_id,trigger_type,operator,value,ref_handling,obligatory,hidden_status) ' .
            'VALUES (' .
            $ilDB->quote($next_id, 'integer') . ',' .
            $ilDB->quote($this->getTargetRefId(), 'integer') . "," .
            $ilDB->quote($this->getTargetObjId(), 'integer') . "," .
            $ilDB->quote($this->getTargetType(), 'text') . "," .
            $ilDB->quote($this->getTriggerRefId(), 'integer') . "," .
            $ilDB->quote($this->getTriggerObjId(), 'integer') . "," .
            $ilDB->quote($this->getTriggerType(), 'text') . "," .
            $ilDB->quote($this->getOperator(), 'text') . "," .
            $ilDB->quote($this->getValue(), 'text') . ", " .
            $ilDB->quote($this->getReferenceHandlingType(), 'integer') . ', ' .
            $ilDB->quote($this->getObligatory(), 'integer') . ', ' .
            $ilDB->quote($this->getHiddenStatus(), 'integer') . ' ' .
            ')';
 
        $res = $ilDB->manipulate($query);
 
        if ($this->validation && !$this->validate()) {
            $this->deleteCondition($next_id);
            return false;
        }
        return true;
    }
 
    public function checkExists()
    {
        global $ilDB;
        
        $query = "SELECT * FROM conditions " .
            "WHERE target_ref_id = " . $ilDB->quote($this->getTargetRefId(), 'integer') . " " .
            "AND target_obj_id = " . $ilDB->quote($this->getTargetObjId(), 'integer') . " " .
            "AND trigger_ref_id = " . $ilDB->quote($this->getTriggerRefId(), 'integer') . " " .
            "AND trigger_obj_id = " . $ilDB->quote($this->getTriggerObjId(), 'integer') . " " .
            "AND operator = " . $ilDB->quote($this->getOperator(), 'text');
        $res = $ilDB->query($query);
 
        return $res->numRows() ? true : false;
    }
    public function updateCondition($a_id)
    {
        global $ilDB;
        
        $query = "UPDATE conditions SET " .
            "target_ref_id = " . $ilDB->quote($this->getTargetRefId(), 'integer') . ", " .
            "operator = " . $ilDB->quote($this->getOperator(), 'text') . ", " .
            "value = " . $ilDB->quote($this->getValue(), 'text') . ", " .
            "ref_handling = " . $this->db->quote($this->getReferenceHandlingType(), 'integer') . ", " .
            'obligatory = ' . $this->db->quote($this->getObligatory(), 'integer') . ' ' .
            "WHERE condition_id = " . $ilDB->quote($a_id, 'integer');
        $res = $ilDB->manipulate($query);
 
        return true;
    }
    
    public function updateHiddenStatus($a_status)
    {
        global $ilDB;
        
        $query = 'UPDATE conditions SET ' .
                'hidden_status = ' . $ilDB->quote($a_status, 'integer') . ' ' .
                'WHERE target_ref_id = ' . $ilDB->quote($this->getTargetRefId(), 'integer');
        $ilDB->manipulate($query);
        return true;
    }
    
    public static function updateObligatory($a_id, $a_status)
    {
        global $ilDB;
        
        $query = "UPDATE conditions SET " .
            'obligatory = ' . $ilDB->quote($a_status, 'integer') . ' ' .
            "WHERE condition_id = " . $ilDB->quote($a_id, 'integer');
        $res = $ilDB->manipulate($query);
 
        return true;
    }
 
    public function delete($a_ref_id)
    {
        global $ilDB;
        
        $query = "DELETE FROM conditions WHERE " .
            "target_ref_id = " . $ilDB->quote($a_ref_id, 'integer') . " " .
            "OR trigger_ref_id = " . $ilDB->quote($a_ref_id, 'integer');
        $res = $ilDB->manipulate($query);
 
        return true;
    }
    public function deleteByObjId($a_obj_id)
    {
        global $ilDB;
        
        $query = "DELETE FROM conditions WHERE " .
            "target_obj_id = " . $ilDB->quote($a_obj_id, 'integer') . " " .
            "OR trigger_obj_id = " . $ilDB->quote($a_obj_id, 'integer');
        $res = $ilDB->manipulate($query);
 
        return true;
    }
 
    public function deleteCondition($a_id)
    {
        global $ilDB;
 
        $query = "DELETE FROM conditions " .
            "WHERE condition_id = " . $ilDB->quote($a_id, 'integer');
        $res = $ilDB->manipulate($query);
 
        return true;
    }
 
    public static function getNumberOfConditionsOfTrigger($a_trigger_obj_type, $a_trigger_id)
    {
        global $DIC;
        $db = $DIC->database();
 
        $query = 'select count(*) num from conditions ' .
            'where trigger_obj_id = ' . $db->quote($a_trigger_id, ilDBConstants::T_INTEGER) . ' ' .
            'and trigger_type = ' . $db->quote($a_trigger_obj_type, ilDBConstants::T_TEXT);
        $res = $db->query($query);
        $row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT);
        return (int) $row->num;
    }
    
    public static function _getConditionsOfTrigger($a_trigger_obj_type, $a_trigger_id)
    {
        global $ilDB;
 
        $query = "SELECT * FROM conditions " .
            "WHERE trigger_obj_id = " . $ilDB->quote($a_trigger_id, 'integer') . " " .
            " AND trigger_type = " . $ilDB->quote($a_trigger_obj_type, 'text');
 
        $res = $ilDB->query($query);
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $tmp_array['id']                    = $row->condition_id;
            $tmp_array['target_ref_id'] = $row->target_ref_id;
            $tmp_array['target_obj_id'] = $row->target_obj_id;
            $tmp_array['target_type']   = $row->target_type;
            $tmp_array['trigger_ref_id'] = $row->trigger_ref_id;
            $tmp_array['trigger_obj_id'] = $row->trigger_obj_id;
            $tmp_array['trigger_type']  = $row->trigger_type;
            $tmp_array['operator']              = $row->operator;
            $tmp_array['value']                 = $row->value;
            $tmp_array['ref_handling']  = $row->ref_handling;
            $tmp_array['obligatory']    = $row->obligatory;
            $tmp_array['hidden_status'] = $row->hidden_status;
 
            $conditions[] = $tmp_array;
            unset($tmp_array);
        }
 
        return $conditions ? $conditions : array();
    }
 
    public static function _getConditionsOfTarget($a_target_ref_id, $a_target_obj_id, $a_target_type = "")
    {
        global $ilDB, $ilBench;
 
        // get type if no type given
        if ($a_target_type == "") {
            $a_target_type = ilObject::_lookupType($a_target_obj_id);
        }
 
        // check conditions for target cache
        if (isset(self::$cond_for_target_cache[$a_target_ref_id . ":" . $a_target_obj_id . ":" .
            $a_target_type])) {
            return self::$cond_for_target_cache[$a_target_ref_id . ":" . $a_target_obj_id . ":" .
                $a_target_type];
        }
 
        // check rows cache
        if (isset(self::$cond_target_rows[$a_target_type . ":" . $a_target_obj_id])) {
            $rows = self::$cond_target_rows[$a_target_type . ":" . $a_target_obj_id];
        } else {
            // query data from db
            $query = "SELECT * FROM conditions " .
                "WHERE target_obj_id = " . $ilDB->quote($a_target_obj_id, 'integer') . " " .
                " AND target_type = " . $ilDB->quote($a_target_type, 'text');
 
            $res = $ilDB->query($query);
            $rows = array();
            while ($row = $ilDB->fetchAssoc($res)) {
                $rows[] = $row;
            }
        }
 
        reset($rows);
        $conditions = array();
        foreach ($rows as $row) {
            if ($row["ref_handling"] == self::UNIQUE_CONDITIONS) {
                if ($row["target_ref_id"] != $a_target_ref_id) {
                    continue;
                }
            }
            
            $row["id"] = $row["condition_id"];
            $conditions[] = $row;
        }
 
        // write conditions for target cache
        self::$cond_for_target_cache[$a_target_ref_id . ":" . $a_target_obj_id . ":" .
            $a_target_type] = $conditions;
 
        return $conditions;
    }
 
    public static function preloadConditionsForTargetRecords($a_type, $a_obj_ids)
    {
        global $ilDB;
 
        if (is_array($a_obj_ids) && count($a_obj_ids) > 0) {
            $res = $ilDB->query("SELECT * FROM conditions " .
                "WHERE " . $ilDB->in("target_obj_id", $a_obj_ids, false, "integer") .
                " AND target_type = " . $ilDB->quote($a_type, 'text'));
            $rows = array();
            while ($row = $ilDB->fetchAssoc($res)) {
                self::$cond_target_rows[$a_type . ":" . $row["target_obj_id"]][]
                    = $row;
            }
            // init obj ids without any record
            foreach ($a_obj_ids as $obj_id) {
                if (!is_array(self::$cond_target_rows[$a_type . ":" . $obj_id])) {
                    self::$cond_target_rows[$a_type . ":" . $obj_id] = array();
                }
            }
        }
    }
 
    public static function _getCondition($a_id)
    {
        global $ilDB;
 
        $query = "SELECT * FROM conditions " .
            "WHERE condition_id = " . $ilDB->quote($a_id, 'integer');
 
        $res = $ilDB->query($query);
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $tmp_array['id']                    = $row->condition_id;
            $tmp_array['target_ref_id'] = $row->target_ref_id;
            $tmp_array['target_obj_id'] = $row->target_obj_id;
            $tmp_array['target_type']   = $row->target_type;
            $tmp_array['trigger_ref_id'] = $row->trigger_ref_id;
            $tmp_array['trigger_obj_id'] = $row->trigger_obj_id;
            $tmp_array['trigger_type']  = $row->trigger_type;
            $tmp_array['operator']              = $row->operator;
            $tmp_array['value']                 = $row->value;
            $tmp_array['ref_handling']  = $row->ref_handling;
            $tmp_array['obligatory']    = $row->obligatory;
            $tmp_array['hidden_status'] = $row->hidden_status;
 
            return $tmp_array;
        }
        return false;
    }
 
 
 
    public static function _checkCondition($a_id, $a_usr_id = 0)
    {
        global $ilUser, $objDefinition;
        
        $a_usr_id = $a_usr_id ? $a_usr_id : $ilUser->getId();
        
        $condition = ilConditionHandler::_getCondition($a_id);
        
        // check lp
        if ($condition['operator'] == self::OPERATOR_LP) {
            include_once './Services/Tracking/classes/class.ilLPStatus.php';
            return ilLPStatus::_hasUserCompleted($condition['trigger_obj_id'], $a_usr_id);
        }
        
        switch ($condition['trigger_type']) {
            case 'crsg':
                include_once './Modules/Course/classes/class.ilObjCourseGrouping.php';
                return ilObjCourseGrouping::_checkCondition($condition['trigger_obj_id'], $condition['operator'], $condition['value'], $a_usr_id);
        }
        
        $class = $objDefinition->getClassName($condition['trigger_type']);
        $location = $objDefinition->getLocation($condition['trigger_type']);
        $full_class = "ilObj" . $class . "Access";
        include_once($location . "/class." . $full_class . ".php");
 
        $fullfilled = call_user_func(
            array($full_class, 'checkCondition'),
            $condition['trigger_obj_id'],
            $condition['operator'],
            $condition['value'],
            $a_usr_id
        );
        return $fullfilled;
    }
 
    public static function getOptionalConditionsOfTarget($a_target_ref_id, $a_target_obj_id, $a_obj_type = '')
    {
        $conditions = self::_getConditionsOfTarget($a_target_ref_id, $a_target_obj_id);
        
        $opt = array();
        foreach ($conditions as $con) {
            if ($con['obligatory']) {
                continue;
            }
            
            $opt[] = $con;
        }
        return $opt;
    }
    
    public static function lookupObligatoryConditionsOfTarget($a_target_ref_id, $a_target_obj_id)
    {
        global $ilDB;
        
        $query = 'SELECT max(num_obligatory) obl from conditions WHERE ' .
            'target_ref_id = ' . $ilDB->quote($a_target_ref_id, 'integer') . ' ' .
            'AND target_obj_id = ' . $ilDB->quote($a_target_obj_id, 'integer') . ' ' .
            'GROUP BY (num_obligatory)';
        $res = $ilDB->query($query);
        
        $obl = 0;
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $obl = $row->obl;
        }
        return $obl;
    }
 
    public static function calculateRequiredTriggers($a_target_ref_id, $a_target_obj_id, $a_target_obj_type = '', $a_force_update = false)
    {
        global $ilDB;
 
        // Get all conditions
        $all = self::_getConditionsOfTarget($a_target_ref_id, $a_target_obj_id, $a_target_obj_type);
        $opt = self::getOptionalConditionsOfTarget($a_target_ref_id, $a_target_obj_id, $a_target_obj_type);
 
        $set_obl = 0;
        if (isset($all[0])) {
            $set_obl = $all[0]['num_obligatory'];
        }
        
        // existing value is valid
        if ($set_obl > 0 and
            $set_obl < count($all) and
            $set_obl > (count($all) - count($opt)  + 1)) {
            return $set_obl;
        }
        
        if (count($opt)) {
            $result = count($all) - count($opt) + 1;
        } else {
            $result = count($all);
        }
        if ($a_force_update) {
            self::saveNumberOfRequiredTriggers($a_target_ref_id, $a_target_obj_id, $result);
        }
        return $result;
    }
 
    public static function saveNumberOfRequiredTriggers($a_target_ref_id, $a_target_obj_id, $a_num)
    {
        global $ilDB;
 
        $query = 'UPDATE conditions ' .
            'SET num_obligatory = ' . $ilDB->quote($a_num, 'integer') . ' ' .
            'WHERE target_ref_id = ' . $ilDB->quote($a_target_ref_id, 'integer') . ' ' .
            'AND target_obj_id = ' . $ilDB->quote($a_target_obj_id, 'integer');
        $ilDB->manipulate($query);
        return;
    }
 
    public static function _checkAllConditionsOfTarget($a_target_ref_id, $a_target_id, $a_target_type = "", $a_usr_id = 0)
    {
        global $ilBench,$ilUser,$tree;
        
        $a_usr_id = $a_usr_id ? $a_usr_id : $ilUser->getId();
 
        $conditions = ilConditionHandler::_getConditionsOfTarget($a_target_ref_id, $a_target_id, $a_target_type);
 
        if (!count($conditions)) {
            return true;
        }
 
        // @todo check this
        include_once './Services/Container/classes/class.ilMemberViewSettings.php';
        if (ilMemberViewSettings::getInstance()->isActive()) {
            return true;
        }
 
        // First check obligatory conditions
        $optional = self::getOptionalConditionsOfTarget($a_target_ref_id, $a_target_id, $a_target_type);
        $num_required = self::calculateRequiredTriggers($a_target_ref_id, $a_target_id, $a_target_type);
        $passed = 0;
        foreach ($conditions as $condition) {
            if ($tree->isDeleted($condition['trigger_ref_id'])) {
                continue;
            }
            $check = ilConditionHandler::_checkCondition($condition['id'], $a_usr_id);
 
            if ($check) {
                ++$passed;
                if ($passed >= $num_required) {
                    return true;
                }
            } else {
                if (!count($optional)) {
                    return false;
                }
            }
        }
        // not all optional conditions passed
        return false;
    }
 
    // PRIVATE
    public function validate()
    {
        global $ilDB;
        
        // check if obj_id is already assigned
        $trigger_obj =&ilObjectFactory::getInstanceByRefId($this->getTriggerRefId());
        $target_obj =&ilObjectFactory::getInstanceByRefId($this->getTargetRefId());
 
 
        $query = "SELECT * FROM conditions WHERE " .
            "trigger_ref_id = " . $ilDB->quote($trigger_obj->getRefId(), 'integer') . " " .
            "AND target_ref_id = " . $ilDB->quote($target_obj->getRefId(), 'integer');
 
        $res = $this->db->query($query);
        if ($res->numRows() > 1) {
            $this->setErrorMessage($this->lng->txt('condition_already_assigned'));
 
            unset($trigger_obj);
            unset($target_obj);
            return false;
        }
 
        // check for circle
        $this->target_obj_id = $target_obj->getId();
        if ($this->checkCircle($this->getTargetRefId(), $target_obj->getId())) {
            $this->setErrorMessage($this->lng->txt('condition_circle_created'));
            
            unset($trigger_obj);
            unset($target_obj);
            return false;
        }
        return true;
    }
 
    public function checkCircle($a_ref_id, $a_obj_id)
    {
        foreach (ilConditionHandler::_getConditionsOfTarget($a_ref_id, $a_obj_id) as $condition) {
            if ($condition['trigger_obj_id'] == $this->target_obj_id and $condition['operator'] == $this->getOperator()) {
                $this->circle = true;
                break;
            } else {
                $this->checkCircle($condition['trigger_ref_id'], $condition['trigger_obj_id']);
            }
        }
        return $this->circle;
    }
    
    public static function cloneDependencies($a_src_ref_id, $a_target_ref_id, $a_copy_id)
    {
        include_once './Services/CopyWizard/classes/class.ilCopyWizardOptions.php';
        $cwo = ilCopyWizardOptions::_getInstance($a_copy_id);
        $mappings = $cwo->getMappings();
 
        $valid = 0;
        $conditions = ilConditionHandler::_getConditionsOfTarget($a_src_ref_id, ilObject::_lookupObjId($a_src_ref_id));
        foreach ($conditions as $con) {
            if ($mappings[$con['trigger_ref_id']]) {
                $newCondition = new ilConditionHandler();
 
                $target_obj = ilObject::_lookupObjId($a_target_ref_id);
                $target_typ = ilObject::_lookupType($target_obj);
 
                $newCondition->setTargetRefId($a_target_ref_id);
                $newCondition->setTargetObjId($target_obj);
                $newCondition->setTargetType($target_typ);
 
                $trigger_ref = $mappings[$con['trigger_ref_id']];
                $trigger_obj = ilObject::_lookupObjId($trigger_ref);
                $trigger_typ = ilObject::_lookupType($trigger_obj);
 
                $newCondition->setTriggerRefId($trigger_ref);
                $newCondition->setTriggerObjId($trigger_obj);
                $newCondition->setTriggerType($trigger_typ);
                $newCondition->setOperator($con['operator']);
                $newCondition->setValue($con['value']);
                $newCondition->setReferenceHandlingType($con['ref_handling']);
                $newCondition->setObligatory($con['obligatory']);
                
                // :TODO: not sure about this
                $newCondition->setHiddenStatus(self::lookupHiddenStatusByTarget($a_src_ref_id));
                
                if ($newCondition->storeCondition()) {
                    $valid++;
                }
            }
        }
        if ($valid) {
            $tgt_obj_id = ilObject::_lookupObjId($a_target_ref_id);
            
            // num_obligatory
            self::calculateRequiredTriggers($a_target_ref_id, $tgt_obj_id, ilObject::_lookupType($tgt_obj_id), true);
        }
    }
}