class.ilTestRandomQuestionSetPoolDeriver.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

class ilTestRandomQuestionSetPoolDeriver
{
    protected ilDBInterface $db;
    protected ilComponentRepository $component_repository;
    protected ilObjTest $testOBJ;
    protected ilQuestionPoolFactory $poolFactory;

    protected $targetContainerRef;

    protected $ownerId;

    protected $sourcePoolDefinitionList;

    public function __construct(ilDBInterface $ilDB, ilComponentRepository $component_repository, ilObjTest $testOBJ)
    {
        $this->db = $ilDB;
        $this->component_repository = $component_repository;
        $this->testOBJ = $testOBJ;
        $this->poolFactory = new ilQuestionPoolFactory();
    }

    public function getTargetContainerRef(): int
    {
        return $this->targetContainerRef;
    }

    public function setTargetContainerRef($targetContainerRef)
    {
        $this->targetContainerRef = $targetContainerRef;
    }

    public function getOwnerId(): int
    {
        return $this->ownerId;
    }

    public function setOwnerId($ownerId)
    {
        $this->ownerId = $ownerId;
    }

    public function getSourcePoolDefinitionList(): ilTestRandomQuestionSetSourcePoolDefinitionList
    {
        return $this->sourcePoolDefinitionList;
    }

    public function setSourcePoolDefinitionList($sourcePoolDefinitionList)
    {
        $this->sourcePoolDefinitionList = $sourcePoolDefinitionList;
    }

    protected function getQuestionsForPool(ilTestRandomQuestionSetNonAvailablePool $nonAvailablePool): array
    {
        $questionList = new ilTestRandomQuestionSetStagingPoolQuestionList(
            $this->db,
            $this->component_repository
        );

        $questionList->setTestObjId($this->testOBJ->getId());
        $questionList->setTestId($this->testOBJ->getTestId());
        $questionList->setPoolId($nonAvailablePool->getId());

        $questionList->loadQuestions();

        $questions = array();
        $list = $questionList->getQuestions();
        foreach ($list as $questionId) {
            $questions[] = assQuestion::instantiateQuestion($questionId);
        }

        return $questions;
    }

    protected function createNewPool(ilTestRandomQuestionSetNonAvailablePool $nonAvailablePool): ilObjQuestionPool
    {
        $pool = $this->poolFactory->createNewInstance($this->getTargetContainerRef());

        if (strlen($nonAvailablePool->getTitle())) {
            $pool->setTitle($nonAvailablePool->getTitle());
            $pool->update();
        }

        return $pool;
    }

    protected function copyQuestionsToPool(ilObjQuestionPool $pool, $questions): array
    {
        $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): array
    {
        $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): ilQuestionPoolDuplicatedTaxonomiesKeysMap
    {
        $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,
        array $mapped_taxonomy_filter
    ): array {
        $original_taxonomy_filter = [];
        foreach ($mapped_taxonomy_filter as $test_taxonomy_id => $test_tax_nodes) {
            $pool_taxonomy_id = $taxKeysMap->getMappedTaxonomyId($test_taxonomy_id);
            if ($pool_taxonomy_id === null) {
                continue;
            }
            $original_taxonomy_filter[$pool_taxonomy_id] = [];

            foreach ($test_tax_nodes as $test_tax_node) {
                $pool_tax_node = $taxKeysMap->getMappedTaxNodeId((int) $test_tax_node);
                if ($pool_tax_node !== null) {
                    $original_taxonomy_filter[$pool_taxonomy_id][] = $pool_tax_node;
                }
            }
        }

        return $original_taxonomy_filter;
    }

    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): ilObjQuestionPool
    {
        $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;
    }
}