class.assQuestion.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */

include_once "./Modules/Test/classes/inc.AssessmentConstants.php";

abstract class assQuestion
{
        const IMG_MIME_TYPE_JPG = 'image/jpeg'; 
        const IMG_MIME_TYPE_PNG = 'image/png'; 
        const IMG_MIME_TYPE_GIF = 'image/gif';
        
        protected static $allowedFileExtensionsByMimeType = array(
                self::IMG_MIME_TYPE_JPG => array('jpg', 'jpeg'),
                self::IMG_MIME_TYPE_PNG => array('png'),
                self::IMG_MIME_TYPE_GIF => array('gif')
        );

        protected static $allowedCharsetsByMimeType = array(
                self::IMG_MIME_TYPE_JPG => array('binary'),
                self::IMG_MIME_TYPE_PNG => array('binary'),
                self::IMG_MIME_TYPE_GIF => array('binary')
        );

        protected $id;

        protected $title;

        protected $comment;

        protected $owner;

        protected $author;

        protected $question;

        protected $points;

        protected $est_working_time;

        protected $shuffle;

        protected $test_id;

        protected $obj_id;

        protected $ilias;

        protected $tpl;

        protected $lng;

        protected $db;

        protected $outputType = OUTPUT_JAVASCRIPT;

        protected $suggested_solutions;

        protected $original_id;

        protected $page;

        private $nr_of_tries;
        
        private $arrData;

        private $export_image_path;

        protected $external_id = '';
        
        const ADDITIONAL_CONTENT_EDITING_MODE_DEFAULT = 'default';

        const ADDITIONAL_CONTENT_EDITING_MODE_PAGE_OBJECT = 'pageobject';
        
        private $additinalContentEditingMode = null;
        
        public $feedbackOBJ = null;

        var $prevent_rte_usage = false;

        var $selfassessmenteditingmode = false;

        var $defaultnroftries = 0;
        
        protected $questionChangeListeners = array();

        protected $processLocker;

        public $questionActionCmd = 'handleQuestionAction';

        private static $resultGateway = null;

        protected $step = null;
        
        protected $lastChange;

        protected $shuffler;

        private $obligationsToBeConsidered = false;
        
// fau: testNav - new variable $testQuestionConfig
        protected $testQuestionConfig;
// fau.
        
        protected static $allowedImageMaterialFileExtensionsByMimeType = array(
                'image/jpeg' => array('jpg', 'jpeg'), 'image/png' => array('png'), 'image/gif' => array('gif')
        );
        
        function __construct(
                $title = "",
                $comment = "",
                $author = "",
                $owner = -1,
                $question = ""
        )
        {
                global $ilias, $lng, $tpl, $ilDB;

                $this->ilias = $ilias;
                $this->lng = $lng;
                $this->tpl = $tpl;
                $this->db = $ilDB;

                $this->original_id = null;
                $this->title = $title;
                $this->comment = $comment;
                $this->page = null;
                $this->author = $author;
                $this->setQuestion($question);
                if (!$this->author)
                {
                        $this->author = $this->ilias->account->fullname;
                }
                $this->owner = $owner;
                if ($this->owner <= 0)
                {
                        $this->owner = $this->ilias->account->id;
                }
                $this->id = -1;
                $this->test_id = -1;
                $this->suggested_solutions = array();
                $this->shuffle = 1;
                $this->nr_of_tries = 0;
                $this->setEstimatedWorkingTime(0,1,0);
                $this->arrData = array();
                $this->setExternalId('');

                $this->questionActionCmd = 'handleQuestionAction';
                
                $this->lastChange = null;

                require_once 'Services/Randomization/classes/class.ilArrayElementOrderKeeper.php';
                $this->shuffler = new ilArrayElementOrderKeeper();
        }
        
        protected static $forcePassResultsUpdateEnabled = false;
        
        public static function setForcePassResultUpdateEnabled($forcePassResultsUpdateEnabled)
        {
                self::$forcePassResultsUpdateEnabled = $forcePassResultsUpdateEnabled;
        }
        
        public static function isForcePassResultUpdateEnabled()
        {
                return self::$forcePassResultsUpdateEnabled;
        }

        public static function isAllowedImageMimeType($mimeType)
        {
                return (bool)count(self::getAllowedFileExtensionsForMimeType($mimeType));
        }

        public static function fetchMimeTypeIdentifier($contentTypeString)
        {
                return current(explode(';', $contentTypeString));
        }

        public static function getAllowedFileExtensionsForMimeType($mimeType)
        {
                foreach(self::$allowedFileExtensionsByMimeType as $allowedMimeType => $extensions)
                {
                        $rexCharsets = implode('|', self::$allowedCharsetsByMimeType[$allowedMimeType]);
                        $rexMimeType = preg_quote($allowedMimeType, '/');

                        $rex = '/^'.$rexMimeType.'(;(\s)*charset=('.$rexCharsets.'))*$/';

                        if( !preg_match($rex, $mimeType) )
                        {
                                continue;
                        }

                        return $extensions;
                }

                return array();
        }

        public static function isAllowedImageFileExtension($mimeType, $fileExtension)
        {
                return in_array(
                        strtolower($fileExtension), self::getAllowedFileExtensionsForMimeType($mimeType)
                );
        }
        
        // hey: prevPassSolutions - question action actracted (heavy use in fileupload refactoring)
        
        protected function getQuestionAction()
        {
                if( !isset($_POST['cmd']) || !isset($_POST['cmd'][$this->questionActionCmd]) )
                {
                        return '';
                }
                
                if( !is_array($_POST['cmd'][$this->questionActionCmd]) || !count($_POST['cmd'][$this->questionActionCmd]) )
                {
                        return '';
                }
                
                return key($_POST['cmd'][$this->questionActionCmd]);
        }
        
        protected function isNonEmptyItemListPostSubmission($postSubmissionFieldname)
        {
                if( !isset($_POST[$postSubmissionFieldname]) )
                {
                        return false;
                }
                
                if( !is_array($_POST[$postSubmissionFieldname]) )
                {
                        return false;
                }
                
                if( !count($_POST[$postSubmissionFieldname]) )
                {
                        return false;
                }
                
                return true;
        }
        
        protected function ensureCurrentTestPass($active_id, $pass)
        {
                if( is_integer($pass) && $pass >= 0 )
                {
                        return $pass;
                }
                
                return $this->lookupCurrentTestPass($active_id, $pass);
        }
        
        protected function lookupCurrentTestPass($active_id, $pass)
        {
                require_once 'Modules/Test/classes/class.ilObjTest.php';
                return ilObjTest::_getPass($active_id);
        }
        
        protected function lookupTestId($active_id)
        {
                $ilDB = isset($GLOBALS['DIC']) ? $GLOBALS['DIC']['ilDB'] : $GLOBALS['ilDB'];
                
                $result = $ilDB->queryF("SELECT test_fi FROM tst_active WHERE active_id = %s",
                        array('integer'), array($active_id)
                );
                
                while($row = $ilDB->fetchAssoc($result))
                {
                        return $row["test_fi"];
                }
                
                return null;
        }
        // hey.
        
        protected function log($active_id, $langVar)
        {
                if( ilObjAssessmentFolder::_enabledAssessmentLogging() )
                {
                        $message = $this->lng->txtlng('assessment', $langVar, ilObjAssessmentFolder::_getLogLanguage());
                        assQuestion::logAction($message, $active_id, $this->getId());
                }
        }

        public static function getAllowedImageMaterialFileExtensions()
        {
                $extensions = array();

                foreach (self::$allowedImageMaterialFileExtensionsByMimeType as $mimeType => $mimeExtensions)
                {
                        $extensions = array_merge($extensions, $mimeExtensions);
                }
                return array_unique($extensions);
        }

        public function getShuffler()
        {
                return $this->shuffler;
        }

        public function setShuffler(ilArrayElementShuffler $shuffler)
        {
                $this->shuffler = $shuffler;
        }

        public function setProcessLocker($processLocker)
        {
                $this->processLocker = $processLocker;
        }

        public function getProcessLocker()
        {
                return $this->processLocker;
        }

        function fromXML(&$item, &$questionpool_id, &$tst_id, &$tst_object, &$question_counter, &$import_mapping)
        {
                include_once "./Modules/TestQuestionPool/classes/import/qti12/class." . $this->getQuestionType() . "Import.php";
                $classname = $this->getQuestionType() . "Import";
                $import = new $classname($this);
                $import->fromXML($item, $questionpool_id, $tst_id, $tst_object, $question_counter, $import_mapping);
        }
        
        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." . $this->getQuestionType() . "Export.php";
                $classname = $this->getQuestionType() . "Export";
                $export = new $classname($this);
                return $export->toXML($a_include_header, $a_include_binary, $a_shuffle, $test_output, $force_image_references);
        }

        function isComplete()
        {
                return false;
        }

        function questionTitleExists($questionpool_id, $title)
        {
                global $ilDB;
                
                $result = $ilDB->queryF("SELECT * FROM qpl_questions WHERE obj_fi = %s AND title = %s",
                        array('integer','text'),
                        array($questionpool_id, $title)
                );
                return ($result->numRows() > 0) ? TRUE : FALSE;
        }

        function setTitle($title = "")
        {
                $this->title = $title;
        }

        function setId($id = -1)
        {
                $this->id = $id;
        }

        function setTestId($id = -1)
        {
                $this->test_id = $id;
        }

        function setComment($comment = "")
        {
                $this->comment = $comment;
        }

        function setOutputType($outputType = OUTPUT_HTML)
        {
                $this->outputType = $outputType;
        }


        function setShuffle($shuffle = true)
        {
                if ($shuffle)
                {
                        $this->shuffle = 1;
                }
                        else
                {
                        $this->shuffle = 0;
                }
        }

        function setEstimatedWorkingTime($hour=0, $min=0, $sec=0)
        {
                $this->est_working_time = array("h" => (int)$hour, "m" => (int)$min, "s" => (int)$sec);
        }

        function setEstimatedWorkingTimeFromDurationString($durationString)
        {
                $this->est_working_time = array(
                        'h' => (int)substr($durationString, 0, 2),
                        'm' => (int)substr($durationString, 3, 2),
                        's' => (int)substr($durationString, 6, 2)
                );
        }

        function keyInArray($searchkey, $array)
        {
                if ($searchkey)
                {
                        foreach ($array as $key => $value)
                        {
                                if (strcmp($key, $searchkey)==0)
                                {
                                        return true;
                                }
                        }
                }
                return false;
        }

        function setAuthor($author = "")
        {
                if (!$author)
                {
                        $author = $this->ilias->account->fullname;
                }
                $this->author = $author;
        }

        function setOwner($owner = "")
        {
                $this->owner = $owner;
        }

        function getTitle()
        {
                return $this->title;
        }
        
        public function getTitleFilenameCompliant()
        {
                require_once 'Services/Utilities/classes/class.ilUtil.php';
                return ilUtil::getASCIIFilename($this->getTitle());
        }

        function getId()
        {
                return $this->id;
        }

        function getShuffle()
        {
                return $this->shuffle;
        }

        function getTestId()
        {
                return $this->test_id;
        }

        function getComment()
        {
                return $this->comment;
        }

        function getOutputType()
        {
                return $this->outputType;
        }
        
        public function supportsJavascriptOutput()
        {
                return FALSE;
        }

        public function supportsNonJsOutput()
        {
                return true;
        }
        
        public function requiresJsSwitch()
        {
                return $this->supportsJavascriptOutput() && $this->supportsNonJsOutput();
        }

        function getEstimatedWorkingTime()
        {
                if (!$this->est_working_time)
                {
                        $this->est_working_time = array("h" => 0, "m" => 0, "s" => 0);
                }
                return $this->est_working_time;
        }

        function getAuthor()
        {
                return $this->author;
        }

        function getOwner()
        {
                return $this->owner;
        }

        function getObjId()
        {
                return $this->obj_id;
        }

        function setObjId($obj_id = 0)
        {
                $this->obj_id = $obj_id;
        }

        public function setExternalId($external_id)
        {
                $this->external_id = $external_id;
        }

        public function getExternalId()
        {
                if(!strlen($this->external_id))
                {
                        if($this->getId() > 0)
                        {
                                return 'il_' . IL_INST_ID . '_qst_' . $this->getId();
                        }
                        else
                        {
                                return uniqid('', true);
                        }
                }
                else
                {
                        return $this->external_id;
                }
        }

        public static function _getMaximumPoints($question_id)
        {
                global $ilDB;

                $points = 0;
                $result = $ilDB->queryF("SELECT points FROM qpl_questions WHERE question_id = %s",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows() == 1)
                {
                        $row = $ilDB->fetchAssoc($result);
                        $points = $row["points"];
                }
                return $points;
  }

        public static function _getQuestionInfo($question_id)
        {
                global $ilDB;

                $result = $ilDB->queryF("SELECT qpl_questions.*, qpl_qst_type.type_tag FROM qpl_qst_type, qpl_questions WHERE qpl_questions.question_id = %s AND qpl_questions.question_type_fi = qpl_qst_type.question_type_id",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows())
                {
                        return $ilDB->fetchAssoc($result);
                }
                else return array();
        }
        
        public static function _getSuggestedSolutionCount($question_id)
        {
                global $ilDB;

                $result = $ilDB->queryF("SELECT suggested_solution_id FROM qpl_sol_sug WHERE question_fi = %s",
                        array('integer'),
                        array($question_id)
                );
                return $result->numRows();
        }

        public static function _getSuggestedSolutionOutput($question_id)
        {
                $question =& assQuestion::_instanciateQuestion($question_id);
                if (!is_object($question)) return "";
                return $question->getSuggestedSolutionOutput();
        }

        public function getSuggestedSolutionOutput()
        {
                $output = array();
                foreach ($this->suggested_solutions as $solution)
                {
                        switch ($solution["type"])
                        {
                                case "lm":
                                case "st":
                                case "pg":
                                case "git":
                                        array_push($output, '<a href="' . assQuestion::_getInternalLinkHref($solution["internal_link"]) . '">' . $this->lng->txt("solution_hint") . '</a>');
                                        break;
                                case "file":
                                        $possible_texts = array_values(array_filter(array(
                                                ilUtil::prepareFormOutput($solution['value']['filename']),
                                                ilUtil::prepareFormOutput($solution['value']['name']),
                                                $this->lng->txt('tst_show_solution_suggested')
                                        )));

                                        require_once 'Services/WebAccessChecker/classes/class.ilWACSignedPath.php';
                                        ilWACSignedPath::setTokenMaxLifetimeInSeconds(60);
                                        array_push($output, '<a href="' . ilWACSignedPath::signFile($this->getSuggestedSolutionPathWeb() . $solution["value"]["name"]) . '">' . $possible_texts[0] . '</a>');
                                        break;
                                case "text":
                                        $solutionValue = $solution["value"];
                                        $solutionValue = $this->fixSvgToPng($solutionValue);
                                        $solutionValue = $this->fixUnavailableSkinImageSources($solutionValue);
                                        $output[] = $this->prepareTextareaOutput($solutionValue, true);
                                        break;
                        }
                }
                return join($output, "<br />");
        }

        function &_getSuggestedSolution($question_id, $subquestion_index = 0)
        {
                global $ilDB;

                $result = $ilDB->queryF("SELECT * FROM qpl_sol_sug WHERE question_fi = %s AND subquestion_index = %s",
                        array('integer','integer'),
                        array($question_id, $subquestion_index)
                );
                if ($result->numRows() == 1)
                {
                        $row = $ilDB->fetchAssoc($result);
                        return array(
                                "internal_link" => $row["internal_link"],
                                "import_id" => $row["import_id"]
                        );
                }
                else
                {
                        return array();
                }
        }
        
        public function getSuggestedSolutions()
        {
                return $this->suggested_solutions;
        }
        
        public static function _getReachedPoints($active_id, $question_id, $pass = NULL)
        {
                global $ilDB;

                $points = 0;
                if (is_null($pass))
                {
                        include_once "./Modules/TestQuestionPool/classes/class.assQuestion.php";
                        $pass = assQuestion::_getSolutionMaxPass($question_id, $active_id);
                }
                $result = $ilDB->queryF("SELECT * FROM tst_test_result WHERE active_fi = %s AND question_fi = %s AND pass = %s",
                        array('integer','integer','integer'),
                        array($active_id, $question_id, $pass)
                );
                if ($result->numRows() == 1)
                {
                        $row = $ilDB->fetchAssoc($result);
                        $points = $row["points"];
                }
                return $points;
        }

        function getReachedPoints($active_id, $pass = NULL)
        {
                return round(self::_getReachedPoints($active_id, $this->getId(), $pass), 2);
        }
        
        function getMaximumPoints()
        {
                return $this->points;
        }
        
        final public function getAdjustedReachedPoints($active_id, $pass = NULL, $authorizedSolution = true)
        {
            if (is_null($pass))
            {
                    include_once "./Modules/Test/classes/class.ilObjTest.php";
                    $pass = ilObjTest::_getPass($active_id);
            }
            
            // determine reached points for submitted solution
            $reached_points = $this->calculateReachedPoints($active_id, $pass, $authorizedSolution);
                        
                        

            // deduct points for requested hints from reached points
            require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintTracking.php';
                        $hintTracking = new ilAssQuestionHintTracking($this->getId(), $active_id, $pass);
            $requestsStatisticData = $hintTracking->getRequestStatisticDataByQuestionAndTestpass();
            $reached_points = $reached_points - $requestsStatisticData->getRequestsPoints();

            // adjust reached points regarding to tests scoring options
            $reached_points = $this->adjustReachedPointsByScoringOptions($reached_points, $active_id, $pass);
            
            return $reached_points;
        }
        
        final public function calculateResultsFromSolution($active_id, $pass = NULL, $obligationsEnabled = false)
        {
                global $ilDB, $ilUser;
                
                if( is_null($pass) )
                {
                        include_once "./Modules/Test/classes/class.ilObjTest.php";
                        $pass = ilObjTest::_getPass($active_id);
                }
                
                // determine reached points for submitted solution
                $reached_points = $this->calculateReachedPoints($active_id, $pass);

                // deduct points for requested hints from reached points
                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintTracking.php';
                $questionHintTracking = new ilAssQuestionHintTracking($this->getId(), $active_id, $pass);
                $requestsStatisticData = $questionHintTracking->getRequestStatisticDataByQuestionAndTestpass();
                $reached_points = $reached_points - $requestsStatisticData->getRequestsPoints();

                // adjust reached points regarding to tests scoring options
                $reached_points = $this->adjustReachedPointsByScoringOptions($reached_points, $active_id, $pass);
                
                if( $obligationsEnabled && ilObjTest::isQuestionObligatory($this->getId()) )
                {
                    $isAnswered = $this->isAnswered($active_id, $pass);
                }
                else
                {
                    $isAnswered = true;
                }
                
                if( is_null($reached_points) ) $reached_points = 0;

// fau: testNav - check for existing authorized solution to know if a result record should be written
                $existingSolutions = $this->lookupForExistingSolutions($active_id, $pass);

                $this->getProcessLocker()->executeUserQuestionResultUpdateOperation(function() use($ilDB, $active_id, $pass, $reached_points, $requestsStatisticData, $isAnswered, $existingSolutions) {

                        $query = "
                        DELETE FROM             tst_test_result
                        
                        WHERE                   active_fi = %s
                        AND                             question_fi = %s
                        AND                             pass = %s
                ";

                        $types = array('integer', 'integer', 'integer');
                        $values = array($active_id, $this->getId(), $pass);

                        if( $this->getStep() !== NULL )
                        {
                                $query .= "
                                AND                             step = %s
                        ";

                                $types[] = 'integer';
                                $values[] = $this->getStep();
                        }
                        $ilDB->manipulateF($query, $types, $values);

                        if ($existingSolutions['authorized'])
                        {
                                $next_id = $ilDB->nextId("tst_test_result");
                                $fieldData = array(
                                        'test_result_id'        => array('integer', $next_id),
                                        'active_fi'                     => array('integer', $active_id),
                                        'question_fi'           => array('integer', $this->getId()),
                                        'pass'                          => array('integer', $pass),
                                        'points'                        => array('float', $reached_points),
                                        'tstamp'                        => array('integer', time()),
                                        'hint_count'            => array('integer', $requestsStatisticData->getRequestsCount()),
                                        'hint_points'           => array('float', $requestsStatisticData->getRequestsPoints()),
                                        'answered'                      => array('integer', $isAnswered)
                                );

                                if( $this->getStep() !== NULL )
                                {
                                        $fieldData['step'] = array('integer', $this->getStep());
                                }

                                $ilDB->insert('tst_test_result', $fieldData);
                        }

                });
// fau.

                include_once ("./Modules/Test/classes/class.ilObjAssessmentFolder.php");
                
                if( ilObjAssessmentFolder::_enabledAssessmentLogging() )
                {
                        assQuestion::logAction(
                                sprintf(
                                        $this->lng->txtlng(
                                                "assessment", "log_user_answered_question", ilObjAssessmentFolder::_getLogLanguage()
                                        ),
                                        $reached_points
                                ),
                                $active_id,
                                $this->getId()
                        );
                }

                // update test pass results
                self::_updateTestPassResults($active_id, $pass, $obligationsEnabled, $this->getProcessLocker());

                // Update objective status
                include_once 'Modules/Course/classes/class.ilCourseObjectiveResult.php';
                ilCourseObjectiveResult::_updateObjectiveResult($ilUser->getId(),$active_id,$this->getId());
        }

        final public function persistWorkingState($active_id, $pass = NULL, $obligationsEnabled = false, $authorized = true)
        {
                if( $pass === null )
                {
                        require_once 'Modules/Test/classes/class.ilObjTest.php';
                        $pass = ilObjTest::_getPass($active_id);
                }
                
                if( !$this->validateSolutionSubmit() )
                {
                        return false;
                }

                $saveStatus = false;

                $this->getProcessLocker()->executePersistWorkingStateLockOperation(function() use ($active_id, $pass, $authorized, $obligationsEnabled, &$saveStatus) {

                        $saveStatus = $this->saveWorkingData($active_id, $pass, $authorized);

                        if($authorized)
                        {
// fau: testNav - remove an intermediate solution if the authorized solution is saved
//              the intermediate solution would set the displayed question status as "editing ..."
                        $this->removeIntermediateSolution($active_id, $pass);
// fau.
                                $this->calculateResultsFromSolution($active_id, $pass, $obligationsEnabled);
                        }

                        $this->reworkWorkingData($active_id, $pass, $obligationsEnabled, $authorized);

                });

                return $saveStatus;
        }

        final public function persistPreviewState(ilAssQuestionPreviewSession $previewSession)
        {
                $this->savePreviewData($previewSession);
                return $this->validateSolutionSubmit();
        }
        
        public function validateSolutionSubmit()
        {
                return true;
        }
        
        abstract public function saveWorkingData($active_id, $pass = NULL, $authorized = true);

        abstract protected function reworkWorkingData($active_id, $pass, $obligationsAnswered, $authorized);

        protected function savePreviewData(ilAssQuestionPreviewSession $previewSession)
        {
                $previewSession->setParticipantsSolution($this->getSolutionSubmit());
        }
        
        public static function _updateTestResultCache($active_id, ilAssQuestionProcessLocker $processLocker = null)
        {
                global $ilDB;

                include_once "./Modules/Test/classes/class.ilObjTest.php";
                include_once "./Modules/Test/classes/class.assMarkSchema.php";
                
                $pass = ilObjTest::_getResultPass($active_id);

                $query = "
                        SELECT          tst_pass_result.*
                        FROM            tst_pass_result
                        WHERE           active_fi = %s
                        AND                     pass = %s
                ";
                
                $result = $ilDB->queryF(
                        $query, array('integer','integer'), array($active_id, $pass)
                );
                
                $row = $ilDB->fetchAssoc($result);
                
                $max = $row['maxpoints'];
                $reached = $row['points'];
                
                $obligationsAnswered = (int)$row['obligations_answered'];
                
                include_once "./Modules/Test/classes/class.assMarkSchema.php";
                
                $percentage = (!$max) ? 0 : ($reached / $max) * 100.0;
                
                $mark = ASS_MarkSchema::_getMatchingMarkFromActiveId($active_id, $percentage);
                
                $isPassed = (  $mark["passed"] ? 1 : 0 );
                $isFailed = ( !$mark["passed"] ? 1 : 0 );

                $userTestResultUpdateCallback = function() use ($ilDB, $active_id, $pass, $max, $reached, $isFailed, $isPassed, $obligationsAnswered, $row, $mark) {

                        $query = "
                                DELETE FROM             tst_result_cache
                                WHERE                   active_fi = %s
                        ";
                        $ilDB->manipulateF(
                                $query, array('integer'), array($active_id)
                        );

                        $ilDB->insert('tst_result_cache', array(
                                'active_fi'=> array('integer', $active_id),
                                'pass'=> array('integer', strlen($pass) ? $pass : 0),
                                'max_points'=> array('float', strlen($max) ? $max : 0),
                                'reached_points'=> array('float', strlen($reached) ? $reached : 0),
                                'mark_short'=> array('text', strlen($mark["short_name"]) ? $mark["short_name"] : " "),
                                'mark_official'=> array('text', strlen($mark["official_name"]) ? $mark["official_name"] : " "),
                                'passed'=> array('integer', $isPassed),
                                'failed'=> array('integer', $isFailed),
                                'tstamp'=> array('integer', time()),
                                'hint_count'=> array('integer', $row['hint_count']),
                                'hint_points'=> array('float', $row['hint_points']),
                                'obligations_answered' => array('integer', $obligationsAnswered)
                        ));

                };

                if(is_object($processLocker))
                {
                        $processLocker->executeUserTestResultUpdateLockOperation($userTestResultUpdateCallback);
                }
                else
                {
                        $userTestResultUpdateCallback();
                }
        }
        
        public static function _updateTestPassResults($active_id, $pass, $obligationsEnabled = false, ilAssQuestionProcessLocker $processLocker = null, $test_obj_id = null)
        {
                global $ilDB;

                include_once "./Modules/Test/classes/class.ilObjTest.php";

                if( self::getResultGateway() !== null )
                {
                        $data = self::getResultGateway()->getQuestionCountAndPointsForPassOfParticipant($active_id, $pass);
                        $time = self::getResultGateway()->getWorkingTimeOfParticipantForPass($active_id, $pass);
                }
                else
                {
                        $data = ilObjTest::_getQuestionCountAndPointsForPassOfParticipant($active_id, $pass);
                        $time = ilObjTest::_getWorkingTimeOfParticipantForPass($active_id, $pass);
                }

                
                // update test pass results
                
                $result = $ilDB->queryF("
                        SELECT          SUM(points) reachedpoints,
                                                SUM(hint_count) hint_count,
                                                SUM(hint_points) hint_points,
                                                COUNT(DISTINCT(question_fi)) answeredquestions
                        FROM            tst_test_result
                        WHERE           active_fi = %s
                        AND                     pass = %s
                        ",
                        array('integer','integer'),
                        array($active_id, $pass)
                );
                
                if ($result->numRows() > 0)
                {
                        if( $obligationsEnabled )
                        {
                                $query = '
                                        SELECT          answered answ
                                        FROM            tst_test_question
                                          INNER JOIN    tst_active
                                                ON                      active_id = %s
                                                AND                     tst_test_question.test_fi = tst_active.test_fi
                                        LEFT JOIN       tst_test_result
                                                ON                      tst_test_result.active_fi = %s
                                                AND                     tst_test_result.pass = %s
                                                AND                     tst_test_question.question_fi = tst_test_result.question_fi
                                        WHERE           obligatory = 1';

                                $result_obligatory = $ilDB->queryF(
                                        $query, array('integer','integer','integer'), array($active_id, $active_id, $pass)
                                );

                                $obligations_answered = 1;

                                while($row_obligatory = $ilDB->fetchAssoc($result_obligatory))
                                {
                                        if(!(int)$row_obligatory['answ'])
                                        {
                                                $obligations_answered = 0;
                                                break;
                                        }
                                }
                        }
                        else
                        {
                                $obligations_answered = 1;
                        }
                        
                        $row = $ilDB->fetchAssoc($result);
                        
                        if( $row['hint_count'] === null ) $row['hint_count'] = 0;
                        if( $row['hint_points'] === null ) $row['hint_points'] = 0;

                        $exam_identifier = ilObjTest::buildExamId( $active_id, $pass, $test_obj_id);

                        $updatePassResultCallback = function() use ($ilDB, $data, $active_id, $pass, $row, $time, $obligations_answered, $exam_identifier) {

                                $ilDB->replace('tst_pass_result',
                                        array(
                                                'active_fi' => array('integer', $active_id),
                                                'pass'      => array('integer', strlen($pass) ? $pass : 0)),
                                        array(
                                                'points'               => array('float', $row['reachedpoints'] ? $row['reachedpoints'] : 0),
                                                'maxpoints'            => array('float', $data['points']),
                                                'questioncount'        => array('integer', $data['count']),
                                                'answeredquestions'    => array('integer', $row['answeredquestions']),
                                                'workingtime'          => array('integer', $time),
                                                'tstamp'               => array('integer', time()),
                                                'hint_count'           => array('integer', $row['hint_count']),
                                                'hint_points'          => array('float', $row['hint_points']),
                                                'obligations_answered' => array('integer', $obligations_answered),
                                                'exam_id'              => array('text', $exam_identifier)
                                        )
                                );

                        };

                        if(is_object($processLocker))
                        {
                                $processLocker->executeUserPassResultUpdateLockOperation($updatePassResultCallback);
                        }
                        else
                        {
                                $updatePassResultCallback();
                        }
                }
                
                assQuestion::_updateTestResultCache($active_id, $processLocker);
                
                return array(
                        'active_fi' => $active_id,
                        'pass' => $pass,
                        'points' => ($row["reachedpoints"]) ? $row["reachedpoints"] : 0,
                        'maxpoints' => $data["points"],
                        'questioncount' => $data["count"],
                        'answeredquestions' => $row["answeredquestions"],
                        'workingtime' => $time,
                        'tstamp' => time(),
                        'hint_count' => $row['hint_count'],
                        'hint_points' => $row['hint_points'],
                        'obligations_answered' => $obligations_answered,
                        'exam_id' => $exam_identifier
                );
        }

        public static function logAction($logtext = "", $active_id = "", $question_id = "")
        {
                $original_id = "";
                if( strlen($question_id) )
                {
                        $original_id = self::_getOriginalId($question_id);
                }
                
                require_once 'Modules/Test/classes/class.ilObjAssessmentFolder.php';
                require_once 'Modules/Test/classes/class.ilObjTest.php';
                
                ilObjAssessmentFolder::_addLog(
                        $GLOBALS['DIC']['ilUser']->getId(),
                        ilObjTest::_getObjectIDFromActiveID($active_id),
                        $logtext,
                        $question_id,
                        $original_id
                );
        }
        
        function moveUploadedMediaFile($file, $name)
        {
                $mediatempdir = CLIENT_WEB_DIR . "/assessment/temp";
                if (!@is_dir($mediatempdir)) ilUtil::createDirectory($mediatempdir);
                $temp_name = tempnam($mediatempdir, $name . "_____");
                $temp_name = str_replace("\\", "/", $temp_name);
                @unlink($temp_name);
                if (!ilUtil::moveUploadedFile($file, $name, $temp_name))
                {
                        return FALSE;
                }
                else
                {
                        return $temp_name;
                }
        }
        
        function getSuggestedSolutionPath() {
                return CLIENT_WEB_DIR . "/assessment/$this->obj_id/$this->id/solution/";
        }

        function getJavaPath() {
                return CLIENT_WEB_DIR . "/assessment/$this->obj_id/$this->id/java/";
        }
        
        function getImagePath($question_id = null, $object_id = null)
        {
                if( $question_id === null)
                {
                        $question_id = $this->id;
                }
                
                if( $object_id === null)
                {
                        $object_id = $this->obj_id;
                }
                
                return $this->buildImagePath($question_id, $object_id);
        }
        
        public function buildImagePath($questionId, $parentObjectId)
        {
                return CLIENT_WEB_DIR . "/assessment/{$parentObjectId}/{$questionId}/images/";
        }

        function getFlashPath() 
        {
                return CLIENT_WEB_DIR . "/assessment/$this->obj_id/$this->id/flash/";
        }

        function getJavaPathWeb()
        {
                include_once "./Services/Utilities/classes/class.ilUtil.php";
                $webdir = ilUtil::removeTrailingPathSeparators(CLIENT_WEB_DIR) . "/assessment/$this->obj_id/$this->id/java/";
                return str_replace(ilUtil::removeTrailingPathSeparators(ILIAS_ABSOLUTE_PATH), ilUtil::removeTrailingPathSeparators(ILIAS_HTTP_PATH), $webdir);
        }

        function getSuggestedSolutionPathWeb() 
        {
                include_once "./Services/Utilities/classes/class.ilUtil.php";
                $webdir = ilUtil::removeTrailingPathSeparators(CLIENT_WEB_DIR) . "/assessment/$this->obj_id/$this->id/solution/";
                return str_replace(ilUtil::removeTrailingPathSeparators(ILIAS_ABSOLUTE_PATH), ilUtil::removeTrailingPathSeparators(ILIAS_HTTP_PATH), $webdir);
        }

        function getImagePathWeb()
        {
                if(!$this->export_image_path)
                {
                        include_once "./Services/Utilities/classes/class.ilUtil.php";
                        $webdir = ilUtil::removeTrailingPathSeparators(CLIENT_WEB_DIR) . "/assessment/$this->obj_id/$this->id/images/";
                        return str_replace(ilUtil::removeTrailingPathSeparators(ILIAS_ABSOLUTE_PATH), ilUtil::removeTrailingPathSeparators(ILIAS_HTTP_PATH), $webdir);
                }
                else
                {
                        return $this->export_image_path;
                }
        }

        function getFlashPathWeb()
        {
                include_once "./Services/Utilities/classes/class.ilUtil.php";
                $webdir = ilUtil::removeTrailingPathSeparators(CLIENT_WEB_DIR) . "/assessment/$this->obj_id/$this->id/flash/";
                return str_replace(ilUtil::removeTrailingPathSeparators(ILIAS_ABSOLUTE_PATH), ilUtil::removeTrailingPathSeparators(ILIAS_HTTP_PATH), $webdir);
        }
        
        // hey: prevPassSolutions - accept and prefer intermediate only from current pass
        public function getTestOutputSolutions($activeId, $pass)
        {
                // hey: refactored identifiers
                if( $this->getTestPresentationConfig()->isSolutionInitiallyPrefilled() )
                // hey.
                {
                        return $this->getSolutionValues($activeId, $pass, true);
                }
                
                return $this->getUserSolutionPreferingIntermediate($activeId, $pass);
        }
        // hey.
        
        public function getUserSolutionPreferingIntermediate($active_id, $pass = NULL)
        {
                $solution = $this->getSolutionValues($active_id, $pass, false);
                
                if( !count($solution) )
                {
                        $solution = $this->getSolutionValues($active_id, $pass, true);
                }
                
                return $solution;
        }
        
        public function getSolutionValues($active_id, $pass = NULL, $authorized = true)
        {
                global $ilDB;
                
                if (is_null($pass))
                {
                        $pass = $this->getSolutionMaxPass($active_id);
                }

                if( $this->getStep() !== NULL )
                {
                        $query = "
                                SELECT *
                                FROM tst_solutions
                                WHERE active_fi = %s
                                AND question_fi = %s
                                AND pass = %s
                                AND step = %s
                                AND authorized = %s
                                ORDER BY solution_id";
                        
                        $result = $ilDB->queryF($query, array('integer', 'integer', 'integer', 'integer', 'integer'),
                                array($active_id, $this->getId(), $pass, $this->getStep(), (int)$authorized)
                        );      
                }
                else
                {
                        $query = "
                                SELECT *
                                FROM tst_solutions
                                WHERE active_fi = %s
                                AND question_fi = %s 
                                AND pass = %s
                                AND authorized = %s
                                ORDER BY solution_id
                        ";
                        
                        $result = $ilDB->queryF($query, array('integer', 'integer', 'integer', 'integer'),
                                array($active_id, $this->getId(), $pass, (int)$authorized)
                        );
                }

                $values = array();

                while( $row = $ilDB->fetchAssoc($result) )
                {
                        $values[] = $row;
                }

                return $values;
        }

        public function isInUse($question_id = "")
        {
                global $ilDB;
                
                if ($question_id < 1) $question_id = $this->getId();
                $result = $ilDB->queryF("SELECT COUNT(qpl_questions.question_id) question_count FROM qpl_questions, tst_test_question WHERE qpl_questions.original_id = %s AND qpl_questions.question_id = tst_test_question.question_fi",
                        array('integer'),
                        array($question_id)
                );
                $row = $ilDB->fetchAssoc($result);
                $count = $row["question_count"];

                $result = $ilDB->queryF("
                        SELECT tst_active.test_fi
                        FROM qpl_questions
                        INNER JOIN tst_test_rnd_qst ON tst_test_rnd_qst.question_fi = qpl_questions.question_id
                        INNER JOIN tst_active ON tst_active.active_id = tst_test_rnd_qst.active_fi
                        WHERE qpl_questions.original_id = %s
                        GROUP BY tst_active.test_fi",
                        array('integer'),
                        array($question_id)
                );
                $count += $result->numRows();

                return $count;
        }

        function isClone($question_id = "")
        {
                global $ilDB;
                
                if ($question_id < 1) $question_id = $this->id;
                $result = $ilDB->queryF("SELECT original_id FROM qpl_questions WHERE question_id = %s",
                        array('integer'),
                        array($question_id)
                );
                $row = $ilDB->fetchAssoc($result);
                return ($row["original_id"] > 0) ? TRUE : FALSE;
        }

        function pcArrayShuffle($array)
        {
                $keys = array_keys($array);
                shuffle($keys);
                $result = array();
                foreach ($keys as $key)
                {
                        $result[$key] = $array[$key];
                }
                return $result;
        }

        public static function getQuestionTypeFromDb($question_id)
        {
                global $ilDB;

                $result = $ilDB->queryF("SELECT qpl_qst_type.type_tag FROM qpl_qst_type, qpl_questions WHERE qpl_questions.question_id = %s AND qpl_questions.question_type_fi = qpl_qst_type.question_type_id",
                        array('integer'),
                        array($question_id)
                );
                $data = $ilDB->fetchAssoc($result);
                return $data["type_tag"];
        }

        function getAdditionalTableName()
        {
                return "";
        }
        
        function getAnswerTableName()
        {
                return "";
        }

        function deleteAnswers($question_id)
        {
                global $ilDB;
                $answer_table_name = $this->getAnswerTableName();
                
                if( !is_array($answer_table_name) )
                {
                        $answer_table_name = array($answer_table_name);
                }
                
                foreach ($answer_table_name as $table)
                {
                        if (strlen($table))
                        {
                                $affectedRows = $ilDB->manipulateF("DELETE FROM $table WHERE question_fi = %s",
                                        array('integer'),
                                        array($question_id)
                                );
                        }
                }
        }

        function deleteAdditionalTableData($question_id)
        {
                global $ilDB;
                
                $additional_table_name = $this->getAdditionalTableName();
                
                if( !is_array($additional_table_name) )
                {
                        $additional_table_name = array($additional_table_name);
                }
                
                foreach ($additional_table_name as $table)
                {
                        if (strlen($table))
                        {
                                $affectedRows = $ilDB->manipulateF("DELETE FROM $table WHERE question_fi = %s",
                                        array('integer'),
                                        array($question_id)
                                );
                        }
                }
        }

        protected function deletePageOfQuestion($question_id)
        {
                include_once "./Modules/TestQuestionPool/classes/class.ilAssQuestionPage.php";
                $page = new ilAssQuestionPage($question_id);
                $page->delete();
                return true;
        }

        public function delete($question_id)
        {
                global $ilDB, $ilLog;
                
                if ($question_id < 1) return true; // nothing to do

                $result = $ilDB->queryF("SELECT obj_fi FROM qpl_questions WHERE question_id = %s",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows() == 1)
                {
                        $row = $ilDB->fetchAssoc($result);
                        $obj_id = $row["obj_fi"];
                }
                else
                {
                        return true; // nothing to do
                }
                try
                {
                        $this->deletePageOfQuestion($question_id);
                }
                catch (Exception $e)
                {
                        $ilLog->write("EXCEPTION: Could not delete page of question $question_id: $e");
                        return false;
                }
                
                $affectedRows = $ilDB->manipulateF("DELETE FROM qpl_questions WHERE question_id = %s",
                        array('integer'),
                        array($question_id)
                );
                if ($affectedRows == 0) return false;

                try
                {
                        $this->deleteAdditionalTableData($question_id);
                        $this->deleteAnswers($question_id);
                        $this->feedbackOBJ->deleteGenericFeedbacks($question_id, $this->isAdditionalContentEditingModePageObject());
                        $this->feedbackOBJ->deleteSpecificAnswerFeedbacks($question_id, $this->isAdditionalContentEditingModePageObject());
                }
                catch (Exception $e)
                {
                        $ilLog->write("EXCEPTION: Could not delete additional table data of question $question_id: $e");
                        return false;
                }

                try
                {
                        // delete the question in the tst_test_question table (list of test questions)
                        $affectedRows = $ilDB->manipulateF("DELETE FROM tst_test_question WHERE question_fi = %s", 
                                array('integer'),
                                array($question_id)
                        );
                }
                catch (Exception $e)
                {
                        $ilLog->write("EXCEPTION: Could not delete delete question $question_id from a test: $e");
                        return false;
                }

                try
                {
                        // delete suggested solutions contained in the question
                        $affectedRows = $ilDB->manipulateF("DELETE FROM qpl_sol_sug WHERE question_fi = %s", 
                                array('integer'),
                                array($question_id)
                        );
                }
                catch (Exception $e)
                {
                        $ilLog->write("EXCEPTION: Could not delete suggested solutions of question $question_id: $e");
                        return false;
                }
                                
                try
                {
                        $directory = CLIENT_WEB_DIR . "/assessment/" . $obj_id . "/$question_id";
                        if (preg_match("/\d+/", $obj_id) and preg_match("/\d+/", $question_id) and is_dir($directory))
                        {
                                include_once "./Services/Utilities/classes/class.ilUtil.php";
                                ilUtil::delDir($directory);
                        }
                }
                catch (Exception $e)
                {
                        $ilLog->write("EXCEPTION: Could not delete question file directory $directory of question $question_id: $e");
                        return false;
                }

                try
                {
                        include_once("./Services/MediaObjects/classes/class.ilObjMediaObject.php");
                        $mobs = ilObjMediaObject::_getMobsOfObject("qpl:html", $question_id);
                        // 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, "qpl:html", $question_id);
                                if (ilObjMediaObject::_exists($mob))
                                {
                                        $mob_obj = new ilObjMediaObject($mob);
                                        $mob_obj->delete();
                                }
                        }
                }
                catch (Exception $e)
                {
                        $ilLog->write("EXCEPTION: Error deleting the media objects of question $question_id: $e");
                        return false;
                }
                
                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintTracking.php';
                ilAssQuestionHintTracking::deleteRequestsByQuestionIds(array($question_id));
                
                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintList.php';
                ilAssQuestionHintList::deleteHintsByQuestionIds(array($question_id));

                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionSkillAssignmentList.php';
                $assignmentList = new ilAssQuestionSkillAssignmentList($ilDB);
                $assignmentList->setParentObjId($obj_id);
                $assignmentList->setQuestionIdFilter($question_id);
                $assignmentList->loadFromDb();
                foreach($assignmentList->getAssignmentsByQuestionId($question_id) as $assignment)
                {
                        /* @var ilAssQuestionSkillAssignment $assignment */
                        $assignment->deleteFromDb();
                }

                $this->deleteTaxonomyAssignments();
                
                try
                {
                        // update question count of question pool
                        include_once "./Modules/TestQuestionPool/classes/class.ilObjQuestionPool.php";
                        ilObjQuestionPool::_updateQuestionCount($this->getObjId());
                }
                catch (Exception $e)
                {
                        $ilLog->write("EXCEPTION: Error updating the question pool question count of question pool " . $this->getObjId() . " when deleting question $question_id: $e");
                        return false;
                }
                
                $this->notifyQuestionDeleted($this);
                
                return true;
        }
        
        private function deleteTaxonomyAssignments()
        {
                require_once 'Services/Taxonomy/classes/class.ilObjTaxonomy.php';
                require_once 'Services/Taxonomy/classes/class.ilTaxNodeAssignment.php';
                $taxIds = ilObjTaxonomy::getUsageOfObject($this->getObjId());
                
                foreach($taxIds as $taxId)
                {
                        $taxNodeAssignment = new ilTaxNodeAssignment('qpl', $this->getObjId(), 'quest', $taxId);
                        $taxNodeAssignment->deleteAssignmentsOfItem($this->getId());
                }
        }

        function getTotalAnswers()
        {
                return $this->_getTotalAnswers($this->id);
        }

        function _getTotalAnswers($a_q_id)
        {
                global $ilDB;

                // get all question references to the question id
                $result = $ilDB->queryF("SELECT question_id FROM qpl_questions WHERE original_id = %s OR question_id = %s",
                        array('integer','integer'),
                        array($a_q_id, $a_q_id)
                );
                if ($result->numRows() == 0)
                {
                        return 0;
                }
                $found_id = array();
                while ($row = $ilDB->fetchAssoc($result))
                {
                        array_push($found_id, $row["question_id"]);
                }

                $result = $ilDB->query("SELECT * FROM tst_test_result WHERE " . $ilDB->in('question_fi', $found_id, false, 'integer'));

                return $result->numRows();
        }


        public static function _getTotalRightAnswers($a_q_id)
        {
                global $ilDB;
                $result = $ilDB->queryF("SELECT question_id FROM qpl_questions WHERE original_id = %s OR question_id = %s",
                        array('integer','integer'),
                        array($a_q_id, $a_q_id)
                );
                if ($result->numRows() == 0)
                {
                        return 0;
                }
                $found_id = array();
                while ($row = $ilDB->fetchAssoc($result))
                {
                        array_push($found_id, $row["question_id"]);
                }
                $result = $ilDB->query("SELECT * FROM tst_test_result WHERE " . $ilDB->in('question_fi', $found_id, false, 'integer'));
                $answers = array();
                while ($row = $ilDB->fetchAssoc($result))
                {
                        $reached = $row["points"]; 
                        include_once "./Modules/TestQuestionPool/classes/class.assQuestion.php";
                        $max = assQuestion::_getMaximumPoints($row["question_fi"]);
                        array_push($answers, array("reached" => $reached, "max" => $max));
                }
                $max = 0.0;
                $reached = 0.0;
                foreach ($answers as $key => $value)
                {
                        $max += $value["max"];
                        $reached += $value["reached"];
                }
                if ($max > 0)
                {
                        return $reached / $max;
                }
                else
                {
                        return 0;
                }
        }

        static function _getTitle($a_q_id)
        {
                global $ilDB;
                $result = $ilDB->queryF("SELECT title FROM qpl_questions WHERE question_id = %s",
                        array('integer'),
                        array($a_q_id)
                );
                if ($result->numRows() == 1)
                {
                        $row = $ilDB->fetchAssoc($result);
                        return $row["title"];
                }
                else
                {
                        return "";
                }
        }
        
        static function _getQuestionText($a_q_id)
        {
                global $ilDB;
                $result = $ilDB->queryF("SELECT question_text FROM qpl_questions WHERE question_id = %s",
                                array('integer'),
                                array($a_q_id)
                );
                if ($result->numRows() == 1)
                {
                        $row = $ilDB->fetchAssoc($result);
                        return $row["question_text"];
                }
                else
                {
                        return "";
                }
        }
        
        public static function isFileAvailable($file)
        {
                if( !file_exists($file) )
                {
                        return false;
                }
                
                if( !is_file($file) )
                {
                        return false;
                }
                
                if( !is_readable($file) )
                {
                        return false;
                }
                
                return true;
        }
        
        function copyXHTMLMediaObjectsOfQuestion($a_q_id)
        {
                include_once("./Services/MediaObjects/classes/class.ilObjMediaObject.php");
                $mobs = ilObjMediaObject::_getMobsOfObject("qpl:html", $a_q_id);
                foreach ($mobs as $mob)
                {
                        ilObjMediaObject::_saveUsage($mob, "qpl:html", $this->getId());
                }
        }
        
        function syncXHTMLMediaObjectsOfQuestion()
        {
                include_once("./Services/MediaObjects/classes/class.ilObjMediaObject.php");
                $mobs = ilObjMediaObject::_getMobsOfObject("qpl:html", $this->getId());
                foreach ($mobs as $mob)
                {
                        ilObjMediaObject::_saveUsage($mob, "qpl:html", $this->original_id);
                }
        }
        
        function createPageObject()
        {
                $qpl_id = $this->getObjId();

                include_once "./Modules/TestQuestionPool/classes/class.ilAssQuestionPage.php";
                $this->page = new ilAssQuestionPage(0);
                $this->page->setId($this->getId());
                $this->page->setParentId($qpl_id);
                $this->page->setXMLContent("<PageObject><PageContent>".
                        "<Question QRef=\"il__qst_".$this->getId()."\"/>".
                        "</PageContent></PageObject>");
                $this->page->create();
        }

        function copyPageOfQuestion($a_q_id)
        {
                if ($a_q_id > 0)
                {
                        include_once "./Modules/TestQuestionPool/classes/class.ilAssQuestionPage.php";
                        $page = new ilAssQuestionPage($a_q_id);

                        $xml = str_replace("il__qst_".$a_q_id, "il__qst_".$this->id, $page->getXMLContent());
                        $this->page->setXMLContent($xml);
                        $this->page->updateFromXML();
                }
        }

        function getPageOfQuestion()
        {
                include_once "./Modules/TestQuestionPool/classes/class.ilAssQuestionPage.php";
                $page = new ilAssQuestionPage($this->id);
                return $page->getXMLContent();
        }

        public static function _getQuestionType($question_id)
        {
                global $ilDB;

                if ($question_id < 1) return "";
                $result = $ilDB->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",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows() == 1) 
                {
                        $data = $ilDB->fetchAssoc($result);
                        return $data["type_tag"];
                }
                else 
                {
                        return "";
                }
        }

        public static function _getQuestionTitle($question_id) 
        {
                global $ilDB;
                
                if ($question_id < 1) return "";

                $result = $ilDB->queryF("SELECT title FROM qpl_questions WHERE qpl_questions.question_id = %s",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows() == 1) 
                {
                        $data = $ilDB->fetchAssoc($result);
                        return $data["title"];
                }
                else 
                {
                        return "";
                }
        }

        function setOriginalId($original_id)
        {
                $this->original_id = $original_id;
        }
        
        function getOriginalId()
        {
                return $this->original_id;
        }
        
        protected static $imageSourceFixReplaceMap = array(
                'ok.svg' => 'ok.png', 'not_ok.svg' => 'not_ok.png',
                'checkbox_checked.svg' => 'checkbox_checked.png',
                'checkbox_unchecked.svg' => 'checkbox_unchecked.png',
                'radiobutton_checked.svg' => 'radiobutton_checked.png',
                'radiobutton_unchecked.svg' => 'radiobutton_unchecked.png'
        );
        
        public function fixSvgToPng($imageFilenameContainingString)
        {
                $needles = array_keys(self::$imageSourceFixReplaceMap);
                $replacements = array_values(self::$imageSourceFixReplaceMap);
                return str_replace($needles, $replacements, $imageFilenameContainingString);
        }
        
        
        public function fixUnavailableSkinImageSources($html)
        {
                $matches = null;
                if( preg_match_all('/src="(.*?)"/m', $html, $matches) )
                {
                        $sources = $matches[1];
                        
                        $needleReplacementMap = array();
                        
                        foreach($sources as $src)
                        {
                                $file = ilUtil::removeTrailingPathSeparators( ILIAS_ABSOLUTE_PATH ) . DIRECTORY_SEPARATOR . $src;
                                
                                if( file_exists($file) )
                                {
                                        continue;
                                }
                                
                                $levels = explode(DIRECTORY_SEPARATOR, $src);
                                if( count($levels) < 5 || $levels[0] != 'Customizing' || $levels[2] != 'skin' )
                                {
                                        continue;
                                }
                                
                                $component = '';
                                
                                if( $levels[4] == 'Modules' || $levels[4] == 'Services' )
                                {
                                        $component = $levels[4] . DIRECTORY_SEPARATOR . $levels[5];
                                }
                                
                                $needleReplacementMap[$src] = ilUtil::getImagePath(basename($src), $component);
                        }
                        
                        if( count($needleReplacementMap) )
                        {
                                $html = str_replace(array_keys($needleReplacementMap), array_values($needleReplacementMap), $html);
                        }
                }
                
                return $html;
        }

        function loadFromDb($question_id)
        {
                global $ilDB;

                $result = $ilDB->queryF(
                        "SELECT external_id FROM qpl_questions WHERE question_id = %s",
                        array("integer"),
                        array($question_id)
                );
                if($result->numRows() == 1)
                {
                        $data = $ilDB->fetchAssoc($result);
                        $this->external_id = $data['external_id'];
                }
                
                $result = $ilDB->queryF("SELECT * FROM qpl_sol_sug WHERE question_fi = %s",
                        array('integer'),
                        array($this->getId())
                );
                $this->suggested_solutions = array();
                if ($result->numRows())
                {
                        include_once("./Services/RTE/classes/class.ilRTE.php");
                        while ($row = $ilDB->fetchAssoc($result))
                        {
                                $value = (is_array(unserialize($row["value"]))) ? unserialize($row["value"]) : ilRTE::_replaceMediaObjectImageSrc($row["value"], 1);
                                $this->suggested_solutions[$row["subquestion_index"]] = array(
                                        "type" => $row["type"],
                                        "value" => $value,
                                        "internal_link" => $row["internal_link"],
                                        "import_id" => $row["import_id"]
                                );
                        }
                }
        }

        public function createNewQuestion($a_create_page = true)
        {
                global $ilDB, $ilUser;
                
                $complete = "0";
                $estw_time = $this->getEstimatedWorkingTime();
                $estw_time = sprintf("%02d:%02d:%02d", $estw_time['h'], $estw_time['m'], $estw_time['s']);
                $obj_id = ($this->getObjId() <= 0) ? (ilObject::_lookupObjId((strlen($_GET["ref_id"])) ? $_GET["ref_id"] : $_POST["sel_qpl"])) : $this->getObjId();
                if ($obj_id > 0)
                {                       
                        if($a_create_page)
                        {
                                $tstamp = 0;
                        }
                        else
                        {
                                // question pool must not try to purge
                                $tstamp = time();
                        }
                        
                        $next_id = $ilDB->nextId('qpl_questions');
                        $affectedRows = $ilDB->insert("qpl_questions", array(
                                "question_id" => array("integer", $next_id),
                                "question_type_fi" => array("integer", $this->getQuestionTypeID()),
                                "obj_fi" => array("integer", $obj_id),
                                "title" => array("text", NULL),
                                "description" => array("text", NULL),
                                "author" => array("text", $this->getAuthor()),
                                "owner" => array("integer", $ilUser->getId()),
                                "question_text" => array("clob", NULL),
                                "points" => array("float", 0),
                                "nr_of_tries" => array("integer", $this->getDefaultNrOfTries()), // #10771
                                "working_time" => array("text", $estw_time),
                                "complete" => array("text", $complete),
                                "created" => array("integer", time()),
                                "original_id" => array("integer", NULL),
                                "tstamp" => array("integer", $tstamp),
                                "external_id" => array("text", $this->getExternalId()),
                                'add_cont_edit_mode' => array('text', $this->getAdditionalContentEditingMode())
                        ));
                        $this->setId($next_id);
                        
                        if($a_create_page)
                        {
                                // create page object of question
                                $this->createPageObject();
                        }
                }
                
                $this->notifyQuestionCreated();
                
                return $this->getId();
        }

        public function saveQuestionDataToDb($original_id = "")
        {
                global $ilDB;

                $estw_time = $this->getEstimatedWorkingTime();
                $estw_time = sprintf("%02d:%02d:%02d", $estw_time['h'], $estw_time['m'], $estw_time['s']);

                // cleanup RTE images which are not inserted into the question text
                include_once("./Services/RTE/classes/class.ilRTE.php");
                if ($this->getId() == -1)
                {
                        // Neuen Datensatz schreiben
                        $next_id = $ilDB->nextId('qpl_questions');
                        $affectedRows = $ilDB->insert("qpl_questions", array(
                                "question_id" => array("integer", $next_id),
                                "question_type_fi" => array("integer", $this->getQuestionTypeID()),
                                "obj_fi" => array("integer", $this->getObjId()),
                                "title" => array("text", $this->getTitle()),
                                "description" => array("text", $this->getComment()),
                                "author" => array("text", $this->getAuthor()),
                                "owner" => array("integer", $this->getOwner()),
                                "question_text" => array("clob", ilRTE::_replaceMediaObjectImageSrc($this->getQuestion(), 0)),
                                "points" => array("float", $this->getMaximumPoints()),
                                "working_time" => array("text", $estw_time),
                                "nr_of_tries" => array("integer", $this->getNrOfTries()),
                                "created" => array("integer", time()),
                                "original_id" => array("integer", ($original_id) ? $original_id : NULL),
                                "tstamp" => array("integer", time()),
                                "external_id" => array("text", $this->getExternalId()),
                                'add_cont_edit_mode' => array('text', $this->getAdditionalContentEditingMode())
                        ));
                        $this->setId($next_id);
                        // create page object of question
                        $this->createPageObject();
                }
                else
                {
                        // Vorhandenen Datensatz aktualisieren
                        $affectedRows = $ilDB->update("qpl_questions", array(
                                "obj_fi" => array("integer", $this->getObjId()),
                                "title" => array("text", $this->getTitle()),
                                "description" => array("text", $this->getComment()),
                                "author" => array("text", $this->getAuthor()),
                                "question_text" => array("clob", ilRTE::_replaceMediaObjectImageSrc($this->getQuestion(), 0)),
                                "points" => array("float", $this->getMaximumPoints()),
                                "nr_of_tries" => array("integer", $this->getNrOfTries()),
                                "working_time" => array("text", $estw_time),
                                "tstamp" => array("integer", time()),
                                'complete' => array('integer', $this->isComplete()),
                                "external_id" => array("text", $this->getExternalId())
                        ), array(
                        "question_id" => array("integer", $this->getId())
                        ));
                }
        }

        function saveToDb($original_id = "")
        {
                global $ilDB;

                $this->updateSuggestedSolutions();
                
                // remove unused media objects from ILIAS
                $this->cleanupMediaObjectUsage();

                $complete = "0";
                if ($this->isComplete())
                {
                        $complete = "1";
                }

                        // update the question time stamp and completion status
                $affectedRows = $ilDB->manipulateF("UPDATE qpl_questions SET tstamp = %s, owner = %s, complete = %s WHERE question_id = %s",
                        array('integer','integer', 'integer','text'),
                        array(time(), ($this->getOwner() <= 0) ? $this->ilias->account->id : $this->getOwner(), $complete, $this->getId())
                );

                // update question count of question pool
                include_once "./Modules/TestQuestionPool/classes/class.ilObjQuestionPool.php";
                ilObjQuestionPool::_updateQuestionCount($this->obj_id);
                
                $this->notifyQuestionEdited($this);
        }
        
        public function setNewOriginalId($newId) {
            self::saveOriginalId($this->getId(), $newId);
        }
        
        public static function saveOriginalId($questionId, $originalId)
        {
                $query = "UPDATE qpl_questions SET tstamp = %s, original_id = %s WHERE question_id = %s";
                
                $GLOBALS['DIC']['ilDB']->manipulateF(
                        $query, array('integer','integer', 'text'), array(time(), $originalId, $questionId)
                );
        }
        
        public static function resetOriginalId($questionId)
        {
                $query = "UPDATE qpl_questions SET tstamp = %s, original_id = NULL WHERE question_id = %s";
                
                $GLOBALS['DIC']['ilDB']->manipulateF(
                        $query, array('integer', 'text'), array(time(), $questionId)
                );
        }
        
        protected function onDuplicate($originalParentId, $originalQuestionId, $duplicateParentId, $duplicateQuestionId)
        {
                $this->duplicateSuggestedSolutionFiles($originalParentId, $originalQuestionId);
                
                // duplicate question feeback
                $this->feedbackOBJ->duplicateFeedback($originalQuestionId, $duplicateQuestionId);
                
                // duplicate question hints
                $this->duplicateQuestionHints($originalQuestionId, $duplicateQuestionId);
                
                // duplicate skill assignments
                $this->duplicateSkillAssignments($originalParentId, $originalQuestionId, $duplicateParentId, $duplicateQuestionId);
        }

        protected function beforeSyncWithOriginal($origQuestionId, $dupQuestionId, $origParentObjId, $dupParentObjId)
        {
                
        }

        protected function afterSyncWithOriginal($origQuestionId, $dupQuestionId, $origParentObjId, $dupParentObjId)
        {
                // sync question feeback
                $this->feedbackOBJ->syncFeedback($origQuestionId, $dupQuestionId);
        }
        
        protected function onCopy($sourceParentId, $sourceQuestionId, $targetParentId, $targetQuestionId)
        {
                $this->copySuggestedSolutionFiles($sourceParentId, $sourceQuestionId);
                
                // duplicate question feeback
                $this->feedbackOBJ->duplicateFeedback($sourceQuestionId, $targetQuestionId);
                
                // duplicate question hints
                $this->duplicateQuestionHints($sourceQuestionId, $targetQuestionId);

                // duplicate skill assignments
                $this->duplicateSkillAssignments($sourceParentId, $sourceQuestionId, $targetParentId, $targetQuestionId);
        }
        
        public function deleteSuggestedSolutions()
        {
                global $ilDB;
                // delete the links in the qpl_sol_sug table
                $affectedRows = $ilDB->manipulateF("DELETE FROM qpl_sol_sug WHERE question_fi = %s",
                        array('integer'),
                        array($this->getId())
                );
                // delete the links in the int_link table
                include_once "./Services/Link/classes/class.ilInternalLink.php";
                ilInternalLink::_deleteAllLinksOfSource("qst", $this->getId());
                $this->suggested_solutions = array();
                ilUtil::delDir($this->getSuggestedSolutionPath());
        }
        
        function getSuggestedSolution($subquestion_index = 0)
        {
                if (array_key_exists($subquestion_index, $this->suggested_solutions))
                {
                        return $this->suggested_solutions[$subquestion_index];
                }
                else
                {
                        return array();
                }
        }

        function getSuggestedSolutionTitle($subquestion_index = 0)
        {
                if (array_key_exists($subquestion_index, $this->suggested_solutions))
                {
                        $title = $this->suggested_solutions[$subquestion_index]["internal_link"];
                        // TO DO: resolve internal link an get link type and title
                }
                else
                {
                        $title = "";
                }
                return $title;
        }

        function setSuggestedSolution($solution_id = "", $subquestion_index = 0, $is_import = false)
        {
                if (strcmp($solution_id, "") != 0)
                {
                        $import_id = "";
                        if ($is_import)
                        {
                                $import_id = $solution_id;
                                $solution_id = $this->_resolveInternalLink($import_id);
                        }
                        $this->suggested_solutions[$subquestion_index] = array(
                                "internal_link" => $solution_id,
                                "import_id" => $import_id
                        );
                }
        }

        protected function duplicateSuggestedSolutionFiles($parent_id, $question_id)
        {
                global $ilLog;

                foreach ($this->suggested_solutions as $index => $solution)
                {
                        if (strcmp($solution["type"], "file") == 0)
                        {
                                $filepath = $this->getSuggestedSolutionPath();
                                $filepath_original = str_replace(
                                        "/{$this->obj_id}/{$this->id}/solution",
                                        "/$parent_id/$question_id/solution",
                                        $filepath
                                );
                                if (!file_exists($filepath))
                                {
                                        ilUtil::makeDirParents($filepath);
                                }
                                $filename = $solution["value"]["name"];
                                if (strlen($filename))
                                {
                                        if (!copy($filepath_original . $filename, $filepath . $filename))
                                        {
                                                $ilLog->write("File could not be duplicated!!!!", $ilLog->ERROR);
                                                $ilLog->write("object: " . print_r($this, TRUE), $ilLog->ERROR);
                                        }
                                }
                        }
                }
        }

        protected function syncSuggestedSolutionFiles($original_id)
        {
                global $ilLog;

                $filepath = $this->getSuggestedSolutionPath();
                $filepath_original = str_replace("/$this->id/solution", "/$original_id/solution", $filepath);
                ilUtil::delDir($filepath_original);
                foreach ($this->suggested_solutions as $index => $solution)
                {
                        if (strcmp($solution["type"], "file") == 0)
                        {
                                if (!file_exists($filepath_original))
                                {
                                        ilUtil::makeDirParents($filepath_original);
                                }
                                $filename = $solution["value"]["name"];
                                if (strlen($filename))
                                {
                                        if (!@copy($filepath . $filename, $filepath_original . $filename))
                                        {
                                                $ilLog->write("File could not be duplicated!!!!", $ilLog->ERROR);
                                                $ilLog->write("object: " . print_r($this, TRUE), $ilLog->ERROR);
                                        }
                                }
                        }
                }
        }

        protected function copySuggestedSolutionFiles($source_questionpool_id, $source_question_id)
        {
                global $ilLog;

                foreach ($this->suggested_solutions as $index => $solution)
                {
                        if (strcmp($solution["type"], "file") == 0)
                        {
                                $filepath = $this->getSuggestedSolutionPath();
                                $filepath_original = str_replace("/$this->obj_id/$this->id/solution", "/$source_questionpool_id/$source_question_id/solution", $filepath);
                                if (!file_exists($filepath))
                                {
                                        ilUtil::makeDirParents($filepath);
                                }
                                $filename = $solution["value"]["name"];
                                if (strlen($filename))
                                {
                                        if (!copy($filepath_original . $filename, $filepath . $filename))
                                        {
                                                $ilLog->write("File could not be copied!!!!", $ilLog->ERROR);
                                                $ilLog->write("object: " . print_r($this, TRUE), $ilLog->ERROR);
                                        }
                                }
                        }
                }
        }

        public function updateSuggestedSolutions($original_id = "")
        {
                global $ilDB;

                $id = (strlen($original_id) && is_numeric($original_id)) ? $original_id : $this->getId();
                include_once "./Services/Link/classes/class.ilInternalLink.php";
                $affectedRows = $ilDB->manipulateF("DELETE FROM qpl_sol_sug WHERE question_fi = %s",
                        array('integer'),
                        array($id)
                );
                ilInternalLink::_deleteAllLinksOfSource("qst", $id);
                include_once("./Services/RTE/classes/class.ilRTE.php");
                foreach ($this->suggested_solutions as $index => $solution)
                {
                        $next_id = $ilDB->nextId('qpl_sol_sug');
                        $ilDB->insert('qpl_sol_sug', array(
                                                                                   'suggested_solution_id'      => array( 'integer',    $next_id ),
                                                                                   'question_fi'                        => array( 'integer',    $id ),
                                                                                   'type'                                       => array( 'text',               $solution['type'] ),
                                                                                   'value'                                      => array( 'clob',               ilRTE::_replaceMediaObjectImageSrc( (is_array( $solution['value'] ) ) ? serialize( $solution[ 'value' ] ) : $solution['value'], 0 ) ),
                                                                                   'internal_link'                      => array( 'text',               $solution['internal_link'] ),
                                                                                   'import_id'                          => array( 'text',               null ),
                                                                                   'subquestion_index'          => array( 'integer',    $index ),
                                                                                   'tstamp'                             => array( 'integer',    time() ),
                                                                           )
                        );
                        if (preg_match("/il_(\d*?)_(\w+)_(\d+)/", $solution["internal_link"], $matches))
                        {
                                ilInternalLink::_saveLink("qst", $id, $matches[2], $matches[3], $matches[1]);
                        }
                }
                if (strlen($original_id) && is_numeric($original_id)) $this->syncSuggestedSolutionFiles($id);
                $this->cleanupMediaObjectUsage();
        }
        
        function saveSuggestedSolution($type, $solution_id = "", $subquestion_index = 0, $value = "")
        {
                global $ilDB;

                $affectedRows = $ilDB->manipulateF("DELETE FROM qpl_sol_sug WHERE question_fi = %s AND subquestion_index = %s", 
                        array("integer", "integer"),
                        array(
                                $this->getId(), 
                                $subquestion_index
                        )
                );
                
                $next_id = $ilDB->nextId('qpl_sol_sug');
                include_once("./Services/RTE/classes/class.ilRTE.php");
                $affectedRows = $ilDB->insert('qpl_sol_sug', array(
                                                                                                           'suggested_solution_id'      => array( 'integer',    $next_id ),
                                                                                                           'question_fi'                        => array( 'integer',    $this->getId() ),
                                                                                                           'type'                                       => array( 'text',               $type ),
                                                                                                           'value'                                      => array( 'clob',               ilRTE::_replaceMediaObjectImageSrc( (is_array( $value ) ) ? serialize( $value ) : $value, 0 ) ),
                                                                                                           'internal_link'                      => array( 'text',               $solution_id ),
                                                                                                           'import_id'                          => array( 'text',               null ),
                                                                                                           'subquestion_index'          => array( 'integer',    $subquestion_index ),
                                                                                                           'tstamp'                                     => array( 'integer',    time() ),
                                                                                                   )
                );
                if ($affectedRows == 1)
                {
                        $this->suggested_solutions[$subquestion_index] = array(
                                "type" => $type,
                                "value" => $value,
                                "internal_link" => $solution_id,
                                "import_id" => ""
                        );
                }
                $this->cleanupMediaObjectUsage();
        }

        function _resolveInternalLink($internal_link)
        {
                if (preg_match("/il_(\d+)_(\w+)_(\d+)/", $internal_link, $matches))
                {
                        include_once "./Services/Link/classes/class.ilInternalLink.php";
                        include_once "./Modules/LearningModule/classes/class.ilLMObject.php";
                        include_once "./Modules/Glossary/classes/class.ilGlossaryTerm.php";
                        switch ($matches[2])
                        {
                                case "lm":
                                        $resolved_link = ilLMObject::_getIdForImportId($internal_link);
                                        break;
                                case "pg":
                                        $resolved_link = ilInternalLink::_getIdForImportId("PageObject", $internal_link);
                                        break;
                                case "st":
                                        $resolved_link = ilInternalLink::_getIdForImportId("StructureObject", $internal_link);
                                        break;
                                case "git":
                                        $resolved_link = ilInternalLink::_getIdForImportId("GlossaryItem", $internal_link);
                                        break;
                                case "mob":
                                        $resolved_link = ilInternalLink::_getIdForImportId("MediaObject", $internal_link);
                                        break;
                        }
                        if (strcmp($resolved_link, "") == 0)
                        {
                                $resolved_link = $internal_link;
                        }
                }
                else
                {
                        $resolved_link = $internal_link;
                }
                return $resolved_link;
        }
        
        function _resolveIntLinks($question_id)
        {
                global $ilDB;
                $resolvedlinks = 0;
                $result = $ilDB->queryF("SELECT * FROM qpl_sol_sug WHERE question_fi = %s",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows())
                {
                        while ($row = $ilDB->fetchAssoc($result))
                        {
                                $internal_link = $row["internal_link"];
                                include_once "./Modules/TestQuestionPool/classes/class.assQuestion.php";
                                $resolved_link = assQuestion::_resolveInternalLink($internal_link);
                                if (strcmp($internal_link, $resolved_link) != 0)
                                {
                                        // internal link was resolved successfully
                                        $affectedRows = $ilDB->manipulateF("UPDATE qpl_sol_sug SET internal_link = %s WHERE suggested_solution_id = %s",
                                                array('text','integer'),
                                                array($resolved_link, $row["suggested_solution_id"])
                                        );
                                        $resolvedlinks++;
                                }
                        }
                }
                if ($resolvedlinks)
                {
                        // there are resolved links -> reenter theses links to the database

                        // delete all internal links from the database
                        include_once "./Services/Link/classes/class.ilInternalLink.php";
                        ilInternalLink::_deleteAllLinksOfSource("qst", $question_id);

                        $result = $ilDB->queryF("SELECT * FROM qpl_sol_sug WHERE question_fi = %s",
                                array('integer'),
                                array($question_id)
                        );
                        if ($result->numRows())
                        {
                                while ($row = $ilDB->fetchAssoc($result))
                                {
                                        if (preg_match("/il_(\d*?)_(\w+)_(\d+)/", $row["internal_link"], $matches))
                                        {
                                                ilInternalLink::_saveLink("qst", $question_id, $matches[2], $matches[3], $matches[1]);
                                        }
                                }
                        }
                }
        }
        
        public static function _getInternalLinkHref($target = "")
        {
                global $ilDB;
                $linktypes = array(
                        "lm" => "LearningModule",
                        "pg" => "PageObject",
                        "st" => "StructureObject",
                        "git" => "GlossaryItem",
                        "mob" => "MediaObject"
                );
                $href = "";
                if (preg_match("/il__(\w+)_(\d+)/", $target, $matches))
                {
                        $type = $matches[1];
                        $target_id = $matches[2];
                        include_once "./Services/Utilities/classes/class.ilUtil.php";
                        switch($linktypes[$matches[1]])
                        {
                                case "LearningModule":
                                        $href = "./goto.php?target=" . $type . "_" . $target_id;
                                        break;
                                case "PageObject":
                                case "StructureObject":
                                        $href = "./goto.php?target=" . $type . "_" . $target_id;
                                        break;
                                case "GlossaryItem":
                                        $href = "./goto.php?target=" . $type . "_" . $target_id;
                                        break;
                                case "MediaObject":
                                        $href = "./ilias.php?baseClass=ilLMPresentationGUI&obj_type=" . $linktypes[$type] . "&cmd=media&ref_id=".$_GET["ref_id"]."&mob_id=".$target_id;
                                        break;
                        }
                }
                return $href;
        }
        
        public static function _getOriginalId($question_id)
        {
                global $ilDB;
                $result = $ilDB->queryF("SELECT * FROM qpl_questions WHERE question_id = %s",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows() > 0)
                {
                        $row = $ilDB->fetchAssoc($result);
                        if ($row["original_id"] > 0)
                        {
                                return $row["original_id"];
                        }
                        else
                        {
                                return $row["question_id"];
                        }
                }
                else
                {
                        return "";
                }
        }

        public static function originalQuestionExists($questionId)
        {
                global $ilDB;

                $query = "
                        SELECT COUNT(dupl.question_id) cnt
                        FROM qpl_questions dupl
                        INNER JOIN qpl_questions orig
                        ON orig.question_id = dupl.original_id
                        WHERE dupl.question_id = %s
                ";

                $res = $ilDB->queryF($query, array('integer'), array($questionId));
                $row = $ilDB->fetchAssoc($res);

                return $row['cnt'] > 0;
        }

        function syncWithOriginal()
        {
                global $ilDB;

                if( !$this->getOriginalId() )
                {
                        return;
                }
                
                $originalObjId = self::lookupOriginalParentObjId($this->getOriginalId());
                
                if ( !$originalObjId )
                {
                        return;
                }
                
                $id = $this->getId();
                $objId = $this->getObjId();
                $original = $this->getOriginalId();

                $this->beforeSyncWithOriginal($original, $id, $originalObjId, $objId);

                $this->setId($original);
                $this->setOriginalId(NULL);
                $this->setObjId($originalObjId);
                
                $this->saveToDb();
                
                $this->deletePageOfQuestion($original);
                $this->createPageObject();
                $this->copyPageOfQuestion($id);

                $this->setId($id);
                $this->setOriginalId($original);
                $this->setObjId($objId);
                
                $this->updateSuggestedSolutions($original);
                $this->syncXHTMLMediaObjectsOfQuestion();

                $this->afterSyncWithOriginal($original, $id, $originalObjId, $objId);
                $this->syncHints();
        }

        function createRandomSolution($test_id, $user_id)
        {
        }

        function _questionExists($question_id)
        {
                global $ilDB;

                if ($question_id < 1)
                {
                        return false;
                }
                
                $result = $ilDB->queryF("SELECT question_id FROM qpl_questions WHERE question_id = %s",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows() == 1)
                {
                        return true;
                }
                else
                {
                        return false;
                }
        }

        function _questionExistsInPool($question_id)
        {
                global $ilDB;

                if ($question_id < 1)
                {
                        return false;
                }

                $result = $ilDB->queryF("SELECT question_id FROM qpl_questions INNER JOIN object_data ON obj_fi = obj_id WHERE question_id = %s AND type = 'qpl'",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows() == 1)
                {
                        return true;
                }
                else
                {
                        return false;
                }
        }

        public static function _instanciateQuestion($question_id)
        {
                return self::_instantiateQuestion($question_id);
        }

        public static function _instantiateQuestion($question_id)
        {
                global $ilCtrl, $ilDB, $lng;
                
                if (strcmp($question_id, "") != 0)
                {
                        $question_type = assQuestion::_getQuestionType($question_id);
                        if (!strlen($question_type)) return null;
                        assQuestion::_includeClass($question_type);
                        $objectClassname = self::getObjectClassNameByQuestionType($question_type);
                        $question = new $objectClassname();
                        $question->loadFromDb($question_id);
                        
                        $feedbackObjectClassname = self::getFeedbackClassNameByQuestionType($question_type);
                        $question->feedbackOBJ = new $feedbackObjectClassname($question, $ilCtrl, $ilDB, $lng);
                        
                        return $question;
                }
        }
        
        function getPoints()
        {
                if (strcmp($this->points, "") == 0)
                {
                        return 0;
                }
                else
                {
                        return $this->points;
                }
        }

        
        function setPoints($a_points)
        {
                $this->points = $a_points;
        }
        
        function getSolutionMaxPass($active_id)
        {
                return self::_getSolutionMaxPass($this->getId(), $active_id);
        }

        public static function _getSolutionMaxPass($question_id, $active_id)
        {
/*              include_once "./Modules/Test/classes/class.ilObjTest.php";
                $pass = ilObjTest::_getPass($active_id);
                return $pass;*/

                // the following code was the old solution which added the non answered
                // questions of a pass from the answered questions of the previous pass
                // with the above solution, only the answered questions of the last pass are counted
                global $ilDB;

                $result = $ilDB->queryF("SELECT MAX(pass) maxpass FROM tst_test_result WHERE active_fi = %s AND question_fi = %s",
                        array('integer','integer'),
                        array($active_id, $question_id)
                );
                if ($result->numRows() == 1)
                {
                        $row = $ilDB->fetchAssoc($result);
                        return $row["maxpass"];
                }
                else
                {
                        return 0;
                }
        }

        public static function _isWriteable($question_id, $user_id)
        {
                global $ilDB;

                if (($question_id < 1) || ($user_id < 1))
                {
                        return false;
                }
                
                $result = $ilDB->queryF("SELECT obj_fi FROM qpl_questions WHERE question_id = %s",
                        array('integer'),
                        array($question_id)
                );
                if ($result->numRows() == 1)
                {
                        $row = $ilDB->fetchAssoc($result);
                        $qpl_object_id = $row["obj_fi"];
                        include_once "./Modules/TestQuestionPool/classes/class.ilObjQuestionPool.php";
                        return ilObjQuestionPool::_isWriteable($qpl_object_id, $user_id);
                }
                else
                {
                        return false;
                }
        }

        public static function _isUsedInRandomTest($question_id = "")
        {
                global $ilDB;
                
                if ($question_id < 1) return 0;
                $result = $ilDB->queryF("SELECT test_random_question_id FROM tst_test_rnd_qst WHERE question_fi = %s",
                        array('integer'),
                        array($question_id)
                );
                return $result->numRows();
        }
        
        abstract public function calculateReachedPoints($active_id, $pass = NULL, $authorizedSolution = true, $returndetails = FALSE);

        public function deductHintPointsFromReachedPoints(ilAssQuestionPreviewSession $previewSession, $reachedPoints)
        {
                global $DIC;
        
                $hintTracking = new ilAssQuestionPreviewHintTracking($DIC->database(), $previewSession);
                $requestsStatisticData = $hintTracking->getRequestStatisticData();
                $reachedPoints = $reachedPoints - $requestsStatisticData->getRequestsPoints();
                
                return $reachedPoints;
        }
        
        public function calculateReachedPointsFromPreviewSession(ilAssQuestionPreviewSession $previewSession)
        {
                $reachedPoints = $this->calculateReachedPointsForSolution($previewSession->getParticipantsSolution());
                $reachedPoints = $this->deductHintPointsFromReachedPoints($previewSession, $reachedPoints);
                
                return $this->ensureNonNegativePoints($reachedPoints);
        }
        
        protected function ensureNonNegativePoints($points)
        {
                return $points > 0 ? $points : 0;
        }
        
        public function isPreviewSolutionCorrect(ilAssQuestionPreviewSession $previewSession)
        {
                $reachedPoints = $this->calculateReachedPointsFromPreviewSession($previewSession);

                if( $reachedPoints < $this->getMaximumPoints() )
                {
                        return false;
                }
                
                return true;
        }


        final public function adjustReachedPointsByScoringOptions($points, $active_id, $pass = NULL)
        {
                include_once "./Modules/Test/classes/class.ilObjTest.php";
                $count_system = ilObjTest::_getCountSystem($active_id);
                if ($count_system == 1)
                {
                        if (abs($this->getMaximumPoints() - $points) > 0.0000000001)
                        {
                                $points = 0;
                        }
                }
                $score_cutting = ilObjTest::_getScoreCutting($active_id);
                if ($score_cutting == 0)
                {
                        if ($points < 0)
                        {
                                $points = 0;
                        }
                }
                return $points;
        }

        public static function _isWorkedThrough($active_id, $question_id, $pass = NULL)
        {
                return self::lookupResultRecordExist($active_id, $question_id, $pass);
                
                // oldschool "workedthru"

                global $ilDB;

                $points = 0;
                if (is_null($pass))
                {
                        include_once "./Modules/TestQuestionPool/classes/class.assQuestion.php";
                        $pass = assQuestion::_getSolutionMaxPass($question_id, $active_id);
                }
                $result = $ilDB->queryF("SELECT solution_id FROM tst_solutions WHERE active_fi = %s AND question_fi = %s AND pass = %s",
                        array('integer','integer','integer'),
                        array($active_id, $question_id, $pass)
                );
                if ($result->numRows())
                {
                        return TRUE;
                }
                else
                {
                        return FALSE;
                }
        }

        public static function _areAnswered($a_user_id,$a_question_ids)
        {
                global $ilDB;

                $res = $ilDB->queryF("SELECT DISTINCT(question_fi) FROM tst_test_result JOIN tst_active ".
                        "ON (active_id = active_fi) ".
                        "WHERE " . $ilDB->in('question_fi', $a_question_ids, false, 'integer') .
                        " AND user_fi = %s",
                        array('integer'),
                        array($a_user_id)
                );
                return ($res->numRows() == count($a_question_ids)) ? true : false;
        }
        
        function isHTML($a_text)
        {
                return ilUtil::isHTML($a_text);
        }
        
        function prepareTextareaOutput($txt_output, $prepare_for_latex_output = FALSE, $omitNl2BrWhenTextArea = false)
        {
                include_once "./Services/Utilities/classes/class.ilUtil.php";
                return ilUtil::prepareTextareaOutput($txt_output, $prepare_for_latex_output, $omitNl2BrWhenTextArea);
        }

        function QTIMaterialToString($a_material)
        {
                $result = "";
                for ($i = 0; $i < $a_material->getMaterialCount(); $i++)
                {
                        $material = $a_material->getMaterial($i);
                        if (strcmp($material["type"], "mattext") == 0)
                        {
                                $result .= $material["material"]->getContent();
                        }
                        if (strcmp($material["type"], "matimage") == 0)
                        {
                                $matimage = $material["material"];
                                if (preg_match("/(il_([0-9]+)_mob_([0-9]+))/", $matimage->getLabel(), $matches))
                                {
                                        // import an mediaobject which was inserted using tiny mce
                                        if (!is_array($_SESSION["import_mob_xhtml"])) $_SESSION["import_mob_xhtml"] = array();
                                        array_push($_SESSION["import_mob_xhtml"], array("mob" => $matimage->getLabel(), "uri" => $matimage->getUri()));
                                }
                        }
                }
                return $result;
        }
        
        function addQTIMaterial(&$a_xml_writer, $a_material, $close_material_tag = TRUE, $add_mobs = TRUE)
        {
                include_once "./Services/RTE/classes/class.ilRTE.php";
                include_once("./Services/MediaObjects/classes/class.ilObjMediaObject.php");

                $a_xml_writer->xmlStartTag("material");
                $attrs = array(
                        "texttype" => "text/plain"
                );
                if ($this->isHTML($a_material))
                {
                        $attrs["texttype"] = "text/xhtml";
                }
                $a_xml_writer->xmlElement("mattext", $attrs, ilRTE::_replaceMediaObjectImageSrc($a_material, 0));
                if ($add_mobs)
                {
                        $mobs = ilObjMediaObject::_getMobsOfObject("qpl:html", $this->getId());
                        foreach ($mobs as $mob)
                        {
                                $moblabel = "il_" . IL_INST_ID . "_mob_" . $mob;
                                if (strpos($a_material, "mm_$mob") !== FALSE)
                                {
                                        if (ilObjMediaObject::_exists($mob))
                                        {
                                                $mob_obj = new ilObjMediaObject($mob);
                                                $imgattrs = array(
                                                        "label" => $moblabel,
                                                        "uri" => "objects/" . "il_" . IL_INST_ID . "_mob_" . $mob . "/" . $mob_obj->getTitle()
                                                );
                                        }
                                        $a_xml_writer->xmlElement("matimage", $imgattrs, NULL);
                                }
                        }
                }               
                if ($close_material_tag) $a_xml_writer->xmlEndTag("material");
        }
        
        function buildHashedImageFilename($plain_image_filename, $unique = false)
        {
                $extension = "";
                
                if (preg_match("/.*\.(png|jpg|gif|jpeg)$/i", $plain_image_filename, $matches))
                {
                        $extension = "." . $matches[1];
                }
                
                if($unique)
                {
                        $plain_image_filename = uniqid($plain_image_filename.microtime(true));
                }
                
                $hashed_filename = md5($plain_image_filename) . $extension;
                
                return $hashed_filename;
        }

        public static function _setReachedPoints($active_id, $question_id, $points, $maxpoints, $pass, $manualscoring, $obligationsEnabled)
        {
                global $ilDB;
                
                if ($points <= $maxpoints)
                {
                        if (is_null($pass))
                        {
                                $pass = assQuestion::_getSolutionMaxPass($question_id, $active_id);
                        }

                        // retrieve the already given points
                        $old_points = 0;
                        $result = $ilDB->queryF("SELECT points FROM tst_test_result WHERE active_fi = %s AND question_fi = %s AND pass = %s",
                                array('integer','integer','integer'),
                                array($active_id, $question_id, $pass)
                        );
                        $manual = ($manualscoring) ? 1 : 0;
                        $rowsnum = $result->numRows();
                        if($rowsnum)
                        {
                                $row = $ilDB->fetchAssoc($result);
                                $old_points = $row["points"];
                                if($old_points != $points)
                                {
                                        $affectedRows = $ilDB->manipulateF("UPDATE tst_test_result SET points = %s, manual = %s, tstamp = %s WHERE active_fi = %s AND question_fi = %s AND pass = %s",
                                                array('float', 'integer', 'integer', 'integer', 'integer', 'integer'),
                                                array($points, $manual, time(), $active_id, $question_id, $pass)
                                        );
                                }
                        }
                        else
                        {
                                $next_id = $ilDB->nextId('tst_test_result');
                                $affectedRows = $ilDB->manipulateF("INSERT INTO tst_test_result (test_result_id, active_fi, question_fi, points, pass, manual, tstamp) VALUES (%s, %s, %s, %s, %s, %s, %s)",
                                        array('integer', 'integer','integer', 'float', 'integer', 'integer','integer'),
                                        array($next_id, $active_id, $question_id, $points, $pass, $manual, time())
                                );
                        }

                        if(self::isForcePassResultUpdateEnabled() || $old_points != $points || !$rowsnum)
                        {
                                assQuestion::_updateTestPassResults($active_id, $pass, $obligationsEnabled);
                                // finally update objective result
                                include_once "./Modules/Test/classes/class.ilObjTest.php";
                                include_once './Modules/Course/classes/class.ilCourseObjectiveResult.php';
                                ilCourseObjectiveResult::_updateObjectiveResult(ilObjTest::_getUserIdFromActiveId($active_id),$question_id,$points);
        
                                include_once ("./Modules/Test/classes/class.ilObjAssessmentFolder.php");
                                if (ilObjAssessmentFolder::_enabledAssessmentLogging())
                                {
                                        global $lng, $ilUser;
                                        include_once "./Modules/Test/classes/class.ilObjTestAccess.php";
                                        $username = ilObjTestAccess::_getParticipantData($active_id);
                                        assQuestion::logAction(sprintf($lng->txtlng("assessment", "log_answer_changed_points", ilObjAssessmentFolder::_getLogLanguage()), $username, $old_points, $points, $ilUser->getFullname() . " (" . $ilUser->getLogin() . ")"), $active_id, $question_id);
                                }
                        }

                        return TRUE;
                }
                else
                {
                        return FALSE;
                }
        }
        
        function getQuestion() 
        {
                return $this->question;
        }

        function setQuestion($question = "") 
        {
                $this->question = $question;
        }

        abstract public function getQuestionType();
        
        function getQuestionTypeID()
        {
                global $ilDB;
                
                $result = $ilDB->queryF("SELECT question_type_id FROM qpl_qst_type WHERE type_tag = %s",
                        array('text'),
                        array($this->getQuestionType())
                );
                if ($result->numRows() == 1)
                {
                        $row = $ilDB->fetchAssoc($result);
                        return $row["question_type_id"];
                }
                return 0;
        }

        public function syncHints()
        {
                global $ilDB;

                // delete hints of the original
                $ilDB->manipulateF("DELETE FROM qpl_hints WHERE qht_question_fi = %s",
                        array('integer'),
                        array($this->original_id)
                );

                // get hints of the actual question
                $result = $ilDB->queryF("SELECT * FROM qpl_hints WHERE qht_question_fi = %s",
                        array('integer'),
                        array($this->getId())
                );

                // save hints to the original
                if ($result->numRows())
                {
                        while ($row = $ilDB->fetchAssoc($result))
                        {
                                $next_id = $ilDB->nextId('qpl_hints');
                                $ilDB->insert('qpl_hints', array(
                                                'qht_hint_id'     => array('integer', $next_id),
                                                'qht_question_fi' => array('integer', $this->original_id),
                                                'qht_hint_index'  => array('integer', $row["qht_hint_index"]),
                                                'qht_hint_points' => array('integer', $row["qht_hint_points"]),
                                                'qht_hint_text'   => array('text', $row["qht_hint_text"]),
                                        )
                                );
                        }
                }
        }
        
        protected function getRTETextWithMediaObjects()
        {
                // must be called in parent classes. add additional RTE text in the parent
                // classes and call this method to add the standard RTE text
                $collected = $this->getQuestion();
                $collected .= $this->feedbackOBJ->getGenericFeedbackContent($this->getId(), false);
                $collected .= $this->feedbackOBJ->getGenericFeedbackContent($this->getId(), true);
                $collected .= $this->feedbackOBJ->getAllSpecificAnswerFeedbackContents($this->getId());
                
                foreach ($this->suggested_solutions as $solution_array)
                {
                        $collected .= $solution_array["value"];
                }

                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintList.php';
                $questionHintList = ilAssQuestionHintList::getListByQuestionId($this->getId());
                foreach($questionHintList as $questionHint)
                {
                        /* @var $questionHint ilAssQuestionHint */
                        $collected .= $questionHint->getText();
                }

                return $collected;
        }

        function cleanupMediaObjectUsage()
        {
                $combinedtext = $this->getRTETextWithMediaObjects();
                include_once("./Services/RTE/classes/class.ilRTE.php");
                ilRTE::_cleanupMediaObjectUsage($combinedtext, "qpl:html", $this->getId());
        }
        
        function &getInstances()
        {
                global $ilDB;

                $result = $ilDB->queryF("SELECT question_id FROM qpl_questions WHERE original_id = %s",
                        array("integer"),
                        array($this->getId())
                );
                $instances = array();
                $ids = array();
                while ($row = $ilDB->fetchAssoc($result))
                {
                        array_push($ids, $row["question_id"]);
                }
                foreach ($ids as $question_id)
                {
                        // check non random tests
                        $result = $ilDB->queryF("SELECT tst_tests.obj_fi FROM tst_tests, tst_test_question WHERE tst_test_question.question_fi = %s AND tst_test_question.test_fi = tst_tests.test_id",
                                array("integer"),
                                array($question_id)
                        );
                        while ($row = $ilDB->fetchAssoc($result))
                        {
                                $instances[$row['obj_fi']] = ilObject::_lookupTitle($row['obj_fi']);
                        }
                        // check random tests
                        $result = $ilDB->queryF("SELECT tst_tests.obj_fi FROM tst_tests, tst_test_rnd_qst, tst_active WHERE tst_test_rnd_qst.active_fi = tst_active.active_id AND tst_test_rnd_qst.question_fi = %s AND tst_tests.test_id = tst_active.test_fi",
                                array("integer"),
                                array($question_id)
                        );
                        while ($row = $ilDB->fetchAssoc($result))
                        {
                                $instances[$row['obj_fi']] = ilObject::_lookupTitle($row['obj_fi']);
                        }
                }
                include_once "./Modules/Test/classes/class.ilObjTest.php";
                foreach ($instances as $key => $value)
                {
                        $instances[$key] = array("obj_id" => $key, "title" => $value, "author" => ilObjTest::_lookupAuthor($key), "refs" => ilObject::_getAllReferences($key));
                }
                return $instances;
        }

        public static function _needsManualScoring($question_id)
        {
                include_once "./Modules/Test/classes/class.ilObjAssessmentFolder.php";
                $scoring = ilObjAssessmentFolder::_getManualScoringTypes();
                $questiontype = assQuestion::_getQuestionType($question_id);
                if (in_array($questiontype, $scoring))
                {
                        return TRUE;
                }
                else
                {
                        return FALSE;
                }
        }

        function getActiveUserData($active_id)
        {
                global $ilDB;
                $result = $ilDB->queryF("SELECT * FROM tst_active WHERE active_id = %s",
                        array('integer'),
                        array($active_id)
                );
                if ($result->numRows())
                {
                        $row = $ilDB->fetchAssoc($result);
                        return array("user_id" => $row["user_fi"], "test_id" => $row["test_fi"]);
                }
                else
                {
                        return array();
                }
        }

        static function _includeClass($question_type, $gui = 0)
        {
                if( self::isCoreQuestionType($question_type) )
                {
                        self::includeCoreClass($question_type, $gui);
                }
                else
                {
                        self::includePluginClass($question_type, $gui);
                }
        }

        public static function getGuiClassNameByQuestionType($questionType)
        {
                return $questionType.'GUI';
        }

        public static function getObjectClassNameByQuestionType($questionType)
        {
                return $questionType;
        }

        public static function getFeedbackClassNameByQuestionType($questionType)
        {
                return str_replace('ass', 'ilAss', $questionType).'Feedback';
        }

        public static function isCoreQuestionType($questionType)
        {
                $guiClassName = self::getGuiClassNameByQuestionType($questionType);
                return file_exists("Modules/TestQuestionPool/classes/class.{$guiClassName}.php");
        }

        public static function includeCoreClass($questionType, $withGuiClass)
        {
                if( $withGuiClass )
                {
                        $guiClassName = self::getGuiClassNameByQuestionType($questionType);
                        require_once "Modules/TestQuestionPool/classes/class.{$guiClassName}.php";

                        // object class is included by gui classes constructor
                }
                else
                {
                        $objectClassName = self::getObjectClassNameByQuestionType($questionType);
                        require_once "Modules/TestQuestionPool/classes/class.{$objectClassName}.php";
                }

                $feedbackClassName = self::getFeedbackClassNameByQuestionType($questionType);
                require_once "Modules/TestQuestionPool/classes/feedback/class.{$feedbackClassName}.php";
        }

        public static function includePluginClass($questionType, $withGuiClass)
        {
                global $ilPluginAdmin;

                $classes = array(
                        self::getObjectClassNameByQuestionType($questionType),
                        self::getFeedbackClassNameByQuestionType($questionType)
                );

                if( $withGuiClass )
                {
                        $classes[] = self::getGuiClassNameByQuestionType($questionType);
                }

                $pl_names = $ilPluginAdmin->getActivePluginsForSlot(IL_COMP_MODULE, "TestQuestionPool", "qst");
                foreach ($pl_names as $pl_name)
                {
                        $pl = ilPlugin::getPluginObject(IL_COMP_MODULE, "TestQuestionPool", "qst", $pl_name);
                        if (strcmp($pl->getQuestionType(), $questionType) == 0)
                        {
                                foreach($classes as $class)
                                {
                                        $pl->includeClass("class.{$class}.php");
                                }

                                break;
                        }
                }
        }

        static function _getQuestionTypeName($type_tag)
        {
                if (file_exists("./Modules/TestQuestionPool/classes/class.".$type_tag.".php"))
                {
                        global $lng;
                        return $lng->txt($type_tag);
                }
                else
                {
                        global $ilPluginAdmin;
                        $pl_names = $ilPluginAdmin->getActivePluginsForSlot(IL_COMP_MODULE, "TestQuestionPool", "qst");
                        foreach ($pl_names as $pl_name)
                        {
                                $pl = ilPlugin::getPluginObject(IL_COMP_MODULE, "TestQuestionPool", "qst", $pl_name);
                                if (strcmp($pl->getQuestionType(), $type_tag) == 0)
                                {
                                        return $pl->getQuestionTypeTranslation();
                                }
                        }
                }
                return "";
        }

        public static function &_instanciateQuestionGUI($question_id) 
        {
                return self::instantiateQuestionGUI($question_id);
        }

        public static function instantiateQuestionGUI($a_question_id)
        {
                global $ilCtrl, $ilDB, $lng, $ilUser;

                if (strcmp($a_question_id, "") != 0)
                {
                        $question_type = assQuestion::_getQuestionType($a_question_id);

                        assQuestion::_includeClass($question_type, 1);

                        $question_type_gui = self::getGuiClassNameByQuestionType($question_type);
                        $question_gui = new $question_type_gui();
                        $question_gui->object->loadFromDb($a_question_id);

                        $feedbackObjectClassname = self::getFeedbackClassNameByQuestionType($question_type);
                        $question_gui->object->feedbackOBJ = new $feedbackObjectClassname($question_gui->object, $ilCtrl, $ilDB, $lng);

                        $assSettings = new ilSetting('assessment');
                        require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionProcessLockerFactory.php';
                        $processLockerFactory = new ilAssQuestionProcessLockerFactory($assSettings, $ilDB);
                        $processLockerFactory->setQuestionId($question_gui->object->getId());
                        $processLockerFactory->setUserId($ilUser->getId());
                        include_once ("./Modules/Test/classes/class.ilObjAssessmentFolder.php");
                        $processLockerFactory->setAssessmentLogEnabled(ilObjAssessmentFolder::_enabledAssessmentLogging());
                        $question_gui->object->setProcessLocker($processLockerFactory->getLocker());
                }
                else 
                {
                        global $ilLog;
                        $ilLog->write('Instantiate question called without question id. (instantiateQuestionGUI@assQuestion)', $ilLog->WARNING);
                        return null;
                }
                return $question_gui;
        }

        public function setExportDetailsXLS($worksheet, $startrow, $active_id, $pass)
        {
                $worksheet->setFormattedExcelTitle($worksheet->getColumnCoord(0) . $startrow, $this->lng->txt($this->getQuestionType()));
                $worksheet->setFormattedExcelTitle($worksheet->getColumnCoord(1) . $startrow, $this->getTitle());

                return $startrow;
        }

        public function __get($value)
        {
                switch ($value)
                {
                        case "id":
                                return $this->getId();
                                break;
                        case "title":
                                return $this->getTitle();
                                break;
                        case "comment":
                                return $this->getComment();
                                break;
                        case "owner":
                                return $this->getOwner();
                                break;
                        case "author":
                                return $this->getAuthor();
                                break;
                        case "question":
                                return $this->getQuestion();
                                break;
                        case "points":
                                return $this->getPoints();
                                break;
                        case "est_working_time":
                                return $this->getEstimatedWorkingTime();
                                break;
                        case "shuffle":
                                return $this->getShuffle();
                                break;
                        case "test_id":
                                return $this->getTestId();
                                break;
                        case "obj_id":
                                return $this->getObjId();
                                break;
                        case "ilias":
                                return $this->ilias;
                                break;
                        case "tpl":
                                return $this->tpl;
                                break;
                        case "page":
                                return $this->page;
                                break;
                        case "outputType":
                                return $this->getOutputType();
                                break;
                        case "suggested_solutions":
                                return $this->getSuggestedSolutions();
                                break;
                        case "original_id":
                                return $this->getOriginalId();
                                break;
                        default:
                                if (array_key_exists($value, $this->arrData))
                                {
                                        return $this->arrData[$value];
                                }
                                else
                                {
                                        return null;
                                }
                                break;
                }
        }

        public function __set($key, $value)
        {
                switch ($key)
                {
                        case "id":
                                $this->setId($value);
                                break;
                        case "title":
                                $this->setTitle($value);
                                break;
                        case "comment":
                                $this->setComment($value);
                                break;
                        case "owner":
                                $this->setOwner($value);
                                break;
                        case "author":
                                $this->setAuthor($value);
                                break;
                        case "question":
                                $this->setQuestion($value);
                                break;
                        case "points":
                                $this->setPoints($value);
                                break;
                        case "est_working_time":
                                if (is_array($value))
                                {
                                        $this->setEstimatedWorkingTime($value["h"], $value["m"], $value["s"]);
                                }
                                break;
                        case "shuffle":
                                $this->setShuffle($value);
                                break;
                        case "test_id":
                                $this->setTestId($value);
                                break;
                        case "obj_id":
                                $this->setObjId($value);
                                break;
                        case "outputType":
                                $this->setOutputType($value);
                                break;
                        case "original_id":
                                $this->setOriginalId($value);
                                break;
                        case "page":
                                $this->page =& $value;
                                break;
                        default:
                                $this->arrData[$key] = $value;
                                break;
                }
        }
        
        public function getNrOfTries()
        {                       
                return (int)$this->nr_of_tries;
        }
        
        public function setNrOfTries($a_nr_of_tries)
        {
                $this->nr_of_tries = $a_nr_of_tries;
        }

        public function setExportImagePath($a_path)
        {
                $this->export_image_path = (string)$a_path;
        }

        public static function _questionExistsInTest($question_id, $test_id)
        {
                global $ilDB;

                if ($question_id < 1)
                {
                        return false;
                }

                $result = $ilDB->queryF("SELECT question_fi FROM tst_test_question WHERE question_fi = %s AND test_fi = %s",
                        array('integer', 'integer'),
                        array($question_id, $test_id)
                );
                if ($result->numRows() == 1)
                {
                        return true;
                }
                else
                {
                        return false;
                }
        }

        public function formatSAQuestion($a_q)
        {
                return $this->getSelfAssessmentFormatter()->format($a_q);
        }

        protected function getSelfAssessmentFormatter()
        {
                require_once 'Modules/TestQuestionPool/classes/questions/class.ilAssSelfAssessmentQuestionFormatter.php';
                return new \ilAssSelfAssessmentQuestionFormatter();
        }

        // scorm2004-start ???
        
        function setPreventRteUsage($a_val)
        {
                $this->prevent_rte_usage = $a_val;
        }

        function getPreventRteUsage()
        {
                return $this->prevent_rte_usage;
        }
        
        public function migrateContentForLearningModule(ilAssSelfAssessmentMigrator $migrator)
        {
                $this->lmMigrateQuestionTypeGenericContent($migrator);
                $this->lmMigrateQuestionTypeSpecificContent($migrator);
                $this->saveToDb();
                
                $this->feedbackOBJ->migrateContentForLearningModule($migrator, $this->getId());
        }
        
        protected function lmMigrateQuestionTypeGenericContent(ilAssSelfAssessmentMigrator $migrator)
        {
                $this->setQuestion( $migrator->migrateToLmContent( $this->getQuestion() ) );
        }
        
        protected function lmMigrateQuestionTypeSpecificContent(ilAssSelfAssessmentMigrator $migrator)
        {
                // overwrite if any question type specific content except feedback needs to be migrated
        }
        
        function setSelfAssessmentEditingMode($a_selfassessmenteditingmode)
        {
                $this->selfassessmenteditingmode = $a_selfassessmenteditingmode;
        }

        function getSelfAssessmentEditingMode()
        {
                return $this->selfassessmenteditingmode;
        }

        function setDefaultNrOfTries($a_defaultnroftries)
        {
                $this->defaultnroftries = $a_defaultnroftries;
        }
        
        function getDefaultNrOfTries()
        {
                return (int)$this->defaultnroftries;
        }
        
        // scorm2004-end ???

        public static function lookupParentObjId($questionId)
        {
                global $ilDB;

                $query = "SELECT obj_fi FROM qpl_questions WHERE question_id = %s";

                $res = $ilDB->queryF($query, array('integer'), array((int)$questionId));
                $row = $ilDB->fetchAssoc($res);

                return $row['obj_fi'];
        }

        public static function lookupOriginalParentObjId($originalQuestionId)
        {
                return self::lookupParentObjId($originalQuestionId);
        }

        protected function duplicateQuestionHints($originalQuestionId, $duplicateQuestionId)
        {
                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintList.php';
                $hintIds = ilAssQuestionHintList::duplicateListForQuestion($originalQuestionId, $duplicateQuestionId);
                
                if( $this->isAdditionalContentEditingModePageObject() )
                {
                        require_once 'Modules/TestQuestionPool/classes/class.ilAssHintPage.php';
                        
                        foreach($hintIds as $originalHintId => $duplicateHintId)
                        {
                                $originalPageObject = new ilAssHintPage($originalHintId);
                                $originalXML = $originalPageObject->getXMLContent();
                                
                                $duplicatePageObject = new ilAssHintPage();
                                $duplicatePageObject->setId($duplicateHintId);
                                $duplicatePageObject->setParentId($this->getId());
                                $duplicatePageObject->setXMLContent($originalXML);                              
                                $duplicatePageObject->createFromXML();
                        }
                }
        }

        protected function duplicateSkillAssignments($srcParentId, $srcQuestionId, $trgParentId, $trgQuestionId)
        {
                global $ilDB;
                
                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionSkillAssignmentList.php';
                $assignmentList = new ilAssQuestionSkillAssignmentList($ilDB);
                $assignmentList->setParentObjId($srcParentId);
                $assignmentList->setQuestionIdFilter($srcQuestionId);
                $assignmentList->loadFromDb();
                
                foreach($assignmentList->getAssignmentsByQuestionId($srcQuestionId) as $assignment)
                {
                        /* @var ilAssQuestionSkillAssignment $assignment */
                        
                        $assignment->setParentObjId($trgParentId);
                        $assignment->setQuestionId($trgQuestionId);
                        $assignment->saveToDb();
                }
        }

        public function syncSkillAssignments($srcParentId, $srcQuestionId, $trgParentId, $trgQuestionId)
        {
                global $ilDB;

                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionSkillAssignmentList.php';
                $assignmentList = new ilAssQuestionSkillAssignmentList($ilDB);
                $assignmentList->setParentObjId($trgParentId);
                $assignmentList->setQuestionIdFilter($trgQuestionId);
                $assignmentList->loadFromDb();
                
                foreach($assignmentList->getAssignmentsByQuestionId($trgQuestionId) as $assignment)
                {
                        /* @var ilAssQuestionSkillAssignment $assignment */

                        $assignment->deleteFromDb();
                }
                
                $this->duplicateSkillAssignments($srcParentId, $srcQuestionId, $trgParentId, $trgQuestionId);
        }
        
        public function isAnswered($active_id, $pass = null)
        {
                return true;            
        }
        
        public static function isObligationPossible($questionId)
        {
                return false;
        }
        
        public function isAutosaveable()
        {
                return TRUE;
        }
        
        protected static function getNumExistingSolutionRecords($activeId, $pass, $questionId)
        {
                global $ilDB;
                
                $query = "
                        SELECT          count(active_fi) cnt
                        
                        FROM            tst_solutions
                        
                        WHERE           active_fi = %s
                        AND                     question_fi = %s
                        AND                     pass = %s
                ";
                
                $res = $ilDB->queryF(
                        $query, array('integer','integer','integer'),
                        array($activeId, $questionId, $pass)
                );
                
                $row = $ilDB->fetchAssoc($res);
                
                return (int)$row['cnt'];
        }
        
        public function getAdditionalContentEditingMode()
        {
                return $this->additinalContentEditingMode;
        }
        
        public function setAdditionalContentEditingMode($additinalContentEditingMode)
        {
                if( !in_array($additinalContentEditingMode, $this->getValidAdditionalContentEditingModes()) )
                {
                        require_once 'Modules/TestQuestionPool/exceptions/class.ilTestQuestionPoolException.php';
                        throw new ilTestQuestionPoolException('invalid additional content editing mode given: '.$additinalContentEditingMode);
                }
                
                $this->additinalContentEditingMode = $additinalContentEditingMode;
        }
        
        public function isAdditionalContentEditingModePageObject()
        {
                return $this->getAdditionalContentEditingMode() == assQuestion::ADDITIONAL_CONTENT_EDITING_MODE_PAGE_OBJECT;
        }
        
        public function isValidAdditionalContentEditingMode($additionalContentEditingMode)
        {
                if( in_array($additionalContentEditingMode, $this->getValidAdditionalContentEditingModes()) )
                {
                        return true;
                }
                
                return false;
        }
        
        public function getValidAdditionalContentEditingModes()
        {
                return array(
                        self::ADDITIONAL_CONTENT_EDITING_MODE_DEFAULT,
                        self::ADDITIONAL_CONTENT_EDITING_MODE_PAGE_OBJECT
                );
        }
        
        public function addQuestionChangeListener(ilQuestionChangeListener $listener)
        {
                $this->questionChangeListeners[] = $listener;
        }
        
        public function getQuestionChangeListeners()
        {
                return $this->questionChangeListeners;
        }
        
        private function notifyQuestionCreated()
        {
                foreach($this->getQuestionChangeListeners() as $listener)
                {
                        $listener->notifyQuestionCreated($this);
                }
        }
        
        private function notifyQuestionEdited()
        {
                foreach($this->getQuestionChangeListeners() as $listener)
                {
                        $listener->notifyQuestionEdited($this);
                }
        }
        
        private function notifyQuestionDeleted()
        {
                foreach($this->getQuestionChangeListeners() as $listener)
                {
                        $listener->notifyQuestionDeleted($this);
                }
        }

        public function getHtmlUserSolutionPurifier()
        {
                require_once 'Services/Html/classes/class.ilHtmlPurifierFactory.php';
                return ilHtmlPurifierFactory::_getInstanceByType('qpl_usersolution');
        }

        public function getHtmlQuestionContentPurifier()
        {
                require_once 'Services/Html/classes/class.ilHtmlPurifierFactory.php';
                return ilHtmlPurifierFactory::_getInstanceByType('qpl_usersolution');
        }
        
        protected function buildQuestionDataQuery()
        {
                return "
                        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
                ";
        }

        public function setLastChange($lastChange)
        {
                $this->lastChange = $lastChange;
        }

        public function getLastChange()
        {
                return $this->lastChange;
        }

        protected function getCurrentSolutionResultSet($active_id, $pass, $authorized = true)
        {
                global $ilDB;

                if($this->getStep() !== NULL)
                {
                        $query = "
                                SELECT *
                                FROM tst_solutions
                                WHERE active_fi = %s
                                AND question_fi = %s
                                AND pass = %s
                                AND step = %s
                                AND authorized = %s
                        ";

                        return $ilDB->queryF($query, array('integer', 'integer', 'integer', 'integer', 'integer'),
                                array($active_id, $this->getId(), $pass, $this->getStep(), (int)$authorized)
                        );      
                }
                else
                {
                        $query = "
                                SELECT *
                                FROM tst_solutions
                                WHERE active_fi = %s
                                AND question_fi = %s
                                AND pass = %s
                                AND authorized = %s
                        ";

                        return $ilDB->queryF($query, array('integer', 'integer', 'integer', 'integer'),
                                array($active_id, $this->getId(), $pass, (int)$authorized)
                        );
                }

        }

        protected function removeSolutionRecordById($solutionId)
        {
                global $ilDB;

                return $ilDB->manipulateF("DELETE FROM tst_solutions WHERE solution_id = %s",
                        array('integer'), array($solutionId)
                );
        }
        
        // hey: prevPassSolutions - selected file reuse, copy solution records
        protected function getSolutionRecordById($solutionId)
        {
                $ilDB = isset($GLOBALS['DIC']) ? $GLOBALS['DIC']['ilDB'] : $GLOBALS['ilDB'];

                $res = $ilDB->queryF("SELECT * FROM tst_solutions WHERE solution_id = %s",
                        array('integer'), array($solutionId)
                );
                
                while($row = $ilDB->fetchAssoc($res))
                {
                        return $row;
                }
        }
        // hey.
        
        public function removeIntermediateSolution($active_id, $pass)
        {
                $this->getProcessLocker()->executeUserSolutionUpdateLockOperation(function() use ($active_id, $pass) {
                        $this->removeCurrentSolution($active_id, $pass, false);
                });
        }

        public function removeCurrentSolution($active_id, $pass, $authorized = true)
        {
                global $ilDB;

                if($this->getStep() !== NULL)
                {
                        $query = "
                                DELETE FROM tst_solutions
                                WHERE active_fi = %s
                                AND question_fi = %s
                                AND pass = %s
                                AND step = %s
                                AND authorized = %s
                        ";

                        return $ilDB->manipulateF($query, array('integer', 'integer', 'integer', 'integer', 'integer'),
                                array($active_id, $this->getId(), $pass, $this->getStep(), (int)$authorized)
                        );      
                }
                else
                {
                        $query = "
                                DELETE FROM tst_solutions
                                WHERE active_fi = %s
                                AND question_fi = %s
                                AND pass = %s
                                AND authorized = %s
                        ";

                        return $ilDB->manipulateF($query, array('integer', 'integer', 'integer', 'integer'),
                                array($active_id, $this->getId(), $pass, (int)$authorized)
                        );
                }
        }

// fau: testNav - add timestamp as parameter to saveCurrentSolution
        public function saveCurrentSolution($active_id, $pass, $value1, $value2, $authorized = true, $tstamp = null)
        {
                global $ilDB;

                $next_id = $ilDB->nextId("tst_solutions");
                
                $fieldData = array(
                        "solution_id" => array("integer", $next_id),
                        "active_fi" => array("integer", $active_id),
                        "question_fi" => array("integer", $this->getId()),
                        "value1" => array("clob", $value1),
                        "value2" => array("clob", $value2),
                        "pass" => array("integer", $pass),
                        "tstamp" => array("integer", isset($tstamp) ? $tstamp : time()),
                        'authorized' => array('integer', (int)$authorized)
                );

                if( $this->getStep() !== null )
                {
                        $fieldData['step'] = array("integer", $this->getStep());
                }

                return $ilDB->insert("tst_solutions", $fieldData);
        }
// fau.

        public function updateCurrentSolution($solutionId, $value1, $value2, $authorized = true)
        {
                global $ilDB;

                $fieldData = array(
                        "value1" => array("clob", $value1),
                        "value2" => array("clob", $value2),
                        "tstamp" => array("integer", time()),
                        'authorized' => array('integer', (int)$authorized)
                );

                if( $this->getStep() !== null )
                {
                        $fieldData['step'] = array("integer", $this->getStep());
                }

                return $ilDB->update("tst_solutions", $fieldData, array(
                        'solution_id' => array('integer', $solutionId)
                ));
        }

// fau: testNav - added parameter to keep the timestamp (default: false)
        public function updateCurrentSolutionsAuthorization($activeId, $pass, $authorized, $keepTime = false)
        {
                global $ilDB;

                $fieldData = array(
                        'authorized' => array('integer', (int)$authorized)
                );

                if (!$keepTime)
                {
                        $fieldData['tstamp'] = array('integer', time());
                }

                $whereData = array(
                        'question_fi' => array('integer', $this->getId()),
                        'active_fi' => array('integer', $activeId),
                        'pass' => array('integer', $pass)
                );

                if( $this->getStep() !== NULL )
                {
                        $whereData['step'] = array("integer", $this->getStep());
                }

                return $ilDB->update('tst_solutions', $fieldData, $whereData);
        }
        // fau.
        
        // hey: prevPassSolutions - motivation slowly decreases on imagemap
        const KEY_VALUES_IMPLOSION_SEPARATOR = ':';
        protected static function getKeyValuesImplosionSeparator()
        {
                return self::KEY_VALUES_IMPLOSION_SEPARATOR;
        }
        public static function implodeKeyValues($keyValues)
        {
                return implode(self::getKeyValuesImplosionSeparator(), $keyValues);
        }
        public static function explodeKeyValues($keyValues)
        {
                return explode(self::getKeyValuesImplosionSeparator(), $keyValues);
        }
        
        protected function deleteDummySolutionRecord($activeId, $passIndex)
        {
                foreach( $this->getSolutionValues($activeId, $passIndex, false) as $solutionRec )
                {
                        if( 0 == strlen($solutionRec['value1']) && 0 == strlen($solutionRec['value2']) )
                        {
                                $this->removeSolutionRecordById($solutionRec['solution_id']);
                        }
                }
        }
        
        protected function deleteSolutionRecordByValues($activeId, $passIndex, $authorized, $matchValues)
        {
                $ilDB = isset($GLOBALS['DIC']) ? $GLOBALS['DIC']['ilDB'] : $GLOBALS['ilDB'];
                
                $types = array("integer", "integer", "integer", "integer");
                $values = array($activeId, $this->getId(), $passIndex, (int)$authorized);
                $valuesCondition = array();
                
                foreach($matchValues as $valueField => $value)
                {
                        switch($valueField)
                        {
                                case 'value1':
                                case 'value2':
                                        $valuesCondition[] = "{$valueField} = %s";
                                        $types[] = 'text';
                                        $values[] = $value;
                                        break;
                                
                                default:
                                        require_once 'Modules/TestQuestionPool/exceptions/class.ilTestQuestionPoolException.php';
                                        throw new ilTestQuestionPoolException('invalid value field given: '.$valueField);
                        }
                }
                
                $valuesCondition = implode(' AND ', $valuesCondition);
                
                $query = "
                        DELETE FROM tst_solutions
                        WHERE active_fi = %s
                        AND question_fi = %s
                        AND pass = %s
                        AND authorized = %s
                        AND $valuesCondition
                ";
                
                if( $this->getStep() !== NULL )
                {
                        $query .= " AND step = %s ";
                        $types[] = 'integer';
                        $values[] = $this->getStep();
                }
                
                $ilDB->manipulateF($query, $types, $values);
        }
        
        protected function duplicateIntermediateSolutionAuthorized($activeId, $passIndex)
        {
                foreach($this->getSolutionValues($activeId, $passIndex, false) as $rec)
                {
                        $this->saveCurrentSolution($activeId, $passIndex, $rec['value1'], $rec['value2'], true, $rec['tstamp']);
                }
        }
        
        protected function forceExistingIntermediateSolution($activeId, $passIndex, $considerDummyRecordCreation)
        {
                $intermediateSolution = $this->getSolutionValues($activeId, $passIndex, false);
                
                if( !count($intermediateSolution) )
                {
                        // make the authorized solution intermediate (keeping timestamps)
                        // this keeps the solution_ids in synch with eventually selected in $_POST['deletefiles']
                        $this->updateCurrentSolutionsAuthorization($activeId, $passIndex, false, true);
                        
                        // create a backup as authorized solution again (keeping timestamps)
                        $this->duplicateIntermediateSolutionAuthorized($activeId, $passIndex);
                        
                        if( $considerDummyRecordCreation )
                        {
                                // create an additional dummy record to indicate the existence of an intermediate solution
                                // even if all entries are deleted from the intermediate solution later
                                $this->saveCurrentSolution($activeId, $passIndex, null, null, false, null);
                        }
                }
        }
        // hey.

        public static function setResultGateway($resultGateway)
        {
                self::$resultGateway = $resultGateway;
        }

        public static function getResultGateway()
        {
                return self::$resultGateway;
        }

        public function setStep($step)
        {
                $this->step = $step;
        }

        public function getStep()
        {
                return $this->step;
        }

        public static function sumTimesInISO8601FormatH_i_s_Extended($time1, $time2)
        {
                $time = assQuestion::convertISO8601FormatH_i_s_ExtendedToSeconds($time1) +
                                assQuestion::convertISO8601FormatH_i_s_ExtendedToSeconds($time2);
                return gmdate('H:i:s', $time);
        }

        public static function convertISO8601FormatH_i_s_ExtendedToSeconds($time)
        {
                $sec = 0;
                $time_array = explode(':',$time);
                if(     sizeof($time_array) == 3)
                {
                        $sec += $time_array[0] * 3600;
                        $sec += $time_array[1] * 60;
                        $sec += $time_array[2];
                }
                return $sec;
        }

        public function toJSON()
        {
                return json_encode(array());
        }
        
        abstract public function duplicate($for_test = true, $title = "", $author = "", $owner = "", $testObjId = null);

        // hey: prevPassSolutions - check for authorized solution
        public function intermediateSolutionExists($active_id, $pass)
        {
                $solutionAvailability = $this->lookupForExistingSolutions($active_id, $pass);
                return (bool)$solutionAvailability['intermediate'];
        }
        public function authorizedSolutionExists($active_id, $pass)
        {
                $solutionAvailability = $this->lookupForExistingSolutions($active_id, $pass);
                return (bool)$solutionAvailability['authorized'];
        }
        public function authorizedOrIntermediateSolutionExists($active_id, $pass)
        {
                $solutionAvailability = $this->lookupForExistingSolutions($active_id, $pass);
                return (bool)$solutionAvailability['authorized'] || (bool)$solutionAvailability['intermediate'];
        }
        // hey.
        
        protected function lookupMaxStep($active_id, $pass)
        {
                global $ilDB;

                $res = $ilDB->queryF(
                        "SELECT MAX(step) max_step FROM tst_solutions WHERE active_fi = %s AND pass = %s AND question_fi = %s",
                        array("integer", "integer", "integer"), array($active_id, $pass, $this->getId())
                );

                $row = $ilDB->fetchAssoc($res);

                $maxStep = $row['max_step'];

                return $maxStep;
        }
                
// fau: testNav - new function lookupForExistingSolutions
        public function lookupForExistingSolutions($activeId, $pass)
        {
                global $ilDB;

                $return = array(
                        'authorized' => false,
                        'intermediate' => false
                );

                $query = "
                        SELECT authorized, COUNT(*) cnt
                        FROM tst_solutions
                        WHERE active_fi = %s
                        AND question_fi = %s
                        AND pass = %s
                ";

                if( $this->getStep() !== NULL )
                {
                        $query .= " AND step = " . $ilDB->quote((int)$this->getStep(), 'integer') . " ";
                }

                $query .= "
                        GROUP BY authorized
                ";

                $result = $ilDB->queryF($query, array('integer', 'integer', 'integer'), array($activeId, $this->getId(), $pass));

                while ($row = $ilDB->fetchAssoc($result))
                {
                        if ($row['authorized']) {
                                $return['authorized'] = $row['cnt'] > 0;
                        }
                        else
                        {
                                $return['intermediate'] = $row['cnt'] > 0;
                        }
                }
                return $return;
        }
// fau.

        public function removeExistingSolutions($activeId, $pass)
        {
                global $ilDB;

                $query = "
                        DELETE FROM tst_solutions
                        WHERE active_fi = %s
                        AND question_fi = %s
                        AND pass = %s
                ";

                if( $this->getStep() !== NULL )
                {
                        $query .= " AND step = " . $ilDB->quote((int)$this->getStep(), 'integer') . " ";
                }

                return $ilDB->manipulateF($query, array('integer', 'integer', 'integer'),
                        array($activeId, $this->getId(), $pass)
                );
        }

        public function resetUsersAnswer($activeId, $pass)
        {
                $this->removeExistingSolutions($activeId, $pass);
                $this->removeResultRecord($activeId, $pass);

                $this->log($activeId, "log_user_solution_willingly_deleted");
                
                self::_updateTestPassResults(
                        $activeId, $pass, $this->areObligationsToBeConsidered(), $this->getProcessLocker(), $this->getTestId()
                );
        }

        public function removeResultRecord($activeId, $pass)
        {
                global $ilDB;
                
                $query = "
                        DELETE FROM tst_test_result
                        WHERE active_fi = %s
                        AND question_fi = %s
                        AND pass = %s
                ";

                if( $this->getStep() !== NULL )
                {
                        $query .= " AND step = " . $ilDB->quote((int)$this->getStep(), 'integer') . " ";
                }

                return $ilDB->manipulateF($query, array('integer', 'integer', 'integer'),
                        array($activeId, $this->getId(), $pass)
                );
        }
        
        public static function missingResultRecordExists($activeId, $pass, $questionIds)
        {
                global $ilDB;
                
                $IN_questionIds = $ilDB->in('question_fi', $questionIds, false, 'integer');
                
                $query = "
                        SELECT COUNT(*) cnt
                        FROM tst_test_result
                        WHERE active_fi = %s
                        AND pass = %s
                        AND $IN_questionIds
                ";

                $row = $ilDB->fetchAssoc($ilDB->queryF(
                        $query, array('integer', 'integer'), array($activeId, $pass)
                ));

                return $row['cnt'] < count($questionIds);
        }
        
        public static function getQuestionsMissingResultRecord($activeId, $pass, $questionIds)
        {
                global $ilDB;
                
                $IN_questionIds = $ilDB->in('question_fi', $questionIds, false, 'integer');
                
                $query = "
                        SELECT question_fi
                        FROM tst_test_result
                        WHERE active_fi = %s
                        AND pass = %s
                        AND $IN_questionIds
                ";

                $res = $ilDB->queryF(
                        $query, array('integer', 'integer'), array($activeId, $pass)
                );
                
                $questionsHavingResultRecord = array();
                
                while($row = $ilDB->fetchAssoc($res))
                {
                        $questionsHavingResultRecord[] = $row['question_fi'];
                }
                
                $questionsMissingResultRecordt = array_diff(
                        $questionIds, $questionsHavingResultRecord
                );

                return $questionsMissingResultRecordt;
        }

        public static function lookupResultRecordExist($activeId, $questionId, $pass)
        {
                global $ilDB;

                $query = "
                        SELECT COUNT(*) cnt
                        FROM tst_test_result
                        WHERE active_fi = %s
                        AND question_fi = %s
                        AND pass = %s
                ";

                $row = $ilDB->fetchAssoc($ilDB->queryF($query, array('integer', 'integer', 'integer'), array($activeId, $questionId, $pass)));

                return $row['cnt'] > 0;
        }
        
        public function fetchValuePairsFromIndexedValues(array $indexedValues)
        {
                $valuePairs = array();
                
                foreach($indexedValues as $value1 => $value2)
                {
                        $valuePairs[] = array('value1' => $value1, 'value2' => $value2);
                }
                
                return $valuePairs;
        }
        
        public function fetchIndexedValuesFromValuePairs(array $valuePairs)
        {
                $indexedValues = array();
                
                foreach($valuePairs as $valuePair)
                {
                        $indexedValues[ $valuePair['value1'] ] = $valuePair['value2'];
                }
                
                return $indexedValues;
        }

        public function areObligationsToBeConsidered()
        {
                return $this->obligationsToBeConsidered;
        }

        public function setObligationsToBeConsidered($obligationsToBeConsidered)
        {
                $this->obligationsToBeConsidered = $obligationsToBeConsidered;
        }

        public function updateTimestamp()
        {
                global $ilDB;

                $ilDB->manipulateF("UPDATE qpl_questions SET tstamp = %s  WHERE question_id = %s",
                        array('integer', 'integer'),
                        array(time(), $this->getId())
                );
        }

// fau: testNav - new function getTestQuestionConfig()
        // hey: prevPassSolutions - get caching independent from configuration (config once)
        //                                      renamed: getTestPresentationConfig() -> does the caching
        //                                      completed: extracted instance building
        //                                      avoids configuring cached instances on every access
        //                                      allows a stable reconfigure of the instance from outside
        private $testQuestionConfigInstance = null;
        
        public function getTestPresentationConfig()
        {
                if( $this->testQuestionConfigInstance === null )
                {
                        $this->testQuestionConfigInstance = $this->buildTestPresentationConfig();
                }
                
                return $this->testQuestionConfigInstance;
        }
        
        protected function buildTestPresentationConfig()
        {
                include_once('Modules/TestQuestionPool/classes/class.ilTestQuestionConfig.php');
                return new ilTestQuestionConfig();
        }
        // hey.
// fau.
}