TestExporter.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Test\ExportImport;
 
use ILIAS\Data\Factory as DataFactory;
use ILIAS\Data\ObjectId;
use ILIAS\Data\UUID\Factory as UUIDFactory;
use ILIAS\Filesystem\Stream\Streams;
use ILIAS\Language\Language;
use ILIAS\ResourceStorage\Services as IRSS;
use ILIAS\Taxonomy\DomainService as Taxonomy;
use ILIAS\Test\ExportImport\Normalize\Processors\CollectUserIds;
use ILIAS\Test\Logging\TestLogger;
use ILIAS\Test\Participants\ParticipantRepository;
use ILIAS\Test\Questions\Properties\Repository as QuestionsRepository;
use ILIAS\Test\Results\Data\Repository as ResultsRepository;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Export\ExportPhase;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Export\ExportContext;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Export\Exporter;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Serialize\Serializer;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\Transformations;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Normalize\Processors\CollectResources;
use ILIAS\TestQuestionPool\ExportImport\Foundation\Serialize\XmlSerializer;
use TestQuestionPool\ExportImport\Normalize\Processors\CollectQuestionImages;
use ILIAS\TestQuestionPool\Questions\GeneralQuestionPropertiesRepository;
 
class TestExporter implements Exporter
{
    public function __construct(
        private readonly TransformationsBuilder $builder,
        private readonly DataFactory $data_factory,
        private readonly \ilDBInterface $db,
        private readonly \ilTree $tree,
        private readonly Language $lng,
        private readonly TestLogger $logger,
        private readonly \ilComponentRepository $component_repository,
        private readonly IRSS $irss,
        private readonly ParticipantRepository $participant_repository,
        private readonly ResultsRepository $results_repository,
        private readonly QuestionsRepository $questions_repository,
        private readonly GeneralQuestionPropertiesRepository $general_questions_repository,
        private readonly Taxonomy $taxonomy
    ) {
    }
 
    public function prepare(ExportContext $context): void
    {
        $context->logger()->info('Preparing test export (1/3)...');
        $context->assertPhase(ExportPhase::Init);
        $context->setPhase(ExportPhase::Prepare);
 
        $object_id = $this->extractObjectId($context);
        if ($object_id === null) {
            return;
        }
 
        $collector = new TestCollector(
            $this->participant_repository,
            $this->results_repository,
            $this->questions_repository,
            $this->general_questions_repository,
            $this->db,
            $this->tree,
            $this->lng,
            $this->logger,
            $this->component_repository,
            $object_id
        );
        $context->setCollector($collector);
 
        $transformations = $this->builder->forExport(
            new CollectUserIds(),
            new CollectQuestionImages(
                new UUIDFactory(),
                $object_id
            ),
            new CollectResources(
                $this->irss,
                $this->logger
            )
        );
 
        $context->setTransformations($transformations);
        $context->logger()->info('...Finished preparing test export (1/3)');
    }
 
    private function extractObjectId(ExportContext $context): ?ObjectId
    {
        $target_ids = $context->target()->getObjectIds();
 
        if ($target_ids === []) {
            $context->logger()->warning('No target object IDs found for test export');
            return null;
        }
 
        if (count($target_ids) > 1) {
            $context->logger()->warning(
                'Multiple target object IDs found for test export. Only the first one will be used.'
            );
        }
 
        return $this->data_factory->objId(array_shift($target_ids));
    }
 
    private function collector(ExportContext $context): TestCollector
    {
        $collector = $context->collector();
        if (!($collector instanceof TestCollector)) {
            throw new \LogicException('Unexpected test collector');
        }
 
        return $collector;
    }
 
    public function process(ExportContext $context): void
    {
        $context->logger()->info('Processing test export (2/3)...');
        $context->assertPhase(ExportPhase::Prepare);
        $context->setPhase(ExportPhase::Process);
 
        $context->serializer()->group(
            'general',
            fn() => $this->exportObject(
                $this->collector($context),
                $context->transformations(),
                $context->serializer(),
                $context
            )
        );
        $context->serializer()->group(
            'settings',
            fn() => $this->exportSettings(
                $this->collector($context),
                $context->transformations(),
                $context->serializer(),
                $context
            )
        );
        $context->serializer()->group(
            'questions',
            fn() => $this->exportQuestions(
                $this->collector($context),
                $context->transformations(),
                $context->serializer(),
                $context
            )
        );
        $context->serializer()->group(
            'question_set_config',
            fn() => $this->exportQuestionSetConfig(
                $this->collector($context),
                $context->transformations(),
                $context->serializer(),
            )
        );
        $context->serializer()->group(
            'additional_working_times',
            fn() => $this->exportAdditionalWorkingTimes(
                $this->collector($context),
                $context->transformations(),
                $context->serializer(),
            )
        );
        $context->serializer()->group(
            'skill_assignments',
            fn() => $this->exportSkillAssignments(
                $this->collector($context),
                $context->transformations(),
                $context->serializer(),
            )
        );
        $context->serializer()->group(
            'skill_thresholds',
            fn() => $this->exportSkillLevelThresholds(
                $this->collector($context),
                $context->transformations(),
                $context->serializer(),
            )
        );
 
        if ($context->getOption() === Types::XML_WITH_RESULTS->value) {
            $context->logger()->info('Processing test results export ...');
            $this->processResults($context);
            $context->logger()->info('...Finished processing test results export');
        }
 
        $context->logger()->info('...Finished processing test export (2/3)');
    }
 
    private function processResults(ExportContext $context): void
    {
        $context->serializer()->group(
            'participants',
            fn() => $this->exportParticipants(
                $this->collector($context),
                $context->transformations(),
                $context->serializer()
            )
        );
        $context->serializer()->group(
            'results',
            fn() => $this->exportResults(
                $this->collector($context),
                $context->transformations(),
                $context->serializer()
            )
        );
    }
 
    public function write(ExportContext $context): void
    {
        $context->logger()->info('Writing test export (3/3)...');
        $context->assertPhase(ExportPhase::Process);
        $context->setPhase(ExportPhase::Write);
 
        $export_dir = $context->path()->getPathToComponentExpDirInContainer();
        $question_image_collector = $context->transformations()
            ->normalizationProcessor(CollectQuestionImages::class);
        if (!($question_image_collector instanceof CollectQuestionImages)) {
            throw new \LogicException('Unexpected question image processor');
        }
 
        $resource_collector = $context->transformations()
            ->normalizationProcessor(CollectResources::class);
        if (!($resource_collector instanceof CollectResources)) {
            throw new \LogicException('Unexpected resource processor');
        }
 
        foreach ($question_image_collector->getFiles() as $file) {
            if (!file_exists($file['from'])) {
                $context->logger()->warning('Question image file not found: ' . $file['from']);
                continue;
            }
 
            $context->writer()->writeFileByFilePath(
                $file['from'],
                "{$export_dir}/" . $file['to']
            );
        }
 
        foreach ($resource_collector->getResources() as $id => $resource) {
            $clean_id = str_replace(['-', '_'], '', $id);
            $file = "{$clean_id}.{$resource->getCurrentRevision()->getInformation()->getSuffix()}";
 
            $context->writer()->writeFilesByResourceId(
                $id,
                "{$export_dir}/resources/{$file}"
            );
        }
 
        $this->writeMappings(
            $this->collector($context),
            $context->transformations(),
            $context
        );
 
        $context->logger()->info('...Finished writing test export (3/3)');
    }
 
 
    private function exportObject(
        TestCollector $collector,
        Transformations $transformations,
        Serializer $serializer,
        ExportContext $context
    ): void {
        $serializer->append('object', $transformations->normalize($collector->getObject()));
 
        $obj_id = $collector->getObjectId()->toInt();
        $context->addDependency('components/ILIAS/ILIASObject', 'common', [$obj_id]);
        $context->addDependency('components/ILIAS/MetaData', 'tst', ["{$obj_id}:0:tst"]);
        $context->addDependency(
            'components/ILIAS/Taxonomy',
            'tax',
            $this->taxonomy->getUsageOfObject($obj_id)
        );
        $context->addDependency('components/ILIAS/Tracking', 'lpsettings', [$obj_id]);
    }
 
    private function exportSettings(
        TestCollector $collector,
        Transformations $transformations,
        Serializer $serializer,
        ExportContext $context
    ): void {
        $test = $collector->getObject();
        $main_settings = $test->getMainSettings();
 
        $serializer->append('main', $transformations->normalize($main_settings));
        $serializer->append('scoring', $transformations->normalize($test->getScoreSettings()));
        $serializer->append('marks', $transformations->normalize($test->getMarkSchema()));
 
        $intro_page_id = $main_settings->getIntroductionSettings()->getIntroductionPageId();
        if ($intro_page_id !== null && $intro_page_id !== 0) {
            $context->addDependency('components/ILIAS/COPage', 'pg', ["tst:{$intro_page_id}"]);
        }
        $concluding_page_id = $main_settings->getFinishingSettings()->getConcludingRemarksPageId();
        if ($concluding_page_id !== null && $concluding_page_id !== 0) {
            $context->addDependency('components/ILIAS/COPage', 'pg', ["tst:{$concluding_page_id}"]);
        }
    }
 
    private function exportQuestions(
        TestCollector $collector,
        Transformations $transformations,
        Serializer $serializer,
        ExportContext $context
    ): void {
        $question_properties = $collector->getTestQuestionProperties();
 
        foreach ($collector->getQuestionObjects() as $question) {
            $normalized = [
                ... $transformations->normalize($question),
                'feedback' => $transformations->normalize(
                    $collector->getFeedback($question)
                ),
                'sequence' => $question_properties[$question->getId()]->getSequenceInformation()?->getPlaceInSequence(),
            ];
 
            if ($question instanceof \assFormulaQuestion) {
                $data = $collector->getUnitsAndCategories($question->getId());
                $normalized['formula_data'] = $transformations->normalize($data);
            }
 
            $serializer->append('question', $normalized);
            $context->addDependency('components/ILIAS/COPage', 'pg', ["qpl:{$question->getId()}"]);
        }
    }
 
    private function exportQuestionSetConfig(
        TestCollector $collector,
        Transformations $transformations,
        Serializer $serializer,
    ): void {
        $serializer->append(
            'question_set_config',
            $transformations->normalize($collector->getQuestionSetConfig())
        );
    }
 
    private function exportSkillAssignments(
        TestCollector $collector,
        Transformations $transformations,
        Serializer $serializer,
    ): void {
        foreach ($collector->getSkillAssignments() as $assignment) {
            $serializer->append('skill_assignment', $transformations->normalize($assignment));
        }
    }
 
    private function exportSkillLevelThresholds(
        TestCollector $collector,
        Transformations $transformations,
        Serializer $serializer,
    ): void {
        foreach ($collector->getSkillLevelThresholds() as $threshold) {
            $serializer->append('skill_level_threshold', $transformations->normalize($threshold));
        }
    }
 
    private function exportParticipants(
        TestCollector $collector,
        Transformations $transformations,
        Serializer $serializer
    ): void {
        $additional_data = $collector->getAdditionalParticipantData($collector->getParticipantsIds());
 
        foreach ($collector->getParticipants() as $participant) {
            $normalized = $transformations->normalize($participant);
            if ($participant->getActiveId() !== null) {
                $normalized = array_merge($normalized, $additional_data[$participant->getActiveId()]);
            }
 
            $serializer->append('participant', $normalized);
        }
    }
 
    private function exportResults(
        TestCollector $collector,
        Transformations $transformations,
        Serializer $serializer
    ): void {
        foreach ($collector->getParticipantsIds() as $participant_id) {
            $serializer->append(
                'set',
                $transformations->normalize(
                    $collector->getResults($participant_id)
                )
            );
        }
    }
 
    private function exportAdditionalWorkingTimes(
        TestCollector $collector,
        Transformations $transformations,
        Serializer $serializer,
    ): void {
        foreach ($collector->getAdditionalWorkingTimes() as $additional_working_time) {
            $serializer->append('time', $transformations->normalize($additional_working_time));
        }
    }
 
    private function writeMappings(
        TestCollector $collector,
        Transformations $transformations,
        ExportContext $context
    ): void {
        $serializer = XmlSerializer::inMemory();
        $serializer->createDocument('Test Export Mappings');
        $serializer->startGroup('mappings');
 
        $user_id_processor = $transformations->normalizationProcessor(CollectUserIds::class);
        if (!($user_id_processor instanceof CollectUserIds)) {
            throw new \LogicException('Unexpected user ID processor');
        }
        $user_ids = $user_id_processor->getIds();
        $serializer->append('users', $collector->getUserMapping($user_ids));
 
        $resource_processor = $transformations->normalizationProcessor(CollectResources::class);
        if (!($resource_processor instanceof CollectResources)) {
            throw new \LogicException('Unexpected resource processor');
        }
        $resources = $resource_processor->getResources();
        $serializer->append(
            'resources',
            array_map($transformations->normalize(...), $resources)
        );
 
        $serializer->endGroup('mappings');
 
        $context->writer()->writeFileByStream(
            Streams::ofString($serializer->write()),
            "{$context->path()->getPathToComponentDirInContainer()}/mappings.xml"
        );
    }
}