weekly on-sync release 2.6dev
[moodle.git] / question / type / questiontypebase.php
CommitLineData
f29aeb5a 1<?php
f29aeb5a
TH
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/>.
16
516cf3eb 17/**
4323d029 18 * The default questiontype class.
19 *
7764183a 20 * @package moodlecore
4323d029 21 * @subpackage questiontypes
7764183a
TH
22 * @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}
23 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
271e6dec 24 */
516cf3eb 25
f29aeb5a 26
a17b297d
TH
27defined('MOODLE_INTERNAL') || die();
28
d1b7e03d 29require_once($CFG->dirroot . '/question/engine/lib.php');
516cf3eb 30
f29aeb5a 31
32b0adfa 32/**
33 * This is the base class for Moodle question types.
271ffe3f 34 *
32b0adfa 35 * There are detailed comments on each method, explaining what the method is
36 * for, and the circumstances under which you might need to override it.
271ffe3f 37 *
32b0adfa 38 * Note: the questiontype API should NOT be considered stable yet. Very few
22cebed5 39 * question types have been produced yet, so we do not yet know all the places
271ffe3f 40 * where the current API is insufficient. I would rather learn from the
32b0adfa 41 * experiences of the first few question type implementors, and improve the
42 * interface to meet their needs, rather the freeze the API prematurely and
43 * condem everyone to working round a clunky interface for ever afterwards.
271e6dec 44 *
7764183a
TH
45 * @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}
46 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
32b0adfa 47 */
d1b7e03d 48class question_type {
f29aeb5a
TH
49 protected $fileoptions = array(
50 'subdirs' => false,
51 'maxfiles' => -1,
52 'maxbytes' => 0,
53 );
516cf3eb 54
d1b7e03d 55 public function __construct() {
869309b8 56 }
57
4995b9c1 58 /**
d1b7e03d 59 * @return string the name of this question type.
869309b8 60 */
d1b7e03d
TH
61 public function name() {
62 return substr(get_class($this), 6);
a2156789 63 }
271ffe3f 64
f29aeb5a
TH
65 /**
66 * @return string the full frankenstyle name for this plugin.
67 */
68 public function plugin_name() {
69 return get_class($this);
70 }
71
72 /**
73 * @return string the name of this question type in the user's language.
74 * You should not need to override this method, the default behaviour should be fine.
75 */
76 public function local_name() {
0b94d6bf 77 return get_string('pluginname', $this->plugin_name());
f29aeb5a
TH
78 }
79
869309b8 80 /**
81 * The name this question should appear as in the create new question
f29aeb5a
TH
82 * dropdown. Override this method to return false if you don't want your
83 * question type to be createable, for example if it is an abstract base type,
84 * otherwise, you should not need to override this method.
869309b8 85 *
86 * @return mixed the desired string, or false to hide this question type in the menu.
87 */
d1b7e03d 88 public function menu_name() {
f29aeb5a
TH
89 return $this->local_name();
90 }
91
f29aeb5a 92 /**
f7970e3c 93 * @return bool override this to return false if this is not really a
f29aeb5a
TH
94 * question type, for example the description question type is not
95 * really a question type.
96 */
97 public function is_real_question_type() {
98 return true;
b974f947 99 }
100
a2156789 101 /**
f7970e3c 102 * @return bool true if this question type sometimes requires manual grading.
a2156789 103 */
d1b7e03d 104 public function is_manual_graded() {
a2156789 105 return false;
106 }
107
f24493ec 108 /**
109 * @param object $question a question of this type.
110 * @param string $otherquestionsinuse comma-separate list of other question ids in this attempt.
f7970e3c 111 * @return bool true if a particular instance of this question requires manual grading.
f24493ec 112 */
d1b7e03d 113 public function is_question_manual_graded($question, $otherquestionsinuse) {
f24493ec 114 return $this->is_manual_graded();
115 }
116
869309b8 117 /**
f7970e3c 118 * @return bool true if this question type can be used by the random question type.
869309b8 119 */
d1b7e03d
TH
120 public function is_usable_by_random() {
121 return true;
869309b8 122 }
123
a2156789 124 /**
d1b7e03d
TH
125 * Whether this question type can perform a frequency analysis of student
126 * responses.
127 *
128 * If this method returns true, you must implement the get_possible_responses
129 * method, and the question_definition class must implement the
130 * classify_response method.
131 *
f7970e3c 132 * @return bool whether this report can analyse all the student reponses
d1b7e03d 133 * for things like the quiz statistics report.
a2156789 134 */
d1b7e03d
TH
135 public function can_analyse_responses() {
136 // This works in most cases.
137 return !$this->is_manual_graded();
a2156789 138 }
139
869309b8 140 /**
d1b7e03d
TH
141 * @return whether the question_answers.answer field needs to have
142 * restore_decode_content_links_worker called on it.
869309b8 143 */
d1b7e03d 144 public function has_html_answers() {
869309b8 145 return false;
146 }
d001dac7 147
295043c2 148 /**
149 * If your question type has a table that extends the question table, and
150 * you want the base class to automatically save, backup and restore the extra fields,
151 * override this method to return an array wherer the first element is the table name,
152 * and the subsequent entries are the column names (apart from id and questionid).
153 *
154 * @return mixed array as above, or null to tell the base class to do nothing.
155 */
d1b7e03d 156 public function extra_question_fields() {
295043c2 157 return null;
158 }
159
d001dac7 160 /**
eaeb6b51
TH
161 * If you use extra_question_fields, overload this function to return question id field name
162 * in case you table use another name for this column
163 */
56565037 164 public function questionid_column_name() {
d001dac7 165 return 'questionid';
166 }
167
295043c2 168 /**
169 * If your question type has a table that extends the question_answers table,
170 * make this method return an array wherer the first element is the table name,
171 * and the subsequent entries are the column names (apart from id and answerid).
172 *
173 * @return mixed array as above, or null to tell the base class to do nothing.
174 */
56565037 175 public function extra_answer_fields() {
6b5f24d3
TH
176 return null;
177 }
178
179 /**
180 * If the quetsion type uses files in responses, then this method should
181 * return an array of all the response variables that might have corresponding
182 * files. For example, the essay qtype returns array('attachments', 'answers').
183 *
184 * @return array response variable names that may have associated files.
185 */
186 public function response_file_areas() {
187 return array();
188 }
295043c2 189
36703ed7 190 /**
191 * Return an instance of the question editing form definition. This looks for a
192 * class called edit_{$this->name()}_question_form in the file
f29aeb5a 193 * question/type/{$this->name()}/edit_{$this->name()}_question_form.php
36703ed7 194 * and if it exists returns an instance of it.
195 *
196 * @param string $submiturl passed on to the constructor call.
197 * @return object an instance of the form definition, or null if one could not be found.
198 */
eaeb6b51
TH
199 public function create_editing_form($submiturl, $question, $category,
200 $contexts, $formeditable) {
36703ed7 201 global $CFG;
1fa39364
TH
202 require_once($CFG->dirroot . '/question/type/edit_question_form.php');
203 $definitionfile = $CFG->dirroot . '/question/type/' . $this->name() .
eaeb6b51 204 '/edit_' . $this->name() . '_form.php';
1fa39364
TH
205 if (!is_readable($definitionfile) || !is_file($definitionfile)) {
206 throw new coding_exception($this->plugin_name() .
afe24f85
TH
207 ' is missing the definition of its editing formin file ' .
208 $definitionfile . '.');
36703ed7 209 }
1fa39364 210 require_once($definitionfile);
6e34cd29 211 $classname = $this->plugin_name() . '_edit_form';
36703ed7 212 if (!class_exists($classname)) {
1fa39364
TH
213 throw new coding_exception($this->plugin_name() .
214 ' does not define the class ' . $this->plugin_name() .
215 '_edit_form.');
36703ed7 216 }
271e6dec 217 return new $classname($submiturl, $question, $category, $contexts, $formeditable);
36703ed7 218 }
219
99ba746d 220 /**
221 * @return string the full path of the folder this plugin's files live in.
222 */
d1b7e03d 223 public function plugin_dir() {
99ba746d 224 global $CFG;
225 return $CFG->dirroot . '/question/type/' . $this->name();
226 }
227
228 /**
229 * @return string the URL of the folder this plugin's files live in.
230 */
d1b7e03d 231 public function plugin_baseurl() {
99ba746d 232 global $CFG;
233 return $CFG->wwwroot . '/question/type/' . $this->name();
234 }
235
7b41a4a9 236 /**
237 * This method should be overriden if you want to include a special heading or some other
238 * html on a question editing page besides the question editing form.
239 *
240 * @param question_edit_form $mform a child of question_edit_form
241 * @param object $question
242 * @param string $wizardnow is '' for first page.
243 */
f29aeb5a
TH
244 public function display_question_editing_page($mform, $question, $wizardnow) {
245 global $OUTPUT;
246 $heading = $this->get_heading(empty($question->id));
247
0b94d6bf 248 echo $OUTPUT->heading_with_help($heading, 'pluginname', $this->plugin_name());
f29aeb5a 249
271e6dec 250 $permissionstrs = array();
eaeb6b51
TH
251 if (!empty($question->id)) {
252 if ($question->formoptions->canedit) {
271e6dec 253 $permissionstrs[] = get_string('permissionedit', 'question');
254 }
eaeb6b51 255 if ($question->formoptions->canmove) {
271e6dec 256 $permissionstrs[] = get_string('permissionmove', 'question');
257 }
eaeb6b51 258 if ($question->formoptions->cansaveasnew) {
271e6dec 259 $permissionstrs[] = get_string('permissionsaveasnew', 'question');
260 }
261 }
eaeb6b51 262 if (!$question->formoptions->movecontext && count($permissionstrs)) {
f29aeb5a 263 echo $OUTPUT->heading(get_string('permissionto', 'question'), 3);
271e6dec 264 $html = '<ul>';
eaeb6b51 265 foreach ($permissionstrs as $permissionstr) {
271e6dec 266 $html .= '<li>'.$permissionstr.'</li>';
267 }
268 $html .= '</ul>';
f29aeb5a 269 echo $OUTPUT->box($html, 'boxwidthnarrow boxaligncenter generalbox');
271e6dec 270 }
9ab75b2b 271 $mform->display();
272 }
271e6dec 273
9ab75b2b 274 /**
eaeb6b51
TH
275 * Method called by display_question_editing_page and by question.php to get
276 * heading for breadcrumbs.
271e6dec 277 *
d1b7e03d 278 * @return string the heading
9ab75b2b 279 */
eaeb6b51 280 public function get_heading($adding = false) {
f29aeb5a 281 if ($adding) {
226b3124 282 $string = 'pluginnameadding';
226b3124
TH
283 } else {
284 $string = 'pluginnameediting';
c2f8c4be 285 }
0b94d6bf 286 return get_string($string, $this->plugin_name());
d1b7e03d
TH
287 }
288
289 /**
290 * Set any missing settings for this question to the default values. This is
291 * called before displaying the question editing form.
292 *
293 * @param object $questiondata the question data, loaded from the databsae,
294 * or more likely a newly created question object that is only partially
295 * initialised.
296 */
297 public function set_default_options($questiondata) {
7b41a4a9 298 }
299
516cf3eb 300 /**
eaeb6b51
TH
301 * Saves (creates or updates) a question.
302 *
303 * Given some question info and some data about the answers
304 * this function parses, organises and saves the question
305 * It is used by {@link question.php} when saving new data from
306 * a form, and also by {@link import.php} when importing questions
307 * This function in turn calls {@link save_question_options}
308 * to save question-type specific data.
309 *
310 * Whether we are saving a new question or updating an existing one can be
311 * determined by testing !empty($question->id). If it is not empty, we are updating.
312 *
313 * The question will be saved in category $form->category.
314 *
315 * @param object $question the question object which should be updated. For a
316 * new question will be mostly empty.
317 * @param object $form the object containing the information to save, as if
318 * from the question editing form.
319 * @param object $course not really used any more.
320 * @return object On success, return the new question object. On failure,
321 * return an object as follows. If the error object has an errors field,
322 * display that as an error message. Otherwise, the editing form will be
323 * redisplayed with validation errors, from validation_errors field, which
324 * is itself an object, shown next to the form fields. (I don't think this
325 * is accurate any more.)
326 */
c7df5006 327 public function save_question($question, $form) {
f29aeb5a
TH
328 global $USER, $DB, $OUTPUT;
329
330 list($question->category) = explode(',', $form->category);
331 $context = $this->get_context_by_category_id($question->category);
fe6ce234 332
516cf3eb 333 // This default implementation is suitable for most
334 // question types.
271ffe3f 335
3d9645ae 336 // First, save the basic question itself.
24e8b9b6 337 $question->name = trim($form->name);
24e8b9b6 338 $question->parent = isset($form->parent) ? $form->parent : 0;
516cf3eb 339 $question->length = $this->actual_number_of_questions($question);
340 $question->penalty = isset($form->penalty) ? $form->penalty : 0;
341
f29aeb5a
TH
342 if (empty($form->questiontext['text'])) {
343 $question->questiontext = '';
516cf3eb 344 } else {
0e35ba6f 345 $question->questiontext = trim($form->questiontext['text']);
516cf3eb 346 }
eaeb6b51
TH
347 $question->questiontextformat = !empty($form->questiontext['format']) ?
348 $form->questiontext['format'] : 0;
516cf3eb 349
f29aeb5a 350 if (empty($form->generalfeedback['text'])) {
a4514d91 351 $question->generalfeedback = '';
1b8a7434 352 } else {
f29aeb5a 353 $question->generalfeedback = trim($form->generalfeedback['text']);
1b8a7434 354 }
eaeb6b51
TH
355 $question->generalfeedbackformat = !empty($form->generalfeedback['format']) ?
356 $form->generalfeedback['format'] : 0;
1b8a7434 357
516cf3eb 358 if (empty($question->name)) {
f29aeb5a 359 $question->name = shorten_text(strip_tags($form->questiontext['text']), 15);
516cf3eb 360 if (empty($question->name)) {
361 $question->name = '-';
362 }
363 }
364
365 if ($question->penalty > 1 or $question->penalty < 0) {
5e8a85aa 366 $question->errors['penalty'] = get_string('invalidpenalty', 'question');
516cf3eb 367 }
368
d1b7e03d
TH
369 if (isset($form->defaultmark)) {
370 $question->defaultmark = $form->defaultmark;
516cf3eb 371 }
372
f29aeb5a
TH
373 // If the question is new, create it.
374 if (empty($question->id)) {
3d9645ae 375 // Set the unique code.
cbe20043 376 $question->stamp = make_unique_id_code();
271e6dec 377 $question->createdby = $USER->id;
378 $question->timecreated = time();
f29aeb5a 379 $question->id = $DB->insert_record('question', $question);
516cf3eb 380 }
381
f29aeb5a
TH
382 // Now, whether we are updating a existing question, or creating a new
383 // one, we have to do the files processing and update the record.
3d9645ae 384 // Question already exists, update.
f29aeb5a
TH
385 $question->modifiedby = $USER->id;
386 $question->timemodified = time();
387
388 if (!empty($question->questiontext) && !empty($form->questiontext['itemid'])) {
eaeb6b51
TH
389 $question->questiontext = file_save_draft_area_files($form->questiontext['itemid'],
390 $context->id, 'question', 'questiontext', (int)$question->id,
391 $this->fileoptions, $question->questiontext);
f29aeb5a
TH
392 }
393 if (!empty($question->generalfeedback) && !empty($form->generalfeedback['itemid'])) {
eaeb6b51
TH
394 $question->generalfeedback = file_save_draft_area_files(
395 $form->generalfeedback['itemid'], $context->id,
396 'question', 'generalfeedback', (int)$question->id,
397 $this->fileoptions, $question->generalfeedback);
f29aeb5a
TH
398 }
399 $DB->update_record('question', $question);
400
3d9645ae 401 // Now to save all the answers and type-specific options.
6459b8fc 402 $form->id = $question->id;
403 $form->qtype = $question->qtype;
516cf3eb 404 $form->category = $question->category;
6459b8fc 405 $form->questiontext = $question->questiontext;
f29aeb5a 406 $form->questiontextformat = $question->questiontextformat;
3d9645ae 407 // Current context.
f29aeb5a 408 $form->context = $context;
516cf3eb 409
410 $result = $this->save_question_options($form);
411
412 if (!empty($result->error)) {
f29aeb5a 413 print_error($result->error);
516cf3eb 414 }
415
416 if (!empty($result->notice)) {
417 notice($result->notice, "question.php?id=$question->id");
418 }
419
420 if (!empty($result->noticeyesno)) {
eaeb6b51
TH
421 throw new coding_exception(
422 '$result->noticeyesno no longer supported in save_question.');
516cf3eb 423 }
424
3d9645ae 425 // Give the question a unique version stamp determined by question_hash().
eaeb6b51
TH
426 $DB->set_field('question', 'version', question_hash($question),
427 array('id' => $question->id));
cbe20043 428
516cf3eb 429 return $question;
430 }
271ffe3f 431
516cf3eb 432 /**
d1b7e03d
TH
433 * Saves question-type specific options
434 *
435 * This is called by {@link save_question()} to save the question-type specific data
436 * @return object $result->error or $result->noticeyesno or $result->notice
437 * @param object $question This holds the information from the editing form,
438 * it is not a standard question object.
439 */
440 public function save_question_options($question) {
f29aeb5a 441 global $DB;
eaeb6b51 442 $extraquestionfields = $this->extra_question_fields();
295043c2 443
eaeb6b51
TH
444 if (is_array($extraquestionfields)) {
445 $question_extension_table = array_shift($extraquestionfields);
271e6dec 446
295043c2 447 $function = 'update_record';
d001dac7 448 $questionidcolname = $this->questionid_column_name();
eaeb6b51
TH
449 $options = $DB->get_record($question_extension_table,
450 array($questionidcolname => $question->id));
295043c2 451 if (!$options) {
452 $function = 'insert_record';
0ff4bd08 453 $options = new stdClass();
d001dac7 454 $options->$questionidcolname = $question->id;
295043c2 455 }
eaeb6b51 456 foreach ($extraquestionfields as $field) {
a8e577de 457 if (property_exists($question, $field)) {
8d54191d 458 $options->$field = $question->$field;
295043c2 459 }
295043c2 460 }
271e6dec 461
8d54191d 462 $DB->{$function}($question_extension_table, $options);
295043c2 463 }
464
eaeb6b51 465 $extraanswerfields = $this->extra_answer_fields();
295043c2 466 // TODO save the answers, with any extra data.
516cf3eb 467 }
468
d1b7e03d 469 public function save_hints($formdata, $withparts = false) {
f29aeb5a 470 global $DB;
7a719748
TH
471 $context = $formdata->context;
472
e5060e22
JP
473 $oldhints = $DB->get_records('question_hints',
474 array('questionid' => $formdata->id), 'id ASC');
295043c2 475
d1b7e03d
TH
476 if (!empty($formdata->hint)) {
477 $numhints = max(array_keys($formdata->hint)) + 1;
478 } else {
479 $numhints = 0;
516cf3eb 480 }
295043c2 481
d1b7e03d
TH
482 if ($withparts) {
483 if (!empty($formdata->hintclearwrong)) {
484 $numclears = max(array_keys($formdata->hintclearwrong)) + 1;
485 } else {
486 $numclears = 0;
487 }
488 if (!empty($formdata->hintshownumcorrect)) {
489 $numshows = max(array_keys($formdata->hintshownumcorrect)) + 1;
490 } else {
491 $numshows = 0;
492 }
493 $numhints = max($numhints, $numclears, $numshows);
494 }
495
496 for ($i = 0; $i < $numhints; $i += 1) {
7a719748
TH
497 if (html_is_blank($formdata->hint[$i]['text'])) {
498 $formdata->hint[$i]['text'] = '';
d1b7e03d
TH
499 }
500
501 if ($withparts) {
7a719748
TH
502 $clearwrong = !empty($formdata->hintclearwrong[$i]);
503 $shownumcorrect = !empty($formdata->hintshownumcorrect[$i]);
d1b7e03d
TH
504 }
505
eaeb6b51
TH
506 if (empty($formdata->hint[$i]['text']) && empty($clearwrong) &&
507 empty($shownumcorrect)) {
d1b7e03d
TH
508 continue;
509 }
510
f3ca24e4 511 // Update an existing hint if possible.
7a719748
TH
512 $hint = array_shift($oldhints);
513 if (!$hint) {
514 $hint = new stdClass();
515 $hint->questionid = $formdata->id;
516 $hint->hint = '';
517 $hint->id = $DB->insert_record('question_hints', $hint);
518 }
519
7a719748
TH
520 $hint->hint = $this->import_or_save_files($formdata->hint[$i],
521 $context, 'question', 'hint', $hint->id);
522 $hint->hintformat = $formdata->hint[$i]['format'];
523 if ($withparts) {
524 $hint->clearwrong = $clearwrong;
525 $hint->shownumcorrect = $shownumcorrect;
526 }
527 $DB->update_record('question_hints', $hint);
528 }
529
530 // Delete any remaining old hints.
531 $fs = get_file_storage();
c73c9836 532 foreach ($oldhints as $oldhint) {
7a719748
TH
533 $fs->delete_area_files($context->id, 'question', 'hint', $oldhint->id);
534 $DB->delete_records('question_hints', array('id' => $oldhint->id));
d1b7e03d
TH
535 }
536 }
537
1c2ed7c5
TH
538 /**
539 * Can be used to {@link save_question_options()} to transfer the combined
540 * feedback fields from $formdata to $options.
541 * @param object $options the $question->options object being built.
542 * @param object $formdata the data from the form.
543 * @param object $context the context the quetsion is being saved into.
f7970e3c 544 * @param bool $withparts whether $options->shownumcorrect should be set.
1c2ed7c5 545 */
eaeb6b51
TH
546 protected function save_combined_feedback_helper($options, $formdata,
547 $context, $withparts = false) {
1c2ed7c5
TH
548 $options->correctfeedback = $this->import_or_save_files($formdata->correctfeedback,
549 $context, 'question', 'correctfeedback', $formdata->id);
550 $options->correctfeedbackformat = $formdata->correctfeedback['format'];
eaeb6b51
TH
551
552 $options->partiallycorrectfeedback = $this->import_or_save_files(
553 $formdata->partiallycorrectfeedback,
1c2ed7c5
TH
554 $context, 'question', 'partiallycorrectfeedback', $formdata->id);
555 $options->partiallycorrectfeedbackformat = $formdata->partiallycorrectfeedback['format'];
eaeb6b51 556
1c2ed7c5
TH
557 $options->incorrectfeedback = $this->import_or_save_files($formdata->incorrectfeedback,
558 $context, 'question', 'incorrectfeedback', $formdata->id);
559 $options->incorrectfeedbackformat = $formdata->incorrectfeedback['format'];
560
561 if ($withparts) {
562 $options->shownumcorrect = !empty($formdata->shownumcorrect);
563 }
564
565 return $options;
566 }
567
d1b7e03d
TH
568 /**
569 * Loads the question type specific options for the question.
570 *
571 * This function loads any question type specific options for the
572 * question from the database into the question object. This information
573 * is placed in the $question->options field. A question type is
574 * free, however, to decide on a internal structure of the options field.
575 * @return bool Indicates success or failure.
576 * @param object $question The question object for the question. This object
577 * should be updated to include the question type
578 * specific information (it is passed by reference).
579 */
580 public function get_question_options($question) {
f29aeb5a
TH
581 global $CFG, $DB, $OUTPUT;
582
583 if (!isset($question->options)) {
584 $question->options = new stdClass();
585 }
d1b7e03d 586
eaeb6b51
TH
587 $extraquestionfields = $this->extra_question_fields();
588 if (is_array($extraquestionfields)) {
589 $question_extension_table = array_shift($extraquestionfields);
590 $extra_data = $DB->get_record($question_extension_table,
591 array($this->questionid_column_name() => $question->id),
592 implode(', ', $extraquestionfields));
295043c2 593 if ($extra_data) {
eaeb6b51 594 foreach ($extraquestionfields as $field) {
295043c2 595 $question->options->$field = $extra_data->$field;
596 }
597 } else {
eaeb6b51
TH
598 echo $OUTPUT->notification('Failed to load question options from the table ' .
599 $question_extension_table . ' for questionid ' . $question->id);
295043c2 600 return false;
601 }
602 }
603
eaeb6b51
TH
604 $extraanswerfields = $this->extra_answer_fields();
605 if (is_array($extraanswerfields)) {
606 $answer_extension_table = array_shift($extraanswerfields);
f29aeb5a 607 $question->options->answers = $DB->get_records_sql("
eaeb6b51 608 SELECT qa.*, qax." . implode(', qax.', $extraanswerfields) . "
e5060e22 609 FROM {question_answers} qa, {{$answer_extension_table}} qax
da8cd9f4
JP
610 WHERE qa.question = ? AND qax.answerid = qa.id
611 ORDER BY qa.id", array($question->id));
295043c2 612 if (!$question->options->answers) {
eaeb6b51
TH
613 echo $OUTPUT->notification('Failed to load question answers from the table ' .
614 $answer_extension_table . 'for questionid ' . $question->id);
295043c2 615 return false;
616 }
617 } else {
eaeb6b51
TH
618 // Don't check for success or failure because some question types do
619 // not use the answers table.
620 $question->options->answers = $DB->get_records('question_answers',
621 array('question' => $question->id), 'id ASC');
295043c2 622 }
623
eaeb6b51
TH
624 $question->hints = $DB->get_records('question_hints',
625 array('questionid' => $question->id), 'id ASC');
d1b7e03d 626
516cf3eb 627 return true;
628 }
629
630 /**
d1b7e03d
TH
631 * Create an appropriate question_definition for the question of this type
632 * using data loaded from the database.
633 * @param object $questiondata the question data loaded from the database.
634 * @return question_definition the corresponding question_definition.
635 */
636 public function make_question($questiondata) {
637 $question = $this->make_question_instance($questiondata);
638 $this->initialise_question_instance($question, $questiondata);
639 return $question;
640 }
0429cd86 641
d1b7e03d
TH
642 /**
643 * Create an appropriate question_definition for the question of this type
644 * using data loaded from the database.
645 * @param object $questiondata the question data loaded from the database.
646 * @return question_definition an instance of the appropriate question_definition subclass.
647 * Still needs to be initialised.
648 */
649 protected function make_question_instance($questiondata) {
650 question_bank::load_question_definition_classes($this->name());
651 $class = 'qtype_' . $this->name() . '_question';
652 return new $class();
653 }
654
655 /**
656 * Initialise the common question_definition fields.
657 * @param question_definition $question the question_definition we are creating.
658 * @param object $questiondata the question data loaded from the database.
659 */
660 protected function initialise_question_instance(question_definition $question, $questiondata) {
661 $question->id = $questiondata->id;
662 $question->category = $questiondata->category;
56e82d99 663 $question->contextid = $questiondata->contextid;
d1b7e03d
TH
664 $question->parent = $questiondata->parent;
665 $question->qtype = $this;
666 $question->name = $questiondata->name;
667 $question->questiontext = $questiondata->questiontext;
668 $question->questiontextformat = $questiondata->questiontextformat;
669 $question->generalfeedback = $questiondata->generalfeedback;
1c2ed7c5 670 $question->generalfeedbackformat = $questiondata->generalfeedbackformat;
d1b7e03d
TH
671 $question->defaultmark = $questiondata->defaultmark + 0;
672 $question->length = $questiondata->length;
673 $question->penalty = $questiondata->penalty;
674 $question->stamp = $questiondata->stamp;
675 $question->version = $questiondata->version;
676 $question->hidden = $questiondata->hidden;
677 $question->timecreated = $questiondata->timecreated;
678 $question->timemodified = $questiondata->timemodified;
679 $question->createdby = $questiondata->createdby;
680 $question->modifiedby = $questiondata->modifiedby;
681
3d9645ae 682 // Fill extra question fields values.
10677751
OS
683 $extraquestionfields = $this->extra_question_fields();
684 if (is_array($extraquestionfields)) {
3d9645ae 685 // Omit table name.
10677751 686 array_shift($extraquestionfields);
3d9645ae 687 foreach ($extraquestionfields as $field) {
10677751
OS
688 $question->$field = $questiondata->options->$field;
689 }
690 }
691
d1b7e03d
TH
692 $this->initialise_question_hints($question, $questiondata);
693 }
694
695 /**
696 * Initialise question_definition::hints field.
697 * @param question_definition $question the question_definition we are creating.
698 * @param object $questiondata the question data loaded from the database.
699 */
700 protected function initialise_question_hints(question_definition $question, $questiondata) {
701 if (empty($questiondata->hints)) {
702 return;
703 }
704 foreach ($questiondata->hints as $hint) {
705 $question->hints[] = $this->make_hint($hint);
706 }
0429cd86 707 }
708
709 /**
d1b7e03d
TH
710 * Create a question_hint, or an appropriate subclass for this question,
711 * from a row loaded from the database.
712 * @param object $hint the DB row from the question hints table.
713 * @return question_hint
9203b705 714 */
d1b7e03d
TH
715 protected function make_hint($hint) {
716 return question_hint::load_from_record($hint);
717 }
718
1c2ed7c5
TH
719 /**
720 * Initialise the combined feedback fields.
721 * @param question_definition $question the question_definition we are creating.
722 * @param object $questiondata the question data loaded from the database.
f7970e3c 723 * @param bool $withparts whether to set the shownumcorrect field.
1c2ed7c5 724 */
eaeb6b51
TH
725 protected function initialise_combined_feedback(question_definition $question,
726 $questiondata, $withparts = false) {
1c2ed7c5
TH
727 $question->correctfeedback = $questiondata->options->correctfeedback;
728 $question->correctfeedbackformat = $questiondata->options->correctfeedbackformat;
729 $question->partiallycorrectfeedback = $questiondata->options->partiallycorrectfeedback;
eaeb6b51
TH
730 $question->partiallycorrectfeedbackformat =
731 $questiondata->options->partiallycorrectfeedbackformat;
1c2ed7c5
TH
732 $question->incorrectfeedback = $questiondata->options->incorrectfeedback;
733 $question->incorrectfeedbackformat = $questiondata->options->incorrectfeedbackformat;
734 if ($withparts) {
735 $question->shownumcorrect = $questiondata->options->shownumcorrect;
736 }
737 }
738
d1b7e03d
TH
739 /**
740 * Initialise question_definition::answers field.
741 * @param question_definition $question the question_definition we are creating.
742 * @param object $questiondata the question data loaded from the database.
35c9b652
TH
743 * @param bool $forceplaintextanswers most qtypes assume that answers are
744 * FORMAT_PLAIN, and dont use the answerformat DB column (it contains
745 * the default 0 = FORMAT_MOODLE). Therefore, by default this method
746 * ingores answerformat. Pass false here to use answerformat. For example
747 * multichoice does this.
748 */
749 protected function initialise_question_answers(question_definition $question,
750 $questiondata, $forceplaintextanswers = true) {
d1b7e03d
TH
751 $question->answers = array();
752 if (empty($questiondata->options->answers)) {
753 return;
754 }
755 foreach ($questiondata->options->answers as $a) {
5f7cfba7
TH
756 $question->answers[$a->id] = new question_answer($a->id, $a->answer,
757 $a->fraction, $a->feedback, $a->feedbackformat);
35c9b652
TH
758 if (!$forceplaintextanswers) {
759 $question->answers[$a->id]->answerformat = $a->answerformat;
760 }
d1b7e03d
TH
761 }
762 }
9203b705 763
d1b7e03d 764 /**
f29aeb5a 765 * Deletes the question-type specific data when a question is deleted.
f7970e3c
TH
766 * @param int $question the question being deleted.
767 * @param int $contextid the context this quesiotn belongs to.
f29aeb5a
TH
768 */
769 public function delete_question($questionid, $contextid) {
770 global $DB;
771
772 $this->delete_files($questionid, $contextid);
516cf3eb 773
eaeb6b51
TH
774 $extraquestionfields = $this->extra_question_fields();
775 if (is_array($extraquestionfields)) {
776 $question_extension_table = array_shift($extraquestionfields);
f29aeb5a
TH
777 $DB->delete_records($question_extension_table,
778 array($this->questionid_column_name() => $questionid));
295043c2 779 }
780
eaeb6b51
TH
781 $extraanswerfields = $this->extra_answer_fields();
782 if (is_array($extraanswerfields)) {
783 $answer_extension_table = array_shift($extraanswerfields);
f29aeb5a 784 $DB->delete_records_select($answer_extension_table,
eaeb6b51
TH
785 'answerid IN (SELECT qa.id FROM {question_answers} qa WHERE qa.question = ?)',
786 array($questionid));
295043c2 787 }
788
f29aeb5a 789 $DB->delete_records('question_answers', array('question' => $questionid));
d1b7e03d 790
f29aeb5a 791 $DB->delete_records('question_hints', array('questionid' => $questionid));
516cf3eb 792 }
793
794 /**
eaeb6b51
TH
795 * Returns the number of question numbers which are used by the question
796 *
797 * This function returns the number of question numbers to be assigned
798 * to the question. Most question types will have length one; they will be
799 * assigned one number. The 'description' type, however does not use up a
800 * number and so has a length of zero. Other question types may wish to
801 * handle a bundle of questions and hence return a number greater than one.
802 * @return int The number of question numbers which should be
803 * assigned to the question.
804 * @param object $question The question whose length is to be determined.
805 * Question type specific information is included.
806 */
d1b7e03d 807 public function actual_number_of_questions($question) {
3d9645ae 808 // By default, each question is given one number.
516cf3eb 809 return 1;
810 }
811
6f51ed72 812 /**
813 * @param object $question
d1b7e03d
TH
814 * @return number|null either a fraction estimating what the student would
815 * score by guessing, or null, if it is not possible to estimate.
6f51ed72 816 */
c7df5006 817 public function get_random_guess_score($questiondata) {
6f51ed72 818 return 0;
819 }
516cf3eb 820
516cf3eb 821 /**
d1b7e03d 822 * This method should return all the possible types of response that are
f9b0500f 823 * recognised for this question.
271e6dec 824 *
d1b7e03d
TH
825 * The question is modelled as comprising one or more subparts. For each
826 * subpart, there are one or more classes that that students response
827 * might fall into, each of those classes earning a certain score.
50da63eb 828 *
d1b7e03d
TH
829 * For example, in a shortanswer question, there is only one subpart, the
830 * text entry field. The response the student gave will be classified according
831 * to which of the possible $question->options->answers it matches.
271e6dec 832 *
d1b7e03d
TH
833 * For the matching question type, there will be one subpart for each
834 * question stem, and for each stem, each of the possible choices is a class
835 * of student's response.
836 *
837 * A response is an object with two fields, ->responseclass is a string
838 * presentation of that response, and ->fraction, the credit for a response
839 * in that class.
840 *
841 * Array keys have no specific meaning, but must be unique, and must be
842 * the same if this function is called repeatedly.
843 *
844 * @param object $question the question definition data.
845 * @return array keys are subquestionid, values are arrays of possible
846 * responses to that subquestion.
99ba746d 847 */
c7df5006 848 public function get_possible_responses($questiondata) {
d1b7e03d 849 return array();
50da63eb 850 }
5fceb049 851
50da63eb 852 /**
46e40567
TH
853 * Utility method used by {@link qtype_renderer::head_code()}. It looks
854 * for any of the files script.js or script.php that exist in the plugin
855 * folder and ensures they get included.
50da63eb 856 */
c76145d3 857 public function find_standard_scripts() {
f29aeb5a
TH
858 global $PAGE;
859
99ba746d 860 $plugindir = $this->plugin_dir();
f29aeb5a 861 $plugindirrel = 'question/type/' . $this->name();
50da63eb 862
863 if (file_exists($plugindir . '/script.js')) {
f29aeb5a 864 $PAGE->requires->js('/' . $plugindirrel . '/script.js');
50da63eb 865 }
866 if (file_exists($plugindir . '/script.php')) {
f29aeb5a 867 $PAGE->requires->js('/' . $plugindirrel . '/script.php');
516cf3eb 868 }
fe9b5cfd 869 }
870
62e76c67 871 /**
eaeb6b51
TH
872 * Returns true if the editing wizard is finished, false otherwise.
873 *
874 * The default implementation returns true, which is suitable for all question-
875 * types that only use one editing form. This function is used in
876 * question.php to decide whether we can regrade any states of the edited
877 * question and redirect to edit.php.
878 *
879 * The dataset dependent question-type, which is extended by the calculated
880 * question-type, overwrites this method because it uses multiple pages (i.e.
881 * a wizard) to set up the question and associated datasets.
882 *
883 * @param object $form The data submitted by the previous page.
884 *
885 * @return bool Whether the wizard's last page was submitted or not.
886 */
f29aeb5a 887 public function finished_edit_wizard($form) {
3d9645ae 888 // In the default case there is only one edit page.
d1b7e03d 889 return true;
62e76c67 890 }
891
3d9645ae 892 // IMPORT/EXPORT FUNCTIONS --------------------------------- .
88bc20c3 893
894 /*
895 * Imports question from the Moodle XML format
896 *
897 * Imports question using information from extra_question_fields function
898 * If some of you fields contains id's you'll need to reimplement this
899 */
a031b0f3 900 public function import_from_xml($data, $question, qformat_xml $format, $extra=null) {
88bc20c3 901 $question_type = $data['@']['type'];
902 if ($question_type != $this->name()) {
903 return false;
904 }
905
906 $extraquestionfields = $this->extra_question_fields();
907 if (!is_array($extraquestionfields)) {
908 return false;
909 }
910
3d9645ae 911 // Omit table name.
88bc20c3 912 array_shift($extraquestionfields);
913 $qo = $format->import_headers($data);
914 $qo->qtype = $question_type;
915
916 foreach ($extraquestionfields as $field) {
05cef658 917 $qo->$field = $format->getpath($data, array('#', $field, 0, '#'), '');
88bc20c3 918 }
919
3d9645ae 920 // Run through the answers.
88bc20c3 921 $answers = $data['#']['answer'];
922 $a_count = 0;
05cef658
JP
923 $extraanswersfields = $this->extra_answer_fields();
924 if (is_array($extraanswersfields)) {
925 array_shift($extraanswersfields);
926 }
927 foreach ($answers as $answer) {
928 $ans = $format->import_answer($answer);
929 if (!$this->has_html_answers()) {
930 $qo->answer[$a_count] = $ans->answer['text'];
931 } else {
88bc20c3 932 $qo->answer[$a_count] = $ans->answer;
88bc20c3 933 }
05cef658
JP
934 $qo->fraction[$a_count] = $ans->fraction;
935 $qo->feedback[$a_count] = $ans->feedback;
936 if (is_array($extraanswersfields)) {
937 foreach ($extraanswersfields as $field) {
938 $qo->{$field}[$a_count] =
939 $format->getpath($answer, array('#', $field, 0, '#'), '');
940 }
941 }
942 ++$a_count;
88bc20c3 943 }
944 return $qo;
945 }
946
947 /*
948 * Export question to the Moodle XML format
949 *
950 * Export question using information from extra_question_fields function
951 * If some of you fields contains id's you'll need to reimplement this
952 */
a031b0f3 953 public function export_to_xml($question, qformat_xml $format, $extra=null) {
88bc20c3 954 $extraquestionfields = $this->extra_question_fields();
955 if (!is_array($extraquestionfields)) {
956 return false;
957 }
958
3d9645ae 959 // Omit table name.
88bc20c3 960 array_shift($extraquestionfields);
961 $expout='';
962 foreach ($extraquestionfields as $field) {
1b343d52 963 $exportedvalue = $format->xml_escape($question->options->$field);
2d01a916 964 $expout .= " <$field>{$exportedvalue}</$field>\n";
88bc20c3 965 }
966
05cef658
JP
967 $extraanswersfields = $this->extra_answer_fields();
968 if (is_array($extraanswersfields)) {
969 array_shift($extraanswersfields);
970 }
971 foreach ($question->options->answers as $answer) {
04fcd1f5 972 $extra = '';
05cef658
JP
973 if (is_array($extraanswersfields)) {
974 foreach ($extraanswersfields as $field) {
1b343d52 975 $exportedvalue = $format->xml_escape($answer->$field);
04fcd1f5 976 $extra .= " <{$field}>{$exportedvalue}</{$field}>\n";
05cef658 977 }
88bc20c3 978 }
05cef658 979
04fcd1f5 980 $expout .= $format->write_answer($answer, $extra);
88bc20c3 981 }
982 return $expout;
983 }
984
b9bd6da4 985 /**
986 * Abstract function implemented by each question type. It runs all the code
987 * required to set up and save a question of any type for testing purposes.
988 * Alternate DB table prefix may be used to facilitate data deletion.
989 */
d1b7e03d 990 public function generate_test($name, $courseid=null) {
b9bd6da4 991 $form = new stdClass();
992 $form->name = $name;
993 $form->questiontextformat = 1;
994 $form->questiontext = 'test question, generated by script';
d1b7e03d
TH
995 $form->defaultmark = 1;
996 $form->penalty = 0.3333333;
b9bd6da4 997 $form->generalfeedback = "Well done";
998
21c08c63 999 $context = context_course::instance($courseid);
b9bd6da4 1000 $newcategory = question_make_default_categories(array($context));
1001 $form->category = $newcategory->id . ',1';
1002
1003 $question = new stdClass();
1004 $question->courseid = $courseid;
1005 $question->qtype = $this->qtype;
1006 return array($form, $question);
1007 }
f29aeb5a
TH
1008
1009 /**
1010 * Get question context by category id
1011 * @param int $category
1012 * @return object $context
1013 */
c7df5006 1014 protected function get_context_by_category_id($category) {
f29aeb5a
TH
1015 global $DB;
1016 $contextid = $DB->get_field('question_categories', 'contextid', array('id'=>$category));
5fbe2118 1017 $context = context::instance_by_id($contextid, IGNORE_MISSING);
f29aeb5a
TH
1018 return $context;
1019 }
1020
1021 /**
1022 * Save the file belonging to one text field.
1023 *
1024 * @param array $field the data from the form (or from import). This will
1025 * normally have come from the formslib editor element, so it will be an
1026 * array with keys 'text', 'format' and 'itemid'. However, when we are
1027 * importing, it will be an array with keys 'text', 'format' and 'files'
1028 * @param object $context the context the question is in.
1029 * @param string $component indentifies the file area question.
eaeb6b51
TH
1030 * @param string $filearea indentifies the file area questiontext,
1031 * generalfeedback, answerfeedback, etc.
f7970e3c 1032 * @param int $itemid identifies the file area.
f29aeb5a
TH
1033 *
1034 * @return string the text for this field, after files have been processed.
1035 */
1036 protected function import_or_save_files($field, $context, $component, $filearea, $itemid) {
1037 if (!empty($field['itemid'])) {
1038 // This is the normal case. We are safing the questions editing form.
1039 return file_save_draft_area_files($field['itemid'], $context->id, $component,
1040 $filearea, $itemid, $this->fileoptions, trim($field['text']));
1041
1042 } else if (!empty($field['files'])) {
1043 // This is the case when we are doing an import.
1044 foreach ($field['files'] as $file) {
1045 $this->import_file($context, $component, $filearea, $itemid, $file);
1046 }
1047 }
1048 return trim($field['text']);
1049 }
1050
1051 /**
1052 * Move all the files belonging to this question from one context to another.
f7970e3c
TH
1053 * @param int $questionid the question being moved.
1054 * @param int $oldcontextid the context it is moving from.
1055 * @param int $newcontextid the context it is moving to.
f29aeb5a
TH
1056 */
1057 public function move_files($questionid, $oldcontextid, $newcontextid) {
1058 $fs = get_file_storage();
1059 $fs->move_area_files_to_new_context($oldcontextid,
1060 $newcontextid, 'question', 'questiontext', $questionid);
1061 $fs->move_area_files_to_new_context($oldcontextid,
1062 $newcontextid, 'question', 'generalfeedback', $questionid);
1063 }
1064
1065 /**
1066 * Move all the files belonging to this question's answers when the question
1067 * is moved from one context to another.
f7970e3c
TH
1068 * @param int $questionid the question being moved.
1069 * @param int $oldcontextid the context it is moving from.
1070 * @param int $newcontextid the context it is moving to.
1071 * @param bool $answerstoo whether there is an 'answer' question area,
f29aeb5a
TH
1072 * as well as an 'answerfeedback' one. Default false.
1073 */
eaeb6b51
TH
1074 protected function move_files_in_answers($questionid, $oldcontextid,
1075 $newcontextid, $answerstoo = false) {
f29aeb5a
TH
1076 global $DB;
1077 $fs = get_file_storage();
1078
1079 $answerids = $DB->get_records_menu('question_answers',
1080 array('question' => $questionid), 'id', 'id,1');
1081 foreach ($answerids as $answerid => $notused) {
1082 if ($answerstoo) {
1083 $fs->move_area_files_to_new_context($oldcontextid,
1084 $newcontextid, 'question', 'answer', $answerid);
1085 }
1086 $fs->move_area_files_to_new_context($oldcontextid,
1087 $newcontextid, 'question', 'answerfeedback', $answerid);
1088 }
1089 }
1090
d44480f6
TH
1091 /**
1092 * Move all the files belonging to this question's hints when the question
1093 * is moved from one context to another.
1094 * @param int $questionid the question being moved.
1095 * @param int $oldcontextid the context it is moving from.
1096 * @param int $newcontextid the context it is moving to.
1097 * @param bool $answerstoo whether there is an 'answer' question area,
1098 * as well as an 'answerfeedback' one. Default false.
1099 */
1100 protected function move_files_in_hints($questionid, $oldcontextid, $newcontextid) {
1101 global $DB;
1102 $fs = get_file_storage();
1103
1104 $hintids = $DB->get_records_menu('question_hints',
1105 array('questionid' => $questionid), 'id', 'id,1');
1106 foreach ($hintids as $hintid => $notused) {
1107 $fs->move_area_files_to_new_context($oldcontextid,
1108 $newcontextid, 'question', 'hint', $hintid);
1109 }
1110 }
1111
a23bda41
TH
1112 /**
1113 * Move all the files belonging to this question's answers when the question
1114 * is moved from one context to another.
1115 * @param int $questionid the question being moved.
1116 * @param int $oldcontextid the context it is moving from.
1117 * @param int $newcontextid the context it is moving to.
1118 * @param bool $answerstoo whether there is an 'answer' question area,
1119 * as well as an 'answerfeedback' one. Default false.
1120 */
1121 protected function move_files_in_combined_feedback($questionid, $oldcontextid,
1122 $newcontextid) {
1123 global $DB;
1124 $fs = get_file_storage();
1125
1126 $fs->move_area_files_to_new_context($oldcontextid,
1127 $newcontextid, 'question', 'correctfeedback', $questionid);
1128 $fs->move_area_files_to_new_context($oldcontextid,
1129 $newcontextid, 'question', 'partiallycorrectfeedback', $questionid);
1130 $fs->move_area_files_to_new_context($oldcontextid,
1131 $newcontextid, 'question', 'incorrectfeedback', $questionid);
1132 }
1133
f29aeb5a
TH
1134 /**
1135 * Delete all the files belonging to this question.
f7970e3c
TH
1136 * @param int $questionid the question being deleted.
1137 * @param int $contextid the context the question is in.
f29aeb5a
TH
1138 */
1139 protected function delete_files($questionid, $contextid) {
1140 $fs = get_file_storage();
1141 $fs->delete_area_files($contextid, 'question', 'questiontext', $questionid);
1142 $fs->delete_area_files($contextid, 'question', 'generalfeedback', $questionid);
1143 }
1144
1145 /**
1146 * Delete all the files belonging to this question's answers.
f7970e3c
TH
1147 * @param int $questionid the question being deleted.
1148 * @param int $contextid the context the question is in.
1149 * @param bool $answerstoo whether there is an 'answer' question area,
f29aeb5a
TH
1150 * as well as an 'answerfeedback' one. Default false.
1151 */
1152 protected function delete_files_in_answers($questionid, $contextid, $answerstoo = false) {
1153 global $DB;
1154 $fs = get_file_storage();
1155
1156 $answerids = $DB->get_records_menu('question_answers',
1157 array('question' => $questionid), 'id', 'id,1');
1158 foreach ($answerids as $answerid => $notused) {
1159 if ($answerstoo) {
1160 $fs->delete_area_files($contextid, 'question', 'answer', $answerid);
1161 }
1162 $fs->delete_area_files($contextid, 'question', 'answerfeedback', $answerid);
1163 }
1164 }
1165
d44480f6
TH
1166 /**
1167 * Delete all the files belonging to this question's hints.
1168 * @param int $questionid the question being deleted.
1169 * @param int $contextid the context the question is in.
1170 */
1171 protected function delete_files_in_hints($questionid, $contextid) {
1172 global $DB;
1173 $fs = get_file_storage();
1174
1175 $hintids = $DB->get_records_menu('question_hints',
1176 array('questionid' => $questionid), 'id', 'id,1');
1177 foreach ($hintids as $hintid => $notused) {
1178 $fs->delete_area_files($contextid, 'question', 'hint', $hintid);
1179 }
1180 }
1181
a23bda41
TH
1182 /**
1183 * Delete all the files belonging to this question's answers.
1184 * @param int $questionid the question being deleted.
1185 * @param int $contextid the context the question is in.
1186 * @param bool $answerstoo whether there is an 'answer' question area,
1187 * as well as an 'answerfeedback' one. Default false.
1188 */
1189 protected function delete_files_in_combined_feedback($questionid, $contextid) {
1190 global $DB;
1191 $fs = get_file_storage();
1192
1193 $fs->delete_area_files($contextid,
1194 'question', 'correctfeedback', $questionid);
1195 $fs->delete_area_files($contextid,
1196 'question', 'partiallycorrectfeedback', $questionid);
1197 $fs->delete_area_files($contextid,
1198 'question', 'incorrectfeedback', $questionid);
1199 }
1200
f902a54e 1201 public function import_file($context, $component, $filearea, $itemid, $file) {
f29aeb5a 1202 $fs = get_file_storage();
0ff4bd08 1203 $record = new stdClass();
f29aeb5a
TH
1204 if (is_object($context)) {
1205 $record->contextid = $context->id;
1206 } else {
1207 $record->contextid = $context;
1208 }
1209 $record->component = $component;
1210 $record->filearea = $filearea;
1211 $record->itemid = $itemid;
1212 $record->filename = $file->name;
1213 $record->filepath = '/';
1214 return $fs->create_file_from_string($record, $this->decode_file($file));
1215 }
1216
c7df5006 1217 protected function decode_file($file) {
f29aeb5a 1218 switch ($file->encoding) {
eaeb6b51
TH
1219 case 'base64':
1220 default:
1221 return base64_decode($file->content);
f29aeb5a
TH
1222 }
1223 }
d1b7e03d 1224}
aeb15530 1225
cde2709a 1226
d1b7e03d
TH
1227/**
1228 * This class is used in the return value from
1229 * {@link question_type::get_possible_responses()}.
1230 *
7764183a
TH
1231 * @copyright 2010 The Open University
1232 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
d1b7e03d
TH
1233 */
1234class question_possible_response {
9203b705 1235 /**
d1b7e03d
TH
1236 * @var string the classification of this response the student gave to this
1237 * part of the question. Must match one of the responseclasses returned by
1238 * {@link question_type::get_possible_responses()}.
9203b705 1239 */
d1b7e03d 1240 public $responseclass;
ba6425ab
TH
1241
1242 /** @var string the (partial) credit awarded for this responses. */
d1b7e03d 1243 public $fraction;
ba6425ab 1244
9203b705 1245 /**
d1b7e03d
TH
1246 * Constructor, just an easy way to set the fields.
1247 * @param string $responseclassid see the field descriptions above.
1248 * @param string $response see the field descriptions above.
1249 * @param number $fraction see the field descriptions above.
9203b705 1250 */
d1b7e03d
TH
1251 public function __construct($responseclass, $fraction) {
1252 $this->responseclass = $responseclass;
1253 $this->fraction = $fraction;
cde2709a
DC
1254 }
1255
d1b7e03d
TH
1256 public static function no_response() {
1257 return new question_possible_response(get_string('noresponse', 'question'), 0);
cde2709a 1258 }
fe6ce234 1259}