class.ilTestInfoScreenToolbarGUI.php

Go to the documentation of this file.

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

require_once 'Services/UIComponent/Toolbar/classes/class.ilToolbarGUI.php';
require_once 'Services/UIComponent/Button/classes/class.ilLinkButton.php';
require_once 'Services/UIComponent/Button/classes/class.ilSubmitButton.php';
require_once 'Services/Form/classes/class.ilFormPropertyGUI.php';
require_once 'Services/Form/classes/class.ilHiddenInputGUI.php';

class ilTestInfoScreenToolbarGUI extends ilToolbarGUI
{
        private static $TARGET_CLASS_PATH_BASE = array('ilRepositoryGUI', 'ilObjTestGUI');

        private $globalToolbar;

        protected $db;

        protected $access;

        protected $ctrl;

        protected $lng;

        protected $pluginAdmin;
        
        protected $testOBJ;

        protected $testQuestionSetConfig;

        protected $testPlayerGUI;

        protected $testSession;

        protected $testSequence;

        private $sessionLockString;

        private $infoMessages = array();
        
        private $failureMessages = array();

        public function __construct(ilDBInterface $db, ilAccessHandler $access, ilCtrl $ctrl, ilLanguage $lng, ilPluginAdmin $pluginAdmin)
        {
                $this->db = $db;
                $this->access = $access;
                $this->ctrl = $ctrl;
                $this->lng = $lng;
                $this->pluginAdmin = $pluginAdmin;
        }

        public function getGlobalToolbar()
        {
                return $this->globalToolbar;
        }

        public function setGlobalToolbar($globalToolbar)
        {
                $this->globalToolbar = $globalToolbar;
        }
        
        public function getTestOBJ()
        {
                return $this->testOBJ;
        }

        public function setTestOBJ($testOBJ)
        {
                $this->testOBJ = $testOBJ;
        }

        public function getTestQuestionSetConfig()
        {
                return $this->testQuestionSetConfig;
        }

        public function setTestQuestionSetConfig($testQuestionSetConfig)
        {
                $this->testQuestionSetConfig = $testQuestionSetConfig;
        }

        public function getTestPlayerGUI()
        {
                return $this->testPlayerGUI;
        }

        public function setTestPlayerGUI($testPlayerGUI)
        {
                $this->testPlayerGUI = $testPlayerGUI;
        }

        public function getTestSession()
        {
                return $this->testSession;
        }

        public function setTestSession($testSession)
        {
                $this->testSession = $testSession;
        }

        public function getTestSequence()
        {
                return $this->testSequence;
        }

        public function setTestSequence($testSequence)
        {
                $this->testSequence = $testSequence;
        }

        public function getSessionLockString()
        {
                return $this->sessionLockString;
        }

        public function setSessionLockString($sessionLockString)
        {
                $this->sessionLockString = $sessionLockString;
        }

        public function getInfoMessages()
        {
                return $this->infoMessages;
        }

        public function addInfoMessage($infoMessage)
        {
                $this->infoMessages[] = $infoMessage;
        }

        public function getFailureMessages()
        {
                return $this->failureMessages;
        }

        public function addFailureMessage($failureMessage)
        {
                $this->failureMessages[] = $failureMessage;
        }

        public function setFormAction($formAction, $isMultipart = false, $target = '')
        {
                if($this->globalToolbar instanceof parent)
                {
                        $this->globalToolbar->setFormAction($formAction, $isMultipart, $target);
                }
                else
                {
                        parent::setFormAction($formAction, $isMultipart, $target);
                }
        }
        
        public function addButtonInstance(ilButtonBase $btnInstance)
        {
                if($this->globalToolbar instanceof parent)
                {
                        $this->globalToolbar->addButtonInstance($btnInstance);
                }
                else
                {
                        parent::addButtonInstance($btnInstance);
                }
        }
        
        public function setCloseFormTag($enabled)
        {
                if($this->globalToolbar instanceof parent)
                {
                        $this->globalToolbar->setCloseFormTag($enabled);
                }
                else
                {
                        parent::setCloseFormTag($enabled);
                }
        }
        
        public function addInputItem(ilToolbarItem $inputItem, $outputLabel = false)
        {
                if($this->globalToolbar instanceof parent)
                {
                        $this->globalToolbar->addInputItem($inputItem, $outputLabel);
                }
                else
                {
                        parent::addInputItem($inputItem, $outputLabel);
                }
        }
        
        public function addFormInput($formInput)
        {
                if($this->globalToolbar instanceof parent)
                {
                        $this->globalToolbar->addFormInput($formInput);
                }
                else
                {
                        parent::addFormInput($formInput);
                }
        }
        
        public function clearItems()
        {
                if($this->globalToolbar instanceof parent)
                {
                        $this->globalToolbar->setItems(array());
                }
                else
                {
                        $this->setItems(array());
                }
        }
        
        private function getClassName($target)
        {
                if( is_object($target) )
                {
                        $target = get_class($target);
                }
                
                return $target;
        }

        private function getClassNameArray($target)
        {
                if( is_array($target) )
                {
                        return $target;
                }
                
                return array($this->getClassName($target));
        }

        private function getClassPath($target)
        {
                return array_merge(self::$TARGET_CLASS_PATH_BASE, $this->getClassNameArray($target));
        }
        
        private function setParameter($target, $parameter, $value)
        {
                $this->ctrl->setParameterByClass($this->getClassName($target), $parameter, $value);
        }
        
        private function buildLinkTarget($target, $cmd = null)
        {
                return $this->ctrl->getLinkTargetByClass($this->getClassPath($target), $cmd);
        }
        
        private function buildFormAction($target)
        {
                return $this->ctrl->getFormActionByClass($this->getClassPath($target));
        }

        private function ensureInitialisedSessionLockString()
        {
                if( !strlen($this->getSessionLockString()) )
                {
                        $this->setSessionLockString($this->buildSessionLockString());
                }
        }

        private function buildSessionLockString()
        {
                return md5($_COOKIE['PHPSESSID'] . time());
        }

        private function isDeleteDynamicTestResultsButtonRequired()
        {
                if( !$this->getTestSession()->getActiveId() )
                {
                        return false;
                }

                if( !$this->getTestOBJ()->isDynamicTest() )
                {
                        return false;
                }

                if( !$this->getTestOBJ()->isPassDeletionAllowed() )
                {
                        return false;
                }

                if( !$this->getTestSequence()->hasStarted($this->getTestSession()) )
                {
                        return false;
                }

                return true;
        }

        private function populateDeleteDynamicTestResultsButton()
        {
                require_once 'Modules/Test/classes/confirmations/class.ilTestPassDeletionConfirmationGUI.php';

                $this->ctrl->setParameterByClass(
                        'iltestevaluationgui', 'context', ilTestPassDeletionConfirmationGUI::CONTEXT_INFO_SCREEN
                );

                $this->setParameter('iltestevaluationgui', 'active_id', $this->getTestSession()->getActiveId());
                $this->setParameter('iltestevaluationgui', 'pass', $this->getTestSession()->getPass());

                $btn = ilLinkButton::getInstance();
                $btn->setCaption('tst_delete_dyn_test_results_btn');
                $btn->setUrl($this->buildLinkTarget('iltestevaluationgui',  'confirmDeletePass'));
                $btn->setPrimary(false);
                
                $this->addButtonInstance($btn);
        }

        private function areSkillLevelThresholdsMissing()
        {
                if( !$this->getTestOBJ()->isSkillServiceEnabled() )
                {
                        return false;
                }

                if( $this->getTestOBJ()->isDynamicTest() )
                {
                        $questionSetConfig = $this->getTestQuestionSetConfig();
                        $questionContainerId = $questionSetConfig->getSourceQuestionPoolId();
                }
                else
                {
                        $questionContainerId = $this->getTestOBJ()->getId();
                }

                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionSkillAssignmentList.php';
                require_once 'Modules/Test/classes/class.ilTestSkillLevelThreshold.php';

                $assignmentList = new ilAssQuestionSkillAssignmentList($this->db);
                $assignmentList->setParentObjId($questionContainerId);
                $assignmentList->loadFromDb();

                foreach($assignmentList->getUniqueAssignedSkills() as $data)
                {
                        foreach($data['skill']->getLevelData() as $level)
                        {
                                $treshold = new ilTestSkillLevelThreshold($this->db);
                                $treshold->setTestId($this->getTestOBJ()->getTestId());
                                $treshold->setSkillBaseId($data['skill_base_id']);
                                $treshold->setSkillTrefId($data['skill_tref_id']);
                                $treshold->setSkillLevelId($level['id']);

                                if( !$treshold->dbRecordExists() )
                                {
                                        return true;
                                }
                        }
                }

                return false;
        }

        private function getSkillLevelThresholdsMissingInfo()
        {
                require_once 'Modules/Test/classes/class.ilTestSkillLevelThresholdsGUI.php';

                $link = $this->buildLinkTarget(
                        array('ilTestSkillAdministrationGUI', 'ilTestSkillLevelThresholdsGUI'),
                        ilTestSkillLevelThresholdsGUI::CMD_SHOW_SKILL_THRESHOLDS
                );

                $msg = $this->lng->txt('tst_skl_level_thresholds_missing');
                $msg .= '<br /><a href="'.$link.'">'.$this->lng->txt('tst_skl_level_thresholds_link').'</a>';

                return $msg;
        }
        
        private function hasFixedQuestionSetSkillAssignsLowerThanBarrier()
        {
                if( !$this->testOBJ->isFixedTest() )
                {
                        return false;
                }
                
                require_once 'Modules/TestQuestionPool/classes/class.ilAssQuestionSkillAssignmentList.php';
                $assignmentList = new ilAssQuestionSkillAssignmentList($this->db);
                $assignmentList->setParentObjId($this->testOBJ->getId());
                $assignmentList->loadFromDb();
                
                return $assignmentList->hasSkillsAssignedLowerThanBarrier();
        }
        
        private function getSkillAssignBarrierInfo()
        {
                require_once 'Modules/Test/classes/class.ilObjAssessmentFolder.php';
                
                return sprintf( $this->lng->txt('tst_skill_triggerings_num_req_answers_not_reached_warn'),
                        ilObjAssessmentFolder::getSkillTriggerAnswerNumberBarrier()
                );
        }

        public function build()
        {
                $this->ensureInitialisedSessionLockString();
                
                $this->setParameter($this->getTestPlayerGUI(), 'lock', $this->getSessionLockString());
                $this->setParameter($this->getTestPlayerGUI(), 'sequence', $this->getTestSession()->getLastSequence());
                $this->setParameter('ilObjTestGUI', 'ref_id', $this->getTestOBJ()->getRefId());
                
                $this->setFormAction($this->buildFormAction($this->testPlayerGUI));
                
                $online_access = false;
                if ($this->getTestOBJ()->getFixedParticipants())
                {
                        include_once "./Modules/Test/classes/class.ilObjTestAccess.php";
                        $online_access_result = ilObjTestAccess::_lookupOnlineTestAccess($this->getTestOBJ()->getId(), $this->getTestSession()->getUserId());
                        if ($online_access_result === true)
                        {
                                $online_access = true;
                        }
                        else
                        {
                                $this->addInfoMessage($online_access_result);
                        }
                }

                if( $this->getTestOBJ()->isOnline() && $this->getTestOBJ()->isComplete( $this->getTestQuestionSetConfig() ) )
                {
                        if ((!$this->getTestOBJ()->getFixedParticipants() || $online_access) && $this->access->checkAccess("read", "", $this->getTestOBJ()->getRefId()))
                        {
                                $executable = $this->getTestOBJ()->isExecutable(
                                        $this->getTestSession(), $this->getTestSession()->getUserId(), $allowPassIncrease = TRUE
                                );
                                
                                if ($executable["executable"])
                                {
                                        if( $this->getTestOBJ()->areObligationsEnabled() && $this->getTestOBJ()->hasObligations($this->getTestOBJ()->getTestId()) )
                                        {
                                                $this->addInfoMessage($this->lng->txt('tst_test_contains_obligatory_questions'));
                                        }

                                        if ($this->getTestSession()->getActiveId() > 0)
                                        {
                                                // resume test
                                                require_once 'Modules/Test/classes/class.ilTestPassesSelector.php';
                                                $testPassesSelector = new ilTestPassesSelector($this->db, $this->getTestOBJ());
                                                $testPassesSelector->setActiveId($this->getTestSession()->getActiveId());
                                                $testPassesSelector->setLastFinishedPass($this->getTestSession()->getLastFinishedPass());

                                                $closedPasses = $testPassesSelector->getClosedPasses();
                                                $existingPasses = $testPassesSelector->getExistingPasses();

                                                if ($existingPasses > $closedPasses)
                                                {
                                                        $btn = ilSubmitButton::getInstance();
                                                        $btn->setCaption('tst_resume_test');
                                                        $btn->setCommand('resumePlayer');
                                                        $btn->setPrimary(true);
                                                        $this->addButtonInstance($btn);
                                                }
                                                else
                                                {
                                                        $btn = ilSubmitButton::getInstance();
                                                        $btn->setCaption($this->getTestOBJ()->getStartTestLabel($this->getTestSession()->getActiveId()), false);
                                                        $btn->setCommand('startPlayer');
                                                        $btn->setPrimary(true);
                                                        $this->addButtonInstance($btn);
                                                }
                                        }
                                        else
                                        {
                                                // start new test
                                                $btn = ilSubmitButton::getInstance();
                                                $btn->setCaption($this->getTestOBJ()->getStartTestLabel($this->getTestSession()->getActiveId()), false);
                                                $btn->setCommand('startPlayer');
                                                $btn->setPrimary(true);
                                                $this->addButtonInstance($btn);
                                        }
                                }
                                else
                                {
                                        $this->addInfoMessage($executable['errormessage']);
                                }
                                if ($this->getTestSession()->getActiveId() > 0)
                                {
                                        // test results button

                                        require_once 'Modules/Test/classes/class.ilTestPassesSelector.php';
                                        $testPassesSelector = new ilTestPassesSelector($GLOBALS['ilDB'], $this->getTestOBJ());
                                        $testPassesSelector->setActiveId($this->getTestSession()->getActiveId());
                                        $testPassesSelector->setLastFinishedPass($this->getTestSession()->getLastFinishedPass());

                                        if( $this->getTestOBJ()->canShowTestResults($this->getTestSession()) )
                                        {
                                                $btn = ilLinkButton::getInstance();
                                                $btn->setCaption('tst_show_results');
                                                $btn->setUrl($this->buildLinkTarget('ilTestEvaluationGUI',  'outUserResultsOverview'));
                                                $btn->setPrimary(false);
                                                $this->addButtonInstance($btn);

                                                if ($this->getTestOBJ()->getHighscoreEnabled())
                                                {
                                                        // Can also compare results then
                                                        $btn = ilLinkButton::getInstance();
                                                        $btn->setCaption('tst_show_toplist');
                                                        $btn->setUrl($this->buildLinkTarget('ilTestToplistGUI', 'outResultsToplist'));
                                                        $btn->setPrimary(false);
                                                        $this->addButtonInstance($btn);
                                                }

                                                if( $this->getTestOBJ()->isSkillServiceToBeConsidered() )
                                                {
                                                        require_once 'Modules/Test/classes/class.ilTestSkillEvaluationGUI.php';

                                                        $btn = ilLinkButton::getInstance();
                                                        $btn->setCaption('tst_show_comp_results');
                                                        $btn->setUrl($this->buildLinkTarget('ilTestSkillEvaluationGUI', ilTestSkillEvaluationGUI::CMD_SHOW));
                                                        $btn->setPrimary(false);
                                                        $this->addButtonInstance($btn);
                                                }
                                        }

                                }
                        }
                        if ($this->getTestSession()->getActiveId() > 0)
                        {
                                if ($this->getTestOBJ()->canShowSolutionPrintview($this->getTestSession()->getUserId()))
                                {
                                        $btn = ilLinkButton::getInstance();
                                        $btn->setCaption('tst_list_of_answers_show');
                                        $btn->setUrl($this->buildLinkTarget('ilTestEvaluationGUI',  'outUserListOfAnswerPasses'));
                                        $btn->setPrimary(false);
                                        $this->addButtonInstance($btn);
                                }
                        }

                        if( $this->isDeleteDynamicTestResultsButtonRequired() )
                        {
                                $this->populateDeleteDynamicTestResultsButton();
                        }

                        if($_SESSION["AccountId"] == ANONYMOUS_USER_ID)
                        {
                                if( $this->getItems() )
                                {
                                        $this->addSeparator();
                                }
                                
                                require_once 'Services/Form/classes/class.ilTextInputGUI.php';
                                $anonymous_id = new ilTextInputGUI($this->lng->txt('enter_anonymous_code'), 'anonymous_id');
                                $anonymous_id->setSize(8);
                                $this->addInputItem($anonymous_id, true);
                                $this->addFormButton($this->lng->txt('submit'), 'setAnonymousId');
                        }
                }
                if( !$this->getTestOBJ()->isOnline() && !$this->getTestQuestionSetConfig()->areDepenciesBroken() )
                {
                        $message = $this->lng->txt("test_is_offline");

                        if($this->access->checkAccess("write", "", $this->getTestOBJ()->getRefId()))
                        {
                                $message .= "<br /><a href=\"".$this->buildLinkTarget('ilobjtestsettingsgeneralgui')."\">".
                                        $this->lng->txt("test_edit_settings")."</a>";
                        }

                        $this->addInfoMessage($message);
                }
                
                if($this->access->checkAccess("write", "", $this->getTestOBJ()->getRefId()))
                {
                        require_once 'Modules/TestQuestionPool/classes/questions/class.ilAssQuestionSkillAssignmentImportFails.php';
                        $qsaImportFails = new ilAssQuestionSkillAssignmentImportFails($this->testOBJ->getId());
                        require_once 'Modules/Test/classes/class.ilTestSkillLevelThresholdImportFails.php';
                        $sltImportFails = new ilTestSkillLevelThresholdImportFails($this->testOBJ->getId());
                        
                        if( $qsaImportFails->failedImportsRegistered() || $sltImportFails->failedImportsRegistered() )
                        {
                                $importFailsMsg = array();
                                
                                if( $qsaImportFails->failedImportsRegistered() )
                                {
                                        $importFailsMsg[] = $qsaImportFails->getFailedImportsMessage($this->lng);
                                }
                                
                                if( $sltImportFails->failedImportsRegistered() )
                                {
                                        $importFailsMsg[] = $sltImportFails->getFailedImportsMessage($this->lng);
                                }
                                
                                $button = ilLinkButton::getInstance();
                                $button->setUrl($this->ctrl->getLinkTargetByClass('ilObjTestGUI', 'removeImportFails'));
                                $button->setCaption('ass_skl_import_fails_remove_btn');
                                $importFailsMsg[] = $button->render();
                                
                                $this->addFailureMessage(implode('<br />', $importFailsMsg));
                        }
                        elseif( $this->getTestOBJ()->isSkillServiceToBeConsidered() )
                        {
                                if( $this->areSkillLevelThresholdsMissing() )
                                {
                                        $this->addFailureMessage($this->getSkillLevelThresholdsMissingInfo());
                                }
                                
                                if( $this->hasFixedQuestionSetSkillAssignsLowerThanBarrier() )
                                {
                                        $this->addInfoMessage($this->getSkillAssignBarrierInfo());
                                }
                        }

                        if( $this->getTestQuestionSetConfig()->areDepenciesBroken() )
                        {
                                $this->addFailureMessage($this->getTestQuestionSetConfig()->getDepenciesBrokenMessage($this->lng));

                                $this->clearItems();
                        }
                        elseif( $this->getTestQuestionSetConfig()->areDepenciesInVulnerableState() )
                        {
                                $this->addInfoMessage( $this->getTestQuestionSetConfig()->getDepenciesInVulnerableStateMessage($this->lng) );
                        }
                }
        }
        
        public function sendMessages()
        {
                ilUtil::sendInfo( array_pop($this->getInfoMessages()) );
                ilUtil::sendFailure( array_pop($this->getFailureMessages()) );
        }
}