Merge branch 'MDL-63113-master' of git://github.com/bmbrands/moodle
[moodle.git] / question / type / edit_question_form.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * A base class for question editing forms.
19  *
20  * @package    moodlecore
21  * @subpackage questiontypes
22  * @copyright  2006 The Open University
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU Public License
24  */
27 defined('MOODLE_INTERNAL') || die();
29 global $CFG;
30 require_once($CFG->libdir.'/formslib.php');
33 abstract class question_wizard_form extends moodleform {
34     /**
35      * Add all the hidden form fields used by question/question.php.
36      */
37     protected function add_hidden_fields() {
38         $mform = $this->_form;
40         $mform->addElement('hidden', 'id');
41         $mform->setType('id', PARAM_INT);
43         $mform->addElement('hidden', 'inpopup');
44         $mform->setType('inpopup', PARAM_INT);
46         $mform->addElement('hidden', 'cmid');
47         $mform->setType('cmid', PARAM_INT);
49         $mform->addElement('hidden', 'courseid');
50         $mform->setType('courseid', PARAM_INT);
52         $mform->addElement('hidden', 'returnurl');
53         $mform->setType('returnurl', PARAM_LOCALURL);
55         $mform->addElement('hidden', 'scrollpos');
56         $mform->setType('scrollpos', PARAM_INT);
58         $mform->addElement('hidden', 'appendqnumstring');
59         $mform->setType('appendqnumstring', PARAM_ALPHA);
60     }
61 }
63 /**
64  * Form definition base class. This defines the common fields that
65  * all question types need. Question types should define their own
66  * class that inherits from this one, and implements the definition_inner()
67  * method.
68  *
69  * @copyright  2006 The Open University
70  * @license    http://www.gnu.org/copyleft/gpl.html GNU Public License
71  */
72 abstract class question_edit_form extends question_wizard_form {
73     const DEFAULT_NUM_HINTS = 2;
75     /**
76      * Question object with options and answers already loaded by get_question_options
77      * Be careful how you use this it is needed sometimes to set up the structure of the
78      * form in definition_inner but data is always loaded into the form with set_data.
79      * @var object
80      */
81     protected $question;
83     protected $contexts;
84     protected $category;
85     protected $categorycontext;
87     /** @var object current context */
88     public $context;
89     /** @var array html editor options */
90     public $editoroptions;
91     /** @var array options to preapre draft area */
92     public $fileoptions;
93     /** @var object instance of question type */
94     public $instance;
96     public function __construct($submiturl, $question, $category, $contexts, $formeditable = true) {
97         global $DB;
99         $this->question = $question;
100         $this->contexts = $contexts;
102         $record = $DB->get_record('question_categories',
103                 array('id' => $question->category), 'contextid');
104         $this->context = context::instance_by_id($record->contextid);
106         $this->editoroptions = array('subdirs' => 1, 'maxfiles' => EDITOR_UNLIMITED_FILES,
107                 'context' => $this->context);
108         $this->fileoptions = array('subdirs' => 1, 'maxfiles' => -1, 'maxbytes' => -1);
110         $this->category = $category;
111         $this->categorycontext = context::instance_by_id($category->contextid);
113         parent::__construct($submiturl, null, 'post', '', null, $formeditable);
114     }
116     /**
117      * Build the form definition.
118      *
119      * This adds all the form fields that the default question type supports.
120      * If your question type does not support all these fields, then you can
121      * override this method and remove the ones you don't want with $mform->removeElement().
122      */
123     protected function definition() {
124         global $COURSE, $CFG, $DB, $PAGE;
126         $qtype = $this->qtype();
127         $langfile = "qtype_{$qtype}";
129         $mform = $this->_form;
131         // Standard fields at the start of the form.
132         $mform->addElement('header', 'generalheader', get_string("general", 'form'));
134         if (!isset($this->question->id)) {
135             if (!empty($this->question->formoptions->mustbeusable)) {
136                 $contexts = $this->contexts->having_add_and_use();
137             } else {
138                 $contexts = $this->contexts->having_cap('moodle/question:add');
139             }
141             // Adding question.
142             $mform->addElement('questioncategory', 'category', get_string('category', 'question'),
143                     array('contexts' => $contexts));
144         } else if (!($this->question->formoptions->canmove ||
145                 $this->question->formoptions->cansaveasnew)) {
146             // Editing question with no permission to move from category.
147             $mform->addElement('questioncategory', 'category', get_string('category', 'question'),
148                     array('contexts' => array($this->categorycontext)));
149             $mform->addElement('hidden', 'usecurrentcat', 1);
150             $mform->setType('usecurrentcat', PARAM_BOOL);
151             $mform->setConstant('usecurrentcat', 1);
152         } else {
153             // Editing question with permission to move from category or save as new q.
154             $currentgrp = array();
155             $currentgrp[0] = $mform->createElement('questioncategory', 'category',
156                     get_string('categorycurrent', 'question'),
157                     array('contexts' => array($this->categorycontext)));
158             if ($this->question->formoptions->canedit ||
159                     $this->question->formoptions->cansaveasnew) {
160                 // Not move only form.
161                 $currentgrp[1] = $mform->createElement('checkbox', 'usecurrentcat', '',
162                         get_string('categorycurrentuse', 'question'));
163                 $mform->setDefault('usecurrentcat', 1);
164             }
165             $currentgrp[0]->freeze();
166             $currentgrp[0]->setPersistantFreeze(false);
167             $mform->addGroup($currentgrp, 'currentgrp',
168                     get_string('categorycurrent', 'question'), null, false);
170             $mform->addElement('questioncategory', 'categorymoveto',
171                     get_string('categorymoveto', 'question'),
172                     array('contexts' => array($this->categorycontext)));
173             if ($this->question->formoptions->canedit ||
174                     $this->question->formoptions->cansaveasnew) {
175                 // Not move only form.
176                 $mform->disabledIf('categorymoveto', 'usecurrentcat', 'checked');
177             }
178         }
180         $mform->addElement('text', 'name', get_string('questionname', 'question'),
181                 array('size' => 50, 'maxlength' => 255));
182         $mform->setType('name', PARAM_TEXT);
183         $mform->addRule('name', null, 'required', null, 'client');
185         $mform->addElement('editor', 'questiontext', get_string('questiontext', 'question'),
186                 array('rows' => 15), $this->editoroptions);
187         $mform->setType('questiontext', PARAM_RAW);
188         $mform->addRule('questiontext', null, 'required', null, 'client');
190         $mform->addElement('text', 'defaultmark', get_string('defaultmark', 'question'),
191                 array('size' => 7));
192         $mform->setType('defaultmark', PARAM_FLOAT);
193         $mform->setDefault('defaultmark', 1);
194         $mform->addRule('defaultmark', null, 'required', null, 'client');
196         $mform->addElement('editor', 'generalfeedback', get_string('generalfeedback', 'question'),
197                 array('rows' => 10), $this->editoroptions);
198         $mform->setType('generalfeedback', PARAM_RAW);
199         $mform->addHelpButton('generalfeedback', 'generalfeedback', 'question');
201         $mform->addElement('text', 'idnumber', get_string('idnumber', 'question'), 'maxlength="100"  size="10"');
202         $mform->addHelpButton('idnumber', 'idnumber', 'question');
203         $mform->setType('idnumber', PARAM_RAW);
205         // Any questiontype specific fields.
206         $this->definition_inner($mform);
208         if (core_tag_tag::is_enabled('core_question', 'question')) {
209             $this->add_tag_fields($mform);
210         }
212         if (!empty($this->question->id)) {
213             $mform->addElement('header', 'createdmodifiedheader',
214                     get_string('createdmodifiedheader', 'question'));
215             $a = new stdClass();
216             if (!empty($this->question->createdby)) {
217                 $a->time = userdate($this->question->timecreated);
218                 $a->user = fullname($DB->get_record(
219                         'user', array('id' => $this->question->createdby)));
220             } else {
221                 $a->time = get_string('unknown', 'question');
222                 $a->user = get_string('unknown', 'question');
223             }
224             $mform->addElement('static', 'created', get_string('created', 'question'),
225                      get_string('byandon', 'question', $a));
226             if (!empty($this->question->modifiedby)) {
227                 $a = new stdClass();
228                 $a->time = userdate($this->question->timemodified);
229                 $a->user = fullname($DB->get_record(
230                         'user', array('id' => $this->question->modifiedby)));
231                 $mform->addElement('static', 'modified', get_string('modified', 'question'),
232                         get_string('byandon', 'question', $a));
233             }
234         }
236         $this->add_hidden_fields();
238         $mform->addElement('hidden', 'qtype');
239         $mform->setType('qtype', PARAM_ALPHA);
241         $mform->addElement('hidden', 'makecopy');
242         $mform->setType('makecopy', PARAM_INT);
244         $buttonarray = array();
245         $buttonarray[] = $mform->createElement('submit', 'updatebutton',
246                              get_string('savechangesandcontinueediting', 'question'));
247         if ($this->can_preview()) {
248             $previewlink = $PAGE->get_renderer('core_question')->question_preview_link(
249                     $this->question->id, $this->context, true);
250             $buttonarray[] = $mform->createElement('static', 'previewlink', '', $previewlink);
251         }
253         $mform->addGroup($buttonarray, 'updatebuttonar', '', array(' '), false);
254         $mform->closeHeaderBefore('updatebuttonar');
256         $this->add_action_buttons(true, get_string('savechanges'));
258         if ((!empty($this->question->id)) && (!($this->question->formoptions->canedit ||
259                 $this->question->formoptions->cansaveasnew))) {
260             $mform->hardFreezeAllVisibleExcept(array('categorymoveto', 'buttonar', 'currentgrp'));
261         }
262     }
264     /**
265      * Add any question-type specific form fields.
266      *
267      * @param object $mform the form being built.
268      */
269     protected function definition_inner($mform) {
270         // By default, do nothing.
271     }
273     /**
274      * Is the question being edited in a state where it can be previewed?
275      * @return bool whether to show the preview link.
276      */
277     protected function can_preview() {
278         return empty($this->question->beingcopied) && !empty($this->question->id) &&
279                 $this->question->formoptions->canedit;
280     }
282     /**
283      * Get the list of form elements to repeat, one for each answer.
284      * @param object $mform the form being built.
285      * @param $label the label to use for each option.
286      * @param $gradeoptions the possible grades for each answer.
287      * @param $repeatedoptions reference to array of repeated options to fill
288      * @param $answersoption reference to return the name of $question->options
289      *      field holding an array of answers
290      * @return array of form fields.
291      */
292     protected function get_per_answer_fields($mform, $label, $gradeoptions,
293             &$repeatedoptions, &$answersoption) {
294         $repeated = array();
295         $answeroptions = array();
296         $answeroptions[] = $mform->createElement('text', 'answer',
297                 $label, array('size' => 40));
298         $answeroptions[] = $mform->createElement('select', 'fraction',
299                 get_string('grade'), $gradeoptions);
300         $repeated[] = $mform->createElement('group', 'answeroptions',
301                  $label, $answeroptions, null, false);
302         $repeated[] = $mform->createElement('editor', 'feedback',
303                 get_string('feedback', 'question'), array('rows' => 5), $this->editoroptions);
304         $repeatedoptions['answer']['type'] = PARAM_RAW;
305         $repeatedoptions['fraction']['default'] = 0;
306         $answersoption = 'answers';
307         return $repeated;
308     }
310     /**
311      * Add the tag and course tag fields to the mform.
312      *
313      * If the form is being built in a course context then add the field
314      * for course tags.
315      *
316      * If the question category doesn't belong to a course context or we
317      * aren't editing in a course context then add the tags element to allow
318      * tags to be added to the question category context.
319      *
320      * @param object $mform The form being built
321      */
322     protected function add_tag_fields($mform) {
323         global $CFG, $DB;
325         $hastagcapability = question_has_capability_on($this->question, 'tag');
326         // Is the question category in a course context?
327         $qcontext = $this->categorycontext;
328         $qcoursecontext = $qcontext->get_course_context(false);
329         $iscourseoractivityquestion = !empty($qcoursecontext);
330         // Is the current context we're editing in a course context?
331         $editingcontext = $this->contexts->lowest();
332         $editingcoursecontext = $editingcontext->get_course_context(false);
333         $iseditingcontextcourseoractivity = !empty($editingcoursecontext);
335         $mform->addElement('header', 'tagsheader', get_string('tags'));
336         $tags = \core_tag_tag::get_tags_by_area_in_contexts('core_question', 'question', $this->contexts->all());
337         $tagstrings = [];
338         foreach ($tags as $tag) {
339             $tagstrings[$tag->name] = $tag->name;
340         }
342         $showstandard = core_tag_area::get_showstandard('core_question', 'question');
343         if ($showstandard != core_tag_tag::HIDE_STANDARD) {
344             $namefield = empty($CFG->keeptagnamecase) ? 'name' : 'rawname';
345             $standardtags = $DB->get_records('tag',
346                     array('isstandard' => 1, 'tagcollid' => core_tag_area::get_collection('core', 'question')),
347                     $namefield, 'id,' . $namefield);
348             foreach ($standardtags as $standardtag) {
349                 $tagstrings[$standardtag->$namefield] = $standardtag->$namefield;
350             }
351         }
353         $options = [
354             'tags' => true,
355             'multiple' => true,
356             'noselectionstring' => get_string('anytags', 'quiz'),
357         ];
358         $mform->addElement('autocomplete', 'tags',  get_string('tags'), $tagstrings, $options);
360         if (!$hastagcapability) {
361             $mform->hardFreeze('tags');
362         }
364         if ($iseditingcontextcourseoractivity && !$iscourseoractivityquestion) {
365             // If the question is being edited in a course or activity context
366             // and the question isn't a course or activity level question then
367             // allow course tags to be added to the course.
368             $coursetagheader = get_string('questionformtagheader', 'core_question',
369                 $editingcoursecontext->get_context_name(true));
370             $mform->addElement('header', 'coursetagsheader', $coursetagheader);
371             $mform->addElement('autocomplete', 'coursetags',  get_string('tags'), $tagstrings, $options);
373             if (!$hastagcapability) {
374                 $mform->hardFreeze('coursetags');
375             }
376         }
377     }
379     /**
380      * Add a set of form fields, obtained from get_per_answer_fields, to the form,
381      * one for each existing answer, with some blanks for some new ones.
382      * @param object $mform the form being built.
383      * @param $label the label to use for each option.
384      * @param $gradeoptions the possible grades for each answer.
385      * @param $minoptions the minimum number of answer blanks to display.
386      *      Default QUESTION_NUMANS_START.
387      * @param $addoptions the number of answer blanks to add. Default QUESTION_NUMANS_ADD.
388      */
389     protected function add_per_answer_fields(&$mform, $label, $gradeoptions,
390             $minoptions = QUESTION_NUMANS_START, $addoptions = QUESTION_NUMANS_ADD) {
391         $mform->addElement('header', 'answerhdr',
392                     get_string('answers', 'question'), '');
393         $mform->setExpanded('answerhdr', 1);
394         $answersoption = '';
395         $repeatedoptions = array();
396         $repeated = $this->get_per_answer_fields($mform, $label, $gradeoptions,
397                 $repeatedoptions, $answersoption);
399         if (isset($this->question->options)) {
400             $repeatsatstart = count($this->question->options->$answersoption);
401         } else {
402             $repeatsatstart = $minoptions;
403         }
405         $this->repeat_elements($repeated, $repeatsatstart, $repeatedoptions,
406                 'noanswers', 'addanswers', $addoptions,
407                 $this->get_more_choices_string(), true);
408     }
410     /**
411      * Language string to use for 'Add {no} more {whatever we call answers}'.
412      */
413     protected function get_more_choices_string() {
414         return get_string('addmorechoiceblanks', 'question');
415     }
417     protected function add_combined_feedback_fields($withshownumpartscorrect = false) {
418         $mform = $this->_form;
420         $mform->addElement('header', 'combinedfeedbackhdr',
421                 get_string('combinedfeedback', 'question'));
423         $fields = array('correctfeedback', 'partiallycorrectfeedback', 'incorrectfeedback');
424         foreach ($fields as $feedbackname) {
425             $element = $mform->addElement('editor', $feedbackname,
426                                 get_string($feedbackname, 'question'),
427                                 array('rows' => 5), $this->editoroptions);
428             $mform->setType($feedbackname, PARAM_RAW);
429             // Using setValue() as setDefault() does not work for the editor class.
430             $element->setValue(array('text' => get_string($feedbackname.'default', 'question')));
432             if ($withshownumpartscorrect && $feedbackname == 'partiallycorrectfeedback') {
433                 $mform->addElement('advcheckbox', 'shownumcorrect',
434                         get_string('options', 'question'),
435                         get_string('shownumpartscorrectwhenfinished', 'question'));
436                 $mform->setDefault('shownumcorrect', true);
437             }
438         }
439     }
441     /**
442      * Create the form elements required by one hint.
443      * @param string $withclearwrong whether this quesiton type uses the 'Clear wrong' option on hints.
444      * @param string $withshownumpartscorrect whether this quesiton type uses the 'Show num parts correct' option on hints.
445      * @return array form field elements for one hint.
446      */
447     protected function get_hint_fields($withclearwrong = false, $withshownumpartscorrect = false) {
448         $mform = $this->_form;
450         $repeatedoptions = array();
451         $repeated = array();
452         $repeated[] = $mform->createElement('editor', 'hint', get_string('hintn', 'question'),
453                 array('rows' => 5), $this->editoroptions);
454         $repeatedoptions['hint']['type'] = PARAM_RAW;
456         $optionelements = array();
457         if ($withclearwrong) {
458             $optionelements[] = $mform->createElement('advcheckbox', 'hintclearwrong',
459                     get_string('options', 'question'), get_string('clearwrongparts', 'question'));
460         }
461         if ($withshownumpartscorrect) {
462             $optionelements[] = $mform->createElement('advcheckbox', 'hintshownumcorrect', '',
463                     get_string('shownumpartscorrect', 'question'));
464         }
466         if (count($optionelements)) {
467             $repeated[] = $mform->createElement('group', 'hintoptions',
468                  get_string('hintnoptions', 'question'), $optionelements, null, false);
469         }
471         return array($repeated, $repeatedoptions);
472     }
474     protected function add_interactive_settings($withclearwrong = false,
475             $withshownumpartscorrect = false) {
476         $mform = $this->_form;
478         $mform->addElement('header', 'multitriesheader',
479                 get_string('settingsformultipletries', 'question'));
481         $penalties = array(
482             1.0000000,
483             0.5000000,
484             0.3333333,
485             0.2500000,
486             0.2000000,
487             0.1000000,
488             0.0000000
489         );
490         if (!empty($this->question->penalty) && !in_array($this->question->penalty, $penalties)) {
491             $penalties[] = $this->question->penalty;
492             sort($penalties);
493         }
494         $penaltyoptions = array();
495         foreach ($penalties as $penalty) {
496             $penaltyoptions["{$penalty}"] = (100 * $penalty) . '%';
497         }
498         $mform->addElement('select', 'penalty',
499                 get_string('penaltyforeachincorrecttry', 'question'), $penaltyoptions);
500         $mform->addHelpButton('penalty', 'penaltyforeachincorrecttry', 'question');
501         $mform->setDefault('penalty', 0.3333333);
503         if (isset($this->question->hints)) {
504             $counthints = count($this->question->hints);
505         } else {
506             $counthints = 0;
507         }
509         if ($this->question->formoptions->repeatelements) {
510             $repeatsatstart = max(self::DEFAULT_NUM_HINTS, $counthints);
511         } else {
512             $repeatsatstart = $counthints;
513         }
515         list($repeated, $repeatedoptions) = $this->get_hint_fields(
516                 $withclearwrong, $withshownumpartscorrect);
517         $this->repeat_elements($repeated, $repeatsatstart, $repeatedoptions,
518                 'numhints', 'addhint', 1, get_string('addanotherhint', 'question'), true);
519     }
521     public function set_data($question) {
522         question_bank::get_qtype($question->qtype)->set_default_options($question);
524         // Prepare question text.
525         $draftid = file_get_submitted_draft_itemid('questiontext');
527         if (!empty($question->questiontext)) {
528             $questiontext = $question->questiontext;
529         } else {
530             $questiontext = $this->_form->getElement('questiontext')->getValue();
531             $questiontext = $questiontext['text'];
532         }
533         $questiontext = file_prepare_draft_area($draftid, $this->context->id,
534                 'question', 'questiontext', empty($question->id) ? null : (int) $question->id,
535                 $this->fileoptions, $questiontext);
537         $question->questiontext = array();
538         $question->questiontext['text'] = $questiontext;
539         $question->questiontext['format'] = empty($question->questiontextformat) ?
540                 editors_get_preferred_format() : $question->questiontextformat;
541         $question->questiontext['itemid'] = $draftid;
543         // Prepare general feedback.
544         $draftid = file_get_submitted_draft_itemid('generalfeedback');
546         if (empty($question->generalfeedback)) {
547             $generalfeedback = $this->_form->getElement('generalfeedback')->getValue();
548             $question->generalfeedback = $generalfeedback['text'];
549         }
551         $feedback = file_prepare_draft_area($draftid, $this->context->id,
552                 'question', 'generalfeedback', empty($question->id) ? null : (int) $question->id,
553                 $this->fileoptions, $question->generalfeedback);
554         $question->generalfeedback = array();
555         $question->generalfeedback['text'] = $feedback;
556         $question->generalfeedback['format'] = empty($question->generalfeedbackformat) ?
557                 editors_get_preferred_format() : $question->generalfeedbackformat;
558         $question->generalfeedback['itemid'] = $draftid;
560         // Remove unnecessary trailing 0s form grade fields.
561         if (isset($question->defaultgrade)) {
562             $question->defaultgrade = 0 + $question->defaultgrade;
563         }
564         if (isset($question->penalty)) {
565             $question->penalty = 0 + $question->penalty;
566         }
568         // Set any options.
569         $extraquestionfields = question_bank::get_qtype($question->qtype)->extra_question_fields();
570         if (is_array($extraquestionfields) && !empty($question->options)) {
571             array_shift($extraquestionfields);
572             foreach ($extraquestionfields as $field) {
573                 if (property_exists($question->options, $field)) {
574                     $question->$field = $question->options->$field;
575                 }
576             }
577         }
579         // Subclass adds data_preprocessing code here.
580         $question = $this->data_preprocessing($question);
582         parent::set_data($question);
583     }
585     /**
586      * Perform an preprocessing needed on the data passed to {@link set_data()}
587      * before it is used to initialise the form.
588      * @param object $question the data being passed to the form.
589      * @return object $question the modified data.
590      */
591     protected function data_preprocessing($question) {
592         return $question;
593     }
595     /**
596      * Perform the necessary preprocessing for the fields added by
597      * {@link add_per_answer_fields()}.
598      * @param object $question the data being passed to the form.
599      * @return object $question the modified data.
600      */
601     protected function data_preprocessing_answers($question, $withanswerfiles = false) {
602         if (empty($question->options->answers)) {
603             return $question;
604         }
606         $key = 0;
607         foreach ($question->options->answers as $answer) {
608             if ($withanswerfiles) {
609                 // Prepare the feedback editor to display files in draft area.
610                 $draftitemid = file_get_submitted_draft_itemid('answer['.$key.']');
611                 $question->answer[$key]['text'] = file_prepare_draft_area(
612                     $draftitemid,          // Draftid
613                     $this->context->id,    // context
614                     'question',            // component
615                     'answer',              // filarea
616                     !empty($answer->id) ? (int) $answer->id : null, // itemid
617                     $this->fileoptions,    // options
618                     $answer->answer        // text.
619                 );
620                 $question->answer[$key]['itemid'] = $draftitemid;
621                 $question->answer[$key]['format'] = $answer->answerformat;
622             } else {
623                 $question->answer[$key] = $answer->answer;
624             }
626             $question->fraction[$key] = 0 + $answer->fraction;
627             $question->feedback[$key] = array();
629             // Evil hack alert. Formslib can store defaults in two ways for
630             // repeat elements:
631             //   ->_defaultValues['fraction[0]'] and
632             //   ->_defaultValues['fraction'][0].
633             // The $repeatedoptions['fraction']['default'] = 0 bit above means
634             // that ->_defaultValues['fraction[0]'] has already been set, but we
635             // are using object notation here, so we will be setting
636             // ->_defaultValues['fraction'][0]. That does not work, so we have
637             // to unset ->_defaultValues['fraction[0]'].
638             unset($this->_form->_defaultValues["fraction[{$key}]"]);
640             // Prepare the feedback editor to display files in draft area.
641             $draftitemid = file_get_submitted_draft_itemid('feedback['.$key.']');
642             $question->feedback[$key]['text'] = file_prepare_draft_area(
643                 $draftitemid,          // Draftid
644                 $this->context->id,    // context
645                 'question',            // component
646                 'answerfeedback',      // filarea
647                 !empty($answer->id) ? (int) $answer->id : null, // itemid
648                 $this->fileoptions,    // options
649                 $answer->feedback      // text.
650             );
651             $question->feedback[$key]['itemid'] = $draftitemid;
652             $question->feedback[$key]['format'] = $answer->feedbackformat;
653             $key++;
654         }
656         // Now process extra answer fields.
657         $extraanswerfields = question_bank::get_qtype($question->qtype)->extra_answer_fields();
658         if (is_array($extraanswerfields)) {
659             // Omit table name.
660             array_shift($extraanswerfields);
661             $question = $this->data_preprocessing_extra_answer_fields($question, $extraanswerfields);
662         }
664         return $question;
665     }
667     /**
668      * Perform the necessary preprocessing for the extra answer fields.
669      *
670      * Questions that do something not trivial when editing extra answer fields
671      * will want to override this.
672      * @param object $question the data being passed to the form.
673      * @param array $extraanswerfields extra answer fields (without table name).
674      * @return object $question the modified data.
675      */
676     protected function data_preprocessing_extra_answer_fields($question, $extraanswerfields) {
677         // Setting $question->$field[$key] won't work in PHP, so we need set an array of answer values to $question->$field.
678         // As we may have several extra fields with data for several answers in each, we use an array of arrays.
679         // Index in $extrafieldsdata is an extra answer field name, value - array of it's data for each answer.
680         $extrafieldsdata = array();
681         // First, prepare an array if empty arrays for each extra answer fields data.
682         foreach ($extraanswerfields as $field) {
683             $extrafieldsdata[$field] = array();
684         }
686         // Fill arrays with data from $question->options->answers.
687         $key = 0;
688         foreach ($question->options->answers as $answer) {
689             foreach ($extraanswerfields as $field) {
690                 // See hack comment in {@link data_preprocessing_answers()}.
691                 unset($this->_form->_defaultValues["{$field}[{$key}]"]);
692                 $extrafieldsdata[$field][$key] = $this->data_preprocessing_extra_answer_field($answer, $field);
693             }
694             $key++;
695         }
697         // Set this data in the $question object.
698         foreach ($extraanswerfields as $field) {
699             $question->$field = $extrafieldsdata[$field];
700         }
701         return $question;
702     }
704     /**
705      * Perfmorm preprocessing for particular extra answer field.
706      *
707      * Questions with non-trivial DB - form element relationship will
708      * want to override this.
709      * @param object $answer an answer object to get extra field from.
710      * @param string $field extra answer field name.
711      * @return field value to be set to the form.
712      */
713     protected function data_preprocessing_extra_answer_field($answer, $field) {
714         return $answer->$field;
715     }
717     /**
718      * Perform the necessary preprocessing for the fields added by
719      * {@link add_combined_feedback_fields()}.
720      * @param object $question the data being passed to the form.
721      * @return object $question the modified data.
722      */
723     protected function data_preprocessing_combined_feedback($question,
724             $withshownumcorrect = false) {
725         if (empty($question->options)) {
726             return $question;
727         }
729         $fields = array('correctfeedback', 'partiallycorrectfeedback', 'incorrectfeedback');
730         foreach ($fields as $feedbackname) {
731             $draftid = file_get_submitted_draft_itemid($feedbackname);
732             $feedback = array();
733             $feedback['text'] = file_prepare_draft_area(
734                 $draftid,              // Draftid
735                 $this->context->id,    // context
736                 'question',            // component
737                 $feedbackname,         // filarea
738                 !empty($question->id) ? (int) $question->id : null, // itemid
739                 $this->fileoptions,    // options
740                 $question->options->$feedbackname // text.
741             );
742             $feedbackformat = $feedbackname . 'format';
743             $feedback['format'] = $question->options->$feedbackformat;
744             $feedback['itemid'] = $draftid;
746             $question->$feedbackname = $feedback;
747         }
749         if ($withshownumcorrect) {
750             $question->shownumcorrect = $question->options->shownumcorrect;
751         }
753         return $question;
754     }
756     /**
757      * Perform the necessary preprocessing for the hint fields.
758      * @param object $question the data being passed to the form.
759      * @return object $question the modified data.
760      */
761     protected function data_preprocessing_hints($question, $withclearwrong = false,
762             $withshownumpartscorrect = false) {
763         if (empty($question->hints)) {
764             return $question;
765         }
767         $key = 0;
768         foreach ($question->hints as $hint) {
769             $question->hint[$key] = array();
771             // Prepare feedback editor to display files in draft area.
772             $draftitemid = file_get_submitted_draft_itemid('hint['.$key.']');
773             $question->hint[$key]['text'] = file_prepare_draft_area(
774                 $draftitemid,          // Draftid
775                 $this->context->id,    // context
776                 'question',            // component
777                 'hint',                // filarea
778                 !empty($hint->id) ? (int) $hint->id : null, // itemid
779                 $this->fileoptions,    // options
780                 $hint->hint            // text.
781             );
782             $question->hint[$key]['itemid'] = $draftitemid;
783             $question->hint[$key]['format'] = $hint->hintformat;
784             $key++;
786             if ($withclearwrong) {
787                 $question->hintclearwrong[] = $hint->clearwrong;
788             }
789             if ($withshownumpartscorrect) {
790                 $question->hintshownumcorrect[] = $hint->shownumcorrect;
791             }
792         }
794         return $question;
795     }
797     public function validation($fromform, $files) {
798         global $DB;
800         $errors = parent::validation($fromform, $files);
801         if (empty($fromform['makecopy']) && isset($this->question->id)
802                 && ($this->question->formoptions->canedit ||
803                         $this->question->formoptions->cansaveasnew)
804                 && empty($fromform['usecurrentcat']) && !$this->question->formoptions->canmove) {
805             $errors['currentgrp'] = get_string('nopermissionmove', 'question');
806         }
808         // Category.
809         if (empty($fromform['category'])) {
810             // User has provided an invalid category.
811             $errors['category'] = get_string('required');
812         }
814         // Default mark.
815         if (array_key_exists('defaultmark', $fromform) && $fromform['defaultmark'] < 0) {
816             $errors['defaultmark'] = get_string('defaultmarkmustbepositive', 'question');
817         }
819         // Can only have one idnumber per category.
820         if (strpos($fromform['category'], ',') !== false) {
821             list($category, $categorycontextid) = explode(',', $fromform['category']);
822         } else {
823             $category = $fromform['category'];
824         }
825         if (isset($fromform['idnumber']) && ((string) $fromform['idnumber'] !== '')) {
826             if (empty($fromform['usecurrentcat']) && !empty($fromform['categorymoveto'])) {
827                 $categoryinfo = $fromform['categorymoveto'];
828             } else {
829                 $categoryinfo = $fromform['category'];
830             }
831             list($categoryid, $notused) = explode(',', $categoryinfo);
832             $conditions = 'category = ? AND idnumber = ?';
833             $params = [$categoryid, $fromform['idnumber']];
834             if (!empty($this->question->id)) {
835                 $conditions .= ' AND id <> ?';
836                 $params[] = $this->question->id;
837             }
838             if ($DB->record_exists_select('question', $conditions, $params)) {
839                 $errors['idnumber'] = get_string('idnumbertaken', 'error');
840             }
841         }
843         return $errors;
844     }
846     /**
847      * Override this in the subclass to question type name.
848      * @return the question type name, should be the same as the name() method
849      *      in the question type class.
850      */
851     public abstract function qtype();
853     /**
854      * Returns an array of editor options with collapsed options turned off.
855      * @deprecated since 2.6
856      * @return array
857      */
858     protected function get_non_collabsible_editor_options() {
859         debugging('get_non_collabsible_editor_options() is deprecated, use $this->editoroptions instead.', DEBUG_DEVELOPER);
860         return $this->editoroptions;
861     }