MDL-25492 Blackboard V6+ question import is broken.
[moodle.git] / question / format.php
CommitLineData
aeb15530 1<?php
d3603157
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
17/**
18 * Defines the base class for question import and export formats.
19 *
20 * @package moodlecore
21 * @subpackage questionbank
22 * @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}
23 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24 */
25
26
a17b297d
TH
27defined('MOODLE_INTERNAL') || die();
28
29
55190d7e
TH
30/**#@+
31 * The core question types.
32 *
33 * These used to be in lib/questionlib.php, but are being deprecated. Copying
34 * them here to keep the import/export code working for now (there are 135
35 * references to these constants which I don't want to try to fix at the moment.)
36 */
37if (!defined('SHORTANSWER')) {
38 define("SHORTANSWER", "shortanswer");
39 define("TRUEFALSE", "truefalse");
40 define("MULTICHOICE", "multichoice");
41 define("RANDOM", "random");
42 define("MATCH", "match");
43 define("RANDOMSAMATCH", "randomsamatch");
44 define("DESCRIPTION", "description");
45 define("NUMERICAL", "numerical");
46 define("MULTIANSWER", "multianswer");
47 define("CALCULATED", "calculated");
48 define("ESSAY", "essay");
49}
50/**#@-*/
51
52
4323d029 53/**
54 * Base class for question import and export formats.
55 *
d3603157
TH
56 * @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}
57 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
4323d029 58 */
f5565b69 59class qformat_default {
aca318e1 60
13bb604e 61 public $displayerrors = true;
e0736817 62 public $category = null;
13bb604e 63 public $questions = array();
e0736817 64 public $course = null;
13bb604e
TH
65 public $filename = '';
66 public $realfilename = '';
67 public $matchgrades = 'error';
68 public $catfromfile = 0;
69 public $contextfromfile = 0;
70 public $cattofile = 0;
71 public $contexttofile = 0;
72 public $questionids = array();
73 public $importerrors = 0;
74 public $stoponerror = true;
75 public $translator = null;
76 public $canaccessbackupdata = true;
271e6dec 77
cde2709a 78 protected $importcontext = null;
aca318e1 79
e198992b
TH
80 // functions to indicate import/export functionality
81 // override to return true if implemented
aca318e1 82
f7970e3c 83 /** @return bool whether this plugin provides import functionality. */
c7df5006 84 public function provide_import() {
46732124 85 return false;
aca318e1 86 }
87
f7970e3c 88 /** @return bool whether this plugin provides export functionality. */
c7df5006 89 public function provide_export() {
46732124
TH
90 return false;
91 }
92
93 /** The string mime-type of the files that this plugin reads or writes. */
c7df5006 94 public function mime_type() {
46732124
TH
95 return mimeinfo('type', $this->export_file_extension());
96 }
97
98 /**
99 * @return string the file extension (including .) that is normally used for
100 * files handled by this plugin.
101 */
c7df5006 102 public function export_file_extension() {
46732124 103 return '.txt';
aca318e1 104 }
a1ef8c6d 105
7da7bfa1
JF
106 /**
107 * Check if the given file is capable of being imported by this plugin.
108 *
109 * Note that expensive or detailed integrity checks on the file should
110 * not be performed by this method. Simple file type or magic-number tests
111 * would be suitable.
112 *
a1ef8c6d 113 * @param stored_file $file the file to check
7da7bfa1
JF
114 * @return bool whether this plugin can import the file
115 */
116 public function can_import_file($file) {
117 return ($file->get_mimetype() == $this->mime_type());
118 }
aca318e1 119
e198992b 120 // Accessor methods
aca318e1 121
08892d5b 122 /**
123 * set the category
124 * @param object category the category object
125 */
c7df5006 126 public function setCategory($category) {
13bb604e 127 if (count($this->questions)) {
88bc20c3 128 debugging('You shouldn\'t call setCategory after setQuestions');
129 }
08892d5b 130 $this->category = $category;
4d188926 131 $this->importcontext = get_context_instance_by_id($this->category->contextid);
08892d5b 132 }
aca318e1 133
2c44a3d3 134 /**
135 * Set the specific questions to export. Should not include questions with
136 * parents (sub questions of cloze question type).
137 * Only used for question export.
138 * @param array of question objects
139 */
c7df5006 140 public function setQuestions($questions) {
13bb604e 141 if ($this->category !== null) {
88bc20c3 142 debugging('You shouldn\'t call setQuestions after setCategory');
143 }
2c44a3d3 144 $this->questions = $questions;
145 }
146
08892d5b 147 /**
148 * set the course class variable
149 * @param course object Moodle course variable
150 */
c7df5006 151 public function setCourse($course) {
aca318e1 152 $this->course = $course;
08892d5b 153 }
13bb604e 154
271e6dec 155 /**
156 * set an array of contexts.
157 * @param array $contexts Moodle course variable
158 */
c7df5006 159 public function setContexts($contexts) {
271e6dec 160 $this->contexts = $contexts;
161 $this->translator = new context_to_string_translator($this->contexts);
162 }
aca318e1 163
08892d5b 164 /**
165 * set the filename
166 * @param string filename name of file to import/export
167 */
c7df5006 168 public function setFilename($filename) {
08892d5b 169 $this->filename = $filename;
170 }
88bc20c3 171
172 /**
73b7b195 173 * set the "real" filename
174 * (this is what the user typed, regardless of wha happened next)
175 * @param string realfilename name of file as typed by user
176 */
c7df5006 177 public function setRealfilename($realfilename) {
88bc20c3 178 $this->realfilename = $realfilename;
179 }
08892d5b 180
181 /**
182 * set matchgrades
183 * @param string matchgrades error or nearest for grades
184 */
c7df5006 185 public function setMatchgrades($matchgrades) {
08892d5b 186 $this->matchgrades = $matchgrades;
aca318e1 187 }
188
76f0a334 189 /**
08892d5b 190 * set catfromfile
191 * @param bool catfromfile allow categories embedded in import file
76f0a334 192 */
c7df5006 193 public function setCatfromfile($catfromfile) {
08892d5b 194 $this->catfromfile = $catfromfile;
195 }
271e6dec 196
197 /**
198 * set contextfromfile
199 * @param bool $contextfromfile allow contexts embedded in import file
200 */
c7df5006 201 public function setContextfromfile($contextfromfile) {
271e6dec 202 $this->contextfromfile = $contextfromfile;
203 }
204
f1abd39f 205 /**
206 * set cattofile
207 * @param bool cattofile exports categories within export file
208 */
c7df5006 209 public function setCattofile($cattofile) {
f1abd39f 210 $this->cattofile = $cattofile;
271e6dec 211 }
13bb604e 212
271e6dec 213 /**
214 * set contexttofile
215 * @param bool cattofile exports categories within export file
216 */
c7df5006 217 public function setContexttofile($contexttofile) {
271e6dec 218 $this->contexttofile = $contexttofile;
219 }
aca318e1 220
f3701561 221 /**
222 * set stoponerror
223 * @param bool stoponerror stops database write if any errors reported
224 */
c7df5006 225 public function setStoponerror($stoponerror) {
f3701561 226 $this->stoponerror = $stoponerror;
227 }
228
1b8b535d 229 /**
f7970e3c 230 * @param bool $canaccess Whether the current use can access the backup data folder. Determines
1b8b535d 231 * where export files are saved.
232 */
c7df5006 233 public function set_can_access_backupdata($canaccess) {
1b8b535d 234 $this->canaccessbackupdata = $canaccess;
235 }
236
e198992b
TH
237 /***********************
238 * IMPORTING FUNCTIONS
239 ***********************/
f3701561 240
241 /**
242 * Handle parsing error
243 */
c7df5006 244 protected function error($message, $text='', $questionname='') {
5e8a85aa 245 $importerrorquestion = get_string('importerrorquestion', 'question');
cdeabc06 246
f3701561 247 echo "<div class=\"importerror\">\n";
cdeabc06 248 echo "<strong>$importerrorquestion $questionname</strong>";
f3701561 249 if (!empty($text)) {
250 $text = s($text);
251 echo "<blockquote>$text</blockquote>\n";
252 }
253 echo "<strong>$message</strong>\n";
254 echo "</div>";
255
256 $this->importerrors++;
257 }
08892d5b 258
271e6dec 259 /**
a41e3287 260 * Import for questiontype plugins
261 * Do not override.
262 * @param data mixed The segment of data containing the question
263 * @param question object processed (so far) by standard import code if appropriate
264 * @param extra mixed any additional format specific data that may be passed by the format
88bc20c3 265 * @param qtypehint hint about a question type from format
a41e3287 266 * @return object question object suitable for save_options() or false if cannot handle
267 */
c7df5006 268 public function try_importing_using_qtypes($data, $question = null, $extra = null,
49e2bba7 269 $qtypehint = '') {
a41e3287 270
271 // work out what format we are using
88bc20c3 272 $formatname = substr(get_class($this), strlen('qformat_'));
a41e3287 273 $methodname = "import_from_$formatname";
274
88bc20c3 275 //first try importing using a hint from format
276 if (!empty($qtypehint)) {
49e2bba7 277 $qtype = question_bank::get_qtype($qtypehint, false);
88bc20c3 278 if (is_object($qtype) && method_exists($qtype, $methodname)) {
279 $question = $qtype->$methodname($data, $question, $this, $extra);
280 if ($question) {
281 return $question;
282 }
283 }
284 }
285
a41e3287 286 // loop through installed questiontypes checking for
287 // function to handle this question
49e2bba7 288 foreach (question_bank::get_all_qtypes() as $qtype) {
13bb604e
TH
289 if (method_exists($qtype, $methodname)) {
290 if ($question = $qtype->$methodname($data, $question, $this, $extra)) {
a41e3287 291 return $question;
292 }
293 }
271e6dec 294 }
295 return false;
a41e3287 296 }
297
08892d5b 298 /**
299 * Perform any required pre-processing
f7970e3c 300 * @return bool success
08892d5b 301 */
7348402f 302 public function importpreprocess() {
08892d5b 303 return true;
304 }
305
306 /**
307 * Process the file
308 * This method should not normally be overidden
49e2bba7 309 * @param object $category
f7970e3c 310 * @return bool success
08892d5b 311 */
7348402f 312 public function importprocess($category) {
d649fb02 313 global $USER, $CFG, $DB, $OUTPUT;
cde2709a 314
9dd46039
TH
315 // reset the timer in case file upload was slow
316 set_time_limit(0);
67c12527 317
9dd46039 318 // STAGE 1: Parse the file
5e8a85aa 319 echo $OUTPUT->notification(get_string('parsingquestions', 'question'), 'notifysuccess');
271e6dec 320
08892d5b 321 if (! $lines = $this->readdata($this->filename)) {
5e8a85aa 322 echo $OUTPUT->notification(get_string('cannotread', 'question'));
aca318e1 323 return false;
324 }
325
4d188926 326 if (!$questions = $this->readquestions($lines)) { // Extract all the questions
5e8a85aa 327 echo $OUTPUT->notification(get_string('noquestionsinfile', 'question'));
aca318e1 328 return false;
329 }
330
f3701561 331 // STAGE 2: Write data to database
5e8a85aa 332 echo $OUTPUT->notification(get_string('importingquestions', 'question',
f7c1dfaf 333 $this->count_questions($questions)), 'notifysuccess');
aca318e1 334
f3701561 335 // check for errors before we continue
336 if ($this->stoponerror and ($this->importerrors>0)) {
5e8a85aa 337 echo $OUTPUT->notification(get_string('importparseerror', 'question'));
10b4a508 338 return true;
f3701561 339 }
340
76f0a334 341 // get list of valid answer grades
92111e8d 342 $gradeoptionsfull = question_bank::fraction_options_full();
76f0a334 343
c1828e0b 344 // check answer grades are valid
345 // (now need to do this here because of 'stop on error': MDL-10689)
346 $gradeerrors = 0;
347 $goodquestions = array();
348 foreach ($questions as $question) {
349 if (!empty($question->fraction) and (is_array($question->fraction))) {
350 $fractions = $question->fraction;
351 $answersvalid = true; // in case they are!
352 foreach ($fractions as $key => $fraction) {
e198992b
TH
353 $newfraction = match_grade_options($gradeoptionsfull, $fraction,
354 $this->matchgrades);
355 if ($newfraction === false) {
c1828e0b 356 $answersvalid = false;
e198992b 357 } else {
c1828e0b 358 $fractions[$key] = $newfraction;
359 }
360 }
361 if (!$answersvalid) {
5e8a85aa 362 echo $OUTPUT->notification(get_string('invalidgrade', 'question'));
c1828e0b 363 ++$gradeerrors;
364 continue;
e198992b 365 } else {
c1828e0b 366 $question->fraction = $fractions;
367 }
368 }
369 $goodquestions[] = $question;
370 }
371 $questions = $goodquestions;
372
373 // check for errors before we continue
e198992b 374 if ($this->stoponerror && $gradeerrors > 0) {
c1828e0b 375 return false;
376 }
377
378 // count number of questions processed
aca318e1 379 $count = 0;
380
381 foreach ($questions as $question) { // Process and store each question
08892d5b 382
271e6dec 383 // reset the php timeout
49e2bba7 384 set_time_limit(0);
67c12527 385
08892d5b 386 // check for category modifiers
9dd46039 387 if ($question->qtype == 'category') {
08892d5b 388 if ($this->catfromfile) {
389 // find/create category object
40e71443 390 $catpath = $question->category;
728d60a1 391 $newcategory = $this->create_category_path($catpath);
08892d5b 392 if (!empty($newcategory)) {
393 $this->category = $newcategory;
394 }
395 }
271e6dec 396 continue;
08892d5b 397 }
4d188926 398 $question->context = $this->importcontext;
08892d5b 399
aca318e1 400 $count++;
401
5b0dc681 402 echo "<hr /><p><b>$count</b>. ".$this->format_question_text($question)."</p>";
aca318e1 403
9dd46039 404 $question->category = $this->category->id;
aca318e1 405 $question->stamp = make_unique_id_code(); // Set the unique code (not to be changed)
aca318e1 406
271e6dec 407 $question->createdby = $USER->id;
408 $question->timecreated = time();
08f53286
TH
409 $question->modifiedby = $USER->id;
410 $question->timemodified = time();
cc0188c2
JMV
411 $fileoptions = array(
412 'subdirs' => false,
413 'maxfiles' => -1,
414 'maxbytes' => 0,
415 );
416 if (is_array($question->questiontext)) {
417 // Importing images from draftfile.
418 $questiontext = $question->questiontext;
419 $question->questiontext = $questiontext['text'];
420 }
421 if (is_array($question->generalfeedback)) {
422 $generalfeedback = $question->generalfeedback;
423 $question->generalfeedback = $generalfeedback['text'];
424 }
271e6dec 425
cde2709a 426 $question->id = $DB->insert_record('question', $question);
cc0188c2
JMV
427
428 if (!empty($questiontext['itemid'])) {
429 $question->questiontext = file_save_draft_area_files($questiontext['itemid'],
430 $this->importcontext->id, 'question', 'questiontext', $question->id,
431 $fileoptions, $question->questiontext);
432 } else if (isset($question->questiontextfiles)) {
cde2709a 433 foreach ($question->questiontextfiles as $file) {
d649fb02 434 question_bank::get_qtype($question->qtype)->import_file(
4d188926 435 $this->importcontext, 'question', 'questiontext', $question->id, $file);
cde2709a
DC
436 }
437 }
cc0188c2
JMV
438 if (!empty($generalfeedback['itemid'])) {
439 $question->generalfeedback = file_save_draft_area_files($generalfeedback['itemid'],
440 $this->importcontext->id, 'question', 'generalfeedback', $question->id,
441 $fileoptions, $question->generalfeedback);
442 } else if (isset($question->generalfeedbackfiles)) {
cde2709a 443 foreach ($question->generalfeedbackfiles as $file) {
d649fb02 444 question_bank::get_qtype($question->qtype)->import_file(
4d188926 445 $this->importcontext, 'question', 'generalfeedback', $question->id, $file);
cde2709a
DC
446 }
447 }
cc0188c2 448 $DB->update_record('question', $question);
aca318e1 449
450 $this->questionids[] = $question->id;
451
452 // Now to save all the answers and type-specific options
453
d649fb02 454 $result = question_bank::get_qtype($question->qtype)->save_question_options($question);
aca318e1 455
4f290077
TH
456 if (!empty($CFG->usetags) && isset($question->tags)) {
457 require_once($CFG->dirroot . '/tag/lib.php');
458 tag_set('question', $question->id, $question->tags);
459 }
460
aca318e1 461 if (!empty($result->error)) {
fef8f84e 462 echo $OUTPUT->notification($result->error);
aca318e1 463 return false;
464 }
465
466 if (!empty($result->notice)) {
fef8f84e 467 echo $OUTPUT->notification($result->notice);
aca318e1 468 return true;
469 }
cbe20043 470
471 // Give the question a unique version stamp determined by question_hash()
e198992b
TH
472 $DB->set_field('question', 'version', question_hash($question),
473 array('id' => $question->id));
aca318e1 474 }
475 return true;
476 }
13bb604e 477
ce2df288 478 /**
479 * Count all non-category questions in the questions array.
f34488b2 480 *
ce2df288 481 * @param array questions An array of question objects.
482 * @return int The count.
f34488b2 483 *
ce2df288 484 */
c7df5006 485 protected function count_questions($questions) {
ce2df288 486 $count = 0;
487 if (!is_array($questions)) {
488 return $count;
489 }
490 foreach ($questions as $question) {
e198992b
TH
491 if (!is_object($question) || !isset($question->qtype) ||
492 ($question->qtype == 'category')) {
ce2df288 493 continue;
494 }
495 $count++;
496 }
497 return $count;
498 }
499
271e6dec 500 /**
501 * find and/or create the category described by a delimited list
502 * e.g. $course$/tom/dick/harry or tom/dick/harry
503 *
504 * removes any context string no matter whether $getcontext is set
505 * but if $getcontext is set then ignore the context and use selected category context.
506 *
507 * @param string catpath delimited category path
271e6dec 508 * @param int courseid course to search for categories
509 * @return mixed category object or null if fails
510 */
c7df5006 511 protected function create_category_path($catpath) {
f34488b2 512 global $DB;
728d60a1 513 $catnames = $this->split_category_path($catpath);
271e6dec 514 $parent = 0;
515 $category = null;
88bc20c3 516
5ca9e32d 517 // check for context id in path, it might not be there in pre 1.9 exports
518 $matchcount = preg_match('/^\$([a-z]+)\$$/', $catnames[0], $matches);
49e2bba7 519 if ($matchcount == 1) {
271e6dec 520 $contextid = $this->translator->string_to_context($matches[1]);
521 array_shift($catnames);
522 } else {
728d60a1 523 $contextid = false;
271e6dec 524 }
728d60a1
TH
525
526 if ($this->contextfromfile && $contextid !== false) {
271e6dec 527 $context = get_context_instance_by_id($contextid);
528 require_capability('moodle/question:add', $context);
529 } else {
530 $context = get_context_instance_by_id($this->category->contextid);
531 }
4d188926 532 $this->importcontext = $context;
728d60a1
TH
533
534 // Now create any categories that need to be created.
271e6dec 535 foreach ($catnames as $catname) {
e198992b
TH
536 if ($category = $DB->get_record('question_categories',
537 array('name' => $catname, 'contextid' => $context->id, 'parent' => $parent))) {
271e6dec 538 $parent = $category->id;
539 } else {
540 require_capability('moodle/question:managecategory', $context);
541 // create the new category
7f389342 542 $category = new stdClass();
271e6dec 543 $category->contextid = $context->id;
544 $category->name = $catname;
545 $category->info = '';
546 $category->parent = $parent;
547 $category->sortorder = 999;
548 $category->stamp = make_unique_id_code();
bf8e93d7 549 $id = $DB->insert_record('question_categories', $category);
271e6dec 550 $category->id = $id;
551 $parent = $id;
552 }
553 }
554 return $category;
555 }
3f5633df 556
f3701561 557 /**
558 * Return complete file within an array, one item per line
559 * @param string filename name of file
560 * @return mixed contents array or false on failure
561 */
c7df5006 562 protected function readdata($filename) {
aca318e1 563 if (is_readable($filename)) {
564 $filearray = file($filename);
565
5af6c967
TH
566 // If the first line of the file starts with a UTF-8 BOM, remove it.
567 $filearray[0] = textlib::trim_utf8_bom($filearray[0]);
568
569 // Check for Macintosh OS line returns (ie file on one line), and fix.
6dbcacee 570 if (preg_match("~\r~", $filearray[0]) AND !preg_match("~\n~", $filearray[0])) {
aca318e1 571 return explode("\r", $filearray[0]);
572 } else {
573 return $filearray;
574 }
575 }
576 return false;
577 }
578
f3701561 579 /**
271e6dec 580 * Parses an array of lines into an array of questions,
581 * where each item is a question object as defined by
582 * readquestion(). Questions are defined as anything
f3701561 583 * between blank lines.
584 *
4d188926
TH
585 * NOTE this method used to take $context as a second argument. However, at
586 * the point where this method was called, it was impossible to know what
587 * context the quetsions were going to be saved into, so the value could be
588 * wrong. Also, none of the standard question formats were using this argument,
589 * so it was removed. See MDL-32220.
590 *
f3701561 591 * If your format does not use blank lines as a delimiter
592 * then you will need to override this method. Even then
593 * try to use readquestion for each question
594 * @param array lines array of lines from readdata
595 * @return array array of question objects
596 */
4d188926 597 protected function readquestions($lines) {
271e6dec 598
aca318e1 599 $questions = array();
600 $currentquestion = array();
601
602 foreach ($lines as $line) {
603 $line = trim($line);
604 if (empty($line)) {
605 if (!empty($currentquestion)) {
606 if ($question = $this->readquestion($currentquestion)) {
607 $questions[] = $question;
608 }
609 $currentquestion = array();
610 }
611 } else {
612 $currentquestion[] = $line;
613 }
614 }
615
616 if (!empty($currentquestion)) { // There may be a final question
4d188926 617 if ($question = $this->readquestion($currentquestion)) {
aca318e1 618 $questions[] = $question;
619 }
620 }
621
622 return $questions;
623 }
624
f3701561 625 /**
626 * return an "empty" question
627 * Somewhere to specify question parameters that are not handled
628 * by import but are required db fields.
629 * This should not be overridden.
630 * @return object default question
271e6dec 631 */
c7df5006 632 protected function defaultquestion() {
b0679efa 633 global $CFG;
0cd46577 634 static $defaultshuffleanswers = null;
635 if (is_null($defaultshuffleanswers)) {
636 $defaultshuffleanswers = get_config('quiz', 'shuffleanswers');
637 }
271e6dec 638
aca318e1 639 $question = new stdClass();
0cd46577 640 $question->shuffleanswers = $defaultshuffleanswers;
49e2bba7 641 $question->defaultmark = 1;
aca318e1 642 $question->image = "";
643 $question->usecase = 0;
644 $question->multiplier = array();
45bdcf11 645 $question->questiontextformat = FORMAT_MOODLE;
172f6d95 646 $question->generalfeedback = '';
45bdcf11 647 $question->generalfeedbackformat = FORMAT_MOODLE;
08892d5b 648 $question->correctfeedback = '';
649 $question->partiallycorrectfeedback = '';
650 $question->incorrectfeedback = '';
5931ea94 651 $question->answernumbering = 'abc';
49e2bba7 652 $question->penalty = 0.3333333;
3f5633df 653 $question->length = 1;
aca318e1 654
5fd8f999 655 // this option in case the questiontypes class wants
656 // to know where the data came from
657 $question->export_process = true;
093414d2 658 $question->import_process = true;
5fd8f999 659
aca318e1 660 return $question;
661 }
662
cc0188c2
JMV
663 /**
664 * Add a blank combined feedback to a question object.
665 * @param object question
666 * @return object question
667 */
668 protected function add_blank_combined_feedback($question) {
669 $question->correctfeedback['text'] = '';
670 $question->correctfeedback['format'] = $question->questiontextformat;
671 $question->correctfeedback['files'] = array();
672 $question->partiallycorrectfeedback['text'] = '';
673 $question->partiallycorrectfeedback['format'] = $question->questiontextformat;
674 $question->partiallycorrectfeedback['files'] = array();
675 $question->incorrectfeedback['text'] = '';
676 $question->incorrectfeedback['format'] = $question->questiontextformat;
677 $question->incorrectfeedback['files'] = array();
678 return $question;
679 }
680
f3701561 681 /**
271e6dec 682 * Given the data known to define a question in
683 * this format, this function converts it into a question
f3701561 684 * object suitable for processing and insertion into Moodle.
685 *
686 * If your format does not use blank lines to delimit questions
687 * (e.g. an XML format) you must override 'readquestions' too
688 * @param $lines mixed data that represents question
689 * @return object question object
690 */
c7df5006 691 protected function readquestion($lines) {
aca318e1 692
5e8a85aa 693 $formatnotimplemented = get_string('formatnotimplemented', 'question');
1e3d6fd8 694 echo "<p>$formatnotimplemented</p>";
aca318e1 695
e0736817 696 return null;
aca318e1 697 }
698
f3701561 699 /**
700 * Override if any post-processing is required
f7970e3c 701 * @return bool success
f3701561 702 */
7348402f 703 public function importpostprocess() {
aca318e1 704 return true;
705 }
706
e198992b
TH
707 /*******************
708 * EXPORT FUNCTIONS
709 *******************/
aca318e1 710
271e6dec 711 /**
a41e3287 712 * Provide export functionality for plugin questiontypes
713 * Do not override
714 * @param name questiontype name
271e6dec 715 * @param question object data to export
a41e3287 716 * @param extra mixed any addition format specific data needed
717 * @return string the data to append to export or false if error (or unhandled)
718 */
c7df5006 719 protected function try_exporting_using_qtypes($name, $question, $extra=null) {
a41e3287 720 // work out the name of format in use
13bb604e 721 $formatname = substr(get_class($this), strlen('qformat_'));
a41e3287 722 $methodname = "export_to_$formatname";
723
d649fb02
TH
724 $qtype = question_bank::get_qtype($name, false);
725 if (method_exists($qtype, $methodname)) {
726 return $qtype->$methodname($question, $this, $extra);
a41e3287 727 }
728 return false;
729 }
730
f3701561 731 /**
732 * Do any pre-processing that may be required
f7970e3c 733 * @param bool success
f3701561 734 */
c7df5006 735 public function exportpreprocess() {
aca318e1 736 return true;
737 }
738
f3701561 739 /**
740 * Enable any processing to be done on the content
741 * just prior to the file being saved
742 * default is to do nothing
743 * @param string output text
744 * @param string processed output text
745 */
c7df5006 746 protected function presave_process($content) {
aca318e1 747 return $content;
748 }
749
f3701561 750 /**
751 * Do the export
752 * For most types this should not need to be overrided
cde2709a 753 * @return stored_file
f3701561 754 */
c7df5006 755 public function exportprocess() {
cde2709a 756 global $CFG, $OUTPUT, $DB, $USER;
aca318e1 757
758 // get the questions (from database) in this category
759 // only get q's with no parents (no cloze subquestions specifically)
cde2709a 760 if ($this->category) {
13bb604e 761 $questions = get_questions_category($this->category, true);
2c44a3d3 762 } else {
763 $questions = $this->questions;
764 }
aca318e1 765
aca318e1 766 $count = 0;
767
768 // results are first written into string (and then to a file)
769 // so create/initialize the string here
770 $expout = "";
271e6dec 771
f1abd39f 772 // track which category questions are in
773 // if it changes we will record the category change in the output
774 // file if selected. 0 means that it will get printed before the 1st question
775 $trackcategory = 0;
aca318e1 776
777 // iterate through questions
e198992b 778 foreach ($questions as $question) {
cde2709a 779 // used by file api
e198992b
TH
780 $contextid = $DB->get_field('question_categories', 'contextid',
781 array('id' => $question->category));
cde2709a 782 $question->contextid = $contextid;
271e6dec 783
a9b16aff 784 // do not export hidden questions
785 if (!empty($question->hidden)) {
786 continue;
787 }
788
789 // do not export random questions
55190d7e 790 if ($question->qtype == 'random') {
a9b16aff 791 continue;
792 }
271e6dec 793
f1abd39f 794 // check if we need to record category change
795 if ($this->cattofile) {
796 if ($question->category != $trackcategory) {
271e6dec 797 $trackcategory = $question->category;
728d60a1 798 $categoryname = $this->get_category_path($trackcategory, $this->contexttofile);
271e6dec 799
f1abd39f 800 // create 'dummy' question for category export
7f389342 801 $dummyquestion = new stdClass();
f1abd39f 802 $dummyquestion->qtype = 'category';
803 $dummyquestion->category = $categoryname;
728d60a1 804 $dummyquestion->name = 'Switch category to ' . $categoryname;
f1abd39f 805 $dummyquestion->id = 0;
806 $dummyquestion->questiontextformat = '';
cde2709a 807 $dummyquestion->contextid = 0;
728d60a1 808 $expout .= $this->writequestion($dummyquestion) . "\n";
271e6dec 809 }
810 }
f1abd39f 811
812 // export the question displaying message
813 $count++;
cde2709a 814
cde2709a 815 if (question_has_capability_on($question, 'view', $question->category)) {
cde2709a 816 $expout .= $this->writequestion($question, $contextid) . "\n";
0647e82b 817 }
a9b16aff 818 }
aca318e1 819
2c6d2c88 820 // continue path for following error checks
821 $course = $this->course;
2c44a3d3 822 $continuepath = "$CFG->wwwroot/question/export.php?courseid=$course->id";
2c6d2c88 823
824 // did we actually process anything
825 if ($count==0) {
5e8a85aa 826 print_error('noquestions', 'question', $continuepath);
2c6d2c88 827 }
828
aca318e1 829 // final pre-process on exported data
cde2709a
DC
830 $expout = $this->presave_process($expout);
831 return $expout;
aca318e1 832 }
3f5633df 833
271e6dec 834 /**
835 * get the category as a path (e.g., tom/dick/harry)
836 * @param int id the id of the most nested catgory
271e6dec 837 * @return string the path
838 */
c7df5006 839 protected function get_category_path($id, $includecontext = true) {
f34488b2 840 global $DB;
728d60a1 841
e198992b 842 if (!$category = $DB->get_record('question_categories', array('id' => $id))) {
1e7386c9 843 print_error('cannotfindcategory', 'error', '', $id);
271e6dec 844 }
271e6dec 845 $contextstring = $this->translator->context_to_string($category->contextid);
728d60a1
TH
846
847 $pathsections = array();
271e6dec 848 do {
728d60a1 849 $pathsections[] = $category->name;
271e6dec 850 $id = $category->parent;
13bb604e 851 } while ($category = $DB->get_record('question_categories', array('id' => $id)));
271e6dec 852
13bb604e 853 if ($includecontext) {
728d60a1 854 $pathsections[] = '$' . $contextstring . '$';
271e6dec 855 }
728d60a1
TH
856
857 $path = $this->assemble_category_path(array_reverse($pathsections));
858
271e6dec 859 return $path;
860 }
aca318e1 861
728d60a1
TH
862 /**
863 * Convert a list of category names, possibly preceeded by one of the
864 * context tokens like $course$, into a string representation of the
865 * category path.
866 *
867 * Names are separated by / delimiters. And /s in the name are replaced by //.
868 *
869 * To reverse the process and split the paths into names, use
870 * {@link split_category_path()}.
871 *
872 * @param array $names
873 * @return string
874 */
875 protected function assemble_category_path($names) {
876 $escapednames = array();
877 foreach ($names as $name) {
878 $escapedname = str_replace('/', '//', $name);
879 if (substr($escapedname, 0, 1) == '/') {
880 $escapedname = ' ' . $escapedname;
881 }
882 if (substr($escapedname, -1) == '/') {
883 $escapedname = $escapedname . ' ';
884 }
885 $escapednames[] = $escapedname;
886 }
887 return implode('/', $escapednames);
888 }
889
890 /**
891 * Convert a string, as returned by {@link assemble_category_path()},
892 * back into an array of category names.
893 *
894 * Each category name is cleaned by a call to clean_param(, PARAM_MULTILANG),
aab03169 895 * which matches the cleaning in question/category_form.php.
728d60a1
TH
896 *
897 * @param string $path
898 * @return array of category names.
899 */
900 protected function split_category_path($path) {
901 $rawnames = preg_split('~(?<!/)/(?!/)~', $path);
902 $names = array();
903 foreach ($rawnames as $rawname) {
904 $names[] = clean_param(trim(str_replace('//', '/', $rawname)), PARAM_MULTILANG);
905 }
906 return $names;
907 }
908
f3701561 909 /**
910 * Do an post-processing that may be required
f7970e3c 911 * @return bool success
f3701561 912 */
c7df5006 913 protected function exportpostprocess() {
aca318e1 914 return true;
915 }
916
f3701561 917 /**
918 * convert a single question object into text output in the given
919 * format.
920 * This must be overriden
921 * @param object question question object
922 * @return mixed question export text or null if not implemented
923 */
c7df5006 924 protected function writequestion($question) {
1e3d6fd8 925 // if not overidden, then this is an error.
5e8a85aa 926 $formatnotimplemented = get_string('formatnotimplemented', 'question');
1e3d6fd8 927 echo "<p>$formatnotimplemented</p>";
e0736817 928 return null;
aca318e1 929 }
930
f3701561 931 /**
13bb604e
TH
932 * Convert the question text to plain text, so it can safely be displayed
933 * during import to let the user see roughly what is going on.
f3701561 934 */
c7df5006 935 protected function format_question_text($question) {
fe6ce234 936 global $DB;
0ff4bd08 937 $formatoptions = new stdClass();
5b0dc681 938 $formatoptions->noclean = true;
22cebed5 939 return html_to_text(format_text($question->questiontext,
c73c9836 940 $question->questiontextformat, $formatoptions), 0, false);
5b0dc681 941 }
aca318e1 942}
8a8dd7d8
JMV
943
944class qformat_based_on_xml extends qformat_default {
945
cc0188c2
JMV
946 /**
947 * A lot of imported files contain unwanted entities.
948 * This method tries to clean up all known problems.
949 * @param string str string to correct
950 * @return string the corrected string
951 */
952 public function cleaninput($str) {
953
954 $html_code_list = array(
955 "&#039;" => "'",
956 "&#8217;" => "'",
957 "&#8220;" => "\"",
958 "&#8221;" => "\"",
959 "&#8211;" => "-",
960 "&#8212;" => "-",
961 );
962 $str = strtr($str, $html_code_list);
963 // Use textlib entities_to_utf8 function to convert only numerical entities.
964 $str = textlib::entities_to_utf8($str, false);
965 return $str;
966 }
967
8a8dd7d8
JMV
968 /**
969 * Return the array moodle is expecting
970 * for an HTML text. No processing is done on $text.
971 * qformat classes that want to process $text
972 * for instance to import external images files
973 * and recode urls in $text must overwrite this method.
974 * @param array $text some HTML text string
975 * @return array with keys text, format and files.
976 */
977 public function text_field($text) {
978 return array(
979 'text' => trim($text),
980 'format' => FORMAT_HTML,
981 'files' => array(),
982 );
983 }
984
985 /**
986 * Return the value of a node, given a path to the node
987 * if it doesn't exist return the default value.
988 * @param array xml data to read
989 * @param array path path to node expressed as array
990 * @param mixed default
991 * @param bool istext process as text
992 * @param string error if set value must exist, return false and issue message if not
993 * @return mixed value
994 */
995 public function getpath($xml, $path, $default, $istext=false, $error='') {
996 foreach ($path as $index) {
997 if (!isset($xml[$index])) {
998 if (!empty($error)) {
999 $this->error($error);
1000 return false;
1001 } else {
1002 return $default;
1003 }
1004 }
1005
1006 $xml = $xml[$index];
1007 }
1008
1009 if ($istext) {
1010 if (!is_string($xml)) {
1011 $this->error(get_string('invalidxml', 'qformat_xml'));
1012 }
1013 $xml = trim($xml);
1014 }
1015
1016 return $xml;
1017 }
1018}