class.ilAssQuestionHintsGUI.php

Go to the documentation of this file.

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

require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintAbstractGUI.php';
require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintGUI.php';
require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintsOrderingClipboard.php';

class ilAssQuestionHintsGUI extends ilAssQuestionHintAbstractGUI
{
        const CMD_SHOW_LIST                                                             = 'showList';
        const CMD_SHOW_HINT                                                             = 'showHint';
        const CMD_CONFIRM_DELETE                                                = 'confirmDelete';
        const CMD_PERFORM_DELETE                                                = 'performDelete';
        const CMD_SAVE_LIST_ORDER                                               = 'saveListOrder';
        const CMD_CUT_TO_ORDERING_CLIPBOARD                             = 'cutToOrderingClipboard';
        const CMD_PASTE_FROM_ORDERING_CLIPBOARD_BEFORE  = 'pasteFromOrderingClipboardBefore';
        const CMD_PASTE_FROM_ORDERING_CLIPBOARD_AFTER   = 'pasteFromOrderingClipboardAfter';
        const CMD_RESET_ORDERING_CLIPBOARD                              = 'resetOrderingClipboard';
        const CMD_CONFIRM_SYNC                                                  = 'confirmSync';
        
        private $hintOrderingClipboard = null;
        
        protected $editingEnabled = false;
        
        public function __construct(assQuestionGUI $questionGUI)
        {
                parent::__construct($questionGUI);
                
                $this->hintOrderingClipboard = new ilAssQuestionHintsOrderingClipboard($questionGUI->object);
        }
        
        public function isEditingEnabled()
        {
                return $this->editingEnabled;
        }
        
        public function setEditingEnabled(bool $editingEnabled)
        {
                $this->editingEnabled = $editingEnabled;
        }

        public function executeCommand()
        {
                global $ilCtrl, $ilTabs, $lng, $tpl;
                global $DIC; /* @var \ILIAS\DI\Container $DIC */
                $ilHelp = $DIC['ilHelp']; /* @var ilHelpGUI $ilHelp */
                $ilHelp->setScreenIdComponent('qpl');

                require_once "./Services/Style/Content/classes/class.ilObjStyleSheet.php";
                $tpl->setCurrentBlock("ContentStyle");
                $tpl->setVariable("LOCATION_CONTENT_STYLESHEET", ilObjStyleSheet::getContentStylePath(0));
                $tpl->parseCurrentBlock();
                
                $cmd = $ilCtrl->getCmd(self::CMD_SHOW_LIST);
                $nextClass = $ilCtrl->getNextClass($this);

                switch($nextClass)
                {
                        case 'ilassquestionhintgui':

                                if( !$this->isEditingEnabled() )
                                {
                                        return;
                                }
                                
                                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintGUI.php';
                                $gui = new ilAssQuestionHintGUI($this->questionGUI);
                                $ilCtrl->forwardCommand($gui);
                                break;
                                
                        case 'ilasshintpagegui':
                                
                                if( $this->isEditingEnabled() )
                                {
                                        $presentationMode = ilAssQuestionHintPageObjectCommandForwarder::PRESENTATION_MODE_AUTHOR;
                                }
                                else
                                {
                                        $presentationMode = ilAssQuestionHintPageObjectCommandForwarder::PRESENTATION_MODE_PREVIEW;
                                }
                                
                                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintPageObjectCommandForwarder.php';
                                $forwarder = new ilAssQuestionHintPageObjectCommandForwarder($this->questionOBJ, $ilCtrl, $ilTabs, $lng);
                                $forwarder->setPresentationMode($presentationMode);
                                $forwarder->forward();
                                break;

                        default:
                                
                                $cmd .= 'Cmd';
                                $this->$cmd();
                                break;
                }
        }
        
        private function showListCmd()
        {
                global $ilCtrl, $tpl, $lng;
                
                $this->initHintOrderingClipboardNotification();
                
                require_once 'Services/UIComponent/Toolbar/classes/class.ilToolbarGUI.php';
                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionHintsTableGUI.php';

                $toolbar = new ilToolbarGUI();

                $questionHintList = ilAssQuestionHintList::getListByQuestionId( $this->questionOBJ->getId() );

                if( $this->isEditingEnabled() )
                {
                        if( $this->hintOrderingClipboard->hasStored() )
                        {
                                $questionHintList = $this->getQuestionHintListWithoutHintStoredInOrderingClipboard($questionHintList);
                                
                                $toolbar->addButton(
                                        $lng->txt('tst_questions_hints_toolbar_cmd_reset_ordering_clipboard'),
                                        $ilCtrl->getLinkTarget($this, self::CMD_RESET_ORDERING_CLIPBOARD)
                                );
                        }
                        else
                        {
                                $toolbar->addButton(
                                        $lng->txt('tst_questions_hints_toolbar_cmd_add_hint'),
                                        $ilCtrl->getLinkTargetByClass('ilAssQuestionHintGUI', ilAssQuestionHintGUI::CMD_SHOW_FORM)
                                );
                        }
                        
                        $tableMode = ilAssQuestionHintsTableGUI::TBL_MODE_ADMINISTRATION;
                }
                else
                {
                        $tableMode = ilAssQuestionHintsTableGUI::TBL_MODE_TESTOUTPUT;
                }
                
                $table = new ilAssQuestionHintsTableGUI(
                                $this->questionOBJ, $questionHintList, $this, self::CMD_SHOW_LIST,
                                $tableMode, $this->hintOrderingClipboard
                );

                $tpl->setContent( $ilCtrl->getHtml($toolbar) . $ilCtrl->getHtml($table) );
        }

        private function confirmDeleteCmd()
        {
                global $ilCtrl, $tpl, $lng;
                
                $hintIds = self::fetchHintIdsParameter();

                if( !count($hintIds) )
                {
                        ilUtil::sendFailure($lng->txt('tst_question_hints_delete_hints_missing_selection_msg'), true);
                        $ilCtrl->redirect($this);
                }
                
                require_once 'Services/Utilities/classes/class.ilConfirmationGUI.php';
                $confirmation = new ilConfirmationGUI();
                
                $confirmation->setHeaderText($lng->txt('tst_question_hints_delete_hints_confirm_header'));
                $confirmation->setFormAction($ilCtrl->getFormAction($this));
                $confirmation->setConfirm($lng->txt('tst_question_hints_delete_hints_confirm_cmd'), self::CMD_PERFORM_DELETE);
                $confirmation->setCancel($lng->txt('cancel'), self::CMD_SHOW_LIST);

                $questionHintList = ilAssQuestionHintList::getListByQuestionId($this->questionOBJ->getId());
                
                foreach($questionHintList as $questionHint)
                {
                        /* @var $questionHint ilAssQuestionHint */
                        
                        if( in_array($questionHint->getId(), $hintIds) )
                        {
                                $confirmation->addItem('hint_ids[]', $questionHint->getId(), sprintf(
                                                $lng->txt('tst_question_hints_delete_hints_confirm_item'), $questionHint->getIndex(), $questionHint->getText()
                                ));
                        }
                }
                
                $tpl->setContent( $ilCtrl->getHtml($confirmation) );
        }

        private function performDeleteCmd()
        {
                if( !$this->isEditingEnabled() )
                {
                        return;
                }
                
                global $ilCtrl, $tpl, $lng;
                
                $hintIds = self::fetchHintIdsParameter();
                
                if( !count($hintIds) )
                {
                        ilUtil::sendFailure($lng->txt('tst_question_hints_delete_hints_missing_selection_msg'), true);
                        $ilCtrl->redirect($this);
                }
                
                $questionCompleteHintList = ilAssQuestionHintList::getListByQuestionId($this->questionOBJ->getId());
                
                $questionRemainingHintList = new ilAssQuestionHintList();
                
                foreach($questionCompleteHintList as $listKey => $questionHint)
                {
                        /* @var $questionHint ilAssQuestionHint */
                        
                        if( in_array($questionHint->getId(), $hintIds) )
                        {
                                $questionHint->delete();
                        }
                        else
                        {
                                $questionRemainingHintList->addHint($questionHint);
                        }
                }
                
                $questionRemainingHintList->reIndex();
                
                ilUtil::sendSuccess($lng->txt('tst_question_hints_delete_success_msg'), true);

                $originalexists = $this->questionOBJ->_questionExistsInPool($this->questionOBJ->original_id);
                include_once "./Modules/TestQuestionPool/classes/class.assQuestion.php";
                global $ilUser;
                if ($_GET["calling_test"] && $originalexists && assQuestion::_isWriteable($this->questionOBJ->original_id, $ilUser->getId()))
                {
                        $ilCtrl->redirectByClass('ilAssQuestionHintsGUI', ilAssQuestionHintsGUI::CMD_CONFIRM_SYNC);
                }
                
                $ilCtrl->redirect($this);
        }
        
        private function saveListOrderCmd()
        {
                if( !$this->isEditingEnabled() )
                {
                        return;
                }
                
                global $ilCtrl, $lng;
                
                $hintIndexes = self::orderHintIndexes(
                        self::fetchHintIndexesParameter()
                );
                
                if( !count($hintIndexes) )
                {
                        ilUtil::sendFailure($lng->txt('tst_question_hints_save_order_unkown_failure_msg'), true);
                        $ilCtrl->redirect($this);
                }
                
                $curQuestionHintList = ilAssQuestionHintList::getListByQuestionId( $this->questionOBJ->getId() );
                
                $newQuestionHintList = new ilAssQuestionHintList();
                
                foreach($hintIndexes as $hintId => $hintIndex)
                {
                        if( !$curQuestionHintList->hintExists($hintId) )
                        {
                                ilUtil::sendFailure($lng->txt('tst_question_hints_save_order_unkown_failure_msg'), true);
                                $ilCtrl->redirect($this);
                        }
                        
                        $questionHint = $curQuestionHintList->getHint($hintId);
                        
                        $newQuestionHintList->addHint($questionHint);
                }
                
                $newQuestionHintList->reIndex();
                
                ilUtil::sendSuccess($lng->txt('tst_question_hints_save_order_success_msg'), true);

                $originalexists = $this->questionOBJ->_questionExistsInPool($this->questionOBJ->original_id);
                include_once "./Modules/TestQuestionPool/classes/class.assQuestion.php";
                global $ilUser;
                if ($_GET["calling_test"] && $originalexists && assQuestion::_isWriteable($this->questionOBJ->original_id, $ilUser->getId()))
                {
                        $ilCtrl->redirectByClass('ilAssQuestionHintsGUI', ilAssQuestionHintsGUI::CMD_CONFIRM_SYNC);
                }
                
                $ilCtrl->redirect($this);
        }
        
        private function cutToOrderingClipboardCmd()
        {
                if( !$this->isEditingEnabled() )
                {
                        return;
                }
                
                global $ilCtrl;
                
                $moveHintIds = self::fetchHintIdsParameter();
                $this->checkForSingleHintIdAndRedirectOnFailure($moveHintIds);
                
                $moveHintId = current($moveHintIds);
                
                $this->checkForExistingHintRelatingToCurrentQuestionAndRedirectOnFailure($moveHintId);
                
                $this->hintOrderingClipboard->setStored($moveHintId);
                
                $ilCtrl->redirect($this, self::CMD_SHOW_LIST);
        }
        
        private function pasteFromOrderingClipboardBeforeCmd()
        {
                if( !$this->isEditingEnabled() )
                {
                        return;
                }
                
                global $ilCtrl, $lng;

                $targetHintIds = self::fetchHintIdsParameter();
                $this->checkForSingleHintIdAndRedirectOnFailure($targetHintIds);
                
                $targetHintId = current($targetHintIds);
                
                $this->checkForExistingHintRelatingToCurrentQuestionAndRedirectOnFailure($targetHintId);
                
                $curQuestionHintList = ilAssQuestionHintList::getListByQuestionId( $this->questionOBJ->getId() );
                $newQuestionHintList = new ilAssQuestionHintList( $this->questionOBJ->getId() );
                
                foreach($curQuestionHintList as $questionHint)
                {
                        /* @var $questionHint ilAssQuestionHint */

                        if( $questionHint->getId() == $this->hintOrderingClipboard->getStored() )
                        {
                                continue;
                        }
                        
                        if( $questionHint->getId() == $targetHintId )
                        {
                                $targetQuestionHint = $questionHint;

                                $pasteQuestionHint = ilAssQuestionHint::getInstanceById( $this->hintOrderingClipboard->getStored() );
                                
                                $newQuestionHintList->addHint($pasteQuestionHint);
                        }
                        
                        $newQuestionHintList->addHint($questionHint);
                }
                
                $successMsg = sprintf(
                        $lng->txt('tst_question_hints_paste_before_success_msg'),
                        $pasteQuestionHint->getIndex(), $targetQuestionHint->getIndex()
                );
                
                $newQuestionHintList->reIndex();
                
                $this->hintOrderingClipboard->resetStored();
                
                ilUtil::sendSuccess($successMsg, true);

                $ilCtrl->redirect($this, self::CMD_SHOW_LIST);
        }
        
        private function pasteFromOrderingClipboardAfterCmd()
        {
                if( !$this->isEditingEnabled() )
                {
                        return;
                }
                
                global $ilCtrl, $lng;

                $targetHintIds = self::fetchHintIdsParameter();
                $this->checkForSingleHintIdAndRedirectOnFailure($targetHintIds);
                
                $targetHintId = current($targetHintIds);
                
                $this->checkForExistingHintRelatingToCurrentQuestionAndRedirectOnFailure($targetHintId);
                
                $curQuestionHintList = ilAssQuestionHintList::getListByQuestionId( $this->questionOBJ->getId() );
                $newQuestionHintList = new ilAssQuestionHintList( $this->questionOBJ->getId() );
                
                foreach($curQuestionHintList as $questionHint)
                {
                        /* @var $questionHint ilAssQuestionHint */

                        if( $questionHint->getId() == $this->hintOrderingClipboard->getStored() )
                        {
                                continue;
                        }
                        
                        $newQuestionHintList->addHint($questionHint);
                        
                        if( $questionHint->getId() == $targetHintId )
                        {
                                $targetQuestionHint = $questionHint;
                                
                                $pasteQuestionHint = ilAssQuestionHint::getInstanceById( $this->hintOrderingClipboard->getStored() );
                                
                                $newQuestionHintList->addHint($pasteQuestionHint);
                        }
                }
                
                $successMsg = sprintf(
                        $lng->txt('tst_question_hints_paste_after_success_msg'),
                        $pasteQuestionHint->getIndex(), $targetQuestionHint->getIndex()
                );
                
                $newQuestionHintList->reIndex();

                $this->hintOrderingClipboard->resetStored();

                ilUtil::sendSuccess($successMsg, true);
                
                $ilCtrl->redirect($this, self::CMD_SHOW_LIST);
        }
        
        private function resetOrderingClipboardCmd()
        {
                global $ilCtrl, $lng;
                
                $this->hintOrderingClipboard->resetStored();
                
                ilUtil::sendInfo($lng->txt('tst_question_hints_ordering_clipboard_resetted'), true);
                $ilCtrl->redirect($this, self::CMD_SHOW_LIST);
        }
        
        private function initHintOrderingClipboardNotification()
        {
                global $lng;
                
                if( !$this->hintOrderingClipboard->hasStored() )
                {
                        return;
                }

                $questionHint = ilAssQuestionHint::getInstanceById( $this->hintOrderingClipboard->getStored() );

                ilUtil::sendInfo(sprintf(
                                $lng->txt('tst_question_hints_item_stored_in_ordering_clipboard'), $questionHint->getIndex()
                ));
        }
        
        private function checkForExistingHintRelatingToCurrentQuestionAndRedirectOnFailure($hintId)
        {
                $questionHintList = ilAssQuestionHintList::getListByQuestionId( $this->questionOBJ->getId() );
                
                if( !$questionHintList->hintExists($hintId) )
                {
                        ilUtil::sendFailure($lng->txt('tst_question_hints_invalid_hint_id'), true);
                        $ilCtrl->redirect($this, self::CMD_SHOW_LIST);
                }
        }
        
        private function getQuestionHintListWithoutHintStoredInOrderingClipboard(ilAssQuestionHintList $questionHintList)
        {
                $filteredQuestionHintList = new ilAssQuestionHintList();
                
                foreach($questionHintList as $questionHint)
                {
                        /* @var $questionHint ilAssQuestionHint */

                        if( $questionHint->getId() != $this->hintOrderingClipboard->getStored() )
                        {
                                $filteredQuestionHintList->addHint($questionHint);
                        }
                }
                
                return $filteredQuestionHintList;
        }
        
        private function checkForSingleHintIdAndRedirectOnFailure($hintIds)
        {
                global $ilCtrl, $lng;
                
                if( !count($hintIds) )
                {
                        ilUtil::sendFailure($lng->txt('tst_question_hints_cut_hints_missing_selection_msg'), true);
                        $ilCtrl->redirect($this, self::CMD_SHOW_LIST);
                }
                elseif( count($hintIds) > 1 )
                {
                        ilUtil::sendFailure($lng->txt('tst_question_hints_cut_hints_single_selection_msg'), true);
                        $ilCtrl->redirect($this, self::CMD_SHOW_LIST);
                }
        }
        
        private static function fetchHintIdsParameter()
        {
                $hintIds = array();
                
                if( isset($_POST['hint_ids']) && is_array($_POST['hint_ids']) )
                {
                        foreach($_POST['hint_ids'] as $hintId)
                        {
                                if( (int)$hintId ) $hintIds[] = (int)$hintId;
                        }
                }
                elseif( isset($_GET['hint_id']) && (int)$_GET['hint_id'] )
                {
                        $hintIds[] = (int)$_GET['hint_id'];
                }
                
                return $hintIds;
        }
        
        private static function fetchHintIndexesParameter()
        {
                $hintIndexes = array();
                
                if( isset($_POST['hint_indexes']) && is_array($_POST['hint_indexes']) )
                {
                        foreach($_POST['hint_indexes'] as $hintId => $hintIndex)
                        {
                                if( (int)$hintId ) $hintIndexes[(int)$hintId] = $hintIndex;
                        }
                }

                return $hintIndexes;
        }

        private static function orderHintIndexes($hintIndexes)
        {
                asort($hintIndexes);

                return $hintIndexes;
        }
        
        public function confirmSyncCmd()
        {
                $this->questionGUI->originalSyncForm('showHints');
        }
        
        public function getHintPresentationLinkTarget($hintId, $xmlStyle = true)
        {
                global $DIC;
                $ilCtrl = $DIC['ilCtrl'];
                
                if( $this->questionOBJ->isAdditionalContentEditingModePageObject() )
                {
                        $ilCtrl->setParameterByClass('ilasshintpagegui', 'hint_id', $hintId);
                        $linkTarget = $ilCtrl->getLinkTargetByClass('ilAssHintPageGUI', '', '', false, $xmlStyle);
                }
                else
                {
                        $ilCtrl->setParameter($this, 'hintId', $hintId);
                        $linkTarget = $ilCtrl->getLinkTarget($this, self::CMD_SHOW_HINT, '', false, $xmlStyle);
                }
                
                return $linkTarget;
        }
        
        private function showHintCmd()
        {
                global $DIC;
                $ilCtrl = $DIC['ilCtrl'];
                $tpl = $DIC['tpl'];
                $lng = $DIC['lng'];
                
                if( !isset($_GET['hintId']) || !(int)$_GET['hintId'] )
                {
                        throw new ilTestException('no hint id given');
                }
                
                $DIC->tabs()->clearTargets();
                $DIC->tabs()->clearSubTabs();
                
                $DIC->tabs()->setBackTarget(
                        $DIC->language()->txt('tst_question_hints_back_to_hint_list'), $DIC->ctrl()->getLinkTarget($this, self::CMD_SHOW_LIST)
                );
                
                $questionHint = ilAssQuestionHint::getInstanceById((int)$_GET['hintId']);
                
                // build form
                
                $form = new ilPropertyFormGUI();
                
                $form->setFormAction($ilCtrl->getFormAction($this));
                
                $form->setTableWidth('100%');
                
                $form->setTitle(sprintf(
                        $lng->txt('tst_question_hints_form_header_edit'),
                        $questionHint->getIndex(),
                        $this->questionOBJ->getTitle()
                ));

                // form input: hint text
                
                $nonEditableHintText = new ilNonEditableValueGUI($lng->txt('tst_question_hints_form_label_hint_text'), 'hint_text', true);
                $nonEditableHintText->setValue( ilUtil::prepareTextareaOutput($questionHint->getText(), true) );
                $form->addItem($nonEditableHintText);
                
                // form input: hint points
                
                $nonEditableHintPoints = new ilNonEditableValueGUI($lng->txt('tst_question_hints_form_label_hint_points'), 'hint_points');
                $nonEditableHintPoints->setValue($questionHint->getPoints());
                $form->addItem($nonEditableHintPoints);
                
                $tpl->setContent( $form->getHTML() );
        }
}