MDL-28438 Aiken question import broken since MDL-24594.
[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     // Accessor methods
108     /**
109      * set the category
110      * @param object category the category object
111      */
112     public function setCategory($category) {
113         if (count($this->questions)) {
114             debugging('You shouldn\'t call setCategory after setQuestions');
115         }
116         $this->category = $category;
117     }
119     /**
120      * Set the specific questions to export. Should not include questions with
121      * parents (sub questions of cloze question type).
122      * Only used for question export.
123      * @param array of question objects
124      */
125     public function setQuestions($questions) {
126         if ($this->category !== null) {
127             debugging('You shouldn\'t call setQuestions after setCategory');
128         }
129         $this->questions = $questions;
130     }
132     /**
133      * set the course class variable
134      * @param course object Moodle course variable
135      */
136     public function setCourse($course) {
137         $this->course = $course;
138     }
140     /**
141      * set an array of contexts.
142      * @param array $contexts Moodle course variable
143      */
144     public function setContexts($contexts) {
145         $this->contexts = $contexts;
146         $this->translator = new context_to_string_translator($this->contexts);
147     }
149     /**
150      * set the filename
151      * @param string filename name of file to import/export
152      */
153     public function setFilename($filename) {
154         $this->filename = $filename;
155     }
157     /**
158      * set the "real" filename
159      * (this is what the user typed, regardless of wha happened next)
160      * @param string realfilename name of file as typed by user
161      */
162     public function setRealfilename($realfilename) {
163         $this->realfilename = $realfilename;
164     }
166     /**
167      * set matchgrades
168      * @param string matchgrades error or nearest for grades
169      */
170     public function setMatchgrades($matchgrades) {
171         $this->matchgrades = $matchgrades;
172     }
174     /**
175      * set catfromfile
176      * @param bool catfromfile allow categories embedded in import file
177      */
178     public function setCatfromfile($catfromfile) {
179         $this->catfromfile = $catfromfile;
180     }
182     /**
183      * set contextfromfile
184      * @param bool $contextfromfile allow contexts embedded in import file
185      */
186     public function setContextfromfile($contextfromfile) {
187         $this->contextfromfile = $contextfromfile;
188     }
190     /**
191      * set cattofile
192      * @param bool cattofile exports categories within export file
193      */
194     public function setCattofile($cattofile) {
195         $this->cattofile = $cattofile;
196     }
198     /**
199      * set contexttofile
200      * @param bool cattofile exports categories within export file
201      */
202     public function setContexttofile($contexttofile) {
203         $this->contexttofile = $contexttofile;
204     }
206     /**
207      * set stoponerror
208      * @param bool stoponerror stops database write if any errors reported
209      */
210     public function setStoponerror($stoponerror) {
211         $this->stoponerror = $stoponerror;
212     }
214     /**
215      * @param bool $canaccess Whether the current use can access the backup data folder. Determines
216      * where export files are saved.
217      */
218     public function set_can_access_backupdata($canaccess) {
219         $this->canaccessbackupdata = $canaccess;
220     }
222     /***********************
223      * IMPORTING FUNCTIONS
224      ***********************/
226     /**
227      * Handle parsing error
228      */
229     protected function error($message, $text='', $questionname='') {
230         $importerrorquestion = get_string('importerrorquestion', 'question');
232         echo "<div class=\"importerror\">\n";
233         echo "<strong>$importerrorquestion $questionname</strong>";
234         if (!empty($text)) {
235             $text = s($text);
236             echo "<blockquote>$text</blockquote>\n";
237         }
238         echo "<strong>$message</strong>\n";
239         echo "</div>";
241          $this->importerrors++;
242     }
244     /**
245      * Import for questiontype plugins
246      * Do not override.
247      * @param data mixed The segment of data containing the question
248      * @param question object processed (so far) by standard import code if appropriate
249      * @param extra mixed any additional format specific data that may be passed by the format
250      * @param qtypehint hint about a question type from format
251      * @return object question object suitable for save_options() or false if cannot handle
252      */
253     public function try_importing_using_qtypes($data, $question = null, $extra = null,
254             $qtypehint = '') {
256         // work out what format we are using
257         $formatname = substr(get_class($this), strlen('qformat_'));
258         $methodname = "import_from_$formatname";
260         //first try importing using a hint from format
261         if (!empty($qtypehint)) {
262             $qtype = question_bank::get_qtype($qtypehint, false);
263             if (is_object($qtype) && method_exists($qtype, $methodname)) {
264                 $question = $qtype->$methodname($data, $question, $this, $extra);
265                 if ($question) {
266                     return $question;
267                 }
268             }
269         }
271         // loop through installed questiontypes checking for
272         // function to handle this question
273         foreach (question_bank::get_all_qtypes() as $qtype) {
274             if (method_exists($qtype, $methodname)) {
275                 if ($question = $qtype->$methodname($data, $question, $this, $extra)) {
276                     return $question;
277                 }
278             }
279         }
280         return false;
281     }
283     /**
284      * Perform any required pre-processing
285      * @return bool success
286      */
287     public function importpreprocess() {
288         return true;
289     }
291     /**
292      * Process the file
293      * This method should not normally be overidden
294      * @param object $category
295      * @return bool success
296      */
297     public function importprocess($category) {
298         global $USER, $CFG, $DB, $OUTPUT;
300         $context = $category->context;
301         $this->importcontext = $context;
303         // reset the timer in case file upload was slow
304         set_time_limit(0);
306         // STAGE 1: Parse the file
307         echo $OUTPUT->notification(get_string('parsingquestions', 'question'), 'notifysuccess');
309         if (! $lines = $this->readdata($this->filename)) {
310             echo $OUTPUT->notification(get_string('cannotread', 'question'));
311             return false;
312         }
314         if (!$questions = $this->readquestions($lines, $context)) {   // Extract all the questions
315             echo $OUTPUT->notification(get_string('noquestionsinfile', 'question'));
316             return false;
317         }
319         // STAGE 2: Write data to database
320         echo $OUTPUT->notification(get_string('importingquestions', 'question',
321                 $this->count_questions($questions)), 'notifysuccess');
323         // check for errors before we continue
324         if ($this->stoponerror and ($this->importerrors>0)) {
325             echo $OUTPUT->notification(get_string('importparseerror', 'question'));
326             return true;
327         }
329         // get list of valid answer grades
330         $gradeoptionsfull = question_bank::fraction_options_full();
332         // check answer grades are valid
333         // (now need to do this here because of 'stop on error': MDL-10689)
334         $gradeerrors = 0;
335         $goodquestions = array();
336         foreach ($questions as $question) {
337             if (!empty($question->fraction) and (is_array($question->fraction))) {
338                 $fractions = $question->fraction;
339                 $answersvalid = true; // in case they are!
340                 foreach ($fractions as $key => $fraction) {
341                     $newfraction = match_grade_options($gradeoptionsfull, $fraction,
342                             $this->matchgrades);
343                     if ($newfraction === false) {
344                         $answersvalid = false;
345                     } else {
346                         $fractions[$key] = $newfraction;
347                     }
348                 }
349                 if (!$answersvalid) {
350                     echo $OUTPUT->notification(get_string('invalidgrade', 'question'));
351                     ++$gradeerrors;
352                     continue;
353                 } else {
354                     $question->fraction = $fractions;
355                 }
356             }
357             $goodquestions[] = $question;
358         }
359         $questions = $goodquestions;
361         // check for errors before we continue
362         if ($this->stoponerror && $gradeerrors > 0) {
363             return false;
364         }
366         // count number of questions processed
367         $count = 0;
369         foreach ($questions as $question) {   // Process and store each question
371             // reset the php timeout
372             set_time_limit(0);
374             // check for category modifiers
375             if ($question->qtype == 'category') {
376                 if ($this->catfromfile) {
377                     // find/create category object
378                     $catpath = $question->category;
379                     $newcategory = $this->create_category_path($catpath);
380                     if (!empty($newcategory)) {
381                         $this->category = $newcategory;
382                     }
383                 }
384                 continue;
385             }
386             $question->context = $context;
388             $count++;
390             echo "<hr /><p><b>$count</b>. ".$this->format_question_text($question)."</p>";
392             $question->category = $this->category->id;
393             $question->stamp = make_unique_id_code();  // Set the unique code (not to be changed)
395             $question->createdby = $USER->id;
396             $question->timecreated = time();
398             $question->id = $DB->insert_record('question', $question);
399             if (isset($question->questiontextfiles)) {
400                 foreach ($question->questiontextfiles as $file) {
401                     question_bank::get_qtype($question->qtype)->import_file(
402                             $context, 'question', 'questiontext', $question->id, $file);
403                 }
404             }
405             if (isset($question->generalfeedbackfiles)) {
406                 foreach ($question->generalfeedbackfiles as $file) {
407                     question_bank::get_qtype($question->qtype)->import_file(
408                             $context, 'question', 'generalfeedback', $question->id, $file);
409                 }
410             }
412             $this->questionids[] = $question->id;
414             // Now to save all the answers and type-specific options
416             $result = question_bank::get_qtype($question->qtype)->save_question_options($question);
418             if (!empty($CFG->usetags) && isset($question->tags)) {
419                 require_once($CFG->dirroot . '/tag/lib.php');
420                 tag_set('question', $question->id, $question->tags);
421             }
423             if (!empty($result->error)) {
424                 echo $OUTPUT->notification($result->error);
425                 return false;
426             }
428             if (!empty($result->notice)) {
429                 echo $OUTPUT->notification($result->notice);
430                 return true;
431             }
433             // Give the question a unique version stamp determined by question_hash()
434             $DB->set_field('question', 'version', question_hash($question),
435                     array('id' => $question->id));
436         }
437         return true;
438     }
440     /**
441      * Count all non-category questions in the questions array.
442      *
443      * @param array questions An array of question objects.
444      * @return int The count.
445      *
446      */
447     protected function count_questions($questions) {
448         $count = 0;
449         if (!is_array($questions)) {
450             return $count;
451         }
452         foreach ($questions as $question) {
453             if (!is_object($question) || !isset($question->qtype) ||
454                     ($question->qtype == 'category')) {
455                 continue;
456             }
457             $count++;
458         }
459         return $count;
460     }
462     /**
463      * find and/or create the category described by a delimited list
464      * e.g. $course$/tom/dick/harry or tom/dick/harry
465      *
466      * removes any context string no matter whether $getcontext is set
467      * but if $getcontext is set then ignore the context and use selected category context.
468      *
469      * @param string catpath delimited category path
470      * @param int courseid course to search for categories
471      * @return mixed category object or null if fails
472      */
473     protected function create_category_path($catpath) {
474         global $DB;
475         $catnames = $this->split_category_path($catpath);
476         $parent = 0;
477         $category = null;
479         // check for context id in path, it might not be there in pre 1.9 exports
480         $matchcount = preg_match('/^\$([a-z]+)\$$/', $catnames[0], $matches);
481         if ($matchcount == 1) {
482             $contextid = $this->translator->string_to_context($matches[1]);
483             array_shift($catnames);
484         } else {
485             $contextid = false;
486         }
488         if ($this->contextfromfile && $contextid !== false) {
489             $context = get_context_instance_by_id($contextid);
490             require_capability('moodle/question:add', $context);
491         } else {
492             $context = get_context_instance_by_id($this->category->contextid);
493         }
495         // Now create any categories that need to be created.
496         foreach ($catnames as $catname) {
497             if ($category = $DB->get_record('question_categories',
498                     array('name' => $catname, 'contextid' => $context->id, 'parent' => $parent))) {
499                 $parent = $category->id;
500             } else {
501                 require_capability('moodle/question:managecategory', $context);
502                 // create the new category
503                 $category = new stdClass();
504                 $category->contextid = $context->id;
505                 $category->name = $catname;
506                 $category->info = '';
507                 $category->parent = $parent;
508                 $category->sortorder = 999;
509                 $category->stamp = make_unique_id_code();
510                 $id = $DB->insert_record('question_categories', $category);
511                 $category->id = $id;
512                 $parent = $id;
513             }
514         }
515         return $category;
516     }
518     /**
519      * Return complete file within an array, one item per line
520      * @param string filename name of file
521      * @return mixed contents array or false on failure
522      */
523     protected function readdata($filename) {
524         if (is_readable($filename)) {
525             $filearray = file($filename);
527             /// Check for Macintosh OS line returns (ie file on one line), and fix
528             if (preg_match("~\r~", $filearray[0]) AND !preg_match("~\n~", $filearray[0])) {
529                 return explode("\r", $filearray[0]);
530             } else {
531                 return $filearray;
532             }
533         }
534         return false;
535     }
537     /**
538      * Parses an array of lines into an array of questions,
539      * where each item is a question object as defined by
540      * readquestion().   Questions are defined as anything
541      * between blank lines.
542      *
543      * If your format does not use blank lines as a delimiter
544      * then you will need to override this method. Even then
545      * try to use readquestion for each question
546      * @param array lines array of lines from readdata
547      * @param object $context
548      * @return array array of question objects
549      */
550     protected function readquestions($lines, $context) {
552         $questions = array();
553         $currentquestion = array();
555         foreach ($lines as $line) {
556             $line = trim($line);
557             if (empty($line)) {
558                 if (!empty($currentquestion)) {
559                     if ($question = $this->readquestion($currentquestion)) {
560                         $questions[] = $question;
561                     }
562                     $currentquestion = array();
563                 }
564             } else {
565                 $currentquestion[] = $line;
566             }
567         }
569         if (!empty($currentquestion)) {  // There may be a final question
570             if ($question = $this->readquestion($currentquestion, $context)) {
571                 $questions[] = $question;
572             }
573         }
575         return $questions;
576     }
578     /**
579      * return an "empty" question
580      * Somewhere to specify question parameters that are not handled
581      * by import but are required db fields.
582      * This should not be overridden.
583      * @return object default question
584      */
585     protected function defaultquestion() {
586         global $CFG;
587         static $defaultshuffleanswers = null;
588         if (is_null($defaultshuffleanswers)) {
589             $defaultshuffleanswers = get_config('quiz', 'shuffleanswers');
590         }
592         $question = new stdClass();
593         $question->shuffleanswers = $defaultshuffleanswers;
594         $question->defaultmark = 1;
595         $question->image = "";
596         $question->usecase = 0;
597         $question->multiplier = array();
598         $question->questiontextformat = FORMAT_MOODLE;
599         $question->generalfeedback = '';
600         $question->generalfeedbackformat = FORMAT_MOODLE;
601         $question->correctfeedback = '';
602         $question->partiallycorrectfeedback = '';
603         $question->incorrectfeedback = '';
604         $question->answernumbering = 'abc';
605         $question->penalty = 0.3333333;
606         $question->length = 1;
608         // this option in case the questiontypes class wants
609         // to know where the data came from
610         $question->export_process = true;
611         $question->import_process = true;
613         return $question;
614     }
616     /**
617      * Given the data known to define a question in
618      * this format, this function converts it into a question
619      * object suitable for processing and insertion into Moodle.
620      *
621      * If your format does not use blank lines to delimit questions
622      * (e.g. an XML format) you must override 'readquestions' too
623      * @param $lines mixed data that represents question
624      * @return object question object
625      */
626     protected function readquestion($lines) {
628         $formatnotimplemented = get_string('formatnotimplemented', 'question');
629         echo "<p>$formatnotimplemented</p>";
631         return null;
632     }
634     /**
635      * Override if any post-processing is required
636      * @return bool success
637      */
638     public function importpostprocess() {
639         return true;
640     }
642     /*******************
643      * EXPORT FUNCTIONS
644      *******************/
646     /**
647      * Provide export functionality for plugin questiontypes
648      * Do not override
649      * @param name questiontype name
650      * @param question object data to export
651      * @param extra mixed any addition format specific data needed
652      * @return string the data to append to export or false if error (or unhandled)
653      */
654     protected function try_exporting_using_qtypes($name, $question, $extra=null) {
655         // work out the name of format in use
656         $formatname = substr(get_class($this), strlen('qformat_'));
657         $methodname = "export_to_$formatname";
659         $qtype = question_bank::get_qtype($name, false);
660         if (method_exists($qtype, $methodname)) {
661             return $qtype->$methodname($question, $this, $extra);
662         }
663         return false;
664     }
666     /**
667      * Do any pre-processing that may be required
668      * @param bool success
669      */
670     public function exportpreprocess() {
671         return true;
672     }
674     /**
675      * Enable any processing to be done on the content
676      * just prior to the file being saved
677      * default is to do nothing
678      * @param string output text
679      * @param string processed output text
680      */
681     protected function presave_process($content) {
682         return $content;
683     }
685     /**
686      * Do the export
687      * For most types this should not need to be overrided
688      * @return stored_file
689      */
690     public function exportprocess() {
691         global $CFG, $OUTPUT, $DB, $USER;
693         // get the questions (from database) in this category
694         // only get q's with no parents (no cloze subquestions specifically)
695         if ($this->category) {
696             $questions = get_questions_category($this->category, true);
697         } else {
698             $questions = $this->questions;
699         }
701         $count = 0;
703         // results are first written into string (and then to a file)
704         // so create/initialize the string here
705         $expout = "";
707         // track which category questions are in
708         // if it changes we will record the category change in the output
709         // file if selected. 0 means that it will get printed before the 1st question
710         $trackcategory = 0;
712         // iterate through questions
713         foreach ($questions as $question) {
714             // used by file api
715             $contextid = $DB->get_field('question_categories', 'contextid',
716                     array('id' => $question->category));
717             $question->contextid = $contextid;
719             // do not export hidden questions
720             if (!empty($question->hidden)) {
721                 continue;
722             }
724             // do not export random questions
725             if ($question->qtype == 'random') {
726                 continue;
727             }
729             // check if we need to record category change
730             if ($this->cattofile) {
731                 if ($question->category != $trackcategory) {
732                     $trackcategory = $question->category;
733                     $categoryname = $this->get_category_path($trackcategory, $this->contexttofile);
735                     // create 'dummy' question for category export
736                     $dummyquestion = new stdClass();
737                     $dummyquestion->qtype = 'category';
738                     $dummyquestion->category = $categoryname;
739                     $dummyquestion->name = 'Switch category to ' . $categoryname;
740                     $dummyquestion->id = 0;
741                     $dummyquestion->questiontextformat = '';
742                     $dummyquestion->contextid = 0;
743                     $expout .= $this->writequestion($dummyquestion) . "\n";
744                 }
745             }
747             // export the question displaying message
748             $count++;
750             if (question_has_capability_on($question, 'view', $question->category)) {
751                 $expout .= $this->writequestion($question, $contextid) . "\n";
752             }
753         }
755         // continue path for following error checks
756         $course = $this->course;
757         $continuepath = "$CFG->wwwroot/question/export.php?courseid=$course->id";
759         // did we actually process anything
760         if ($count==0) {
761             print_error('noquestions', 'question', $continuepath);
762         }
764         // final pre-process on exported data
765         $expout = $this->presave_process($expout);
766         return $expout;
767     }
769     /**
770      * get the category as a path (e.g., tom/dick/harry)
771      * @param int id the id of the most nested catgory
772      * @return string the path
773      */
774     protected function get_category_path($id, $includecontext = true) {
775         global $DB;
777         if (!$category = $DB->get_record('question_categories', array('id' => $id))) {
778             print_error('cannotfindcategory', 'error', '', $id);
779         }
780         $contextstring = $this->translator->context_to_string($category->contextid);
782         $pathsections = array();
783         do {
784             $pathsections[] = $category->name;
785             $id = $category->parent;
786         } while ($category = $DB->get_record('question_categories', array('id' => $id)));
788         if ($includecontext) {
789             $pathsections[] = '$' . $contextstring . '$';
790         }
792         $path = $this->assemble_category_path(array_reverse($pathsections));
794         return $path;
795     }
797     /**
798      * Convert a list of category names, possibly preceeded by one of the
799      * context tokens like $course$, into a string representation of the
800      * category path.
801      *
802      * Names are separated by / delimiters. And /s in the name are replaced by //.
803      *
804      * To reverse the process and split the paths into names, use
805      * {@link split_category_path()}.
806      *
807      * @param array $names
808      * @return string
809      */
810     protected function assemble_category_path($names) {
811         $escapednames = array();
812         foreach ($names as $name) {
813             $escapedname = str_replace('/', '//', $name);
814             if (substr($escapedname, 0, 1) == '/') {
815                 $escapedname = ' ' . $escapedname;
816             }
817             if (substr($escapedname, -1) == '/') {
818                 $escapedname = $escapedname . ' ';
819             }
820             $escapednames[] = $escapedname;
821         }
822         return implode('/', $escapednames);
823     }
825     /**
826      * Convert a string, as returned by {@link assemble_category_path()},
827      * back into an array of category names.
828      *
829      * Each category name is cleaned by a call to clean_param(, PARAM_MULTILANG),
830      * which matches the cleaning in question/category_form.php.
831      *
832      * @param string $path
833      * @return array of category names.
834      */
835     protected function split_category_path($path) {
836         $rawnames = preg_split('~(?<!/)/(?!/)~', $path);
837         $names = array();
838         foreach ($rawnames as $rawname) {
839             $names[] = clean_param(trim(str_replace('//', '/', $rawname)), PARAM_MULTILANG);
840         }
841         return $names;
842     }
844     /**
845      * Do an post-processing that may be required
846      * @return bool success
847      */
848     protected function exportpostprocess() {
849         return true;
850     }
852     /**
853      * convert a single question object into text output in the given
854      * format.
855      * This must be overriden
856      * @param object question question object
857      * @return mixed question export text or null if not implemented
858      */
859     protected function writequestion($question) {
860         // if not overidden, then this is an error.
861         $formatnotimplemented = get_string('formatnotimplemented', 'question');
862         echo "<p>$formatnotimplemented</p>";
863         return null;
864     }
866     /**
867      * Convert the question text to plain text, so it can safely be displayed
868      * during import to let the user see roughly what is going on.
869      */
870     protected function format_question_text($question) {
871         global $DB;
872         $formatoptions = new stdClass();
873         $formatoptions->noclean = true;
874         return html_to_text(format_text($question->questiontext,
875                 $question->questiontextformat, $formatoptions), 0, false);
876     }
878     /**
879      * convert files into text output in the given format.
880      * @param array
881      * @param string encoding method
882      * @return string $string
883      */
884     protected function writefiles($files, $encoding='base64') {
885         if (empty($files)) {
886             return '';
887         }
888         $string = '';
889         foreach ($files as $file) {
890             if ($file->is_directory()) {
891                 continue;
892             }
893             $string .= '<file name="' . $file->get_filename() . '" encoding="' . $encoding . '">';
894             $string .= base64_encode($file->get_content());
895             $string .= '</file>';
896         }
897         return $string;
898     }