class.ilTestRandomQuestionSetConfig.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
require_once 'Modules/Test/classes/class.ilTestQuestionSetConfig.php';
 
class ilTestRandomQuestionSetConfig extends ilTestQuestionSetConfig
{
        const QUESTION_AMOUNT_CONFIG_MODE_PER_TEST = 'TEST';
        const QUESTION_AMOUNT_CONFIG_MODE_PER_POOL = 'POOL';
        
        private $requirePoolsWithHomogeneousScoredQuestions = null;
        
        private $questionAmountConfigurationMode = null;
        
        private $questionAmountPerTest = null;
        
        private $lastQuestionSyncTimestamp = null;
 
        public function __construct(ilTree $tree, ilDB $db, ilPluginAdmin $pluginAdmin, ilObjTest $testOBJ)
        {
                parent::__construct($tree, $db, $pluginAdmin, $testOBJ);
        }
 
        public function setPoolsWithHomogeneousScoredQuestionsRequired($requirePoolsWithHomogeneousScoredQuestions)
        {
                $this->requirePoolsWithHomogeneousScoredQuestions = $requirePoolsWithHomogeneousScoredQuestions;
        }
        
        public function arePoolsWithHomogeneousScoredQuestionsRequired()
        {
                return $this->requirePoolsWithHomogeneousScoredQuestions;
        }
        
        public function setQuestionAmountConfigurationMode($questionAmountConfigurationMode)
        {
                $this->questionAmountConfigurationMode = $questionAmountConfigurationMode;
        }
        
        public function getQuestionAmountConfigurationMode()
        {
                return $this->questionAmountConfigurationMode;
        }
        
        public function isQuestionAmountConfigurationModePerPool()
        {
                return $this->getQuestionAmountConfigurationMode() == self::QUESTION_AMOUNT_CONFIG_MODE_PER_POOL;
        }
        
        public function isQuestionAmountConfigurationModePerTest()
        {
                return $this->getQuestionAmountConfigurationMode() == self::QUESTION_AMOUNT_CONFIG_MODE_PER_TEST;
        }
        
        public function setQuestionAmountPerTest($questionAmountPerTest)
        {
                $this->questionAmountPerTest = $questionAmountPerTest;
        }
        
        public function getQuestionAmountPerTest()
        {
                return $this->questionAmountPerTest;
        }
        
        public function setLastQuestionSyncTimestamp($lastQuestionSyncTimestamp)
        {
                $this->lastQuestionSyncTimestamp = $lastQuestionSyncTimestamp;
        }
        
        public function getLastQuestionSyncTimestamp()
        {
                return $this->lastQuestionSyncTimestamp;
        }
        
        // -----------------------------------------------------------------------------------------------------------------
        
        public function initFromArray($dataArray)
        {
                foreach($dataArray as $field => $value)
                {
                        switch($field)
                        {
                                case 'req_pools_homo_scored':           $this->setPoolsWithHomogeneousScoredQuestionsRequired($value);  break;
                                case 'quest_amount_cfg_mode':           $this->setQuestionAmountConfigurationMode($value);                              break;
                                case 'quest_amount_per_test':           $this->setQuestionAmountPerTest($value);                                                break;
                                case 'quest_sync_timestamp':            $this->setLastQuestionSyncTimestamp($value);                                    break;
                        }
                }
        }
        
        public function loadFromDb()
        {
                $res = $this->db->queryF(
                                "SELECT * FROM tst_rnd_quest_set_cfg WHERE test_fi = %s",
                                array('integer'), array($this->testOBJ->getTestId())
                );
                
                while( $row = $this->db->fetchAssoc($res) )
                {
                        $this->initFromArray($row);
                        
                        return true;
                }
                
                return false;
        }
        
        public function saveToDb()
        {
                if( $this->dbRecordExists($this->testOBJ->getTestId()) )
                {
                        $this->updateDbRecord($this->testOBJ->getTestId());
                }
                else
                {
                        $this->insertDbRecord($this->testOBJ->getTestId());
                }
        }
 
        public function cloneToDbForTestId($testId)
        {
                $this->insertDbRecord($testId);
        }
 
        public function deleteFromDb()
        {
                $this->db->manipulateF(
                                "DELETE FROM tst_rnd_quest_set_cfg WHERE test_fi = %s",
                                array('integer'), array($this->testOBJ->getTestId())
                );
        }
 
        // -----------------------------------------------------------------------------------------------------------------
 
        private function dbRecordExists($testId)
        {
                $res = $this->db->queryF(
                        "SELECT COUNT(*) cnt FROM tst_rnd_quest_set_cfg WHERE test_fi = %s",
                        array('integer'), array($testId)
                );
                
                $row = $this->db->fetchAssoc($res);
                
                return (bool)$row['cnt'];
        }
 
        private function updateDbRecord($testId)
        {
                $this->db->update('tst_rnd_quest_set_cfg',
                        array(
                                'req_pools_homo_scored' => array('integer', (int)$this->arePoolsWithHomogeneousScoredQuestionsRequired()),
                                'quest_amount_cfg_mode' => array('text', $this->getQuestionAmountConfigurationMode()),
                                'quest_amount_per_test' => array('integer', (int)$this->getQuestionAmountPerTest()),
                                'quest_sync_timestamp' => array('integer', (int)$this->getLastQuestionSyncTimestamp())
                        ),
                        array(
                                'test_fi' => array('integer', $testId)
                        )
                );
        }
        
        private function insertDbRecord($testId)
        {
                $this->db->insert('tst_rnd_quest_set_cfg', array(
                        'test_fi' => array('integer', $testId),
                        'req_pools_homo_scored' => array('integer', (int)$this->arePoolsWithHomogeneousScoredQuestionsRequired()),
                        'quest_amount_cfg_mode' => array('text', $this->getQuestionAmountConfigurationMode()),
                        'quest_amount_per_test' => array('integer', (int)$this->getQuestionAmountPerTest()),
                        'quest_sync_timestamp' => array('integer', (int)$this->getLastQuestionSyncTimestamp())
                ));
        }
 
        // -----------------------------------------------------------------------------------------------------------------
 
        public function isQuestionSetConfigured()
        {
                if( !$this->isQuestionAmountConfigComplete() )
                {
                        return false;
                }
 
                if( !$this->hasSourcePoolDefinitions() )
                {
                        return false;
                }
 
                if( !$this->isQuestionSetBuildable() )
                {
                        return false;
                }
 
                return true;
        }
 
        public function isQuestionAmountConfigComplete()
        {
                if( $this->isQuestionAmountConfigurationModePerPool() )
                {
                        $sourcePoolDefinitionList = $this->buildSourcePoolDefinitionList($this->testOBJ);
 
                        $sourcePoolDefinitionList->loadDefinitions();
 
                        foreach($sourcePoolDefinitionList as $definition)
                        {
                                if( $definition->getQuestionAmount() < 1 )
                                {
                                        return false;
                                }
                        }
                }
                elseif( $this->getQuestionAmountPerTest() < 1 )
                {
                        return false;
                }
 
                return true;
        }
 
        public function hasSourcePoolDefinitions()
        {
                $sourcePoolDefinitionList = $this->buildSourcePoolDefinitionList($this->testOBJ);
 
                return $sourcePoolDefinitionList->savedDefinitionsExist();
        }
 
        public function isQuestionSetBuildable()
        {
                $sourcePoolDefinitionList = $this->buildSourcePoolDefinitionList($this->testOBJ);
                $sourcePoolDefinitionList->loadDefinitions();
 
                require_once 'Modules/Test/classes/class.ilTestRandomQuestionSetStagingPoolQuestionList.php';
                $stagingPoolQuestionList = new ilTestRandomQuestionSetStagingPoolQuestionList($this->db, $this->pluginAdmin);
 
                require_once 'Modules/Test/classes/class.ilTestRandomQuestionSetBuilder.php';
                $questionSetBuilder = ilTestRandomQuestionSetBuilder::getInstance($this->db, $this->testOBJ, $this, $sourcePoolDefinitionList, $stagingPoolQuestionList);
 
                return $questionSetBuilder->checkBuildable();
        }
        
        public function doesQuestionSetRelatedDataExist()
        {
                if( $this->dbRecordExists($this->testOBJ->getTestId()) )
                {
                        return true;
                }
 
                $sourcePoolDefinitionList = $this->buildSourcePoolDefinitionList($this->testOBJ);
 
                if( $sourcePoolDefinitionList->savedDefinitionsExist() )
                {
                        return true;
                }
 
                return false;
        }
        
        public function removeQuestionSetRelatedData()
        {
                $sourcePoolDefinitionList = $this->buildSourcePoolDefinitionList($this->testOBJ);
                $sourcePoolDefinitionList->deleteDefinitions();
 
                require_once 'Modules/Test/classes/class.ilTestRandomQuestionSetStagingPoolBuilder.php';
                $stagingPool = new ilTestRandomQuestionSetStagingPoolBuilder(
                        $this->db, $this->testOBJ
                );
                $stagingPool->reset();
 
                $this->resetQuestionSetRelatedTestSettings();
 
                $this->deleteFromDb();
        }
 
        public function resetQuestionSetRelatedTestSettings()
        {
                $this->testOBJ->setResultFilterTaxIds(array());
                $this->testOBJ->saveToDb(true);
        }
 
        public function cloneQuestionSetRelatedData($cloneTestOBJ)
        {
                // clone general config
                
                $this->loadFromDb();
                $this->cloneToDbForTestId($cloneTestOBJ->getTestId());
 
                // clone source pool definitions (selection rules)
 
                $sourcePoolDefinitionList = $this->buildSourcePoolDefinitionList($this->testOBJ);
                $sourcePoolDefinitionList->loadDefinitions();
                $sourcePoolDefinitionList->cloneDefinitionsForTestId($cloneTestOBJ->getTestId());
 
                // build new question stage for cloned test
 
                $sourcePoolDefinitionList = $this->buildSourcePoolDefinitionList($cloneTestOBJ);
                $stagingPool = $this->buildStagingPoolBuilder($cloneTestOBJ);
 
                $sourcePoolDefinitionList->loadDefinitions();
                $stagingPool->rebuild($sourcePoolDefinitionList);
                $sourcePoolDefinitionList->saveDefinitions();
                
                $this->updateLastQuestionSyncTimestampForTestId($cloneTestOBJ->getTestId(), time());
        }
 
        private function buildSourcePoolDefinitionList(ilObjTest $testOBJ)
        {
                require_once 'Modules/Test/classes/class.ilTestRandomQuestionSetSourcePoolDefinitionFactory.php';
                $sourcePoolDefinitionFactory = new ilTestRandomQuestionSetSourcePoolDefinitionFactory(
                        $this->db, $testOBJ
                );
 
                require_once 'Modules/Test/classes/class.ilTestRandomQuestionSetSourcePoolDefinitionList.php';
                $sourcePoolDefinitionList = new ilTestRandomQuestionSetSourcePoolDefinitionList(
                        $this->db, $testOBJ, $sourcePoolDefinitionFactory
                );
 
                return $sourcePoolDefinitionList;
        }
        
        private function buildStagingPoolBuilder(ilObjTest $testOBJ)
        {
                require_once 'Modules/Test/classes/class.ilTestRandomQuestionSetStagingPoolBuilder.php';
                $stagingPool = new ilTestRandomQuestionSetStagingPoolBuilder($this->db, $testOBJ);
                
                return $stagingPool;
        }
        
        // -----------------------------------------------------------------------------------------------------------------
        
        public function updateLastQuestionSyncTimestampForTestId($testId, $timestamp)
        {
                $this->db->update('tst_rnd_quest_set_cfg',
                        array(
                                'quest_sync_timestamp' => array('integer', (int)$timestamp)
                        ),
                        array(
                                'test_fi' => array('integer', $testId)
                        )
                );
        }
 
        public function isResultTaxonomyFilterSupported()
        {
                return true;
        }
 
        // -----------------------------------------------------------------------------------------------------------------
        
        public function getSelectableQuestionPools()
        {
                return $this->testOBJ->getAvailableQuestionpools(
                        true, $this->arePoolsWithHomogeneousScoredQuestionsRequired(), false, true, true
                );
        }
        
        public function doesSelectableQuestionPoolsExist()
        {
                return (bool)count($this->getSelectableQuestionPools());
        }
 
        // -----------------------------------------------------------------------------------------------------------------
 
        public function areDepenciesBroken()
        {
                return (bool)$this->testOBJ->isTestFinalBroken();
        }
 
        public function getDepenciesBrokenMessage(ilLanguage $lng)
        {
                return $lng->txt('tst_old_style_rnd_quest_set_broken');
        }
 
        public function isValidRequestOnBrokenQuestionSetDepencies($nextClass, $cmd)
        {
                //vd($nextClass, $cmd);
 
                switch( $nextClass )
                {
                        case 'ilmdeditorgui':
                        case 'ilpermissiongui':
 
                                return true;
 
                        case 'ilobjtestgui':
                        case '':
 
                                $cmds = array(
                                        'infoScreen', 'participants', 'npSetFilter', 'npResetFilter',
                                        //'deleteAllUserResults', 'confirmDeleteAllUserResults',
                                        //'deleteSingleUserResults', 'confirmDeleteSelectedUserData', 'cancelDeleteSelectedUserData'
                                );
 
                                if( in_array($cmd, $cmds) )
                                {
                                        return true;
                                }
 
                                break;
                }
 
                return false;
        }
 
        public function getHiddenTabsOnBrokenDepencies()
        {
                return array(
                        'assQuestions', 'settings', 'manscoring', 'scoringadjust', 'statistics', 'history', 'export'
                );
        }
}