class.assNumericGUI.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.assQuestionGUI.php';
require_once './Modules/TestQuestionPool/interfaces/interface.ilGuiQuestionScoringAdjustable.php';
require_once './Modules/TestQuestionPool/interfaces/interface.ilGuiAnswerScoringAdjustable.php';
require_once './Modules/Test/classes/inc.AssessmentConstants.php';
 
class assNumericGUI extends assQuestionGUI implements ilGuiQuestionScoringAdjustable, ilGuiAnswerScoringAdjustable
{
    public function __construct($id = -1)
    {
        parent::__construct();
        require_once './Modules/TestQuestionPool/classes/class.assNumeric.php';
        $this->object = new assNumeric();
        if ($id >= 0) {
            $this->object->loadFromDb($id);
        }
    }
 
    public function getCommand($cmd)
    {
        if (substr($cmd, 0, 6) == "delete") {
            $cmd = "delete";
        }
        return $cmd;
    }
 
    protected function writePostData($always = false)
    {
        $hasErrors = (!$always) ? $this->editQuestion(true) : false;
        if (!$hasErrors) {
            require_once 'Services/Form/classes/class.ilPropertyFormGUI.php';
            $this->writeQuestionGenericPostData();
            $this->writeQuestionSpecificPostData(new ilPropertyFormGUI());
            $this->writeAnswerSpecificPostData(new ilPropertyFormGUI());
            $this->saveTaxonomyAssignments();
            return 0;
        }
        return 1;
    }
 
    public function editQuestion($checkonly = false)
    {
        $save = $this->isSaveCommand();
        $this->getQuestionTemplate();
 
        include_once("./Services/Form/classes/class.ilPropertyFormGUI.php");
        $form = new ilPropertyFormGUI();
        $this->editForm = $form;
 
        $form->setFormAction($this->ctrl->getFormAction($this));
        $form->setTitle($this->outQuestionType());
        $form->setMultipart(true);
        $form->setTableWidth("100%");
        $form->setId("assnumeric");
 
        $this->addBasicQuestionFormProperties($form);
        $this->populateQuestionSpecificFormPart($form);
        $this->populateAnswerSpecificFormPart($form);
        $this->populateTaxonomyFormSection($form);
        $this->addQuestionFormCommandButtons($form);
 
        $errors = false;
 
        if ($save) {
            $form->setValuesByPost();
            $errors = !$form->checkInput();
            $form->setValuesByPost(); // again, because checkInput now performs the whole stripSlashes handling and we need this if we don't want to have duplication of backslashes
 
            $lower = $form->getItemByPostVar('lowerlimit');
            $upper = $form->getItemByPostVar('upperlimit');
 
            if (!$this->checkRange($lower->getValue(), $upper->getValue())) {
                global $DIC;
                $lower->setAlert($DIC->language()->txt('qpl_numeric_lower_needs_valid_lower_alert'));
                $upper->setAlert($DIC->language()->txt('qpl_numeric_upper_needs_valid_upper_alert'));
                ilUtil::sendFailure($DIC->language()->txt("form_input_not_valid"));
                $errors = true;
            }
 
            if ($errors) {
                $checkonly = false;
            }
        }
 
        if (!$checkonly) {
            $this->tpl->setVariable("QUESTION_DATA", $form->getHTML());
        }
        return $errors;
    }
 
    public function checkRange($lower, $upper)
    {
        include_once "./Services/Math/classes/class.EvalMath.php";
        $eval = new EvalMath();
        $eval->suppress_errors = true;
        if (($eval->e($lower) !== false) and ($eval->e($upper) !== false)) {
            if ($eval->e($lower) <= $eval->e($upper)) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }
 
    public function supportsIntermediateSolutionOutput()
    {
        return true;
    }
 
    public function getSolutionOutput(
        $active_id,
        $pass = null,
        $graphicalOutput = false,
        $result_output = false,
        $show_question_only = true,
        $show_feedback = false,
        $show_correct_solution = false,
        $show_manual_scoring = false,
        $show_question_text = true
    ) {
        // get the solution of the user for the active pass or from the last pass if allowed
        $solutions = array();
        if (($active_id > 0) && (!$show_correct_solution)) {
            $solutions = $this->object->getSolutionValues($active_id, $pass, !$this->getUseIntermediateSolution());
        } else {
            array_push($solutions, array("value1" => sprintf($this->lng->txt("value_between_x_and_y"), $this->object->getLowerLimit(), $this->object->getUpperLimit())));
        }
 
        // generate the question output
        require_once './Services/UICore/classes/class.ilTemplate.php';
        $template = new ilTemplate("tpl.il_as_qpl_numeric_output_solution.html", true, true, "Modules/TestQuestionPool");
        $solutiontemplate = new ilTemplate("tpl.il_as_tst_solution_output.html", true, true, "Modules/TestQuestionPool");
        if (is_array($solutions)) {
            if (($active_id > 0) && (!$show_correct_solution)) {
                if ($graphicalOutput) {
                    if ($this->object->getStep() === null) {
                        $reached_points = $this->object->getReachedPoints($active_id, $pass);
                    } else {
                        $reached_points = $this->object->calculateReachedPoints($active_id, $pass);
                    }
                    // output of ok/not ok icons for user entered solutions
                    if ($reached_points == $this->object->getMaximumPoints()) {
                        $template->setCurrentBlock("icon_ok");
                        $template->setVariable("ICON_OK", ilUtil::getImagePath("icon_ok.svg"));
                        $template->setVariable("TEXT_OK", $this->lng->txt("answer_is_right"));
                        $template->parseCurrentBlock();
                    } else {
                        $template->setCurrentBlock("icon_ok");
                        $template->setVariable("ICON_NOT_OK", ilUtil::getImagePath("icon_not_ok.svg"));
                        $template->setVariable("TEXT_NOT_OK", $this->lng->txt("answer_is_wrong"));
                        $template->parseCurrentBlock();
                    }
                }
            }
            foreach ($solutions as $solution) {
                $template->setVariable("NUMERIC_VALUE", $solution["value1"]);
            }
            if (count($solutions) == 0) {
                $template->setVariable("NUMERIC_VALUE", "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
            }
        }
        $template->setVariable("NUMERIC_SIZE", $this->object->getMaxChars());
        if ($show_question_text == true) {
            $template->setVariable("QUESTIONTEXT", $this->object->getQuestionForHTMLOutput());
        }
        $questionoutput = $template->get();
        //$feedback = ($show_feedback) ? $this->getAnswerFeedbackOutput($active_id, $pass) : ""; // Moving new method
        // due to deprecation.
        $feedback = ($show_feedback && !$this->isTestPresentationContext()) ? $this->getGenericFeedbackOutput($active_id, $pass) : "";
        if (strlen($feedback)) {
            $cssClass = (
                $this->hasCorrectSolution($active_id, $pass) ?
                ilAssQuestionFeedback::CSS_CLASS_FEEDBACK_CORRECT : ilAssQuestionFeedback::CSS_CLASS_FEEDBACK_WRONG
            );
 
            $solutiontemplate->setVariable("ILC_FB_CSS_CLASS", $cssClass);
            $solutiontemplate->setVariable("FEEDBACK", $this->object->prepareTextareaOutput($feedback, true));
        }
        $solutiontemplate->setVariable("SOLUTION_OUTPUT", $questionoutput);
 
        $solutionoutput = $solutiontemplate->get();
        if (!$show_question_only) {
            // get page object output
            $solutionoutput = $this->getILIASPage($solutionoutput);
        }
        return $solutionoutput;
    }
 
    public function getPreview($show_question_only = false, $showInlineFeedback = false)
    {
        // generate the question output
        require_once './Services/UICore/classes/class.ilTemplate.php';
        $template = new ilTemplate("tpl.il_as_qpl_numeric_output.html", true, true, "Modules/TestQuestionPool");
        if (is_object($this->getPreviewSession())) {
            $template->setVariable("NUMERIC_VALUE", " value=\"" . $this->getPreviewSession()->getParticipantsSolution() . "\"");
        }
        $template->setVariable("NUMERIC_SIZE", $this->object->getMaxChars());
        $template->setVariable("QUESTIONTEXT", $this->object->getQuestionForHTMLOutput());
        $questionoutput = $template->get();
        if (!$show_question_only) {
            // get page object output
            $questionoutput = $this->getILIASPage($questionoutput);
        }
        return $questionoutput;
    }
 
    // hey: prevPassSolutions - pass will be always available from now on
    public function getTestOutput($active_id, $pass, $is_postponed = false, $use_post_solutions = false, $inlineFeedback)
    // hey.
    {
        $solutions = null;
        // get the solution of the user for the active pass or from the last pass if allowed
        if ($use_post_solutions !== false) {
            $solutions = array(
                array('value1' => $use_post_solutions['numeric_result'])
            );
        } elseif ($active_id) {
 
            // hey: prevPassSolutions - obsolete due to central check
            #include_once "./Modules/Test/classes/class.ilObjTest.php";
            #if (!ilObjTest::_getUsePreviousAnswers($active_id, true))
            #{
            #   if (is_null($pass)) $pass = ilObjTest::_getPass($active_id);
            #}
            $solutions = $this->object->getTestOutputSolutions($active_id, $pass);
            // hey.
        }
 
        // generate the question output
        require_once './Services/UICore/classes/class.ilTemplate.php';
        $template = new ilTemplate("tpl.il_as_qpl_numeric_output.html", true, true, "Modules/TestQuestionPool");
        if (is_array($solutions)) {
            foreach ($solutions as $solution) {
                $template->setVariable("NUMERIC_VALUE", " value=\"" . $solution["value1"] . "\"");
            }
        }
        $template->setVariable("NUMERIC_SIZE", $this->object->getMaxChars());
        $template->setVariable("QUESTIONTEXT", $this->object->getQuestionForHTMLOutput());
        $questionoutput = $template->get();
        $pageoutput = $this->outQuestionPage("", $is_postponed, $active_id, $questionoutput);
        return $pageoutput;
    }
 
    public function getSpecificFeedbackOutput($userSolution)
    {
        $output = "";
        return $this->object->prepareTextareaOutput($output, true);
    }
 
    public function writeQuestionSpecificPostData(ilPropertyFormGUI $form)
    {
        $this->object->setMaxChars($_POST["maxchars"]);
    }
 
    public function writeAnswerSpecificPostData(ilPropertyFormGUI $form)
    {
        $this->object->setLowerLimit($_POST['lowerlimit']);
        $this->object->setUpperLimit($_POST['upperlimit']);
        $this->object->setPoints($_POST['points']);
    }
 
    public function populateQuestionSpecificFormPart(\ilPropertyFormGUI $form)
    {
        // maxchars
        $maxchars = new ilNumberInputGUI($this->lng->txt("maxchars"), "maxchars");
        $maxchars->setInfo($this->lng->txt('qpl_maxchars_info_numeric_question'));
        $maxchars->setSize(10);
        $maxchars->setDecimals(0);
        $maxchars->setMinValue(1);
        $maxchars->setRequired(true);
        if ($this->object->getMaxChars() > 0) {
            $maxchars->setValue($this->object->getMaxChars());
        }
        $form->addItem($maxchars);
    }
 
    public function populateAnswerSpecificFormPart(\ilPropertyFormGUI $form)
    {
        // points
        $points = new ilNumberInputGUI($this->lng->txt("points"), "points");
        $points->allowDecimals(true);
        $points->setValue($this->object->getPoints() > 0 ? $this->object->getPoints() : '');
        $points->setRequired(true);
        $points->setSize(3);
        $points->setMinValue(0.0);
        $points->setMinvalueShouldBeGreater(true);
        $form->addItem($points);
 
        $header = new ilFormSectionHeaderGUI();
        $header->setTitle($this->lng->txt("range"));
        $form->addItem($header);
 
        // lower bound
        $lower_limit = new ilFormulaInputGUI($this->lng->txt("range_lower_limit"), "lowerlimit");
        $lower_limit->setSize(25);
        $lower_limit->setMaxLength(20);
        $lower_limit->setRequired(true);
        $lower_limit->setValue($this->object->getLowerLimit());
        $form->addItem($lower_limit);
 
        // upper bound
        $upper_limit = new ilFormulaInputGUI($this->lng->txt("range_upper_limit"), "upperlimit");
        $upper_limit->setSize(25);
        $upper_limit->setMaxLength(20);
        $upper_limit->setRequired(true);
        $upper_limit->setValue($this->object->getUpperLimit());
        $form->addItem($upper_limit);
 
        // reset input length, if max chars are set
        if ($this->object->getMaxChars() > 0) {
            $lower_limit->setSize($this->object->getMaxChars());
            $lower_limit->setMaxLength($this->object->getMaxChars());
            $upper_limit->setSize($this->object->getMaxChars());
            $upper_limit->setMaxLength($this->object->getMaxChars());
        }
    }
 
    public function getAfterParticipationSuppressionAnswerPostVars()
    {
        return array();
    }
 
    public function getAfterParticipationSuppressionQuestionPostVars()
    {
        return array();
    }
 
    public function getAggregatedAnswersView($relevant_answers)
    {
        return  $this->renderAggregateView(
            $this->aggregateAnswers($relevant_answers)
        )->get();
    }
 
    public function aggregateAnswers($relevant_answers_chosen)
    {
        $aggregate = array();
 
        foreach ($relevant_answers_chosen as $relevant_answer) {
            if (array_key_exists($relevant_answer['value1'], $aggregate)) {
                $aggregate[$relevant_answer['value1']]++;
            } else {
                $aggregate[$relevant_answer['value1']] = 1;
            }
        }
        return $aggregate;
    }
 
    public function renderAggregateView($aggregate)
    {
        $tpl = new ilTemplate('tpl.il_as_aggregated_answers_table.html', true, true, "Modules/TestQuestionPool");
 
        $tpl->setCurrentBlock('headercell');
        $tpl->setVariable('HEADER', $this->lng->txt('tst_answer_aggr_answer_header'));
        $tpl->parseCurrentBlock();
 
        $tpl->setCurrentBlock('headercell');
        $tpl->setVariable('HEADER', $this->lng->txt('tst_answer_aggr_frequency_header'));
        $tpl->parseCurrentBlock();
 
        foreach ($aggregate as $key => $value) {
            $tpl->setCurrentBlock('aggregaterow');
            $tpl->setVariable('OPTION', $key);
            $tpl->setVariable('COUNT', $value);
            $tpl->parseCurrentBlock();
        }
        return $tpl;
    }
 
    public function getAnswersFrequency($relevantAnswers, $questionIndex)
    {
        $answers = array();
 
        foreach ($relevantAnswers as $ans) {
            if (!isset($answers[$ans['value1']])) {
                $answers[$ans['value1']] = array(
                    'answer' => $ans['value1'], 'frequency' => 0
                );
            }
 
            $answers[$ans['value1']]['frequency']++;
        }
 
        return $answers;
    }
 
    public function populateCorrectionsFormProperties(ilPropertyFormGUI $form)
    {
        // points
        $points = new ilNumberInputGUI($this->lng->txt("points"), "points");
        $points->allowDecimals(true);
        $points->setValue($this->object->getPoints() > 0 ? $this->object->getPoints() : '');
        $points->setRequired(true);
        $points->setSize(3);
        $points->setMinValue(0.0);
        $points->setMinvalueShouldBeGreater(true);
        $form->addItem($points);
 
        $header = new ilFormSectionHeaderGUI();
        $header->setTitle($this->lng->txt("range"));
        $form->addItem($header);
 
        // lower bound
        $lower_limit = new ilFormulaInputGUI($this->lng->txt("range_lower_limit"), "lowerlimit");
        $lower_limit->setSize(25);
        $lower_limit->setMaxLength(20);
        $lower_limit->setRequired(true);
        $lower_limit->setValue($this->object->getLowerLimit());
        $form->addItem($lower_limit);
 
        // upper bound
        $upper_limit = new ilFormulaInputGUI($this->lng->txt("range_upper_limit"), "upperlimit");
        $upper_limit->setSize(25);
        $upper_limit->setMaxLength(20);
        $upper_limit->setRequired(true);
        $upper_limit->setValue($this->object->getUpperLimit());
        $form->addItem($upper_limit);
 
        // reset input length, if max chars are set
        if ($this->object->getMaxChars() > 0) {
            $lower_limit->setSize($this->object->getMaxChars());
            $lower_limit->setMaxLength($this->object->getMaxChars());
            $upper_limit->setSize($this->object->getMaxChars());
            $upper_limit->setMaxLength($this->object->getMaxChars());
        }
    }
 
    public function saveCorrectionsFormProperties(ilPropertyFormGUI $form)
    {
        $this->object->setPoints((float) $form->getInput('points'));
        $this->object->setLowerLimit((float) $form->getInput('lowerlimit'));
        $this->object->setUpperLimit((float) $form->getInput('upperlimit'));
    }
}