class.assFileUpload.php

Go to the documentation of this file.

<?php

use ILIAS\FileUpload\Exception\IllegalStateException;

require_once './Modules/Test/classes/inc.AssessmentConstants.php';

class assFileUpload extends assQuestion implements ilObjQuestionScoringAdjustable, ilObjFileHandlingQuestionType
{
    // hey: prevPassSolutions - support reusing selected files
    public const REUSE_FILES_TBL_POSTVAR = 'reusefiles';
    public const DELETE_FILES_TBL_POSTVAR = 'deletefiles';
    // hey.

    protected const HAS_SPECIFIC_FEEDBACK = false;

    protected ?int $maxsize = null;

    protected $allowedextensions;

    private ?string $current_cmd;

    protected $completion_by_submission = false;

    private \ILIAS\FileUpload\FileUpload $file_upload;

    public function __construct(
        $title = "",
        $comment = "",
        $author = "",
        $owner = -1,
        $question = ""
    ) {
        parent::__construct($title, $comment, $author, $owner, $question);
        global $DIC;
        $this->file_upload = $DIC['upload'];
        $this->current_cmd = $DIC['ilCtrl']->getCmd();
    }

    public function isComplete(): bool
    {
        if (
            strlen($this->title)
            && ($this->author)
            && ($this->question)
            && ($this->getMaximumPoints() >= 0)
            && is_numeric($this->getMaximumPoints())) {
            return true;
        }
        return false;
    }

    public function saveToDb($original_id = ""): void
    {
        if ($original_id == '') {
            $this->saveQuestionDataToDb();
        } else {
            $this->saveQuestionDataToDb($original_id);
        }

        $this->saveAdditionalQuestionDataToDb();
        parent::saveToDb();
    }

    public function saveAdditionalQuestionDataToDb()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $ilDB->manipulateF(
            "DELETE FROM " . $this->getAdditionalTableName() . " WHERE question_fi = %s",
            array( "integer" ),
            array( $this->getId() )
        );
        $ilDB->manipulateF(
            "INSERT INTO " . $this->getAdditionalTableName(
            ) . " (question_fi, maxsize, allowedextensions, compl_by_submission) VALUES (%s, %s, %s, %s)",
            array( "integer", "float", "text", "integer" ),
            array(
                                $this->getId(),
                                $this->getMaxSize(),
                                (strlen($this->getAllowedExtensions())) ? $this->getAllowedExtensions() : null,
                                (int) $this->isCompletionBySubmissionEnabled()
                            )
        );
    }

    public function loadFromDb($question_id): void
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $result = $ilDB->queryF(
            "SELECT qpl_questions.*, " . $this->getAdditionalTableName() . ".* FROM qpl_questions LEFT JOIN " . $this->getAdditionalTableName() . " ON " . $this->getAdditionalTableName() . ".question_fi = qpl_questions.question_id WHERE qpl_questions.question_id = %s",
            array("integer"),
            array($question_id)
        );
        if ($result->numRows() == 1) {
            $data = $ilDB->fetchAssoc($result);
            $this->setId($question_id);
            $this->setTitle((string) $data["title"]);
            $this->setComment((string) $data["description"]);
            $this->setNrOfTries($data['nr_of_tries']);
            $this->setOriginalId($data["original_id"]);
            $this->setObjId($data["obj_fi"]);
            $this->setAuthor($data["author"]);
            $this->setOwner($data["owner"]);
            $this->setPoints($data["points"]);

            $this->setQuestion(ilRTE::_replaceMediaObjectImageSrc((string) $data["question_text"], 1));
            $this->setMaxSize(($data["maxsize"] ?? null) ? (int) $data["maxsize"] : null);
            $this->setAllowedExtensions($data["allowedextensions"]);
            $this->setCompletionBySubmission($data['compl_by_submission'] == 1 ? true : false);

            try {
                $this->setLifecycle(ilAssQuestionLifecycle::getInstance($data['lifecycle']));
            } catch (ilTestQuestionPoolInvalidArgumentException $e) {
                $this->setLifecycle(ilAssQuestionLifecycle::getDraftInstance());
            }

            try {
                $this->setAdditionalContentEditingMode($data['add_cont_edit_mode']);
            } catch (ilTestQuestionPoolException $e) {
            }
        }
        parent::loadFromDb($question_id);
    }

    public function duplicate(bool $for_test = true, string $title = "", string $author = "", string $owner = "", $testObjId = null): int
    {
        if ($this->id <= 0) {
            // The question has not been saved. It cannot be duplicated
            return -1;
        }
        // duplicate the question in database
        $this_id = $this->getId();
        $thisObjId = $this->getObjId();

        $clone = $this;
        $original_id = assQuestion::_getOriginalId($this->id);
        $clone->id = -1;

        if ((int) $testObjId > 0) {
            $clone->setObjId($testObjId);
        }

        if ($title) {
            $clone->setTitle($title);
        }

        if ($author) {
            $clone->setAuthor($author);
        }
        if ($owner) {
            $clone->setOwner($owner);
        }

        if ($for_test) {
            $clone->saveToDb($original_id);
        } else {
            $clone->saveToDb();
        }

        // copy question page content
        $clone->copyPageOfQuestion($this_id);
        // copy XHTML media objects
        $clone->copyXHTMLMediaObjectsOfQuestion($this_id);

        $clone->onDuplicate($thisObjId, $this_id, $clone->getObjId(), $clone->getId());

        return $clone->id;
    }

    public function copyObject($target_questionpool_id, $title = ""): int
    {
        if ($this->getId() <= 0) {
            throw new RuntimeException('The question has not been saved. It cannot be duplicated');
        }
        // duplicate the question in database
        $clone = $this;
        $original_id = assQuestion::_getOriginalId($this->id);
        $clone->id = -1;
        $source_questionpool_id = $this->getObjId();
        $clone->setObjId($target_questionpool_id);
        if ($title) {
            $clone->setTitle($title);
        }
        $clone->saveToDb();

        // copy question page content
        $clone->copyPageOfQuestion($original_id);
        // copy XHTML media objects
        $clone->copyXHTMLMediaObjectsOfQuestion($original_id);

        $clone->onCopy($source_questionpool_id, $original_id, $clone->getObjId(), $clone->getId());

        return $clone->id;
    }

    public function createNewOriginalFromThisDuplicate($targetParentId, $targetQuestionTitle = ""): int
    {
        if ($this->getId() <= 0) {
            throw new RuntimeException('The question has not been saved. It cannot be duplicated');
        }

        $sourceQuestionId = $this->id;
        $sourceParentId = $this->getObjId();

        // duplicate the question in database
        $clone = $this;
        $clone->id = -1;

        $clone->setObjId($targetParentId);

        if ($targetQuestionTitle) {
            $clone->setTitle($targetQuestionTitle);
        }

        $clone->saveToDb();
        // copy question page content
        $clone->copyPageOfQuestion($sourceQuestionId);
        // copy XHTML media objects
        $clone->copyXHTMLMediaObjectsOfQuestion($sourceQuestionId);

        $clone->onCopy($sourceParentId, $sourceQuestionId, $clone->getObjId(), $clone->getId());

        return $clone->id;
    }

    public function getMaximumPoints(): float
    {
        return $this->getPoints();
    }

    public function calculateReachedPoints($active_id, $pass = null, $authorizedSolution = true, $returndetails = false)
    {
        if ($returndetails) {
            throw new ilTestException('return details not implemented for ' . __METHOD__);
        }

        if ($this->isCompletionBySubmissionEnabled()) {
            if (is_null($pass)) {
                $pass = $this->getSolutionMaxPass($active_id);
            }

            global $DIC;

            $result = $this->getCurrentSolutionResultSet($active_id, $pass, $authorizedSolution);

            while ($data = $DIC->database()->fetchAssoc($result)) {
                if ($this->isDummySolutionRecord($data)) {
                    continue;
                }

                return $this->getPoints();
            }
        }

        return 0;
    }

    protected function calculateReachedPointsForSolution($userSolution)
    {
        if ($this->isCompletionBySubmissionEnabled() &&
            is_array($userSolution) &&
            count($userSolution)) {
            return $this->getPoints();
        }

        return 0;
    }

    public function checkUpload(): bool
    {
        $this->lng->loadLanguageModule("form");
        // remove trailing '/'
        $_FILES["upload"]["name"] = rtrim($_FILES["upload"]["name"], '/');

        $filename = $_FILES["upload"]["name"];
        $filename_arr = pathinfo($_FILES["upload"]["name"]);
        $suffix = $filename_arr["extension"] ?? '';
        $mimetype = $_FILES["upload"]["type"];
        $size_bytes = $_FILES["upload"]["size"];
        $temp_name = $_FILES["upload"]["tmp_name"];
        $error = $_FILES["upload"]["error"];

        if ($size_bytes > $this->getMaxFilesizeInBytes()) {
            $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_size_exceeds"), true);
            return false;
        }

        // error handling
        if ($error > 0) {
            switch ($error) {
                case UPLOAD_ERR_FORM_SIZE:
                case UPLOAD_ERR_INI_SIZE:
                    $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_size_exceeds"), true);
                    return false;
                    break;

                case UPLOAD_ERR_PARTIAL:
                    $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_partially_uploaded"), true);
                    return false;
                    break;

                case UPLOAD_ERR_NO_FILE:
                    $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_no_upload"), true);
                    return false;
                    break;

                case UPLOAD_ERR_NO_TMP_DIR:
                    $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_missing_tmp_dir"), true);
                    return false;
                    break;

                case UPLOAD_ERR_CANT_WRITE:
                    $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_cannot_write_to_disk"), true);
                    return false;
                    break;

                case UPLOAD_ERR_EXTENSION:
                    $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_upload_stopped_ext"), true);
                    return false;
                    break;
            }
        }

        // check suffixes
        if (count($this->getAllowedExtensionsArray())) {
            if (!strlen($suffix)) {
                $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_missing_file_ext"), true);
                return false;
            }

            if (!in_array(strtolower($suffix), $this->getAllowedExtensionsArray())) {
                $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_wrong_file_type"), true);
                return false;
            }
        }

        // virus handling
        if (strlen($temp_name)) {
            $vir = ilVirusScanner::virusHandling($temp_name, $filename);
            if ($vir[0] == false) {
                $this->tpl->setOnScreenMessage('failure', $this->lng->txt("form_msg_file_virus_found") . "<br />" . $vir[1], true);
                return false;
            }
        }
        return true;
    }

    public function getFileUploadPath($test_id, $active_id, $question_id = null): string
    {
        if (is_null($question_id)) {
            $question_id = $this->getId();
        }
        return CLIENT_WEB_DIR . "/assessment/tst_$test_id/$active_id/$question_id/files/";
    }

    protected function getPreviewFileUploadPath($userId): string
    {
        return CLIENT_WEB_DIR . "/assessment/qst_preview/$userId/{$this->getId()}/fileuploads/";
    }

    public function getFileUploadPathWeb($test_id, $active_id, $question_id = null)
    {
        if (is_null($question_id)) {
            $question_id = $this->getId();
        }
        $webdir = ilFileUtils::removeTrailingPathSeparators(CLIENT_WEB_DIR) . "/assessment/tst_$test_id/$active_id/$question_id/files/";
        return str_replace(
            ilFileUtils::removeTrailingPathSeparators(ILIAS_ABSOLUTE_PATH),
            ilFileUtils::removeTrailingPathSeparators(ILIAS_HTTP_PATH),
            $webdir
        );
    }

    protected function getPreviewFileUploadPathWeb($userId)
    {
        $webdir = ilFileUtils::removeTrailingPathSeparators(CLIENT_WEB_DIR) . "/assessment/qst_preview/$userId/{$this->getId()}/fileuploads/";
        return str_replace(
            ilFileUtils::removeTrailingPathSeparators(ILIAS_ABSOLUTE_PATH),
            ilFileUtils::removeTrailingPathSeparators(ILIAS_HTTP_PATH),
            $webdir
        );
    }

    public function getUploadedFiles($active_id, $pass = null, $authorized = true): array
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];

        if (is_null($pass)) {
            $pass = $this->getSolutionMaxPass($active_id);
        }
        // fau: testNav - check existing value1 because the intermediate solution will have a dummy entry
        $result = $ilDB->queryF(
            "SELECT * FROM tst_solutions WHERE active_fi = %s AND question_fi = %s AND pass = %s AND authorized = %s AND value1 IS NOT NULL ORDER BY tstamp",
            array("integer", "integer", "integer", 'integer'),
            array($active_id, $this->getId(), $pass, (int) $authorized)
        );
        // fau.
        $found = array();

        while ($data = $ilDB->fetchAssoc($result)) {
            array_push($found, $data);
        }

        return $found;
    }

    public function getPreviewFileUploads(ilAssQuestionPreviewSession $previewSession): array
    {
        if ($previewSession->getParticipantsSolution() === false || $previewSession->getParticipantsSolution() === null) {
            return [];
        }

        return $previewSession->getParticipantsSolution();
    }

    public function getUploadedFilesForWeb($active_id, $pass): array
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];

        $found = $this->getUploadedFiles($active_id, $pass);
        $result = $ilDB->queryF(
            "SELECT test_fi FROM tst_active WHERE active_id = %s",
            array('integer'),
            array($active_id)
        );
        if ($result->numRows() == 1) {
            $row = $ilDB->fetchAssoc($result);
            $test_id = $row["test_fi"];
            $path = $this->getFileUploadPathWeb($test_id, $active_id);
            foreach ($found as $idx => $data) {
                $found[$idx]['webpath'] = $path;
            }
        }
        return $found;
    }

    protected function deleteUploadedFiles($files, $test_id, $active_id, $authorized): void
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];

        $pass = null;
        $active_id = null;
        foreach ($files as $solution_id) {
            $result = $ilDB->queryF(
                "SELECT * FROM tst_solutions WHERE solution_id = %s AND authorized = %s",
                array("integer", 'integer'),
                array($solution_id, (int) $authorized)
            );
            if ($result->numRows() == 1) {
                $data = $ilDB->fetchAssoc($result);
                $pass = $data['pass'];
                $active_id = $data['active_fi'];
                @unlink($this->getFileUploadPath($test_id, $active_id) . $data['value1']);
            }
        }
        foreach ($files as $solution_id) {
            $affectedRows = $ilDB->manipulateF(
                "DELETE FROM tst_solutions WHERE solution_id = %s AND authorized = %s",
                array("integer", 'integer'),
                array($solution_id, $authorized)
            );
        }
    }

    // fau: testNav new function deleteUnusedFiles()
    protected function deleteUnusedFiles($test_id, $active_id, $pass): void
    {
        // read all solutions (authorized and intermediate) from all steps
        $step = $this->getStep();
        $this->setStep(null);
        $solutions = array_merge(
            $this->getSolutionValues($active_id, $pass, true),
            $this->getSolutionValues($active_id, $pass, false)
        );
        $this->setStep($step);

        // get the used files from these solutions
        $used_files = array();
        foreach ($solutions as $solution) {
            $used_files[] = $solution['value1'];
        }

        // read the existing files for user and pass
        // delete all files that are not used in the solutions
        $uploadPath = $this->getFileUploadPath($test_id, $active_id);
        if (is_dir($uploadPath) && is_readable($uploadPath)) {
            $iter = new \RegexIterator(new \DirectoryIterator($uploadPath), '/^file_' . $active_id . '_' . $pass . '_(.*)/');
            foreach ($iter as $file) {
                if ($file->isFile() && !in_array($file->getFilename(), $used_files)) {
                    unlink($file->getPathname());
                }
            }
        }
    }
    // fau.

    protected function deletePreviewFileUploads($userId, $userSolution, $files)
    {
        foreach ($files as $name) {
            if (isset($userSolution[$name])) {
                unset($userSolution[$name]);
                @unlink($this->getPreviewFileUploadPath($userId) . $name);
            }
        }

        return $userSolution;
    }

    public function getMaxFilesizeAsString(): string
    {
        $size = $this->getMaxFilesizeInBytes();
        if ($size < 1024) {
            $max_filesize = sprintf("%d Bytes", $size);
        } elseif ($size < 1024 * 1024) {
            $max_filesize = sprintf("%.1f KB", $size / 1024);
        } else {
            $max_filesize = sprintf("%.1f MB", $size / 1024 / 1024);
        }

        return $max_filesize;
    }

    public function getMaxFilesizeInBytes(): int
    {
        if ($this->getMaxSize() > 0) {
            return $this->getMaxSize();
        }

        // get the value for the maximal uploadable filesize from the php.ini (if available)
        $umf = get_cfg_var("upload_max_filesize");
        // get the value for the maximal post data from the php.ini (if available)
        $pms = get_cfg_var("post_max_size");

        //convert from short-string representation to "real" bytes
        $multiplier_a = array("K" => 1024, "M" => 1024 * 1024, "G" => 1024 * 1024 * 1024);

        $umf_parts = preg_split("/(\d+)([K|G|M])/", $umf, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
        $pms_parts = preg_split("/(\d+)([K|G|M])/", $pms, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);

        if (count($umf_parts) === 2) {
            $umf = $umf_parts[0] * $multiplier_a[$umf_parts[1]];
        }
        if (count($pms_parts) === 2) {
            $pms = $pms_parts[0] * $multiplier_a[$pms_parts[1]];
        }

        // use the smaller one as limit
        $max_filesize = min($umf, $pms);

        if (!$max_filesize) {
            $max_filesize = max($umf, $pms);
        }

        return (int) $max_filesize;
    }

    public function saveWorkingData($active_id, $pass = null, $authorized = true): bool
    {
        $pass = $this->ensureCurrentTestPass($active_id, $pass);
        $test_id = $this->lookupTestId($active_id);

        try {
            $upload_handling_required = $this->current_cmd !== 'submitSolution'
                && $this->current_cmd !== 'showInstantResponse'
                && !$this->isFileDeletionAction()
                && $this->isFileUploadAvailable()
                && $this->checkUpload();
        } catch (IllegalStateException $e) {
            $this->tpl->setOnScreenMessage('failure', $e->getMessage(), true);
            return false;
        }
        $upload_file_data = [];

        if ($upload_handling_required) {
            if (!@file_exists($this->getFileUploadPath($test_id, $active_id))) {
                ilFileUtils::makeDirParents($this->getFileUploadPath($test_id, $active_id));
            }

            $upload_file_data ['solution_file_versioning_upload_ts'] = time();
            $filename_arr = pathinfo($_FILES["upload"]["name"]);
            $extension = $filename_arr["extension"];
            $new_file_name = "file_" . $active_id . "_" . $pass . "_" . $upload_file_data ['solution_file_versioning_upload_ts'] . "." . $extension;
            $upload_file_data['new_file_name'] = ilFileUtils::getValidFilename($new_file_name);

            try {
                ilFileUtils::moveUploadedFile(
                    $_FILES["upload"]["tmp_name"],
                    $_FILES["upload"]["name"],
                    $this->getFileUploadPath($test_id, $active_id) . $upload_file_data['new_file_name']
                );
            } catch (ilException $e) {
                $this->tpl->setOnScreenMessage('failure', $e->getMessage(), true);
                return false;
            }
        }

        $entered_values = false;

        $this->getProcessLocker()->executeUserSolutionUpdateLockOperation(function () use (&$entered_values, $upload_handling_required, $upload_file_data, $test_id, $active_id, $pass, $authorized) {
            if ($authorized == false) {
                $this->forceExistingIntermediateSolution($active_id, $pass, true);
            }

            if ($this->isFileDeletionAction()) {
                if ($this->isFileDeletionSubmitAvailable()) {
                    foreach ($_POST[self::DELETE_FILES_TBL_POSTVAR] as $solution_id) {
                        $this->removeSolutionRecordById($solution_id);
                    }
                } else {
                    $this->tpl->setOnScreenMessage('info', $this->lng->txt('no_checkbox'), true);
                }
            } else {
                if ($this->isFileReuseHandlingRequired()) {
                    foreach ($_POST[self::REUSE_FILES_TBL_POSTVAR] as $solutionId) {
                        $solution = $this->getSolutionRecordById($solutionId);

                        $this->saveCurrentSolution(
                            $active_id,
                            $pass,
                            $solution['value1'],
                            $solution['value2'],
                            false,
                            $solution['tstamp']
                        );
                    }
                }

                if ($upload_handling_required) {
                    $dispoFilename = ilFileUtils::getValidFilename($_FILES['upload']['name']);

                    $this->saveCurrentSolution(
                        $active_id,
                        $pass,
                        $upload_file_data['new_file_name'],
                        $dispoFilename,
                        false,
                        $upload_file_data ['solution_file_versioning_upload_ts']
                    );

                    $entered_values = true;
                }
            }

            if ($authorized == true && $this->intermediateSolutionExists($active_id, $pass)) {
                // remove the dummy record of the intermediate solution
                $this->deleteDummySolutionRecord($active_id, $pass);

                // delete the authorized solution and make the intermediate solution authorized (keeping timestamps)
                $this->removeCurrentSolution($active_id, $pass, true);
                $this->updateCurrentSolutionsAuthorization($active_id, $pass, true, true);
            }

            $this->deleteUnusedFiles($test_id, $active_id, $pass);
        });

        if ($entered_values) {
            if (ilObjAssessmentFolder::_enabledAssessmentLogging()) {
                assQuestion::logAction($this->lng->txtlng(
                    "assessment",
                    "log_user_entered_values",
                    ilObjAssessmentFolder::_getLogLanguage()
                ), $active_id, $this->getId());
            }
        } else {
            if (ilObjAssessmentFolder::_enabledAssessmentLogging()) {
                assQuestion::logAction($this->lng->txtlng(
                    "assessment",
                    "log_user_not_entered_values",
                    ilObjAssessmentFolder::_getLogLanguage()
                ), $active_id, $this->getId());
            }
        }

        return true;
    }

    public function getUserSolutionPreferingIntermediate($active_id, $pass = null): array
    {
        $solution = $this->getSolutionValues($active_id, $pass, false);

        if (!count($solution)) {
            $solution = $this->getSolutionValues($active_id, $pass, true);
        } else {
            $cleaned = array();
            foreach ($solution as $row) {
                if (!empty($row['value1'])) {
                    $cleaned[] = $row;
                }
            }
            $solution = $cleaned;
        }

        return $solution;
    }
    // fau.

    public function removeIntermediateSolution(int $active_id, int $pass): void
    {
        parent::removeIntermediateSolution($active_id, $pass);

        $test_id = $this->lookupTestId($active_id);
        if ($test_id !== -1) {
            $this->deleteUnusedFiles($test_id, $active_id, $pass);
        }
    }


    protected function savePreviewData(ilAssQuestionPreviewSession $previewSession): void
    {
        $userSolution = $previewSession->getParticipantsSolution();

        if (!is_array($userSolution)) {
            $userSolution = array();
        }

        // hey: prevPassSolutions - readability spree - get a chance to understand the code
        if ($this->isFileDeletionAction()) {
            // hey.
            // hey: prevPassSolutions - readability spree - get a chance to understand the code
            if ($this->isFileDeletionSubmitAvailable()) {
                // hey.
                $userSolution = $this->deletePreviewFileUploads($previewSession->getUserId(), $userSolution, $_POST['deletefiles']);
            } else {
                $this->tpl->setOnScreenMessage('info', $this->lng->txt('no_checkbox'), true);
            }
        } else {
            try {
                $fileUploadAvailable = $this->current_cmd !== 'instantResponse'
                    && $this->isFileUploadAvailable();
            } catch (IllegalStateException $e) {
                $this->tpl->setOnScreenMessage('failure', $e->getMessage(), true);
                return;
            }
            // hey: prevPassSolutions - readability spree - get a chance to understand the code
            if ($fileUploadAvailable) {
                // hey.
                if ($this->checkUpload()) {
                    if (!@file_exists($this->getPreviewFileUploadPath($previewSession->getUserId()))) {
                        ilFileUtils::makeDirParents($this->getPreviewFileUploadPath($previewSession->getUserId()));
                    }

                    $version = time();
                    $filename_arr = pathinfo($_FILES["upload"]["name"]);
                    $extension = $filename_arr["extension"];
                    $newfile = "file_" . md5($_FILES["upload"]["name"]) . "_" . $version . "." . $extension;
                    try {
                        ilFileUtils::moveUploadedFile(
                            $_FILES["upload"]["tmp_name"],
                            $_FILES["upload"]["name"],
                            $this->getPreviewFileUploadPath($previewSession->getUserId()) . $newfile
                        );
                    } catch (ilException $e) {
                        $this->tpl->setOnScreenMessage('failure', $e->getMessage(), true);
                        return;
                    }


                    $userSolution[$newfile] = array(
                        'solution_id' => $newfile,
                        'value1' => $newfile,
                        'value2' => $_FILES['upload']['name'],
                        'tstamp' => $version,
                        'webpath' => $this->getPreviewFileUploadPathWeb($previewSession->getUserId())
                    );
                }
            }
        }

        $previewSession->setParticipantsSolution($userSolution);
    }

    protected function handleSubmission($active_id, $pass, $obligationsAnswered, $authorized): void
    {
        if (!$authorized) {
            return;
        }

        if ($this->isCompletionBySubmissionEnabled()) {
            $maxpoints = assQuestion::_getMaximumPoints($this->getId());

            if ($this->getUploadedFiles($active_id, $pass, $authorized)) {
                $points = $maxpoints;
            } else {
                // fau: testNav - don't set reached points if no file is available
                return;
                // fau.
            }

            assQuestion::_setReachedPoints($active_id, $this->getId(), $points, $maxpoints, $pass, true, $obligationsAnswered);

            ilLPStatusWrapper::_updateStatus(
                ilObjTest::_getObjectIDFromActiveID((int) $active_id),
                ilObjTestAccess::_getParticipantId((int) $active_id)
            );
        }
    }

    public function getQuestionType(): string
    {
        return "assFileUpload";
    }

    public function getAdditionalTableName(): string
    {
        return "qpl_qst_fileupload";
    }

    public function getAnswerTableName(): string
    {
        return "";
    }

    public function deleteAnswers($question_id): void
    {
    }

    public function getRTETextWithMediaObjects(): string
    {
        $text = parent::getRTETextWithMediaObjects();
        return $text;
    }

    public function setExportDetailsXLS(ilAssExcelFormatHelper $worksheet, int $startrow, int $active_id, int $pass): int
    {
        parent::setExportDetailsXLS($worksheet, $startrow, $active_id, $pass);

        $i = 1;
        $solutions = $this->getSolutionValues($active_id, $pass);
        foreach ($solutions as $solution) {
            $worksheet->setCell($startrow + $i, 0, $this->lng->txt("result"));
            $worksheet->setBold($worksheet->getColumnCoord(0) . ($startrow + $i));
            if (strlen($solution["value1"])) {
                $worksheet->setCell($startrow + $i, 2, $solution["value1"]);
                $worksheet->setCell($startrow + $i, 3, $solution["value2"]);
            }
            $i++;
        }

        return $startrow + $i + 1;
    }

    public function fromXML($item, int $questionpool_id, ?int $tst_id, &$tst_object, int &$question_counter, array $import_mapping, array &$solutionhints = []): array
    {
        $import = new assFileUploadImport($this);
        return $import->fromXML($item, $questionpool_id, $tst_id, $tst_object, $question_counter, $import_mapping);
    }

    public function toXML($a_include_header = true, $a_include_binary = true, $a_shuffle = false, $test_output = false, $force_image_references = false): string
    {
        $export = new assFileUploadExport($this);
        return $export->toXML($a_include_header, $a_include_binary, $a_shuffle, $test_output, $force_image_references);
    }

    public function getBestSolution($active_id, $pass): array
    {
        $user_solution = array();
        return $user_solution;
    }

    public function getMaxSize(): ?int
    {
        return $this->maxsize;
    }

    public function setMaxSize(?int $a_value): void
    {
        $this->maxsize = $a_value;
    }

    public function getAllowedExtensionsArray(): array
    {
        if (strlen($this->allowedextensions)) {
            return array_filter(array_map('trim', explode(",", $this->allowedextensions)));
        }
        return array();
    }

    public function getAllowedExtensions(): string
    {
        return $this->allowedextensions;
    }

    public function setAllowedExtensions($a_value): void
    {
        $this->allowedextensions = strtolower(trim($a_value));
    }

    public function hasFileUploads($test_id): bool
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $query = "
                SELECT tst_solutions.solution_id
                FROM tst_solutions, tst_active, qpl_questions
                WHERE tst_solutions.active_fi = tst_active.active_id
                AND tst_solutions.question_fi = qpl_questions.question_id
                AND tst_solutions.question_fi = %s AND tst_active.test_fi = %s
                AND tst_solutions.value1 is not null";
        $result = $ilDB->queryF(
            $query,
            array("integer", "integer"),
            array($this->getId(), $test_id)
        );
        if ($result->numRows() > 0) {
            return true;
        } else {
            return false;
        }
    }

    public function deliverFileUploadZIPFile($ref_id, $test_id, $test_title): void
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $lng = $DIC['lng'];

        $exporter = new ilAssFileUploadUploadsExporter($ilDB, $lng);

        $exporter->setRefId($ref_id);
        $exporter->setTestId($test_id);
        $exporter->setTestTitle($test_title);
        $exporter->setQuestion($this);

        $exporter->build();

        ilFileDelivery::deliverFileLegacy(
            $exporter->getFinalZipFilePath(),
            $exporter->getDispoZipFileName(),
            $exporter->getZipFileMimeType(),
            false,
            true
        );
    }

    public function isCompletionBySubmissionEnabled(): bool
    {
        return $this->completion_by_submission;
    }

    public function setCompletionBySubmission($bool): assFileUpload
    {
        $this->completion_by_submission = (bool) $bool;
        return $this;
    }

    public function isAnswered(int $active_id, int $pass): bool
    {
        $numExistingSolutionRecords = assQuestion::getNumExistingSolutionRecords($active_id, $pass, $this->getId());

        return $numExistingSolutionRecords > 0;
    }

    public static function isObligationPossible(int $questionId): bool
    {
        return true;
    }

    public function isAutosaveable(): bool
    {
        return false;
    }

    public function buildTestPresentationConfig(): ilTestQuestionConfig
    {
        return parent::buildTestPresentationConfig()
            ->setFormChangeDetectionEnabled(false);
    }

    protected function isFileDeletionAction(): bool
    {
        return $this->getQuestionAction() == ilAssFileUploadFileTableDeleteButton::ACTION;
    }

    protected function isFileDeletionSubmitAvailable(): bool
    {
        return $this->isNonEmptyItemListPostSubmission(self::DELETE_FILES_TBL_POSTVAR);
    }

    protected function isFileReuseSubmitAvailable(): bool
    {
        return $this->isNonEmptyItemListPostSubmission(self::REUSE_FILES_TBL_POSTVAR);
    }

    protected function isFileReuseHandlingRequired(): bool
    {
        if (!$this->getTestPresentationConfig()->isPreviousPassSolutionReuseAllowed()) {
            return false;
        }

        if (!$this->isFileReuseSubmitAvailable()) {
            return false;
        }

        return true;
    }

    protected function isFileUploadAvailable(): bool
    {
        if (!$this->file_upload->hasUploads()) {
            return false;
        }

        if (!$this->file_upload->hasBeenProcessed()) {
            $this->file_upload->process();
        }

        return true;
    }
}