class.ilLOSettings.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2010 ILIAS open source, Extended GPL, see docs/LICENSE */
 
class ilLOSettings
{
        // new settings 5.1
        const QST_PASSED_FLAG = 1;
        const QST_PASSED_HIDE = 2;
        
        const TYPE_INITIAL_PLACEMENT_ALL = 1;
        const TYPE_INITIAL_PLACEMENT_SELECTED = 2;
        const TYPE_INITIAL_QUALIFYING_ALL = 3;
        const TYPE_INITIAL_QUALIFYING_SELECTED = 4;
        const TYPE_INITIAL_NONE = 5;
        
        const TYPE_QUALIFYING_ALL = 1;
        const TYPE_QUALIFYING_SELECTED = 2;
        
        // end new settings
        
        const TYPE_TEST_UNDEFINED = 0;
        const TYPE_TEST_INITIAL = 1;
        const TYPE_TEST_QUALIFIED = 2;
        
        const QT_VISIBLE_ALL = 0;
        const QT_VISIBLE_OBJECTIVE = 1;
        
        
        const LOC_INITIAL_ALL = 1;
        const LOC_INITIAL_SEL = 2;
        const LOC_QUALIFIED = 3;
        const LOC_PRACTISE = 4;
        
        const HIDE_PASSED_OBJECTIVE_QST = 1;
        const MARK_PASSED_OBJECTIVE_QST = 2;
        
        
        private static $instances = array();
        
        private $logger = null;
        
        
        // settings 5.1
        private $it_type = self::TYPE_INITIAL_PLACEMENT_ALL;
        private $qt_type = self::TYPE_QUALIFYING_ALL;
        
        private $it_start = FALSE;
        private $qt_start = FALSE;
        
        // end settings 5.1
        
        private $container_id = 0;
        private $type = 0;
        private $initial_test = 0;
        private $qualified_test = 0;
        private $reset_results = true;
        private $passed_obj_mode = self::HIDE_PASSED_OBJECTIVE_QST;
 
 
        private $entry_exists = false;
 
        
        protected function __construct($a_cont_id)
        {
                $this->logger = $GLOBALS['DIC']->logger()->crs();
                
                $this->container_id = $a_cont_id;
                $this->read();
        }
        
        public static function getInstanceByObjId($a_obj_id)
        {
                if(self::$instances[$a_obj_id])
                {
                        return self::$instances[$a_obj_id];
                }
                return self::$instances[$a_obj_id] = new ilLOSettings($a_obj_id);
        }
        
        public function setInitialTestType($a_type)
        {
                $this->it_type = $a_type;
        }
        
        public function getInitialTestType()
        {
                return $this->it_type;
        }
        
        public function getQualifyingTestType()
        {
                return $this->qt_type;
        }
        
        public function setQualifyingTestType($a_type)
        {
                $this->qt_type = $a_type;
        }
        
        public function setInitialTestAsStart($a_type)
        {
                $this->it_start = $a_type;
        }
        
        public function isInitialTestStart()
        {
                return $this->it_start;
        }
        
        public function setQualifyingTestAsStart($a_type)
        {
                $this->qt_start = $a_type;
        }
        
        public function isQualifyingTestStart()
        {
                return $this->qt_start;
        }
        
        public function hasSeparateInitialTests()
        {
                return $this->getInitialTestType() == self::TYPE_INITIAL_PLACEMENT_SELECTED || $this->getInitialTestType() == self::TYPE_INITIAL_QUALIFYING_SELECTED;
        }
        
        public function hasSeparateQualifiedTests()
        {
                return $this->getQualifyingTestType() == self::TYPE_QUALIFYING_SELECTED;
        }
 
        public function isInitialTestQualifying()
        {
                return $this->getInitialTestType() == self::TYPE_INITIAL_QUALIFYING_ALL || $this->getInitialTestType() == self::TYPE_INITIAL_QUALIFYING_SELECTED;
        }
        
        public static function isObjectiveTest($a_trst_ref_id)
        {
                global $ilDB;
                
                
                // Check for direct assignment
                $query = 'SELECT obj_id FROM loc_settings '.
                                'WHERE itest = '.$ilDB->quote($a_trst_ref_id,'integer').' '.
                                'OR qtest = '.$ilDB->quote($a_trst_ref_id,'integer');
                $res = $ilDB->query($query);
                while($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT))
                {
                        return $row->obj_id;
                }
                
                include_once './Modules/Course/classes/Objectives/class.ilLOTestAssignments.php';
                return ilLOTestAssignments::lookupContainerForTest($a_trst_ref_id);
        }
        
        public static function cloneSettings($a_copy_id, $a_container_id, $a_new_container_id)
        {
                include_once './Services/CopyWizard/classes/class.ilCopyWizardOptions.php';
                $options = ilCopyWizardOptions::_getInstance($a_copy_id);
                $mappings = $options->getMappings();
                
                $settings = self::getInstanceByObjId($a_container_id);
                $new_settings = self::getInstanceByObjId($a_new_container_id);
                
                $new_settings->setType($settings->getType());
                $new_settings->setInitialTestType($settings->getInitialTestType());
                $new_settings->setQualifyingTestType($settings->getQualifyingTestType());
                $new_settings->resetResults($settings->isResetResultsEnabled());
                $new_settings->setPassedObjectiveMode($settings->getPassedObjectiveMode());
                
                if($settings->getInitialTest() and array_key_exists($settings->getInitialTest(), $mappings))
                {
                        $new_settings->setInitialTest($mappings[$settings->getInitialTest()]);
                        $new_settings->setInitialTestAsStart($new_settings->isInitialTestStart());
                }
                
                if($settings->getQualifiedTest() and array_key_exists($settings->getQualifiedTest(), $mappings))
                {
                        $new_settings->setQualifiedTest($mappings[$settings->getQualifiedTest()]);
                        $new_settings->setQualifyingTestAsStart($settings->isQualifyingTestStart());
                }
                
                // update calls create in case of no entry exists.
                $new_settings->update();
        }
        
        public function worksWithStartObjects()
        {
                return $this->isInitialTestStart() or $this->isQualifyingTestStart();
        }
 
 
        public function worksWithInitialTest()
        {
                return $this->getInitialTestType() != self::TYPE_INITIAL_NONE;
        }
        
        public function isGeneralQualifiedTestVisible()
        {
                return $this->getQualifyingTestType() == self::TYPE_QUALIFYING_ALL;
        }
 
        public function setGeneralQualifiedTestVisibility($a_stat)
        {
                $this->qt_visible_all = $a_stat;
                return true;
        }
        
        public function isQualifiedTestPerObjectiveVisible()
        {
                return $this->getQualifyingTestType() == self::TYPE_QUALIFYING_SELECTED;
        }
        
        public function setQualifiedTestPerObjectiveVisibility($a_stat)
        {
                $this->qt_visible_lo = $a_stat;
        }
 
        public function getPassedObjectiveMode()
        {
                return $this->passed_objective_mode;
        }
        
        public function setPassedObjectiveMode($a_mode)
        {
                $this->passed_objective_mode = $a_mode;
        }
        
        public function isGeneralInitialTestVisible()
        {
                return $this->getInitialTestType() == self::TYPE_INITIAL_PLACEMENT_ALL || $this->getInitialTestType() == self::TYPE_INITIAL_QUALIFYING_ALL;
        }
        
        public function settingsExist()
        {
                return $this->entry_exists;
        }
        
        public function getObjId()
        {
                return $this->container_id;
        }
        
        public function setType($a_type)
        {
                $this->type = $a_type;
        }
        
        public function getType()
        {
                return $this->type;
        }
        
        public function getTestByType($a_type)
        {
                switch($a_type)
                {
                        case self::TYPE_TEST_INITIAL:
                                return $this->getInitialTest();
                                
                        case self::TYPE_TEST_QUALIFIED:
                                return $this->getQualifiedTest();
                }
        }
        
        public function getTests()
        {
                $tests = array();
                if($this->getInitialTest())
                {
                        $tests[] = $this->getInitialTest();
                }
                if($this->getQualifiedTest())
                {
                        $tests[] = $this->getQualifiedTest();
                }
                return $tests;
        }
        
        public function isRandomTestType($a_type)
        {
                $tst = $this->getTestByType($a_type);
                include_once './Modules/Test/classes/class.ilObjTest.php';
                return ilObjTest::_lookupRandomTest(ilObject::_lookupObjId($tst));
        }
        
        public function setInitialTest($a_id)
        {
                $this->initial_test = $a_id;
        }
 
        public function getInitialTest()
        {
                return $this->initial_test;
        }
 
        public function setQualifiedTest($a_id)
        {
                $this->qualified_test = $a_id;
        }
        
        public function getQualifiedTest()
        {
                return $this->qualified_test;
        }
 
        public function resetResults($a_status)
        {
                $this->reset_results = $a_status;
        }
        
        public function isResetResultsEnabled()
        {
                return (bool) $this->reset_results;
        }
        
        public function create()
        {
                global $ilDB;
                
                $query = 'INSERT INTO loc_settings '.
                                '(obj_id, it_type,itest,qtest,it_start,qt_type,qt_start,reset_results,passed_obj_mode) VALUES ( '.
                                $ilDB->quote($this->getObjId(),'integer').', '.
                                $ilDB->quote($this->getInitialTestType(),'integer').', '.
                                $ilDB->quote($this->getInitialTest(),'integer').', '.
                                $ilDB->quote($this->getQualifiedTest(),'integer').', '.
                                $ilDB->quote($this->isInitialTestStart(),'integer').', '.
                                $ilDB->quote($this->getQualifyingTestType(),'integer').', '.
                                $ilDB->quote($this->isQualifyingTestStart(),'integer').', '.
                                $ilDB->quote($this->isResetResultsEnabled(),'integer').', '.
                                $ilDB->quote($this->getPassedObjectiveMode(),'integer').' '.
                                ') ';
                $ilDB->manipulate($query);
                
                $this->entry_exists = true;
        }
 
        
        public function update()
        {
                global $ilDB;
                
                if(!$this->entry_exists)
                {
                        return $this->create();
                }
                
                $query = 'UPDATE loc_settings '.' '.
                                'SET it_type = '.$ilDB->quote($this->getInitialTestType(),'integer').', '.
                                'itest = '.$ilDB->quote($this->getInitialTest(),'integer').', '.
                                'qtest = '.$ilDB->quote($this->getQualifiedTest(),'integer').', '.
                                'it_start = '.$ilDB->quote($this->isInitialTestStart(),'integer').', '.
                                'qt_type = '.$ilDB->quote($this->getQualifyingTestType(),'integer').', '.
                                'qt_start = '.$ilDB->quote($this->isQualifyingTestStart(),'integer').', '.
                                'reset_results = '.$ilDB->quote($this->isResetResultsEnabled(),'integer').', '.
                                'passed_obj_mode = '.$ilDB->quote($this->getPassedObjectiveMode(),'integer').' '.
                                'WHERE obj_id = '.$ilDB->quote($this->getObjId(),'integer');
                                
                $ilDB->manipulate($query);
        }
 
        public function updateStartObjects(ilContainerStartObjects $start)
        {
                if($this->getInitialTestType() != self::TYPE_INITIAL_NONE)
                {
                        if($start->exists($this->getQualifiedTest()))
                        {
                                $start->deleteItem($this->getQualifiedTest());
                        }
                }
                
                switch($this->getInitialTestType())
                {
                        case self::TYPE_INITIAL_PLACEMENT_ALL:
                        case self::TYPE_INITIAL_QUALIFYING_ALL:
                                
                                if($this->isInitialTestStart())
                                {
                                        if(!$start->exists($this->getInitialTest()))
                                        {
                                                $start->add($this->getInitialTest());
                                        }
                                }
                                else
                                {
                                        if($start->exists($this->getInitialTest()))
                                        {
                                                $start->deleteItem($this->getInitialTest());
                                        }
                                }
                                break;
                                
                        case self::TYPE_INITIAL_NONE:
                                
                                if($start->exists($this->getInitialTest()))
                                {
                                        $start->deleteItem($this->getInitialTest());
                                }
                                break;
                                
                        default:
 
                                $this->logger->debug('Type initial default');
                                if($start->exists($this->getInitialTest()))
                                {
                                        $this->logger->debug('Old start object exists. Trying to delete');
                                        $start->deleteItem($this->getInitialTest());
                                }
                                break;
                }
                
                switch($this->getQualifyingTestType())
                {
                        case self::TYPE_QUALIFYING_ALL:
                                
                                if($this->isQualifyingTestStart())
                                {
                                        if(!$start->exists($this->getQualifiedTest()))
                                        {
                                                $start->add($this->getQualifiedTest());
                                        }
                                }
                                break;
                                
                        default:
                                if($start->exists($this->getQualifiedTest()))
                                {
                                        $start->deleteItem($this->getQualifiedTest());
                                }
                                break;
                }
                return TRUE;
        }
        
        
        protected function read()
        {
                global $ilDB;
                
                $query = 'SELECT * FROM loc_settings '.
                                'WHERE obj_id = '.$ilDB->quote($this->getObjId(),'integer');
                $res = $ilDB->query($query);
                while($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT))
                {
                        $this->entry_exists = true;
                        
                        $this->setInitialTestType($row->it_type);
                        $this->setInitialTestAsStart((bool) $row->it_start);
                        $this->setQualifyingTestType($row->qt_type);
                        $this->setQualifyingTestAsStart($row->qt_start);
                        
                        #$this->setType($row->type);
                        $this->setInitialTest($row->itest);
                        $this->setQualifiedTest($row->qtest);
                        #$this->setGeneralQualifiedTestVisibility($row->qt_vis_all);
                        #$this->setQualifiedTestPerObjectiveVisibility($row->qt_vis_obj);
                        $this->resetResults($row->reset_results);
                        $this->setPassedObjectiveMode($row->passed_obj_mode);
                }
                
                if($GLOBALS['tree']->isDeleted($this->getInitialTest()))
                {
                        $this->setInitialTest(0);
                }
                if($GLOBALS['tree']->isDeleted($this->getQualifiedTest()))
                {
                        $this->setQualifiedTest(0);
                }
        }
        
        public function toXml(ilXmlWriter $writer)
        {
                $writer->xmlElement(
                        'Settings',
                        array(
                                'initialTestType'                       => (int) $this->getInitialTestType(),
                                'initialTestStart'                      => (int) $this->isInitialTestStart(),
                                'qualifyingTestType'            => (int) $this->getQualifyingTestType(),
                                'qualifyingTestStart'           => (int) $this->isQualifyingTestStart(),
                                'resetResults'                          => (int) $this->isResetResultsEnabled(),
                                'passedObjectivesMode'          => (int) $this->getPassedObjectiveMode(),
                                'iTest'                                         => (int) $this->getInitialTest(),
                                'qTest'                                         => (int) $this->getQualifiedTest()
                        )
                );
                
        }
}
?>