Merge branch 'MDL-30021' of git://github.com/timhunt/moodle
[moodle.git] / question / format / xml / format.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  * Code for exporting questions as Moodle XML.
19  *
20  * @package    qformat
21  * @subpackage xml
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  */
27 defined('MOODLE_INTERNAL') || die();
29 require_once($CFG->libdir . '/xmlize.php');
30 if (!class_exists('qformat_default')) {
31     // This is ugly, but this class is also (ab)used by mod/lesson, which defines
32     // a different base class in mod/lesson/format.php. Thefore, we can only
33     // include the proper base class conditionally like this. (We have to include
34     // the base class like this, otherwise it breaks third-party question types.)
35     // This may be reviewd, and a better fix found one day.
36     require_once($CFG->dirroot . '/question/format.php');
37 }
40 /**
41  * Importer for Moodle XML question format.
42  *
43  * See http://docs.moodle.org/en/Moodle_XML_format for a description of the format.
44  *
45  * @copyright  1999 onwards Martin Dougiamas {@link http://moodle.com}
46  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
47  */
48 class qformat_xml extends qformat_default {
50     public function provide_import() {
51         return true;
52     }
54     public function provide_export() {
55         return true;
56     }
58     public function mime_type() {
59         return 'application/xml';
60     }
62     // IMPORT FUNCTIONS START HERE
64     /**
65      * Translate human readable format name
66      * into internal Moodle code number
67      * @param string name format name from xml file
68      * @return int Moodle format code
69      */
70     public function trans_format($name) {
71         $name = trim($name);
73         if ($name == 'moodle_auto_format') {
74             return FORMAT_MOODLE;
75         } else if ($name == 'html') {
76             return FORMAT_HTML;
77         } else if ($name == 'plain_text') {
78             return FORMAT_PLAIN;
79         } else if ($name == 'wiki_like') {
80             return FORMAT_WIKI;
81         } else if ($name == 'markdown') {
82             return FORMAT_MARKDOWN;
83         } else {
84             debugging("Unrecognised text format '{$name}' in the import file. Assuming 'html'.");
85             return FORMAT_HTML;
86         }
87     }
89     /**
90      * Translate human readable single answer option
91      * to internal code number
92      * @param string name true/false
93      * @return int internal code number
94      */
95     public function trans_single($name) {
96         $name = trim($name);
97         if ($name == "false" || !$name) {
98             return 0;
99         } else {
100             return 1;
101         }
102     }
104     /**
105      * process text string from xml file
106      * @param array $text bit of xml tree after ['text']
107      * @return string processed text.
108      */
109     public function import_text($text) {
110         // quick sanity check
111         if (empty($text)) {
112             return '';
113         }
114         $data = $text[0]['#'];
115         return trim($data);
116     }
118     /**
119      * return the value of a node, given a path to the node
120      * if it doesn't exist return the default value
121      * @param array xml data to read
122      * @param array path path to node expressed as array
123      * @param mixed default
124      * @param bool istext process as text
125      * @param string error if set value must exist, return false and issue message if not
126      * @return mixed value
127      */
128     public function getpath($xml, $path, $default, $istext=false, $error='') {
129         foreach ($path as $index) {
130             if (!isset($xml[$index])) {
131                 if (!empty($error)) {
132                     $this->error($error);
133                     return false;
134                 } else {
135                     return $default;
136                 }
137             }
139             $xml = $xml[$index];
140         }
142         if ($istext) {
143             if (!is_string($xml)) {
144                 $this->error(get_string('invalidxml', 'qformat_xml'));
145             }
146             $xml = trim($xml);
147         }
149         return $xml;
150     }
153     /**
154      * import parts of question common to all types
155      * @param $question array question question array from xml tree
156      * @return object question object
157      */
158     public function import_headers($question) {
159         global $CFG;
161         // get some error strings
162         $error_noname = get_string('xmlimportnoname', 'qformat_xml');
163         $error_noquestion = get_string('xmlimportnoquestion', 'qformat_xml');
165         // this routine initialises the question object
166         $qo = $this->defaultquestion();
168         // Question name
169         $qo->name = $this->getpath($question,
170                 array('#', 'name', 0, '#', 'text', 0, '#'), '', true,
171                 get_string('xmlimportnoname', 'qformat_xml'));
172         $qo->questiontext = $this->getpath($question,
173                 array('#', 'questiontext', 0, '#', 'text', 0, '#'), '', true);
174         $qo->questiontextformat = $this->trans_format($this->getpath(
175                 $question, array('#', 'questiontext', 0, '@', 'format'), 'html'));
177         $qo->questiontextfiles = $this->import_files($this->getpath($question,
178                 array('#', 'questiontext', 0, '#', 'file'), array(), false));
180         // Backwards compatibility, deal with the old image tag.
181         $filedata = $this->getpath($question, array('#', 'image_base64', '0', '#'), null, false);
182         $filename = $this->getpath($question, array('#', 'image', '0', '#'), null, false);
183         if ($filedata && $filename) {
184             $data = new stdClass();
185             $data->content = $filedata;
186             $data->encoding = 'base64';
187             $data->name = $filename;
188             $qo->questiontextfiles[] = $data;
189             $qo->questiontext .= ' <img src="@@PLUGINFILE@@/' . $filename . '" />';
190         }
192         // restore files in generalfeedback
193         $qo->generalfeedback = $this->getpath($question,
194                 array('#', 'generalfeedback', 0, '#', 'text', 0, '#'), $qo->generalfeedback, true);
195         $qo->generalfeedbackfiles = array();
196         $qo->generalfeedbackformat = $this->trans_format($this->getpath($question,
197                 array('#', 'generalfeedback', 0, '@', 'format'), $this->get_format($qo->questiontextformat)));
198         $qo->generalfeedbackfiles = $this->import_files($this->getpath($question,
199                 array('#', 'generalfeedback', 0, '#', 'file'), array(), false));
201         $qo->defaultmark = $this->getpath($question,
202                 array('#', 'defaultgrade', 0, '#'), $qo->defaultmark);
203         $qo->penalty = $this->getpath($question,
204                 array('#', 'penalty', 0, '#'), $qo->penalty);
206         // Fix problematic rounding from old files:
207         if (abs($qo->penalty - 0.3333333) < 0.005) {
208             $qo->penalty = 0.3333333;
209         }
211         // Read the question tags.
212         if (!empty($CFG->usetags) && array_key_exists('tags', $question['#'])
213                 && !empty($question['#']['tags'][0]['#']['tag'])) {
214             require_once($CFG->dirroot.'/tag/lib.php');
215             $qo->tags = array();
216             foreach ($question['#']['tags'][0]['#']['tag'] as $tagdata) {
217                 $qo->tags[] = $this->getpath($tagdata, array('#', 'text', 0, '#'), '', true);
218             }
219         }
221         return $qo;
222     }
224     /**
225      * Import the common parts of a single answer
226      * @param array answer xml tree for single answer
227      * @param bool $withanswerfiles if true, the answers are HTML (or $defaultformat)
228      *      and so may contain files, otherwise the answers are plain text.
229      * @param array Default text format for the feedback, and the answers if $withanswerfiles
230      *      is true.
231      * @return object answer object
232      */
233     public function import_answer($answer, $withanswerfiles = false, $defaultformat = 'html') {
234         $ans = new stdClass();
236         $ans->answer = array();
237         $ans->answer['text']   = $this->getpath($answer, array('#', 'text', 0, '#'), '', true);
238         $ans->answer['format'] = $this->trans_format($this->getpath($answer,
239                 array('@', 'format'), $defaultformat));
240         if ($withanswerfiles) {
241             $ans->answer['files']  = $this->import_files($this->getpath($answer,
242                     array('#', 'file'), array()));
243         } else {
244             $ans->answer['format'] = FORMAT_PLAIN;
245         }
247         $ans->feedback = array();
248         $ans->feedback['text']   = $this->getpath($answer,
249                 array('#', 'feedback', 0, '#', 'text', 0, '#'), '', true);
250         $ans->feedback['format'] = $this->trans_format($this->getpath($answer,
251                 array('#', 'feedback', 0, '@', 'format'), $defaultformat));
252         $ans->feedback['files']  = $this->import_files($this->getpath($answer,
253                 array('#', 'feedback', 0, '#', 'file'), array()));
255         $ans->fraction = $this->getpath($answer, array('@', 'fraction'), 0) / 100;
257         return $ans;
258     }
260     /**
261      * Import the common overall feedback fields.
262      * @param object $question the part of the XML relating to this question.
263      * @param object $qo the question data to add the fields to.
264      * @param bool $withshownumpartscorrect include the shownumcorrect field.
265      */
266     public function import_combined_feedback($qo, $questionxml, $withshownumpartscorrect = false) {
267         $fields = array('correctfeedback', 'partiallycorrectfeedback', 'incorrectfeedback');
268         foreach ($fields as $field) {
269             $text = array();
270             $text['text'] = $this->getpath($questionxml,
271                     array('#', $field, 0, '#', 'text', 0, '#'), '', true);
272             $text['format'] = $this->trans_format($this->getpath($questionxml,
273                     array('#', $field, 0, '@', 'format'), $this->get_format($qo->questiontextformat)));
274             $text['files'] = $this->import_files($this->getpath($questionxml,
275                     array('#', $field, 0, '#', 'file'), array(), false));
277             $qo->$field = $text;
278         }
280         if ($withshownumpartscorrect) {
281             $qo->shownumcorrect = array_key_exists('shownumcorrect', $questionxml['#']);
283             // Backwards compatibility:
284             if (array_key_exists('correctresponsesfeedback', $questionxml['#'])) {
285                 $qo->shownumcorrect = $this->trans_single($this->getpath($questionxml,
286                         array('#', 'correctresponsesfeedback', 0, '#'), 1));
287             }
288         }
289     }
291     /**
292      * Import a question hint
293      * @param array $hintxml hint xml fragment.
294      * @param string $defaultformat the text format to assume for hints that do not specify.
295      * @return object hint for storing in the database.
296      */
297     public function import_hint($hintxml, $defaultformat) {
298         if (array_key_exists('hintcontent', $hintxml['#'])) {
299             // Backwards compatibility:
301             $hint = new stdClass();
302             $hint->hint = array('format' => FORMAT_HTML, 'files' => array());
303             $hint->hint['text'] = $this->getpath($hintxml,
304                     array('#', 'hintcontent', 0, '#', 'text', 0, '#'), '', true);
305             $hint->hint['format'] = $this->trans_format($defaultformat);
306             $hint->hint['files'] = array();
307             $hint->shownumcorrect = $this->getpath($hintxml,
308                     array('#', 'statenumberofcorrectresponses', 0, '#'), 0);
309             $hint->clearwrong = $this->getpath($hintxml,
310                     array('#', 'clearincorrectresponses', 0, '#'), 0);
311             $hint->options = $this->getpath($hintxml,
312                     array('#', 'showfeedbacktoresponses', 0, '#'), 0);
314             return $hint;
315         }
317         $hint = new stdClass();
318         $hint->hint['text'] = $this->getpath($hintxml,
319                 array('#', 'text', 0, '#'), '', true);
320         $hint->hint['format'] = $this->trans_format($this->getpath($hintxml,
321                 array('@', 'format'), $defaultformat));
322         $hint->hint['files'] = $this->import_files($this->getpath($hintxml,
323                 array('#', 'file'), array(), false));
324         $hint->shownumcorrect = array_key_exists('shownumcorrect', $hintxml['#']);
325         $hint->clearwrong = array_key_exists('clearwrong', $hintxml['#']);
326         $hint->options = $this->getpath($hintxml, array('#', 'options', 0, '#'), '', true);
328         return $hint;
329     }
331     /**
332      * Import all the question hints
333      *
334      * @param object $qo the question data that is being constructed.
335      * @param array $questionxml The xml representing the question.
336      * @param bool $withparts whether the extra fields relating to parts should be imported.
337      * @param bool $withoptions whether the extra options field should be imported.
338      * @param string $defaultformat the text format to assume for hints that do not specify.
339      * @return array of objects representing the hints in the file.
340      */
341     public function import_hints($qo, $questionxml, $withparts = false,
342             $withoptions = false, $defaultformat = 'html') {
343         if (!isset($questionxml['#']['hint'])) {
344             return;
345         }
347         foreach ($questionxml['#']['hint'] as $hintxml) {
348             $hint = $this->import_hint($hintxml, $defaultformat);
349             $qo->hint[] = $hint->hint;
351             if ($withparts) {
352                 $qo->hintshownumcorrect[] = $hint->shownumcorrect;
353                 $qo->hintclearwrong[] = $hint->clearwrong;
354             }
356             if ($withoptions) {
357                 $qo->hintoptions[] = $hint->options;
358             }
359         }
360     }
362     /**
363      * Import files from a node in the XML.
364      * @param array $xml an array of <file> nodes from the the parsed XML.
365      * @return array of things representing files - in the form that save_question expects.
366      */
367     public function import_files($xml) {
368         $files = array();
369         foreach ($xml as $file) {
370             $data = new stdClass();
371             $data->content = $file['#'];
372             $data->encoding = $file['@']['encoding'];
373             $data->name = $file['@']['name'];
374             $files[] = $data;
375         }
376         return $files;
377     }
379     /**
380      * import multiple choice question
381      * @param array question question array from xml tree
382      * @return object question object
383      */
384     public function import_multichoice($question) {
385         // get common parts
386         $qo = $this->import_headers($question);
388         // 'header' parts particular to multichoice
389         $qo->qtype = MULTICHOICE;
390         $single = $this->getpath($question, array('#', 'single', 0, '#'), 'true');
391         $qo->single = $this->trans_single($single);
392         $shuffleanswers = $this->getpath($question,
393                 array('#', 'shuffleanswers', 0, '#'), 'false');
394         $qo->answernumbering = $this->getpath($question,
395                 array('#', 'answernumbering', 0, '#'), 'abc');
396         $qo->shuffleanswers = $this->trans_single($shuffleanswers);
398         // There was a time on the 1.8 branch when it could output an empty
399         // answernumbering tag, so fix up any found.
400         if (empty($qo->answernumbering)) {
401             $qo->answernumbering = 'abc';
402         }
404         // Run through the answers
405         $answers = $question['#']['answer'];
406         $acount = 0;
407         foreach ($answers as $answer) {
408             $ans = $this->import_answer($answer, true, $this->get_format($qo->questiontextformat));
409             $qo->answer[$acount] = $ans->answer;
410             $qo->fraction[$acount] = $ans->fraction;
411             $qo->feedback[$acount] = $ans->feedback;
412             ++$acount;
413         }
415         $this->import_combined_feedback($qo, $question, true);
416         $this->import_hints($qo, $question, true, false, $this->get_format($qo->questiontextformat));
418         return $qo;
419     }
421     /**
422      * Import cloze type question
423      * @param array question question array from xml tree
424      * @return object question object
425      */
426     public function import_multianswer($question) {
427         question_bank::get_qtype('multianswer');
429         $questiontext['text'] = $this->import_text($question['#']['questiontext'][0]['#']['text']);
430         $questiontext['format'] = FORMAT_HTML;
431         $questiontext['itemid'] = '';
432         $qo = qtype_multianswer_extract_question($questiontext);
434         // 'header' parts particular to multianswer
435         $qo->qtype = 'multianswer';
436         $qo->course = $this->course;
437         $qo->generalfeedback = '';
439         $qo->name = $this->import_text($question['#']['name'][0]['#']['text']);
440         $qo->questiontextformat = $questiontext['format'];
441         $qo->questiontext = $qo->questiontext['text'];
442         $qo->questiontextfiles = array();
444         // restore files in generalfeedback
445         $qo->generalfeedback = $this->getpath($question,
446                 array('#', 'generalfeedback', 0, '#', 'text', 0, '#'), $qo->generalfeedback, true);
447         $qo->generalfeedbackformat = $this->trans_format($this->getpath($question,
448                 array('#', 'generalfeedback', 0, '@', 'format'), $this->get_format($qo->questiontextformat)));
449         $qo->generalfeedbackfiles = $this->import_files($this->getpath($question,
450                 array('#', 'generalfeedback', 0, '#', 'file'), array(), false));
452         $qo->penalty = $this->getpath($question,
453                 array('#', 'penalty', 0, '#'), $this->defaultquestion()->penalty);
454         // Fix problematic rounding from old files:
455         if (abs($qo->penalty - 0.3333333) < 0.005) {
456             $qo->penalty = 0.3333333;
457         }
459         $this->import_hints($qo, $question, false, false, $this->get_format($qo->questiontextformat));
461         return $qo;
462     }
464     /**
465      * Import true/false type question
466      * @param array question question array from xml tree
467      * @return object question object
468      */
469     public function import_truefalse($question) {
470         // get common parts
471         global $OUTPUT;
472         $qo = $this->import_headers($question);
474         // 'header' parts particular to true/false
475         $qo->qtype = TRUEFALSE;
477         // In the past, it used to be assumed that the two answers were in the file
478         // true first, then false. Howevever that was not always true. Now, we
479         // try to match on the answer text, but in old exports, this will be a localised
480         // string, so if we don't find true or false, we fall back to the old system.
481         $first = true;
482         $warning = false;
483         foreach ($question['#']['answer'] as $answer) {
484             $answertext = $this->getpath($answer,
485                     array('#', 'text', 0, '#'), '', true);
486             $feedback = $this->getpath($answer,
487                     array('#', 'feedback', 0, '#', 'text', 0, '#'), '', true);
488             $feedbackformat = $this->getpath($answer,
489                     array('#', 'feedback', 0, '@', 'format'), $this->get_format($qo->questiontextformat));
490             $feedbackfiles = $this->getpath($answer,
491                     array('#', 'feedback', 0, '#', 'file'), array());
492             $files = array();
493             foreach ($feedbackfiles as $file) {
494                 $data = new stdClass();
495                 $data->content = $file['#'];
496                 $data->encoding = $file['@']['encoding'];
497                 $data->name = $file['@']['name'];
498                 $files[] = $data;
499             }
500             if ($answertext != 'true' && $answertext != 'false') {
501                 // Old style file, assume order is true/false.
502                 $warning = true;
503                 if ($first) {
504                     $answertext = 'true';
505                 } else {
506                     $answertext = 'false';
507                 }
508             }
510             if ($answertext == 'true') {
511                 $qo->answer = ($answer['@']['fraction'] == 100);
512                 $qo->correctanswer = $qo->answer;
513                 $qo->feedbacktrue = array();
514                 $qo->feedbacktrue['text'] = $feedback;
515                 $qo->feedbacktrue['format'] = $this->trans_format($feedbackformat);
516                 $qo->feedbacktrue['files'] = $files;
517             } else {
518                 $qo->answer = ($answer['@']['fraction'] != 100);
519                 $qo->correctanswer = $qo->answer;
520                 $qo->feedbackfalse = array();
521                 $qo->feedbackfalse['text'] = $feedback;
522                 $qo->feedbackfalse['format'] = $this->trans_format($feedbackformat);
523                 $qo->feedbackfalse['files'] = $files;
524             }
525             $first = false;
526         }
528         if ($warning) {
529             $a = new stdClass();
530             $a->questiontext = $qo->questiontext;
531             $a->answer = get_string($qo->correctanswer ? 'true' : 'false', 'qtype_truefalse');
532             echo $OUTPUT->notification(get_string('truefalseimporterror', 'qformat_xml', $a));
533         }
535         $this->import_hints($qo, $question, false, false, $this->get_format($qo->questiontextformat));
537         return $qo;
538     }
540     /**
541      * Import short answer type question
542      * @param array question question array from xml tree
543      * @return object question object
544      */
545     public function import_shortanswer($question) {
546         // get common parts
547         $qo = $this->import_headers($question);
549         // header parts particular to shortanswer
550         $qo->qtype = SHORTANSWER;
552         // get usecase
553         $qo->usecase = $this->getpath($question, array('#', 'usecase', 0, '#'), $qo->usecase);
555         // Run through the answers
556         $answers = $question['#']['answer'];
557         $acount = 0;
558         foreach ($answers as $answer) {
559             $ans = $this->import_answer($answer, false, $this->get_format($qo->questiontextformat));
560             $qo->answer[$acount] = $ans->answer['text'];
561             $qo->fraction[$acount] = $ans->fraction;
562             $qo->feedback[$acount] = $ans->feedback;
563             ++$acount;
564         }
566         $this->import_hints($qo, $question, false, false, $this->get_format($qo->questiontextformat));
568         return $qo;
569     }
571     /**
572      * Import description type question
573      * @param array question question array from xml tree
574      * @return object question object
575      */
576     public function import_description($question) {
577         // get common parts
578         $qo = $this->import_headers($question);
579         // header parts particular to shortanswer
580         $qo->qtype = DESCRIPTION;
581         $qo->defaultmark = 0;
582         $qo->length = 0;
583         return $qo;
584     }
586     /**
587      * Import numerical type question
588      * @param array question question array from xml tree
589      * @return object question object
590      */
591     public function import_numerical($question) {
592         // get common parts
593         $qo = $this->import_headers($question);
595         // header parts particular to numerical
596         $qo->qtype = NUMERICAL;
598         // get answers array
599         $answers = $question['#']['answer'];
600         $qo->answer = array();
601         $qo->feedback = array();
602         $qo->fraction = array();
603         $qo->tolerance = array();
604         foreach ($answers as $answer) {
605             // answer outside of <text> is deprecated
606             $obj = $this->import_answer($answer, false, $this->get_format($qo->questiontextformat));
607             $qo->answer[] = $obj->answer['text'];
608             if (empty($qo->answer)) {
609                 $qo->answer = '*';
610             }
611             $qo->feedback[]  = $obj->feedback;
612             $qo->tolerance[] = $this->getpath($answer, array('#', 'tolerance', 0, '#'), 0);
614             // fraction as a tag is deprecated
615             $fraction = $this->getpath($answer, array('@', 'fraction'), 0) / 100;
616             $qo->fraction[] = $this->getpath($answer,
617                     array('#', 'fraction', 0, '#'), $fraction); // deprecated
618         }
620         // Get the units array
621         $qo->unit = array();
622         $units = $this->getpath($question, array('#', 'units', 0, '#', 'unit'), array());
623         if (!empty($units)) {
624             $qo->multiplier = array();
625             foreach ($units as $unit) {
626                 $qo->multiplier[] = $this->getpath($unit, array('#', 'multiplier', 0, '#'), 1);
627                 $qo->unit[] = $this->getpath($unit, array('#', 'unit_name', 0, '#'), '', true);
628             }
629         }
630         $qo->unitgradingtype = $this->getpath($question, array('#', 'unitgradingtype', 0, '#'), 0);
631         $qo->unitpenalty = $this->getpath($question, array('#', 'unitpenalty', 0, '#'), 0.1);
632         $qo->showunits = $this->getpath($question, array('#', 'showunits', 0, '#'), null);
633         $qo->unitsleft = $this->getpath($question, array('#', 'unitsleft', 0, '#'), 0);
634         $qo->instructions['text'] = '';
635         $qo->instructions['format'] = FORMAT_HTML;
636         $instructions = $this->getpath($question, array('#', 'instructions'), array());
637         if (!empty($instructions)) {
638             $qo->instructions = array();
639             $qo->instructions['text'] = $this->getpath($instructions,
640                     array('0', '#', 'text', '0', '#'), '', true);
641             $qo->instructions['format'] = $this->trans_format($this->getpath($instructions,
642                     array('0', '@', 'format'), $this->get_format($qo->questiontextformat)));
643             $qo->instructions['files'] = $this->import_files($this->getpath(
644                     $instructions, array('0', '#', 'file'), array()));
645         }
647         if (is_null($qo->showunits)) {
648             // Set a good default, depending on whether there are any units defined.
649             if (empty($qo->unit)) {
650                 $qo->showunits = 3; // qtype_numerical::UNITNONE;
651             } else {
652                 $qo->showunits = 0; // qtype_numerical::UNITOPTIONAL;
653             }
654         }
656         $this->import_hints($qo, $question, false, false, $this->get_format($qo->questiontextformat));
658         return $qo;
659     }
661     /**
662      * Import matching type question
663      * @param array question question array from xml tree
664      * @return object question object
665      */
666     public function import_match($question) {
667         // get common parts
668         $qo = $this->import_headers($question);
670         // header parts particular to matching
671         $qo->qtype = 'match';
672         $qo->shuffleanswers = $this->trans_single($this->getpath($question,
673                 array('#', 'shuffleanswers', 0, '#'), 1));
675         // run through subquestions
676         $qo->subquestions = array();
677         $qo->subanswers = array();
678         foreach ($question['#']['subquestion'] as $subqxml) {
679             $subquestion = array();
680             $subquestion['text'] = $this->getpath($subqxml, array('#', 'text', 0, '#'), '', true);
681             $subquestion['format'] = $this->trans_format($this->getpath($subqxml,
682                     array('@', 'format'), $this->get_format($qo->questiontextformat)));
683             $subquestion['files'] = $this->import_files($this->getpath($subqxml,
684                     array('#', 'file'), array()));
686             $qo->subquestions[] = $subquestion;
687             $answers = $this->getpath($subqxml, array('#', 'answer'), array());
688             $qo->subanswers[] = $this->getpath($subqxml,
689                     array('#', 'answer', 0, '#', 'text', 0, '#'), '', true);
690         }
692         $this->import_combined_feedback($qo, $question, true);
693         $this->import_hints($qo, $question, true, false, $this->get_format($qo->questiontextformat));
695         return $qo;
696     }
698     /**
699      * Import essay type question
700      * @param array question question array from xml tree
701      * @return object question object
702      */
703     public function import_essay($question) {
704         // get common parts
705         $qo = $this->import_headers($question);
707         // header parts particular to essay
708         $qo->qtype = ESSAY;
710         $qo->responseformat = $this->getpath($question,
711                 array('#', 'responseformat', 0, '#'), 'editor');
712         $qo->responsefieldlines = $this->getpath($question,
713                 array('#', 'responsefieldlines', 0, '#'), 15);
714         $qo->attachments = $this->getpath($question,
715                 array('#', 'attachments', 0, '#'), 0);
716         $qo->graderinfo['text'] = $this->getpath($question,
717                 array('#', 'graderinfo', 0, '#', 'text', 0, '#'), '', true);
718         $qo->graderinfo['format'] = $this->trans_format($this->getpath($question,
719                 array('#', 'graderinfo', 0, '@', 'format'), $this->get_format($qo->questiontextformat)));
720         $qo->graderinfo['files'] = $this->import_files($this->getpath($question,
721                 array('#', 'graderinfo', '0', '#', 'file'), array()));
723         return $qo;
724     }
726     /**
727      * Import a calculated question
728      * @param object $question the imported XML data.
729      */
730     public function import_calculated($question) {
732         // get common parts
733         $qo = $this->import_headers($question);
735         // header parts particular to calculated
736         $qo->qtype = CALCULATED;
737         $qo->synchronize = $this->getpath($question, array('#', 'synchronize', 0, '#'), 0);
738         $single = $this->getpath($question, array('#', 'single', 0, '#'), 'true');
739         $qo->single = $this->trans_single($single);
740         $shuffleanswers = $this->getpath($question, array('#', 'shuffleanswers', 0, '#'), 'false');
741         $qo->answernumbering = $this->getpath($question,
742                 array('#', 'answernumbering', 0, '#'), 'abc');
743         $qo->shuffleanswers = $this->trans_single($shuffleanswers);
745         $this->import_combined_feedback($qo, $question);
747         $qo->unitgradingtype = $this->getpath($question,
748                 array('#', 'unitgradingtype', 0, '#'), 0);
749         $qo->unitpenalty = $this->getpath($question, array('#', 'unitpenalty', 0, '#'), null);
750         $qo->showunits = $this->getpath($question, array('#', 'showunits', 0, '#'), 0);
751         $qo->unitsleft = $this->getpath($question, array('#', 'unitsleft', 0, '#'), 0);
752         $qo->instructions = $this->getpath($question,
753                 array('#', 'instructions', 0, '#', 'text', 0, '#'), '', true);
754         if (!empty($instructions)) {
755             $qo->instructions = array();
756             $qo->instructions['text'] = $this->getpath($instructions,
757                     array('0', '#', 'text', '0', '#'), '', true);
758             $qo->instructions['format'] = $this->trans_format($this->getpath($instructions,
759                     array('0', '@', 'format'), $this->get_format($qo->questiontextformat)));
760             $qo->instructions['files'] = $this->import_files($this->getpath($instructions,
761                     array('0', '#', 'file'), array()));
762         }
764         // get answers array
765         $answers = $question['#']['answer'];
766         $qo->answers = array();
767         $qo->feedback = array();
768         $qo->fraction = array();
769         $qo->tolerance = array();
770         $qo->tolerancetype = array();
771         $qo->correctanswerformat = array();
772         $qo->correctanswerlength = array();
773         $qo->feedback = array();
774         foreach ($answers as $answer) {
775             $ans = $this->import_answer($answer, true, $this->get_format($qo->questiontextformat));
776             // answer outside of <text> is deprecated
777             if (empty($ans->answer['text'])) {
778                 $ans->answer['text'] = '*';
779             }
780             $qo->answers[] = $ans->answer;
781             $qo->feedback[] = $ans->feedback;
782             $qo->tolerance[] = $answer['#']['tolerance'][0]['#'];
783             // fraction as a tag is deprecated
784             if (!empty($answer['#']['fraction'][0]['#'])) {
785                 $qo->fraction[] = $answer['#']['fraction'][0]['#'];
786             } else {
787                 $qo->fraction[] = $answer['@']['fraction'] / 100;
788             }
789             $qo->tolerancetype[] = $answer['#']['tolerancetype'][0]['#'];
790             $qo->correctanswerformat[] = $answer['#']['correctanswerformat'][0]['#'];
791             $qo->correctanswerlength[] = $answer['#']['correctanswerlength'][0]['#'];
792         }
793         // get units array
794         $qo->unit = array();
795         if (isset($question['#']['units'][0]['#']['unit'])) {
796             $units = $question['#']['units'][0]['#']['unit'];
797             $qo->multiplier = array();
798             foreach ($units as $unit) {
799                 $qo->multiplier[] = $unit['#']['multiplier'][0]['#'];
800                 $qo->unit[] = $unit['#']['unit_name'][0]['#'];
801             }
802         }
803         $instructions = $this->getpath($question, array('#', 'instructions'), array());
804         if (!empty($instructions)) {
805             $qo->instructions = array();
806             $qo->instructions['text'] = $this->getpath($instructions,
807                     array('0', '#', 'text', '0', '#'), '', true);
808             $qo->instructions['format'] = $this->trans_format($this->getpath($instructions,
809                     array('0', '@', 'format'), $this->get_format($qo->questiontextformat)));
810             $qo->instructions['files'] = $this->import_files($this->getpath($instructions,
811                     array('0', '#', 'file'), array()));
812         }
814         if (is_null($qo->unitpenalty)) {
815             // Set a good default, depending on whether there are any units defined.
816             if (empty($qo->unit)) {
817                 $qo->showunits = 3; // qtype_numerical::UNITNONE;
818             } else {
819                 $qo->showunits = 0; // qtype_numerical::UNITOPTIONAL;
820             }
821         }
823         $datasets = $question['#']['dataset_definitions'][0]['#']['dataset_definition'];
824         $qo->dataset = array();
825         $qo->datasetindex= 0;
826         foreach ($datasets as $dataset) {
827             $qo->datasetindex++;
828             $qo->dataset[$qo->datasetindex] = new stdClass();
829             $qo->dataset[$qo->datasetindex]->status =
830                     $this->import_text($dataset['#']['status'][0]['#']['text']);
831             $qo->dataset[$qo->datasetindex]->name =
832                     $this->import_text($dataset['#']['name'][0]['#']['text']);
833             $qo->dataset[$qo->datasetindex]->type =
834                     $dataset['#']['type'][0]['#'];
835             $qo->dataset[$qo->datasetindex]->distribution =
836                     $this->import_text($dataset['#']['distribution'][0]['#']['text']);
837             $qo->dataset[$qo->datasetindex]->max =
838                     $this->import_text($dataset['#']['maximum'][0]['#']['text']);
839             $qo->dataset[$qo->datasetindex]->min =
840                     $this->import_text($dataset['#']['minimum'][0]['#']['text']);
841             $qo->dataset[$qo->datasetindex]->length =
842                     $this->import_text($dataset['#']['decimals'][0]['#']['text']);
843             $qo->dataset[$qo->datasetindex]->distribution =
844                     $this->import_text($dataset['#']['distribution'][0]['#']['text']);
845             $qo->dataset[$qo->datasetindex]->itemcount = $dataset['#']['itemcount'][0]['#'];
846             $qo->dataset[$qo->datasetindex]->datasetitem = array();
847             $qo->dataset[$qo->datasetindex]->itemindex = 0;
848             $qo->dataset[$qo->datasetindex]->number_of_items =
849                     $dataset['#']['number_of_items'][0]['#'];
850             $datasetitems = $dataset['#']['dataset_items'][0]['#']['dataset_item'];
851             foreach ($datasetitems as $datasetitem) {
852                 $qo->dataset[$qo->datasetindex]->itemindex++;
853                 $qo->dataset[$qo->datasetindex]->datasetitem[
854                         $qo->dataset[$qo->datasetindex]->itemindex] = new stdClass();
855                 $qo->dataset[$qo->datasetindex]->datasetitem[
856                         $qo->dataset[$qo->datasetindex]->itemindex]->itemnumber =
857                                 $datasetitem['#']['number'][0]['#'];
858                 $qo->dataset[$qo->datasetindex]->datasetitem[
859                         $qo->dataset[$qo->datasetindex]->itemindex]->value =
860                                 $datasetitem['#']['value'][0]['#'];
861             }
862         }
864         $this->import_hints($qo, $question, false, false, $this->get_format($qo->questiontextformat));
866         return $qo;
867     }
869     /**
870      * This is not a real question type. It's a dummy type used to specify the
871      * import category. The format is:
872      * <question type="category">
873      *     <category>tom/dick/harry</category>
874      * </question>
875      */
876     protected function import_category($question) {
877         $qo = new stdClass();
878         $qo->qtype = 'category';
879         $qo->category = $this->import_text($question['#']['category'][0]['#']['text']);
880         return $qo;
881     }
883     /**
884      * Parse the array of lines into an array of questions
885      * this *could* burn memory - but it won't happen that much
886      * so fingers crossed!
887      * @param array of lines from the input file.
888      * @return array (of objects) question objects.
889      */
890     protected function readquestions($lines) {
891         // We just need it as one big string
892         $text = implode($lines, ' ');
893         unset($lines);
895         // This converts xml to big nasty data structure
896         // the 0 means keep white space as it is (important for markdown format)
897         try {
898             $xml = xmlize($text, 0, 'UTF-8', true);
899         } catch (xml_format_exception $e) {
900             $this->error($e->getMessage(), '');
901             return false;
902         }
903         // Set up array to hold all our questions
904         $questions = array();
906         // Iterate through questions
907         foreach ($xml['quiz']['#']['question'] as $question) {
908             $questiontype = $question['@']['type'];
910             if ($questiontype == 'multichoice') {
911                 $qo = $this->import_multichoice($question);
912             } else if ($questiontype == 'truefalse') {
913                 $qo = $this->import_truefalse($question);
914             } else if ($questiontype == 'shortanswer') {
915                 $qo = $this->import_shortanswer($question);
916             } else if ($questiontype == 'numerical') {
917                 $qo = $this->import_numerical($question);
918             } else if ($questiontype == 'description') {
919                 $qo = $this->import_description($question);
920             } else if ($questiontype == 'matching' || $questiontype == 'match') {
921                 $qo = $this->import_match($question);
922             } else if ($questiontype == 'cloze' || $questiontype == 'multianswer') {
923                 $qo = $this->import_multianswer($question);
924             } else if ($questiontype == 'essay') {
925                 $qo = $this->import_essay($question);
926             } else if ($questiontype == 'calculated') {
927                 $qo = $this->import_calculated($question);
928             } else if ($questiontype == 'calculatedsimple') {
929                 $qo = $this->import_calculated($question);
930                 $qo->qtype = 'calculatedsimple';
931             } else if ($questiontype == 'calculatedmulti') {
932                 $qo = $this->import_calculated($question);
933                 $qo->qtype = 'calculatedmulti';
934             } else if ($questiontype == 'category') {
935                 $qo = $this->import_category($question);
937             } else {
938                 // Not a type we handle ourselves. See if the question type wants
939                 // to handle it.
940                 if (!$qo = $this->try_importing_using_qtypes(
941                         $question, null, null, $questiontype)) {
942                     $this->error(get_string('xmltypeunsupported', 'qformat_xml', $questiontype));
943                     $qo = null;
944                 }
945             }
947             // Stick the result in the $questions array
948             if ($qo) {
949                 $questions[] = $qo;
950             }
951         }
952         return $questions;
953     }
955     // EXPORT FUNCTIONS START HERE
957     public function export_file_extension() {
958         return '.xml';
959     }
961     /**
962      * Turn the internal question type name into a human readable form.
963      * (In the past, the code used to use integers internally. Now, it uses
964      * strings, so there is less need for this, but to maintain
965      * backwards-compatibility we change two of the type names.)
966      * @param string $qtype question type plugin name.
967      * @return string $qtype string to use in the file.
968      */
969     protected function get_qtype($qtype) {
970         switch($qtype) {
971             case 'match':
972                 return 'matching';
973             case 'multianswer':
974                 return 'cloze';
975             default:
976                 return $qtype;
977         }
978     }
980     /**
981      * Convert internal Moodle text format code into
982      * human readable form
983      * @param int id internal code
984      * @return string format text
985      */
986     public function get_format($id) {
987         switch($id) {
988             case FORMAT_MOODLE:
989                 return 'moodle_auto_format';
990             case FORMAT_HTML:
991                 return 'html';
992             case FORMAT_PLAIN:
993                 return 'plain_text';
994             case FORMAT_WIKI:
995                 return 'wiki_like';
996             case FORMAT_MARKDOWN:
997                 return 'markdown';
998             default:
999                 return 'unknown';
1000         }
1001     }
1003     /**
1004      * Convert internal single question code into
1005      * human readable form
1006      * @param int id single question code
1007      * @return string single question string
1008      */
1009     public function get_single($id) {
1010         switch($id) {
1011             case 0:
1012                 return 'false';
1013             case 1:
1014                 return 'true';
1015             default:
1016                 return 'unknown';
1017         }
1018     }
1020     /**
1021      * Take a string, and wrap it in a CDATA secion, if that is required to make
1022      * the output XML valid.
1023      * @param string $string a string
1024      * @return string the string, wrapped in CDATA if necessary.
1025      */
1026     public function xml_escape($string) {
1027         if (!empty($string) && htmlspecialchars($string) != $string) {
1028             return "<![CDATA[{$string}]]>";
1029         } else {
1030             return $string;
1031         }
1032     }
1034     /**
1035      * Generates <text></text> tags, processing raw text therein
1036      * @param string $raw the content to output.
1037      * @param int $indent the current indent level.
1038      * @param bool $short stick it on one line.
1039      * @return string formatted text.
1040      */
1041     public function writetext($raw, $indent = 0, $short = true) {
1042         $indent = str_repeat('  ', $indent);
1043         $raw = $this->xml_escape($raw);
1045         if ($short) {
1046             $xml = "$indent<text>$raw</text>\n";
1047         } else {
1048             $xml = "$indent<text>\n$raw\n$indent</text>\n";
1049         }
1051         return $xml;
1052     }
1054     protected function presave_process($content) {
1055         // Override to allow us to add xml headers and footers
1056         return '<?xml version="1.0" encoding="UTF-8"?>
1057 <quiz>
1058 ' . $content . '</quiz>';
1059     }
1061     /**
1062      * Turns question into an xml segment
1063      * @param object $question the question data.
1064      * @return string xml segment
1065      */
1066     public function writequestion($question) {
1067         global $CFG, $OUTPUT;
1069         $fs = get_file_storage();
1070         $contextid = $question->contextid;
1071         // Get files used by the questiontext.
1072         $question->questiontextfiles = $fs->get_area_files(
1073                 $contextid, 'question', 'questiontext', $question->id);
1074         // Get files used by the generalfeedback.
1075         $question->generalfeedbackfiles = $fs->get_area_files(
1076                 $contextid, 'question', 'generalfeedback', $question->id);
1077         if (!empty($question->options->answers)) {
1078             foreach ($question->options->answers as $answer) {
1079                 $answer->answerfiles = $fs->get_area_files(
1080                         $contextid, 'question', 'answer', $answer->id);
1081                 $answer->feedbackfiles = $fs->get_area_files(
1082                         $contextid, 'question', 'answerfeedback', $answer->id);
1083             }
1084         }
1086         $expout = '';
1088         // Add a comment linking this to the original question id.
1089         $expout .= "<!-- question: $question->id  -->\n";
1091         // Check question type
1092         $questiontype = $this->get_qtype($question->qtype);
1094         // Categories are a special case.
1095         if ($question->qtype == 'category') {
1096             $categorypath = $this->writetext($question->category);
1097             $expout .= "  <question type=\"category\">\n";
1098             $expout .= "    <category>\n";
1099             $expout .= "        $categorypath\n";
1100             $expout .= "    </category>\n";
1101             $expout .= "  </question>\n";
1102             return $expout;
1103         }
1105         // Now we know we are are handing a real question.
1106         // Output the generic information.
1107         $expout .= "  <question type=\"$questiontype\">\n";
1108         $expout .= "    <name>\n";
1109         $expout .= $this->writetext($question->name, 3);
1110         $expout .= "    </name>\n";
1111         $expout .= "    <questiontext {$this->format($question->questiontextformat)}>\n";
1112         $expout .= $this->writetext($question->questiontext, 3);
1113         $expout .= $this->writefiles($question->questiontextfiles);
1114         $expout .= "    </questiontext>\n";
1115         $expout .= "    <generalfeedback {$this->format($question->generalfeedbackformat)}>\n";
1116         $expout .= $this->writetext($question->generalfeedback, 3);
1117         $expout .= $this->writefiles($question->generalfeedbackfiles);
1118         $expout .= "    </generalfeedback>\n";
1119         if ($question->qtype != 'multianswer') {
1120             $expout .= "    <defaultgrade>{$question->defaultmark}</defaultgrade>\n";
1121         }
1122         $expout .= "    <penalty>{$question->penalty}</penalty>\n";
1123         $expout .= "    <hidden>{$question->hidden}</hidden>\n";
1125         // The rest of the output depends on question type.
1126         switch($question->qtype) {
1127             case 'category':
1128                 // not a qtype really - dummy used for category switching
1129                 break;
1131             case 'truefalse':
1132                 $trueanswer = $question->options->answers[$question->options->trueanswer];
1133                 $trueanswer->answer = 'true';
1134                 $expout .= $this->write_answer($trueanswer);
1136                 $falseanswer = $question->options->answers[$question->options->falseanswer];
1137                 $falseanswer->answer = 'false';
1138                 $expout .= $this->write_answer($falseanswer);
1139                 break;
1141             case 'multichoice':
1142                 $expout .= "    <single>" . $this->get_single($question->options->single) .
1143                         "</single>\n";
1144                 $expout .= "    <shuffleanswers>" .
1145                         $this->get_single($question->options->shuffleanswers) .
1146                         "</shuffleanswers>\n";
1147                 $expout .= "    <answernumbering>" . $question->options->answernumbering .
1148                         "</answernumbering>\n";
1149                 $expout .= $this->write_combined_feedback($question->options, $question->id, $question->contextid);
1150                 $expout .= $this->write_answers($question->options->answers);
1151                 break;
1153             case 'shortanswer':
1154                 $expout .= "    <usecase>{$question->options->usecase}</usecase>\n";
1155                 $expout .= $this->write_answers($question->options->answers);
1156                 break;
1158             case 'numerical':
1159                 foreach ($question->options->answers as $answer) {
1160                     $expout .= $this->write_answer($answer,
1161                             "      <tolerance>$answer->tolerance</tolerance>\n");
1162                 }
1164                 $units = $question->options->units;
1165                 if (count($units)) {
1166                     $expout .= "<units>\n";
1167                     foreach ($units as $unit) {
1168                         $expout .= "  <unit>\n";
1169                         $expout .= "    <multiplier>{$unit->multiplier}</multiplier>\n";
1170                         $expout .= "    <unit_name>{$unit->unit}</unit_name>\n";
1171                         $expout .= "  </unit>\n";
1172                     }
1173                     $expout .= "</units>\n";
1174                 }
1175                 if (isset($question->options->unitgradingtype)) {
1176                     $expout .= "    <unitgradingtype>" . $question->options->unitgradingtype .
1177                             "</unitgradingtype>\n";
1178                 }
1179                 if (isset($question->options->unitpenalty)) {
1180                     $expout .= "    <unitpenalty>{$question->options->unitpenalty}</unitpenalty>\n";
1181                 }
1182                 if (isset($question->options->showunits)) {
1183                     $expout .= "    <showunits>{$question->options->showunits}</showunits>\n";
1184                 }
1185                 if (isset($question->options->unitsleft)) {
1186                     $expout .= "    <unitsleft>{$question->options->unitsleft}</unitsleft>\n";
1187                 }
1188                 if (!empty($question->options->instructionsformat)) {
1189                     $files = $fs->get_area_files($contextid, 'qtype_numerical',
1190                             'instruction', $question->id);
1191                     $expout .= "    <instructions " .
1192                             $this->format($question->options->instructionsformat) . ">\n";
1193                     $expout .= $this->writetext($question->options->instructions, 3);
1194                     $expout .= $this->writefiles($files);
1195                     $expout .= "    </instructions>\n";
1196                 }
1197                 break;
1199             case 'match':
1200                 $expout .= "    <shuffleanswers>" .
1201                         $this->get_single($question->options->shuffleanswers) .
1202                         "</shuffleanswers>\n";
1203                 $expout .= $this->write_combined_feedback($question->options, $question->id, $question->contextid);
1204                 foreach ($question->options->subquestions as $subquestion) {
1205                     $files = $fs->get_area_files($contextid, 'qtype_match',
1206                             'subquestion', $subquestion->id);
1207                     $expout .= "    <subquestion " .
1208                             $this->format($subquestion->questiontextformat) . ">\n";
1209                     $expout .= $this->writetext($subquestion->questiontext, 3);
1210                     $expout .= $this->writefiles($files);
1211                     $expout .= "      <answer>\n";
1212                     $expout .= $this->writetext($subquestion->answertext, 4);
1213                     $expout .= "      </answer>\n";
1214                     $expout .= "    </subquestion>\n";
1215                 }
1216                 break;
1218             case 'description':
1219                 // Nothing else to do.
1220                 break;
1222             case 'multianswer':
1223                 foreach ($question->options->questions as $index => $subq) {
1224                     $expout = preg_replace('~{#' . $index . '}~', $subq->questiontext, $expout);
1225                 }
1226                 break;
1228             case 'essay':
1229                 $expout .= "    <responseformat>" . $question->options->responseformat .
1230                         "</responseformat>\n";
1231                 $expout .= "    <responsefieldlines>" . $question->options->responsefieldlines .
1232                         "</responsefieldlines>\n";
1233                 $expout .= "    <attachments>" . $question->options->attachments .
1234                         "</attachments>\n";
1235                 $expout .= "    <graderinfo " .
1236                         $this->format($question->options->graderinfoformat) . ">\n";
1237                 $expout .= $this->writetext($question->options->graderinfo, 3);
1238                 $expout .= $this->writefiles($fs->get_area_files($contextid, 'qtype_essay',
1239                         'graderinfo', $question->id));
1240                 $expout .= "    </graderinfo>\n";
1241                 break;
1243             case 'calculated':
1244             case 'calculatedsimple':
1245             case 'calculatedmulti':
1246                 $expout .= "    <synchronize>{$question->options->synchronize}</synchronize>\n";
1247                 $expout .= "    <single>{$question->options->single}</single>\n";
1248                 $expout .= "    <answernumbering>" . $question->options->answernumbering .
1249                         "</answernumbering>\n";
1250                 $expout .= "    <shuffleanswers>" . $question->options->shuffleanswers .
1251                         "</shuffleanswers>\n";
1253                 $component = 'qtype_' . $question->qtype;
1254                 $files = $fs->get_area_files($contextid, $component,
1255                         'correctfeedback', $question->id);
1256                 $expout .= "    <correctfeedback>\n";
1257                 $expout .= $this->writetext($question->options->correctfeedback, 3);
1258                 $expout .= $this->writefiles($files);
1259                 $expout .= "    </correctfeedback>\n";
1261                 $files = $fs->get_area_files($contextid, $component,
1262                         'partiallycorrectfeedback', $question->id);
1263                 $expout .= "    <partiallycorrectfeedback>\n";
1264                 $expout .= $this->writetext($question->options->partiallycorrectfeedback, 3);
1265                 $expout .= $this->writefiles($files);
1266                 $expout .= "    </partiallycorrectfeedback>\n";
1268                 $files = $fs->get_area_files($contextid, $component,
1269                         'incorrectfeedback', $question->id);
1270                 $expout .= "    <incorrectfeedback>\n";
1271                 $expout .= $this->writetext($question->options->incorrectfeedback, 3);
1272                 $expout .= $this->writefiles($files);
1273                 $expout .= "    </incorrectfeedback>\n";
1275                 foreach ($question->options->answers as $answer) {
1276                     $percent = 100 * $answer->fraction;
1277                     $expout .= "<answer fraction=\"$percent\">\n";
1278                     // "<text/>" tags are an added feature, old files won't have them
1279                     $expout .= "    <text>{$answer->answer}</text>\n";
1280                     $expout .= "    <tolerance>{$answer->tolerance}</tolerance>\n";
1281                     $expout .= "    <tolerancetype>{$answer->tolerancetype}</tolerancetype>\n";
1282                     $expout .= "    <correctanswerformat>" .
1283                             $answer->correctanswerformat . "</correctanswerformat>\n";
1284                     $expout .= "    <correctanswerlength>" .
1285                             $answer->correctanswerlength . "</correctanswerlength>\n";
1286                     $expout .= "    <feedback {$this->format($answer->feedbackformat)}>\n";
1287                     $files = $fs->get_area_files($contextid, $component,
1288                             'instruction', $question->id);
1289                     $expout .= $this->writetext($answer->feedback);
1290                     $expout .= $this->writefiles($answer->feedbackfiles);
1291                     $expout .= "    </feedback>\n";
1292                     $expout .= "</answer>\n";
1293                 }
1294                 if (isset($question->options->unitgradingtype)) {
1295                     $expout .= "    <unitgradingtype>" .
1296                             $question->options->unitgradingtype . "</unitgradingtype>\n";
1297                 }
1298                 if (isset($question->options->unitpenalty)) {
1299                     $expout .= "    <unitpenalty>" .
1300                             $question->options->unitpenalty . "</unitpenalty>\n";
1301                 }
1302                 if (isset($question->options->showunits)) {
1303                     $expout .= "    <showunits>{$question->options->showunits}</showunits>\n";
1304                 }
1305                 if (isset($question->options->unitsleft)) {
1306                     $expout .= "    <unitsleft>{$question->options->unitsleft}</unitsleft>\n";
1307                 }
1309                 if (isset($question->options->instructionsformat)) {
1310                     $files = $fs->get_area_files($contextid, $component,
1311                             'instruction', $question->id);
1312                     $expout .= "    <instructions " .
1313                             $this->format($question->options->instructionsformat) . ">\n";
1314                     $expout .= $this->writetext($question->options->instructions, 3);
1315                     $expout .= $this->writefiles($files);
1316                     $expout .= "    </instructions>\n";
1317                 }
1319                 if (isset($question->options->units)) {
1320                     $units = $question->options->units;
1321                     if (count($units)) {
1322                         $expout .= "<units>\n";
1323                         foreach ($units as $unit) {
1324                             $expout .= "  <unit>\n";
1325                             $expout .= "    <multiplier>{$unit->multiplier}</multiplier>\n";
1326                             $expout .= "    <unit_name>{$unit->unit}</unit_name>\n";
1327                             $expout .= "  </unit>\n";
1328                         }
1329                         $expout .= "</units>\n";
1330                     }
1331                 }
1333                 // The tag $question->export_process has been set so we get all the
1334                 // data items in the database from the function
1335                 // qtype_calculated::get_question_options calculatedsimple defaults
1336                 // to calculated
1337                 if (isset($question->options->datasets) && count($question->options->datasets)) {
1338                     $expout .= "<dataset_definitions>\n";
1339                     foreach ($question->options->datasets as $def) {
1340                         $expout .= "<dataset_definition>\n";
1341                         $expout .= "    <status>".$this->writetext($def->status)."</status>\n";
1342                         $expout .= "    <name>".$this->writetext($def->name)."</name>\n";
1343                         if ($question->qtype == CALCULATED) {
1344                             $expout .= "    <type>calculated</type>\n";
1345                         } else {
1346                             $expout .= "    <type>calculatedsimple</type>\n";
1347                         }
1348                         $expout .= "    <distribution>" . $this->writetext($def->distribution) .
1349                                 "</distribution>\n";
1350                         $expout .= "    <minimum>" . $this->writetext($def->minimum) .
1351                                 "</minimum>\n";
1352                         $expout .= "    <maximum>" . $this->writetext($def->maximum) .
1353                                 "</maximum>\n";
1354                         $expout .= "    <decimals>" . $this->writetext($def->decimals) .
1355                                 "</decimals>\n";
1356                         $expout .= "    <itemcount>$def->itemcount</itemcount>\n";
1357                         if ($def->itemcount > 0) {
1358                             $expout .= "    <dataset_items>\n";
1359                             foreach ($def->items as $item) {
1360                                   $expout .= "        <dataset_item>\n";
1361                                   $expout .= "           <number>".$item->itemnumber."</number>\n";
1362                                   $expout .= "           <value>".$item->value."</value>\n";
1363                                   $expout .= "        </dataset_item>\n";
1364                             }
1365                             $expout .= "    </dataset_items>\n";
1366                             $expout .= "    <number_of_items>" . $def->number_of_items .
1367                                     "</number_of_items>\n";
1368                         }
1369                         $expout .= "</dataset_definition>\n";
1370                     }
1371                     $expout .= "</dataset_definitions>\n";
1372                 }
1373                 break;
1375             default:
1376                 // try support by optional plugin
1377                 if (!$data = $this->try_exporting_using_qtypes($question->qtype, $question)) {
1378                     notify(get_string('unsupportedexport', 'qformat_xml', $question->qtype));
1379                 }
1380                 $expout .= $data;
1381         }
1383         // Output any hints.
1384         $expout .= $this->write_hints($question);
1386         // Write the question tags.
1387         if (!empty($CFG->usetags)) {
1388             require_once($CFG->dirroot.'/tag/lib.php');
1389             $tags = tag_get_tags_array('question', $question->id);
1390             if (!empty($tags)) {
1391                 $expout .= "    <tags>\n";
1392                 foreach ($tags as $tag) {
1393                     $expout .= "      <tag>" . $this->writetext($tag, 0, true) . "</tag>\n";
1394                 }
1395                 $expout .= "    </tags>\n";
1396             }
1397         }
1399         // close the question tag
1400         $expout .= "  </question>\n";
1402         return $expout;
1403     }
1405     public function write_answers($answers) {
1406         if (empty($answers)) {
1407             return;
1408         }
1409         $output = '';
1410         foreach ($answers as $answer) {
1411             $output .= $this->write_answer($answer);
1412         }
1413         return $output;
1414     }
1416     public function write_answer($answer, $extra = '') {
1417         $percent = $answer->fraction * 100;
1418         $output = '';
1419         $output .= "    <answer fraction=\"$percent\" {$this->format($answer->answerformat)}>\n";
1420         $output .= $this->writetext($answer->answer, 3);
1421         $output .= $this->writefiles($answer->answerfiles);
1422         $output .= "      <feedback {$this->format($answer->feedbackformat)}>\n";
1423         $output .= $this->writetext($answer->feedback, 4);
1424         $output .= $this->writefiles($answer->feedbackfiles);
1425         $output .= "      </feedback>\n";
1426         $output .= $extra;
1427         $output .= "    </answer>\n";
1428         return $output;
1429     }
1431     /**
1432      * Write out the hints.
1433      * @param object $question the question definition data.
1434      * @return string XML to output.
1435      */
1436     public function write_hints($question) {
1437         if (empty($question->hints)) {
1438             return '';
1439         }
1441         $output = '';
1442         foreach ($question->hints as $hint) {
1443             $output .= $this->write_hint($hint, $question->contextid);
1444         }
1445         return $output;
1446     }
1448     /**
1449      * @param unknown_type $format a FORMAT_... constant.
1450      * @return string the attribute to add to an XML tag.
1451      */
1452     protected function format($format) {
1453         return 'format="' . $this->get_format($format) . '"';
1454     }
1456     public function write_hint($hint, $contextid) {
1457         $fs = get_file_storage();
1458         $files = $fs->get_area_files($contextid, 'question', 'hint', $hint->id);
1460         $output = '';
1461         $output .= "    <hint {$this->format($hint->hintformat)}>\n";
1462         $output .= '      ' . $this->writetext($hint->hint);
1464         if (!empty($hint->shownumcorrect)) {
1465             $output .= "      <shownumcorrect/>\n";
1466         }
1467         if (!empty($hint->clearwrong)) {
1468             $output .= "      <clearwrong/>\n";
1469         }
1471         if (!empty($hint->options)) {
1472             $output .= '      <options>' . $this->xml_escape($hint->options) . "</options>\n";
1473         }
1474         $output .= $this->writefiles($files);
1475         $output .= "    </hint>\n";
1476         return $output;
1477     }
1479     /**
1480      * Output the combined feedback fields.
1481      * @param object $questionoptions the question definition data.
1482      * @param int $questionid the question id.
1483      * @param int $contextid the question context id.
1484      * @return string XML to output.
1485      */
1486     public function write_combined_feedback($questionoptions, $questionid, $contextid) {
1487         $fs = get_file_storage();
1488         $output = '';
1490         $fields = array('correctfeedback', 'partiallycorrectfeedback', 'incorrectfeedback');
1491         foreach ($fields as $field) {
1492             $formatfield = $field . 'format';
1493             $files = $fs->get_area_files($contextid, 'question', $field, $questionid);
1495             $output .= "    <{$field} {$this->format($questionoptions->$formatfield)}>\n";
1496             $output .= '      ' . $this->writetext($questionoptions->$field);
1497             $output .= $this->writefiles($files);
1498             $output .= "    </{$field}>\n";
1499         }
1501         if (!empty($questionoptions->shownumcorrect)) {
1502             $output .= "    <shownumcorrect/>\n";
1503         }
1504         return $output;
1505     }