class.ilObjTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\Test\Participants\ParticipantRepository;
use ILIAS\Test\Results\Data\Repository;
use ILIAS\Test\TestDIC;
use ILIAS\Test\RequestDataCollector;
use ILIAS\Test\TestManScoringDoneHelper;
use ILIAS\Test\Logging\TestLogger;
use ILIAS\Test\Logging\TestLogViewer;
use ILIAS\Test\ExportImport\Factory as ExportImportFactory;
use ILIAS\Test\Logging\TestAdministrationInteractionTypes;
use ILIAS\Test\Logging\TestScoringInteractionTypes;
use ILIAS\Test\Logging\AdditionalInformationGenerator;
use ILIAS\Test\Scoring\Marks\MarksRepository;
use ILIAS\Test\Scoring\Marks\Mark;
use ILIAS\Test\Scoring\Marks\MarkSchema;
use ILIAS\Test\Scoring\Manual\TestScoring;
use ILIAS\Test\Settings\SettingsFactory;
use ILIAS\Test\Settings\GlobalSettings\Repository as GlobalSettingsRepository;
use ILIAS\Test\Settings\GlobalSettings\GlobalTestSettings;
use ILIAS\Test\Settings\MainSettings\MainSettingsRepository;
use ILIAS\Test\Settings\MainSettings\MainSettings;
use ILIAS\Test\Settings\MainSettings\RedirectionModes;
use ILIAS\Test\Settings\MainSettings\SettingsIntroduction;
use ILIAS\Test\Settings\MainSettings\SettingsFinishing;
use ILIAS\Test\Settings\ScoreReporting\ScoreSettingsRepository;
use ILIAS\Test\Settings\ScoreReporting\ScoreReportingTypes;
use ILIAS\Test\Settings\ScoreReporting\ScoreSettings;
use ILIAS\TestQuestionPool\Import\TestQuestionsImportTrait;
use ILIAS\TestQuestionPool\Questions\GeneralQuestionPropertiesRepository;
use ILIAS\Refinery\Factory as Refinery;
use ILIAS\Filesystem\Filesystem;
use ILIAS\MetaData\Services\ServicesInterface as LOMetadata;
 
class ilObjTest extends ilObject
{
    use TestQuestionsImportTrait;
 
    public const QUESTION_SET_TYPE_FIXED = 'FIXED_QUEST_SET';
    public const QUESTION_SET_TYPE_RANDOM = 'RANDOM_QUEST_SET';
    public const INVITATION_OFF = 0;
    public const INVITATION_ON = 1;
    public const SCORE_LAST_PASS = 0;
    public const SCORE_BEST_PASS = 1;
 
    private ?bool $activation_limited = null;
    private array $mob_ids;
    private array $file_ids = [];
    private bool $online;
    protected GeneralQuestionPropertiesRepository $questionrepository;
    private RequestDataCollector $testrequest;
    private MarksRepository $marks_repository;
    private ?MarkSchema $mark_schema = null;
    public int $test_id = -1;
    public int $invitation = self::INVITATION_OFF;
    public string $author;
 
    public $metadata;
    public array $questions = [];
 
    public $evaluation_data;
 
    public $test_sequence = false;
 
    private int $template_id = 0;
 
    protected bool $print_best_solution_with_result = true;
 
    protected bool $activation_visibility = false;
    protected ?int $activation_starting_time = null;
    protected ?int $activation_ending_time = null;
 
    private $participantDataExist = null;
 
    private ?int $tmpCopyWizardCopyId = null;
 
    private TestManScoringDoneHelper $test_man_scoring_done_helper;
    protected ilCtrlInterface $ctrl;
    protected Refinery $refinery;
    protected ilSetting $settings;
    protected ilBenchmark $bench;
    protected ilTestParticipantAccessFilterFactory $participant_access_filter;
 
    protected GlobalSettingsRepository $global_settings_repo;
    protected ?MainSettings $main_settings = null;
    protected ?MainSettingsRepository $main_settings_repository = null;
    protected ?ScoreSettings $score_settings = null;
    protected ?ScoreSettingsRepository $score_settings_repository = null;
    protected SettingsFactory $settings_factory;
 
    protected TestLogger $logger;
    protected TestLogViewer $log_viewer;
    protected ilTestQuestionSetConfigFactory $question_set_config_factory;
 
    protected ExportImportFactory $export_factory;
 
    private ilComponentRepository $component_repository;
    private ilComponentFactory $component_factory;
    private Filesystem $filesystem_web;
 
    protected ?ilTestParticipantList $access_filtered_participant_list = null;
    protected ParticipantRepository $participant_repository;
    protected Repository $test_result_repository;
 
    protected LOMetadata $lo_metadata;
 
    public function __construct(int $id = 0, bool $a_call_by_reference = true)
    {
        $this->type = "tst";
 
        global $DIC;
        $this->ctrl = $DIC['ilCtrl'];
        $this->refinery = $DIC['refinery'];
        $this->settings = $DIC['ilSetting'];
        $this->bench = $DIC['ilBench'];
        $this->component_repository = $DIC['component.repository'];
        $this->component_factory = $DIC['component.factory'];
        $this->filesystem_web = $DIC->filesystem()->web();
        $this->lo_metadata = $DIC->learningObjectMetadata();
 
        $local_dic = $this->getLocalDIC();
        $this->participant_access_filter = $local_dic['participant.access_filter.factory'];
        $this->test_man_scoring_done_helper = $local_dic['scoring.manual.done_helper'];
        $this->logger = $local_dic['logging.logger'];
        $this->log_viewer = $local_dic['logging.viewer'];
        $this->global_settings_repo = $local_dic['settings.global.repository'];
        $this->marks_repository = $local_dic['marks.repository'];
        $this->settings_factory = $local_dic['settings.factory'];
        $this->questionrepository = $local_dic['question.general_properties.repository'];
        $this->testrequest = $local_dic['request_data_collector'];
        $this->participant_repository = $local_dic['participant.repository'];
        $this->export_factory = $local_dic['exportimport.factory'];
        $this->test_result_repository = $local_dic['results.data.repository'];
        $this->main_settings_repository = $local_dic['settings.main.repository'];
        $this->score_settings_repository = $local_dic['settings.scoring.repository'];
 
        parent::__construct($id, $a_call_by_reference);
 
        $this->lng->loadLanguageModule("assessment");
        $this->score_settings = null;
 
        $this->question_set_config_factory = new ilTestQuestionSetConfigFactory(
            $this->tree,
            $this->db,
            $this->lng,
            $this->logger,
            $this->component_repository,
            $this,
            $this->questionrepository
        );
    }
 
    public function getLocalDIC(): TestDIC
    {
        return TestDIC::dic();
    }
 
    public function getTestLogger(): TestLogger
    {
        return $this->logger;
    }
 
    public function getTestLogViewer(): TestLogViewer
    {
        return $this->log_viewer;
    }
 
    public function getQuestionSetConfig(): ilTestQuestionSetConfig
    {
        return $this->question_set_config_factory->getQuestionSetConfig();
    }
 
    public function getTitleFilenameCompliant(): string
    {
        return ilFileUtils::getASCIIFilename($this->getTitle());
    }
 
    public function getTmpCopyWizardCopyId(): ?int
    {
        return $this->tmpCopyWizardCopyId;
    }
 
    public function setTmpCopyWizardCopyId(int $tmpCopyWizardCopyId): void
    {
        $this->tmpCopyWizardCopyId = $tmpCopyWizardCopyId;
    }
 
    public function create(): int
    {
        $id = parent::create();
        $this->createMetaData();
        return $id;
    }
 
    public function update(): bool
    {
        if (!parent::update()) {
            return false;
        }
 
        // put here object specific stuff
        $this->updateMetaData();
        return true;
    }
 
    public function read(): void
    {
        parent::read();
        $this->main_settings = null;
        $this->score_settings = null;
        $this->mark_schema = null;
        $this->loadFromDb();
    }
 
    public function delete(): bool
    {
        // always call parent delete function first!!
        if (!parent::delete()) {
            return false;
        }
 
        // delet meta data
        $this->deleteMetaData();
 
        //put here your module specific stuff
        $this->deleteTest();
 
        $qsaImportFails = new ilAssQuestionSkillAssignmentImportFails($this->getId());
        $qsaImportFails->deleteRegisteredImportFails();
        $sltImportFails = new ilTestSkillLevelThresholdImportFails($this->getId());
        $sltImportFails->deleteRegisteredImportFails();
 
        if ($this->logger->isLoggingEnabled()) {
            $this->logger->logTestAdministrationInteraction(
                $this->logger->getInteractionFactory()->buildTestAdministrationInteraction(
                    $this->getRefId(),
                    $this->user->getId(),
                    TestAdministrationInteractionTypes::TEST_DELETED,
                    [
                        AdditionalInformationGenerator::KEY_TEST_TITLE => $test_title = $this->title
                    ]
                )
            );
        }
 
        return true;
    }
 
    public function deleteTest(): void
    {
        $participantData = new ilTestParticipantData($this->db, $this->lng);
        $participantData->load($this->getTestId());
        $this->removeTestResults($participantData);
 
        $this->db->manipulateF(
            "DELETE FROM tst_mark WHERE test_fi = %s",
            ['integer'],
            [$this->getTestId()]
        );
 
        $this->db->manipulateF(
            "DELETE FROM tst_tests WHERE test_id = %s",
            ['integer'],
            [$this->getTestId()]
        );
 
        $this->db->manipulateF(
            "DELETE FROM tst_test_settings WHERE id = %s",
            ['integer'],
            [$this->getMainSettings()->getId()]
        );
 
        $tst_data_dir = ilFileUtils::getDataDir() . "/tst_data";
        $directory = $tst_data_dir . "/tst_" . $this->getId();
        if (is_dir($directory)) {
            ilFileUtils::delDir($directory);
        }
        $mobs = ilObjMediaObject::_getMobsOfObject("tst:html", $this->getId());
        // remaining usages are not in text anymore -> delete them
        // and media objects (note: delete method of ilObjMediaObject
        // checks whether object is used in another context; if yes,
        // the object is not deleted!)
        foreach ($mobs as $mob) {
            ilObjMediaObject::_removeUsage($mob, "tst:html", $this->getId());
            if (ilObjMediaObject::_exists($mob)) {
                $mob_obj = new ilObjMediaObject($mob);
                $mob_obj->delete();
            }
        }
    }
 
    public function createExportDirectory(): void
    {
        $tst_data_dir = ilFileUtils::getDataDir() . "/tst_data";
        ilFileUtils::makeDir($tst_data_dir);
        if (!is_writable($tst_data_dir)) {
            $this->ilias->raiseError("Test Data Directory (" . $tst_data_dir
                . ") not writeable.", $this->ilias->error_obj->MESSAGE);
        }
 
        // create learning module directory (data_dir/lm_data/lm_<id>)
        $tst_dir = $tst_data_dir . "/tst_" . $this->getId();
        ilFileUtils::makeDir($tst_dir);
        if (!@is_dir($tst_dir)) {
            $this->ilias->raiseError("Creation of Test Directory failed.", $this->ilias->error_obj->MESSAGE);
        }
        // create Export subdirectory (data_dir/lm_data/lm_<id>/Export)
        $export_dir = $tst_dir . "/export";
        ilFileUtils::makeDir($export_dir);
        if (!@is_dir($export_dir)) {
            $this->ilias->raiseError("Creation of Export Directory failed.", $this->ilias->error_obj->MESSAGE);
        }
    }
 
    public function getExportDirectory(): string
    {
        $export_dir = ilFileUtils::getDataDir() . "/tst_data" . "/tst_" . $this->getId() . "/export";
        return $export_dir;
    }
 
    public function getExportFiles(string $dir = ''): array
    {
        // quit if import dir not available
        if (!@is_dir($dir) || !is_writable($dir)) {
            return [];
        }
 
        $files = [];
        foreach (new DirectoryIterator($dir) as $file) {
            if ($file->isDir()) {
                continue;
            }
 
            $files[] = $file->getBasename();
        }
 
        sort($files);
 
        return $files;
    }
 
    public static function _createImportDirectory(): string
    {
        global $DIC;
        $ilias = $DIC['ilias'];
        $tst_data_dir = ilFileUtils::getDataDir() . "/tst_data";
        ilFileUtils::makeDir($tst_data_dir);
 
        if (!is_writable($tst_data_dir)) {
            $ilias->raiseError("Test Data Directory (" . $tst_data_dir
                . ") not writeable.", $ilias->error_obj->FATAL);
        }
 
        // create test directory (data_dir/tst_data/tst_import)
        $tst_dir = $tst_data_dir . "/tst_import";
        ilFileUtils::makeDir($tst_dir);
        if (!@is_dir($tst_dir)) {
            $ilias->raiseError("Creation of test import directory failed.", $ilias->error_obj->FATAL);
        }
 
        // assert that this is empty and does not contain old data
        ilFileUtils::delDir($tst_dir, true);
 
        return $tst_dir;
    }
 
    final public function isComplete(ilTestQuestionSetConfig $test_question_set_config): bool
    {
        if ($this->getMarkSchema() === null
            || $this->getMarkSchema()->getMarkSteps() === []) {
            return false;
        }
 
        if (!$test_question_set_config->isQuestionSetConfigured()) {
            return false;
        }
 
        return true;
    }
 
    public function saveCompleteStatus(ilTestQuestionSetConfig $test_question_set_config): void
    {
        $complete = 0;
        if ($this->isComplete($test_question_set_config)) {
            $complete = 1;
        }
        if ($this->getTestId() > 0) {
            $this->db->manipulateF(
                'UPDATE tst_tests SET complete = %s WHERE test_id = %s',
                ['text', 'integer'],
                [$complete, $this->test_id]
            );
        }
    }
 
    public function saveToDb(bool $properties_only = false): void
    {
        if ($this->test_id === -1) {
            // Create new dataset
            $next_id = $this->db->nextId('tst_tests');
 
            $this->db->insert(
                'tst_tests',
                [
                    'test_id' => ['integer', $next_id],
                    'obj_fi' => ['integer', $this->getId()],
                    'created' => ['integer', time()],
                    'tstamp' => ['integer', time()],
                    'template_id' => ['integer', $this->getTemplate()]
                ]
            );
 
            $this->test_id = $next_id;
 
            $this->getMainSettingsRepository()->store(
                $this->settings_factory->createDefaultMainSettings(),
                $this->getTestId()
            );
        } else {
            if ($this->evalTotalPersons() > 0) {
                // reset the finished status of participants if the nr of test passes did change
                if ($this->getNrOfTries() > 0) {
                    // set all unfinished tests with nr of passes >= allowed passes finished
                    $aresult = $this->db->queryF(
                        "SELECT active_id FROM tst_active WHERE test_fi = %s AND tries >= %s AND submitted = %s",
                        ['integer', 'integer', 'integer'],
                        [$this->getTestId(), $this->getNrOfTries(), 0]
                    );
                    while ($row = $this->db->fetchAssoc($aresult)) {
                        $this->db->manipulateF(
                            "UPDATE tst_active SET submitted = %s, submittimestamp = %s WHERE active_id = %s",
                            ['integer', 'timestamp', 'integer'],
                            [1, date('Y-m-d H:i:s'), $row["active_id"]]
                        );
                    }
 
                    // set all finished tests with nr of passes < allowed passes not finished
                    $aresult = $this->db->queryF(
                        "SELECT active_id FROM tst_active WHERE test_fi = %s AND tries < %s AND submitted = %s",
                        ['integer', 'integer', 'integer'],
                        [$this->getTestId(), $this->getNrOfTries() - 1, 1]
                    );
                    while ($row = $this->db->fetchAssoc($aresult)) {
                        $this->db->manipulateF(
                            "UPDATE tst_active SET submitted = %s, submittimestamp = %s WHERE active_id = %s",
                            ['integer', 'timestamp', 'integer'],
                            [0, null, $row["active_id"]]
                        );
                    }
                } else {
                    // set all finished tests with nr of passes >= allowed passes not finished
                    $aresult = $this->db->queryF(
                        "SELECT active_id FROM tst_active WHERE test_fi = %s AND submitted = %s",
                        ['integer', 'integer'],
                        [$this->getTestId(), 1]
                    );
                    while ($row = $this->db->fetchAssoc($aresult)) {
                        $this->db->manipulateF(
                            "UPDATE tst_active SET submitted = %s, submittimestamp = %s WHERE active_id = %s",
                            ['integer', 'timestamp', 'integer'],
                            [0, null, $row["active_id"]]
                        );
                    }
                }
            }
        }
 
        if ($properties_only) {
            return;
        }
 
        if ($this->getQuestionSetType() == self::QUESTION_SET_TYPE_FIXED) {
            $this->saveQuestionsToDb();
        }
 
        $this->marks_repository->storeMarkSchema($this->getMarkSchema());
    }
 
    public function saveQuestionsToDb(): void
    {
        $this->db->manipulateF(
            'DELETE FROM tst_test_question WHERE test_fi = %s',
            ['integer'],
            [$this->getTestId()]
        );
        foreach ($this->questions as $key => $value) {
            $next_id = $this->db->nextId('tst_test_question');
            $this->db->insert('tst_test_question', [
                'test_question_id' => ['integer', $next_id],
                'test_fi' => ['integer', $this->getTestId()],
                'question_fi' => ['integer', $value],
                'sequence' => ['integer', $key],
                'tstamp' => ['integer', time()]
            ]);
        }
    }
 
    public function copyQuestions(array $question_ids): void
    {
        $copy_count = 0;
        $question_titles = $this->getQuestionTitles();
 
        foreach ($question_ids as $id) {
            $question = assQuestion::instantiateQuestionGUI($id);
            if ($question) {
                $title = $question->getObject()->getTitle();
                $i = 2;
                while (in_array($title . ' (' . $i . ')', $question_titles)) {
                    $i++;
                }
 
                $title .= ' (' . $i . ')';
 
                $question_titles[] = $title;
 
                $new_id = $question->getObject()->duplicate(false, $title);
 
                $clone = assQuestion::instantiateQuestionGUI($new_id);
                $question = $clone->getObject();
                $question->setObjId($this->getId());
                $clone->setObject($question);
                $clone->getObject()->saveToDb();
 
                $this->insertQuestion($new_id, true);
 
                $copy_count++;
            }
        }
    }
 
    public function getNrOfResultsForPass($active_id, $pass): int
    {
        $result = $this->db->queryF(
            "SELECT test_result_id FROM tst_test_result WHERE active_fi = %s AND pass = %s",
            ['integer','integer'],
            [$active_id, $pass]
        );
        return $result->numRows();
    }
 
    public function loadFromDb(): void
    {
        $result = $this->db->queryF(
            "SELECT test_id FROM tst_tests WHERE obj_fi = %s",
            ['integer'],
            [$this->getId()]
        );
        if ($result->numRows() === 1) {
            $data = $this->db->fetchObject($result);
            $this->setTestId($data->test_id);
            $this->loadQuestions();
        }
    }
 
    public function loadQuestions(int $active_id = 0, ?int $pass = null): void
    {
        $this->questions = [];
        if ($this->isRandomTest()) {
            if ($active_id === 0) {
                $active_id = $this->getActiveIdOfUser($this->user->getId());
            }
            if (is_null($pass)) {
                $pass = self::_getPass($active_id);
            }
            $result = $this->db->queryF(
                'SELECT tst_test_rnd_qst.* '
                . 'FROM tst_test_rnd_qst, qpl_questions '
                . 'WHERE tst_test_rnd_qst.active_fi = %s '
                . 'AND qpl_questions.question_id = tst_test_rnd_qst.question_fi '
                . 'AND tst_test_rnd_qst.pass = %s '
                . 'ORDER BY sequence',
                ['integer', 'integer'],
                [$active_id, $pass]
            );
        } else {
            $result = $this->db->queryF(
                'SELECT tst_test_question.* '
                . 'FROM tst_test_question, qpl_questions '
                . 'WHERE tst_test_question.test_fi = %s '
                . 'AND qpl_questions.question_id = tst_test_question.question_fi '
                . 'ORDER BY sequence',
                ['integer'],
                [$this->test_id]
            );
        }
        $index = 1;
        if ($this->test_id !== -1) {
            //Omit loading of questions for non-id'ed test
            while ($data = $this->db->fetchAssoc($result)) {
                $this->questions[$index++] = $data["question_fi"];
            }
        }
    }
 
    public function getIntroduction(): string
    {
        $page_id = $this->getMainSettings()->getIntroductionSettings()->getIntroductionPageId();
        return $page_id !== null
            ? (new ilTestPageGUI('tst', $page_id))->showPage()
            : '';
    }
 
    private function cloneIntroduction(): ?int
    {
        $page_id = $this->getMainSettings()->getIntroductionSettings()->getIntroductionPageId();
        if ($page_id === null) {
            return null;
        }
        return $this->clonePage($page_id);
    }
 
    public function getFinalStatement(): string
    {
        $page_id = $this->getMainSettings()->getFinishingSettings()->getConcludingRemarksPageId();
        return $page_id !== null
            ? (new ilTestPageGUI('tst', $page_id))->showPage()
            : '';
    }
 
    private function cloneConcludingRemarks(): ?int
    {
        $page_id = $this->getMainSettings()->getFinishingSettings()->getConcludingRemarksPageId();
        if ($page_id === null) {
            return null;
        }
        return $this->clonePage($page_id);
    }
 
    private function clonePage(int $source_page_id): int
    {
        $page_object = new ilTestPage();
        $page_object->setParentId($this->getId());
        $new_page_id = $page_object->createPageWithNextId();
        (new ilTestPage($source_page_id))->copy($new_page_id);
        return $new_page_id;
    }
 
    public function getTestId(): int
    {
        return $this->test_id;
    }
 
    public function isPostponingEnabled(): bool
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getPostponedQuestionsMoveToEnd();
    }
 
    public function isScoreReportingEnabled(): bool
    {
        return $this->getScoreSettings()->getResultSummarySettings()->getScoreReporting()->isReportingEnabled();
    }
 
    public function getAnswerFeedbackPoints(): bool
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getInstantFeedbackPointsEnabled();
    }
 
    public function getGenericAnswerFeedback(): bool
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getInstantFeedbackGenericEnabled();
    }
 
    public function getInstantFeedbackSolution(): bool
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getInstantFeedbackSolutionEnabled();
    }
 
    public function getCountSystem(): int
    {
        return $this->getScoreSettings()->getScoringSettings()->getCountSystem();
    }
 
    private static function _getScoreSettingsByActiveId(int $active_id): ScoreSettings
    {
        return TestDIC::dic()['settings.scoring.repository']->getFor(
            ilObjTest::_getTestIDFromObjectID(ilObjTest::_getObjectIDFromActiveID($active_id)),
        );
    }
 
    public static function _getCountSystem(int $active_id): int
    {
        return self::_getScoreSettingsByActiveId($active_id)->getScoringSettings()->getCountSystem();
    }
 
    public function getScoreCutting(): int
    {
        return $this->getScoreSettings()->getScoringSettings()->getScoreCutting();
    }
 
    public function getPassScoring(): int
    {
        return $this->getScoreSettings()->getScoringSettings()->getPassScoring();
    }
 
    public static function _getPassScoring(int $active_id): int
    {
        return self::_getScoreSettingsByActiveId($active_id)->getScoringSettings()->getPassScoring();
    }
 
    public static function _getScoreCutting(int $active_id): bool
    {
        return (bool) self::_getScoreSettingsByActiveId($active_id)->getScoringSettings()->getScoreCutting();
    }
 
    public function getMarkSchema(): MarkSchema
    {
        if ($this->mark_schema === null) {
            $this->mark_schema = $this->marks_repository->getMarkSchemaFor($this->getTestId());
        }
 
        return $this->mark_schema;
    }
 
    public function storeMarkSchema(MarkSchema $mark_schema): void
    {
        $this->marks_repository->storeMarkSchema($mark_schema);
        $this->mark_schema = null;
    }
 
    public function getNrOfTries(): int
    {
        return $this->getMainSettings()->getTestBehaviourSettings()->getNumberOfTries();
    }
 
    public function isBlockPassesAfterPassedEnabled(): bool
    {
        return $this->getMainSettings()->getTestBehaviourSettings()->getBlockAfterPassedEnabled();
    }
 
    public function getKioskMode(): bool
    {
        return $this->getMainSettings()->getTestBehaviourSettings()->getKioskModeEnabled();
    }
 
    public function getShowKioskModeTitle(): bool
    {
        return $this->getMainSettings()->getTestBehaviourSettings()->getShowTitleInKioskMode();
    }
    public function getShowKioskModeParticipant(): bool
    {
        return $this->getMainSettings()->getTestBehaviourSettings()->getShowParticipantNameInKioskMode();
    }
 
    public function getUsePreviousAnswers(): bool
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getUsePreviousAnswerAllowed();
    }
 
    public function getTitleOutput(): int
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getQuestionTitleOutputMode();
    }
 
    public function isPreviousSolutionReuseEnabled(): bool
    {
        return $this->getUsePreviousAnswers() && $this->user->getPref('tst_use_previous_answers') === '1';
    }
 
    public function getProcessingTime(): ?string
    {
        return $this->getMainSettings()->getTestBehaviourSettings()->getProcessingTime();
    }
 
    private function getProcessingTimeForXML(): string
    {
        $processing_time = $this->getMainSettings()->getTestBehaviourSettings()->getProcessingTime();
        if ($processing_time === null
            || $processing_time === ''
            || !preg_match('/(\d{2}):(\d{2}):(\d{2})/is', $processing_time, $matches)
        ) {
            return '';
        }
 
        return sprintf(
            "P0Y0M0DT%dH%dM%dS",
            $matches[1],
            $matches[2],
            $matches[3]
        );
    }
 
    public function getProcessingTimeInSeconds(int $active_id = 0): int
    {
        $processing_time = $this->getMainSettings()->getTestBehaviourSettings()->getProcessingTime() ?? '';
        if (preg_match("/(\d{2}):(\d{2}):(\d{2})/", (string) $processing_time, $matches)) {
            $extratime = $this->getExtraTime($active_id) * 60;
            return ($matches[1] * 3600) + ($matches[2] * 60) + $matches[3] + $extratime;
        } else {
            return 0;
        }
    }
 
    public function getEnableProcessingTime(): bool
    {
        return $this->getMainSettings()->getTestBehaviourSettings()->getProcessingTimeEnabled();
    }
 
    public function getResetProcessingTime(): bool
    {
        return $this->getMainSettings()->getTestBehaviourSettings()->getResetProcessingTime();
    }
 
    public function isStartingTimeEnabled(): bool
    {
        return $this->getMainSettings()->getAccessSettings()->getStartTimeEnabled();
    }
 
    public function getStartingTime(): int
    {
        $start_time = $this->getMainSettings()->getAccessSettings()->getStartTime();
        return $start_time !== null ? $start_time->getTimestamp() : 0;
    }
 
    public function isEndingTimeEnabled(): bool
    {
        return $this->getMainSettings()->getAccessSettings()->getEndTimeEnabled();
    }
 
    public function getEndingTime(): int
    {
        $end_time = $this->getMainSettings()->getAccessSettings()->getEndTime();
        return $end_time !== null ? $end_time->getTimestamp() : 0;
    }
 
    public function isPasswordEnabled(): bool
    {
        return $this->getMainSettings()->getAccessSettings()->getPasswordEnabled();
    }
 
    public function getPassword(): ?string
    {
        return $this->getMainSettings()->getAccessSettings()->getPassword();
    }
 
    public function removeQuestionsWithResults(array $question_ids): void
    {
        $scoring = new TestScoring(
            $this,
            $this->user,
            $this->db,
            $this->test_result_repository
        );
 
        array_walk(
            $question_ids,
            fn(int $v, int $k) => $this->removeQuestionWithResults($v, $scoring)
        );
    }
 
    private function removeQuestionWithResults(int $question_id, TestScoring $scoring): void
    {
        $question = \assQuestion::instantiateQuestion($question_id);
 
        $participant_data = new ilTestParticipantData($this->db, $this->lng);
        $participant_data->load($this->test_id);
 
        $question->removeAllExistingSolutions();
        $scoring->removeAllQuestionResults($question_id);
 
        $this->removeQuestion($question_id);
        if (!$this->isRandomTest()) {
            $this->removeQuestionFromSequences(
                $question_id,
                $participant_data->getActiveIds(),
                $this->reindexFixedQuestionOrdering()
            );
        }
 
        $scoring->updatePassAndTestResults($participant_data->getActiveIds());
        ilLPStatusWrapper::_refreshStatus($this->getId(), $participant_data->getUserIds());
        $question->delete($question_id);
 
        if ($this->getTestQuestions() === []) {
            $object_properties = $this->getObjectProperties();
            $object_properties->storePropertyIsOnline(
                $object_properties->getPropertyIsOnline()->withOffline()
            );
        }
 
        if ($this->logger->isLoggingEnabled()) {
            $this->logger->logTestAdministrationInteraction(
                $this->logger->getInteractionFactory()->buildTestAdministrationInteraction(
                    $this->getRefId(),
                    $this->user->getId(),
                    TestAdministrationInteractionTypes::QUESTION_REMOVED_IN_CORRECTIONS,
                    [
                        AdditionalInformationGenerator::KEY_QUESTION_TITLE => $question->getTitleForHTMLOutput(),
                        AdditionalInformationGenerator::KEY_QUESTION_TEXT => $question->getQuestion(),
                        AdditionalInformationGenerator::KEY_QUESTION_ID => $question->getId(),
                        AdditionalInformationGenerator::KEY_QUESTION_TYPE => $question->getQuestionType()
                    ]
                )
            );
        }
    }
 
    public function removeQuestionFromSequences(
        int $question_id,
        array $active_ids,
        ilTestReindexedSequencePositionMap $reindexed_sequence_position_map
    ): void {
        $test_sequence_factory = new ilTestSequenceFactory(
            $this,
            $this->db,
            $this->questionrepository
        );
 
        foreach ($active_ids as $active_id) {
            $passSelector = new ilTestPassesSelector($this->db, $this);
            $passSelector->setActiveId($active_id);
 
            foreach ($passSelector->getExistingPasses() as $pass) {
                $test_sequence = $test_sequence_factory->getSequenceByActiveIdAndPass($active_id, $pass);
                $test_sequence->loadFromDb();
 
                $test_sequence->removeQuestion($question_id, $reindexed_sequence_position_map);
                $test_sequence->saveToDb();
            }
        }
    }
 
    public function removeQuestions(array $question_ids): void
    {
        foreach ($question_ids as $question_id) {
            $this->removeQuestion((int) $question_id);
        }
 
        $this->reindexFixedQuestionOrdering();
    }
 
    public function removeQuestion(int $question_id): void
    {
        try {
            $question = self::_instanciateQuestion($question_id);
            $question_title = $question->getTitleForHTMLOutput();
            $question->delete($question_id);
            if ($this->logger->isLoggingEnabled()) {
                $this->logger->logTestAdministrationInteraction(
                    $this->logger->getInteractionFactory()->buildTestAdministrationInteraction(
                        $this->getRefId(),
                        $this->user->getId(),
                        TestAdministrationInteractionTypes::QUESTION_REMOVED,
                        [
                            AdditionalInformationGenerator::KEY_QUESTION_TITLE => $question_title
                        ]
                    )
                );
            }
        } catch (InvalidArgumentException $e) {
            $this->logger->error($e->getMessage());
            $this->logger->error($e->getTraceAsString());
        }
    }
 
    public function removeTestResultsFromSoapLpAdministration(array $user_ids)
    {
        $this->removeTestResultsByUserIds($user_ids);
 
        $participantData = new ilTestParticipantData($this->db, $this->lng);
        $participantData->setUserIdsFilter($user_ids);
        $participantData->load($this->getTestId());
 
        $this->removeTestActives($participantData->getActiveIds());
 
 
        if ($this->logger->isLoggingEnabled()) {
            $this->logger->logTestAdministrationInteraction(
                $this->logger->getInteractionFactory()->buildTestAdministrationInteraction(
                    $this->getRefId(),
                    $this->user->getId(),
                    TestAdministrationInteractionTypes::PARTICIPANT_DATA_REMOVED,
                    [
                        AdditionalInformationGenerator::KEY_USERS => $participantData->getUserIds()
                    ]
                )
            );
        }
    }
 
    public function removeTestResults(ilTestParticipantData $participant_data): void
    {
        if ($participant_data->getAnonymousActiveIds() !== []) {
            $this->removeTestResultsByActiveIds($participant_data->getAnonymousActiveIds());
 
            $user_ids = array_map(
                static fn($active_id) => $participant_data->getUserIdByActiveId($active_id),
                $participant_data->getAnonymousActiveIds(),
            );
            $this->participant_repository->removeExtraTimeByUserId($this->getTestId(), $user_ids);
        }
 
        if ($participant_data->getUserIds() !== []) {
            /* @var ilTestLP $testLP */
            $test_lp = ilObjectLP::getInstance($this->getId());
            if ($test_lp instanceof ilTestLP) {
                $test_lp->setTestObject($this);
                $test_lp->resetLPDataForUserIds($participant_data->getUserIds(), false);
            }
 
            $this->participant_repository->removeExtraTimeByUserId($this->getTestId(), $participant_data->getUserIds());
        }
 
        if ($participant_data->getActiveIds() !== []) {
            $this->removeTestActives($participant_data->getActiveIds());
 
            $user_ids = array_map(
                static fn($active_id) => $participant_data->getUserIdByActiveId($active_id),
                $participant_data->getActiveIds(),
            );
            $this->participant_repository->removeExtraTimeByUserId($this->getTestId(), $user_ids);
        }
 
        if ($this->logger->isLoggingEnabled()) {
            $this->logger->logTestAdministrationInteraction(
                $this->logger->getInteractionFactory()->buildTestAdministrationInteraction(
                    $this->getRefId(),
                    $this->user->getId(),
                    TestAdministrationInteractionTypes::PARTICIPANT_DATA_REMOVED,
                    [
                        AdditionalInformationGenerator::KEY_USERS => $participant_data->getUserIds(),
                        AdditionalInformationGenerator::KEY_ANON_IDS => $participant_data->getAnonymousActiveIds()
                    ]
                )
            );
        }
    }
 
    public function removeTestResultsByUserIds(array $user_ids): void
    {
        $participantData = new ilTestParticipantData($this->db, $this->lng);
        $participantData->setUserIdsFilter($user_ids);
        $participantData->load($this->getTestId());
 
        $in_user_ids = $this->db->in('usr_id', $participantData->getUserIds(), false, 'integer');
        $this->db->manipulateF(
            "DELETE FROM usr_pref WHERE {$in_user_ids} AND keyword = %s",
            ['text'],
            ['tst_password_' . $this->getTestId()]
        );
 
        if ($participantData->getActiveIds() !== []) {
            $this->removeTestResultsByActiveIds($participantData->getActiveIds());
        }
    }
 
    private function removeTestResultsByActiveIds(array $active_ids): void
    {
        $in_active_ids = $this->db->in('active_fi', $active_ids, false, 'integer');
 
        $this->db->manipulate("DELETE FROM tst_solutions WHERE {$in_active_ids}");
        $this->db->manipulate("DELETE FROM tst_qst_solved WHERE {$in_active_ids}");
        $this->db->manipulate("DELETE FROM tst_test_result WHERE {$in_active_ids}");
        $this->db->manipulate("DELETE FROM tst_pass_result WHERE {$in_active_ids}");
        $this->db->manipulate("DELETE FROM tst_result_cache WHERE {$in_active_ids}");
        $this->db->manipulate("DELETE FROM tst_sequence WHERE {$in_active_ids}");
        $this->db->manipulate("DELETE FROM tst_times WHERE {$in_active_ids}");
        $this->db->manipulate(
            'DELETE FROM ' . PassPresentedVariablesRepo::TABLE_NAME
            . ' WHERE ' . $this->db->in('active_id', $active_ids, false, 'integer')
        );
 
        if ($this->isRandomTest()) {
            $this->db->manipulate("DELETE FROM tst_test_rnd_qst WHERE {$in_active_ids}");
        }
 
        $this->test_result_repository->removeTestResults($active_ids, $this->getId());
 
        foreach ($active_ids as $active_id) {
            // remove file uploads
            if (is_dir(CLIENT_WEB_DIR . "/assessment/tst_" . $this->getTestId() . "/$active_id")) {
                ilFileUtils::delDir(CLIENT_WEB_DIR . "/assessment/tst_" . $this->getTestId() . "/$active_id");
            }
        }
    }
 
    public function removeTestActives(array $active_ids): void
    {
        $IN_activeIds = $this->db->in('active_id', $active_ids, false, 'integer');
        $this->db->manipulate("DELETE FROM tst_active WHERE $IN_activeIds");
    }
 
    public function questionMoveUp($question_id)
    {
        // Move a question up in sequence
        $result = $this->db->queryF(
            "SELECT * FROM tst_test_question WHERE test_fi=%s AND question_fi=%s",
            ['integer', 'integer'],
            [$this->getTestId(), $question_id]
        );
        $data = $this->db->fetchObject($result);
        if ($data->sequence > 1) {
            // OK, it's not the top question, so move it up
            $result = $this->db->queryF(
                "SELECT * FROM tst_test_question WHERE test_fi=%s AND sequence=%s",
                ['integer','integer'],
                [$this->getTestId(), $data->sequence - 1]
            );
            $data_previous = $this->db->fetchObject($result);
            // change previous dataset
            $this->db->manipulateF(
                "UPDATE tst_test_question SET sequence=%s WHERE test_question_id=%s",
                ['integer','integer'],
                [$data->sequence, $data_previous->test_question_id]
            );
            // move actual dataset up
            $this->db->manipulateF(
                "UPDATE tst_test_question SET sequence=%s WHERE test_question_id=%s",
                ['integer','integer'],
                [$data->sequence - 1, $data->test_question_id]
            );
        }
        $this->loadQuestions();
    }
 
    public function questionMoveDown($question_id)
    {
        $current_question_result = $this->db->queryF(
            "SELECT * FROM tst_test_question WHERE test_fi=%s AND question_fi=%s",
            ['integer','integer'],
            [$this->getTestId(), $question_id]
        );
        $current_question_data = $this->db->fetchObject($current_question_result);
        $next_question_result = $this->db->queryF(
            "SELECT * FROM tst_test_question WHERE test_fi=%s AND sequence=%s",
            ['integer','integer'],
            [$this->getTestId(), $current_question_data->sequence + 1]
        );
        if ($this->db->numRows($next_question_result) === 1) {
            // OK, it's not the last question, so move it down
            $next_question_data = $this->db->fetchObject($next_question_result);
            // change next dataset
            $this->db->manipulateF(
                "UPDATE tst_test_question SET sequence=%s WHERE test_question_id=%s",
                ['integer','integer'],
                [$current_question_data->sequence, $next_question_data->test_question_id]
            );
            // move actual dataset down
            $this->db->manipulateF(
                "UPDATE tst_test_question SET sequence=%s WHERE test_question_id=%s",
                ['integer','integer'],
                [$current_question_data->sequence + 1, $current_question_data->test_question_id]
            );
        }
        $this->loadQuestions();
    }
 
    public function duplicateQuestionForTest($question_id): int
    {
        $question = ilObjTest::_instanciateQuestion($question_id);
        $duplicate_id = $question->duplicate(true, '', '', -1, $this->getId());
        return $duplicate_id;
    }
 
    public function insertQuestion(int $question_id, bool $link_only = false): int
    {
        if ($link_only) {
            $duplicate_id = $question_id;
        } else {
            $duplicate_id = $this->duplicateQuestionForTest($question_id);
        }
 
        // get maximum sequence index in test
        $result = $this->db->queryF(
            "SELECT MAX(sequence) seq FROM tst_test_question WHERE test_fi=%s",
            ['integer'],
            [$this->getTestId()]
        );
        $sequence = 1;
 
        if ($result->numRows() == 1) {
            $data = $this->db->fetchObject($result);
            $sequence = $data->seq + 1;
        }
 
        $next_id = $this->db->nextId('tst_test_question');
        $this->db->manipulateF(
            "INSERT INTO tst_test_question (test_question_id, test_fi, question_fi, sequence, tstamp) VALUES (%s, %s, %s, %s, %s)",
            ['integer', 'integer','integer','integer','integer'],
            [$next_id, $this->getTestId(), $duplicate_id, $sequence, time()]
        );
        // remove test_active entries, because test has changed
        $this->db->manipulateF(
            "DELETE FROM tst_active WHERE test_fi = %s",
            ['integer'],
            [$this->getTestId()]
        );
        $this->loadQuestions();
        $this->saveCompleteStatus($this->question_set_config_factory->getQuestionSetConfig());
 
        if ($this->logger->isLoggingEnabled()) {
            $this->logger->logTestAdministrationInteraction(
                $this->logger->getInteractionFactory()->buildTestAdministrationInteraction(
                    $this->getRefId(),
                    $this->user->getId(),
                    TestAdministrationInteractionTypes::QUESTION_ADDED,
                    [
                        AdditionalInformationGenerator::KEY_QUESTION_ID => $question_id
                    ] + (assQuestion::instantiateQuestion($question_id))
                            ->toLog($this->logger->getAdditionalInformationGenerator())
                )
            );
        }
 
        return $duplicate_id;
    }
 
    private function getQuestionTitles(): array
    {
        $titles = [];
        if ($this->getQuestionSetType() === self::QUESTION_SET_TYPE_FIXED) {
            $result = $this->db->queryF(
                'SELECT qpl_questions.title FROM tst_test_question, qpl_questions '
                . 'WHERE tst_test_question.test_fi = %s AND tst_test_question.question_fi = qpl_questions.question_id '
                . 'ORDER BY tst_test_question.sequence',
                ['integer'],
                [$this->getTestId()]
            );
            while ($row = $this->db->fetchAssoc($result)) {
                array_push($titles, $row['title']);
            }
        }
        return $titles;
    }
 
    public function getQuestionTitlesAndIndexes(): array
    {
        $titles = [];
        if ($this->getQuestionSetType() == self::QUESTION_SET_TYPE_FIXED) {
            $result = $this->db->queryF(
                'SELECT qpl_questions.title, qpl_questions.question_id '
                . 'FROM tst_test_question, qpl_questions '
                . 'WHERE tst_test_question.test_fi = %s AND tst_test_question.question_fi = qpl_questions.question_id '
                . 'ORDER BY tst_test_question.sequence',
                ['integer'],
                [$this->getTestId()]
            );
            while ($row = $this->db->fetchAssoc($result)) {
                $titles[$row['question_id']] = $row["title"];
            }
        }
        return $titles;
    }
 
    // fau: testNav - add number parameter (to show if title should not be shown)
    public function getQuestionTitle($title, $nr = null, $points = null): string
    {
        switch ($this->getTitleOutput()) {
            case '0':
            case '1':
                return $title;
                break;
            case '2':
                if (isset($nr)) {
                    return $this->lng->txt("ass_question") . ' ' . $nr;
                }
                return $this->lng->txt("ass_question");
                break;
            case 3:
                if (isset($nr)) {
                    $txt = $this->lng->txt("ass_question") . ' ' . $nr;
                } else {
                    $txt = $this->lng->txt("ass_question");
                }
                if ($points != '') {
                    $lngv = $this->lng->txt('points');
                    if ($points == 1) {
                        $lngv = $this->lng->txt('point');
                    }
                    $txt .= ' - ' . $points . ' ' . $lngv;
                }
                return $txt;
                break;
 
        }
        return $this->lng->txt("ass_question");
    }
    // fau.
 
    public function getQuestionDataset($question_id): object
    {
        $result = $this->db->queryF(
            "SELECT qpl_questions.*, qpl_qst_type.type_tag FROM qpl_questions, qpl_qst_type WHERE qpl_questions.question_id = %s AND qpl_questions.question_type_fi = qpl_qst_type.question_type_id",
            ['integer'],
            [$question_id]
        );
        $row = $this->db->fetchObject($result);
        return $row;
    }
 
    public function &getExistingQuestions($pass = null): array
    {
        $existing_questions = [];
        $active_id = $this->getActiveIdOfUser($this->user->getId());
        if ($this->isRandomTest()) {
            if (is_null($pass)) {
                $pass = 0;
            }
            $result = $this->db->queryF(
                "SELECT qpl_questions.original_id FROM qpl_questions, tst_test_rnd_qst WHERE tst_test_rnd_qst.active_fi = %s AND tst_test_rnd_qst.question_fi = qpl_questions.question_id AND tst_test_rnd_qst.pass = %s",
                ['integer','integer'],
                [$active_id, $pass]
            );
        } else {
            $result = $this->db->queryF(
                "SELECT qpl_questions.original_id FROM qpl_questions, tst_test_question WHERE tst_test_question.test_fi = %s AND tst_test_question.question_fi = qpl_questions.question_id",
                ['integer'],
                [$this->getTestId()]
            );
        }
        while ($data = $this->db->fetchObject($result)) {
            if ($data->original_id === null) {
                continue;
            }
 
            array_push($existing_questions, $data->original_id);
        }
        return $existing_questions;
    }
 
    public function getQuestionType($question_id)
    {
        if ($question_id < 1) {
            return -1;
        }
        $result = $this->db->queryF(
            "SELECT type_tag FROM qpl_questions, qpl_qst_type WHERE qpl_questions.question_id = %s AND qpl_questions.question_type_fi = qpl_qst_type.question_type_id",
            ['integer'],
            [$question_id]
        );
        if ($result->numRows() == 1) {
            $data = $this->db->fetchObject($result);
            return $data->type_tag;
        } else {
            return "";
        }
    }
 
    public function startWorkingTime($active_id, $pass)
    {
        $next_id = $this->db->nextId('tst_times');
        $affectedRows = $this->db->manipulateF(
            "INSERT INTO tst_times (times_id, active_fi, started, finished, pass, tstamp) VALUES (%s, %s, %s, %s, %s, %s)",
            ['integer', 'integer', 'timestamp', 'timestamp', 'integer', 'integer'],
            [$next_id, $active_id, date("Y-m-d H:i:s"), date("Y-m-d H:i:s"), $pass, time()]
        );
        return $next_id;
    }
 
    public function updateWorkingTime($times_id)
    {
        $affectedRows = $this->db->manipulateF(
            "UPDATE tst_times SET finished = %s, tstamp = %s WHERE times_id = %s",
            ['timestamp', 'integer', 'integer'],
            [date('Y-m-d H:i:s'), time(), $times_id]
        );
    }
 
    public function &getWorkedQuestions($active_id, $pass = null): array
    {
        if (is_null($pass)) {
            $result = $this->db->queryF(
                "SELECT question_fi FROM tst_solutions WHERE active_fi = %s AND pass = %s GROUP BY question_fi",
                ['integer','integer'],
                [$active_id, 0]
            );
        } else {
            $result = $this->db->queryF(
                "SELECT question_fi FROM tst_solutions WHERE active_fi = %s AND pass = %s GROUP BY question_fi",
                ['integer','integer'],
                [$active_id, $pass]
            );
        }
        $result_array = [];
        while ($row = $this->db->fetchAssoc($result)) {
            array_push($result_array, $row["question_fi"]);
        }
        return $result_array;
    }
 
    public function isTestFinishedToViewResults($active_id, $currentpass): bool
    {
        $num = ilObjTest::lookupPassResultsUpdateTimestamp($active_id, $currentpass);
        return ((($currentpass > 0) && ($num == 0)) || $this->isTestFinished($active_id)) ? true : false;
    }
 
    public function getAllQuestions($pass = null): array
    {
        if ($this->isRandomTest()) {
            $active_id = $this->getActiveIdOfUser($this->user->getId());
            if ($active_id === null) {
                return [];
            }
            $this->loadQuestions($active_id, $pass);
            if (count($this->questions) === 0) {
                return [];
            }
            if (is_null($pass)) {
                $pass = self::_getPass($active_id);
            }
            $result = $this->db->queryF(
                "SELECT qpl_questions.* FROM qpl_questions, tst_test_rnd_qst WHERE tst_test_rnd_qst.question_fi = qpl_questions.question_id AND tst_test_rnd_qst.active_fi = %s AND tst_test_rnd_qst.pass = %s AND " . $this->db->in('qpl_questions.question_id', $this->questions, false, 'integer'),
                ['integer','integer'],
                [$active_id, $pass]
            );
        } else {
            if (count($this->questions) === 0) {
                return [];
            }
            $result = $this->db->query("SELECT qpl_questions.* FROM qpl_questions, tst_test_question WHERE tst_test_question.question_fi = qpl_questions.question_id AND " . $this->db->in('qpl_questions.question_id', $this->questions, false, 'integer'));
        }
        $result_array = [];
        while ($row = $this->db->fetchAssoc($result)) {
            $result_array[$row["question_id"]] = $row;
        }
        return $result_array;
    }
 
    public function getActiveIdOfUser($user_id = "", $anonymous_id = ""): ?int
    {
        if (!$user_id) {
            $user_id = $this->user->getId();
        }
 
        $tst_access_code = ilSession::get('tst_access_code');
        if (is_array($tst_access_code) &&
            $this->user->getId() === ANONYMOUS_USER_ID &&
            isset($tst_access_code[$this->getTestId()]) &&
            $tst_access_code[$this->getTestId()] !== '') {
            $result = $this->db->queryF(
                'SELECT active_id FROM tst_active WHERE user_fi = %s AND test_fi = %s AND anonymous_id = %s',
                ['integer', 'integer', 'text'],
                [$user_id, $this->test_id, $tst_access_code[$this->getTestId()]]
            );
        } elseif ((string) $anonymous_id !== '') {
            $result = $this->db->queryF(
                'SELECT active_id FROM tst_active WHERE user_fi = %s AND test_fi = %s AND anonymous_id = %s',
                ['integer', 'integer', 'text'],
                [$user_id, $this->test_id, $anonymous_id]
            );
        } else {
            if ((int) $user_id === ANONYMOUS_USER_ID) {
                return null;
            }
            $result = $this->db->queryF(
                'SELECT active_id FROM tst_active WHERE user_fi = %s AND test_fi = %s',
                ['integer', 'integer'],
                [$user_id, $this->test_id]
            );
        }
 
        if ($result->numRows()) {
            $row = $this->db->fetchAssoc($result);
            return (int) $row['active_id'];
        }
 
        return null;
    }
 
    public static function _getActiveIdOfUser($user_id = "", $test_id = "")
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $ilUser = $DIC['ilUser'];
 
        if (!$user_id) {
            $user_id = $ilUser->id;
        }
        if (!$test_id) {
            return "";
        }
        $result = $ilDB->queryF(
            "SELECT tst_active.active_id FROM tst_active WHERE user_fi = %s AND test_fi = %s",
            ['integer', 'integer'],
            [$user_id, $test_id]
        );
        if ($result->numRows()) {
            $row = $ilDB->fetchAssoc($result);
            return $row["active_id"];
        } else {
            return "";
        }
    }
 
    public function pcArrayShuffle($array): array
    {
        $keys = array_keys($array);
        shuffle($keys);
        $result = [];
        foreach ($keys as $key) {
            $result[$key] = $array[$key];
        }
        return $result;
    }
 
    public function getTestResult(
        int $active_id,
        ?int $attempt = null,
        bool $ordered_sequence = false,
        bool $consider_hidden_questions = true,
        bool $consider_optional_questions = true
    ): array {
        $test_result = $this->test_result_repository->getTestResult($active_id);
 
        if ($test_result === null) {
            $test_result = $this->test_result_repository->updateTestResultCache($active_id);
        }
 
        if ($attempt === null) {
            $attempt = $test_result->getAttempt();
        }
 
        $test_sequence_factory = new ilTestSequenceFactory($this, $this->db, $this->questionrepository);
        $test_sequence = $test_sequence_factory->getSequenceByActiveIdAndPass($active_id, $attempt);
 
        $test_sequence->setConsiderHiddenQuestionsEnabled($consider_hidden_questions);
        $test_sequence->setConsiderOptionalQuestionsEnabled($consider_optional_questions);
 
        $test_sequence->loadFromDb();
        $test_sequence->loadQuestions();
 
        if ($ordered_sequence) {
            $sequence = $test_sequence->getOrderedSequenceQuestions();
        } else {
            $sequence = $test_sequence->getUserSequenceQuestions();
        }
 
        $arr_results = [];
 
        $query = "
            SELECT
                tst_test_result.question_fi,
                tst_test_result.points reached,
                tst_test_result.answered answered,
                tst_manual_fb.finalized_evaluation finalized_evaluation
 
            FROM tst_test_result
 
            LEFT JOIN tst_solutions
            ON tst_solutions.active_fi = tst_test_result.active_fi
            AND tst_solutions.question_fi = tst_test_result.question_fi
 
            LEFT JOIN tst_manual_fb
            ON tst_test_result.active_fi = tst_manual_fb.active_fi
            AND tst_test_result.question_fi = tst_manual_fb.question_fi
 
            WHERE tst_test_result.active_fi = %s
            AND tst_test_result.pass = %s
        ";
 
        $solutionresult = $this->db->queryF(
            $query,
            ['integer', 'integer'],
            [$active_id, $attempt]
        );
 
        while ($row = $this->db->fetchAssoc($solutionresult)) {
            $arr_results[ $row['question_fi'] ] = $row;
        }
 
        $result = $this->db->query(
            'SELECT qpl_questions.*, qpl_qst_type.type_tag, qpl_sol_sug.question_fi has_sug_sol' . PHP_EOL
            . 'FROM     qpl_qst_type, qpl_questions' . PHP_EOL
            . 'LEFT JOIN qpl_sol_sug' . PHP_EOL
            . 'ON qpl_sol_sug.question_fi = qpl_questions.question_id' . PHP_EOL
            . 'WHERE qpl_qst_type.question_type_id = qpl_questions.question_type_fi' . PHP_EOL
            . 'AND ' . $this->db->in('qpl_questions.question_id', $sequence, false, 'integer')
        );
 
        $unordered = [];
        $key = 1;
        while ($row = $this->db->fetchAssoc($result)) {
            if (!isset($arr_results[ $row['question_id'] ])) {
                $percentvalue = 0.0;
            } else {
                $percentvalue = (
                    $row['points'] ? $arr_results[$row['question_id']]['reached'] / $row['points'] : 0
                );
            }
            if ($percentvalue < 0) {
                $percentvalue = 0.0;
            }
 
            $data = [
                'nr' => $key,
                'title' => ilLegacyFormElementsUtil::prepareFormOutput($row['title']),
                'max' => round($row['points'], 2),
                'reached' => round($arr_results[$row['question_id']]['reached'] ?? 0, 2),
                'percent' => sprintf('%2.2f ', ($percentvalue) * 100) . '%',
                'solution' => ($row['has_sug_sol']) ? assQuestion::_getSuggestedSolutionOutput($row['question_id']) : '',
                'type' => $row['type_tag'],
                'qid' => $row['question_id'],
                'original_id' => $row['original_id'],
                'workedthrough' => isset($arr_results[$row['question_id']]) ? 1 : 0,
                'answered' => $arr_results[$row['question_id']]['answered'] ?? 0,
                'finalized_evaluation' => $arr_results[$row['question_id']]['finalized_evaluation'] ?? 0,
            ];
 
            $unordered[ $row['question_id'] ] = $data;
            $key++;
        }
 
        $pass_max = 0;
        $pass_reached = 0;
 
        $found = [];
        foreach ($sequence as $qid) {
            // building pass point sums based on prepared data
            // for question that exists in users qst sequence
            $pass_max += round($unordered[$qid]['max'], 2);
            $pass_reached += round($unordered[$qid]['reached'], 2);
            $found[] = $unordered[$qid];
        }
 
        if ($this->getScoreCutting() == 1) {
            if ($pass_reached < 0) {
                $pass_reached = 0;
            }
        }
 
        $found['pass']['total_max_points'] = $pass_max;
        $found['pass']['total_reached_points'] = $pass_reached;
        $found['pass']['percent'] = ($pass_max > 0) ? $pass_reached / $pass_max : 0;
        $found['pass']['num_workedthrough'] = count($arr_results);
        $found['pass']['num_questions_total'] = count($unordered);
 
        $found['test']['total_max_points'] = $test_result->getMaxPoints();
        $found['test']['total_reached_points'] = $test_result->getReachedPoints();
        $found['test']['result_pass'] = $attempt;
        $found['test']['result_tstamp'] = $test_result->getTimestamp();
        $found['test']['passed'] = $test_result->isPassed();
 
        return $found;
    }
 
    public function evalTotalPersons(): int
    {
        $result = $this->db->queryF(
            'SELECT COUNT(active_id) total FROM tst_active WHERE test_fi = %s',
            ['integer'],
            [$this->getTestId()]
        );
        $row = $this->db->fetchAssoc($result);
        return $row['total'];
    }
 
    public function getCompleteWorkingTime($user_id): int
    {
        $result = $this->db->queryF(
            "SELECT tst_times.* FROM tst_active, tst_times WHERE tst_active.test_fi = %s AND tst_active.active_id = tst_times.active_fi AND tst_active.user_fi = %s",
            ['integer','integer'],
            [$this->getTestId(), $user_id]
        );
        $time = 0;
        while ($row = $this->db->fetchAssoc($result)) {
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row["started"], $matches);
            $epoch_1 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row["finished"], $matches);
            $epoch_2 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            $time += ($epoch_2 - $epoch_1);
        }
        return $time;
    }
 
    public function &getCompleteWorkingTimeOfParticipants(): array
    {
        return $this->_getCompleteWorkingTimeOfParticipants($this->getTestId());
    }
 
    public function &_getCompleteWorkingTimeOfParticipants($test_id): array
    {
        $result = $this->db->queryF(
            "SELECT tst_times.* FROM tst_active, tst_times WHERE tst_active.test_fi = %s AND tst_active.active_id = tst_times.active_fi ORDER BY tst_times.active_fi, tst_times.started",
            ['integer'],
            [$test_id]
        );
        $time = 0;
        $times = [];
        while ($row = $this->db->fetchAssoc($result)) {
            if (!array_key_exists($row["active_fi"], $times)) {
                $times[$row["active_fi"]] = 0;
            }
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row["started"], $matches);
            $epoch_1 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row["finished"], $matches);
            $epoch_2 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            $times[$row["active_fi"]] += ($epoch_2 - $epoch_1);
        }
        return $times;
    }
 
    public function getCompleteWorkingTimeOfParticipant($active_id): int
    {
        $result = $this->db->queryF(
            "SELECT tst_times.* FROM tst_active, tst_times WHERE tst_active.test_fi = %s AND tst_active.active_id = tst_times.active_fi AND tst_active.active_id = %s ORDER BY tst_times.active_fi, tst_times.started",
            ['integer','integer'],
            [$this->getTestId(), $active_id]
        );
        $time = 0;
        while ($row = $this->db->fetchAssoc($result)) {
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row["started"], $matches);
            $epoch_1 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row["finished"], $matches);
            $epoch_2 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            $time += ($epoch_2 - $epoch_1);
        }
        return $time;
    }
 
    public function getWorkingTimeOfParticipantForPass(int $active_id, int $pass): int
    {
        return $this->test_result_repository->fetchWorkingTime($active_id, $pass);
    }
 
    public function evalStatistical($active_id): array
    {
        $pass = ilObjTest::_getResultPass($active_id);
        $test_result = &$this->getTestResult($active_id, $pass);
        $result = $this->db->queryF(
            "SELECT tst_times.* FROM tst_active, tst_times WHERE tst_active.active_id = %s AND tst_active.active_id = tst_times.active_fi",
            ['integer'],
            [$active_id]
        );
        $times = [];
        $first_visit = 0;
        $last_visit = 0;
        while ($row = $this->db->fetchObject($result)) {
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row->started, $matches);
            $epoch_1 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            if (!$first_visit) {
                $first_visit = $epoch_1;
            }
            if ($epoch_1 < $first_visit) {
                $first_visit = $epoch_1;
            }
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row->finished, $matches);
            $epoch_2 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            if (!$last_visit) {
                $last_visit = $epoch_2;
            }
            if ($epoch_2 > $last_visit) {
                $last_visit = $epoch_2;
            }
            $times[$row->active_fi] += ($epoch_2 - $epoch_1);
        }
        $max_time = 0;
        foreach ($times as $key => $value) {
            $max_time += $value;
        }
        if ((!$test_result["test"]["total_reached_points"]) or (!$test_result["test"]["total_max_points"])) {
            $percentage = 0.0;
        } else {
            $percentage = ($test_result["test"]["total_reached_points"] / $test_result["test"]["total_max_points"]) * 100.0;
            if ($percentage < 0) {
                $percentage = 0.0;
            }
        }
        $mark_obj = $this->getMarkSchema()->getMatchingMark($percentage);
        $first_date = getdate($first_visit);
        $last_date = getdate($last_visit);
        $qworkedthrough = 0;
        foreach ($test_result as $key => $value) {
            if (preg_match("/\d+/", $key)) {
                $qworkedthrough += $value["workedthrough"];
            }
        }
        if (!$qworkedthrough) {
            $atimeofwork = 0;
        } else {
            $atimeofwork = $max_time / $qworkedthrough;
        }
 
        $result_mark = "";
        $passed = "";
 
        if ($mark_obj !== null) {
            $result_mark = $mark_obj->getShortName();
 
            if ($mark_obj->getPassed()) {
                $passed = 1;
            } else {
                $passed = 0;
            }
        }
        $percent_worked_through = 0;
        if (count($this->questions)) {
            $percent_worked_through = $qworkedthrough / count($this->questions);
        }
        $result_array = [
            "qworkedthrough" => $qworkedthrough,
            "qmax" => count($this->questions),
            "pworkedthrough" => $percent_worked_through,
            "timeofwork" => $max_time,
            "atimeofwork" => $atimeofwork,
            "firstvisit" => $first_date,
            "lastvisit" => $last_date,
            "resultspoints" => $test_result["test"]["total_reached_points"],
            "maxpoints" => $test_result["test"]["total_max_points"],
            "resultsmarks" => $result_mark,
            "passed" => $passed,
            "distancemedian" => "0"
        ];
        foreach ($test_result as $key => $value) {
            if (preg_match("/\d+/", $key)) {
                $result_array[$key] = $value;
            }
        }
        return $result_array;
    }
 
    public function getTotalPointsPassedArray(): array
    {
        $totalpoints_array = [];
        $all_users = $this->evalTotalParticipantsArray();
        foreach ($all_users as $active_id => $user_name) {
            $test_result = &$this->getTestResult($active_id);
            $reached = $test_result["test"]["total_reached_points"];
            $total = $test_result["test"]["total_max_points"];
            $percentage = $total != 0 ? $reached / $total : 0;
            $mark = $this->getMarkSchema()->getMatchingMark($percentage * 100.0);
 
            if ($mark !== null && $mark->getPassed()) {
                array_push($totalpoints_array, $test_result["test"]["total_reached_points"]);
            }
        }
        return $totalpoints_array;
    }
 
    public function getParticipants(): array
    {
        $result = $this->db->queryF(
            "SELECT tst_active.active_id, usr_data.usr_id, usr_data.firstname, usr_data.lastname, usr_data.title, usr_data.login FROM tst_active LEFT JOIN usr_data ON tst_active.user_fi = usr_data.usr_id WHERE tst_active.test_fi = %s ORDER BY usr_data.lastname ASC",
            ['integer'],
            [$this->getTestId()]
        );
        $persons_array = [];
        while ($row = $this->db->fetchAssoc($result)) {
            $name = $this->lng->txt("anonymous");
            $fullname = $this->lng->txt("anonymous");
            $login = "";
            if (!$this->getAnonymity()) {
                if (strlen($row["firstname"] . $row["lastname"] . $row["title"]) == 0) {
                    $name = $this->lng->txt("deleted_user");
                    $fullname = $this->lng->txt("deleted_user");
                    $login = $this->lng->txt("unknown");
                } else {
                    $login = $row["login"];
                    if ($row["usr_id"] == ANONYMOUS_USER_ID) {
                        $name = $this->lng->txt("anonymous");
                        $fullname = $this->lng->txt("anonymous");
                    } else {
                        $name = trim($row["lastname"] . ", " . $row["firstname"] . " " . $row["title"]);
                        $fullname = trim($row["title"] . " " . $row["firstname"] . " " . $row["lastname"]);
                    }
                }
            }
            $persons_array[$row["active_id"]] = [
                "name" => $name,
                "fullname" => $fullname,
                "login" => $login
            ];
        }
        return $persons_array;
    }
 
    public function evalTotalPersonsArray(string $name_sort_order = 'asc'): array
    {
        $result = $this->db->queryF(
            "SELECT tst_active.user_fi, tst_active.active_id, usr_data.firstname, usr_data.lastname, usr_data.title FROM tst_active LEFT JOIN usr_data ON tst_active.user_fi = usr_data.usr_id WHERE tst_active.test_fi = %s ORDER BY usr_data.lastname " . strtoupper($name_sort_order),
            ['integer'],
            [$this->getTestId()]
        );
        $persons_array = [];
        while ($row = $this->db->fetchAssoc($result)) {
            if ($this->getAccessFilteredParticipantList() && !$this->getAccessFilteredParticipantList()->isActiveIdInList($row["active_id"])) {
                continue;
            }
 
            if ($this->getAnonymity()) {
                $persons_array[$row["active_id"]] = $this->lng->txt("anonymous");
            } else {
                if (strlen($row["firstname"] . $row["lastname"] . $row["title"]) == 0) {
                    $persons_array[$row["active_id"]] = $this->lng->txt("deleted_user");
                } else {
                    if ($row["user_fi"] == ANONYMOUS_USER_ID) {
                        $persons_array[$row["active_id"]] = $row["lastname"];
                    } else {
                        $persons_array[$row["active_id"]] = trim($row["lastname"] . ", " . $row["firstname"] . " " . $row["title"]);
                    }
                }
            }
        }
        return $persons_array;
    }
 
    public function evalTotalParticipantsArray(string $name_sort_order = 'asc'): array
    {
        $result = $this->db->queryF(
            'SELECT tst_active.user_fi, tst_active.active_id, usr_data.login, '
            . 'usr_data.firstname, usr_data.lastname, usr_data.title FROM tst_active '
            . 'LEFT JOIN usr_data ON tst_active.user_fi = usr_data.usr_id '
            . 'WHERE tst_active.test_fi = %s '
            . 'ORDER BY usr_data.lastname ' . strtoupper($name_sort_order),
            ['integer'],
            [$this->getTestId()]
        );
        $persons_array = [];
        while ($row = $this->db->fetchAssoc($result)) {
            if ($this->getAnonymity()) {
                $persons_array[$row['active_id']] = ['name' => $this->lng->txt("anonymous")];
            } else {
                if (strlen($row['firstname'] . $row['lastname'] . $row["title"]) == 0) {
                    $persons_array[$row['active_id']] = ['name' => $this->lng->txt('deleted_user')];
                } else {
                    if ($row['user_fi'] == ANONYMOUS_USER_ID) {
                        $persons_array[$row['active_id']] = ['name' => $row['lastname']];
                    } else {
                        $persons_array[$row['active_id']] = [
                            'name' => trim($row['lastname'] . ', ' . $row['firstname']
                                . ' ' . $row['title']),
                            'login' => $row['login']
                        ];
                    }
                }
            }
        }
        return $persons_array;
    }
 
    public function getQuestionsOfTest(int $active_id): array
    {
        if ($this->isRandomTest()) {
            $this->db->setLimit($this->getQuestionCount(), 0);
            $result = $this->db->queryF(
                'SELECT tst_test_rnd_qst.sequence, tst_test_rnd_qst.question_fi, '
                . 'tst_test_rnd_qst.pass, qpl_questions.points '
                . 'FROM tst_test_rnd_qst, qpl_questions '
                . 'WHERE tst_test_rnd_qst.question_fi = qpl_questions.question_id '
                . 'AND tst_test_rnd_qst.active_fi = %s ORDER BY tst_test_rnd_qst.sequence',
                ['integer'],
                [$active_id]
            );
        } else {
            $result = $this->db->queryF(
                'SELECT tst_test_question.sequence, tst_test_question.question_fi, '
                . 'qpl_questions.points '
                . 'FROM tst_test_question, tst_active, qpl_questions '
                . 'WHERE tst_test_question.question_fi = qpl_questions.question_id '
                . 'AND tst_active.active_id = %s AND tst_active.test_fi = tst_test_question.test_fi',
                ['integer'],
                [$active_id]
            );
        }
        $qtest = [];
        if ($result->numRows()) {
            while ($row = $this->db->fetchAssoc($result)) {
                array_push($qtest, $row);
            }
        }
        return $qtest;
    }
 
    public function getQuestionsOfPass(int $active_id, int $pass): array
    {
        if ($this->isRandomTest()) {
            $this->db->setLimit($this->getQuestionCount(), 0);
            $result = $this->db->queryF(
                'SELECT tst_test_rnd_qst.sequence, tst_test_rnd_qst.question_fi, '
                . 'qpl_questions.points '
                . 'FROM tst_test_rnd_qst, qpl_questions '
                . 'WHERE tst_test_rnd_qst.question_fi = qpl_questions.question_id '
                . 'AND tst_test_rnd_qst.active_fi = %s AND tst_test_rnd_qst.pass = %s '
                . 'ORDER BY tst_test_rnd_qst.sequence',
                ['integer', 'integer'],
                [$active_id, $pass]
            );
        } else {
            $result = $this->db->queryF(
                'SELECT tst_test_question.sequence, tst_test_question.question_fi, '
                . 'qpl_questions.points '
                . 'FROM tst_test_question, tst_active, qpl_questions '
                . 'WHERE tst_test_question.question_fi = qpl_questions.question_id '
                . 'AND tst_active.active_id = %s AND tst_active.test_fi = tst_test_question.test_fi',
                ['integer'],
                [$active_id]
            );
        }
        $qpass = [];
        if ($result->numRows()) {
            while ($row = $this->db->fetchAssoc($result)) {
                array_push($qpass, $row);
            }
        }
        return $qpass;
    }
 
    public function getAccessFilteredParticipantList(): ?ilTestParticipantList
    {
        return $this->access_filtered_participant_list;
    }
 
    public function setAccessFilteredParticipantList(ilTestParticipantList $access_filtered_participant_list): void
    {
        $this->access_filtered_participant_list = $access_filtered_participant_list;
    }
 
    public function buildStatisticsAccessFilteredParticipantList(): ilTestParticipantList
    {
        $list = new ilTestParticipantList($this, $this->user, $this->lng, $this->db);
        $list->initializeFromDbRows($this->getTestParticipants());
 
        return $list->getAccessFilteredList(
            $this->participant_access_filter->getAccessStatisticsUserFilter($this->getRefId())
        );
    }
 
    public function getAnonOnlyParticipantIds(): array
    {
        $list = new ilTestParticipantList($this, $this->user, $this->lng, $this->db);
        $list->initializeFromDbRows($this->getTestParticipants());
        if ($this->getAnonymity()) {
            return $list->getAllUserIds();
        }
        return $list->getAccessFilteredList(
            $this->participant_access_filter->getAnonOnlyParticipantsUserFilter($this->getRefId())
        )->getAllUserIds();
    }
 
    public function getUnfilteredEvaluationData(): ilTestEvaluationData
    {
        return (new ilTestEvaluationFactory($this->db, $this))
            ->getEvaluationData();
    }
 
    public function getQuestionCountAndPointsForPassOfParticipant(int $active_id, int $pass): array
    {
        $question_set_type = $this->lookupQuestionSetTypeByActiveId($active_id);
 
        switch ($question_set_type) {
            case ilObjTest::QUESTION_SET_TYPE_RANDOM:
                $res = $this->db->queryF(
                    "
                                                SELECT          tst_test_rnd_qst.pass,
                                                                        COUNT(tst_test_rnd_qst.question_fi) qcount,
                                                                        SUM(qpl_questions.points) qsum
 
                                                FROM            tst_test_rnd_qst,
                                                                        qpl_questions
 
                                                WHERE           tst_test_rnd_qst.question_fi = qpl_questions.question_id
                                                AND                     tst_test_rnd_qst.active_fi = %s
                                                AND                     pass = %s
 
                                                GROUP BY        tst_test_rnd_qst.active_fi,
                                                                        tst_test_rnd_qst.pass
                                        ",
                    ['integer', 'integer'],
                    [$active_id, $pass]
                );
                break;
 
            case ilObjTest::QUESTION_SET_TYPE_FIXED:
                $res = $this->db->queryF(
                    "
                                                SELECT          COUNT(tst_test_question.question_fi) qcount,
                                                                        SUM(qpl_questions.points) qsum
 
                                                FROM            tst_test_question,
                                                                        qpl_questions,
                                                                        tst_active
 
                                                WHERE           tst_test_question.question_fi = qpl_questions.question_id
                                                AND                     tst_test_question.test_fi = tst_active.test_fi
                                                AND                     tst_active.active_id = %s
 
                                                GROUP BY        tst_test_question.test_fi
                                        ",
                    ['integer'],
                    [$active_id]
                );
                break;
 
            default:
                throw new ilTestException("not supported question set type: $question_set_type");
        }
 
        $row = $this->db->fetchAssoc($res);
 
        if (is_array($row)) {
            return ["count" => $row["qcount"], "points" => $row["qsum"]];
        }
 
        return ["count" => 0, "points" => 0];
    }
 
    public function getCompleteEvaluationData($filterby = '', $filtertext = ''): ilTestEvaluationData
    {
        $data = $this->getUnfilteredEvaluationData();
        $data->setFilter($filterby, $filtertext);
        return $data;
    }
 
    public function buildName(
        ?int $user_id,
        ?string $firstname,
        ?string $lastname
    ): string {
        if ($user_id === null
            || $firstname . $lastname === '') {
            return $this->lng->txt('deleted_user');
        }
 
        if ($this->getAnonymity()) {
            return $this->lng->txt('anonymous');
        }
 
        if ($user_id == ANONYMOUS_USER_ID) {
            return $lastname;
        }
 
        return trim($lastname . ', ' . $firstname);
    }
 
    public function evalTotalStartedAverageTime(?array $active_ids_to_filter = null): int
    {
        $query = "SELECT tst_times.* FROM tst_active, tst_times WHERE tst_active.test_fi = %s AND tst_active.active_id = tst_times.active_fi";
 
        if ($active_ids_to_filter !== null && $active_ids_to_filter !== []) {
            $query .= " AND " . $this->db->in('active_id', $active_ids_to_filter, false, 'integer');
        }
 
        $result = $this->db->queryF($query, ['integer'], [$this->getTestId()]);
        $times = [];
        while ($row = $this->db->fetchObject($result)) {
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row->started, $matches);
            $epoch_1 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row->finished, $matches);
            $epoch_2 = mktime(
                (int) $matches[4],
                (int) $matches[5],
                (int) $matches[6],
                (int) $matches[2],
                (int) $matches[3],
                (int) $matches[1]
            );
            if (isset($times[$row->active_fi])) {
                $times[$row->active_fi] += ($epoch_2 - $epoch_1);
            } else {
                $times[$row->active_fi] = ($epoch_2 - $epoch_1);
            }
        }
        $max_time = 0;
        $counter = 0;
        foreach ($times as $value) {
            $max_time += $value;
            $counter++;
        }
        if ($counter === 0) {
            return 0;
        }
        return (int) round($max_time / $counter);
    }
 
    public function getAvailableQuestionpools(
        bool $use_object_id = false,
        ?bool $equal_points = false,
        bool $could_be_offline = false,
        bool $show_path = false,
        bool $with_questioncount = false,
        string $permission = 'read'
    ): array {
        return ilObjQuestionPool::_getAvailableQuestionpools(
            $use_object_id,
            $equal_points ?? false,
            $could_be_offline,
            $show_path,
            $with_questioncount,
            $permission
        );
    }
 
    public function getImagePath(): string
    {
        return CLIENT_WEB_DIR . "/assessment/" . $this->getId() . "/images/";
    }
 
    public function getImagePathWeb()
    {
        $webdir = ilFileUtils::removeTrailingPathSeparators(CLIENT_WEB_DIR) . "/assessment/" . $this->getId() . "/images/";
        return str_replace(
            ilFileUtils::removeTrailingPathSeparators(ILIAS_ABSOLUTE_PATH),
            ilFileUtils::removeTrailingPathSeparators(ILIAS_HTTP_PATH),
            $webdir
        );
    }
 
    public function createQuestionGUI($question_type, $question_id = -1): ?assQuestionGUI
    {
        if ((!$question_type) and ($question_id > 0)) {
            $question_type = $this->getQuestionType($question_id);
        }
 
        if (!strlen($question_type)) {
            return null;
        }
 
        if ($question_id > 0) {
            $question_gui = assQuestion::instantiateQuestionGUI($question_id);
        } else {
            $question_type_gui = $question_type . 'GUI';
            $question_gui = new $question_type_gui();
        }
 
        return $question_gui;
    }
 
    public static function _instanciateQuestion($question_id): ?assQuestion
    {
        if (strcmp((string) $question_id, "") !== 0) {
            return assQuestion::instantiateQuestion((int) $question_id);
        }
 
        return null;
    }
 
    public function moveQuestions(array $move_questions, int $target_index, int $insert_mode): void
    {
        $this->questions = array_values($this->questions);
        $array_pos = array_search($target_index, $this->questions);
        if ($insert_mode == 0) {
            $part1 = array_slice($this->questions, 0, $array_pos);
            $part2 = array_slice($this->questions, $array_pos);
        } elseif ($insert_mode == 1) {
            $part1 = array_slice($this->questions, 0, $array_pos + 1);
            $part2 = array_slice($this->questions, $array_pos + 1);
        }
        foreach ($move_questions as $question_id) {
            if (!(array_search($question_id, $part1) === false)) {
                unset($part1[array_search($question_id, $part1)]);
            }
            if (!(array_search($question_id, $part2) === false)) {
                unset($part2[array_search($question_id, $part2)]);
            }
        }
        $part1 = array_values($part1);
        $part2 = array_values($part2);
        $new_array = array_values(array_merge($part1, $move_questions, $part2));
        $this->questions = [];
        $counter = 1;
        foreach ($new_array as $question_id) {
            $this->questions[$counter] = $question_id;
            $counter++;
        }
        $this->saveQuestionsToDb();
 
        if ($this->logger->isLoggingEnabled()) {
            $this->logger->logTestAdministrationInteraction(
                $this->logger->getInteractionFactory()->buildTestAdministrationInteraction(
                    $this->getRefId(),
                    $this->user->getId(),
                    TestAdministrationInteractionTypes::QUESTION_MOVED,
                    [
                        AdditionalInformationGenerator::KEY_QUESTION_ORDER => $this->questions
                    ]
                )
            );
        }
    }
 
 
    public function startingTimeReached(): bool
    {
        if ($this->isStartingTimeEnabled() && $this->getStartingTime() != 0) {
            $now = time();
            if ($now < $this->getStartingTime()) {
                return false;
            }
        }
        return true;
    }
 
    public function endingTimeReached(): bool
    {
        if ($this->isEndingTimeEnabled() && $this->getEndingTime() != 0) {
            $now = time();
            if ($now > $this->getEndingTime()) {
                return true;
            }
        }
        return false;
    }
 
    public function getAvailableQuestions($arr_filter, $completeonly = 0): array
    {
        $available_pools = array_keys(ilObjQuestionPool::_getAvailableQuestionpools(true, false, false, false, false));
        $available = "";
        if (count($available_pools)) {
            $available = " AND " . $this->db->in('qpl_questions.obj_fi', $available_pools, false, 'integer');
        } else {
            return [];
        }
        if ($completeonly) {
            $available .= " AND qpl_questions.complete = " . $this->db->quote("1", 'text');
        }
 
        $where = "";
        if (is_array($arr_filter)) {
            if (array_key_exists('title', $arr_filter) && strlen($arr_filter['title'])) {
                $where .= " AND " . $this->db->like('qpl_questions.title', 'text', "%%" . $arr_filter['title'] . "%%");
            }
            if (array_key_exists('description', $arr_filter) && strlen($arr_filter['description'])) {
                $where .= " AND " . $this->db->like('qpl_questions.description', 'text', "%%" . $arr_filter['description'] . "%%");
            }
            if (array_key_exists('author', $arr_filter) && strlen($arr_filter['author'])) {
                $where .= " AND " . $this->db->like('qpl_questions.author', 'text', "%%" . $arr_filter['author'] . "%%");
            }
            if (array_key_exists('type', $arr_filter) && strlen($arr_filter['type'])) {
                $where .= " AND qpl_qst_type.type_tag = " . $this->db->quote($arr_filter['type'], 'text');
            }
            if (array_key_exists('qpl', $arr_filter) && strlen($arr_filter['qpl'])) {
                $where .= " AND " . $this->db->like('object_data.title', 'text', "%%" . $arr_filter['qpl'] . "%%");
            }
        }
 
        $original_ids = &$this->getExistingQuestions();
        $original_clause = " qpl_questions.original_id IS NULL";
        if (count($original_ids)) {
            $original_clause = " qpl_questions.original_id IS NULL AND " . $this->db->in('qpl_questions.question_id', $original_ids, true, 'integer');
        }
 
        $query_result = $this->db->query("
                        SELECT          qpl_questions.*, qpl_questions.tstamp,
                                                qpl_qst_type.type_tag, qpl_qst_type.plugin, qpl_qst_type.plugin_name,
                                                object_data.title parent_title
                        FROM            qpl_questions, qpl_qst_type, object_data
                        WHERE $original_clause $available
                        AND object_data.obj_id = qpl_questions.obj_fi
                        AND qpl_questions.tstamp > 0
                        AND qpl_questions.question_type_fi = qpl_qst_type.question_type_id
                        $where
                ");
        $rows = [];
 
        if ($query_result->numRows()) {
            while ($row = $this->db->fetchAssoc($query_result)) {
                $row = ilAssQuestionType::completeMissingPluginName($row);
 
                if (!$row['plugin']) {
                    $row[ 'ttype' ] = $this->lng->txt($row[ "type_tag" ]);
 
                    $rows[] = $row;
                    continue;
                }
 
                $plugin = $this->component_repository->getPluginByName($row['plugin_name']);
                if (!$plugin->isActive()) {
                    continue;
                }
 
                $pl = $this->component_factory->getPlugin($plugin->getId());
                $row[ 'ttype' ] = $pl->getQuestionTypeTranslation();
 
                $rows[] = $row;
            }
        }
        return $rows;
    }
 
    public function fromXML(ilQTIAssessment $assessment, array $mappings): void
    {
        $this->saveToDb(true);
 
        $main_settings = $this->getMainSettings();
        $general_settings = $main_settings->getGeneralSettings();
        $introduction_settings = $main_settings->getIntroductionSettings();
        $access_settings = $main_settings->getAccessSettings();
        $test_behaviour_settings = $main_settings->getTestBehaviourSettings();
        $question_behaviour_settings = $main_settings->getQuestionBehaviourSettings();
        $participant_functionality_settings = $main_settings->getParticipantFunctionalitySettings();
        $finishing_settings = $main_settings->getFinishingSettings();
        $additional_settings = $main_settings->getAdditionalSettings();
 
        $introduction_settings = $introduction_settings->withIntroductionEnabled(false);
        foreach ($assessment->objectives as $objectives) {
            foreach ($objectives->materials as $material) {
                $introduction_settings = $this->addIntroductionToSettingsFromImport(
                    $introduction_settings,
                    $this->qtiMaterialToArray($material),
                    $mappings
                );
            }
        }
 
        if ($assessment->getPresentationMaterial()
            && $assessment->getPresentationMaterial()->getFlowMat(0)
            && $assessment->getPresentationMaterial()->getFlowMat(0)->getMaterial(0)) {
            $finishing_settings = $this->addConcludingRemarksToSettingsFromImport(
                $finishing_settings,
                $this->qtiMaterialToArray(
                    $assessment->getPresentationMaterial()->getFlowMat(0)->getMaterial(0)
                ),
                $mappings
            );
        }
 
        $score_settings = $this->getScoreSettings();
        $scoring_settings = $score_settings->getScoringSettings();
        $gamification_settings = $score_settings->getGamificationSettings();
        $result_summary_settings = $score_settings->getResultSummarySettings();
        $result_details_settings = $score_settings->getResultDetailsSettings();
 
        $mark_steps = [];
        foreach ($assessment->qtimetadata as $metadata) {
            switch ($metadata["label"]) {
                case "solution_details":
                    $result_details_settings = $result_details_settings->withShowPassDetails((bool) $metadata["entry"]);
                    break;
                case "show_solution_list_comparison":
                    $result_details_settings = $result_details_settings->withShowSolutionListComparison((bool) $metadata["entry"]);
                    break;
                case "print_bs_with_res":
                    $result_details_settings = $result_details_settings->withShowSolutionListComparison((bool) $metadata["entry"]);
                    break;
                case "author":
                    $this->saveAuthorToMetadata($metadata["entry"]);
                    break;
                case "nr_of_tries":
                    $test_behaviour_settings = $test_behaviour_settings->withNumberOfTries((int) $metadata["entry"]);
                    break;
                case 'block_after_passed':
                    $test_behaviour_settings = $test_behaviour_settings->withBlockAfterPassedEnabled((bool) $metadata['entry']);
                    break;
                case "pass_waiting":
                    $test_behaviour_settings = $test_behaviour_settings->withPassWaiting($metadata["entry"]);
                    break;
                case "kiosk":
                    $test_behaviour_settings = $test_behaviour_settings->withKioskMode((int) $metadata["entry"]);
                    break;
                case 'show_introduction':
                    $introduction_settings = $introduction_settings->withIntroductionEnabled((bool) $metadata['entry']);
                    break;
                case "showfinalstatement":
                case 'show_concluding_remarks':
                    $finishing_settings = $finishing_settings->withConcludingRemarksEnabled((bool) $metadata["entry"]);
                    break;
                case 'exam_conditions':
                    $introduction_settings = $introduction_settings->withExamConditionsCheckboxEnabled($metadata['entry'] === '1');
                    break;
                case "highscore_enabled":
                    $gamification_settings = $gamification_settings->withHighscoreEnabled((bool) $metadata["entry"]);
                    break;
                case "highscore_anon":
                    $gamification_settings = $gamification_settings->withHighscoreAnon((bool) $metadata["entry"]);
                    break;
                case "highscore_achieved_ts":
                    $gamification_settings = $gamification_settings->withHighscoreAchievedTS((bool) $metadata["entry"]);
                    break;
                case "highscore_score":
                    $gamification_settings = $gamification_settings->withHighscoreScore((bool) $metadata["entry"]);
                    break;
                case "highscore_percentage":
                    $gamification_settings = $gamification_settings->withHighscorePercentage((bool) $metadata["entry"]);
                    break;
                case "highscore_wtime":
                    $gamification_settings = $gamification_settings->withHighscoreWTime((bool) $metadata["entry"]);
                    break;
                case "highscore_own_table":
                    $gamification_settings = $gamification_settings->withHighscoreOwnTable((bool) $metadata["entry"]);
                    break;
                case "highscore_top_table":
                    $gamification_settings = $gamification_settings->withHighscoreTopTable((bool) $metadata["entry"]);
                    break;
                case "highscore_top_num":
                    $gamification_settings = $gamification_settings->withHighscoreTopNum((int) $metadata["entry"]);
                    break;
                case "use_previous_answers":
                    $participant_functionality_settings = $participant_functionality_settings->withUsePreviousAnswerAllowed((bool) $metadata["entry"]);
                    break;
                case 'question_list_enabled':
                    $participant_functionality_settings = $participant_functionality_settings->withQuestionListEnabled((bool) $metadata['entry']);
                    // no break
                case "title_output":
                    $question_behaviour_settings = $question_behaviour_settings->withQuestionTitleOutputMode((int) $metadata["entry"]);
                    break;
                case "question_set_type":
                    if ($metadata['entry'] === self::QUESTION_SET_TYPE_RANDOM) {
                        $this->questions = [];
                    }
                    $general_settings = $general_settings->withQuestionSetType($metadata["entry"]);
                    break;
                case "anonymity":
                    $general_settings = $general_settings->withAnonymity((bool) $metadata["entry"]);
                    break;
                case "results_presentation":
                    $result_details_settings = $result_details_settings->withResultsPresentation((int) $metadata["entry"]);
                    break;
                case "reset_processing_time":
                    $test_behaviour_settings = $test_behaviour_settings->withResetProcessingTime($metadata["entry"] === '1');
                    break;
                case "answer_feedback_points":
                    $question_behaviour_settings = $question_behaviour_settings->withInstantFeedbackPointsEnabled((bool) $metadata["entry"]);
                    break;
                case "answer_feedback":
                    $question_behaviour_settings = $question_behaviour_settings->withInstantFeedbackGenericEnabled((bool) $metadata["entry"]);
                    break;
                case 'instant_feedback_specific':
                    $question_behaviour_settings = $question_behaviour_settings->withInstantFeedbackSpecificEnabled((bool) $metadata['entry']);
                    break;
                case "instant_verification":
                    $question_behaviour_settings = $question_behaviour_settings->withInstantFeedbackSolutionEnabled((bool) $metadata["entry"]);
                    break;
                case "force_instant_feedback":
                    $question_behaviour_settings = $question_behaviour_settings->withForceInstantFeedbackOnNextQuestion((bool) $metadata["entry"]);
                    break;
                case "follow_qst_answer_fixation":
                    $question_behaviour_settings = $question_behaviour_settings->withLockAnswerOnNextQuestionEnabled((bool) $metadata["entry"]);
                    break;
                case "instant_feedback_answer_fixation":
                    $question_behaviour_settings = $question_behaviour_settings->withLockAnswerOnInstantFeedbackEnabled((bool) $metadata["entry"]);
                    break;
                case "show_cancel":
                case "suspend_test_allowed":
                    $participant_functionality_settings = $participant_functionality_settings->withSuspendTestAllowed((bool) $metadata["entry"]);
                    break;
                case "sequence_settings":
                    $participant_functionality_settings = $participant_functionality_settings->withPostponedQuestionsMoveToEnd((bool) $metadata["entry"]);
                    break;
                case "show_marker":
                    $participant_functionality_settings = $participant_functionality_settings->withQuestionMarkingEnabled((bool) $metadata["entry"]);
                    break;
                case "fixed_participants":
                    $access_settings = $access_settings->withFixedParticipants((bool) $metadata["entry"]);
                    break;
                case "score_reporting":
                    if ($metadata['entry'] !== null) {
                        $result_summary_settings = $result_summary_settings->withScoreReporting(
                            ScoreReportingTypes::tryFrom((int) $metadata['entry']) ?? ScoreReportingTypes::SCORE_REPORTING_DISABLED
                        );
                    }
                    break;
                case "shuffle_questions":
                    $question_behaviour_settings = $question_behaviour_settings->withShuffleQuestions((bool) $metadata["entry"]);
                    break;
                case "count_system":
                    $scoring_settings = $scoring_settings->withCountSystem((int) $metadata["entry"]);
                    break;
                case "exportsettings":
                    $result_details_settings = $result_details_settings->withExportSettings((int) $metadata["entry"]);
                    break;
                case "score_cutting":
                    $scoring_settings = $scoring_settings->withScoreCutting((int) $metadata["entry"]);
                    break;
                case "password":
                    $access_settings = $access_settings->withPasswordEnabled(
                        $metadata["entry"] !== null && $metadata["entry"] !== ''
                    )->withPassword($metadata["entry"]);
                    break;
                case 'ip_range_from':
                    if ($metadata['entry'] !== '') {
                        $access_settings = $access_settings->withIpRangeFrom($metadata['entry']);
                    }
                    break;
                case 'ip_range_to':
                    if ($metadata['entry'] !== '') {
                        $access_settings = $access_settings->withIpRangeTo($metadata['entry']);
                    }
                    break;
                case "pass_scoring":
                    $scoring_settings = $scoring_settings->withPassScoring((int) $metadata["entry"]);
                    break;
                case 'pass_deletion_allowed':
                    $result_summary_settings = $result_summary_settings->withPassDeletionAllowed((bool) $metadata["entry"]);
                    break;
                case "usr_pass_overview_mode":
                    $participant_functionality_settings = $participant_functionality_settings->withUsrPassOverviewMode((int) $metadata["entry"]);
                    break;
                case "question_list":
                    $participant_functionality_settings = $participant_functionality_settings->withQuestionListEnabled((bool) $metadata["entry"]);
                    break;
 
                case "reporting_date":
                    $reporting_date = $this->buildDateTimeImmutableFromPeriod($metadata['entry']);
                    if ($reporting_date !== null) {
                        $result_summary_settings = $result_summary_settings->withReportingDate($reporting_date);
                    }
                    break;
                case 'enable_processing_time':
                    $test_behaviour_settings = $test_behaviour_settings->withProcessingTimeEnabled((bool) $metadata['entry']);
                    break;
                case "processing_time":
                    $test_behaviour_settings = $test_behaviour_settings->withProcessingTime($metadata['entry']);
                    break;
                case "starting_time":
                    $starting_time = $this->buildDateTimeImmutableFromPeriod($metadata['entry']);
                    if ($starting_time !== null) {
                        $access_settings = $access_settings->withStartTime($starting_time)
                            ->withStartTimeEnabled(true);
                    }
                    break;
                case "ending_time":
                    $ending_time = $this->buildDateTimeImmutableFromPeriod($metadata['entry']);
                    if ($ending_time !== null) {
                        $access_settings = $access_settings->withEndTime($ending_time)
                            ->withStartTimeEnabled(true);
                    }
                    break;
                case "enable_examview":
                    $finishing_settings = $finishing_settings->withShowAnswerOverview((bool) $metadata["entry"]);
                    break;
                case 'redirection_mode':
                    $finishing_settings = $finishing_settings->withRedirectionMode(
                        RedirectionModes::tryFrom((int) ($metadata['entry'] ?? 0)) ?? RedirectionModes::NONE
                    );
                    break;
                case 'redirection_url':
                    $finishing_settings = $finishing_settings->withRedirectionUrl($metadata['entry']);
                    break;
                case 'examid_in_test_pass':
                    $test_behaviour_settings = $test_behaviour_settings->withExamIdInTestAttemptEnabled((bool) $metadata['entry']);
                    break;
                case 'examid_in_test_res':
                    $result_details_settings = $result_details_settings->withShowExamIdInTestResults((bool) $metadata["entry"]);
                    break;
                case 'skill_service':
                    $additional_settings = $additional_settings->withSkillsServiceEnabled((bool) $metadata['entry']);
                    break;
                case 'show_grading_status':
                    $result_summary_settings = $result_summary_settings->withShowGradingStatusEnabled((bool) $metadata["entry"]);
                    break;
                case 'show_grading_mark':
                    $result_summary_settings = $result_summary_settings->withShowGradingMarkEnabled((bool) $metadata["entry"]);
                    break;
                case 'autosave':
                    $question_behaviour_settings = $question_behaviour_settings->withAutosaveEnabled((bool) $metadata['entry']);
                    break;
                case 'autosave_ival':
                    $question_behaviour_settings = $question_behaviour_settings->withAutosaveInterval((int) $metadata['entry']);
                    break;
                case 'show_summary':
                    $participant_functionality_settings = $participant_functionality_settings->withQuestionListEnabled(($metadata['entry'] & 1) > 0)
                        ->withUsrPassOverviewMode((int) $metadata['entry']);
 
                    // no break
                case 'hide_info_tab':
                    $additional_settings = $additional_settings->withHideInfoTab($metadata['entry'] === '1');
            }
            if (preg_match("/mark_step_\d+/", $metadata["label"])) {
                $xmlmark = $metadata["entry"];
                preg_match("/<short>(.*?)<\/short>/", $xmlmark, $matches);
                $mark_short = $matches[1];
                preg_match("/<official>(.*?)<\/official>/", $xmlmark, $matches);
                $mark_official = $matches[1];
                preg_match("/<percentage>(.*?)<\/percentage>/", $xmlmark, $matches);
                $mark_percentage = (float) $matches[1];
                preg_match("/<passed>(.*?)<\/passed>/", $xmlmark, $matches);
                $mark_passed = (bool) $matches[1];
                $mark_steps[] = new Mark($mark_short, $mark_official, $mark_percentage, $mark_passed);
            }
        }
        $this->mark_schema = $this->getMarkSchema()->withMarkSteps($mark_steps);
        $this->saveToDb();
        $this->getObjectProperties()->storePropertyTitleAndDescription(
            $this->getObjectProperties()->getPropertyTitleAndDescription()
                ->withTitle($assessment->getTitle())
                ->withDescription($assessment->getComment())
        );
        $this->addToNewsOnOnline(false, $this->getObjectProperties()->getPropertyIsOnline()->getIsOnline());
        $main_settings = $main_settings
            ->withGeneralSettings($general_settings)
            ->withIntroductionSettings($introduction_settings)
            ->withAccessSettings($access_settings)
            ->withParticipantFunctionalitySettings($participant_functionality_settings)
            ->withTestBehaviourSettings($test_behaviour_settings)
            ->withQuestionBehaviourSettings($question_behaviour_settings)
            ->withFinishingSettings($finishing_settings)
            ->withAdditionalSettings($additional_settings);
        $this->getMainSettingsRepository()->store($main_settings);
        $this->main_settings = $main_settings;
 
        $score_settings = $score_settings
            ->withGamificationSettings($gamification_settings)
            ->withScoringSettings($scoring_settings)
            ->withResultDetailsSettings($result_details_settings)
            ->withResultSummarySettings($result_summary_settings);
        $this->getScoreSettingsRepository()->store($score_settings);
        $this->score_settings = $score_settings;
        $this->loadFromDb();
    }
 
    private function addIntroductionToSettingsFromImport(
        SettingsIntroduction $settings,
        array $material,
        array $mappings
    ): SettingsIntroduction {
        if (!str_starts_with($material['text'], '<PageObject>')) {
            return $settings;
        }
 
        $text = $this->replaceFilesInPageImports(
            $this->replaceMobsInPageImports(
                $material['text'],
                $mappings['components/ILIAS/MediaObjects']['mob'] ?? []
            )
        );
 
        $page_object = new ilTestPage();
        $page_object->setParentId($this->getId());
        $page_object->setXMLContent($text);
        $new_page_id = $page_object->createPageWithNextId();
        return $settings->withIntroductionPageId($new_page_id);
    }
 
    private function addConcludingRemarksToSettingsFromImport(
        SettingsFinishing $settings,
        array $material,
        array $mappings
    ): SettingsFinishing {
        if (!str_starts_with($material['text'], '<PageObject>')) {
            return $settings;
        }
 
        $text = $this->replaceFilesInPageImports(
            $this->replaceMobsInPageImports(
                $material['text'],
                $mappings['components/ILIAS/MediaObjects']['mob'] ?? []
            )
        );
 
        $page_object = new ilTestPage();
        $page_object->setParentId($this->getId());
        $page_object->setXMLContent($text);
        $new_page_id = $page_object->createPageWithNextId();
        return $settings->withConcludingRemarksPageId($new_page_id);
    }
 
    private function replaceMobsInPageImports(string $text, array $mappings): string
    {
        preg_match_all('/il_(\d+)_mob_(\d+)/', $text, $matches);
        foreach ($matches[0] as $index => $match) {
            if (empty($mappings[$matches[2][$index]])) {
                continue;
            }
            $text = str_replace($match, "il__mob_{$mappings[$matches[2][$index]]}", $text);
            ilObjMediaObject::_saveUsage((int) $mappings[$matches[2][$index]], 'tst', $this->getId());
        }
        return $text;
    }
 
    private function replaceFilesInPageImports(string $text, array $mappings): string
    {
        preg_match_all('/il_(\d+)_file_(\d+)/', $text, $matches);
        foreach ($matches[0] as $index => $match) {
            if (empty($mappings[$matches[2][$index]])) {
                continue;
            }
            $text = str_replace($match, "il__file_{$mappings[$matches[2][$index]]}", $text);
        }
        return $text;
    }
 
    public function toXML(): string
    {
        $main_settings = $this->getMainSettings();
        $a_xml_writer = new ilXmlWriter();
        // set xml header
        $a_xml_writer->xmlHeader();
        $a_xml_writer->xmlSetDtdDef("<!DOCTYPE questestinterop SYSTEM \"ims_qtiasiv1p2p1.dtd\">");
        $a_xml_writer->xmlStartTag("questestinterop");
 
        $attrs = [
            "ident" => "il_" . IL_INST_ID . "_tst_" . $this->getTestId(),
            "title" => $this->getTitle()
        ];
        $a_xml_writer->xmlStartTag("assessment", $attrs);
        $a_xml_writer->xmlElement("qticomment", null, $this->getDescription());
 
        if ($main_settings->getTestBehaviourSettings()->getProcessingTimeEnabled()) {
            $a_xml_writer->xmlElement(
                "duration",
                null,
                $this->getProcessingTimeForXML()
            );
        }
 
        $a_xml_writer->xmlStartTag("qtimetadata");
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "ILIAS_VERSION");
        $a_xml_writer->xmlElement("fieldentry", null, ILIAS_VERSION);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "anonymity");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getGeneralSettings()->getAnonymity() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "question_set_type");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getGeneralSettings()->getQuestionSetType());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "sequence_settings");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getParticipantFunctionalitySettings()->getPostponedQuestionsMoveToEnd() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "author");
        $a_xml_writer->xmlElement("fieldentry", null, $this->getAuthor());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "reset_processing_time");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getTestBehaviourSettings()->getResetProcessingTime() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "count_system");
        $a_xml_writer->xmlElement("fieldentry", null, $this->getCountSystem());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "score_cutting");
        $a_xml_writer->xmlElement("fieldentry", null, $this->getScoreCutting());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "password");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getAccessSettings()->getPassword() ?? '');
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "ip_range_from");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getAccessSettings()->getIpRangeFrom());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "ip_range_to");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getAccessSettings()->getIpRangeTo());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "pass_scoring");
        $a_xml_writer->xmlElement("fieldentry", null, $this->getPassScoring());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag('qtimetadatafield');
        $a_xml_writer->xmlElement('fieldlabel', null, 'pass_deletion_allowed');
        $a_xml_writer->xmlElement('fieldentry', null, $this->isPassDeletionAllowed() ? 1 : 0);
        $a_xml_writer->xmlEndTag('qtimetadatafield');
 
        if ($this->getScoreSettings()->getResultSummarySettings()->getReportingDate() !== null) {
            $a_xml_writer->xmlStartTag("qtimetadatafield");
            $a_xml_writer->xmlElement("fieldlabel", null, "reporting_date");
            $a_xml_writer->xmlElement(
                "fieldentry",
                null,
                $this->buildIso8601PeriodForExportCompatibility(
                    $this->getScoreSettings()->getResultSummarySettings()->getReportingDate(),
                ),
            );
            $a_xml_writer->xmlEndTag("qtimetadatafield");
        }
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "nr_of_tries");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getTestBehaviourSettings()->getNumberOfTries());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag('qtimetadatafield');
        $a_xml_writer->xmlElement('fieldlabel', null, 'block_after_passed');
        $a_xml_writer->xmlElement('fieldentry', null, $main_settings->getTestBehaviourSettings()->getBlockAfterPassedEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag('qtimetadatafield');
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "pass_waiting");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getTestBehaviourSettings()->getPassWaiting());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "kiosk");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getTestBehaviourSettings()->getKioskMode());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag('qtimetadatafield');
        $a_xml_writer->xmlElement("fieldlabel", null, "redirection_mode");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getFinishingSettings()->getRedirectionMode()->value);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag('qtimetadatafield');
        $a_xml_writer->xmlElement("fieldlabel", null, "redirection_url");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getFinishingSettings()->getRedirectionUrl());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "use_previous_answers");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getParticipantFunctionalitySettings()->getUsePreviousAnswerAllowed() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag('qtimetadatafield');
        $a_xml_writer->xmlElement('fieldlabel', null, 'question_list_enabled');
        $a_xml_writer->xmlElement('fieldentry', null, $main_settings->getParticipantFunctionalitySettings()->getQuestionListEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag('qtimetadatafield');
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "title_output");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getQuestionTitleOutputMode());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "results_presentation");
        $a_xml_writer->xmlElement("fieldentry", null, $this->getScoreSettings()->getResultDetailsSettings()->getResultsPresentation());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "examid_in_test_pass");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getTestBehaviourSettings()->getExamIdInTestAttemptEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "examid_in_test_res");
        $a_xml_writer->xmlElement("fieldentry", null, $this->getScoreSettings()->getResultDetailsSettings()->getShowExamIdInTestResults() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "usr_pass_overview_mode");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getParticipantFunctionalitySettings()->getUsrPassOverviewMode());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "score_reporting");
        $a_xml_writer->xmlElement("fieldentry", null, $this->getScoreSettings()->getResultSummarySettings()->getScoreReporting()->value);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "show_solution_list_comparison");
        $a_xml_writer->xmlElement("fieldentry", null, $this->score_settings->getResultDetailsSettings()->getShowSolutionListComparison() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "instant_verification");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getInstantFeedbackSolutionEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "answer_feedback");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getInstantFeedbackGenericEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "instant_feedback_specific");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getInstantFeedbackSpecificEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "answer_feedback_points");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getInstantFeedbackPointsEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "follow_qst_answer_fixation");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getLockAnswerOnNextQuestionEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "instant_feedback_answer_fixation");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getLockAnswerOnInstantFeedbackEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "force_instant_feedback");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getForceInstantFeedbackOnNextQuestion() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $highscore_metadata = [
            'highscore_enabled' => $this->getHighscoreEnabled(),
            'highscore_anon' => $this->getHighscoreAnon(),
            'highscore_achieved_ts' => $this->getHighscoreAchievedTS(),
            'highscore_score' => $this->getHighscoreScore(),
            'highscore_percentage' => $this->getHighscorePercentage(),
            'highscore_wtime' => $this->getHighscoreWTime(),
            'highscore_own_table' => $this->getHighscoreOwnTable(),
            'highscore_top_table' => $this->getHighscoreTopTable(),
        ];
        foreach ($highscore_metadata as $label => $value) {
            $a_xml_writer->xmlStartTag("qtimetadatafield");
            $a_xml_writer->xmlElement("fieldlabel", null, $label);
            $a_xml_writer->xmlElement("fieldentry", null, $value ? 1 : 0);
            $a_xml_writer->xmlEndTag("qtimetadatafield");
        }
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "highscore_top_num");
        $a_xml_writer->xmlElement("fieldentry", null, $this->getHighscoreTopNum());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "suspend_test_allowed");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getParticipantFunctionalitySettings()->getSuspendTestAllowed() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "show_marker");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getParticipantFunctionalitySettings()->getQuestionMarkingEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "fixed_participants");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getAccessSettings()->getFixedParticipants() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "show_introduction");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getIntroductionSettings()->getIntroductionEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, 'exam_conditions');
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getIntroductionSettings()->getExamConditionsCheckboxEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "show_concluding_remarks");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getFinishingSettings()->getConcludingRemarksEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "exportsettings");
        $a_xml_writer->xmlElement("fieldentry", null, $this->getExportSettings());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "shuffle_questions");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getShuffleQuestions() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "processing_time");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getTestBehaviourSettings()->getProcessingTime());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "enable_examview");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getFinishingSettings()->getShowAnswerOverview() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "skill_service");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getAdditionalSettings()->getSkillsServiceEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        if ($this->getInstantFeedbackSolution() == 1) {
            $attrs = [
                "solutionswitch" => "Yes"
            ];
        } else {
            $attrs = null;
        }
        $a_xml_writer->xmlElement("assessmentcontrol", $attrs, null);
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "show_grading_status");
        $a_xml_writer->xmlElement("fieldentry", null, $this->isShowGradingStatusEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "show_grading_mark");
        $a_xml_writer->xmlElement("fieldentry", null, $this->isShowGradingMarkEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag('qtimetadatafield');
        $a_xml_writer->xmlElement('fieldlabel', null, 'hide_info_tab');
        $a_xml_writer->xmlElement('fieldentry', null, $this->getMainSettings()->getAdditionalSettings()->getHideInfoTab() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        if ($this->getStartingTime() > 0) {
            $a_xml_writer->xmlStartTag("qtimetadatafield");
            $a_xml_writer->xmlElement("fieldlabel", null, "starting_time");
            $a_xml_writer->xmlElement(
                "fieldentry",
                null,
                $this->buildIso8601PeriodForExportCompatibility(
                    (new DateTimeImmutable())->setTimestamp($this->getStartingTime()),
                ),
            );
            $a_xml_writer->xmlEndTag("qtimetadatafield");
        }
 
        if ($this->getEndingTime() > 0) {
            $a_xml_writer->xmlStartTag("qtimetadatafield");
            $a_xml_writer->xmlElement("fieldlabel", null, "ending_time");
            $a_xml_writer->xmlElement(
                "fieldentry",
                null,
                $this->buildIso8601PeriodForExportCompatibility(
                    (new DateTimeImmutable())->setTimestamp($this->getEndingTime()),
                ),
            );
            $a_xml_writer->xmlEndTag("qtimetadatafield");
        }
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "autosave");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getAutosaveEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "autosave_ival");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getAutosaveInterval());
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "instant_feedback_specific");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getInstantFeedbackSpecificEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "instant_feedback_answer_fixation");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getQuestionBehaviourSettings()->getLockAnswerOnInstantFeedbackEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        $a_xml_writer->xmlStartTag("qtimetadatafield");
        $a_xml_writer->xmlElement("fieldlabel", null, "enable_processing_time");
        $a_xml_writer->xmlElement("fieldentry", null, $main_settings->getTestBehaviourSettings()->getProcessingTimeEnabled() ? 1 : 0);
        $a_xml_writer->xmlEndTag("qtimetadatafield");
 
        foreach ($this->getMarkSchema()->getMarkSteps() as $index => $mark) {
            $a_xml_writer->xmlStartTag("qtimetadatafield");
            $a_xml_writer->xmlElement("fieldlabel", null, "mark_step_$index");
            $a_xml_writer->xmlElement("fieldentry", null, sprintf(
                "<short>%s</short><official>%s</official><percentage>%.2f</percentage><passed>%d</passed>",
                $mark->getShortName(),
                $mark->getOfficialName(),
                $mark->getMinimumLevel(),
                $mark->getPassed()
            ));
            $a_xml_writer->xmlEndTag("qtimetadatafield");
        }
        $a_xml_writer->xmlEndTag("qtimetadata");
 
        $page_id = $main_settings->getIntroductionSettings()->getIntroductionPageId();
        $introduction = $page_id !== null
            ? (new ilTestPage($page_id))->getXMLContent()
            : ilRTE::_replaceMediaObjectImageSrc($this->getIntroduction(), 0);
 
        $a_xml_writer->xmlStartTag("objectives");
        $this->addQTIMaterial($a_xml_writer, $page_id, $introduction);
        $a_xml_writer->xmlEndTag("objectives");
 
        if ($this->getInstantFeedbackSolution() == 1) {
            $attrs = [
                "solutionswitch" => "Yes"
            ];
        } else {
            $attrs = null;
        }
        $a_xml_writer->xmlElement("assessmentcontrol", $attrs, null);
 
        if (strlen($this->getFinalStatement())) {
            $page_id = $main_settings->getFinishingSettings()->getConcludingRemarksPageId();
            $concluding_remarks = $page_id !== null
                ? (new ilTestPage($page_id))->getXMLContent()
                : ilRTE::_replaceMediaObjectImageSrc($this->getFinalStatement());
            // add qti presentation_material
            $a_xml_writer->xmlStartTag("presentation_material");
            $a_xml_writer->xmlStartTag("flow_mat");
            $this->addQTIMaterial($a_xml_writer, $page_id, $concluding_remarks);
            $a_xml_writer->xmlEndTag("flow_mat");
            $a_xml_writer->xmlEndTag("presentation_material");
        }
 
        $attrs = [
            "ident" => "1"
        ];
        $a_xml_writer->xmlElement("section", $attrs, null);
        $a_xml_writer->xmlEndTag("assessment");
        $a_xml_writer->xmlEndTag("questestinterop");
 
        $xml = $a_xml_writer->xmlDumpMem(false);
        return $xml;
    }
 
    protected function buildIso8601PeriodForExportCompatibility(DateTimeImmutable $date_time): string
    {
        return $date_time->setTimezone(new DateTimeZone('UTC'))->format('\PY\Yn\Mj\D\TG\Hi\Ms\S');
    }
 
    protected function buildDateTimeImmutableFromPeriod(?string $period): ?DateTimeImmutable
    {
        if ($period === null) {
            return null;
        }
        if (preg_match("/P(\d+)Y(\d+)M(\d+)DT(\d+)H(\d+)M(\d+)S/", $period, $matches)) {
            return new DateTimeImmutable(
                sprintf(
                    "%02d-%02d-%02d %02d:%02d:%02d",
                    $matches[1],
                    $matches[2],
                    $matches[3],
                    $matches[4],
                    $matches[5],
                    $matches[6]
                ),
                new \DateTimeZone('UTC')
            );
        }
        return null;
    }
 
    public function exportPagesXML(&$a_xml_writer, $a_inst, $a_target_dir, &$expLog): void
    {
        $this->mob_ids = [];
 
        // PageObjects
        $expLog->write(date("[y-m-d H:i:s] ") . "Start Export Page Objects");
        $this->bench->start("ContentObjectExport", "exportPageObjects");
        $this->exportXMLPageObjects($a_xml_writer, $a_inst, $expLog);
        $this->bench->stop("ContentObjectExport", "exportPageObjects");
        $expLog->write(date("[y-m-d H:i:s] ") . "Finished Export Page Objects");
 
        // MediaObjects
        $expLog->write(date("[y-m-d H:i:s] ") . "Start Export Media Objects");
        $this->bench->start("ContentObjectExport", "exportMediaObjects");
        $this->exportXMLMediaObjects($a_xml_writer, $a_inst, $a_target_dir, $expLog);
        $this->bench->stop("ContentObjectExport", "exportMediaObjects");
        $expLog->write(date("[y-m-d H:i:s] ") . "Finished Export Media Objects");
 
        // FileItems
        $expLog->write(date("[y-m-d H:i:s] ") . "Start Export File Items");
        $this->bench->start("ContentObjectExport", "exportFileItems");
        $this->exportFileItems($a_target_dir, $expLog);
        $this->bench->stop("ContentObjectExport", "exportFileItems");
        $expLog->write(date("[y-m-d H:i:s] ") . "Finished Export File Items");
    }
 
    public function modifyExportIdentifier($a_tag, $a_param, $a_value)
    {
        if ($a_tag == "Identifier" && $a_param == "Entry") {
            $a_value = ilUtil::insertInstIntoID($a_value);
        }
 
        return $a_value;
    }
 
 
    public function exportXMLPageObjects(&$a_xml_writer, $inst, &$expLog)
    {
        foreach ($this->questions as $question_id) {
            $this->bench->start("ContentObjectExport", "exportPageObject");
            $expLog->write(date("[y-m-d H:i:s] ") . "Page Object " . $question_id);
 
            $attrs = [];
            $a_xml_writer->xmlStartTag("PageObject", $attrs);
 
 
            // export xml to writer object
            $this->bench->start("ContentObjectExport", "exportPageObject_XML");
            $page_object = new ilAssQuestionPage($question_id);
            $page_object->buildDom();
            $page_object->insertInstIntoIDs((string) $inst);
            $mob_ids = $page_object->collectMediaObjects(false);
            $file_ids = ilPCFileList::collectFileItems($page_object, $page_object->getDomDoc());
            $xml = $page_object->getXMLFromDom(false, false, false, "", true);
            $xml = str_replace("&", "&amp;", $xml);
            $a_xml_writer->appendXML($xml);
            $page_object->freeDom();
            unset($page_object);
 
            $this->bench->stop("ContentObjectExport", "exportPageObject_XML");
 
            // collect media objects
            $this->bench->start("ContentObjectExport", "exportPageObject_CollectMedia");
            //$mob_ids = $page_obj->getMediaObjectIDs();
            foreach ($mob_ids as $mob_id) {
                $this->mob_ids[$mob_id] = $mob_id;
            }
            $this->bench->stop("ContentObjectExport", "exportPageObject_CollectMedia");
 
            // collect all file items
            $this->bench->start("ContentObjectExport", "exportPageObject_CollectFileItems");
            //$file_ids = $page_obj->getFileItemIds();
            foreach ($file_ids as $file_id) {
                $this->file_ids[$file_id] = $file_id;
            }
            $this->bench->stop("ContentObjectExport", "exportPageObject_CollectFileItems");
 
            $a_xml_writer->xmlEndTag("PageObject");
            //unset($page_obj);
 
            $this->bench->stop("ContentObjectExport", "exportPageObject");
        }
    }
 
    public function exportXMLMediaObjects(&$a_xml_writer, $a_inst, $a_target_dir, &$expLog)
    {
        foreach ($this->mob_ids as $mob_id) {
            $expLog->write(date("[y-m-d H:i:s] ") . "Media Object " . $mob_id);
            if (ilObjMediaObject::_exists((int) $mob_id)) {
                $target_dir = $a_target_dir . DIRECTORY_SEPARATOR . 'objects'
                    . DIRECTORY_SEPARATOR . 'il_' . IL_INST_ID . '_mob_' . $mob_id;
                ilFileUtils::createDirectory($target_dir);
                $media_obj = new ilObjMediaObject((int) $mob_id);
                $media_obj->exportXML($a_xml_writer, (int) $a_inst);
                foreach ($media_obj->getMediaItems() as $item) {
                    $stream = $item->getLocationStream();
                    file_put_contents($target_dir . DIRECTORY_SEPARATOR . $item->getLocation(), $stream);
                    $stream->close();
                }
                unset($media_obj);
            }
        }
    }
 
    public function exportFileItems($target_dir, &$expLog)
    {
        foreach ($this->file_ids as $file_id) {
            $expLog->write(date("[y-m-d H:i:s] ") . "File Item " . $file_id);
            $file_dir = $target_dir . '/objects/il_' . IL_INST_ID . '_file_' . $file_id;
            ilFileUtils::makeDir($file_dir);
            $file_obj = new ilObjFile((int) $file_id, false);
            $source_file = $file_obj->getFile($file_obj->getVersion());
            if (!is_file($source_file)) {
                $source_file = $file_obj->getFile();
            }
            if (is_file($source_file)) {
                copy($source_file, $file_dir . '/' . $file_obj->getFileName());
            }
            unset($file_obj);
        }
    }
 
    public function getImportMapping(): array
    {
        return [];
    }
 
    public function onMarkSchemaSaved(): void
    {
        $this->saveCompleteStatus($this->question_set_config_factory->getQuestionSetConfig());
 
        if ($this->participantDataExist()) {
            $this->recalculateScores(true);
        }
    }
 
    public function marksEditable(): bool
    {
        $total = $this->evalTotalPersons();
        $results_summary_settings = $this->getScoreSettings()->getResultSummarySettings();
        if ($total === 0
            || $results_summary_settings->getScoreReporting()->isReportingEnabled() === false) {
            return true;
        }
 
        if ($results_summary_settings->getScoreReporting() === ScoreReportingTypes::SCORE_REPORTING_DATE) {
            return $results_summary_settings->getReportingDate()
                >= new DateTimeImmutable('now', new DateTimeZone('UTC'));
        }
 
        return false;
    }
 
    public function saveAuthorToMetadata($author = "")
    {
        $path_to_lifecycle = $this->lo_metadata->paths()->custom()->withNextStep('lifeCycle')->get();
        $path_to_authors = $this->lo_metadata->paths()->authors();
 
        $reader = $this->lo_metadata->read($this->getId(), 0, $this->getType(), $path_to_lifecycle);
        if (!is_null($reader->allData($path_to_lifecycle)->current())) {
            return;
        }
 
        if ($author === '') {
            $author = $this->user->getFullname();
        }
        $this->lo_metadata->manipulate($this->getId(), 0, $this->getType())
                          ->prepareCreateOrUpdate($path_to_authors, $author)
                          ->execute();
    }
 
    protected function doCreateMetaData(): void
    {
        $this->saveAuthorToMetadata();
    }
 
    public function getAuthor(): string
    {
        $path_to_authors = $this->lo_metadata->paths()->authors();
        $author_data = $this->lo_metadata->read($this->getId(), 0, $this->getType(), $path_to_authors)
                                         ->allData($path_to_authors);
 
        return $this->lo_metadata->dataHelper()->makePresentableAsList(', ', ...$author_data);
    }
 
    public static function _lookupAuthor($obj_id): string
    {
        global $DIC;
 
        $lo_metadata = $DIC->learningObjectMetadata();
 
        $path_to_authors = $lo_metadata->paths()->authors();
        $author_data = $lo_metadata->read($obj_id, 0, "tst", $path_to_authors)
                                    ->allData($path_to_authors);
 
        return $lo_metadata->dataHelper()->makePresentableAsList(',', ...$author_data);
    }
 
    public static function _getAvailableTests($use_object_id = false): array
    {
        global $DIC;
        $ilUser = $DIC['ilUser'];
 
        $result_array = [];
        $tests = array_slice(
            array_reverse(
                ilUtil::_getObjectsByOperations("tst", "write", $ilUser->getId(), PHP_INT_MAX)
            ),
            0,
            10000
        );
 
        if (count($tests)) {
            $titles = ilObject::_prepareCloneSelection($tests, "tst");
            foreach ($tests as $ref_id) {
                if ($use_object_id) {
                    $obj_id = ilObject::_lookupObjId($ref_id);
                    $result_array[$obj_id] = $titles[$ref_id];
                } else {
                    $result_array[$ref_id] = $titles[$ref_id];
                }
            }
        }
        return $result_array;
    }
 
    public function cloneObject(int $target_id, int $copy_id = 0, bool $omit_tree = false): ?ilObject
    {
        $this->loadFromDb();
 
        $new_obj = parent::cloneObject($target_id, $copy_id, $omit_tree);
        $new_obj->setTmpCopyWizardCopyId($copy_id);
        $this->cloneMetaData($new_obj);
 
        $new_obj->saveToDb();
        $new_obj->addToNewsOnOnline(false, $new_obj->getObjectProperties()->getPropertyIsOnline()->getIsOnline());
 
        $new_main_settings = $this->getMainSettings()
            ->withIntroductionSettings(
                $this->getMainSettings()->getIntroductionSettings()->withIntroductionPageId(
                    $this->cloneIntroduction()
                )
            )->withFinishingSettings(
                $this->getMainSettings()->getFinishingSettings()->withConcludingRemarksPageId(
                    $this->cloneConcludingRemarks()
                )
            );
 
        $new_main_settings = $this->getMainSettingsRepository()->store($new_main_settings, $new_obj->getTestId());
        $this->getScoreSettingsRepository()->store(
            $this->getScoreSettings()->withId($new_main_settings->getId())
        );
        $this->marks_repository->storeMarkSchema(
            $this->getMarkSchema()->withTestId($new_obj->getTestId())
        );
 
        $new_obj->setTemplate($this->getTemplate());
 
        // clone certificate
        $pathFactory = new ilCertificatePathFactory();
        $templateRepository = new ilCertificateTemplateDatabaseRepository($this->db);
 
        $cloneAction = new ilCertificateCloneAction(
            $this->db,
            $pathFactory,
            $templateRepository,
            new ilCertificateObjectHelper()
        );
 
        $cloneAction->cloneCertificate($this, $new_obj);
 
        $this->question_set_config_factory->getQuestionSetConfig()->cloneQuestionSetRelatedData($new_obj);
        $new_obj->saveQuestionsToDb();
 
        $skillLevelThresholdList = new ilTestSkillLevelThresholdList($this->db);
        $skillLevelThresholdList->setTestId($this->getTestId());
        $skillLevelThresholdList->loadFromDb();
        $skillLevelThresholdList->cloneListForTest($new_obj->getTestId());
 
        $obj_settings = new ilLPObjSettings($this->getId());
        $obj_settings->cloneSettings($new_obj->getId());
 
        if ($new_obj->getTestLogger()->isLoggingEnabled()) {
            $new_obj->getTestLogger()->logTestAdministrationInteraction(
                $new_obj->getTestLogger()->getInteractionFactory()->buildTestAdministrationInteraction(
                    $new_obj->getRefId(),
                    $this->user->getId(),
                    TestAdministrationInteractionTypes::NEW_TEST_CREATED,
                    []
                )
            );
        }
 
        return $new_obj;
    }
 
    public function getQuestionCount(): int
    {
        $num = 0;
 
        if ($this->isRandomTest()) {
            $questionSetConfig = new ilTestRandomQuestionSetConfig(
                $this->tree,
                $this->db,
                $this->lng,
                $this->logger,
                $this->component_repository,
                $this,
                $this->questionrepository
            );
 
            $questionSetConfig->loadFromDb();
 
            if ($questionSetConfig->isQuestionAmountConfigurationModePerPool()) {
                $sourcePoolDefinitionList = new ilTestRandomQuestionSetSourcePoolDefinitionList(
                    $this->db,
                    $this,
                    new ilTestRandomQuestionSetSourcePoolDefinitionFactory($this->db, $this)
                );
 
                $sourcePoolDefinitionList->loadDefinitions();
 
                if (is_int($sourcePoolDefinitionList->getQuestionAmount())) {
                    $num = $sourcePoolDefinitionList->getQuestionAmount();
                }
            } elseif (is_int($questionSetConfig->getQuestionAmountPerTest())) {
                $num = $questionSetConfig->getQuestionAmountPerTest();
            }
        } else {
            $this->loadQuestions();
            $num = count($this->questions);
        }
 
        return $num;
    }
 
    public function getQuestionCountWithoutReloading(): int
    {
        if ($this->isRandomTest()) {
            return $this->getQuestionCount();
        }
        return count($this->questions);
    }
 
    public static function _getObjectIDFromTestID($test_id)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $object_id = false;
        $result = $ilDB->queryF(
            "SELECT obj_fi FROM tst_tests WHERE test_id = %s",
            ['integer'],
            [$test_id]
        );
        if ($result->numRows()) {
            $row = $ilDB->fetchAssoc($result);
            $object_id = $row["obj_fi"];
        }
        return $object_id;
    }
 
    public static function _getObjectIDFromActiveID($active_id)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $object_id = false;
        $result = $ilDB->queryF(
            "SELECT tst_tests.obj_fi FROM tst_tests, tst_active WHERE tst_tests.test_id = tst_active.test_fi AND tst_active.active_id = %s",
            ['integer'],
            [$active_id]
        );
        if ($result->numRows()) {
            $row = $ilDB->fetchAssoc($result);
            $object_id = $row["obj_fi"];
        }
        return $object_id;
    }
 
    public static function _getTestIDFromObjectID($object_id)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $test_id = false;
        $result = $ilDB->queryF(
            "SELECT test_id FROM tst_tests WHERE obj_fi = %s",
            ['integer'],
            [$object_id]
        );
        if ($result->numRows()) {
            $row = $ilDB->fetchAssoc($result);
            $test_id = $row["test_id"];
        }
        return $test_id;
    }
 
    public function getTextAnswer($active_id, $question_id, $pass = null): string
    {
        if (($active_id) && ($question_id)) {
            if ($pass === null) {
                $pass = assQuestion::_getSolutionMaxPass($question_id, $active_id);
            }
            if ($pass === null) {
                return '';
            }
            $query = $this->db->queryF(
                "SELECT value1 FROM tst_solutions WHERE active_fi = %s AND question_fi = %s AND pass = %s",
                ['integer', 'integer', 'integer'],
                [$active_id, $question_id, $pass]
            );
            $result = $this->db->fetchAll($query);
            if (count($result) == 1) {
                return $result[0]["value1"];
            }
        }
        return '';
    }
 
    public function getQuestiontext($question_id): string
    {
        $res = "";
        if ($question_id) {
            $result = $this->db->queryF(
                "SELECT question_text FROM qpl_questions WHERE question_id = %s",
                ['integer'],
                [$question_id]
            );
            if ($result->numRows() == 1) {
                $row = $this->db->fetchAssoc($result);
                $res = $row["question_text"];
            }
        }
        return $res;
    }
 
    public function getActiveParticipantList(): ilTestParticipantList
    {
        $participant_list = new ilTestParticipantList($this, $this->user, $this->lng, $this->db);
        $participant_list->initializeFromDbRows($this->getTestParticipants());
 
        return $participant_list;
    }
 
    public function &getInvitedUsers(int $user_id = 0, $order = "login, lastname, firstname"): array
    {
        $result_array = [];
 
        if ($this->getAnonymity()) {
            if ($user_id !== 0) {
                $result = $this->db->queryF(
                    "SELECT tst_active.active_id, tst_active.tries, usr_id, %s login, %s lastname, %s firstname, " .
                    "tst_active.submitted test_finished, matriculation, COALESCE(tst_active.last_finished_pass, -1) <> tst_active.last_started_pass unfinished_passes  FROM usr_data, tst_invited_user " .
                    "LEFT JOIN tst_active ON tst_active.user_fi = tst_invited_user.user_fi AND tst_active.test_fi = tst_invited_user.test_fi " .
                    "WHERE tst_invited_user.test_fi = %s and tst_invited_user.user_fi=usr_data.usr_id AND usr_data.usr_id=%s " .
                    "ORDER BY $order",
                    ['text', 'text', 'text', 'integer', 'integer'],
                    ['', $this->lng->txt('anonymous'), '', $this->getTestId(), $user_id]
                );
            } else {
                $result = $this->db->queryF(
                    "SELECT tst_active.active_id, tst_active.tries, usr_id, %s login, %s lastname, %s firstname, " .
                    "tst_active.submitted test_finished, matriculation, COALESCE(tst_active.last_finished_pass, -1) <> tst_active.last_started_pass unfinished_passes  FROM usr_data, tst_invited_user " .
                    "LEFT JOIN tst_active ON tst_active.user_fi = tst_invited_user.user_fi AND tst_active.test_fi = tst_invited_user.test_fi " .
                    "WHERE tst_invited_user.test_fi = %s and tst_invited_user.user_fi=usr_data.usr_id " .
                    "ORDER BY $order",
                    ['text', 'text', 'text', 'integer'],
                    ['', $this->lng->txt('anonymous'), '', $this->getTestId()]
                );
            }
        } else {
            if ($user_id !== 0) {
                $result = $this->db->queryF(
                    "SELECT tst_active.active_id, tst_active.tries, usr_id, login, lastname, firstname, " .
                    "tst_active.submitted test_finished, matriculation, COALESCE(tst_active.last_finished_pass, -1) <> tst_active.last_started_pass unfinished_passes  FROM usr_data, tst_invited_user " .
                    "LEFT JOIN tst_active ON tst_active.user_fi = tst_invited_user.user_fi AND tst_active.test_fi = tst_invited_user.test_fi " .
                    "WHERE tst_invited_user.test_fi = %s and tst_invited_user.user_fi=usr_data.usr_id AND usr_data.usr_id=%s " .
                    "ORDER BY $order",
                    ['integer', 'integer'],
                    [$this->getTestId(), $user_id]
                );
            } else {
                $result = $this->db->queryF(
                    "SELECT tst_active.active_id, tst_active.tries, usr_id, login, lastname, firstname, " .
                    "tst_active.submitted test_finished, matriculation, COALESCE(tst_active.last_finished_pass, -1) <> tst_active.last_started_pass unfinished_passes  FROM usr_data, tst_invited_user " .
                    "LEFT JOIN tst_active ON tst_active.user_fi = tst_invited_user.user_fi AND tst_active.test_fi = tst_invited_user.test_fi " .
                    "WHERE tst_invited_user.test_fi = %s and tst_invited_user.user_fi=usr_data.usr_id " .
                    "ORDER BY $order",
                    ['integer'],
                    [$this->getTestId()]
                );
            }
        }
        $result_array = [];
        while ($row = $this->db->fetchAssoc($result)) {
            $result_array[$row['usr_id']] = $row;
        }
        return $result_array;
    }
 
    public function getTestParticipants(): array
    {
        if ($this->getMainSettings()->getGeneralSettings()->getAnonymity()) {
            $query = "
                                SELECT  tst_active.active_id,
                                                tst_active.tries,
                                                tst_active.user_fi usr_id,
                                                %s login,
                                                %s lastname,
                                                %s firstname,
                                                tst_active.submitted test_finished,
                                                usr_data.matriculation,
                                                usr_data.active,
                                                tst_active.lastindex,
                                                COALESCE(tst_active.last_finished_pass, -1) <> tst_active.last_started_pass unfinished_passes
                                FROM tst_active
                                LEFT JOIN usr_data
                                ON tst_active.user_fi = usr_data.usr_id
                                WHERE tst_active.test_fi = %s
                                ORDER BY usr_data.lastname
                        ";
            $result = $this->db->queryF(
                $query,
                ['text', 'text', 'text', 'integer'],
                ['', $this->lng->txt("anonymous"), "", $this->getTestId()]
            );
        } else {
            $query = "
                                SELECT  tst_active.active_id,
                                                tst_active.tries,
                                                tst_active.user_fi usr_id,
                                                usr_data.login,
                                                usr_data.lastname,
                                                usr_data.firstname,
                                                tst_active.submitted test_finished,
                                                usr_data.matriculation,
                                                usr_data.active,
                                                tst_active.lastindex,
                                                COALESCE(tst_active.last_finished_pass, -1) <> tst_active.last_started_pass unfinished_passes
                                FROM tst_active
                                LEFT JOIN usr_data
                                ON tst_active.user_fi = usr_data.usr_id
                                WHERE tst_active.test_fi = %s
                                ORDER BY usr_data.lastname
                        ";
            $result = $this->db->queryF(
                $query,
                ['integer'],
                [$this->getTestId()]
            );
        }
        $data = [];
        while ($row = $this->db->fetchAssoc($result)) {
            $data[$row['active_id']] = $row;
        }
        foreach ($data as $index => $participant) {
            if (strlen(trim($participant["firstname"] . $participant["lastname"])) == 0) {
                $data[$index]["lastname"] = $this->lng->txt("deleted_user");
            }
        }
        return $data;
    }
 
    public function getTestParticipantsForManualScoring($filter = null): array
    {
        if (!$this->getGlobalSettings()->isManualScoringEnabled()) {
            return [];
        }
 
        $filtered_participants = [];
        foreach ($this->getTestParticipants() as $active_id => $participant) {
            if ($participant['tries'] > 0) {
                switch ($filter) {
                    case 4:
                        if ($this->test_man_scoring_done_helper->isDone((int) $active_id)) {
                            $filtered_participants[$active_id] = $participant;
                        }
                        break;
                    case 5:
                        if (!$this->test_man_scoring_done_helper->isDone((int) $active_id)) {
                            $filtered_participants[$active_id] = $participant;
                        }
                        break;
                    default:
                        $filtered_participants[$active_id] = $participant;
                }
            }
        }
        return $filtered_participants;
    }
 
    public function getUserData($ids): array
    {
        if (!is_array($ids) || count($ids) == 0) {
            return [];
        }
 
        if ($this->getAnonymity()) {
            $result = $this->db->queryF(
                "SELECT usr_id, %s login, %s lastname, %s firstname, client_ip clientip FROM usr_data WHERE " . $this->db->in('usr_id', $ids, false, 'integer') . " ORDER BY login",
                ['text', 'text', 'text'],
                ["", $this->lng->txt("anonymous"), ""]
            );
        } else {
            $result = $this->db->query("SELECT usr_id, login, lastname, firstname, client_ip clientip FROM usr_data WHERE " . $this->db->in('usr_id', $ids, false, 'integer') . " ORDER BY login");
        }
 
        $result_array = [];
        while ($row = $this->db->fetchAssoc($result)) {
            $result_array[$row["usr_id"]] = $row;
        }
        return $result_array;
    }
 
    public function getGroupData($ids): array
    {
        if (!is_array($ids) || count($ids) == 0) {
            return [];
        }
        $result = [];
        foreach ($ids as $ref_id) {
            $obj_id = ilObject::_lookupObjId($ref_id);
            $result[$ref_id] = ["ref_id" => $ref_id, "title" => ilObject::_lookupTitle($obj_id), "description" => ilObject::_lookupDescription($obj_id)];
        }
        return $result;
    }
 
    public function getRoleData($ids): array
    {
        if (!is_array($ids) || count($ids) == 0) {
            return [];
        }
        $result = [];
        foreach ($ids as $obj_id) {
            $result[$obj_id] = ["obj_id" => $obj_id, "title" => ilObject::_lookupTitle($obj_id), "description" => ilObject::_lookupDescription($obj_id)];
        }
        return $result;
    }
 
    public function inviteUser($user_id, $client_ip = "")
    {
        $this->db->manipulateF(
            "DELETE FROM tst_invited_user WHERE test_fi = %s AND user_fi = %s",
            ['integer', 'integer'],
            [$this->getTestId(), $user_id]
        );
        $this->db->manipulateF(
            "INSERT INTO tst_invited_user (test_fi, user_fi, ip_range_from, ip_range_to, tstamp) VALUES (%s, %s, %s, %s, %s)",
            ['integer', 'integer', 'text', 'text', 'integer'],
            [$this->getTestId(), $user_id, (strlen($client_ip)) ? $client_ip : null, (strlen($client_ip)) ? $client_ip : null,time()]
        );
    }
 
    public static function _getSolvedQuestions($active_id, $question_fi = null): array
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        if (is_numeric($question_fi)) {
            $result = $ilDB->queryF(
                "SELECT question_fi, solved FROM tst_qst_solved WHERE active_fi = %s AND question_fi=%s",
                ['integer', 'integer'],
                [$active_id, $question_fi]
            );
        } else {
            $result = $ilDB->queryF(
                "SELECT question_fi, solved FROM tst_qst_solved WHERE active_fi = %s",
                ['integer'],
                [$active_id]
            );
        }
        $result_array = [];
        while ($row = $ilDB->fetchAssoc($result)) {
            $result_array[$row["question_fi"]] = $row;
        }
        return $result_array;
    }
 
 
    public function setQuestionSetSolved($value, $question_id, $user_id)
    {
        $active_id = $this->getActiveIdOfUser($user_id);
        $this->db->manipulateF(
            "DELETE FROM tst_qst_solved WHERE active_fi = %s AND question_fi = %s",
            ['integer', 'integer'],
            [$active_id, $question_id]
        );
        $this->db->manipulateF(
            "INSERT INTO tst_qst_solved (solved, question_fi, active_fi) VALUES (%s, %s, %s)",
            ['integer', 'integer', 'integer'],
            [$value, $question_id, $active_id]
        );
    }
 
    public function isTestFinished($active_id): bool
    {
        $result = $this->db->queryF(
            "SELECT submitted FROM tst_active WHERE active_id=%s AND submitted=%s",
            ['integer', 'integer'],
            [$active_id, 1]
        );
        return $result->numRows() == 1;
    }
 
    public function isActiveTestSubmitted($user_id = null): bool
    {
        if (!is_numeric($user_id)) {
            $user_id = $this->user->getId();
        }
 
        $result = $this->db->queryF(
            "SELECT submitted FROM tst_active WHERE test_fi=%s AND user_fi=%s AND submitted=%s",
            ['integer', 'integer', 'integer'],
            [$this->getTestId(), $user_id, 1]
        );
        return $result->numRows() == 1;
    }
 
    public function hasNrOfTriesRestriction(): bool
    {
        return $this->getNrOfTries() != 0;
    }
 
 
    public function isNrOfTriesReached($tries): bool
    {
        return $tries >= $this->getNrOfTries();
    }
 
 
    public function getAllTestResults($participants): array
    {
        $results = [];
        $row = [
            "user_id" => $this->lng->txt("user_id"),
            "matriculation" => $this->lng->txt("matriculation"),
            "lastname" => $this->lng->txt("lastname"),
            "firstname" => $this->lng->txt("firstname"),
            "login" => $this->lng->txt("login"),
            "reached_points" => $this->lng->txt("tst_reached_points"),
            "max_points" => $this->lng->txt("tst_maximum_points"),
            "percent_value" => $this->lng->txt("tst_percent_solved"),
            "mark" => $this->lng->txt("tst_mark"),
            "passed" => $this->lng->txt("tst_mark_passed"),
        ];
        $results[] = $row;
        if (count($participants)) {
            foreach ($participants as $active_id => $user_rec) {
                $mark = '';
                $row = [];
                $reached_points = 0;
                $max_points = 0;
                $pass = ilObjTest::_getResultPass($active_id);
                // abort if no valid pass can be found
                if (!is_int($pass)) {
                    continue;
                }
                foreach ($this->questions as $value) {
                    $question = ilObjTest::_instanciateQuestion($value);
                    if (is_object($question)) {
                        $max_points += $question->getMaximumPoints();
                        $reached_points += $question->getReachedPoints($active_id, $pass);
                    }
                }
                if ($max_points > 0) {
                    $percentvalue = $reached_points / $max_points;
                    if ($percentvalue < 0) {
                        $percentvalue = 0.0;
                    }
                } else {
                    $percentvalue = 0;
                }
                $mark_obj = $this->getMarkSchema()->getMatchingMark($percentvalue * 100);
                $passed = "";
                if ($mark_obj !== null) {
                    $mark = $mark_obj->getOfficialName();
                }
                if ($this->getAnonymity()) {
                    $user_rec['firstname'] = "";
                    $user_rec['lastname'] = $this->lng->txt("anonymous");
                }
                $results[] = [
                    "user_id" => $user_rec['usr_id'],
                    "matriculation" => $user_rec['matriculation'],
                    "lastname" => $user_rec['lastname'],
                    "firstname" => $user_rec['firstname'],
                    "login" => $user_rec['login'],
                    "reached_points" => $reached_points,
                    "max_points" => $max_points,
                    "percent_value" => $percentvalue,
                    "mark" => $mark,
                    "passed" => $user_rec['passed'] ? '1' : '0',
                ];
            }
        }
        return $results;
    }
 
    public static function _getPass($active_id): int
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $result = $ilDB->queryF(
            "SELECT tries FROM tst_active WHERE active_id = %s",
            ['integer'],
            [$active_id]
        );
        if ($result->numRows()) {
            $row = $ilDB->fetchAssoc($result);
            return $row["tries"];
        } else {
            return 0;
        }
    }
 
    public static function _getMaxPass($active_id): ?int
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $result = $ilDB->queryF(
            "SELECT MAX(pass) maxpass FROM tst_pass_result WHERE active_fi = %s",
            ['integer'],
            [$active_id]
        );
 
        if ($result->numRows()) {
            $row = $ilDB->fetchAssoc($result);
            return $row["maxpass"];
        }
 
        return null;
    }
 
    public static function _getBestPass($active_id): ?int
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $result = $ilDB->queryF(
            "SELECT * FROM tst_pass_result WHERE active_fi = %s",
            ['integer'],
            [$active_id]
        );
 
        if (!$result->numRows()) {
            return null;
        }
 
        $bestrow = null;
        $bestfactor = 0.0;
        while ($row = $ilDB->fetchAssoc($result)) {
            if ($row["maxpoints"] > 0.0) {
                $factor = (float) ($row["points"] / $row["maxpoints"]);
            } else {
                $factor = 0.0;
            }
            if ($factor === 0.0 && $bestfactor === 0.0
                || $factor > $bestfactor) {
                $bestrow = $row;
                $bestfactor = $factor;
            }
        }
 
        if (is_array($bestrow)) {
            return $bestrow["pass"];
        }
 
        return null;
    }
 
    public static function _getResultPass($active_id): ?int
    {
        $counted_pass = null;
        if (ilObjTest::_getPassScoring($active_id) == self::SCORE_BEST_PASS) {
            $counted_pass = ilObjTest::_getBestPass($active_id);
        } else {
            $counted_pass = ilObjTest::_getMaxPass($active_id);
        }
        return $counted_pass;
    }
 
    public function getAnsweredQuestionCount($active_id, $pass = null): int
    {
        if ($this->isRandomTest()) {
            $this->loadQuestions($active_id, $pass);
        }
        $workedthrough = 0;
        foreach ($this->questions as $value) {
            if ($this->questionrepository->lookupResultRecordExist($active_id, $value, $pass)) {
                $workedthrough += 1;
            }
        }
        return $workedthrough;
    }
 
    public static function lookupPassResultsUpdateTimestamp($active_id, $pass): int
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        if (is_null($pass)) {
            $pass = 0;
        }
 
        $query = "
                        SELECT  tst_pass_result.tstamp pass_res_tstamp,
                                        tst_test_result.tstamp quest_res_tstamp
 
                        FROM tst_pass_result
 
                        LEFT JOIN tst_test_result
                        ON tst_test_result.active_fi = tst_pass_result.active_fi
                        AND tst_test_result.pass = tst_pass_result.pass
 
                        WHERE tst_pass_result.active_fi = %s
                        AND tst_pass_result.pass = %s
 
                        ORDER BY tst_test_result.tstamp DESC
                ";
 
        $result = $ilDB->queryF(
            $query,
            ['integer', 'integer'],
            [$active_id, $pass]
        );
 
        while ($row = $ilDB->fetchAssoc($result)) {
            if ($row['quest_res_tstamp']) {
                return $row['quest_res_tstamp'];
            }
 
            return $row['pass_res_tstamp'];
        }
 
        return 0;
    }
 
    public function isExecutable($test_session, $user_id, $allow_pass_increase = false): array
    {
        $result = [
            "executable" => true,
            "errormessage" => ""
        ];
 
        if (!$this->getObjectProperties()->getPropertyIsOnline()->getIsOnline()) {
            $result["executable"] = false;
            $result["errormessage"] = $this->lng->txt('autosave_failed') . ': ' . $this->lng->txt('offline');
            return $result;
        }
 
        if (!$this->startingTimeReached()) {
            $result["executable"] = false;
            $result["errormessage"] = sprintf($this->lng->txt("detail_starting_time_not_reached"), ilDatePresentation::formatDate(new ilDateTime($this->getStartingTime(), IL_CAL_UNIX)));
            return $result;
        }
        if ($this->endingTimeReached()) {
            $result["executable"] = false;
            $result["errormessage"] = sprintf($this->lng->txt("detail_ending_time_reached"), ilDatePresentation::formatDate(new ilDateTime($this->getEndingTime(), IL_CAL_UNIX)));
            return $result;
        }
 
        $active_id = $this->getActiveIdOfUser($user_id);
 
        if ($this->getEnableProcessingTime()
            && $active_id > 0
            && ($starting_time = $this->getStartingTimeOfUser($active_id)) !== false
            && $this->isMaxProcessingTimeReached($starting_time, $active_id)) {
            $result["executable"] = false;
            $result["errormessage"] = $this->lng->txt("detail_max_processing_time_reached");
            return $result;
        }
 
        $testPassesSelector = new ilTestPassesSelector($this->db, $this);
        $testPassesSelector->setActiveId($active_id);
        $testPassesSelector->setLastFinishedPass($test_session->getLastFinishedPass());
 
        if ($this->hasNrOfTriesRestriction() && ($active_id > 0)) {
            $closedPasses = $testPassesSelector->getClosedPasses();
 
            if (count($closedPasses) >= $this->getNrOfTries()) {
                $result["executable"] = false;
                $result["errormessage"] = $this->lng->txt("maximum_nr_of_tries_reached");
                return $result;
            }
 
            if ($this->isBlockPassesAfterPassedEnabled() && !$testPassesSelector->openPassExists()) {
                if ($this->test_result_repository->isPassed($user_id, $this->getId())) {
                    $result['executable'] = false;
                    $result['errormessage'] = $this->lng->txt("tst_addit_passes_blocked_after_passed_msg");
                    return $result;
                }
            }
        }
 
        $next_pass_allowed_timestamp = 0;
        if (!$this->isNextPassAllowed($testPassesSelector, $next_pass_allowed_timestamp)) {
            $date = ilDatePresentation::formatDate(new ilDateTime($next_pass_allowed_timestamp, IL_CAL_UNIX));
 
            $result['executable'] = false;
            $result['errormessage'] = sprintf($this->lng->txt('wait_for_next_pass_hint_msg'), $date);
            return $result;
        }
        return $result;
    }
 
    public function isNextPassAllowed(ilTestPassesSelector $testPassesSelector, int &$next_pass_allowed_timestamp): bool
    {
        $waiting_between_passes = $this->getMainSettings()->getTestBehaviourSettings()->getPassWaiting();
        $last_finished_pass_timestamp = $testPassesSelector->getLastFinishedPassTimestamp();
 
        if (
            $this->getMainSettings()->getTestBehaviourSettings()->getPassWaitingEnabled()
            && ($waiting_between_passes !== '')
            && ($testPassesSelector->getLastFinishedPass() !== null)
            && ($last_finished_pass_timestamp !== null)
        ) {
            $time_values = explode(':', $waiting_between_passes);
            $next_pass_allowed_timestamp = strtotime('+ ' . $time_values[0] . ' Days + ' . $time_values[1] . ' Hours' . $time_values[2] . ' Minutes', $last_finished_pass_timestamp);
            return (time() > $next_pass_allowed_timestamp);
        }
 
        return true;
    }
 
    public function canShowTestResults(ilTestSession $test_session): bool
    {
        $pass_selector = new ilTestPassesSelector($this->db, $this);
 
        $pass_selector->setActiveId($test_session->getActiveId());
        $pass_selector->setLastFinishedPass($test_session->getLastFinishedPass());
 
        return $pass_selector->hasReportablePasses();
    }
 
    public function hasAnyTestResult(ilTestSession $test_session): bool
    {
        $pass_selector = new ilTestPassesSelector($this->db, $this);
 
        $pass_selector->setActiveId($test_session->getActiveId());
        $pass_selector->setLastFinishedPass($test_session->getLastFinishedPass());
 
        return $pass_selector->hasExistingPasses();
    }
 
    public function getStartingTimeOfUser($active_id, $pass = null)
    {
        if ($active_id < 1) {
            return false;
        }
        if ($pass === null) {
            $pass = ($this->getResetProcessingTime()) ? self::_getPass($active_id) : 0;
        }
        $result = $this->db->queryF(
            "SELECT tst_times.started FROM tst_times WHERE tst_times.active_fi = %s AND tst_times.pass = %s ORDER BY tst_times.started",
            ['integer', 'integer'],
            [$active_id, $pass]
        );
        if ($result->numRows()) {
            $row = $this->db->fetchAssoc($result);
            if (preg_match("/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/", $row["started"], $matches)) {
                return mktime(
                    (int) $matches[4],
                    (int) $matches[5],
                    (int) $matches[6],
                    (int) $matches[2],
                    (int) $matches[3],
                    (int) $matches[1]
                );
            } else {
                return time();
            }
        } else {
            return time();
        }
    }
 
    public function isMaxProcessingTimeReached(int $starting_time, int $active_id): bool
    {
        if (!$this->getEnableProcessingTime()) {
            return false;
        }
 
        $processing_time = $this->getProcessingTimeInSeconds($active_id);
        $now = time();
        if ($now > ($starting_time + $processing_time)) {
            return true;
        }
 
        return false;
    }
 
    public function getTestQuestions(): array
    {
        $tags_trafo = $this->refinery->string()->stripTags();
 
        $query = "
                        SELECT          questions.*,
                                                questtypes.type_tag,
                                                tstquest.sequence,
                                                origquest.obj_fi orig_obj_fi
 
                        FROM            qpl_questions questions
 
                        INNER JOIN      qpl_qst_type questtypes
                        ON                      questtypes.question_type_id = questions.question_type_fi
 
                        INNER JOIN      tst_test_question tstquest
                        ON                      tstquest.question_fi = questions.question_id
 
                        LEFT JOIN       qpl_questions origquest
                        ON                      origquest.question_id = questions.original_id
 
                        WHERE           tstquest.test_fi = %s
 
                        ORDER BY        tstquest.sequence
                ";
 
        $query_result = $this->db->queryF(
            $query,
            ['integer'],
            [$this->getTestId()]
        );
 
        $questions = [];
 
        while ($row = $this->db->fetchAssoc($query_result)) {
            $row['title'] = $tags_trafo->transform($row['title']);
            $row['description'] = $tags_trafo->transform($row['description'] !== '' && $row['description'] !== null ? $row['description'] : '&nbsp;');
            $row['author'] = $tags_trafo->transform($row['author']);
 
            $questions[] = $row;
        }
 
        return $questions;
    }
 
    public function isTestQuestion(int $question_id): bool
    {
        foreach ($this->getTestQuestions() as $questionData) {
            if ($questionData['question_id'] != $question_id) {
                continue;
            }
 
            return true;
        }
 
        return false;
    }
 
    public function checkQuestionParent(int $question_id): bool
    {
        $row = $this->db->fetchAssoc($this->db->queryF(
            "SELECT COUNT(question_id) cnt FROM qpl_questions WHERE question_id = %s AND obj_fi = %s",
            ['integer', 'integer'],
            [$question_id, $this->getId()]
        ));
 
        return (bool) $row['cnt'];
    }
 
    public function getFixedQuestionSetTotalPoints(): float
    {
        $points = 0;
 
        foreach ($this->getTestQuestions() as $question_data) {
            $points += $question_data['points'];
        }
 
        return $points;
    }
 
    public function getPotentialRandomTestQuestions(): array
    {
        $query = "
                        SELECT          questions.*,
                                                questtypes.type_tag,
                                                origquest.obj_fi orig_obj_fi
 
                        FROM            qpl_questions questions
 
                        INNER JOIN      qpl_qst_type questtypes
                        ON                      questtypes.question_type_id = questions.question_type_fi
 
                        INNER JOIN      tst_rnd_cpy tstquest
                        ON                      tstquest.qst_fi = questions.question_id
 
                        LEFT JOIN       qpl_questions origquest
                        ON                      origquest.question_id = questions.original_id
 
                        WHERE           tstquest.tst_fi = %s
                ";
 
        $query_result = $this->db->queryF(
            $query,
            ['integer'],
            [$this->getTestId()]
        );
 
        return $this->db->fetchAll($query_result);
    }
 
    public function getShuffleQuestions(): bool
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getShuffleQuestions();
    }
 
    public function getListOfQuestionsSettings()
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getUsrPassOverviewMode();
    }
 
    public function getListOfQuestions(): bool
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getQuestionListEnabled();
    }
 
    public function getUsrPassOverviewEnabled(): bool
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getUsrPassOverviewEnabled();
    }
 
    public function getListOfQuestionsStart(): bool
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getShownQuestionListAtBeginning();
    }
 
    public function getListOfQuestionsEnd(): bool
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getShownQuestionListAtEnd();
    }
 
    public function getListOfQuestionsDescription(): bool
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getShowDescriptionInQuestionList();
    }
 
    public function getShowPassDetails(): bool
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getShowPassDetails();
    }
 
    public function getShowSolutionPrintview(): bool
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getShowSolutionPrintview();
    }
    public function canShowSolutionPrintview($user_id = null): bool
    {
        return $this->getShowSolutionPrintview();
    }
 
    public function getShowSolutionFeedback(): bool
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getShowSolutionFeedback();
    }
 
    public function getShowSolutionAnswersOnly(): bool
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getShowSolutionAnswersOnly();
    }
 
    public function getShowSolutionSignature(): bool
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getShowSolutionSignature();
    }
 
    public function getShowSolutionSuggested(): bool
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getShowSolutionSuggested();
    }
 
    public function getShowSolutionListComparison(): bool
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getShowSolutionListComparison();
    }
 
    public function getShowSolutionListOwnAnswers(): bool
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getShowSolutionListOwnAnswers();
    }
 
    public static function _getUserIdFromActiveId(int $active_id): int
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $result = $ilDB->queryF(
            "SELECT user_fi FROM tst_active WHERE active_id = %s",
            ['integer'],
            [$active_id]
        );
        if ($result->numRows()) {
            $row = $ilDB->fetchAssoc($result);
            return $row["user_fi"];
        } else {
            return -1;
        }
    }
 
    public function _getLastAccess(int $active_id): string
    {
        $result = $this->db->queryF(
            "SELECT finished FROM tst_times WHERE active_fi = %s ORDER BY finished DESC",
            ['integer'],
            [$active_id]
        );
        if ($result->numRows()) {
            $row = $this->db->fetchAssoc($result);
            return $row["finished"];
        }
        return "";
    }
 
    public static function lookupLastTestPassAccess(int $active_id, int $pass_index): ?int
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $query = "
            SELECT MAX(tst_times.tstamp) as last_pass_access
            FROM tst_times
            WHERE active_fi = %s
            AND pass = %s
        ";
 
        $res = $ilDB->queryF(
            $query,
            ['integer', 'integer'],
            [$active_id, $pass_index]
        );
 
        while ($row = $ilDB->fetchAssoc($res)) {
            return $row['last_pass_access'];
        }
 
        return null;
    }
 
    public function isHTML($a_text): bool
    {
        if (preg_match("/<[^>]*?>/", $a_text)) {
            return true;
        } else {
            return false;
        }
    }
 
    public function qtiMaterialToArray($a_material): array
    {
        $result = '';
        $mobs = [];
        for ($i = 0; $i < $a_material->getMaterialCount(); $i++) {
            $material = $a_material->getMaterial($i);
            if ($material['type'] === 'mattext') {
                $result .= $material['material']->getContent();
            }
            if ($material['type'] === 'matimage') {
                $matimage = $material['material'];
                if (preg_match('/(il_([0-9]+)_mob_([0-9]+))/', $matimage->getLabel(), $matches)) {
                    $mobs[] = [
                        'mob' => $matimage->getLabel(),
                        'uri' => $matimage->getUri()
                    ];
                }
            }
        }
 
        $decoded_result = base64_decode($result);
        if (str_starts_with($decoded_result, '<PageObject>')) {
            $result = $decoded_result;
        }
 
        return [
            'text' => $result,
            'mobs' => $mobs
        ];
    }
 
    public function addQTIMaterial(ilXmlWriter &$xml_writer, ?int $page_id, string $material = ''): void
    {
        $xml_writer->xmlStartTag('material');
        $attrs = [
            'texttype' => 'text/plain'
        ];
        $file_ids = [];
        $mobs = [];
        if ($page_id !== null) {
            $attrs['texttype'] = 'text/xml';
            $mobs = ilObjMediaObject::_getMobsOfObject('tst:pg', $page_id);
            $page_object = new ilTestPage($page_id);
            $page_object->buildDom();
            $page_object->insertInstIntoIDs((string) IL_INST_ID);
            $material = base64_encode($page_object->getXMLFromDom());
            $file_ids = ilPCFileList::collectFileItems($page_object, $page_object->getDomDoc());
            foreach ($file_ids as $file_id) {
                $this->file_ids[] = (int) $file_id;
            };
            $mob_string = 'il_' . IL_INST_ID . '_mob_';
        } elseif ($this->isHTML($material)) {
            $attrs['texttype'] = 'text/xhtml';
            $mobs = ilObjMediaObject::_getMobsOfObject('tst:html', $this->getId());
            $mob_string = 'mm_';
        }
 
        $xml_writer->xmlElement('mattext', $attrs, $material);
        foreach ($mobs as $mob) {
            $mob_id_string = (string) $mob;
            $moblabel = 'il_' . IL_INST_ID . '_mob_' . $mob_id_string;
            if (strpos($material, $mob_string . $mob_id_string) !== false) {
                if (ilObjMediaObject::_exists($mob)) {
                    $mob_obj = new ilObjMediaObject($mob);
                    $imgattrs = [
                        'label' => $moblabel,
                        'uri' => 'objects/' . 'il_' . IL_INST_ID . '_mob_' . $mob_id_string . '/' . $mob_obj->getTitle()
                    ];
                }
                $xml_writer->xmlElement('matimage', $imgattrs, null);
            }
        }
        $xml_writer->xmlEndTag('material');
    }
 
    public function prepareTextareaOutput($txt_output, $prepare_for_latex_output = false, $omitNl2BrWhenTextArea = false)
    {
        if ($txt_output == null) {
            $txt_output = '';
        }
        return ilLegacyFormElementsUtil::prepareTextareaOutput(
            $txt_output,
            $prepare_for_latex_output,
            $omitNl2BrWhenTextArea
        );
    }
 
    public function getAnonymity(): bool
    {
        return $this->getMainSettings()->getGeneralSettings()->getAnonymity();
    }
 
    public function getShowCancel(): bool
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getSuspendTestAllowed();
    }
 
    public function getShowMarker(): bool
    {
        return $this->getMainSettings()->getParticipantFunctionalitySettings()->getQuestionMarkingEnabled();
    }
 
    public function getFixedParticipants(): bool
    {
        return $this->getMainSettings()->getAccessSettings()->getFixedParticipants();
    }
 
    public function lookupQuestionSetTypeByActiveId(int $active_id): string
    {
        return $this->main_settings_repository->getFor(
            self::_getTestIDFromObjectID(self::_getObjectIDFromActiveID($active_id)),
        )->getGeneralSettings()->getQuestionSetType();
    }
 
    public function userLookupFullName($user_id, $overwrite_anonymity = false, $sorted_order = false, $suffix = ""): string
    {
        if ($this->getAnonymity() && !$overwrite_anonymity) {
            return $this->lng->txt("anonymous") . $suffix;
        } else {
            $uname = ilObjUser::_lookupName($user_id);
            if (strlen($uname["firstname"] . $uname["lastname"]) == 0) {
                $uname["firstname"] = $this->lng->txt("deleted_user");
            }
            if ($sorted_order) {
                return trim($uname["lastname"] . ", " . $uname["firstname"]) . $suffix;
            } else {
                return trim($uname["firstname"] . " " . $uname["lastname"]) . $suffix;
            }
        }
    }
 
    private function convertTimeToDateTimeImmutableIfNecessary(
        DateTimeImmutable|int|null $date_time
    ): ?DateTimeImmutable {
        if ($date_time === null || $date_time instanceof DateTimeImmutable) {
            return $date_time;
        }
 
        return DateTimeImmutable::createFromFormat('U', (string) $date_time);
    }
 
    public function processPrintoutput2FO($print_output): string
    {
        if (extension_loaded("tidy")) {
            $config = [
                "indent" => false,
                "output-xml" => true,
                "numeric-entities" => true
            ];
            $tidy = new tidy();
            $tidy->parseString($print_output, $config, 'utf8');
            $tidy->cleanRepair();
            $print_output = tidy_get_output($tidy);
            $print_output = preg_replace("/^.*?(<html)/", "\\1", $print_output);
        } else {
            $print_output = str_replace("&nbsp;", "&#160;", $print_output);
            $print_output = str_replace("&otimes;", "X", $print_output);
        }
        $xsl = file_get_contents("./components/ILIAS/Test/xml/question2fo.xsl");
 
        // additional font support
 
        $xsl = str_replace(
            'font-family="Helvetica, unifont"',
            'font-family="' . $this->settings->get('rpc_pdf_font', 'Helvetica, unifont') . '"',
            $xsl
        );
 
        $args = [ '/_xml' => $print_output, '/_xsl' => $xsl ];
        $xh = xslt_create();
        $params = [];
        $output = xslt_process($xh, "arg:/_xml", "arg:/_xsl", null, $args, $params);
        xslt_error($xh);
        xslt_free($xh);
        return $output;
    }
 
    public function deliverPDFfromHTML($content, $title = null)
    {
        $content = preg_replace("/href=\".*?\"/", "", $content);
        $printbody = new ilTemplate("tpl.il_as_tst_print_body.html", true, true, "components/ILIAS/Test");
        $printbody->setVariable("TITLE", ilLegacyFormElementsUtil::prepareFormOutput($this->getTitle()));
        $printbody->setVariable("ADM_CONTENT", $content);
        $printbody->setCurrentBlock("css_file");
        $printbody->setVariable("CSS_FILE", ilUtil::getStyleSheetLocation("filesystem", "delos.css"));
        $printbody->parseCurrentBlock();
        $printoutput = $printbody->get();
        $html = str_replace("href=\"./", "href=\"" . ILIAS_HTTP_PATH . "/", $printoutput);
        $html = preg_replace("/<div id=\"dontprint\">.*?<\\/div>/ims", "", $html);
        if (extension_loaded("tidy")) {
            $config = [
                "indent" => false,
                "output-xml" => true,
                "numeric-entities" => true
            ];
            $tidy = new tidy();
            $tidy->parseString($html, $config, 'utf8');
            $tidy->cleanRepair();
            $html = tidy_get_output($tidy);
            $html = preg_replace("/^.*?(<html)/", "\\1", $html);
        } else {
            $html = str_replace("&nbsp;", "&#160;", $html);
            $html = str_replace("&otimes;", "X", $html);
        }
        $html = preg_replace("/src=\".\\//ims", "src=\"" . ILIAS_HTTP_PATH . "/", $html);
        $this->deliverPDFfromFO($this->processPrintoutput2FO($html), $title);
    }
 
    public function deliverPDFfromFO($fo, $title = null): bool
    {
        $fo_file = ilFileUtils::ilTempnam() . ".fo";
        $fp = fopen($fo_file, "w");
        fwrite($fp, $fo);
        fclose($fp);
 
        try {
            $pdf_base64 = ilRpcClientFactory::factory('RPCTransformationHandler')->ilFO2PDF($fo);
            $filename = (strlen($title)) ? $title : $this->getTitle();
            ilUtil::deliverData(
                $pdf_base64->scalar,
                ilFileUtils::getASCIIFilename($filename) . ".pdf",
                "application/pdf"
            );
            return true;
        } catch (Exception $e) {
            $this->logger->info(__METHOD__ . ': ' . $e->getMessage());
            return false;
        }
    }
 
    public static function getManualFeedback(int $active_id, int $question_id, ?int $pass): string
    {
        if ($pass === null) {
            return '';
        }
        $feedback = '';
        $row = self::getSingleManualFeedback((int) $active_id, (int) $question_id, (int) $pass);
 
        if ($row !== [] && ($row['finalized_evaluation'] || \ilTestService::isManScoringDone((int) $active_id))) {
            $feedback = $row['feedback'] ?? '';
        }
 
        return $feedback;
    }
 
    public static function getSingleManualFeedback(int $active_id, int $question_id, int $pass): array
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $row = [];
        $result = $ilDB->queryF(
            "SELECT * FROM tst_manual_fb WHERE active_fi = %s AND question_fi = %s AND pass = %s",
            ['integer', 'integer', 'integer'],
            [$active_id, $question_id, $pass]
        );
 
        if ($ilDB->numRows($result) === 1) {
            $row = $ilDB->fetchAssoc($result);
            $row['feedback'] = ilRTE::_replaceMediaObjectImageSrc($row['feedback'] ?? '', 1);
        } elseif ($ilDB->numRows($result) > 1) {
            $DIC->logger()->root()->warning(
                "WARNING: Multiple feedback entries on tst_manual_fb for " .
                "active_fi = $active_id , question_fi = $question_id and pass = $pass"
            );
        }
 
        return $row;
    }
 
    public function getCompleteManualFeedback(int $question_id): array
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $feedback = [];
        $result = $ilDB->queryF(
            "SELECT * FROM tst_manual_fb WHERE question_fi = %s",
            ['integer'],
            [$question_id]
        );
 
        while ($row = $ilDB->fetchAssoc($result)) {
            $active = $row['active_fi'];
            $pass = $row['pass'];
            $question = $row['question_fi'];
 
            $row['feedback'] = ilRTE::_replaceMediaObjectImageSrc($row['feedback'] ?? '', 1);
 
            $feedback[$active][$pass][$question] = $row;
        }
 
        return $feedback;
    }
 
    public function saveManualFeedback(
        int $active_id,
        int $question_id,
        int $pass,
        ?string $feedback,
        bool $finalized = false
    ): void {
        $feedback_old = self::getSingleManualFeedback($active_id, $question_id, $pass);
        $this->db->manipulateF(
            'DELETE FROM tst_manual_fb WHERE active_fi = %s AND question_fi = %s AND pass = %s',
            ['integer', 'integer', 'integer'],
            [$active_id, $question_id, $pass]
        );
 
        $this->insertManualFeedback($active_id, $question_id, $pass, $feedback, $finalized, $feedback_old);
 
    }
 
    private function insertManualFeedback(
        int $active_id,
        int $question_id,
        int $pass,
        ?string $feedback,
        bool $finalized,
        array $feedback_old
    ): void {
        $next_id = $this->db->nextId('tst_manual_fb');
        $user = $this->user->getId();
        $finalized_time = time();
 
        $update_default = [
            'manual_feedback_id' => [ 'integer', $next_id],
            'active_fi' => [ 'integer', $active_id],
            'question_fi' => [ 'integer', $question_id],
            'pass' => [ 'integer', $pass],
            'feedback' => [ 'clob', $feedback ? ilRTE::_replaceMediaObjectImageSrc($feedback, 0) : null],
            'tstamp' => [ 'integer', time()]
        ];
 
        if ($feedback_old !== [] && (int) $feedback_old['finalized_evaluation'] === 1) {
            $user = $feedback_old['finalized_by_usr_id'];
            $finalized_time = $feedback_old['finalized_tstamp'];
        }
 
        if ($finalized === false) {
            $update_default['finalized_evaluation'] = ['integer', 0];
            $update_default['finalized_by_usr_id'] = ['integer', 0];
            $update_default['finalized_tstamp'] = ['integer', 0];
        } elseif ($finalized === true) {
            $update_default['finalized_evaluation'] = ['integer', 1];
            $update_default['finalized_by_usr_id'] = ['integer', $user];
            $update_default['finalized_tstamp'] = ['integer', $finalized_time];
        }
 
        $this->db->insert('tst_manual_fb', $update_default);
 
        if ($this->logger->isLoggingEnabled()) {
            $this->logger->logScoringInteraction(
                $this->logger->getInteractionFactory()->buildScoringInteraction(
                    $this->getRefId(),
                    $question_id,
                    $this->user->getId(),
                    self::_getUserIdFromActiveId($active_id),
                    TestScoringInteractionTypes::QUESTION_GRADED,
                    [
                        AdditionalInformationGenerator::KEY_EVAL_FINALIZED => $this->logger
                            ->getAdditionalInformationGenerator()->getTrueFalseTagForBool($finalized),
                        AdditionalInformationGenerator::KEY_FEEDBACK => $feedback ? ilRTE::_replaceMediaObjectImageSrc($feedback, 0) : ''
                    ]
                )
            );
        }
    }
 
    public function getJavaScriptOutput(): bool
    {
        return true;
    }
 
    public function &createTestSequence($active_id, $pass, $shuffle)
    {
        $this->test_sequence = new ilTestSequence($active_id, $pass, $this->isRandomTest(), $this->questionrepository);
    }
 
    public function setTestId($a_id)
    {
        $this->test_id = $a_id;
    }
 
    public function getDetailedTestResults($participants): array
    {
        $results = [];
        if (count($participants)) {
            foreach ($participants as $active_id => $user_rec) {
                $row = [];
                $reached_points = 0;
                $max_points = 0;
                $pass = ilObjTest::_getResultPass($active_id);
                foreach ($this->questions as $value) {
                    $question = ilObjTest::_instanciateQuestion($value);
                    if (is_object($question)) {
                        $max_points += $question->getMaximumPoints();
                        $reached_points += $question->getReachedPoints($active_id, $pass);
                        if ($max_points > 0) {
                            $percentvalue = $reached_points / $max_points;
                            if ($percentvalue < 0) {
                                $percentvalue = 0.0;
                            }
                        } else {
                            $percentvalue = 0;
                        }
                        if ($this->getAnonymity()) {
                            $user_rec['firstname'] = "";
                            $user_rec['lastname'] = $this->lng->txt("anonymous");
                        }
                        $results[] = [
                            "user_id" => $user_rec['usr_id'],
                            "matriculation" => $user_rec['matriculation'],
                            "lastname" => $user_rec['lastname'],
                            "firstname" => $user_rec['firstname'],
                            "login" => $user_rec['login'],
                            "question_id" => $question->getId(),
                            "question_title" => $question->getTitle(),
                            "reached_points" => $reached_points,
                            "max_points" => $max_points,
                            "passed" => $user_rec['passed'] ? '1' : '0',
                        ];
                    }
                }
            }
        }
        return $results;
    }
 
    public static function _lookupTestObjIdForQuestionId(int $q_id): ?int
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $result = $ilDB->queryF(
            'SELECT t.obj_fi obj_id FROM tst_test_question q, tst_tests t WHERE q.test_fi = t.test_id AND q.question_fi = %s',
            ['integer'],
            [$q_id]
        );
        $rec = $ilDB->fetchAssoc($result);
        return $rec['obj_id'] ?? null;
    }
 
    public function isPluginActive($a_pname): bool
    {
        if (!$this->component_repository->getComponentByTypeAndName(
            ilComponentInfo::TYPE_COMPONENT,
            'TestQuestionPool'
        )->getPluginSlotById('qst')->hasPluginName($a_pname)) {
            return false;
        }
 
        return $this->component_repository
            ->getComponentByTypeAndName(
                ilComponentInfo::TYPE_COMPONENT,
                'TestQuestionPool'
            )
            ->getPluginSlotById(
                'qst'
            )
            ->getPluginByName(
                $a_pname
            )->isActive();
    }
 
    public function getParticipantsForTestAndQuestion($test_id, $question_id): array
    {
        $query = "
                        SELECT tst_test_result.active_fi, tst_test_result.question_fi, tst_test_result.pass
                        FROM tst_test_result
                        INNER JOIN tst_active ON tst_active.active_id = tst_test_result.active_fi AND tst_active.test_fi = %s
                        INNER JOIN qpl_questions ON qpl_questions.question_id = tst_test_result.question_fi
                        LEFT JOIN usr_data ON usr_data.usr_id = tst_active.user_fi
                        WHERE tst_test_result.question_fi = %s
                        ORDER BY usr_data.lastname ASC, usr_data.firstname ASC
                ";
 
        $result = $this->db->queryF(
            $query,
            ['integer', 'integer'],
            [$test_id, $question_id]
        );
        $foundusers = [];
        while ($row = $this->db->fetchAssoc($result)) {
            if ($this->getAccessFilteredParticipantList() && !$this->getAccessFilteredParticipantList()->isActiveIdInList($row["active_fi"])) {
                continue;
            }
 
            if (!array_key_exists($row["active_fi"], $foundusers)) {
                $foundusers[$row["active_fi"]] = [];
            }
            array_push($foundusers[$row["active_fi"]], ["pass" => $row["pass"], "qid" => $row["question_fi"]]);
        }
        return $foundusers;
    }
 
    public function getAggregatedResultsData(): array
    {
        $data = $this->getCompleteEvaluationData();
        $found_participants = $data->getParticipants();
        $results = ['overview' => [], 'questions' => []];
        if ($found_participants !== []) {
            $results['overview']['tst_stat_result_mark_median'] = $data->getStatistics()->getEvaluationDataOfMedianUser()?->getMark()?->getShortName() ?? '';
            $results['overview']['tst_stat_result_rank_median'] = $data->getStatistics()->rankMedian();
            $results['overview']['tst_stat_result_total_participants'] = $data->getStatistics()->count();
            $results['overview']['tst_stat_result_median'] = $data->getStatistics()->median();
            $results['overview']['tst_eval_total_persons'] = count($found_participants);
            $total_finished = $data->getTotalFinishedParticipants();
            $results['overview']['tst_eval_total_finished'] = $total_finished;
            $results['overview']['tst_eval_total_finished_average_time'] =
                $this->secondsToHoursMinutesSecondsString(
                    $this->evalTotalStartedAverageTime($data->getParticipantIds())
                );
            $total_passed = 0;
            $total_passed_reached = 0;
            $total_passed_max = 0;
            $total_passed_time = 0;
            foreach ($found_participants as $userdata) {
                if ($userdata->getMark()?->getPassed()) {
                    $total_passed++;
                    $total_passed_reached += $userdata->getReached();
                    $total_passed_max += $userdata->getMaxpoints();
                    $total_passed_time += $userdata->getTimeOnTask();
                }
            }
            $average_passed_reached = $total_passed ? $total_passed_reached / $total_passed : 0;
            $average_passed_max = $total_passed ? $total_passed_max / $total_passed : 0;
            $average_passed_time = $total_passed ? $total_passed_time / $total_passed : 0;
            $results['overview']['tst_eval_total_passed'] = $total_passed;
            $results['overview']['tst_eval_total_passed_average_points'] = sprintf('%2.2f', $average_passed_reached)
                . ' ' . strtolower('of') . ' ' . sprintf('%2.2f', $average_passed_max);
            $results['overview']['tst_eval_total_passed_average_time'] =
                $this->secondsToHoursMinutesSecondsString((int) $average_passed_time);
        }
 
        foreach ($data->getQuestionTitles() as $question_id => $question_title) {
            $answered = 0;
            $reached = 0;
            $max = 0;
            foreach ($found_participants as $userdata) {
                for ($i = 0; $i <= $userdata->getLastPass(); $i++) {
                    if (is_object($userdata->getPass($i))) {
                        $question = $userdata->getPass($i)->getAnsweredQuestionByQuestionId($question_id);
                        if (is_array($question)) {
                            $answered++;
                            $reached += $question['reached'];
                            $max += $question['points'];
                        }
                    }
                }
            }
            $percent = $max ? $reached / $max * 100.0 : 0;
            $results['questions'][$question_id] = [
                $question_title,
                sprintf('%.2f', $answered ? $reached / $answered : 0) . ' ' . strtolower($this->lng->txt('of')) . ' ' . sprintf('%.2f', $answered ? $max / $answered : 0),
                sprintf('%.2f', $percent) . '%',
                $answered,
                sprintf('%.2f', $answered ? $reached / $answered : 0),
                sprintf('%.2f', $answered ? $max / $answered : 0),
                $percent / 100.0
            ];
        }
        return $results;
    }
 
    protected function secondsToHoursMinutesSecondsString(int $seconds): string
    {
        $diff_hours = floor($seconds / 3600);
        $seconds -= $diff_hours * 3600;
        $diff_minutes = floor($seconds / 60);
        $seconds -= $diff_minutes * 60;
        return sprintf('%02d:%02d:%02d', $diff_hours, $diff_minutes, $seconds);
    }
 
    public function getXMLZip(): string
    {
        return $this->export_factory->getExporter($this, 'xml')
            ->write();
    }
 
    public function getExportSettings(): int
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getExportSettings();
    }
 
    public function setTemplate(int $template_id)
    {
        $this->template_id = $template_id;
    }
 
    public function getTemplate(): int
    {
        return $this->template_id;
    }
 
    public function reindexFixedQuestionOrdering(): ilTestReindexedSequencePositionMap
    {
        $question_set_config = $this->question_set_config_factory->getQuestionSetConfig();
        $reindexed_sequence_position_map = $question_set_config->reindexQuestionOrdering();
 
        $this->loadQuestions();
 
        return $reindexed_sequence_position_map;
    }
 
    public function setQuestionOrder(array $order)
    {
        asort($order);
 
        $i = 0;
 
        foreach (array_keys($order) as $id) {
            $i++;
 
            $query = "
                                UPDATE          tst_test_question
                                SET                     sequence = %s
                                WHERE           question_fi = %s
                        ";
 
            $this->db->manipulateF(
                $query,
                ['integer', 'integer'],
                [$i, $id]
            );
        }
 
        if ($this->logger->isLoggingEnabled()) {
            $this->logger->logTestAdministrationInteraction(
                $this->logger->getInteractionFactory()->buildTestAdministrationInteraction(
                    $this->getRefId(),
                    $this->user->getId(),
                    TestAdministrationInteractionTypes::QUESTION_MOVED,
                    [
                        AdditionalInformationGenerator::KEY_QUESTION_ORDER => $order
                    ]
                )
            );
        }
 
        $this->loadQuestions();
    }
 
    public function hasQuestionsWithoutQuestionpool(): bool
    {
        $questions = $this->getQuestionTitlesAndIndexes();
 
        $IN_questions = $this->db->in('q1.question_id', array_keys($questions), false, 'integer');
 
        $query = "
                        SELECT          count(q1.question_id) cnt
 
                        FROM            qpl_questions q1
 
                        INNER JOIN      qpl_questions q2
                        ON                      q2.question_id = q1.original_id
 
                        WHERE           $IN_questions
                        AND                     q1.obj_fi = q2.obj_fi
                ";
        $rset = $this->db->query($query);
        $row = $this->db->fetchAssoc($rset);
 
        return $row['cnt'] > 0;
    }
 
    public static function _lookupFinishedUserTests($a_user_id): array
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $result = $ilDB->queryF(
            "SELECT test_fi,MAX(pass) AS pass FROM tst_active" .
            " JOIN tst_pass_result ON (tst_pass_result.active_fi = tst_active.active_id)" .
            " WHERE user_fi=%s" .
            " GROUP BY test_fi",
            ['integer', 'integer'],
            [$a_user_id, 1]
        );
        $all = [];
        while ($row = $ilDB->fetchAssoc($result)) {
            $obj_id = self::_getObjectIDFromTestID($row["test_fi"]);
            $all[$obj_id] = (bool) $row["pass"];
        }
        return $all;
    }
 
    public function getQuestions(): array
    {
        return $this->questions;
    }
 
    public function isOnline(): bool
    {
        return $this->online;
    }
 
    public function getIntroductionPageId(): int
    {
        $page_id = $this->getMainSettings()->getIntroductionSettings()->getIntroductionPageId();
        if ($page_id !== null) {
            return $page_id;
        }
 
        $page_object = new ilTestPage();
        $page_object->setParentId($this->getId());
        $new_page_id = $page_object->createPageWithNextId();
        $settings = $this->getMainSettings()->getIntroductionSettings()
            ->withIntroductionPageId($new_page_id);
        $this->getMainSettingsRepository()->store(
            $this->getMainSettings()->withIntroductionSettings($settings)
        );
        return $new_page_id;
    }
 
    public function getConcludingRemarksPageId(): int
    {
        $page_id = $this->getMainSettings()->getFinishingSettings()->getConcludingRemarksPageId();
        if ($page_id !== null) {
            return $page_id;
        }
 
        $page_object = new ilTestPage();
        $page_object->setParentId($this->getId());
        $new_page_id = $page_object->createPageWithNextId();
        $settings = $this->getMainSettings()->getFinishingSettings()
            ->withConcludingRemarksPageId($new_page_id);
        $this->getMainSettingsRepository()->store(
            $this->getMainSettings()->withFinishingSettings($settings)
        );
        return $new_page_id;
    }
 
    public function getHighscoreEnabled(): bool
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighscoreEnabled();
    }
 
    public function getHighscoreAnon(): bool
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighscoreAnon();
    }
 
    public function isHighscoreAnon(): bool
    {
        return $this->getAnonymity() == 1 || $this->getHighscoreAnon();
    }
 
    public function getHighscoreAchievedTS(): bool
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighscoreAchievedTS();
    }
 
    public function getHighscoreScore(): bool
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighscoreScore();
    }
 
    public function getHighscorePercentage(): bool
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighscorePercentage();
    }
 
    public function getHighscoreWTime(): bool
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighscoreWTime();
    }
 
    public function getHighscoreOwnTable(): bool
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighscoreOwnTable();
    }
 
    public function getHighscoreTopTable(): bool
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighscoreTopTable();
    }
 
    public function getHighscoreTopNum(int $a_retval = 10): int
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighscoreTopNum();
    }
 
    public function getHighscoreMode(): int
    {
        return $this->getScoreSettings()->getGamificationSettings()->getHighScoreMode();
    }
 
    public function getSpecificAnswerFeedback(): bool
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getInstantFeedbackSpecificEnabled();
    }
 
    public function getAutosave(): bool
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getAutosaveEnabled();
    }
 
    public function isPassDeletionAllowed(): bool
    {
        return $this->getScoreSettings()->getResultSummarySettings()->getPassDeletionAllowed();
    }
 
    public function getEnableExamview(): bool
    {
        return $this->getMainSettings()->getFinishingSettings()->getShowAnswerOverview();
    }
 
    public function getStartingTimeOfParticipants(): array
    {
        $times = [];
        $result = $this->db->queryF(
            "SELECT tst_times.active_fi, tst_times.started FROM tst_times, tst_active WHERE tst_times.active_fi = tst_active.active_id AND tst_active.test_fi = %s ORDER BY tst_times.tstamp DESC",
            ['integer'],
            [$this->getTestId()]
        );
        while ($row = $this->db->fetchAssoc($result)) {
            $times[$row['active_fi']] = $row['started'];
        }
        return $times;
    }
 
    public function getTimeExtensionsOfParticipants(): array
    {
        $times = [];
        $result = $this->db->queryF(
            "SELECT tst_addtime.active_fi, tst_addtime.additionaltime FROM tst_addtime, tst_active WHERE tst_addtime.active_fi = tst_active.active_id AND tst_active.test_fi = %s",
            ['integer'],
            [$this->getTestId()]
        );
        while ($row = $this->db->fetchAssoc($result)) {
            $times[$row['active_fi']] = $row['additionaltime'];
        }
        return $times;
    }
 
    private function getExtraTime(int $active_id): int
    {
        if ($active_id === 0) {
            return 0;
        }
        return $this->participant_repository
            ->getParticipantByActiveId($this->getTestId(), $active_id)
            ?->getExtraTime() ?? 0;
    }
 
    public function getMaxPassOfTest(): int
    {
        $query = '
                        SELECT MAX(tst_pass_result.pass) + 1 max_res
                        FROM tst_pass_result
                        INNER JOIN tst_active ON tst_active.active_id = tst_pass_result.active_fi
                        WHERE test_fi = ' . $this->db->quote($this->getTestId(), 'integer') . '
                ';
        $res = $this->db->query($query);
        $data = $this->db->fetchAssoc($res);
        return (int) $data['max_res'];
    }
 
    public static function lookupExamId($active_id, $pass)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $exam_id_query = 'SELECT exam_id FROM tst_pass_result WHERE active_fi = %s AND pass = %s';
        $exam_id_result = $ilDB->queryF($exam_id_query, [ 'integer', 'integer' ], [ $active_id, $pass ]);
        if ($ilDB->numRows($exam_id_result) == 1) {
            $exam_id_row = $ilDB->fetchAssoc($exam_id_result);
 
            if ($exam_id_row['exam_id'] != null) {
                return $exam_id_row['exam_id'];
            }
        }
 
        return null;
    }
 
    public static function buildExamId($active_id, $pass, $test_obj_id = null): string
    {
        global $DIC;
        $ilSetting = $DIC['ilSetting'];
 
        $inst_id = $ilSetting->get('inst_id', null);
 
        if ($test_obj_id === null) {
            $obj_id = self::_getObjectIDFromActiveID($active_id);
        } else {
            $obj_id = $test_obj_id;
        }
 
        $examId = 'I' . $inst_id . '_T' . $obj_id . '_A' . $active_id . '_P' . $pass;
 
        return $examId;
    }
 
    public function isShowExamIdInTestPassEnabled(): bool
    {
        return $this->getMainSettings()->getTestBehaviourSettings()->getExamIdInTestAttemptEnabled();
    }
 
    public function isShowExamIdInTestResultsEnabled(): bool
    {
        return $this->getScoreSettings()->getResultDetailsSettings()->getShowExamIdInTestResults();
    }
 
 
    public function setQuestionSetType(string $question_set_type)
    {
        $this->main_settings = $this->getMainSettings()->withGeneralSettings(
            $this->getMainSettings()->getGeneralSettings()
                ->withQuestionSetType($question_set_type)
        );
    }
 
    public function getQuestionSetType(): string
    {
        return $this->getMainSettings()->getGeneralSettings()->getQuestionSetType();
    }
 
    public function isFixedTest(): bool
    {
        return $this->getQuestionSetType() == self::QUESTION_SET_TYPE_FIXED;
    }
 
    public function isRandomTest(): bool
    {
        return $this->getQuestionSetType() == self::QUESTION_SET_TYPE_RANDOM;
    }
 
    public function getQuestionSetTypeTranslation(ilLanguage $lng, $questionSetType): string
    {
        switch ($questionSetType) {
            case ilObjTest::QUESTION_SET_TYPE_FIXED:
                return $lng->txt('tst_question_set_type_fixed');
 
            case ilObjTest::QUESTION_SET_TYPE_RANDOM:
                return $lng->txt('tst_question_set_type_random');
        }
 
        throw new ilTestException('invalid question set type value given: ' . $questionSetType);
    }
 
    public function participantDataExist(): bool
    {
        if ($this->participantDataExist === null) {
            $this->participantDataExist = (bool) $this->evalTotalPersons();
        }
 
        return $this->participantDataExist;
    }
 
    public function recalculateScores($preserve_manscoring = false)
    {
        $scoring = new TestScoring(
            $this,
            $this->user,
            $this->db,
            $this->test_result_repository
        );
        $scoring->setPreserveManualScores($preserve_manscoring);
        $scoring->recalculateSolutions();
    }
 
    public static function getTestObjIdsWithActiveForUserId($userId): array
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $query = "
                        SELECT obj_fi
                        FROM tst_active
                        INNER JOIN tst_tests
                        ON test_id = test_fi
                        WHERE user_fi = %s
                ";
 
        $res = $ilDB->queryF($query, ['integer'], [$userId]);
 
        $objIds = [];
 
        while ($row = $ilDB->fetchAssoc($res)) {
            $objIds[] = (int) $row['obj_fi'];
        }
 
        return $objIds;
    }
 
    public function isSkillServiceEnabled(): bool
    {
        return $this->getMainSettings()->getAdditionalSettings()->getSkillsServiceEnabled();
    }
 
    public function isSkillServiceToBeConsidered(): bool
    {
        if (!$this->getMainSettings()->getAdditionalSettings()->getSkillsServiceEnabled()) {
            return false;
        }
 
        if (!self::isSkillManagementGloballyActivated()) {
            return false;
        }
 
        return true;
    }
 
    private static $isSkillManagementGloballyActivated = null;
 
    public static function isSkillManagementGloballyActivated(): ?bool
    {
        if (self::$isSkillManagementGloballyActivated === null) {
            $skmgSet = new ilSkillManagementSettings();
 
            self::$isSkillManagementGloballyActivated = $skmgSet->isActivated();
        }
 
        return self::$isSkillManagementGloballyActivated;
    }
 
    public function isShowGradingStatusEnabled(): bool
    {
        return $this->getScoreSettings()->getResultSummarySettings()->getShowGradingStatusEnabled();
    }
 
    public function isShowGradingMarkEnabled(): bool
    {
        return $this->getScoreSettings()->getResultSummarySettings()->getShowGradingMarkEnabled();
    }
 
    public function isFollowupQuestionAnswerFixationEnabled(): bool
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getLockAnswerOnNextQuestionEnabled();
    }
 
    public function isInstantFeedbackAnswerFixationEnabled(): bool
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getLockAnswerOnInstantFeedbackEnabled();
    }
 
    public function isForceInstantFeedbackEnabled(): ?bool
    {
        return $this->getMainSettings()->getQuestionBehaviourSettings()->getForceInstantFeedbackOnNextQuestion();
    }
 
 
    public static function isParticipantsLastPassActive(int $test_ref_id, int $user_id): bool
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $ilUser = $DIC['ilUser'];
 
        $test_obj = ilObjectFactory::getInstanceByRefId($test_ref_id, false);
 
        $active_id = $test_obj->getActiveIdOfUser($user_id);
 
        $test_session_factory = new ilTestSessionFactory($test_obj, $ilDB, $ilUser);
 
        // Added temporarily bugfix smeyer
        $test_session_factory->reset();
 
        $test_sequence_factory = new ilTestSequenceFactory($test_obj, $ilDB, TestDIC::dic()['question.general_properties.repository']);
 
        $test_session = $test_session_factory->getSession($active_id);
        $test_sequence = $test_sequence_factory->getSequenceByActiveIdAndPass($active_id, $test_session->getPass());
        $test_sequence->loadFromDb();
 
        return $test_sequence->hasSequence();
    }
 
    public function adjustTestSequence()
    {
        $query = "
                        SELECT COUNT(test_question_id) cnt
                        FROM tst_test_question
                        WHERE test_fi = %s
                        ORDER BY sequence
                ";
 
        $questRes = $this->db->queryF($query, ['integer'], [$this->getTestId()]);
 
        $row = $this->db->fetchAssoc($questRes);
        $questCount = $row['cnt'];
 
        if ($this->getShuffleQuestions()) {
            $query = "
                                SELECT tseq.*
                                FROM tst_active tac
                                INNER JOIN tst_sequence tseq
                                        ON tseq.active_fi = tac.active_id
                                WHERE tac.test_fi = %s
                        ";
 
            $partRes = $this->db->queryF(
                $query,
                ['integer'],
                [$this->getTestId()]
            );
 
            while ($row = $this->db->fetchAssoc($partRes)) {
                $sequence = @unserialize($row['sequence']);
 
                if (!$sequence) {
                    $sequence = [];
                }
 
                $sequence = array_filter($sequence, function ($value) use ($questCount) {
                    return $value <= $questCount;
                });
 
                $num_seq = count($sequence);
                if ($questCount > $num_seq) {
                    $diff = $questCount - $num_seq;
                    for ($i = 1; $i <= $diff; $i++) {
                        $sequence[$num_seq + $i - 1] = $num_seq + $i;
                    }
                }
 
                $new_sequence = serialize($sequence);
 
                $this->db->update('tst_sequence', [
                    'sequence' => ['clob', $new_sequence]
                ], [
                    'active_fi' => ['integer', $row['active_fi']],
                    'pass' => ['integer', $row['pass']]
                ]);
            }
        } else {
            $new_sequence = serialize($questCount > 0 ? range(1, $questCount) : []);
 
            $query = "
                                SELECT tseq.*
                                FROM tst_active tac
                                INNER JOIN tst_sequence tseq
                                        ON tseq.active_fi = tac.active_id
                                WHERE tac.test_fi = %s
                        ";
 
            $part_rest = $this->db->queryF(
                $query,
                ['integer'],
                [$this->getTestId()]
            );
 
            while ($row = $this->db->fetchAssoc($part_rest)) {
                $this->db->update('tst_sequence', [
                    'sequence' => ['clob', $new_sequence]
                ], [
                    'active_fi' => ['integer', $row['active_fi']],
                    'pass' => ['integer', $row['pass']]
                ]);
            }
        }
    }
 
    protected function getHtmlQuestionContentPurifier(): ilHtmlPurifierInterface
    {
        return ilHtmlPurifierFactory::getInstanceByType('qpl_usersolution');
    }
 
    public function getGeneralQuestionPropertiesRepository(): GeneralQuestionPropertiesRepository
    {
        return $this->questionrepository;
    }
 
    public function getGlobalSettings(): GlobalTestSettings
    {
        return $this->global_settings_repo->getGlobalSettings();
    }
 
    public function getMainSettings(): MainSettings
    {
        if (!$this->main_settings) {
            $this->main_settings = $this->getMainSettingsRepository()
                ->getFor($this->getTestId());
        }
        return $this->main_settings;
    }
 
    public function getMainSettingsRepository(): MainSettingsRepository
    {
        return $this->main_settings_repository;
    }
 
    public function getScoreSettings(): ScoreSettings
    {
        if (!$this->score_settings) {
            $this->score_settings = $this->getScoreSettingsRepository()
                ->getFor($this->getTestId());
        }
        return $this->score_settings;
    }
 
    public function getScoreSettingsRepository(): ScoreSettingsRepository
    {
        return $this->score_settings_repository;
    }
 
    public function addToNewsOnOnline(
        bool $old_online_status,
        bool $new_online_status
    ): void {
        if (!$old_online_status && $new_online_status) {
            $newsItem = new ilNewsItem();
            $newsItem->setContext($this->getId(), 'tst');
            $newsItem->setPriority(NEWS_NOTICE);
            $newsItem->setTitle('new_test_online');
            $newsItem->setContentIsLangVar(true);
            $newsItem->setContent('');
            $newsItem->setUserId($this->user->getId());
            $newsItem->setVisibility(NEWS_USERS);
            $newsItem->create();
            return;
        }
 
        if ($old_online_status && !$new_online_status) {
            ilNewsItem::deleteNewsOfContext($this->getId(), 'tst');
            return;
        }
 
        $newsId = ilNewsItem::getFirstNewsIdForContext($this->getId(), 'tst');
        if (!$new_online_status && $newsId > 0) {
            $newsItem = new ilNewsItem($newsId);
            $newsItem->setTitle('new_test_online');
            $newsItem->setContentIsLangVar(true);
            $newsItem->setContent('');
            $newsItem->update();
        }
    }
 
    public static function _lookupRandomTest(int $obj_id): bool
    {
        return TestDIC::dic()['settings.main.repository']->getFor(
            ilObjTest::_getTestIDFromObjectID($obj_id),
        )->getGeneralSettings()->getQuestionSetType() === self::QUESTION_SET_TYPE_RANDOM;
    }
 
    public function getVisitingTimeOfParticipant(int $active_id): array
    {
        return $this->participant_repository->getFirstAndLastVisitForActiveId($active_id);
    }
}