class.ilTestRandomQuestionSetSourcePoolDefinition.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\FromNormalized;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\ToNormalized;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\Transformations;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\Envelopes\Id;
 
class ilTestRandomQuestionSetSourcePoolDefinition implements ToNormalized, FromNormalized
{
    private ?int $id = null;
    private ?int $pool_id = null;
    private ?int $pool_ref_id = null;
    private string $pool_title = '';
    private string $pool_path = '';
    private ?int $pool_question_count = null;
 
    private array $original_taxonomy_filter = [];
 
    private array $mapped_taxonomy_filter = [];
 
    private array $type_filter = [];
    private array $lifecycle_filter = [];
 
    private ?int $question_amount = null;
 
    private ?int $sequence_position = null;
 
    public function __construct(
        protected ilDBInterface $db,
        protected ilObjTest $test_obj
    ) {
    }
 
    public function setId(int $id): void
    {
        $this->id = $id;
    }
 
    public function getId(): ?int
    {
        return $this->id;
    }
 
    public function setPoolId(int $pool_id): void
    {
        $this->pool_id = $pool_id;
    }
 
    public function getPoolId(): ?int
    {
        return $this->pool_id;
    }
 
    public function getPoolRefId(): ?int
    {
        return $this->pool_ref_id;
    }
 
    public function setPoolRefId(?int $pool_ref_id): void
    {
        $this->pool_ref_id = $pool_ref_id;
    }
 
    public function setPoolTitle(string $pool_title): void
    {
        $this->pool_title = $pool_title;
    }
 
    public function getPoolTitle(): string
    {
        return $this->pool_title;
    }
 
    public function setPoolPath(string $pool_path): void
    {
        $this->pool_path = $pool_path;
    }
 
    public function getPoolPath(): string
    {
        return $this->pool_path;
    }
 
    public function setPoolQuestionCount(?int $pool_question_count): void
    {
        $this->pool_question_count = $pool_question_count;
    }
 
    public function getPoolQuestionCount(): ?int
    {
        return $this->pool_question_count;
    }
 
    public function getOriginalTaxonomyFilter(): array
    {
        return $this->original_taxonomy_filter;
    }
 
    public function setOriginalTaxonomyFilter(array $filter = []): void
    {
        $this->original_taxonomy_filter = $filter;
    }
 
    private function getOriginalTaxonomyFilterForDbValue(): ?string
    {
        // TODO-RND2017: migrate to separate table for common selections by e.g. statistics
        return empty($this->original_taxonomy_filter) ? null : serialize($this->original_taxonomy_filter);
    }
 
    private function setOriginalTaxonomyFilterFromDbValue(?string $value): void
    {
        // TODO-RND2017: migrate to separate table for common selections by e.g. statistics
        $this->original_taxonomy_filter = empty($value) ? [] : unserialize($value);
    }
 
    public function getMappedTaxonomyFilter(): array
    {
        return $this->mapped_taxonomy_filter;
    }
 
    public function setMappedTaxonomyFilter(array $filter = []): void
    {
        $this->mapped_taxonomy_filter = array_filter(
            $filter,
            static fn(mixed $value, int|string $key): bool => (int) $key > 0 || !is_array($value),
            ARRAY_FILTER_USE_BOTH
        );
    }
 
    private function getMappedTaxonomyFilterForDbValue(): ?string
    {
        return empty($this->mapped_taxonomy_filter) ? null : serialize($this->mapped_taxonomy_filter);
    }
 
    private function setMappedTaxonomyFilterFromDbValue(?string $value): void
    {
        $this->mapped_taxonomy_filter = [];
        if ($value === null || $value === '') {
            return;
        }
 
        $filter = unserialize($value, ['allowed_classes' => false]);
        if (!is_array($filter)) {
            return;
        }
 
        $mapped_taxonomy_filter = [];
        foreach ($filter as $tax_id => $node_ids) {
            $mapped_taxonomy_filter[$tax_id] = $node_ids;
        }
 
        $this->setMappedTaxonomyFilter($mapped_taxonomy_filter);
    }
 
    public function mapTaxonomyFilter(ilQuestionPoolDuplicatedTaxonomiesKeysMap $taxonomies_keys_map): void
    {
        $this->mapped_taxonomy_filter = [];
        foreach ($this->original_taxonomy_filter as $tax_id => $node_ids) {
            $mapped_node_ids = [];
 
            $mapped_taxonomy_id = $taxonomies_keys_map->getMappedTaxonomyId($tax_id);
            if ($mapped_taxonomy_id === null || $mapped_taxonomy_id < 1) {
                continue;
            }
 
            foreach ($node_ids as $node_id) {
                $mapped_node_id = $taxonomies_keys_map->getMappedTaxNodeId($node_id);
                if ($mapped_node_id !== null) {
                    $mapped_node_ids[] = $mapped_node_id;
                }
            }
            $this->mapped_taxonomy_filter[$mapped_taxonomy_id] = $mapped_node_ids;
        }
    }
 
    public function setTypeFilter(array $type_filter = []): void
    {
        $this->type_filter = $type_filter;
    }
 
    public function getTypeFilter(): array
    {
        return $this->type_filter;
    }
 
    private function getTypeFilterForDbValue(): ?string
    {
        return empty($this->type_filter) ? null : serialize($this->type_filter);
    }
 
    private function setTypeFilterFromDbValue(?string $value): void
    {
        $this->type_filter = empty($value) ? [] : unserialize($value);
    }
 
    public function getLifecycleFilter(): array
    {
        return $this->lifecycle_filter;
    }
 
    public function setLifecycleFilter(array $lifecycle_filter): void
    {
        $this->lifecycle_filter = $lifecycle_filter;
    }
 
    public function getLifecycleFilterForDbValue(): ?string
    {
        return empty($this->lifecycle_filter) ? null : serialize($this->lifecycle_filter);
    }
 
    public function setLifecycleFilterFromDbValue(?string $db_value)
    {
        $this->lifecycle_filter = empty($db_value) ? [] : unserialize($db_value);
    }
 
    public function getTypeFilterAsTypeTags(): array
    {
        $map = [];
        foreach (ilObjQuestionPool::_getQuestionTypes(true) as $row) {
            $map[$row['question_type_id']] = $row['type_tag'];
        }
 
        $tags = [];
        foreach ($this->type_filter as $type_id) {
            if (isset($map[$type_id])) {
                $tags[] = $map[$type_id];
            }
        }
 
        return $tags;
    }
 
    public function setTypeFilterFromTypeTags(array $tags): void
    {
        $map = [];
        foreach (ilObjQuestionPool::_getQuestionTypes(true) as $row) {
            $map[$row['type_tag']] = $row['question_type_id'];
        }
 
        $this->type_filter = [];
        foreach ($tags as $type_tag) {
            if (isset($map[$type_tag])) {
                $this->type_filter[] = $map[$type_tag];
            }
        }
    }
 
    public function setQuestionAmount(?int $question_amount): void
    {
        $this->question_amount = $question_amount;
    }
 
    public function getQuestionAmount(): ?int
    {
        return $this->question_amount;
    }
 
    public function setSequencePosition(int $sequence_position): void
    {
        $this->sequence_position = $sequence_position;
    }
 
    public function getSequencePosition(): ?int
    {
        return $this->sequence_position;
    }
 
    // -----------------------------------------------------------------------------------------------------------------
 
    public function initFromArray(array $data_array): void
    {
        foreach ($data_array as $field => $value) {
            switch ($field) {
                case 'def_id':
                    $this->setId($value);
                    break;
                case 'pool_fi':
                    $this->setPoolId($value);
                    break;
                case 'pool_ref_id':
                    $this->setPoolRefId($value ? (int) $value : null);
                    break;
                case 'pool_title':
                    $this->setPoolTitle($value ?? '');
                    break;
                case 'pool_path':
                    $this->setPoolPath($value);
                    break;
                case 'pool_quest_count':
                    $this->setPoolQuestionCount($value);
                    break;
                case 'origin_tax_filter':
                    $this->setOriginalTaxonomyFilterFromDbValue($value);
                    break;
                case 'mapped_tax_filter':
                    $this->setMappedTaxonomyFilterFromDbValue($value);
                    break;
                case 'type_filter':
                    $this->setTypeFilterFromDbValue($value);
                    break;
                case 'lifecycle_filter':
                    $this->setLifecycleFilterFromDbValue($value);
                    break;
                    // fau.
                case 'quest_amount':
                    $this->setQuestionAmount($value);
                    break;
                case 'sequence_pos':
                    $this->setSequencePosition($value);
                    break;
            }
        }
    }
 
    public function loadFromDb(int $id): bool
    {
        $res = $this->db->queryF(
            "SELECT * FROM tst_rnd_quest_set_qpls WHERE def_id = %s",
            ['integer'],
            [$id]
        );
 
        while ($row = $this->db->fetchAssoc($res)) {
            $this->initFromArray($row);
 
            return true;
        }
 
        return false;
    }
 
    public function saveToDb(): void
    {
        if ($this->getId()) {
            $this->updateDbRecord($this->test_obj->getTestId());
            return;
        }
 
        $this->insertDbRecord($this->test_obj->getTestId());
    }
 
    public function cloneToDbForTestId(int $test_id): void
    {
        $this->insertDbRecord($test_id);
    }
 
    public function deleteFromDb(): void
    {
        $this->db->manipulateF(
            "DELETE FROM tst_rnd_quest_set_qpls WHERE def_id = %s",
            ['integer'],
            [$this->getId()]
        );
    }
 
    private function updateDbRecord(int $test_id): void
    {
        $this->db->update(
            'tst_rnd_quest_set_qpls',
            [
                'test_fi' => ['integer', $test_id],
                'pool_fi' => ['integer', $this->getPoolId()],
                'pool_ref_id' => ['integer', $this->getPoolRefId()],
                'pool_title' => ['text', $this->getPoolTitle()],
                'pool_path' => ['text', $this->getPoolPath()],
                'pool_quest_count' => ['integer', $this->getPoolQuestionCount()],
                'origin_tax_filter' => ['text', $this->getOriginalTaxonomyFilterForDbValue()],
                'mapped_tax_filter' => ['text', $this->getMappedTaxonomyFilterForDbValue()],
                'type_filter' => ['text', $this->getTypeFilterForDbValue()],
                'lifecycle_filter' => ['text', $this->getLifecycleFilterForDbValue()],
                'quest_amount' => ['integer', $this->getQuestionAmount()],
                'sequence_pos' => ['integer', $this->getSequencePosition()]
            ],
            [
                'def_id' => ['integer', $this->getId()]
            ]
        );
    }
 
    private function insertDbRecord(int $test_id): void
    {
        $next_id = $this->db->nextId('tst_rnd_quest_set_qpls');
 
        $this->db->insert('tst_rnd_quest_set_qpls', [
                'def_id' => ['integer', $next_id],
                'test_fi' => ['integer', $test_id],
                'pool_fi' => ['integer', $this->getPoolId()],
                'pool_ref_id' => ['integer', $this->getPoolRefId()],
                'pool_title' => ['text', $this->getPoolTitle()],
                'pool_path' => ['text', $this->getPoolPath()],
                'pool_quest_count' => ['integer', $this->getPoolQuestionCount()],
                'origin_tax_filter' => ['text', $this->getOriginalTaxonomyFilterForDbValue()],
                'mapped_tax_filter' => ['text', $this->getMappedTaxonomyFilterForDbValue()],
                'type_filter' => ['text', $this->getTypeFilterForDbValue()],
                'lifecycle_filter' => ['text', $this->getLifecycleFilterForDbValue()],
                'quest_amount' => ['integer', $this->getQuestionAmount()],
                'sequence_pos' => ['integer', $this->getSequencePosition()]
        ]);
 
        $this->setId($next_id);
    }
 
    // -----------------------------------------------------------------------------------------------------------------
 
    public function getPoolInfoLabel(ilLanguage $lng): string
    {
        $pool_path = $this->getPoolPath();
        if (is_int($this->getPoolRefId()) && ilObject::_lookupObjId($this->getPoolRefId())) {
            $path = new ilPathGUI();
            $path->enableTextOnly(true);
            $pool_path = $path->getPath(ROOT_FOLDER_ID, (int) $this->getPoolRefId());
        }
 
        $poolInfoLabel = sprintf(
            $lng->txt('tst_random_question_set_source_questionpool_summary_string'),
            $this->getPoolTitle(),
            $pool_path,
            $this->getPoolQuestionCount()
        );
 
        return $poolInfoLabel;
    }
 
    // -----------------------------------------------------------------------------------------------------------------
 
    #[\Override]
    public function toNormalized(
        Transformations $transformations,
        array $context = []
    ): array|float|bool|int|string|null {
        $normalized = [
            'id' => $transformations->normalize(new Id($this->getId(), 'rnd_src_pool_def')),
            'pool_id' => $transformations->normalize(new Id($this->getPoolId(), 'qpl')),
            'pool_title' => $this->getPoolTitle(),
            'pool_path' => $this->getPoolPath(),
            'quest_amount' => $this->getQuestionAmount(),
            'pool_quest_count' => $this->getPoolQuestionCount(),
            'position' => $this->getSequencePosition(),
            'type_filter' => $this->getTypeFilterAsTypeTags(),
            'lifecycle_filter' => $this->getLifecycleFilter(),
            'taxonomy_filter' => [],
            'mapped_taxonomy_filter' => [],
        ];
 
        foreach ($this->getOriginalTaxonomyFilter() as $tax_id => $node_ids) {
            $normalized['taxonomy_filter'][] = [
                'tax_id' => $transformations->normalize(new Id($tax_id, 'tax')),
                'node_ids' => array_map(
                    static fn($node_id): mixed => $transformations->normalize(new Id($node_id, 'tax_node')),
                    $node_ids
                ),
            ];
        }
 
        foreach ($this->getMappedTaxonomyFilter() as $tax_id => $node_ids) {
            $normalized['mapped_taxonomy_filter'][] = [
                'tax_id' => $transformations->normalize(new Id($tax_id, 'mapped_tax')),
                'node_ids' => array_map(
                    static fn($node_id): mixed => $transformations->normalize(new Id($node_id, 'mapped_tax_node')),
                    $node_ids
                ),
            ];
        }
 
        return $normalized;
    }
 
    #[\Override]
    public function fromNormalized(
        array $normalized,
        Transformations $transformations
    ): static {
        $clone = clone $this;
        $clone->setId($transformations->denormalize($normalized['id'], Id::class)->getId());
        $clone->setPoolId($transformations->denormalize($normalized['pool_id'], Id::class)->getId());
        $clone->setPoolTitle($transformations->string($normalized['pool_title']));
        $clone->setPoolPath($transformations->string($normalized['pool_path']));
        $clone->setQuestionAmount($transformations->nullableInt($normalized['quest_amount']));
        $clone->setPoolQuestionCount($transformations->nullableInt($normalized['pool_quest_count']));
        $clone->setSequencePosition($transformations->int($normalized['position']));
        $clone->setTypeFilterFromTypeTags($normalized['type_filter']);
        $clone->setLifecycleFilter($normalized['lifecycle_filter']);
 
        $taxonomy_filter = [];
        foreach ($normalized['taxonomy_filter'] as $item) {
            $tax_id = $transformations->denormalize($item['tax_id'], Id::class)->getId();
            $taxonomy_filter[$tax_id] = array_map(
                static fn($node_id): mixed => $transformations->denormalize($node_id, Id::class)->getId(),
                $item['node_ids']
            );
        }
        $clone->setOriginalTaxonomyFilter($taxonomy_filter);
 
        $mapped_taxonomy_filter = [];
        foreach (($normalized['mapped_taxonomy_filter'] ?? []) as $item) {
            $tax_id = $transformations->denormalize($item['tax_id'], Id::class)->getId();
            $mapped_taxonomy_filter[$tax_id] = array_map(
                static fn($node_id): mixed => $transformations->denormalize($node_id, Id::class)->getId(),
                $item['node_ids']
            );
        }
        $clone->setMappedTaxonomyFilter($mapped_taxonomy_filter);
 
        return $clone;
    }
}