class.ilTestRandomQuestionSetPoolDeriver.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

class ilTestRandomQuestionSetPoolDeriver
{
    private ilQuestionPoolFactory $pool_factory;

    public function __construct(
        private readonly ilDBInterface $db,
        private readonly ilComponentRepository $component_repository,
        private readonly ilObjTest $test_obj,
        private readonly ilTestRandomQuestionSetSourcePoolDefinitionList $source_pool_definition_list,
        private int $owner_id,
        private int $target_container_ref
    ) {
        $this->pool_factory = new ilQuestionPoolFactory();
    }

    public function derive(
        ilTestRandomQuestionSetNonAvailablePool $non_available_pool
    ): ilObjQuestionPool {
        $pool = $this->createNewPool($non_available_pool);
        $questions = $this->getQuestionsForPool($non_available_pool);
        $pool_qid_by_test_qid_map = $this->copyQuestionsToPool($pool, $questions);

        $this->updateTestQuestionStage($pool_qid_by_test_qid_map);
        $this->updateRelatedSourcePoolDefinitions(
            $this->duplicateTaxonomies($pool_qid_by_test_qid_map, $pool),
            $pool->getId(),
            $non_available_pool->getId()
        );

        return $pool;
    }

    private function getQuestionsForPool(
        ilTestRandomQuestionSetNonAvailablePool $non_available_pool
    ): array {
        $question_list = new ilTestRandomQuestionSetStagingPoolQuestionList(
            $this->db,
            $this->component_repository
        );
        $question_list->setTestObjId($this->test_obj->getId());
        $question_list->setTestId($this->test_obj->getTestId());
        $question_list->setPoolId($non_available_pool->getId());
        $question_list->loadQuestions();

        $questions = [];
        foreach ($question_list->getQuestions() as $question_id) {
            $questions[] = assQuestion::instantiateQuestion($question_id);
        }

        return $questions;
    }

    private function createNewPool(
        ilTestRandomQuestionSetNonAvailablePool $non_available_pool
    ): ilObjQuestionPool {
        $pool = $this->pool_factory->createNewInstance($this->target_container_ref);

        if ($non_available_pool->getTitle() !== '') {
            $pool->setTitle($non_available_pool->getTitle());
            $pool->update();
        }

        return $pool;
    }

    private function copyQuestionsToPool(
        ilObjQuestionPool $pool,
        array $questions
    ): array {
        $pool_qid_by_test_qid_map = [];
        foreach ($questions as $question_obj) {
            $pool_qid_by_test_qid_map[$question_obj->getId()] = $question_obj
                ->duplicate(false, '', '', $this->owner_id, $pool->getId());
        }

        return $pool_qid_by_test_qid_map;
    }

    private function updateTestQuestionStage(
        array $pool_qid_by_test_qid_map
    ): void {
        foreach ($pool_qid_by_test_qid_map as $test_qid => $pool_qid) {
            assQuestion::resetOriginalId($pool_qid);
            assQuestion::saveOriginalId($test_qid, $pool_qid);
        }
    }

    private function filterForQuestionRelatedTaxonomies(
        array $taxonomy_ids,
        array $related_question_ids
    ): array {
        $filtered_tax_ids = [];
        foreach ($taxonomy_ids as $taxonomy_id) {
            $tax_node_assignment = new ilTaxNodeAssignment(
                $this->test_obj->getType(),
                $this->test_obj->getId(),
                'quest',
                $taxonomy_id
            );

            foreach ($related_question_ids as $question_id) {
                if ($tax_node_assignment->getAssignmentsOfItem($question_id) !== []) {
                    $filtered_tax_ids[] = $taxonomy_id;
                    break;
                }
            }
        }

        return $filtered_tax_ids;
    }

    private function duplicateTaxonomies(
        array $pool_qid_by_test_qid_map,
        ilObjQuestionPool $pool
    ): ilQuestionPoolDuplicatedTaxonomiesKeysMap {
        $tax_duplicator = new ilQuestionPoolTaxonomiesDuplicator();
        $tax_duplicator->setSourceObjId($this->test_obj->getId());
        $tax_duplicator->setSourceObjType($this->test_obj->getType());
        $tax_duplicator->setTargetObjId($pool->getId());
        $tax_duplicator->setTargetObjType($pool->getType());
        $tax_duplicator->setQuestionIdMapping($pool_qid_by_test_qid_map);

        $tax_duplicator->duplicate($this->filterForQuestionRelatedTaxonomies(
            $tax_duplicator->getAllTaxonomiesForSourceObject(),
            array_keys($pool_qid_by_test_qid_map)
        ));

        return $tax_duplicator->getDuplicatedTaxonomiesKeysMap();
    }

    private function buildOriginalTaxonomyFilterForDerivedPool(
        ilQuestionPoolDuplicatedTaxonomiesKeysMap $tax_keys_map,
        array $mapped_taxonomy_filter
    ): array {
        $original_taxonomy_filter = [];
        foreach ($mapped_taxonomy_filter as $test_taxonomy_id => $test_tax_nodes) {
            $pool_taxonomy_id = $tax_keys_map->getMappedTaxonomyId($test_taxonomy_id);
            if ($pool_taxonomy_id === null) {
                continue;
            }
            $original_taxonomy_filter[$pool_taxonomy_id] = [];

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

        return $original_taxonomy_filter;
    }

    private function updateRelatedSourcePoolDefinitions(
        ilQuestionPoolDuplicatedTaxonomiesKeysMap $tax_keys_map,
        int $derived_pool_id,
        int $non_available_pool_id
    ): void {
        foreach ($this->source_pool_definition_list as $definition) {
            if ($definition->getPoolId() !== $non_available_pool_id) {
                continue;
            }

            $definition->setPoolId($derived_pool_id);
            $definition->setOriginalTaxonomyFilter(
                $this->buildOriginalTaxonomyFilterForDerivedPool(
                    $tax_keys_map,
                    $definition->getMappedTaxonomyFilter()
                )
            );

            $definition->saveToDb();
        }
    }
}