class.ilAssQuestionFeedback.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
abstract class ilAssQuestionFeedback
{
    const CSS_CLASS_FEEDBACK_CORRECT = 'ilc_qfeedr_FeedbackRight';
    const CSS_CLASS_FEEDBACK_WRONG = 'ilc_qfeedw_FeedbackWrong';
 
    const PAGE_OBJECT_TYPE_GENERIC_FEEDBACK = 'qfbg';
 
    const PAGE_OBJECT_TYPE_SPECIFIC_FEEDBACK = 'qfbs';
 
    const FEEDBACK_SOLUTION_INCOMPLETE_PAGE_OBJECT_ID = 1;
 
    const FEEDBACK_SOLUTION_COMPLETE_PAGE_OBJECT_ID = 2;
 
    const TABLE_NAME_GENERIC_FEEDBACK = 'qpl_fb_generic';
 
    protected $questionOBJ = null;
 
    protected $ctrl = null;
 
    protected $db = null;
 
    protected $lng = null;
 
    protected $page_obj_output_mode = "presentation";
 
    final public function __construct(assQuestion $questionOBJ, ilCtrl $ctrl, ilDBInterface $db, ilLanguage $lng)
    {
        $this->questionOBJ = $questionOBJ;
 
        $this->ctrl = $ctrl;
        $this->lng = $lng;
        $this->db = $db;
    }
 
    public function getGenericFeedbackTestPresentation($questionId, $solutionCompleted)
    {
        if ($this->page_obj_output_mode == "edit") {
            return "";
        }
        if ($this->questionOBJ->isAdditionalContentEditingModePageObject()) {
            $genericFeedbackTestPresentationHTML = $this->getPageObjectContent(
                $this->getGenericFeedbackPageObjectType(),
                $this->getGenericFeedbackPageObjectId($questionId, $solutionCompleted)
            );
        } else {
            $genericFeedbackTestPresentationHTML = $this->getGenericFeedbackContent($questionId, $solutionCompleted);
        }
 
        return $genericFeedbackTestPresentationHTML;
    }
 
    abstract public function getSpecificAnswerFeedbackTestPresentation($questionId, $questionIndex, $answerIndex);
 
    final public function completeGenericFormProperties(ilPropertyFormGUI $form)
    {
        $form->addItem($this->buildFeedbackContentFormProperty(
            $this->lng->txt('feedback_complete_solution'),
            'feedback_complete',
            $this->questionOBJ->isAdditionalContentEditingModePageObject()
        ));
 
        $form->addItem($this->buildFeedbackContentFormProperty(
            $this->lng->txt('feedback_incomplete_solution'),
            'feedback_incomplete',
            $this->questionOBJ->isAdditionalContentEditingModePageObject()
        ));
    }
 
    abstract public function completeSpecificFormProperties(ilPropertyFormGUI $form);
 
    final public function initGenericFormProperties(ilPropertyFormGUI $form)
    {
        if ($this->questionOBJ->isAdditionalContentEditingModePageObject()) {
            $pageObjectType = $this->getGenericFeedbackPageObjectType();
 
            $valueFeedbackSolutionComplete = $this->getPageObjectNonEditableValueHTML(
                $pageObjectType,
                $this->getGenericFeedbackPageObjectId($this->questionOBJ->getId(), true)
            );
 
            $valueFeedbackSolutionIncomplete = $this->getPageObjectNonEditableValueHTML(
                $pageObjectType,
                $this->getGenericFeedbackPageObjectId($this->questionOBJ->getId(), false)
            );
        } else {
            $valueFeedbackSolutionComplete = $this->getGenericFeedbackContent(
                $this->questionOBJ->getId(),
                true
            );
 
            $valueFeedbackSolutionIncomplete = $this->getGenericFeedbackContent(
                $this->questionOBJ->getId(),
                false
            );
        }
 
        $form->getItemByPostVar('feedback_complete')->setValue($valueFeedbackSolutionComplete);
        $form->getItemByPostVar('feedback_incomplete')->setValue($valueFeedbackSolutionIncomplete);
    }
 
    abstract public function initSpecificFormProperties(ilPropertyFormGUI $form);
 
    final public function saveGenericFormProperties(ilPropertyFormGUI $form)
    {
        if (!$this->questionOBJ->isAdditionalContentEditingModePageObject()) {
            $this->saveGenericFeedbackContent($this->questionOBJ->getId(), false, $form->getInput('feedback_incomplete'));
            $this->saveGenericFeedbackContent($this->questionOBJ->getId(), true, $form->getInput('feedback_complete'));
        }
    }
 
    abstract public function saveSpecificFormProperties(ilPropertyFormGUI $form);
 
    public function isSaveableInPageObjectEditingMode()
    {
        return false;
    }
 
    final protected function buildFeedbackContentFormProperty($label, $postVar, $asNonEditable)
    {
        if ($asNonEditable) {
            require_once 'Services/Form/classes/class.ilNonEditableValueGUI.php';
 
            $property = new ilNonEditableValueGUI($label, $postVar, true);
        } else {
            require_once 'Services/Form/classes/class.ilTextAreaInputGUI.php';
            require_once 'Services/AdvancedEditing/classes/class.ilObjAdvancedEditing.php';
 
            $property = new ilTextAreaInputGUI($label, $postVar);
            $property->setRequired(false);
            $property->setRows(10);
            $property->setCols(80);
 
            if (!$this->questionOBJ->getPreventRteUsage()) {
                $property->setUseRte(true);
                $property->addPlugin("latex");
                $property->addButton("latex");
                $property->addButton("pastelatex");
 
                require_once 'Services/AdvancedEditing/classes/class.ilObjAdvancedEditing.php';
                $property->setRteTags(ilObjAdvancedEditing::_getUsedHTMLTags("assessment"));
                $property->setRTESupport($this->questionOBJ->getId(), "qpl", "assessment");
            } else {
                require_once 'Modules/TestQuestionPool/classes/questions/class.ilAssSelfAssessmentQuestionFormatter.php';
                $property->setRteTags(ilAssSelfAssessmentQuestionFormatter::getSelfAssessmentTags());
                $property->setUseTagsForRteOnly(false);
            }
 
            $property->setRTESupport($this->questionOBJ->getId(), "qpl", "assessment");
        }
 
        return $property;
    }
 
    final public function getGenericFeedbackContent($questionId, $solutionCompleted)
    {
        require_once 'Services/RTE/classes/class.ilRTE.php';
 
        $correctness = $solutionCompleted ? 1 : 0;
 
        $res = $this->db->queryF(
            "SELECT * FROM {$this->getGenericFeedbackTableName()} WHERE question_fi = %s AND correctness = %s",
            array('integer', 'text'),
            array($questionId, $correctness)
        );
 
        $feedbackContent = null;
 
        while ($row = $this->db->fetchAssoc($res)) {
            $feedbackContent = ilRTE::_replaceMediaObjectImageSrc($row['feedback'], 1);
            break;
        }
 
        return is_null($feedbackContent) ? '' : $this->questionOBJ->getHtmlQuestionContentPurifier()->purify($feedbackContent);
    }
 
    abstract public function getSpecificAnswerFeedbackContent($questionId, $questionIndex, $answerIndex);
 
    abstract public function getAllSpecificAnswerFeedbackContents($questionId);
 
    public function isSpecificAnswerFeedbackAvailable($questionId)
    {
        $res = $this->db->queryF(
            "SELECT answer FROM {$this->getSpecificFeedbackTableName()} WHERE question_fi = %s",
            ['integer'],
            [$questionId]
        );
 
        $allFeedbackContents = '';
 
        while ($row = $this->db->fetchAssoc($res)) {
            $allFeedbackContents .= $this->getSpecificAnswerFeedbackExportPresentation(
                $this->questionOBJ->getId(),
                0,
                $row['answer']
            );
        }
 
        return (bool) strlen(trim(strip_tags($allFeedbackContents)));
    }
 
    final public function saveGenericFeedbackContent($questionId, $solutionCompleted, $feedbackContent)
    {
        require_once 'Services/RTE/classes/class.ilRTE.php';
 
        $correctness = $solutionCompleted ? 1 : 0;
 
        $feedbackId = $this->getGenericFeedbackId($questionId, $solutionCompleted);
 
        if (strlen($feedbackContent)) {
            $feedbackContent = $this->questionOBJ->getHtmlQuestionContentPurifier()->purify($feedbackContent);
            $feedbackContent = ilRTE::_replaceMediaObjectImageSrc($feedbackContent, 0);
        }
 
        if ($feedbackId) {
            $this->db->update(
                $this->getGenericFeedbackTableName(),
                array(
                    'feedback' => array('clob', $feedbackContent),
                    'tstamp' => array('integer', time())
                ),
                array(
                    'feedback_id' => array('integer', $feedbackId)
                )
            );
        } else {
            $feedbackId = $this->db->nextId($this->getGenericFeedbackTableName());
 
            $this->db->insert($this->getGenericFeedbackTableName(), array(
                'feedback_id' => array('integer', $feedbackId),
                'question_fi' => array('integer', $questionId),
                'correctness' => array('text', $correctness), // text ?
                'feedback' => array('clob', $feedbackContent),
                'tstamp' => array('integer', time())
            ));
        }
 
        return $feedbackId;
    }
 
    abstract public function saveSpecificAnswerFeedbackContent($questionId, $questionIndex, $answerIndex, $feedbackContent);
 
    final public function deleteGenericFeedbacks($questionId, $isAdditionalContentEditingModePageObject)
    {
        if ($isAdditionalContentEditingModePageObject) {
            $this->ensurePageObjectDeleted(
                $this->getGenericFeedbackPageObjectType(),
                $this->getGenericFeedbackPageObjectId($questionId, true)
            );
 
            $this->ensurePageObjectDeleted(
                $this->getGenericFeedbackPageObjectType(),
                $this->getGenericFeedbackPageObjectId($questionId, false)
            );
        }
 
        $this->db->manipulateF(
            "DELETE FROM {$this->getGenericFeedbackTableName()} WHERE question_fi = %s",
            array('integer'),
            array($questionId)
        );
    }
 
    abstract public function deleteSpecificAnswerFeedbacks($questionId, $isAdditionalContentEditingModePageObject);
 
    final public function duplicateFeedback($originalQuestionId, $duplicateQuestionId)
    {
        $this->duplicateGenericFeedback($originalQuestionId, $duplicateQuestionId);
        $this->duplicateSpecificFeedback($originalQuestionId, $duplicateQuestionId);
    }
 
    private function duplicateGenericFeedback($originalQuestionId, $duplicateQuestionId)
    {
        $res = $this->db->queryF(
            "SELECT * FROM {$this->getGenericFeedbackTableName()} WHERE question_fi = %s",
            array('integer'),
            array($originalQuestionId)
        );
 
        while ($row = $this->db->fetchAssoc($res)) {
            $feedbackId = $this->db->nextId($this->getGenericFeedbackTableName());
 
            $this->db->insert($this->getGenericFeedbackTableName(), array(
                'feedback_id' => array('integer', $feedbackId),
                'question_fi' => array('integer', $duplicateQuestionId),
                'correctness' => array('text', $row['correctness']),
                'feedback' => array('clob', $row['feedback']),
                'tstamp' => array('integer', time())
            ));
 
            if ($this->questionOBJ->isAdditionalContentEditingModePageObject()) {
                $pageObjectType = $this->getGenericFeedbackPageObjectType();
                $this->duplicatePageObject($pageObjectType, $row['feedback_id'], $feedbackId, $duplicateQuestionId);
            }
        }
    }
 
    abstract protected function duplicateSpecificFeedback($originalQuestionId, $duplicateQuestionId);
 
    final public function syncFeedback($originalQuestionId, $duplicateQuestionId)
    {
        $this->syncGenericFeedback($originalQuestionId, $duplicateQuestionId);
        $this->syncSpecificFeedback($originalQuestionId, $duplicateQuestionId);
    }
 
    private function syncGenericFeedback($originalQuestionId, $duplicateQuestionId)
    {
        // delete generic feedback of the original question
        $this->db->manipulateF(
            "DELETE FROM {$this->getGenericFeedbackTableName()} WHERE question_fi = %s",
            array('integer'),
            array($originalQuestionId)
        );
 
        // get generic feedback of the actual (duplicated) question
        $result = $this->db->queryF(
            "SELECT * FROM {$this->getGenericFeedbackTableName()} WHERE question_fi = %s",
            array('integer'),
            array($duplicateQuestionId)
        );
 
        // save generic feedback to the original question
        while ($row = $this->db->fetchAssoc($result)) {
            $nextId = $this->db->nextId($this->getGenericFeedbackTableName());
 
            $this->db->insert($this->getGenericFeedbackTableName(), array(
                'feedback_id' => array('integer', $nextId),
                'question_fi' => array('integer', $originalQuestionId),
                'correctness' => array('text', $row['correctness']),
                'feedback' => array('clob', $row['feedback']),
                'tstamp' => array('integer', time())
            ));
        }
    }
 
    final protected function getGenericFeedbackId($questionId, $solutionCompleted)
    {
        $res = $this->db->queryF(
            "SELECT feedback_id FROM {$this->getGenericFeedbackTableName()} WHERE question_fi = %s AND correctness = %s",
            array('integer','text'),
            array($questionId, (int) $solutionCompleted)
        );
 
        $feedbackId = null;
 
        while ($row = $this->db->fetchAssoc($res)) {
            $feedbackId = $row['feedback_id'];
            break;
        }
 
        return $feedbackId;
    }
 
    protected function isGenericFeedbackId($feedbackId)
    {
        $row = $this->db->fetchAssoc($this->db->queryF(
            "SELECT COUNT(feedback_id) cnt FROM {$this->getGenericFeedbackTableName()}
                                        WHERE question_fi = %s AND feedback_id = %s",
            array('integer','integer'),
            array($this->questionOBJ->getId(), $feedbackId)
        ));
 
 
        return $row['cnt'];
    }
 
    abstract protected function isSpecificAnswerFeedbackId($feedbackId);
 
    final public function checkFeedbackParent($feedbackId)
    {
        if ($this->isGenericFeedbackId($feedbackId)) {
            return true;
        }
 
        if ($this->isSpecificAnswerFeedbackId($feedbackId)) {
            return true;
        }
 
        return false;
    }
 
    abstract protected function syncSpecificFeedback($originalQuestionId, $duplicateQuestionId);
 
    final protected function getGenericFeedbackTableName()
    {
        return self::TABLE_NAME_GENERIC_FEEDBACK;
    }
 
    final protected function getPageObjectNonEditableValueHTML($pageObjectType, $pageObjectId)
    {
        $link = $this->getPageObjectEditingLink($pageObjectType, $pageObjectId);
        $content = $this->getPageObjectContent($pageObjectType, $pageObjectId);
 
        return "$link<br /><br />$content";
    }
 
    public function getClassNameByType($a_type, $a_gui = false)
    {
        $gui = ($a_gui)
            ? "GUI"
            : "";
        include_once("./Modules/TestQuestionPool/classes/feedback/class.ilAssQuestionFeedback.php");
        if ($a_type == ilAssQuestionFeedback::PAGE_OBJECT_TYPE_GENERIC_FEEDBACK) {
            return "ilAssGenFeedbackPage" . $gui;
        }
        if ($a_type == ilAssQuestionFeedback::PAGE_OBJECT_TYPE_SPECIFIC_FEEDBACK) {
            return "ilAssSpecFeedbackPage" . $gui;
        }
    }
 
 
    private function getPageObjectEditingLink($pageObjectType, $pageObjectId)
    {
        $cl = $this->getClassNameByType($pageObjectType, true);
        $this->ctrl->setParameterByClass($cl, 'feedback_type', $pageObjectType);
        $this->ctrl->setParameterByClass($cl, 'feedback_id', $pageObjectId);
 
        $linkHREF = $this->ctrl->getLinkTargetByClass($cl, 'edit');
        $linkTEXT = $this->lng->txt('tst_question_feedback_edit_page');
 
        return "<a href='$linkHREF'>$linkTEXT</a>";
    }
 
    final public function setPageObjectOutputMode($a_val)
    {
        $this->page_obj_output_mode = $a_val;
    }
 
    final public function getPageObjectOutputMode()
    {
        return $this->page_obj_output_mode;
    }
 
    final protected function getPageObjectContent($pageObjectType, $pageObjectId)
    {
        global $DIC;
        $ilCtrl = $DIC['ilCtrl'];
 
        $cl = $this->getClassNameByType($pageObjectType, true);
        require_once 'Modules/TestQuestionPool/classes/feedback/class.' . $cl . '.php';
 
        $this->ensurePageObjectExists($pageObjectType, $pageObjectId);
 
        $mode = ($ilCtrl->isAsynch())
            ? "presentation"
            : $this->getPageObjectOutputMode();
 
        $pageObjectGUI = new $cl($pageObjectId);
        $pageObjectGUI->setOutputMode($mode);
 
        return $pageObjectGUI->presentation($mode);
    }
 
    final protected function getPageObjectXML($pageObjectType, $pageObjectId)
    {
        $cl = $this->getClassNameByType($pageObjectType);
        require_once 'Modules/TestQuestionPool/classes/feedback/class.' . $cl . '.php';
 
        $this->ensurePageObjectExists($pageObjectType, $pageObjectId);
 
        $pageObject = new $cl($pageObjectId);
        return $pageObject->getXMLContent();
    }
 
    private function ensurePageObjectExists($pageObjectType, $pageObjectId)
    {
        if ($pageObjectType == ilAssQuestionFeedback::PAGE_OBJECT_TYPE_GENERIC_FEEDBACK
            && !ilAssGenFeedbackPage::_exists($pageObjectType, $pageObjectId, '', true)) {
            $pageObject = new ilAssGenFeedbackPage();
            $pageObject->setParentId($this->questionOBJ->getId());
            $pageObject->setId($pageObjectId);
            $pageObject->createFromXML();
        }
        if ($pageObjectType == ilAssQuestionFeedback::PAGE_OBJECT_TYPE_SPECIFIC_FEEDBACK
            && !ilAssSpecFeedbackPage::_exists($pageObjectType, $pageObjectId, '', true)) {
            $pageObject = new ilAssSpecFeedbackPage();
            $pageObject->setParentId($this->questionOBJ->getId());
            $pageObject->setId($pageObjectId);
            $pageObject->createFromXML();
        }
    }
 
    final protected function createPageObject($pageObjectType, $pageObjectId, $pageObjectContent)
    {
        $cl = $this->getClassNameByType($pageObjectType);
        require_once 'Modules/TestQuestionPool/classes/feedback/class.' . $cl . '.php';
 
        $pageObject = new $cl();
        $pageObject->setParentId($this->questionOBJ->getId());
        $pageObject->setId($pageObjectId);
        $pageObject->setXMLContent($pageObjectContent);
        $pageObject->createFromXML();
    }
 
    final protected function duplicatePageObject($pageObjectType, $originalPageObjectId, $duplicatePageObjectId, $duplicatePageObjectParentId)
    {
        $this->ensurePageObjectExists($pageObjectType, $originalPageObjectId);
 
        $cl = $this->getClassNameByType($pageObjectType);
        require_once 'Modules/TestQuestionPool/classes/feedback/class.' . $cl . '.php';
 
        $pageObject = new $cl($originalPageObjectId);
        $pageObject->setParentId($duplicatePageObjectParentId);
        $pageObject->setId($duplicatePageObjectId);
        $pageObject->createFromXML();
    }
 
    final protected function ensurePageObjectDeleted($pageObjectType, $pageObjectId)
    {
        if ($pageObjectType == ilAssQuestionFeedback::PAGE_OBJECT_TYPE_GENERIC_FEEDBACK) {
            include_once("./Modules/TestQuestionPool/classes/feedback/class.ilAssGenFeedbackPage.php");
            if (ilAssGenFeedbackPage::_exists($pageObjectType, $pageObjectId)) {
                $pageObject = new ilAssGenFeedbackPage($pageObjectId);
                $pageObject->delete();
            }
        }
        if ($pageObjectType == ilAssQuestionFeedback::PAGE_OBJECT_TYPE_SPECIFIC_FEEDBACK) {
            include_once("./Modules/TestQuestionPool/classes/feedback/class.ilAssSpecFeedbackPage.php");
            if (ilAssSpecFeedbackPage::_exists($pageObjectType, $pageObjectId)) {
                $pageObject = new ilAssSpecFeedbackPage($pageObjectId);
                $pageObject->delete();
            }
        }
    }
 
    final protected function getGenericFeedbackPageObjectType()
    {
        return self::PAGE_OBJECT_TYPE_GENERIC_FEEDBACK;
    }
 
    final protected function getSpecificAnswerFeedbackPageObjectType()
    {
        return self::PAGE_OBJECT_TYPE_SPECIFIC_FEEDBACK;
    }
 
    final public static function isValidFeedbackPageObjectType($feedbackPageObjectType)
    {
        switch ($feedbackPageObjectType) {
            case self::PAGE_OBJECT_TYPE_GENERIC_FEEDBACK:
            case self::PAGE_OBJECT_TYPE_SPECIFIC_FEEDBACK:
 
                return true;
        }
 
        return false;
    }
 
    final protected function getGenericFeedbackPageObjectId($questionId, $solutionCompleted)
    {
        $pageObjectId = $this->getGenericFeedbackId($questionId, $solutionCompleted);
 
        if (!$pageObjectId) {
            $pageObjectId = $this->saveGenericFeedbackContent($questionId, $solutionCompleted, null);
        }
 
        return $pageObjectId;
    }
 
    public function getGenericFeedbackExportPresentation($questionId, $solutionCompleted)
    {
        if ($this->questionOBJ->isAdditionalContentEditingModePageObject()) {
            $genericFeedbackExportPresentation = $this->getPageObjectXML(
                $this->getGenericFeedbackPageObjectType(),
                $this->getGenericFeedbackPageObjectId($questionId, $solutionCompleted)
            );
        } else {
            $genericFeedbackExportPresentation = $this->getGenericFeedbackContent($questionId, $solutionCompleted);
        }
 
        return $genericFeedbackExportPresentation;
    }
 
    abstract public function getSpecificAnswerFeedbackExportPresentation($questionId, $questionIndex, $answerIndex);
 
    public function importGenericFeedback($questionId, $solutionCompleted, $feedbackContent)
    {
        if ($this->questionOBJ->isAdditionalContentEditingModePageObject()) {
            $pageObjectId = $this->getGenericFeedbackPageObjectId($questionId, $solutionCompleted);
            $pageObjectType = $this->getGenericFeedbackPageObjectType();
 
            $this->createPageObject($pageObjectType, $pageObjectId, $feedbackContent);
        } else {
            $this->saveGenericFeedbackContent($questionId, $solutionCompleted, $feedbackContent);
        }
    }
 
    abstract public function importSpecificAnswerFeedback($questionId, $questionIndex, $answerIndex, $feedbackContent);
 
    public function migrateContentForLearningModule(ilAssSelfAssessmentMigrator $migrator, $questionId)
    {
        $this->saveGenericFeedbackContent($questionId, true, $migrator->migrateToLmContent(
            $this->getGenericFeedbackContent($questionId, true)
        ));
 
        $this->saveGenericFeedbackContent($questionId, false, $migrator->migrateToLmContent(
            $this->getGenericFeedbackContent($questionId, false)
        ));
    }
}