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 UNIQUE_CONDITIONS = 1;
        const SHARED_CONDITIONS = 0;
        
        var $db;
        var $lng;
        
 
        var $error_message;
 
        var $target_obj_id;
        var $target_ref_id;
        var $target_type;
        var $trigger_obj_id;
        var $trigger_ref_id;
        var $trigger_type;
        var $operator;
        var $value;
        var $validation;
        
 
        private $obligatory = true;
        private $hidden_status = FALSE;
 
        var $conditions;
        static $cond_for_target_cache = array();
        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
        function setErrorMessage($a_msg)
        {
                $this->error_message = $a_msg;
        }
        function getErrorMessage()
        {
                return $this->error_message;
        }
 
        function setTargetRefId($a_target_ref_id)
        {
                return $this->target_ref_id = $a_target_ref_id;
        }
        
        function getTargetRefId()
        {
                return $this->target_ref_id;
        }
        
        function setTargetObjId($a_target_obj_id)
        {
                return $this->target_obj_id = $a_target_obj_id;
        }
        
        function getTargetObjId()
        {
                return $this->target_obj_id;
        }
 
        function setTargetType($a_target_type)
        {
                return $this->target_type = $a_target_type;
        }
        
        function getTargetType()
        {
                return $this->target_type;
        }
        
        function setTriggerRefId($a_trigger_ref_id)
        {
                return $this->trigger_ref_id = $a_trigger_ref_id;
        }
        
        function getTriggerRefId()
        {
                return $this->trigger_ref_id;
        }
 
        function setTriggerObjId($a_trigger_obj_id)
        {
                return $this->trigger_obj_id = $a_trigger_obj_id;
        }
        
        function getTriggerObjId()
        {
                return $this->trigger_obj_id;
        }
 
        function setTriggerType($a_trigger_type)
        {
                return $this->trigger_type = $a_trigger_type;
        }
        
        function getTriggerType()
        {
                return $this->trigger_type;
        }
        
        function setOperator($a_operator)
        {
                return $this->operator = $a_operator;
        }
        
        function getOperator()
        {
                return $this->operator;
        }
        
        function setValue($a_value)
        {
                return $this->value = $a_value;
        }
        
        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;
        }
 
 
        function enableAutomaticValidation($a_validate = true)
        {
                $this->validation = $a_validate;
        }
 
        function getTriggerTypes()
        {
                global $objDefinition;
                
                $trigger_types =  array('crs','exc','tst','sahs', 'svy', 'lm', 'iass');
 
                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';
                                $refection = new ReflectionClass($name);
                                if($refection->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;
        }
 
        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;
        }
 
        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;
        }
        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;
        }
        
        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;
        }
 
        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;
        }
        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;
        }
 
        function deleteCondition($a_id)
        {
                global $ilDB;
 
                $query = "DELETE FROM conditions ".
                        "WHERE condition_id = ".$ilDB->quote($a_id,'integer');
                $res = $ilDB->manipulate($query);
 
                return true;
        }
        
        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;
        }
 
        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();
                                }
                        }
                }
        }
 
        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;
        }
 
 
 
        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;
        }
 
        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
        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;
        }
 
        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);
                }
        }
}
 
?>