class.ilObjTestDynamicQuestionSetConfigGUI.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
require_once 'Modules/Test/classes/class.ilObjTestDynamicQuestionSetConfig.php';
 
class ilObjTestDynamicQuestionSetConfigGUI
{
        const CMD_SHOW_FORM     = 'showForm';
        const CMD_SAVE_FORM     = 'saveForm';
        const CMD_GET_TAXONOMY_OPTIONS_ASYNC = 'getTaxonomyOptionsAsync';
        
        protected $ctrl = null;
        
        protected $access = null;
        
        protected $tabs = null;
        
        protected $lng = null;
        
        protected $tpl = null;
        
        protected $db = null;
        
        protected $tree = null;
        
        protected $testOBJ = null;
        
        protected $questionSetConfig = null;
        
        const QUESTION_ORDERING_TYPE_UPDATE_DATE = 'ordering_by_date';
        const QUESTION_ORDERING_TYPE_TAXONOMY = 'ordering_by_tax';
        
        public function __construct(ilCtrl $ctrl, ilAccessHandler $access, ilTabsGUI $tabs, ilLanguage $lng, ilTemplate $tpl, ilDB $db, ilTree $tree, ilPluginAdmin $pluginAdmin, ilObjTest $testOBJ)
        {
                $this->ctrl = $ctrl;
                $this->access = $access;
                $this->tabs = $tabs;
                $this->lng = $lng;
                $this->tpl = $tpl;
                $this->db = $db;
                $this->tree = $tree;
                $this->pluginAdmin = $pluginAdmin;
 
                $this->testOBJ = $testOBJ;
                
                $this->questionSetConfig = new ilObjTestDynamicQuestionSetConfig($this->tree, $this->db, $this->pluginAdmin, $this->testOBJ);
        }
        
        public function executeCommand()
        {
                // allow only write access
                
                if (!$this->access->checkAccess("write", "", $this->testOBJ->getRefId())) 
                {
                        ilUtil::sendInfo($this->lng->txt("cannot_edit_test"), true);
                        $this->ctrl->redirectByClass('ilObjTestGUI', "infoScreen");
                }
                
                // activate corresponding tab (auto activation does not work in ilObjTestGUI-Tabs-Salad)
                
                $this->tabs->activateTab('assQuestions');
                
                // process command
                
                $nextClass = $this->ctrl->getNextClass();
                
                switch($nextClass)
                {
                        default:
                                $cmd = $this->ctrl->getCmd(self::CMD_SHOW_FORM).'Cmd';
                                $this->$cmd();
                }
        }
        
        public function getTaxonomyOptionsAsyncCmd()
        {
                $questionPoolId = (int)$_POST['question_pool_id'];
 
                echo $this->buildTaxonomySelectInputOptionJson($questionPoolId);
                exit;
        }
        
        public function showFormCmd(ilPropertyFormGUI $form = null)
        {
                $this->questionSetConfig->loadFromDb();
                
                if( $this->questionSetConfig->areDepenciesBroken($this->tree) )
                {
                        ilUtil::sendFailure( $this->questionSetConfig->getDepenciesBrokenMessage($this->lng) );
                }
                elseif( $this->questionSetConfig->areDepenciesInVulnerableState($this->tree) )
                {
                        ilUtil::sendInfo( $this->questionSetConfig->getDepenciesInVulnerableStateMessage($this->lng) );
                }
                        
                if( $form === null )
                {
                        $form = $this->buildForm($this->questionSetConfig->getSourceQuestionPoolId());
                }
                
                $this->tpl->setContent( $this->ctrl->getHTML($form) );
                
                $this->tpl->addJavaScript('Modules/Test/js/ilTestDynamicQuestionSetConfig.js');
        }
        
        protected function getSubmittedSourceQuestionPoolId()
        {
                return (int)$_POST['source_qpl_id'];
        }
        
        public function saveFormCmd()
        {
                $form = $this->buildForm(
                        $this->getSubmittedSourceQuestionPoolId()
                );
 
                if( $this->testOBJ->participantDataExist() )
                {
                        ilUtil::sendFailure($this->lng->txt("tst_msg_cannot_modify_dynamic_question_set_conf_due_to_part"), true);
                        return $this->showFormCmd($form);
                }
                
                $errors = !$form->checkInput(); // ALWAYS CALL BEFORE setValuesByPost()
                $form->setValuesByPost(); // NEVER CALL THIS BEFORE checkInput()
 
                if($errors)
                {
                        ilUtil::sendFailure($this->lng->txt('form_input_not_valid'));
                        return $this->showFormCmd($form);
                }
                
                $this->performSaveForm($form);
                
                $this->testOBJ->saveCompleteStatus( $this->questionSetConfig );
 
                ilUtil::sendSuccess($this->lng->txt("tst_msg_dynamic_question_set_config_modified"), true);
                $this->ctrl->redirect($this, self::CMD_SHOW_FORM);
        }
        
        private function performSaveForm(ilPropertyFormGUI $form)
        {
                $this->questionSetConfig->setSourceQuestionPoolId(
                                $form->getItemByPostVar('source_qpl_id')->getValue()
                );
 
                $this->questionSetConfig->setSourceQuestionPoolTitle( ilObject::_lookupTitle(
                                $form->getItemByPostVar('source_qpl_id')->getValue()
                ));
 
                switch( $form->getItemByPostVar('question_ordering')->getValue() )
                {
                        case self::QUESTION_ORDERING_TYPE_UPDATE_DATE:
                                $this->questionSetConfig->setOrderingTaxonomyId(null);
                                break;
                        
                        case self::QUESTION_ORDERING_TYPE_TAXONOMY:
                                $this->questionSetConfig->setOrderingTaxonomyId(
                                        $form->getItemByPostVar('ordering_tax')->getValue()
                                );
                                break;
                }
 
                $this->questionSetConfig->setTaxonomyFilterEnabled(
                        $form->getItemByPostVar('tax_filter_enabled')->getChecked()
                );
 
                $this->questionSetConfig->setAnswerStatusFilterEnabled(
                        $form->getItemByPostVar('answer_status_filter_enabled')->getChecked()
                );
 
                $this->questionSetConfig->setPreviousQuestionsListEnabled(
                        $form->getItemByPostVar('prev_quest_list_enabled')->getChecked()
                );
                
                $this->questionSetConfig->saveToDb( $this->testOBJ->getTestId() );
        }
        
        private function buildForm($sourceQuestionPoolId)
        {
                $this->questionSetConfig->loadFromDb( $this->testOBJ->getTestId() );
                
                require_once 'Services/Form/classes/class.ilPropertyFormGUI.php';
                $form = new ilPropertyFormGUI();
                
                $form->setFormAction($this->ctrl->getFormAction($this));
 
                $form->setId("tst_form_dynamic_question_set_config");
                $form->setTitle($this->lng->txt('tst_form_dynamic_question_set_config'));
                $form->setTableWidth("100%");
                
                $hiddenInputTaxSelectOptAsyncUrl = new ilHiddenInputGUI('taxSelectOptAsyncUrl');
                $hiddenInputTaxSelectOptAsyncUrl->setValue(
                        $this->ctrl->getLinkTarget($this, self::CMD_GET_TAXONOMY_OPTIONS_ASYNC, '', true)
                );
                $form->addItem($hiddenInputTaxSelectOptAsyncUrl);
 
                if( $this->testOBJ->participantDataExist() )
                {
                        $pool = new ilNonEditableValueGUI($this->lng->txt('tst_input_dynamic_question_set_source_questionpool'), 'source_qpl_title');
                        $pool->setValue( $this->questionSetConfig->getSourceQuestionPoolSummaryString($this->lng, $this->tree) );
                        $pool->setDisabled(true);
                        $form->addItem($pool);
                }
                else
                {
                        $poolInput = new ilSelectInputGUI($this->lng->txt('tst_input_dynamic_question_set_source_questionpool'), 'source_qpl_id');
                        $poolInput->setOptions($this->buildQuestionPoolSelectInputOptionArray(
                                        $this->testOBJ->getAvailableQuestionpools(true, false, false, true, true)
                        ));
                        $poolInput->setValue( $sourceQuestionPoolId );
                        $poolInput->setRequired(true);
                        $form->addItem($poolInput);
                }
                
                $questionOderingInput = new ilRadioGroupInputGUI(
                                $this->lng->txt('tst_input_dynamic_question_set_question_ordering'), 'question_ordering'
                );
                $questionOderingInput->setValue( $this->questionSetConfig->getOrderingTaxonomyId() ?
                        self::QUESTION_ORDERING_TYPE_TAXONOMY : self::QUESTION_ORDERING_TYPE_UPDATE_DATE
                );
                $optionOrderByDate = new ilRadioOption(
                                $this->lng->txt('tst_input_dynamic_question_set_question_ordering_by_date'),
                                self::QUESTION_ORDERING_TYPE_UPDATE_DATE,
                                $this->lng->txt('tst_inp_dyn_quest_set_quest_ordering_by_date_desc')
                );
                $questionOderingInput->addOption($optionOrderByDate);
                $optionOrderByTax = new ilRadioOption(
                                $this->lng->txt('tst_input_dynamic_question_set_question_ordering_by_tax'),
                                self::QUESTION_ORDERING_TYPE_TAXONOMY,
                                $this->lng->txt('tst_inp_dyn_quest_set_quest_ordering_by_tax_desc')
                );
                        $orderTaxInput = new ilSelectInputGUI($this->lng->txt('tst_input_dynamic_question_set_ordering_tax'), 'ordering_tax');
                        $orderTaxInput->setInfo($this->lng->txt('tst_input_dynamic_question_set_ordering_tax_description'));
                        $orderTaxInput->setValue($this->questionSetConfig->getOrderingTaxonomyId());
                        $orderTaxInput->setRequired(true);
                        $orderTaxInput->setOptions($this->buildTaxonomySelectInputOptionArray( $sourceQuestionPoolId ));
                $optionOrderByTax->addSubItem($orderTaxInput);
                $questionOderingInput->addOption($optionOrderByTax);
                $form->addItem($questionOderingInput);
                
                $taxFilterInput = new ilCheckboxInputGUI($this->lng->txt('tst_input_dynamic_question_set_taxonomie_filter_enabled'), 'tax_filter_enabled');
                $taxFilterInput->setValue(1);
                $taxFilterInput->setChecked( $this->questionSetConfig->isTaxonomyFilterEnabled() );
                $form->addItem($taxFilterInput);
                
                $answStatusFilterInput = new ilCheckboxInputGUI(
                        $this->lng->txt('tst_input_dyn_quest_set_answer_status_filter_enabled'), 'answer_status_filter_enabled'
                );
                $answStatusFilterInput->setValue(1);
                $answStatusFilterInput->setChecked( $this->questionSetConfig->isAnswerStatusFilterEnabled() );
                $form->addItem($answStatusFilterInput);
                
                $previousQuestionsListInput = new ilCheckboxInputGUI(
                        $this->lng->txt('tst_input_dyn_quest_set_prev_quest_list_enabled'), 'prev_quest_list_enabled'
                );
                $previousQuestionsListInput->setValue(1);
                $previousQuestionsListInput->setChecked( $this->questionSetConfig->isPreviousQuestionsListEnabled() );
                $form->addItem($previousQuestionsListInput);
 
                if( $this->testOBJ->participantDataExist() )
                {
                        $questionOderingInput->setDisabled(true);
                        $taxFilterInput->setDisabled(true);
                        $answStatusFilterInput->setDisabled(true);
                        $previousQuestionsListInput->setDisabled(true);
                }
                else
                {
                        $form->addCommandButton(self::CMD_SAVE_FORM, $this->lng->txt('save'));
                }
                
                return $form;
        }
        
        private function buildQuestionPoolSelectInputOptionArray($questionPoolsData)
        {
                $questionPoolSelectInputOptions = array( '' => $this->lng->txt('please_select') );
                
                foreach($questionPoolsData as $qplId => $qplData)
                {
                        $questionPoolSelectInputOptions[$qplId] = $qplData['title'];
                }
                
                return $questionPoolSelectInputOptions;
        }
        
        private function buildTaxonomySelectInputOptionArray($questionPoolId)
        {
                $taxSelectOptions = array(
                        0 => $this->lng->txt('please_select')
                );
                
                if( $questionPoolId )
                {
                        require_once 'Services/Taxonomy/classes/class.ilObjTaxonomy.php';
 
                        $taxIds = ilObjTaxonomy::getUsageOfObject($questionPoolId);
 
                        foreach($taxIds as $taxId)
                        {
                                $taxSelectOptions[$taxId] = ilObject::_lookupTitle($taxId);
                        }
                }
                
                return $taxSelectOptions;
        }
        
        private function buildTaxonomySelectInputOptionJson($questionPoolId)
        {
                $options = array();
 
                foreach($this->buildTaxonomySelectInputOptionArray($questionPoolId) as $optValue => $optLabel)
                {
                        $options[] = array('value' => $optValue, 'label' => $optLabel);
                }
 
                return json_encode($options);
        }
}