0ccdbce99e9c7d81ddd2ae2d93b1a40ddf302c81
[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  * The core question types.
32  *
33  * These used to be in lib/questionlib.php, but are being deprecated. Copying
34  * them here to keep the import/export code working for now (there are 135
35  * references to these constants which I don't want to try to fix at the moment.)
36  */
37 if (!defined('SHORTANSWER')) {
38     define("SHORTANSWER",   "shortanswer");
39     define("TRUEFALSE",     "truefalse");
40     define("MULTICHOICE",   "multichoice");
41     define("RANDOM",        "random");
42     define("MATCH",         "match");
43     define("RANDOMSAMATCH", "randomsamatch");
44     define("DESCRIPTION",   "description");
45     define("NUMERICAL",     "numerical");
46     define("MULTIANSWER",   "multianswer");
47     define("CALCULATED",    "calculated");
48     define("ESSAY",         "essay");
49 }
50 /**#@-*/
53 /**
54  * Base class for question import and export formats.
55  *
56  * @copyright  1999 onwards Martin Dougiamas {@link http://moodle.com}
57  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
58  */
59 class qformat_default {
61     public $displayerrors = true;
62     public $category = null;
63     public $questions = array();
64     public $course = null;
65     public $filename = '';
66     public $realfilename = '';
67     public $matchgrades = 'error';
68     public $catfromfile = 0;
69     public $contextfromfile = 0;
70     public $cattofile = 0;
71     public $contexttofile = 0;
72     public $questionids = array();
73     public $importerrors = 0;
74     public $stoponerror = true;
75     public $translator = null;
76     public $canaccessbackupdata = true;
78     protected $importcontext = null;
80     // functions to indicate import/export functionality
81     // override to return true if implemented
83     /** @return bool whether this plugin provides import functionality. */
84     public function provide_import() {
85         return false;
86     }
88     /** @return bool whether this plugin provides export functionality. */
89     public function provide_export() {
90         return false;
91     }
93     /** The string mime-type of the files that this plugin reads or writes. */
94     public function mime_type() {
95         return mimeinfo('type', $this->export_file_extension());
96     }
98     /**
99      * @return string the file extension (including .) that is normally used for
100      * files handled by this plugin.
101      */
102     public function export_file_extension() {
103         return '.txt';
104     }
106     /**
107      * Check if the given file is capable of being imported by this plugin.
108      *
109      * Note that expensive or detailed integrity checks on the file should
110      * not be performed by this method. Simple file type or magic-number tests
111      * would be suitable.
112      *
113      * @param stored_file $file the file to check
114      * @return bool whether this plugin can import the file
115      */
116     public function can_import_file($file) {
117         return ($file->get_mimetype() == $this->mime_type());
118     }
120     // Accessor methods
122     /**
123      * set the category
124      * @param object category the category object
125      */
126     public function setCategory($category) {
127         if (count($this->questions)) {
128             debugging('You shouldn\'t call setCategory after setQuestions');
129         }
130         $this->category = $category;
131         $this->importcontext = get_context_instance_by_id($this->category->contextid);
132     }
134     /**
135      * Set the specific questions to export. Should not include questions with
136      * parents (sub questions of cloze question type).
137      * Only used for question export.
138      * @param array of question objects
139      */
140     public function setQuestions($questions) {
141         if ($this->category !== null) {
142             debugging('You shouldn\'t call setQuestions after setCategory');
143         }
144         $this->questions = $questions;
145     }
147     /**
148      * set the course class variable
149      * @param course object Moodle course variable
150      */
151     public function setCourse($course) {
152         $this->course = $course;
153     }
155     /**
156      * set an array of contexts.
157      * @param array $contexts Moodle course variable
158      */
159     public function setContexts($contexts) {
160         $this->contexts = $contexts;
161         $this->translator = new context_to_string_translator($this->contexts);
162     }
164     /**
165      * set the filename
166      * @param string filename name of file to import/export
167      */
168     public function setFilename($filename) {
169         $this->filename = $filename;
170     }
172     /**
173      * set the "real" filename
174      * (this is what the user typed, regardless of wha happened next)
175      * @param string realfilename name of file as typed by user
176      */
177     public function setRealfilename($realfilename) {
178         $this->realfilename = $realfilename;
179     }
181     /**
182      * set matchgrades
183      * @param string matchgrades error or nearest for grades
184      */
185     public function setMatchgrades($matchgrades) {
186         $this->matchgrades = $matchgrades;
187     }
189     /**
190      * set catfromfile
191      * @param bool catfromfile allow categories embedded in import file
192      */
193     public function setCatfromfile($catfromfile) {
194         $this->catfromfile = $catfromfile;
195     }
197     /**
198      * set contextfromfile
199      * @param bool $contextfromfile allow contexts embedded in import file
200      */
201     public function setContextfromfile($contextfromfile) {
202         $this->contextfromfile = $contextfromfile;
203     }
205     /**
206      * set cattofile
207      * @param bool cattofile exports categories within export file
208      */
209     public function setCattofile($cattofile) {
210         $this->cattofile = $cattofile;
211     }
213     /**
214      * set contexttofile
215      * @param bool cattofile exports categories within export file
216      */
217     public function setContexttofile($contexttofile) {
218         $this->contexttofile = $contexttofile;
219     }
221     /**
222      * set stoponerror
223      * @param bool stoponerror stops database write if any errors reported
224      */
225     public function setStoponerror($stoponerror) {
226         $this->stoponerror = $stoponerror;
227     }
229     /**
230      * @param bool $canaccess Whether the current use can access the backup data folder. Determines
231      * where export files are saved.
232      */
233     public function set_can_access_backupdata($canaccess) {
234         $this->canaccessbackupdata = $canaccess;
235     }
237     /***********************
238      * IMPORTING FUNCTIONS
239      ***********************/
241     /**
242      * Handle parsing error
243      */
244     protected function error($message, $text='', $questionname='') {
245         $importerrorquestion = get_string('importerrorquestion', 'question');
247         echo "<div class=\"importerror\">\n";
248         echo "<strong>$importerrorquestion $questionname</strong>";
249         if (!empty($text)) {
250             $text = s($text);
251             echo "<blockquote>$text</blockquote>\n";
252         }
253         echo "<strong>$message</strong>\n";
254         echo "</div>";
256          $this->importerrors++;
257     }
259     /**
260      * Import for questiontype plugins
261      * Do not override.
262      * @param data mixed The segment of data containing the question
263      * @param question object processed (so far) by standard import code if appropriate
264      * @param extra mixed any additional format specific data that may be passed by the format
265      * @param qtypehint hint about a question type from format
266      * @return object question object suitable for save_options() or false if cannot handle
267      */
268     public function try_importing_using_qtypes($data, $question = null, $extra = null,
269             $qtypehint = '') {
271         // work out what format we are using
272         $formatname = substr(get_class($this), strlen('qformat_'));
273         $methodname = "import_from_$formatname";
275         //first try importing using a hint from format
276         if (!empty($qtypehint)) {
277             $qtype = question_bank::get_qtype($qtypehint, false);
278             if (is_object($qtype) && method_exists($qtype, $methodname)) {
279                 $question = $qtype->$methodname($data, $question, $this, $extra);
280                 if ($question) {
281                     return $question;
282                 }
283             }
284         }
286         // loop through installed questiontypes checking for
287         // function to handle this question
288         foreach (question_bank::get_all_qtypes() as $qtype) {
289             if (method_exists($qtype, $methodname)) {
290                 if ($question = $qtype->$methodname($data, $question, $this, $extra)) {
291                     return $question;
292                 }
293             }
294         }
295         return false;
296     }
298     /**
299      * Perform any required pre-processing
300      * @return bool success
301      */
302     public function importpreprocess() {
303         return true;
304     }
306     /**
307      * Process the file
308      * This method should not normally be overidden
309      * @param object $category
310      * @return bool success
311      */
312     public function importprocess($category) {
313         global $USER, $CFG, $DB, $OUTPUT;
315         // reset the timer in case file upload was slow
316         set_time_limit(0);
318         // STAGE 1: Parse the file
319         echo $OUTPUT->notification(get_string('parsingquestions', 'question'), 'notifysuccess');
321         if (! $lines = $this->readdata($this->filename)) {
322             echo $OUTPUT->notification(get_string('cannotread', 'question'));
323             return false;
324         }
326         if (!$questions = $this->readquestions($lines)) {   // Extract all the questions
327             echo $OUTPUT->notification(get_string('noquestionsinfile', 'question'));
328             return false;
329         }
331         // STAGE 2: Write data to database
332         echo $OUTPUT->notification(get_string('importingquestions', 'question',
333                 $this->count_questions($questions)), 'notifysuccess');
335         // check for errors before we continue
336         if ($this->stoponerror and ($this->importerrors>0)) {
337             echo $OUTPUT->notification(get_string('importparseerror', 'question'));
338             return true;
339         }
341         // get list of valid answer grades
342         $gradeoptionsfull = question_bank::fraction_options_full();
344         // check answer grades are valid
345         // (now need to do this here because of 'stop on error': MDL-10689)
346         $gradeerrors = 0;
347         $goodquestions = array();
348         foreach ($questions as $question) {
349             if (!empty($question->fraction) and (is_array($question->fraction))) {
350                 $fractions = $question->fraction;
351                 $answersvalid = true; // in case they are!
352                 foreach ($fractions as $key => $fraction) {
353                     $newfraction = match_grade_options($gradeoptionsfull, $fraction,
354                             $this->matchgrades);
355                     if ($newfraction === false) {
356                         $answersvalid = false;
357                     } else {
358                         $fractions[$key] = $newfraction;
359                     }
360                 }
361                 if (!$answersvalid) {
362                     echo $OUTPUT->notification(get_string('invalidgrade', 'question'));
363                     ++$gradeerrors;
364                     continue;
365                 } else {
366                     $question->fraction = $fractions;
367                 }
368             }
369             $goodquestions[] = $question;
370         }
371         $questions = $goodquestions;
373         // check for errors before we continue
374         if ($this->stoponerror && $gradeerrors > 0) {
375             return false;
376         }
378         // count number of questions processed
379         $count = 0;
381         foreach ($questions as $question) {   // Process and store each question
383             // reset the php timeout
384             set_time_limit(0);
386             // check for category modifiers
387             if ($question->qtype == 'category') {
388                 if ($this->catfromfile) {
389                     // find/create category object
390                     $catpath = $question->category;
391                     $newcategory = $this->create_category_path($catpath);
392                     if (!empty($newcategory)) {
393                         $this->category = $newcategory;
394                     }
395                 }
396                 continue;
397             }
398             $question->context = $this->importcontext;
400             $count++;
402             echo "<hr /><p><b>$count</b>. ".$this->format_question_text($question)."</p>";
404             $question->category = $this->category->id;
405             $question->stamp = make_unique_id_code();  // Set the unique code (not to be changed)
407             $question->createdby = $USER->id;
408             $question->timecreated = time();
409             $question->modifiedby = $USER->id;
410             $question->timemodified = time();
412             $question->id = $DB->insert_record('question', $question);
413             if (isset($question->questiontextfiles)) {
414                 foreach ($question->questiontextfiles as $file) {
415                     question_bank::get_qtype($question->qtype)->import_file(
416                             $this->importcontext, 'question', 'questiontext', $question->id, $file);
417                 }
418             }
419             if (isset($question->generalfeedbackfiles)) {
420                 foreach ($question->generalfeedbackfiles as $file) {
421                     question_bank::get_qtype($question->qtype)->import_file(
422                             $this->importcontext, 'question', 'generalfeedback', $question->id, $file);
423                 }
424             }
426             $this->questionids[] = $question->id;
428             // Now to save all the answers and type-specific options
430             $result = question_bank::get_qtype($question->qtype)->save_question_options($question);
432             if (!empty($CFG->usetags) && isset($question->tags)) {
433                 require_once($CFG->dirroot . '/tag/lib.php');
434                 tag_set('question', $question->id, $question->tags);
435             }
437             if (!empty($result->error)) {
438                 echo $OUTPUT->notification($result->error);
439                 return false;
440             }
442             if (!empty($result->notice)) {
443                 echo $OUTPUT->notification($result->notice);
444                 return true;
445             }
447             // Give the question a unique version stamp determined by question_hash()
448             $DB->set_field('question', 'version', question_hash($question),
449                     array('id' => $question->id));
450         }
451         return true;
452     }
454     /**
455      * Count all non-category questions in the questions array.
456      *
457      * @param array questions An array of question objects.
458      * @return int The count.
459      *
460      */
461     protected function count_questions($questions) {
462         $count = 0;
463         if (!is_array($questions)) {
464             return $count;
465         }
466         foreach ($questions as $question) {
467             if (!is_object($question) || !isset($question->qtype) ||
468                     ($question->qtype == 'category')) {
469                 continue;
470             }
471             $count++;
472         }
473         return $count;
474     }
476     /**
477      * find and/or create the category described by a delimited list
478      * e.g. $course$/tom/dick/harry or tom/dick/harry
479      *
480      * removes any context string no matter whether $getcontext is set
481      * but if $getcontext is set then ignore the context and use selected category context.
482      *
483      * @param string catpath delimited category path
484      * @param int courseid course to search for categories
485      * @return mixed category object or null if fails
486      */
487     protected function create_category_path($catpath) {
488         global $DB;
489         $catnames = $this->split_category_path($catpath);
490         $parent = 0;
491         $category = null;
493         // check for context id in path, it might not be there in pre 1.9 exports
494         $matchcount = preg_match('/^\$([a-z]+)\$$/', $catnames[0], $matches);
495         if ($matchcount == 1) {
496             $contextid = $this->translator->string_to_context($matches[1]);
497             array_shift($catnames);
498         } else {
499             $contextid = false;
500         }
502         if ($this->contextfromfile && $contextid !== false) {
503             $context = get_context_instance_by_id($contextid);
504             require_capability('moodle/question:add', $context);
505         } else {
506             $context = get_context_instance_by_id($this->category->contextid);
507         }
508         $this->importcontext = $context;
510         // Now create any categories that need to be created.
511         foreach ($catnames as $catname) {
512             if ($category = $DB->get_record('question_categories',
513                     array('name' => $catname, 'contextid' => $context->id, 'parent' => $parent))) {
514                 $parent = $category->id;
515             } else {
516                 require_capability('moodle/question:managecategory', $context);
517                 // create the new category
518                 $category = new stdClass();
519                 $category->contextid = $context->id;
520                 $category->name = $catname;
521                 $category->info = '';
522                 $category->parent = $parent;
523                 $category->sortorder = 999;
524                 $category->stamp = make_unique_id_code();
525                 $id = $DB->insert_record('question_categories', $category);
526                 $category->id = $id;
527                 $parent = $id;
528             }
529         }
530         return $category;
531     }
533     /**
534      * Return complete file within an array, one item per line
535      * @param string filename name of file
536      * @return mixed contents array or false on failure
537      */
538     protected function readdata($filename) {
539         if (is_readable($filename)) {
540             $filearray = file($filename);
542             // If the first line of the file starts with a UTF-8 BOM, remove it.
543             $filearray[0] = textlib::trim_utf8_bom($filearray[0]);
545             // Check for Macintosh OS line returns (ie file on one line), and fix.
546             if (preg_match("~\r~", $filearray[0]) AND !preg_match("~\n~", $filearray[0])) {
547                 return explode("\r", $filearray[0]);
548             } else {
549                 return $filearray;
550             }
551         }
552         return false;
553     }
555     /**
556      * Parses an array of lines into an array of questions,
557      * where each item is a question object as defined by
558      * readquestion().   Questions are defined as anything
559      * between blank lines.
560      *
561      * NOTE this method used to take $context as a second argument. However, at
562      * the point where this method was called, it was impossible to know what
563      * context the quetsions were going to be saved into, so the value could be
564      * wrong. Also, none of the standard question formats were using this argument,
565      * so it was removed. See MDL-32220.
566      *
567      * If your format does not use blank lines as a delimiter
568      * then you will need to override this method. Even then
569      * try to use readquestion for each question
570      * @param array lines array of lines from readdata
571      * @return array array of question objects
572      */
573     protected function readquestions($lines) {
575         $questions = array();
576         $currentquestion = array();
578         foreach ($lines as $line) {
579             $line = trim($line);
580             if (empty($line)) {
581                 if (!empty($currentquestion)) {
582                     if ($question = $this->readquestion($currentquestion)) {
583                         $questions[] = $question;
584                     }
585                     $currentquestion = array();
586                 }
587             } else {
588                 $currentquestion[] = $line;
589             }
590         }
592         if (!empty($currentquestion)) {  // There may be a final question
593             if ($question = $this->readquestion($currentquestion)) {
594                 $questions[] = $question;
595             }
596         }
598         return $questions;
599     }
601     /**
602      * return an "empty" question
603      * Somewhere to specify question parameters that are not handled
604      * by import but are required db fields.
605      * This should not be overridden.
606      * @return object default question
607      */
608     protected function defaultquestion() {
609         global $CFG;
610         static $defaultshuffleanswers = null;
611         if (is_null($defaultshuffleanswers)) {
612             $defaultshuffleanswers = get_config('quiz', 'shuffleanswers');
613         }
615         $question = new stdClass();
616         $question->shuffleanswers = $defaultshuffleanswers;
617         $question->defaultmark = 1;
618         $question->image = "";
619         $question->usecase = 0;
620         $question->multiplier = array();
621         $question->questiontextformat = FORMAT_MOODLE;
622         $question->generalfeedback = '';
623         $question->generalfeedbackformat = FORMAT_MOODLE;
624         $question->correctfeedback = '';
625         $question->partiallycorrectfeedback = '';
626         $question->incorrectfeedback = '';
627         $question->answernumbering = 'abc';
628         $question->penalty = 0.3333333;
629         $question->length = 1;
631         // this option in case the questiontypes class wants
632         // to know where the data came from
633         $question->export_process = true;
634         $question->import_process = true;
636         return $question;
637     }
639     /**
640      * Given the data known to define a question in
641      * this format, this function converts it into a question
642      * object suitable for processing and insertion into Moodle.
643      *
644      * If your format does not use blank lines to delimit questions
645      * (e.g. an XML format) you must override 'readquestions' too
646      * @param $lines mixed data that represents question
647      * @return object question object
648      */
649     protected function readquestion($lines) {
651         $formatnotimplemented = get_string('formatnotimplemented', 'question');
652         echo "<p>$formatnotimplemented</p>";
654         return null;
655     }
657     /**
658      * Override if any post-processing is required
659      * @return bool success
660      */
661     public function importpostprocess() {
662         return true;
663     }
665     /*******************
666      * EXPORT FUNCTIONS
667      *******************/
669     /**
670      * Provide export functionality for plugin questiontypes
671      * Do not override
672      * @param name questiontype name
673      * @param question object data to export
674      * @param extra mixed any addition format specific data needed
675      * @return string the data to append to export or false if error (or unhandled)
676      */
677     protected function try_exporting_using_qtypes($name, $question, $extra=null) {
678         // work out the name of format in use
679         $formatname = substr(get_class($this), strlen('qformat_'));
680         $methodname = "export_to_$formatname";
682         $qtype = question_bank::get_qtype($name, false);
683         if (method_exists($qtype, $methodname)) {
684             return $qtype->$methodname($question, $this, $extra);
685         }
686         return false;
687     }
689     /**
690      * Do any pre-processing that may be required
691      * @param bool success
692      */
693     public function exportpreprocess() {
694         return true;
695     }
697     /**
698      * Enable any processing to be done on the content
699      * just prior to the file being saved
700      * default is to do nothing
701      * @param string output text
702      * @param string processed output text
703      */
704     protected function presave_process($content) {
705         return $content;
706     }
708     /**
709      * Do the export
710      * For most types this should not need to be overrided
711      * @return stored_file
712      */
713     public function exportprocess() {
714         global $CFG, $OUTPUT, $DB, $USER;
716         // get the questions (from database) in this category
717         // only get q's with no parents (no cloze subquestions specifically)
718         if ($this->category) {
719             $questions = get_questions_category($this->category, true);
720         } else {
721             $questions = $this->questions;
722         }
724         $count = 0;
726         // results are first written into string (and then to a file)
727         // so create/initialize the string here
728         $expout = "";
730         // track which category questions are in
731         // if it changes we will record the category change in the output
732         // file if selected. 0 means that it will get printed before the 1st question
733         $trackcategory = 0;
735         // iterate through questions
736         foreach ($questions as $question) {
737             // used by file api
738             $contextid = $DB->get_field('question_categories', 'contextid',
739                     array('id' => $question->category));
740             $question->contextid = $contextid;
742             // do not export hidden questions
743             if (!empty($question->hidden)) {
744                 continue;
745             }
747             // do not export random questions
748             if ($question->qtype == 'random') {
749                 continue;
750             }
752             // check if we need to record category change
753             if ($this->cattofile) {
754                 if ($question->category != $trackcategory) {
755                     $trackcategory = $question->category;
756                     $categoryname = $this->get_category_path($trackcategory, $this->contexttofile);
758                     // create 'dummy' question for category export
759                     $dummyquestion = new stdClass();
760                     $dummyquestion->qtype = 'category';
761                     $dummyquestion->category = $categoryname;
762                     $dummyquestion->name = 'Switch category to ' . $categoryname;
763                     $dummyquestion->id = 0;
764                     $dummyquestion->questiontextformat = '';
765                     $dummyquestion->contextid = 0;
766                     $expout .= $this->writequestion($dummyquestion) . "\n";
767                 }
768             }
770             // export the question displaying message
771             $count++;
773             if (question_has_capability_on($question, 'view', $question->category)) {
774                 $expout .= $this->writequestion($question, $contextid) . "\n";
775             }
776         }
778         // continue path for following error checks
779         $course = $this->course;
780         $continuepath = "$CFG->wwwroot/question/export.php?courseid=$course->id";
782         // did we actually process anything
783         if ($count==0) {
784             print_error('noquestions', 'question', $continuepath);
785         }
787         // final pre-process on exported data
788         $expout = $this->presave_process($expout);
789         return $expout;
790     }
792     /**
793      * get the category as a path (e.g., tom/dick/harry)
794      * @param int id the id of the most nested catgory
795      * @return string the path
796      */
797     protected function get_category_path($id, $includecontext = true) {
798         global $DB;
800         if (!$category = $DB->get_record('question_categories', array('id' => $id))) {
801             print_error('cannotfindcategory', 'error', '', $id);
802         }
803         $contextstring = $this->translator->context_to_string($category->contextid);
805         $pathsections = array();
806         do {
807             $pathsections[] = $category->name;
808             $id = $category->parent;
809         } while ($category = $DB->get_record('question_categories', array('id' => $id)));
811         if ($includecontext) {
812             $pathsections[] = '$' . $contextstring . '$';
813         }
815         $path = $this->assemble_category_path(array_reverse($pathsections));
817         return $path;
818     }
820     /**
821      * Convert a list of category names, possibly preceeded by one of the
822      * context tokens like $course$, into a string representation of the
823      * category path.
824      *
825      * Names are separated by / delimiters. And /s in the name are replaced by //.
826      *
827      * To reverse the process and split the paths into names, use
828      * {@link split_category_path()}.
829      *
830      * @param array $names
831      * @return string
832      */
833     protected function assemble_category_path($names) {
834         $escapednames = array();
835         foreach ($names as $name) {
836             $escapedname = str_replace('/', '//', $name);
837             if (substr($escapedname, 0, 1) == '/') {
838                 $escapedname = ' ' . $escapedname;
839             }
840             if (substr($escapedname, -1) == '/') {
841                 $escapedname = $escapedname . ' ';
842             }
843             $escapednames[] = $escapedname;
844         }
845         return implode('/', $escapednames);
846     }
848     /**
849      * Convert a string, as returned by {@link assemble_category_path()},
850      * back into an array of category names.
851      *
852      * Each category name is cleaned by a call to clean_param(, PARAM_MULTILANG),
853      * which matches the cleaning in question/category_form.php.
854      *
855      * @param string $path
856      * @return array of category names.
857      */
858     protected function split_category_path($path) {
859         $rawnames = preg_split('~(?<!/)/(?!/)~', $path);
860         $names = array();
861         foreach ($rawnames as $rawname) {
862             $names[] = clean_param(trim(str_replace('//', '/', $rawname)), PARAM_MULTILANG);
863         }
864         return $names;
865     }
867     /**
868      * Do an post-processing that may be required
869      * @return bool success
870      */
871     protected function exportpostprocess() {
872         return true;
873     }
875     /**
876      * convert a single question object into text output in the given
877      * format.
878      * This must be overriden
879      * @param object question question object
880      * @return mixed question export text or null if not implemented
881      */
882     protected function writequestion($question) {
883         // if not overidden, then this is an error.
884         $formatnotimplemented = get_string('formatnotimplemented', 'question');
885         echo "<p>$formatnotimplemented</p>";
886         return null;
887     }
889     /**
890      * Convert the question text to plain text, so it can safely be displayed
891      * during import to let the user see roughly what is going on.
892      */
893     protected function format_question_text($question) {
894         global $DB;
895         $formatoptions = new stdClass();
896         $formatoptions->noclean = true;
897         return html_to_text(format_text($question->questiontext,
898                 $question->questiontextformat, $formatoptions), 0, false);
899     }