class.ilTestRandomQuestionSetPoolDeriver.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.ilTestRandomQuestionSetStagingPoolQuestionList.php';
require_once 'Modules/TestQuestionPool/classes/class.ilQuestionPoolFactory.php';
require_once 'Modules/TestQuestionPool/classes/class.assQuestion.php';
        
class ilTestRandomQuestionSetPoolDeriver
{
    protected $db;
    
    protected $pluginAdmin;
    
    protected $testOBJ;
    
    protected $targetContainerRef;
    
    protected $ownerId;
    
    protected $poolFactory;
    
    protected $sourcePoolDefinitionList;
    
    public function __construct(ilDBInterface $ilDB, ilPluginAdmin $pluginAdmin, ilObjTest $testOBJ)
    {
        $this->db = $ilDB;
        $this->pluginAdmin = $pluginAdmin;
        $this->testOBJ = $testOBJ;
        $this->poolFactory = new ilQuestionPoolFactory();
    }
        
    public function getTargetContainerRef()
    {
        return $this->targetContainerRef;
    }
    
    public function setTargetContainerRef($targetContainerRef)
    {
        $this->targetContainerRef = $targetContainerRef;
    }
    
    public function getOwnerId()
    {
        return $this->ownerId;
    }
    
    public function setOwnerId($ownerId)
    {
        $this->ownerId = $ownerId;
    }
    
    public function getSourcePoolDefinitionList()
    {
        return $this->sourcePoolDefinitionList;
    }
    
    public function setSourcePoolDefinitionList($sourcePoolDefinitionList)
    {
        $this->sourcePoolDefinitionList = $sourcePoolDefinitionList;
    }
    
    protected function getQuestionsForPool(ilTestRandomQuestionSetNonAvailablePool $nonAvailablePool)
    {
        $questionList = new ilTestRandomQuestionSetStagingPoolQuestionList(
            $this->db,
            $this->pluginAdmin
        );
        
        $questionList->setTestObjId($this->testOBJ->getId());
        $questionList->setTestId($this->testOBJ->getTestId());
        $questionList->setPoolId($nonAvailablePool->getId());
        
        $questionList->loadQuestions();
        
        $questions = array();
        
        foreach ($questionList as $questionId) {
            $questions[] = assQuestion::_instantiateQuestion($questionId);
        }
        
        return $questions;
    }
    
    protected function createNewPool(ilTestRandomQuestionSetNonAvailablePool $nonAvailablePool)
    {
        $pool = $this->poolFactory->createNewInstance($this->getTargetContainerRef());
        
        if (strlen($nonAvailablePool->getTitle())) {
            $pool->setTitle($nonAvailablePool->getTitle());
            $pool->update();
        }
        
        return $pool;
    }
    
    protected function copyQuestionsToPool(ilObjQuestionPool $pool, $questions)
    {
        $poolQidByTestQidMap = array();
        
        foreach ($questions as $questionOBJ) {
            /* @var assQuestion $questionOBJ */

            $testQuestionId = $questionOBJ->getId();
            $poolQuestionId = $questionOBJ->duplicate(false, '', '', $this->getOwnerId(), $pool->getId());
            
            $poolQidByTestQidMap[$testQuestionId] = $poolQuestionId;
        }
        
        return $poolQidByTestQidMap;
    }
    
    protected function updateTestQuestionStage($poolQidByTestQidMap)
    {
        foreach ($poolQidByTestQidMap as $testQid => $poolQid) {
            assQuestion::resetOriginalId($poolQid);
            assQuestion::saveOriginalId($testQid, $poolQid);
        }
    }
    
    protected function filterForQuestionRelatedTaxonomies($taxonomyIds, $relatedQuestionIds)
    {
        require_once 'Services/Taxonomy/classes/class.ilTaxNodeAssignment.php';
        
        $filteredTaxIds = array();
        
        foreach ($taxonomyIds as $taxonomyId) {
            $taxNodeAssignment = new ilTaxNodeAssignment(
                $this->testOBJ->getType(),
                $this->testOBJ->getId(),
                'quest',
                $taxonomyId
            );
            
            foreach ($relatedQuestionIds as $questionId) {
                $assignedTaxNodes = $taxNodeAssignment->getAssignmentsOfItem($questionId);
                
                if (count($assignedTaxNodes)) {
                    $filteredTaxIds[] = $taxonomyId;
                    break;
                }
            }
        }
        
        return $filteredTaxIds;
    }
    
    protected function duplicateTaxonomies($poolQidByTestQidMap, ilObjQuestionPool $pool)
    {
        require_once 'Modules/TestQuestionPool/classes/class.ilQuestionPoolTaxonomiesDuplicator.php';
        $taxDuplicator = new ilQuestionPoolTaxonomiesDuplicator();
        $taxDuplicator->setSourceObjId($this->testOBJ->getId());
        $taxDuplicator->setSourceObjType($this->testOBJ->getType());
        $taxDuplicator->setTargetObjId($pool->getId());
        $taxDuplicator->setTargetObjType($pool->getType());
        $taxDuplicator->setQuestionIdMapping($poolQidByTestQidMap);
        
        $taxDuplicator->duplicate($this->filterForQuestionRelatedTaxonomies(
            $taxDuplicator->getAllTaxonomiesForSourceObject(),
            array_keys($poolQidByTestQidMap)
        ));
        
        return $taxDuplicator->getDuplicatedTaxonomiesKeysMap();
    }
    
    protected function buildOriginalTaxonomyFilterForDerivedPool(ilQuestionPoolDuplicatedTaxonomiesKeysMap $taxKeysMap, $mappedTaxonomyFilter)
    {
        $originalTaxonomyFilter = array();
        
        foreach ($mappedTaxonomyFilter as $testTaxonomyId => $testTaxNodes) {
            $poolTaxonomyId = $taxKeysMap->getMappedTaxonomyId($testTaxonomyId);
            $originalTaxonomyFilter[$poolTaxonomyId] = array();
            
            foreach ($testTaxNodes as $testTaxNode) {
                $poolTaxNode = $taxKeysMap->getMappedTaxNodeId($testTaxNode);
                $originalTaxonomyFilter[$poolTaxonomyId][] = $poolTaxNode;
            }
        }
        
        return $originalTaxonomyFilter;
    }
    
    protected function updateRelatedSourcePoolDefinitions(ilQuestionPoolDuplicatedTaxonomiesKeysMap $taxKeysMap, $derivedPoolId, $nonAvailablePoolId)
    {
        foreach ($this->getSourcePoolDefinitionList() as $definition) {
            if ($definition->getPoolId() != $nonAvailablePoolId) {
                continue;
            }
            
            $definition->setPoolId($derivedPoolId);
            
            $definition->setOriginalTaxonomyFilter($this->buildOriginalTaxonomyFilterForDerivedPool(
                $taxKeysMap,
                $definition->getMappedTaxonomyFilter()
            ));
            
            $definition->saveToDb();
        }
    }
    
    public function derive(ilTestRandomQuestionSetNonAvailablePool $nonAvailablePool)
    {
        $pool = $this->createNewPool($nonAvailablePool);
        $questions = $this->getQuestionsForPool($nonAvailablePool);
        
        $poolQidByTestQidMap = $this->copyQuestionsToPool($pool, $questions);
        
        $this->updateTestQuestionStage($poolQidByTestQidMap);
        
        $duplicatedTaxKeysMap = $this->duplicateTaxonomies($poolQidByTestQidMap, $pool);
        
        $this->updateRelatedSourcePoolDefinitions($duplicatedTaxKeysMap, $pool->getId(), $nonAvailablePool->getId());
        
        return $pool;
    }
}