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