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 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, ilDB $db, ilLanguage $lng)
        {
                $this->questionOBJ = $questionOBJ;
                
                $this->ctrl = $ctrl;
                $this->lng = $lng;
                $this->db = $db;
        }
        
        public function getGenericFeedbackTestPresentation($questionId, $solutionCompleted)
        {
                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, $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->questionOBJ->prepareTextareaOutput(
                                        $this->getGenericFeedbackContent($this->questionOBJ->getId(), true)
                        );
                        
                        $valueFeedbackSolutionIncomplete = $this->questionOBJ->prepareTextareaOutput(
                                        $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->setRteTags(ilObjAdvancedEditing::_getUsedHTMLTags("assessment"));
                                $property->addPlugin("latex");
                                $property->addButton("latex");
                                $property->addButton("pastelatex");
                        }
                        
                        $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 $feedbackContent;
        }

        abstract public function getSpecificAnswerFeedbackContent($questionId, $answerIndex);

        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 = 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, $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);
        }
        
        final 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);
        }
        
        final 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;
        }
        
        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";
        }
        
        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;
                }
        }
        
        
        final 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 $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();
        }
        
        final private function ensurePageObjectExists($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();
                                $pageObject->setParentId($this->questionOBJ->getId());
                                $pageObject->setId($pageObjectId);
                                $pageObject->createFromXML();
                        }
                }
                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();
                                $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)
        {
                $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, $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, $answerIndex, $feedbackContent);
}