question/type/numerical/questiontype.php

   1 <?php
   2
   3 // This file is part of Moodle - http://moodle.org/
   4 //
   5 // Moodle is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // Moodle is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 /**
  19  * @author Martin Dougiamas and many others. Tim Hunt.
  20  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
  21  * @package questionbank
  22  * @subpackage questiontypes
  23  */
  24
  25 require_once("$CFG->dirroot/question/type/shortanswer/questiontype.php");
  26
  27 /**
  28  * NUMERICAL QUESTION TYPE CLASS
  29  *
  30  * This class contains some special features in order to make the
  31  * question type embeddable within a multianswer (cloze) question
  32  *
  33  * This question type behaves like shortanswer in most cases.
  34  * Therefore, it extends the shortanswer question type...
  35  * @package questionbank
  36  * @subpackage questiontypes
  37  */
  38
  39 class question_numerical_qtype extends question_shortanswer_qtype {
  40
  41     public $virtualqtype = false;
  42     function name() {
  43         return 'numerical';
  44     }
  45
  46     function has_wildcards_in_responses() {
  47         return true;
  48     }
  49
  50     function requires_qtypes() {
  51         return array('shortanswer');
  52     }
  53
  54     function get_question_options(&$question) {
  55         // Get the question answers and their respective tolerances
  56         // Note: question_numerical is an extension of the answer table rather than
  57         //       the question table as is usually the case for qtype
  58         //       specific tables.
  59         global $CFG, $DB, $OUTPUT;
  60         if (!$question->options->answers = $DB->get_records_sql(
  61                                 "SELECT a.*, n.tolerance " .
  62                                 "FROM {question_answers} a, " .
  63                                 "     {question_numerical} n " .
  64                                 "WHERE a.question = ? " .
  65                                 "    AND   a.id = n.answer " .
  66                                 "ORDER BY a.id ASC", array($question->id))) {
  67             echo $OUTPUT->notification('Error: Missing question answer for numerical question ' . $question->id . '!');
  68             return false;
  69         }
  70         $this->get_numerical_units($question);
  71         //get_numerical_options() need to know if there are units
  72         // to set correctly default values
  73         $this->get_numerical_options($question);
  74
  75         // If units are defined we strip off the default unit from the answer, if
  76         // it is present. (Required for compatibility with the old code and DB).
  77         if ($defaultunit = $this->get_default_numerical_unit($question)) {
  78             foreach($question->options->answers as $key => $val) {
  79                 $answer = trim($val->answer);
  80                 $length = strlen($defaultunit->unit);
  81                 if ($length && substr($answer, -$length) == $defaultunit->unit) {
  82                     $question->options->answers[$key]->answer =
  83                             substr($answer, 0, strlen($answer)-$length);
  84                 }
  85             }
  86         }
  87
  88         return true;
  89     }
  90     function get_numerical_units(&$question) {
  91         global $DB;
  92         if ($units = $DB->get_records('question_numerical_units', array('question' => $question->id), 'id ASC')) {
  93             $units  = array_values($units);
  94         } else {
  95             $units = array();
  96         }
  97         foreach ($units as $key => $unit) {
  98             $units[$key]->multiplier = clean_param($unit->multiplier, PARAM_NUMBER);
  99         }
 100         $question->options->units = $units;
 101         return true;
 102     }
 103
 104     function get_default_numerical_unit(&$question) {
 105         if (isset($question->options->units[0])) {
 106             foreach ($question->options->units as $unit) {
 107                 if (abs($unit->multiplier - 1.0) < '1.0e-' . ini_get('precision')) {
 108                     return $unit;
 109                 }
 110             }
 111         }
 112         return false;
 113     }
 114
 115     function get_numerical_options(&$question) {
 116         global $DB;
 117         if (!$options = $DB->get_record('question_numerical_options', array('question' => $question->id))) {
 118             $question->options->unitgradingtype = 0; // total grade
 119             $question->options->unitpenalty = 0.1; // default for old questions
 120             // the default
 121             if ($defaultunit = $this->get_default_numerical_unit($question)) {
 122                 // so units can be graded
 123                 $question->options->showunits = NUMERICALQUESTIONUNITTEXTINPUTDISPLAY ;
 124             }else {
 125                 // only numerical will be graded
 126                 $question->options->showunits = NUMERICALQUESTIONUNITNODISPLAY ;
 127             }
 128             $question->options->unitsleft = 0 ;
 129             $question->options->instructions = '';
 130             $question->options->instructionsformat = editors_get_preferred_format();
 131         } else {
 132             $question->options->unitgradingtype = $options->unitgradingtype;
 133             $question->options->unitpenalty = $options->unitpenalty;
 134             $question->options->showunits = $options->showunits;
 135             $question->options->unitsleft = $options->unitsleft;
 136             $question->options->instructions = $options->instructions;
 137             $question->options->instructionsformat = $options->instructionsformat;
 138         }
 139
 140         return true;
 141     }
 142
 143
 144     /**
 145      * Save the units and the answers associated with this question.
 146      */
 147     function save_question_options($question) {
 148         global $DB;
 149         $context = $question->context;
 150
 151         // Get old versions of the objects
 152         if (!$oldanswers = $DB->get_records('question_answers', array('question' =>  $question->id), 'id ASC')) {
 153             $oldanswers = array();
 154         }
 155
 156         if (!$oldoptions = $DB->get_records('question_numerical', array('question' =>  $question->id), 'answer ASC')) {
 157             $oldoptions = array();
 158         }
 159
 160         // Save the units.
 161         $result = $this->save_numerical_units($question);
 162         if (isset($result->error)) {
 163             return $result;
 164         } else {
 165             $units = &$result->units;
 166         }
 167
 168         // Insert all the new answers
 169         foreach ($question->answer as $key => $dataanswer) {
 170             // Check for, and ingore, completely blank answer from the form.
 171             if (trim($dataanswer) == '' && $question->fraction[$key] == 0 &&
 172                     html_is_blank($question->feedback[$key]['text'])) {
 173                 continue;
 174             }
 175
 176             $answer = new stdClass;
 177             $answer->question = $question->id;
 178             if (trim($dataanswer) === '*') {
 179                 $answer->answer = '*';
 180             } else {
 181                 $answer->answer = $this->apply_unit($dataanswer, $units);
 182                 if ($answer->answer === false) {
 183                     $result->notice = get_string('invalidnumericanswer', 'quiz');
 184                 }
 185             }
 186             $answer->fraction = $question->fraction[$key];
 187
 188             $feedbacktext = trim($question->feedback[$key]['text']);
 189             $draftid = $question->feedback[$key]['itemid'];
 190
 191
 192             $answer->feedbackformat = $question->feedback[$key]['format'];
 193
 194             if ($oldanswer = array_shift($oldanswers)) {  // Existing answer, so reuse it
 195                 $feedbacktext = file_save_draft_area_files($draftid, $context->id, 'question', 'answerfeedback', $oldanswer->id, self::$fileoptions, $feedbacktext);
 196                 $answer->feedback = $feedbacktext;
 197                 $answer->id = $oldanswer->id;
 198                 $DB->update_record("question_answers", $answer);
 199             } else { // This is a completely new answer
 200                 $answer->feedback = $feedbacktext;
 201                 $answer->id = $DB->insert_record("question_answers", $answer);
 202                 $feedbacktext = file_save_draft_area_files($draftid, $context->id, 'question', 'answerfeedback', $answer->id, self::$fileoptions, $feedbacktext);
 203                 $DB->set_field('question_answers', 'feedback', $feedbacktext, array('id'=>$answer->id));
 204             }
 205
 206             // Set up the options object
 207             if (!$options = array_shift($oldoptions)) {
 208                 $options = new stdClass;
 209             }
 210             $options->question  = $question->id;
 211             $options->answer    = $answer->id;
 212             if (trim($question->tolerance[$key]) == '') {
 213                 $options->tolerance = '';
 214             } else {
 215                 $options->tolerance = $this->apply_unit($question->tolerance[$key], $units);
 216                 if ($options->tolerance === false) {
 217                     $result->notice = get_string('invalidnumerictolerance', 'quiz');
 218                 }
 219             }
 220
 221             // Save options
 222             if (isset($options->id)) { // reusing existing record
 223                 $DB->update_record('question_numerical', $options);
 224             } else { // new options
 225                 $DB->insert_record('question_numerical', $options);
 226             }
 227         }
 228         // delete old answer records
 229         if (!empty($oldanswers)) {
 230             foreach($oldanswers as $oa) {
 231                 $DB->delete_records('question_answers', array('id' => $oa->id));
 232             }
 233         }
 234
 235         // delete old answer records
 236         if (!empty($oldoptions)) {
 237             foreach($oldoptions as $oo) {
 238                 $DB->delete_records('question_numerical', array('id' => $oo->id));
 239             }
 240         }
 241         $result = $this->save_numerical_options($question);
 242         if (isset($result->error)) {
 243             return $result;
 244         }
 245         // Report any problems.
 246         if (!empty($result->notice)) {
 247             return $result;
 248         }
 249         return true;
 250     }
 251
 252     /**
 253      * The numerical options control the display and the grading of the unit
 254      * part of the numerical question and related types (calculateds)
 255      * Questions previous to 2,0 do not have this table as multianswer questions
 256      * in all versions including 2,0. The default values are set to give the same grade
 257      * as old question.
 258      *
 259      */
 260     function save_numerical_options(&$question) {
 261         global $DB;
 262         //        echo"<p> ".$question->id."question<pre>";print_r($question) ;echo"</pre></p>";
 263
 264         $result = new stdClass;
 265         // numerical options
 266         $update = true ;
 267         $options = $DB->get_record('question_numerical_options', array('question' => $question->id));
 268         if (!$options) {
 269             $update = false;
 270             $options = new stdClass;
 271             $options->question = $question->id;
 272         }
 273         if(isset($question->options->unitgradingtype)){
 274             $options->unitgradingtype = $question->options->unitgradingtype;
 275         }else {
 276             $options->unitgradingtype = 0 ;
 277         }
 278         if(isset($question->unitpenalty)){
 279             $options->unitpenalty = $question->unitpenalty;
 280         }else { //so this is either an old question or a close question type
 281             $options->unitpenalty = 1 ;
 282         }
 283         // if we came from the form then 'unitrole' exists
 284         if(isset($question->unitrole)){
 285             switch ($question->unitrole){
 286                 case '0' : $options->showunits = NUMERICALQUESTIONUNITNODISPLAY ;
 287                 break ;
 288                 case '1' : $options->showunits = NUMERICALQUESTIONUNITTEXTDISPLAY ;
 289                 break ;
 290                 case '2' : $options->showunits = NUMERICALQUESTIONUNITTEXTINPUTDISPLAY ;
 291                            $options->unitgradingtype = 0 ;
 292                 break ;
 293                 case '3' : $options->showunits = $question->multichoicedisplay ;
 294                            $options->unitgradingtype = $question->unitgradingtypes ;
 295                 break ;
 296             }
 297         } else {
 298             if(isset($question->showunits)){
 299                 $options->showunits = $question->showunits;
 300             }else {
 301                 if ($defaultunit = $this->get_default_numerical_unit($question)) {
 302                     // so units can be used
 303                     $options->showunits = NUMERICALQUESTIONUNITTEXTINPUTDISPLAY ;
 304                 }else {
 305                     // only numerical will be graded
 306                     $options->showunits = NUMERICALQUESTIONUNITNODISPLAY ;
 307                 }
 308             }
 309         }
 310         if(isset($question->unitsleft)){
 311             $options->unitsleft = $question->unitsleft;
 312         }else {
 313             $options->unitsleft = 0 ;
 314         }
 315         $options->instructionsformat = $question->instructions['format'];
 316         if(isset($question->instructions)){
 317             $options->instructions = trim($question->instructions['text']);
 318         }else {
 319             $options->instructions = '' ;
 320         }
 321         $component = 'qtype_' . $question->qtype;
 322         $options->instructions = file_save_draft_area_files($question->instructions['itemid'],
 323             $question->context->id,  // context
 324             $component,    // component
 325             'instruction', // filearea
 326             $question->id, // itemid
 327             self::$fileoptions, // options
 328             $question->instructions['text'] // text
 329         );
 330         if ($update) {
 331             $DB->update_record("question_numerical_options", $options);
 332         } else {
 333             $id = $DB->insert_record("question_numerical_options", $options);
 334         }
 335
 336         return $result;
 337     }
 338
 339     function save_numerical_units($question) {
 340         global $DB;
 341         $result = new stdClass;
 342
 343         // Delete the units previously saved for this question.
 344         $DB->delete_records('question_numerical_units', array('question' => $question->id));
 345
 346         // Nothing to do.
 347         if (!isset($question->multiplier)) {
 348             $result->units = array();
 349             return $result;
 350         }
 351
 352         // Save the new units.
 353         $units = array();
 354         $unitalreadyinsert = array();
 355         foreach ($question->multiplier as $i => $multiplier) {
 356             // Discard any unit which doesn't specify the unit or the multiplier
 357             if (!empty($question->multiplier[$i]) && !empty($question->unit[$i])&& !array_key_exists($question->unit[$i],$unitalreadyinsert)) {
 358                 $unitalreadyinsert[$question->unit[$i]] = 1 ;
 359                 $units[$i] = new stdClass;
 360                 $units[$i]->question = $question->id;
 361                 $units[$i]->multiplier = $this->apply_unit($question->multiplier[$i], array());
 362                 $units[$i]->unit = $question->unit[$i];
 363                 $DB->insert_record('question_numerical_units', $units[$i]);
 364             }
 365         }
 366         unset($question->multiplier, $question->unit);
 367
 368         $result->units = &$units;
 369         return $result;
 370     }
 371
 372     function create_session_and_responses(&$question, &$state, $cmoptions, $attempt) {
 373         $state->responses = array();
 374         $state->responses['answer'] =  '';
 375         $state->responses['unit'] = '';
 376
 377         return true;
 378     }
 379     function restore_session_and_responses(&$question, &$state) {
 380        if(false === strpos($state->responses[''], '|||||')){
 381              $state->responses['answer']= $state->responses[''];
 382              $state->responses['unit'] = '';
 383              $this->split_old_answer($state->responses[''], $question->options->units, $state->responses['answer'] ,$state->responses['unit'] );
 384        }else {
 385             $responses = explode('|||||', $state->responses['']);
 386             $state->responses['answer']= $responses[0];
 387             $state->responses['unit'] = $responses[1];
 388        }
 389
 390        return true;
 391     }
 392
 393     function find_unit_index(&$question,$value){
 394             $length = 0;
 395             $goodkey = 0 ;
 396             foreach ($question->options->units as $key => $unit){
 397                     if($unit->unit ==$value ) {
 398                     return $key ;
 399                 }
 400             }
 401         return 0 ;
 402     }
 403
 404     function split_old_answer($rawresponse, $units, &$answer ,&$unit ) {
 405         $answer = $rawresponse ;
 406         // remove spaces and normalise decimal places.
 407         $search  = array(' ', ',');
 408         $replace = array('', '.');
 409         $rawresponse = str_replace($search, $replace, trim($rawresponse));
 410         if (preg_match('~^([+-]?([0-9]+(\\.[0-9]*)?|\\.[0-9]+)([eE][-+]?[0-9]+)?)([^0-9].*)?$~',
 411                 $rawresponse, $responseparts)) {
 412             if(isset($responseparts[5]) ){
 413                 $unit = $responseparts[5] ;
 414             }
 415             if(isset($responseparts[1]) ){
 416                 $answer = $responseparts[1] ;
 417             }
 418         }
 419         return ;
 420     }
 421
 422
 423     function save_session_and_responses(&$question, &$state) {
 424         global $DB;
 425
 426         $responses = '';
 427         if(isset($state->responses['unit']) && isset($question->options->units[$state->responses['unit']])){
 428             $responses = $state->responses['answer'].'|||||'.$question->options->units[$state->responses['unit']]->unit;
 429         }else if(isset($state->responses['unit'])){
 430             $responses = $state->responses['answer'].'|||||'.$state->responses['unit'] ;
 431         }else {
 432             $responses = $state->responses['answer'].'|||||';
 433         }
 434         // Set the legacy answer field
 435         $DB->set_field('question_states', 'answer', $responses, array('id' => $state->id));
 436         return true;
 437     }
 438
 439     /**
 440      * Deletes question from the question-type specific tables
 441      *
 442      * @return boolean Success/Failure
 443      * @param object $question  The question being deleted
 444      */
 445     function delete_question($questionid) {
 446         global $DB;
 447         $DB->delete_records("question_numerical", array("question" => $questionid));
 448         $DB->delete_records("question_numerical_options", array("question" => $questionid));
 449         $DB->delete_records("question_numerical_units", array("question" => $questionid));
 450         return true;
 451     }
 452     /**
 453     * This function has been reinserted in numerical/questiontype.php to simplify
 454     * the separate rendering of number and unit
 455     */
 456     function print_question_formulation_and_controls(&$question, &$state, $cmoptions, $options) {
 457         global $CFG, $OUTPUT;
 458                 //echo"<p> ".$question->id."question->options<pre>";print_r($question->options) ;echo"</pre></p>";
 459                 //echo"<p> ".$question->id."state<pre>";print_r($state) ;echo"</pre></p>";
 460
 461         $context = $this->get_context_by_category_id($question->category);
 462         $readonly = empty($options->readonly) ? '' : 'readonly="readonly"';
 463         $formatoptions = new stdClass;
 464         $formatoptions->noclean = true;
 465         $formatoptions->para = false;
 466         $nameprefix = $question->name_prefix;
 467         $component = 'qtype_' . $question->qtype;
 468         // rewrite instructions text
 469         $question->options->instructions = quiz_rewrite_question_urls($question->options->instructions, 'pluginfile.php', $context->id, $component, 'instruction', array($state->attempt, $state->question), $question->id);
 470
 471         /// Print question text and media
 472
 473         $questiontext = format_text($question->questiontext,
 474                 $question->questiontextformat,
 475                 $formatoptions, $cmoptions->course);
 476
 477         /// Print input controls
 478         // as the entry is controlled the question type here is numerical
 479         // In all cases there is a text input for the number
 480         // If $question->options->showunits == NUMERICALQUESTIONUNITTEXTDISPLAY
 481         // there is an additional text input for the unit
 482         // If $question->options->showunits == NUMERICALQUESTIONUNITMULTICHOICEDISPLAY"
 483         // radio elements display the defined unit
 484         // The code allows the input number elememt to be displayed
 485         // before i.e. at left or after at rigth of the unit variants.
 486         $nameanswer = "name=\"".$question->name_prefix."answer\"";
 487         $nameunit   = "name=\"".$question->name_prefix."unit\"";
 488         // put old answer data in $state->responses['answer'] and $state->responses['unit']
 489         if (isset($state->responses['']) && $state->responses[''] != '' && !isset($state->responses['answer'])){
 490               $this->split_old_answer($state->responses[''], $question->options->units, $state->responses['answer'] ,$state->responses['unit'] );
 491         }
 492         // prepare the values of the input elements to be dispalyed answer i.e. number  and unit
 493         if (isset($state->responses['answer']) && $state->responses['answer']!='') {
 494             $valueanswer = ' value="'.s($state->responses['answer']).'" ';
 495         } else {
 496             $valueanswer = ' value="" ';
 497         }
 498         if (isset($state->responses['unit']) && $state->responses['unit']!='') {
 499             $valueunit = ' value="'.s($state->responses['unit']).'" ';
 500         } else {
 501             $valueunit = ' value="" ';
 502             if ($question->options->showunits == NUMERICALQUESTIONUNITTEXTDISPLAY ){
 503               $valueunit = ' value="'.s($question->options->units[0]->unit).'" ';
 504             }
 505         }
 506
 507         $feedback = '';
 508         $class = '';
 509         $classunit = '' ;
 510         $classunitvalue = '' ;
 511         $feedbackimg = '';
 512         $feedbackimgunit = '' ;
 513         $answerasterisk = false ;
 514         $response = '' ;
 515         $valid_numerical_unit = false ;
 516         $valid_numerical_unit_index = -1 ;
 517         $unit_in_numerical_answer = false ;
 518         $rawgrade = 0 ;
 519         if ($options->feedback) {
 520             $class = question_get_feedback_class(0);
 521             $classunit = question_get_feedback_class(0);
 522             $feedbackimg = question_get_feedback_image(0);
 523             $feedbackimgunit = question_get_feedback_image(0);
 524             $classunitvalue = 0 ;
 525             $valid_numerical_unit_index = -1 ;
 526             // if there is unit in answer and unitgradingtype = 0
 527             // the grade is 0
 528             //this is OK for the first answer with a good response
 529             // having to test for * so response as long as not empty
 530            // $response = $this->extract_numerical_response($state->responses['answer']);
 531             // test for a greater than 0 grade
 532             foreach($question->options->answers as $answer) {
 533                 if ($this->test_response($question, $state, $answer)) {
 534                     // Answer was correct or partially correct.
 535                     if ( $answer->answer === '*'){
 536                         $answerasterisk = true ;
 537                     }
 538                     // in all cases
 539                     $class = question_get_feedback_class($answer->fraction);
 540                     $feedbackimg = question_get_feedback_image($answer->fraction);
 541                     if ($question->options->unitgradingtype == 0 || ($question->options->unitgradingtype == 0 && $answer->answer === '*')){
 542                         // if * then unit has the $answer->fraction value
 543                         // if $question->options->unitgradingtype == 0 everything has been checked
 544                         // if $question->options->showunits == NUMERICALQUESTIONUNITTEXTINPUTDISPLAY
 545                         // then number - unit combination has been used to test response
 546                         // so the unit should have same color
 547                         $classunit = question_get_feedback_class($answer->fraction);
 548                         $feedbackimgunit = question_get_feedback_image($answer->fraction);
 549                         $rawgrade = $answer->fraction ;
 550
 551
 552                     }else {
 553                         // so we need to apply unit grading i.e. to check if the number-unit combination
 554                         // was the rigth one
 555                         // on NUMERICALQUESTIONUNITTEXTINPUTDISPLAY we need only to ckeck if applyunit will test OK
 556                         // with the $state->responses['unit'] value which cannot be empty
 557                         // if $state->responses['unit']
 558                         // if apply-unit is true with a specific unit as long as the unit as been written either in the
 559                         // we need the numerical response and test it with the available units
 560                         // if the unit used is good then it should be set OK
 561                         // however the unit could have been put in the number element in this case
 562                         // the unit penalty should be apllied.
 563                         // testing apply_unit with no units will get us a false response if there is any text in it
 564                         // testing apply_unit with a given unit will get a good value if the number is good with this unit
 565                         // apply unit will return the numerical if
 566                         // we need to know which conditions let to a good numerical value that were done in the
 567                         //
 568                            // echo"<p> unit grading > 0  asterisk <pre>";print_r($answer) ;echo"</pre></p>";
 569                         $valid_numerical_unit = false ;
 570                         $validunit = false ;
 571                         $rawgrade = $answer->fraction ;
 572                         $valid_numerical_unit_index = -1 ;
 573                         $invalid_unit_in_numerical_answer = false ;
 574                         if ( $answerasterisk ) {
 575                             $classunit = question_get_feedback_class($answer->fraction);
 576                             $feedbackimgunit = question_get_feedback_image($answer->fraction);
 577                             $valid_numerical_unit = true ;//everything is true with *
 578                             //echo"<p> answer asterisk <pre>";print_r($answer) ;echo"</pre></p>";
 579                         } else {
 580                             //echo"<p> else after answer asterisk <pre>";print_r($answer) ;echo"</pre></p>";
 581                           //  if( isset($state->responses['unit']) && $state->responses['unit'] != '' ){// unit should be written in the unit input or checked in multichoice
 582                             // we need to see if something was written in the answer field that was not in the number
 583                             // although we cannot actually detect units put before the number which will cause bad numerical.
 584                             // use extract response
 585                             $response = $this->extract_numerical_response($state->responses['answer']);
 586                             if(isset($response->unit ) && $response->unit != ''){
 587                                 $unit_in_numerical_answer = true ;
 588                             }else {
 589                                 $unit_in_numerical_answer = false ;
 590                             }
 591
 592                             // the we let the testing to the two cases either
 593                             // NUMERICALQUESTIONUNITTEXTINPUTDISPLAY or
 594                             // NUMERICALQUESTIONUNITMULTICHOICEDISPLAY
 595                             if( !isset($state->responses['unit']) || $state->responses['unit'] == '' ){
 596                                 // unit should be written in the unit input or checked in multichoice
 597                                 $valid_numerical_unit = false ;
 598                                 $classunit = question_get_feedback_class(0);
 599                                 $feedbackimgunit = question_get_feedback_image(0);
 600                                 $empty_unit = true ;
 601                             } else {
 602                                // echo"<p> some unit answer <pre>";print_r($answer) ;echo"</pre></p>";
 603                                // echo"<p> some unit answer <pre>";print_r($answer) ;echo"</pre></p>";
 604                                 $empty_unit = false ;
 605                                 $valid_numerical_unit = false ;
 606
 607                                 foreach ($question->options->units as $key => $unit) {
 608                                     if ($unit->unit == $state->responses['unit']){
 609                                     //    $response = $this->apply_unit($state->responses['answer'].$unit->unit, array($question->options->units[$key])) ;
 610                                 //       echo "<p> avant false valid_numerical_unit_index $valid_numerical_unit_index  ".$state->responses['answer']."</p>";
 611                                         $invalid_unit_found = 0 ;
 612                                         if ($response->number !== false) {
 613                                 //echo "<p> avanr get valid_numerical_unit_index $valid_numerical_unit_index  </p>";
 614                                        //     $this->get_tolerance_interval($answer);
 615                                        $testresponse = $response->number /$unit->multiplier ;
 616                                             if($answer->min <= $testresponse && $testresponse <= $answer->max){
 617                                 //echo "<p> apres min max  valid_numerical_unit_index $valid_numerical_unit_index  </p>";
 618                                                 $classunit = question_get_feedback_class($answer->fraction) ; //question_get_feedback_class(1);
 619                                                 $feedbackimgunit = question_get_feedback_image($rawgrade);
 620                                                 $valid_numerical_unit = true ;
 621                                                 $validunit = true ;
 622                                                 $valid_numerical_unit_index = $key ;
 623                                                 break ;
 624                                             }
 625                                         }
 626                                     } // else
 627
 628                                    // }
 629                                 }
 630                                 //echo "<p> apres la boucle valid_numerical_unit $valid_numerical_unit valid_numerical_unit_index $valid_numerical_unit_index  </p>";
 631
 632                             }
 633                         }
 634                     }
 635                     //     echo "<p> dans  valid_numerical_unit_index $valid_numerical_unit_index  </p>";
 636                     if ($answer->feedback) {
 637                         $answer->feedback = quiz_rewrite_question_urls($answer->feedback, 'pluginfile.php', $context->id, 'question', 'answerfeedback', array($state->attempt, $state->question), $answer->id);
 638                         $feedback = format_text($answer->feedback, true, $formatoptions, $cmoptions->course);
 639                     }
 640
 641                     break;
 642                 }
 643             }
 644
 645
 646     }
 647    // echo "<p> rawgrade $rawgrade classunit $classunit valid_numerical_unit_index $valid_numerical_unit_index ".$feedbackimgunit."</p>";
 648         $state->options->raw_unitpenalty = 0 ;
 649         $raw_unitpenalty = 0 ;
 650         if( $question->options->showunits == NUMERICALQUESTIONUNITNODISPLAY ||
 651                 $question->options->showunits == NUMERICALQUESTIONUNITTEXTDISPLAY ) {
 652                     $classunitvalue = 1 ;
 653         }
 654
 655         if(! $answerasterisk  && $question->options->unitgradingtype != 0 && (! $valid_numerical_unit || $unit_in_numerical_answer)){
 656             if($question->options->unitgradingtype == 1){
 657                 $raw_unitpenalty = $question->options->unitpenalty * $rawgrade ;
 658             }else {
 659                 $raw_unitpenalty = $question->options->unitpenalty * $question->maxgrade;
 660             }
 661             $state->options->raw_unitpenalty = $raw_unitpenalty ;
 662         }
 663
 664         /// Removed correct answer, to be displayed later MDL-7496
 665         include("$CFG->dirroot/question/type/numerical/display.html");
 666     }
 667
 668
 669     function compare_responses(&$question, $state, $teststate) {
 670
 671                if ($question->options->showunits == NUMERICALQUESTIONUNITMULTICHOICEDISPLAY && isset($question->options->units) && isset($state->responses['unit']) && isset($question->options->units[$state->responses['unit']] )){
 672             $state->responses['unit']=$question->options->units[$state->responses['unit']]->unit;
 673         };
 674
 675
 676         $responses = '';
 677         $testresponses = '';
 678         if (isset($state->responses['answer'])){
 679             $responses = $state->responses['answer'];
 680         }
 681         if (isset($state->responses['unit'])){
 682             $responses .= $state->responses['unit'];
 683         }
 684         if (isset($teststate->responses['answer'])){
 685             $testresponses = $teststate->responses['answer'];
 686         }
 687         if (isset($teststate->responses['unit'])){
 688             $testresponses .= $teststate->responses['unit'];
 689         }
 690
 691         if ( isset($responses)  && isset($testresponses )) {
 692
 693             return $responses == $testresponses ;
 694         }
 695         return false;
 696     }
 697
 698     /**
 699      * Checks whether a response matches a given answer, taking the tolerance
 700      * and but NOT the unit into account. Returns a true for if a response matches the
 701      * answer or in one of the unit , false if it doesn't.
 702      * the total grading will see if the unit match.
 703      * if unit != -1 then the test is done only on this unit
 704      */
 705     function test_response(&$question, &$state, $answer ) {
 706         // Deal with the match anything answer.
 707         //        echo"<p> test_response answer    <pre>";print_r($answer) ;echo"</pre></p>";
 708         //        echo"<p>test_response state    <pre>";print_r($state) ;echo"</pre></p>";
 709         if ($answer->answer === '*') {
 710             return true;
 711         }
 712         // using old grading process if $question->unitgradingtype == 0
 713         // and adding unit1 for the new option NUMERICALQUESTIONUNITTEXTDISPLAY
 714         if ($question->options->unitgradingtype == 0 ){
 715             // values coming form old question stored in attempts
 716             if (!isset($state->responses['answer']) && isset($state->responses[''])){
 717                $state->responses['answer'] =  $state->responses[''];
 718             }
 719             $answertotest = $state->responses['answer'];
 720             // values coming from  NUMERICALQUESTIONUNITTEXTINPUTDISPLAY
 721             // or NUMERICALQUESTIONUNITTEXTDISPLAY as unit hidden HTML element
 722             if(isset($state->responses['unit'])) {
 723                 $answertotest .= $state->responses['unit'] ;
 724             }
 725           //  if ($question->options->showunits == NUMERICALQUESTIONUNITTEXTDISPLAY && isset($question->options->units[0])){
 726            //     $answertotest .= $question->options->units[0]->unit ;
 727            // }
 728            // test OK if only numerical or numerical with known unit names with the unit mltiplier applied
 729             $response = $this->apply_unit($answertotest, $question->options->units);
 730       //          echo"<p> dans response  apres apply  <pre>";print_r($response) ;echo"</pre></p>";
 731
 732             if ($response === false) {
 733                 return false; // The student did not type a number.
 734             }
 735
 736             // The student did type a number, so check it with tolerances.
 737             $this->get_tolerance_interval($answer);
 738       //          echo"<p> test_response apres get tolerance interval answer    <pre>";print_r($answer) ;echo"</pre></p>";
 739             return ($answer->min <= $response && $response <= $answer->max);
 740         }else { // $question->options->unitgradingtype > 0
 741             /* testing with unitgradingtype $question->options->unitgradingtype > 0
 742             * if the response is at least patially true
 743             * if the numerical value agree in the interval
 744             * if so the only non valid case will be a bad unit and a unity penalty.
 745
 746              To be able to test (old) questions that do not have an unit
 747             * input element the test is done using the $state->responses['']
 748             * which contains the response which is analyzed by extract_numerical_response()
 749             * If the data comes from the numerical or calculated display
 750             * the $state->responses['unit'] comes from either
 751             * a multichoice radio element NUMERICALQUESTIONUNITMULTICHOICEDISPLAY
 752             * where the $state->responses['unit'] value is the key => unit object
 753             * in the  the $question->options->units array
 754             * or an input text element NUMERICALQUESTIONUNITTEXTINPUTDISPLAY
 755             * which contains the student response
 756             * for NUMERICALQUESTIONUNITTEXTDISPLAY and NUMERICALQUESTIONUNITNODISPLAY
 757             *
 758             */
 759
 760             $response = $this->extract_numerical_response($state->responses['answer']);
 761
 762            //     echo"<p> response    <pre>";print_r($response) ;echo"</pre></p>";
 763               //  echo"<p> response    <pre>";print_r($response) ;echo"</pre></p>";
 764
 765             if ($response->number === false ) {
 766                 return false; // The student did not type a number.
 767             }
 768
 769             // The student did type a number, so check it with tolerances.
 770             $this->get_tolerance_interval($answer);
 771             if ($answer->min <= $response->number && $response->number <= $answer->max){
 772              //   echo"<p> response  true  <pre>";print_r($response) ;echo"</pre></p>";
 773                return true;
 774             }
 775             // testing for other units
 776             if ( isset($question->options->units) && count($question->options->units) > 0) {
 777                 foreach($question->options->units as $key =>$unit){
 778                     $testresponse = $response->number /$unit->multiplier ;
 779                     if($answer->min <= $testresponse && $testresponse<= $answer->max) {
 780                         return true;
 781                     }
 782                 }
 783             }
 784             return false;
 785         }
 786         return false;
 787     }
 788
 789     /**
 790     * Performs response processing and grading
 791     * The function was redefined for handling correctly the two parts
 792     * number and unit of numerical or calculated questions
 793     * The code handles also the case when there no unit defined by the user or
 794     * when used in a multianswer (Cloze) question.
 795     * This function performs response processing and grading and updates
 796     * the state accordingly.
 797     * @return boolean         Indicates success or failure.
 798     * @param object $question The question to be graded. Question type
 799     *                         specific information is included.
 800     * @param object $state    The state of the question to grade. The current
 801     *                         responses are in ->responses. The last graded state
 802     *                         is in ->last_graded (hence the most recently graded
 803     *                         responses are in ->last_graded->responses). The
 804     *                         question type specific information is also
 805     *                         included. The ->raw_grade and ->penalty fields
 806     *                         must be updated. The method is able to
 807     *                         close the question session (preventing any further
 808     *                         attempts at this question) by setting
 809     *                         $state->event to QUESTION_EVENTCLOSEANDGRADE
 810     * @param object $cmoptions
 811     */
 812     function grade_responses(&$question, &$state, $cmoptions) {
 813        // echo"<p>grade question->options<pre>";print_r($question->options) ;echo"</pre></p>";
 814       //  echo"<p>grade state response<pre>";print_r($state->responses) ;echo"</pre></p>";
 815         /*        if (!isset($state->responses['answer']) && isset($state->responses[''])){
 816            $state->responses['answer'] =  $state->responses[''];
 817         }*/
 818         if ( isset($state->responses['']) && $state->responses[''] != '' && !isset($state->responses['answer'])){
 819               $this->split_old_answer($state->responses[''], $question->options->units, $state->responses['answer'] ,$state->responses['unit'] );
 820         }
 821
 822         //to apply the unit penalty we need to analyse the response in a more complex way
 823         //the apply_unit() function analysis could be used to obtain the infos
 824         // however it is used to detect good or bad numbers but also
 825         // gives false if there is a unit
 826         $state->raw_grade = 0;
 827         $valid_numerical_unit = false ;
 828         $break = 0 ;
 829         $unittested = '';
 830         $hasunits = 0 ;
 831        // $response = $this->extract_numerical_response($state->responses['answer']);
 832         $answerasterisk = false ;
 833
 834         $break = 0 ;
 835         foreach($question->options->answers as $answer) {
 836             if ($this->test_response($question, $state, $answer)) {
 837                 // Answer was correct or partially correct.
 838                 $state->raw_grade = $answer->fraction ;
 839                 if ($question->options->unitgradingtype == 0 || $answer->answer === '*'){
 840                     // if * then unit has the $answer->fraction value
 841                     // if $question->options->unitgradingtype == 0 everything has been checked
 842                     // if $question->options->showunits == NUMERICALQUESTIONUNITTEXTINPUTDISPLAY
 843                     // then number - unit combination has been used to test response
 844                     // so the unit should have same color
 845
 846                 }else {
 847                     // so we need to apply unit grading i.e. to check if the number-unit combination
 848                     // was the rigth one
 849                     $valid_numerical_unit = false ;
 850                     $class = question_get_feedback_class($answer->fraction);
 851                     $feedbackimg = question_get_feedback_image($answer->fraction);
 852                     if(isset($state->responses['unit']) && $state->responses['unit'] != '' ){
 853                         foreach ($question->options->units as $key => $unit) {
 854                             if ($unit->unit == $state->responses['unit']){
 855
 856                                 $response = $this->apply_unit($state->responses['answer'].$state->responses['unit'], array($question->options->units[$key])) ;
 857                                 if ($response !== false) {
 858                                     $this->get_tolerance_interval($answer);
 859                                     if($answer->min <= $response && $response <= $answer->max){
 860                                         $valid_numerical_unit = true ;
 861                                     }
 862                                 }
 863                                 break ;
 864                             }
 865                         }
 866                     }
 867                 }
 868                 break ;
 869             }
 870         }
 871         // apply unit penalty
 872         $raw_unitpenalty = 0 ;
 873         if($question->options->unitgradingtype != 0 && !empty($question->options->unitpenalty)&& $valid_numerical_unit != true ){
 874             if($question->options->unitgradingtype == 1){
 875                 $raw_unitpenalty = $question->options->unitpenalty * $state->raw_grade ;
 876             }else {
 877                 $raw_unitpenalty = $question->options->unitpenalty * $question->maxgrade;
 878             }
 879             $state->raw_grade -= $raw_unitpenalty ;
 880         }
 881
 882         // Make sure we don't assign negative or too high marks.
 883         $state->raw_grade = min(max((float) $state->raw_grade,
 884                             0.0), 1.0) * $question->maxgrade;
 885
 886         // Update the penalty.
 887         $state->penalty = $question->penalty * $question->maxgrade;
 888
 889         // mark the state as graded
 890         $state->event = ($state->event ==  QUESTION_EVENTCLOSE) ? QUESTION_EVENTCLOSEANDGRADE : QUESTION_EVENTGRADE;
 891
 892         return true;
 893     }
 894
 895
 896     function get_correct_responses(&$question, &$state) {
 897         $correct = parent::get_correct_responses($question, $state);
 898         $unit = $this->get_default_numerical_unit($question);
 899         if (isset($correct['']) && $correct[''] != '*' && $unit) {
 900             $correct[''] .= ' '.$unit->unit;
 901         }
 902         return $correct;
 903     }
 904
 905     // ULPGC ecastro
 906     function get_all_responses(&$question, &$state) {
 907         $result = new stdClass;
 908         $answers = array();
 909         $unit = $this->get_default_numerical_unit($question);
 910         if (is_array($question->options->answers)) {
 911             foreach ($question->options->answers as $aid=>$answer) {
 912                 $r = new stdClass;
 913                 $r->answer = $answer->answer;
 914                 $r->credit = $answer->fraction;
 915                 $this->get_tolerance_interval($answer);
 916                 if ($r->answer != '*' && $unit) {
 917                     $r->answer .= ' ' . $unit->unit;
 918                 }
 919                 if ($answer->max != $answer->min) {
 920                     $max = "$answer->max"; //format_float($answer->max, 2);
 921                     $min = "$answer->min"; //format_float($answer->max, 2);
 922                     $r->answer .= ' ('.$min.'..'.$max.')';
 923                 }
 924                 $answers[$aid] = $r;
 925             }
 926         }
 927         $result->id = $question->id;
 928         $result->responses = $answers;
 929         return $result;
 930     }
 931     function get_actual_response($question, $state) {
 932        if (!empty($state->responses) && !empty($state->responses[''])) {
 933            if(false === strpos($state->responses[''], '|||||')){
 934                 $responses[] = $state->responses[''];
 935             }else {
 936                 $resp = explode('|||||', $state->responses['']);
 937                 $responses[] = $resp[0].$resp[1];
 938             }
 939        } else {
 940            $responses[] = '';
 941         }
 942
 943        return $responses;
 944     }
 945
 946
 947     function get_tolerance_interval(&$answer) {
 948         // No tolerance
 949         if (empty($answer->tolerance)) {
 950             $answer->tolerance = 0;
 951         }
 952
 953         // Calculate the interval of correct responses (min/max)
 954         if (!isset($answer->tolerancetype)) {
 955             $answer->tolerancetype = 2; // nominal
 956         }
 957
 958         // We need to add a tiny fraction depending on the set precision to make the
 959         // comparison work correctly. Otherwise seemingly equal values can yield
 960         // false. (fixes bug #3225)
 961         $tolerance = (float)$answer->tolerance + ("1.0e-".ini_get('precision'));
 962         switch ($answer->tolerancetype) {
 963             case '1': case 'relative':
 964                 /// Recalculate the tolerance and fall through
 965                 /// to the nominal case:
 966                 $tolerance = $answer->answer * $tolerance;
 967                 // Do not fall through to the nominal case because the tiny fraction is a factor of the answer
 968                  $tolerance = abs($tolerance); // important - otherwise min and max are swapped
 969                 $max = $answer->answer + $tolerance;
 970                 $min = $answer->answer - $tolerance;
 971                 break;
 972             case '2': case 'nominal':
 973                 $tolerance = abs($tolerance); // important - otherwise min and max are swapped
 974                 // $answer->tolerance 0 or something else
 975                 if ((float)$answer->tolerance == 0.0  &&  abs((float)$answer->answer) <= $tolerance ){
 976                     $tolerance = (float) ("1.0e-".ini_get('precision')) * abs((float)$answer->answer) ; //tiny fraction
 977                 } else if ((float)$answer->tolerance != 0.0 && abs((float)$answer->tolerance) < abs((float)$answer->answer) &&  abs((float)$answer->answer) <= $tolerance){
 978                     $tolerance = (1+("1.0e-".ini_get('precision')) )* abs((float) $answer->tolerance) ;//tiny fraction
 979                }
 980
 981                 $max = $answer->answer + $tolerance;
 982                 $min = $answer->answer - $tolerance;
 983                 break;
 984             case '3': case 'geometric':
 985                 $quotient = 1 + abs($tolerance);
 986                 $max = $answer->answer * $quotient;
 987                 $min = $answer->answer / $quotient;
 988                 break;
 989             default:
 990                 print_error('unknowntolerance', 'question', '', $answer->tolerancetype);
 991         }
 992
 993         $answer->min = $min;
 994         $answer->max = $max;
 995         return true;
 996     }
 997
 998     /**
 999      * Checks if the $rawresponse has a unit and applys it if appropriate.
1000      *
1001      * @param string $rawresponse  The response string to be converted to a float.
1002      * @param array $units         An array with the defined units, where the
1003      *                             unit is the key and the multiplier the value.
1004      * @return float               The rawresponse with the unit taken into
1005      *                             account as a float.
1006      */
1007     function extract_numerical_response($rawresponse) {
1008         $extractedresponse = new stdClass() ;
1009         $rawresponse = trim($rawresponse) ;
1010         $search  = array(' ', ',');
1011         // test if a . is present or there are multiple , (i.e. 2,456,789 ) so that we don't need spaces and ,
1012         if ( strpos($rawresponse,'.' ) !== false || substr_count($rawresponse,',') > 1 ) {
1013             $replace = array('', '');
1014         }else { // remove spaces and normalise , to a . .
1015             $replace = array('', '.');
1016         }
1017         $rawresponse = str_replace($search, $replace, $rawresponse);
1018
1019          if (preg_match('~^([+-]?([0-9]+(\\.[0-9]*)?|\\.[0-9]+)([eE][-+]?[0-9]+)?)([^0-9].*)?$~',
1020                 $rawresponse, $responseparts)) {
1021         //return (float)$responseparts[1] ;
1022             $extractedresponse->number = (float)$responseparts[1] ;
1023         }else {
1024             $extractedresponse->number = false ;
1025         }
1026         if (!empty($responseparts[5])) {
1027             $extractedresponse->unit = $responseparts[5] ;
1028         }else {
1029             $extractedresponse->unit = '';
1030         }
1031
1032         // Invalid number. Must be wrong.
1033         return clone($extractedresponse) ;
1034     }
1035     /**
1036      * Checks if the $rawresponse has a unit and applys it if appropriate.
1037      *
1038      * @param string $rawresponse  The response string to be converted to a float.
1039      * @param array $units         An array with the defined units, where the
1040      *                             unit is the key and the multiplier the value.
1041      * @return float               The rawresponse with the unit taken into
1042      *                             account as a float.
1043      */
1044     function apply_unit($rawresponse, $units) {
1045            //     echo"<p> rawresponse $rawresponse <pre>";print_r($units) ;echo"</pre></p>";
1046
1047         // Make units more useful
1048         $tmpunits = array();
1049         foreach ($units as $unit) {
1050             $tmpunits[$unit->unit] = $unit->multiplier;
1051         }
1052         // remove spaces and normalise decimal places.
1053         $rawresponse = trim($rawresponse) ;
1054         $search  = array(' ', ',');
1055         // test if a . is present or there are multiple , (i.e. 2,456,789 ) so that we don't need spaces and ,
1056         if ( strpos($rawresponse,'.' ) !== false || substr_count($rawresponse,',') > 1 ) {
1057             $replace = array('', '');
1058         }else { // remove spaces and normalise , to a . .
1059             $replace = array('', '.');
1060         }
1061         $rawresponse = str_replace($search, $replace, $rawresponse);
1062
1063
1064         // Apply any unit that is present.
1065         if (ereg('^([+-]?([0-9]+(\\.[0-9]*)?|\\.[0-9]+)([eE][-+]?[0-9]+)?)([^0-9].*)?$',
1066                 $rawresponse, $responseparts)) {
1067            //     echo"<p> responseparts <pre>";print_r($responseparts) ;echo"</pre></p>";
1068
1069             if (!empty($responseparts[5])) {
1070
1071                 if (isset($tmpunits[$responseparts[5]])) {
1072                     // Valid number with unit.
1073                     return (float)$responseparts[1] / $tmpunits[$responseparts[5]];
1074                 } else {
1075                     // Valid number with invalid unit. Must be wrong.
1076                     return false;
1077                 }
1078
1079             } else {
1080                 // Valid number without unit.
1081                 return (float)$responseparts[1];
1082             }
1083         }
1084         // Invalid number. Must be wrong.
1085         return false;
1086     }
1087
1088     /**
1089     * function used in function definition_inner()
1090     * of edit_..._form.php for
1091     * numerical, calculated, calculatedsimple
1092     */
1093     function add_units_options(&$mform, &$that){
1094         // Units are graded
1095         $mform->addElement('header', 'unithandling', get_string('unitshandling', 'qtype_numerical'));
1096         $mform->addElement('radio', 'unitrole', get_string('unitnotused', 'qtype_numerical'), get_string('onlynumerical', 'qtype_numerical'),0);
1097       //  $mform->addElement('header', 'unithandling1', get_string('unitnotgraded', 'qtype_numerical'));
1098         $mform->addElement('radio', 'unitrole', get_string('unitdisplay', 'qtype_numerical'), get_string('oneunitshown', 'qtype_numerical'),1);
1099         $mform->addElement('radio', 'unitrole', get_string('unitsused', 'qtype_numerical'), get_string('manynumerical', 'qtype_numerical'),2);
1100       /*  $showunits1grp = array();
1101         $showunits1grp[] = & $mform->createElement('radio', 'showunits1', '', get_string('no', 'moodle'),3);
1102         $showunits1grp[] = & $mform->createElement('radio', 'showunits1', '', get_string('yes', 'moodle'),2);*/
1103        // $mform->addGroup($showunits1grp, 'showunits1grp', get_string('unitdisplay', 'qtype_numerical'),' ' , false);
1104         $mform->addElement('static', 'separator2', '', '<HR/>');
1105         $mform->addElement('radio', 'unitrole', get_string('unitgraded1', 'qtype_numerical'), get_string('unitgraded', 'qtype_numerical'),3);
1106         $penaltygrp = array();
1107         $penaltygrp[] =& $mform->createElement('text', 'unitpenalty', get_string('unitpenalty', 'qtype_numerical') ,
1108                 array('size' => 6));
1109         $unitgradingtypes = array('1' => get_string('decfractionofquestiongrade', 'qtype_numerical'), '2' => get_string('decfractionofresponsegrade', 'qtype_numerical'));
1110         $penaltygrp[] =& $mform->createElement('select', 'unitgradingtypes', '' , $unitgradingtypes );
1111         $mform->addGroup($penaltygrp, 'penaltygrp', get_string('unitpenalty', 'qtype_numerical'),' ' , false);
1112         $multichoicedisplaygrp = array();
1113         $multichoicedisplaygrp[] =& $mform->createElement('radio', 'multichoicedisplay', get_string('unitedit', 'qtype_numerical'), get_string('editableunittext', 'qtype_numerical'),0);
1114         $multichoicedisplaygrp[] =& $mform->createElement('radio', 'multichoicedisplay', get_string('selectunits', 'qtype_numerical') , get_string('unitchoice', 'qtype_numerical'),1);
1115         $mform->addGroup($multichoicedisplaygrp, 'multichoicedisplaygrp', get_string('studentunitanswer', 'qtype_numerical'),' OR ' , false);
1116
1117
1118
1119         $unitslefts = array('0' => get_string('rightexample', 'qtype_numerical'),'1' => get_string('leftexample', 'qtype_numerical'));
1120         $mform->addElement('select', 'unitsleft', get_string('unitposition', 'qtype_numerical') , $unitslefts );
1121
1122         $mform->addElement('static', 'separator2', '<HR/>', '<HR/>');
1123
1124
1125         $mform->addElement('editor', 'instructions', get_string('instructions', 'qtype_numerical'), null, $that->editoroptions);
1126 //        $mform->addElement('static', 'separator1', '<HR/>', '<HR/>');
1127         // Units are not graded
1128         $showunits1grp = array();
1129         $mform->addElement('static', 'separator2', '<HR/>', '<HR/>');
1130
1131         $mform->setType('unitpenalty', PARAM_NUMBER);
1132         $mform->setDefault('unitpenalty', 0.1);
1133         $mform->setDefault('unitgradingtypes', 1);
1134         $mform->addHelpButton('penaltygrp', 'unitpenalty', 'qtype_numerical'); // TODO help did not exist before MDL-21695
1135        // $mform->setDefault('multichoicedisplay', 1);
1136       //  $mform->setDefault('showunits1', 3);
1137         $mform->setDefault('unitsleft', 0);
1138         $mform->setType('instructions', PARAM_RAW);
1139       //  $mform->addHelpButton('instructions', 'unituses', 'qtype_numerical');
1140         $mform->addHelpButton('instructions', 'numericalinstructions', 'qtype_numerical');
1141         $mform->disabledIf('penaltygrp', 'unitrole','eq','0');
1142         $mform->disabledIf('penaltygrp', 'unitrole','eq','1');
1143         $mform->disabledIf('penaltygrp', 'unitrole','eq','2');
1144       //  $mform->disabledIf('unitgradingtype', 'unitrole','eq','1');
1145       //  $mform->disabledIf('instructions', 'unitrole','eq','1');
1146          $mform->disabledIf('unitsleft', 'unitrole','eq','0');
1147       //  $mform->disabledIf('showunits1','unitrole','eq','0');
1148          $mform->disabledIf('multichoicedisplay','unitrole','eq','0');
1149          $mform->disabledIf('multichoicedisplay','unitrole','eq','1');
1150          $mform->disabledIf('multichoicedisplay','unitrole','eq','2');
1151
1152
1153     }
1154
1155     /**
1156      * function used in in function definition_inner()
1157      * of edit_..._form.php for
1158      * numerical, calculated, calculatedsimple
1159      */
1160     function add_units_elements(& $mform,& $that) {
1161         $repeated = array();
1162         $repeated[] =& $mform->createElement('header', 'unithdr', get_string('unithdr', 'qtype_numerical', '{no}'));
1163
1164         $repeated[] =& $mform->createElement('text', 'unit', get_string('unit', 'quiz'));
1165         $mform->setType('unit', PARAM_NOTAGS);
1166
1167         $repeated[] =& $mform->createElement('text', 'multiplier', get_string('multiplier', 'quiz'));
1168         $mform->setType('multiplier', PARAM_NUMBER);
1169
1170         if (isset($that->question->options)){
1171             $countunits = count($that->question->options->units);
1172         } else {
1173             $countunits = 0;
1174         }
1175         if ($that->question->formoptions->repeatelements){
1176             $repeatsatstart = $countunits + 1;
1177         } else {
1178             $repeatsatstart = $countunits;
1179         }
1180         $that->repeat_elements($repeated, $repeatsatstart, array(), 'nounits', 'addunits', 2, get_string('addmoreunitblanks', 'qtype_calculated', '{no}'));
1181
1182         if ($mform->elementExists('multiplier[0]')){
1183             $firstunit =& $mform->getElement('multiplier[0]');
1184             $firstunit->freeze();
1185             $firstunit->setValue('1.0');
1186             $firstunit->setPersistantFreeze(true);
1187             $mform->addHelpButton('multiplier[0]', 'numericalmultiplier', 'qtype_numerical');
1188         }
1189     }
1190
1191     /**
1192       * function used in in function data_preprocessing() of edit_numerical_form.php for
1193       * numerical, calculated, calculatedsimple
1194       */
1195     function set_numerical_unit_data($mform, &$question, &$default_values){
1196
1197         list($categoryid) = explode(',', $question->category);
1198         $context = $this->get_context_by_category_id($categoryid);
1199
1200         if (isset($question->options)){
1201             $default_values['unitgradingtypes'] = 1 ;
1202             if ($question->options->unitgradingtype == 2 ) {
1203                 $default_values['unitgradingtypes'] = 1 ;
1204             }
1205             if ($question->options->unitgradingtype == 0 ) {
1206                 $default_values['unitgradingtypes'] = 0 ;
1207             }
1208             $default_values['unitpenalty'] = $question->options->unitpenalty ;
1209             switch ($question->options->showunits){
1210                 case 0 :// NUMERICALQUESTIONUNITTEXTINPUTDISPLAY
1211                     if($question->options->unitgradingtype == 0 ){
1212                         $default_values['unitrole'] = 2 ;
1213                         $default_values['multichoicedisplay'] = 0 ;
1214                     }else { // 1 or 2
1215                         $default_values['unitrole'] = 3 ;
1216                         $default_values['multichoicedisplay'] = 0 ;
1217                         $default_values['unitgradingtypes'] = $question->options->unitgradingtype ;
1218                     }
1219                     break;
1220                 case 1 : // NUMERICALQUESTIONUNITMULTICHOICEDISPLAY
1221                     $default_values['unitrole'] = 3 ;
1222                     $default_values['multichoicedisplay'] = $question->options->unitgradingtype ;
1223                     $default_values['unitgradingtypes'] = $question->options->unitgradingtype ;
1224                     break;
1225                 case 2 : // NUMERICALQUESTIONUNITTEXTDISPLAY
1226                     $default_values['unitrole'] = 1 ;
1227                 case 3 : // NUMERICALQUESTIONUNITNODISPLAY
1228                     $default_values['unitrole'] = 0 ;
1229                   //  $default_values['showunits1'] = $question->options->showunits ;
1230                     break;
1231             }
1232             $default_values['unitsleft'] = $question->options->unitsleft ;
1233          //   $question->unitrole = $default_values['unitrole'] ;
1234
1235             // processing files
1236             $component = 'qtype_' . $question->qtype;
1237             $draftid = file_get_submitted_draft_itemid('instructions');
1238             $default_values['instructions'] = array();
1239             $default_values['instructions']['format'] = $question->options->instructionsformat;
1240             $default_values['instructions']['text'] = file_prepare_draft_area(
1241                 $draftid,       // draftid
1242                 $context->id,   // context
1243                 $component,     // component
1244                 'instruction',  // filarea
1245                 !empty($question->id)?(int)$question->id:null, // itemid
1246                 $mform->fileoptions,    // options
1247                 $question->options->instructions // text
1248             );
1249             $default_values['instructions']['itemid'] = $draftid;
1250
1251             if (isset($question->options->units)) {
1252                 $units  = array_values($question->options->units);
1253                 if (!empty($units)) {
1254                     foreach ($units as $key => $unit){
1255                         $default_values['unit['.$key.']'] = $unit->unit;
1256                         $default_values['multiplier['.$key.']'] = $unit->multiplier;
1257                     }
1258                 }
1259             }
1260         }
1261     }
1262
1263     /**
1264       * function use in in function validation()
1265       * of edit_..._form.php for
1266       * numerical, calculated, calculatedsimple
1267       */
1268
1269     function validate_numerical_options(& $data, & $errors){
1270         $units  = $data['unit'];
1271             switch ($data['unitrole']){
1272                 case '0' : $showunits = NUMERICALQUESTIONUNITNODISPLAY ;
1273                 break ;
1274                 case '1' : $showunits = NUMERICALQUESTIONUNITTEXTDISPLAY ;
1275                 break ;
1276                 case '2' : $showunits = NUMERICALQUESTIONUNITTEXTINPUTDISPLAY ;
1277                 break ;
1278                 case '3' : $showunits = $data['multichoicedisplay'] ;
1279                 break ;
1280             }
1281
1282         if (($showunits == NUMERICALQUESTIONUNITTEXTINPUTDISPLAY) ||
1283                 ($showunits == NUMERICALQUESTIONUNITMULTICHOICEDISPLAY ) ||
1284                 ($showunits == NUMERICALQUESTIONUNITTEXTDISPLAY )){
1285            if (trim($units[0]) == ''){
1286              $errors['unit[0]'] = 'You must set a valid unit name' ;
1287             }
1288         }
1289         if ($showunits == NUMERICALQUESTIONUNITNODISPLAY ){
1290             if (count($units)) {
1291                 foreach ($units as $key => $unit){
1292                     if ($units[$key] != ''){
1293                     $errors["unit[$key]"] = 'You must erase this unit name' ;
1294                     }
1295                 }
1296             }
1297         }
1298
1299
1300         // Check double units.
1301         $alreadyseenunits = array();
1302         if (isset($data['unit'])) {
1303             foreach ($data['unit'] as $key => $unit) {
1304                 $trimmedunit = trim($unit);
1305                 if ($trimmedunit!='' && in_array($trimmedunit, $alreadyseenunits)) {
1306                     $errors["unit[$key]"] = get_string('errorrepeatedunit', 'qtype_numerical');
1307                     if (trim($data['multiplier'][$key]) == '') {
1308                         $errors["multiplier[$key]"] = get_string('errornomultiplier', 'qtype_numerical');
1309                     }
1310                 } elseif($trimmedunit!='') {
1311                     $alreadyseenunits[] = $trimmedunit;
1312                 }
1313             }
1314         }
1315              $units  = $data['unit'];
1316             if (count($units)) {
1317                 foreach ($units as $key => $unit){
1318                     if (is_numeric($unit)){
1319                         $errors['unit['.$key.']'] = get_string('mustnotbenumeric', 'qtype_calculated');
1320                     }
1321                     $trimmedunit = trim($unit);
1322                     $trimmedmultiplier = trim($data['multiplier'][$key]);
1323                     if (!empty($trimmedunit)){
1324                         if (empty($trimmedmultiplier)){
1325                             $errors['multiplier['.$key.']'] = get_string('youmustenteramultiplierhere', 'qtype_calculated');
1326                         }
1327                         if (!is_numeric($trimmedmultiplier)){
1328                             $errors['multiplier['.$key.']'] = get_string('mustbenumeric', 'qtype_calculated');
1329                         }
1330
1331                     }
1332                 }
1333             }
1334
1335     }
1336
1337
1338     function valid_unit($rawresponse, $units) {
1339         // Make units more useful
1340         $tmpunits = array();
1341         foreach ($units as $unit) {
1342             $tmpunits[$unit->unit] = $unit->multiplier;
1343         }
1344         // remove spaces and normalise decimal places.
1345         $search  = array(' ', ',');
1346         $replace = array('', '.');
1347         $rawresponse = str_replace($search, $replace, trim($rawresponse));
1348
1349         // Apply any unit that is present.
1350         if (preg_match('~^([+-]?([0-9]+(\\.[0-9]*)?|\\.[0-9]+)([eE][-+]?[0-9]+)?)([^0-9].*)?$~',
1351                 $rawresponse, $responseparts)) {
1352
1353             if (!empty($responseparts[5])) {
1354
1355                 if (isset($tmpunits[$responseparts[5]])) {
1356                     // Valid number with unit.
1357                     return true ; //(float)$responseparts[1] / $tmpunits[$responseparts[5]];
1358                 } else {
1359                     // Valid number with invalid unit. Must be wrong.
1360                     return false;
1361                 }
1362
1363             } else {
1364                 // Valid number without unit.
1365                 return false ; //(float)$responseparts[1];
1366             }
1367         }
1368         // Invalid number. Must be wrong.
1369         return false;
1370     }
1371
1372     /**
1373      * Runs all the code required to set up and save an essay question for testing purposes.
1374      * Alternate DB table prefix may be used to facilitate data deletion.
1375      */
1376     function generate_test($name, $courseid = null) {
1377         global $DB;
1378         list($form, $question) = default_questiontype::generate_test($name, $courseid);
1379         $question->category = $form->category;
1380
1381         $form->questiontext = "What is 674 * 36?";
1382         $form->generalfeedback = "Thank you";
1383         $form->penalty = 0.1;
1384         $form->defaultgrade = 1;
1385         $form->noanswers = 3;
1386         $form->answer = array('24264', '24264', '1');
1387         $form->tolerance = array(10, 100, 0);
1388         $form->fraction = array(1, 0.5, 0);
1389         $form->nounits = 2;
1390         $form->unit = array(0 => null, 1 => null);
1391         $form->multiplier = array(1, 0);
1392         $form->feedback = array('Very good', 'Close, but not quite there', 'Well at least you tried....');
1393
1394         if ($courseid) {
1395             $course = $DB->get_record('course', array('id' => $courseid));
1396         }
1397
1398         return $this->save_question($question, $form, $course);
1399     }
1400     /**
1401      * When move the category of questions, the belonging files should be moved as well
1402      * @param object $question, question information
1403      * @param object $newcategory, target category information
1404      */
1405     function move_files($question, $newcategory) {
1406         global $DB;
1407         parent::move_files($question, $newcategory);
1408
1409         $fs = get_file_storage();
1410         // process files in answer
1411         if (!$oldanswers = $DB->get_records('question_answers', array('question' =>  $question->id), 'id ASC')) {
1412             $oldanswers = array();
1413         }
1414         $component = 'question';
1415         $filearea = 'answerfeedback';
1416         foreach ($oldanswers as $answer) {
1417             $files = $fs->get_area_files($question->contextid, $component, $filearea, $answer->id);
1418             foreach ($files as $storedfile) {
1419                 if (!$storedfile->is_directory()) {
1420                     $newfile = new stdClass();
1421                     $newfile->contextid = (int)$newcategory->contextid;
1422                     $fs->create_file_from_storedfile($newfile, $storedfile);
1423                     $storedfile->delete();
1424                 }
1425             }
1426         }
1427         $component = 'qtype_numerical';
1428         $filearea = 'instruction';
1429         $files = $fs->get_area_files($question->contextid, $component, $filearea, $question->id);
1430         foreach ($files as $storedfile) {
1431             if (!$storedfile->is_directory()) {
1432                 $newfile = new stdClass();
1433                 $newfile->contextid = (int)$newcategory->contextid;
1434                 $fs->create_file_from_storedfile($newfile, $storedfile);
1435                 $storedfile->delete();
1436             }
1437         }
1438     }
1439
1440     function check_file_access($question, $state, $options, $contextid, $component,
1441             $filearea, $args) {
1442         $itemid = reset($args);
1443         if ($component == 'question' && $filearea == 'answerfeedback') {
1444             $result = $options->feedback && array_key_exists($itemid, $question->options->answers);
1445             if (!$result) {
1446                 return false;
1447             }
1448             foreach($question->options->answers as $answer) {
1449                 if ($this->test_response($question, $state, $answer)) {
1450                     return true;
1451                 }
1452             }
1453             return false;
1454         } else if ($filearea == 'instruction') {
1455             if ($itemid != $question->id) {
1456                 return false;
1457             } else {
1458                 return true;
1459             }
1460         } else {
1461             return parent::check_file_access($question, $state, $options, $contextid, $component,
1462                     $filearea, $args);
1463         }
1464     }
1465 }
1466
1467 // INITIATION - Without this line the question type is not in use.
1468 question_register_questiontype(new question_numerical_qtype());
1469 if ( ! defined ("NUMERICALQUESTIONUNITTEXTINPUTDISPLAY")) {
1470     define("NUMERICALQUESTIONUNITTEXTINPUTDISPLAY",   0);
1471 }
1472 if ( ! defined ("NUMERICALQUESTIONUNITMULTICHOICEDISPLAY")) {
1473     define("NUMERICALQUESTIONUNITMULTICHOICEDISPLAY",   1);
1474 }
1475 if ( ! defined ("NUMERICALQUESTIONUNITTEXTDISPLAY")) {
1476     define("NUMERICALQUESTIONUNITTEXTDISPLAY",   2);
1477 }
1478 if ( ! defined ("NUMERICALQUESTIONUNITNODISPLAY")) {
1479     define("NUMERICALQUESTIONUNITNODISPLAY",    3);
1480 }