class.assFileUpload.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
require_once './Modules/TestQuestionPool/classes/class.assQuestion.php';
require_once './Modules/Test/classes/inc.AssessmentConstants.php';
require_once './Modules/TestQuestionPool/interfaces/interface.ilObjQuestionScoringAdjustable.php';
require_once './Modules/TestQuestionPool/interfaces/interface.ilObjFileHandlingQuestionType.php';
 
class assFileUpload extends assQuestion implements ilObjQuestionScoringAdjustable, ilObjFileHandlingQuestionType
{
        // hey: prevPassSolutions - support reusing selected files
        const REUSE_FILES_TBL_POSTVAR = 'reusefiles';
        const DELETE_FILES_TBL_POSTVAR = 'deletefiles';
        // hey.
        
        protected $maxsize;
        
        protected $allowedextensions;
        
        protected $completion_by_submission = false;
        
        function __construct(
                $title = "",
                $comment = "",
                $author = "",
                $owner = -1,
                $question = ""
        )
        {
                parent::__construct($title, $comment, $author, $owner, $question);
        }
        
        public function isComplete()
        {
                if (
                        strlen($this->title) 
                        && ($this->author) 
                        && ($this->question) 
                        && ($this->getMaximumPoints() >= 0) 
                        && is_numeric($this->getMaximumPoints()))
                {
                        return true;
                }
                return false;
        }
 
        public function saveToDb($original_id = "")
        {
                $this->saveQuestionDataToDb($original_id);
                $this->saveAdditionalQuestionDataToDb();
                parent::saveToDb();
        }
 
        public function saveAdditionalQuestionDataToDb()
        {
                global $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(),
                                                                (strlen( $this->getMaxSize() )) ? $this->getMaxSize() : NULL,
                                                                (strlen( $this->getAllowedExtensions() )) ? $this->getAllowedExtensions() : NULL,
                                                                (int)$this->isCompletionBySubmissionEnabled()
                                                        )
                );
        }
 
        public function loadFromDb($question_id)
        {
                global $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($data["title"]);
                        $this->setComment($data["description"]);
                        $this->setNrOfTries($data['nr_of_tries']);
                        $this->setSuggestedSolution($data["solution_hint"]);
                        $this->setOriginalId($data["original_id"]);
                        $this->setObjId($data["obj_fi"]);
                        $this->setAuthor($data["author"]);
                        $this->setOwner($data["owner"]);
                        $this->setPoints($data["points"]);                      
 
                        include_once("./Services/RTE/classes/class.ilRTE.php");
                        $this->setQuestion(ilRTE::_replaceMediaObjectImageSrc($data["question_text"], 1));
                        $this->setEstimatedWorkingTime(substr($data["working_time"], 0, 2), substr($data["working_time"], 3, 2), substr($data["working_time"], 6, 2));
                        $this->setMaxSize($data["maxsize"]);
                        $this->setAllowedExtensions($data["allowedextensions"]);
                        $this->setCompletionBySubmission($data['compl_by_submission'] == 1 ? true : false);
                        
                        try
                        {
                                $this->setAdditionalContentEditingMode($data['add_cont_edit_mode']);
                        }
                        catch(ilTestQuestionPoolException $e)
                        {
                        }
                }
                parent::loadFromDb($question_id);
        }
 
        public function duplicate($for_test = true, $title = "", $author = "", $owner = "", $testObjId = null)
        {
                if ($this->id <= 0)
                {
                        // The question has not been saved. It cannot be duplicated
                        return;
                }
                // duplicate the question in database
                $this_id = $this->getId();
                $thisObjId = $this->getObjId();
                
                $clone = $this;
                include_once ("./Modules/TestQuestionPool/classes/class.assQuestion.php");
                $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 = "")
        {
                if ($this->id <= 0)
                {
                        // The question has not been saved. It cannot be duplicated
                        return;
                }
                // duplicate the question in database
                $clone = $this;
                include_once ("./Modules/TestQuestionPool/classes/class.assQuestion.php");
                $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 = "")
        {
                if ($this->id <= 0)
                {
                        // The question has not been saved. It cannot be duplicated
                        return;
                }
 
                include_once ("./Modules/TestQuestionPool/classes/class.assQuestion.php");
 
                $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()
        {
                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__);
                }
                
                global $ilDB;
                
                if (is_null($pass))
                {
                        $pass = $this->getSolutionMaxPass($active_id);
                }
                $points = 0;
                return $points;
        }
 
        protected function calculateReachedPointsForSolution($userSolution)
        {
                if( $this->isCompletionBySubmissionEnabled() && count($userSolution) )
                {
                        return $this->getPoints();
                }
                
                return 0;
        }
        
        function checkUpload()
        {
                $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())
                {
                        ilUtil::sendFailure($this->lng->txt("form_msg_file_size_exceeds"), true);
                        return false;
                }
 
                // error handling
                if ($error > 0)
                {
                        switch ($error)
                        {
                                case UPLOAD_ERR_INI_SIZE:
                                        ilUtil::sendFailure($this->lng->txt("form_msg_file_size_exceeds"), true);
                                        return false;
                                        break;
                                         
                                case UPLOAD_ERR_FORM_SIZE:
                                        ilUtil::sendFailure($this->lng->txt("form_msg_file_size_exceeds"), true);
                                        return false;
                                        break;
        
                                case UPLOAD_ERR_PARTIAL:
                                        ilUtil::sendFailure($this->lng->txt("form_msg_file_partially_uploaded"), true);
                                        return false;
                                        break;
        
                                case UPLOAD_ERR_NO_FILE:
                                        ilUtil::sendFailure($this->lng->txt("form_msg_file_no_upload"), true);
                                        return false;
                                        break;
         
                                case UPLOAD_ERR_NO_TMP_DIR:
                                        ilUtil::sendFailure($this->lng->txt("form_msg_file_missing_tmp_dir"), true);
                                        return false;
                                        break;
                                         
                                case UPLOAD_ERR_CANT_WRITE:
                                        ilUtil::sendFailure($this->lng->txt("form_msg_file_cannot_write_to_disk"), true);
                                        return false;
                                        break;
         
                                case UPLOAD_ERR_EXTENSION:
                                        ilUtil::sendFailure($this->lng->txt("form_msg_file_upload_stopped_ext"), true);
                                        return false;
                                        break;
                        }
                }
                
                // check suffixes
                if( count($this->getAllowedExtensionsArray()) )
                {
                        if( !strlen($suffix) )
                        {
                                ilUtil::sendFailure($this->lng->txt("form_msg_file_missing_file_ext"), true);
                                return false;
                        }
                        
                        if( !in_array(strtolower($suffix), $this->getAllowedExtensionsArray()) )
                        {
                                ilUtil::sendFailure($this->lng->txt("form_msg_file_wrong_file_type"), true);
                                return false;
                        }
                }
                
                // virus handling
                if (strlen($temp_name))
                {
                        $vir = ilUtil::virusHandling($temp_name, $filename);
                        if ($vir[0] == false)
                        {
                                ilUtil::sendFailure($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)
        {
                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)
        {
                return CLIENT_WEB_DIR . "/assessment/qst_preview/$userId/{$this->getId()}/fileuploads/";
        }
 
        function getFileUploadPathWeb($test_id, $active_id, $question_id = null)
        {
                if (is_null($question_id)) $question_id = $this->getId();
                include_once "./Services/Utilities/classes/class.ilUtil.php";
                $webdir = ilUtil::removeTrailingPathSeparators(CLIENT_WEB_DIR) . "/assessment/tst_$test_id/$active_id/$question_id/files/";
                return str_replace(ilUtil::removeTrailingPathSeparators(ILIAS_ABSOLUTE_PATH), ilUtil::removeTrailingPathSeparators(ILIAS_HTTP_PATH), $webdir);
        }
 
        protected function getPreviewFileUploadPathWeb($userId)
        {
                include_once "./Services/Utilities/classes/class.ilUtil.php";
                $webdir = ilUtil::removeTrailingPathSeparators(CLIENT_WEB_DIR) . "/assessment/qst_preview/$userId/{$this->getId()}/fileuploads/";
                return str_replace(ilUtil::removeTrailingPathSeparators(ILIAS_ABSOLUTE_PATH), ilUtil::removeTrailingPathSeparators(ILIAS_HTTP_PATH), $webdir);
        }
 
        public function getUploadedFiles($active_id, $pass = null, $authorized = true)
        {
                global $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)
        {
                return (array)$previewSession->getParticipantsSolution();
        }
        
        public function getUploadedFilesForWeb($active_id, $pass)
        {
                global $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)
        {
                global $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)
        {
                // 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
                $curdir = getcwd();
                chdir($this->getFileUploadPath($test_id, $active_id));
                $existing_files = glob("file_" . $active_id . "_" . $pass . "_*");
                foreach($existing_files as $file)
                {
                        if (!in_array($file, $used_files))
                        {
                                @unlink($file);
                        }
                }
                chdir($curdir);
        }
// 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()
        {
                $size = $this->getMaxFilesizeInBytes();
                if ($size < 1024)
                {
                        $max_filesize = sprintf("%d Bytes",$size);
                }
                else if ($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()
        {
                if (strlen($this->getMaxSize()))
                {
                        return $this->getMaxSize();
                }
                else
                {
                        // 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 $max_filesize;
                }
        }
 
        // hey: prevPassSolutions - refactored method to get intermediate/authorized
        //                                                      as well as upload, delete and previous files working
        // BASED ON LAST FRED IMPLEMENTATION (@Fred: simply replace and solve unknown calls)
        public function saveWorkingData($active_id, $pass = NULL, $authorized = true)
        {
                $pass = $this->ensureCurrentTestPass($active_id, $pass);
                $test_id = $this->lookupTestId($active_id);
                
                $uploadHandlingRequired = $this->isFileUploadAvailable() && $this->checkUpload();
                
                $entered_values = false;
 
                $this->getProcessLocker()->executeUserSolutionUpdateLockOperation(function() use (&$entered_values, $uploadHandlingRequired, $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
                                {
                                        ilUtil::sendInfo($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( $uploadHandlingRequired )
                                {
                                        if(!@file_exists($this->getFileUploadPath($test_id, $active_id)))
                                        {
                                                ilUtil::makeDirParents($this->getFileUploadPath($test_id, $active_id));
                                        }
                                        
                                        $solutionFileVersioningUploadTS = time();
                                        $filename_arr = pathinfo($_FILES["upload"]["name"]);
                                        $extension = $filename_arr["extension"];
                                        $newfile = "file_" . $active_id . "_" . $pass . "_" . $solutionFileVersioningUploadTS . "." . $extension;
                                        
                                        include_once 'Services/Utilities/classes/class.ilFileUtils.php';
                                        $dispoFilename = ilFileUtils::getValidFilename($_FILES['upload']['name']);
                                        $newfile = ilFileUtils::getValidFilename($newfile);
                                        
                                        ilUtil::moveUploadedFile($_FILES["upload"]["tmp_name"], $_FILES["upload"]["name"], $this->getFileUploadPath($test_id, $active_id) . $newfile);
                                        
                                        $this->saveCurrentSolution($active_id, $pass, $newfile, $dispoFilename, false,
                                                $solutionFileVersioningUploadTS
                                        );
 
                                        $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)
                {
                        include_once ("./Modules/Test/classes/class.ilObjAssessmentFolder.php");
                        if (ilObjAssessmentFolder::_enabledAssessmentLogging())
                        {
                                assQuestion::logAction($this->lng->txtlng("assessment", "log_user_entered_values", ilObjAssessmentFolder::_getLogLanguage()), $active_id, $this->getId());
                        }
                }
                else
                {
                        include_once ("./Modules/Test/classes/class.ilObjAssessmentFolder.php");
                        if (ilObjAssessmentFolder::_enabledAssessmentLogging())
                        {
                                assQuestion::logAction($this->lng->txtlng("assessment", "log_user_not_entered_values", ilObjAssessmentFolder::_getLogLanguage()), $active_id, $this->getId());
                        }
                }
                
                return true;
        }
        // hey.
        
// fau: testNav - remove dummy value when intermediate solution is got for test display
        public function getUserSolutionPreferingIntermediate($active_id, $pass = NULL)
        {
                $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.
 
 
// fau: testNav - remove unused files if an intermediate solution is removed
        public function removeIntermediateSolution($active_id, $pass)
        {
                global $ilDB;
 
                $result = parent::removeIntermediateSolution($active_id, $pass);
 
                // get the current test id
                // hey: prevPassSolutions - exract until you drop :-D
                $test_id = $this->lookupTestId($active_id);
                // hey.
 
                $this->deleteUnusedFiles($test_id, $active_id, $pass);
 
                return $result;
        }
// fau.
 
 
        protected function savePreviewData(ilAssQuestionPreviewSession $previewSession)
        {
                $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
                        {
                                ilUtil::sendInfo($this->lng->txt('no_checkbox'), true);
                        }
                }
                else
                {
                        // hey: prevPassSolutions - readability spree - get a chance to understand the code
                        if ( $this->isFileUploadAvailable() )
                        // hey.
                        {
                                if ($this->checkUpload())
                                {
                                        if( !@file_exists($this->getPreviewFileUploadPath($previewSession->getUserId())) )
                                        {
                                                ilUtil::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;
                                        ilUtil::moveUploadedFile($_FILES["upload"]["tmp_name"], $_FILES["upload"]["name"], $this->getPreviewFileUploadPath($previewSession->getUserId()) . $newfile);
 
                                        $userSolution[$newfile] = array(
                                                'solution_id' => $newfile,
                                                'value1' => $newfile,
                                                'value2' => $_FILES['upload']['name'],
                                                'tstamp' => $version,
                                                'webpath' => $this->getPreviewFileUploadPathWeb($previewSession->getUserId())
                                        );
                                }
                        }
                }
 
                $previewSession->setParticipantsSolution($userSolution);
        }
 
        protected function reworkWorkingData($active_id, $pass, $obligationsAnswered, $authorized)
        {
                $this->handleSubmission($active_id, $pass, $obligationsAnswered, $authorized);
        }
        
        protected function handleSubmission($active_id, $pass, $obligationsAnswered, $authorized)
        {
                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, 1, $obligationsAnswered);                                        
                        
                        // update learning progress
                        include_once 'Modules/Test/classes/class.ilObjTestAccess.php';
                        include_once 'Services/Tracking/classes/class.ilLPStatusWrapper.php';
                        ilLPStatusWrapper::_updateStatus(
                                ilObjTest::_getObjectIDFromActiveID((int)$active_id),
                                ilObjTestAccess::_getParticipantId((int) $active_id)
                        );
                }
        }
 
        public function getQuestionType()
        {
                return "assFileUpload";
        }
        
        public function getAdditionalTableName()
        {
                return "qpl_qst_fileupload";
        }
        
        public function getAnswerTableName()
        {
                return "";
        }
        
        public function deleteAnswers($question_id)
        {
        }
 
        public function getRTETextWithMediaObjects()
        {
                $text = parent::getRTETextWithMediaObjects();
                return $text;
        }
        
        public function setExportDetailsXLS($worksheet, $startrow, $active_id, $pass)
        {
                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, 1, $solution["value1"]);
                                $worksheet->setCell($startrow + $i, 2, $solution["value2"]);
                        }
                        $i++;
                }
 
                return $startrow + $i + 1;
        }
        
        public function fromXML(&$item, &$questionpool_id, &$tst_id, &$tst_object, &$question_counter, &$import_mapping)
        {
                include_once "./Modules/TestQuestionPool/classes/import/qti12/class.assFileUploadImport.php";
                $import = new assFileUploadImport($this);
                $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)
        {
                include_once "./Modules/TestQuestionPool/classes/export/qti12/class.assFileUploadExport.php";
                $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)
        {
                $user_solution = array();
                return $user_solution;
        }
        
        public function getMaxSize()
        {
                return $this->maxsize;
        }
        
        public function setMaxSize($a_value)
        {
                $this->maxsize = $a_value;
        }
        
        public function getAllowedExtensionsArray()
        {
                if (strlen($this->allowedextensions))
                {
                        return array_filter(array_map('trim', explode(",", $this->allowedextensions)));
                }
                return array();
        }
        
        public function getAllowedExtensions()
        {
                return $this->allowedextensions;
        }
        
        public function setAllowedExtensions($a_value)
        {
                $this->allowedextensions = strtolower(trim($a_value));
        }
        
        public function __get($value)
        {
                switch ($value)
                {
                        case "maxsize":
                                return $this->getMaxSize();
                                break;
                        case "allowedextensions":
                                return $this->getAllowedExtensions();
                                break;
                        case 'completion_by_submission':
                                return $this->isCompletionBySubmissionEnabled();
                                break;
                        default:
                                return parent::__get($value);
                                break;
                }
        }
 
        public function __set($key, $value)
        {
                switch ($key)
                {
                        case "maxsize":
                                $this->setMaxSize($value);
                                break;
                        case "allowedextensions":
                                $this->setAllowedExtensions($value);
                                break;
                        case 'completion_by_submission':
                                $this->setCompletionBySubmission($value);
                                break;
                        default:
                                parent::__set($key, $value);
                                break;
                }
        }
 
        public function hasFileUploads($test_id)
        {
                global $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";
                $result = $ilDB->queryF( $query,
                        array("integer", "integer"),
                        array($this->getId(), $test_id)
                );
                if ($result->numRows() > 0)
                {
                        return true;
                }
                else
                {
                        return false;
                }
        }
 
        public function deliverFileUploadZIPFile($test_id, $test_title)
        {
                global $ilDB, $lng;
                
                require_once 'Modules/TestQuestionPool/classes/class.ilAssFileUploadUploadsExporter.php';
                $exporter = new ilAssFileUploadUploadsExporter($ilDB, $lng);
                
                $exporter->setTestId($test_id);
                $exporter->setTestTitle($test_title);
                $exporter->setQuestion($this);
                
                $exporter->build();
 
                ilUtil::deliverFile(
                        $exporter->getFinalZipFilePath(), $exporter->getDispoZipFileName(),
                        $exporter->getZipFileMimeType(), false, true
                );
        }
        
        public function isCompletionBySubmissionEnabled()
        {
                return $this->completion_by_submission;
        }
        
        public function setCompletionBySubmission($bool)
        {
                $this->completion_by_submission = (bool)$bool;
                return $this;
        }
        
        public function isAnswered($active_id, $pass = null)
        {
                $numExistingSolutionRecords = assQuestion::getNumExistingSolutionRecords($active_id, $pass, $this->getId());
                
                return $numExistingSolutionRecords > 0;
        }
        
        public static function isObligationPossible($questionId)
        {
                return true;
        }
        
        public function isAutosaveable()
        {
                return FALSE;
        }
 
// fau: testNav - new function getTestQuestionConfig()
        // hey: refactored identifiers
        public function buildTestPresentationConfig()
        // hey.
        {
                // hey: refactored identifiers
                return parent::buildTestPresentationConfig()
                        // hey.
                        ->setFormChangeDetectionEnabled(false);
        }
// fau.
        
        // hey: prevPassSolutions - additional extractions to get a just chance to understand saveWorkingData()
        protected function isFileDeletionAction()
        {
                require_once 'Modules/TestQuestionPool/classes/questions/class.ilAssFileUploadFileTableDeleteButton.php';
                return $this->getQuestionAction() == ilAssFileUploadFileTableDeleteButton::ACTION;
        }
        
        protected function isFileDeletionSubmitAvailable()
        {
                return $this->isNonEmptyItemListPostSubmission(self::DELETE_FILES_TBL_POSTVAR);
        }
        
        protected function isFileReuseSubmitAvailable()
        {
                return $this->isNonEmptyItemListPostSubmission(self::REUSE_FILES_TBL_POSTVAR);
        }
        
        protected function isFileReuseHandlingRequired()
        {
                if( !$this->getTestPresentationConfig()->isPreviousPassSolutionReuseAllowed() )
                {
                        return false;
                }
                
                if( !$this->isFileReuseSubmitAvailable() )
                {
                        return false;
                }
                
                return true;
        }
        
        protected function isFileUploadAvailable()
        {
                if( !isset($_FILES['upload']) )
                {
                        return false;
                }
                
                if( !isset($_FILES['upload']['tmp_name']) )
                {
                        return false;
                }
                
                return strlen($_FILES['upload']['tmp_name']) > 0;
        }
        // hey.
}