question/format/xml/format.php

   1 <?php // $Id$
   2 //
   3 ///////////////////////////////////////////////////////////////
   4 // XML import/export
   5 //
   6 //////////////////////////////////////////////////////////////////////////
   7 // Based on default.php, included by ../import.php
   8 /**
   9  * @package questionbank
  10  * @subpackage importexport
  11  */
  12 require_once( "$CFG->libdir/xmlize.php" );
  13
  14 class qformat_xml extends qformat_default {
  15
  16     function provide_import() {
  17         return true;
  18     }
  19
  20     function provide_export() {
  21         return true;
  22     }
  23
  24     // IMPORT FUNCTIONS START HERE
  25
  26     /**
  27      * Translate human readable format name
  28      * into internal Moodle code number
  29      * @param string name format name from xml file
  30      * @return int Moodle format code
  31      */
  32     function trans_format( $name ) {
  33         $name = trim($name);
  34
  35         if ($name=='moodle_auto_format') {
  36             $id = 0;
  37         }
  38         elseif ($name=='html') {
  39             $id = 1;
  40         }
  41         elseif ($name=='plain_text') {
  42             $id = 2;
  43         }
  44         elseif ($name=='wiki_like') {
  45             $id = 3;
  46         }
  47         elseif ($name=='markdown') {
  48             $id = 4;
  49         }
  50         else {
  51             $id = 0; // or maybe warning required
  52         }
  53         return $id;
  54     }
  55
  56     /**
  57      * Translate human readable single answer option
  58      * to internal code number
  59      * @param string name true/false
  60      * @return int internal code number
  61      */
  62     function trans_single( $name ) {
  63         $name = trim($name);
  64         if ($name == "false" || !$name) {
  65             return 0;
  66         } else {
  67             return 1;
  68         }
  69     }
  70
  71     /**
  72      * process text string from xml file
  73      * @param array $text bit of xml tree after ['text']
  74      * @return string processed text
  75      */
  76     function import_text( $text ) {
  77         // quick sanity check
  78         if (empty($text)) {
  79             return '';
  80         }
  81         $data = $text[0]['#'];
  82         return addslashes(trim( $data ));
  83     }
  84
  85     /**
  86      * return the value of a node, given a path to the node
  87      * if it doesn't exist return the default value
  88      * @param array xml data to read
  89      * @param array path path to node expressed as array
  90      * @param mixed default
  91      * @param bool istext process as text
  92      * @param string error if set value must exist, return false and issue message if not
  93      * @return mixed value
  94      */
  95     function getpath( $xml, $path, $default, $istext=false, $error='' ) {
  96         foreach ($path as $index) {
  97             if (!isset($xml[$index])) {
  98                 if (!empty($error)) {
  99                     $this->error( $error );
 100                     return false;
 101                 } else {
 102                     return $default;
 103                 }
 104             }
 105             else $xml = $xml[$index];
 106         }
 107         if ($istext) {
 108             if (!is_string($xml)) {
 109                 $this->error( 'Invalid xml file - string expected (use CDATA?)' );
 110             }
 111             $xml = addslashes( trim( $xml ) );
 112         }
 113
 114         return $xml;
 115     }
 116
 117
 118     /**
 119      * import parts of question common to all types
 120      * @param array question question array from xml tree
 121      * @return object question object
 122      */
 123     function import_headers( $question ) {
 124         // get some error strings
 125         $error_noname = get_string( 'xmlimportnoname','quiz' );
 126         $error_noquestion = get_string( 'xmlimportnoquestion','quiz' );
 127
 128         // this routine initialises the question object
 129         $qo = $this->defaultquestion();
 130
 131         // question name
 132         $qo->name = $this->getpath( $question, array('#','name',0,'#','text',0,'#'), '', true, $error_noname );
 133         $qo->questiontext = $this->getpath( $question, array('#','questiontext',0,'#','text',0,'#'), '', true );
 134         $qo->questiontextformat = $this->getpath( $question, array('#','questiontext',0,'@','format'), '' );
 135         $image = $this->getpath( $question, array('#','image',0,'#'), $qo->image );
 136         $image_base64 = $this->getpath( $question, array('#','image_base64','0','#'),'' );
 137         if (!empty($image_base64)) {
 138             $qo->image = $this->importimagefile( $image, stripslashes($image_base64) );
 139         }
 140         $qo->generalfeedback = $this->getpath( $question, array('#','generalfeedback',0,'#','text',0,'#'), $qo->generalfeedback, true );
 141         $qo->defaultgrade = $this->getpath( $question, array('#','defaultgrade',0,'#'), $qo->defaultgrade );
 142         $qo->penalty = $this->getpath( $question, array('#','penalty',0,'#'), $qo->penalty );
 143
 144         return $qo;
 145     }
 146
 147     /**
 148      * import the common parts of a single answer
 149      * @param array answer xml tree for single answer
 150      * @return object answer object
 151      */
 152     function import_answer( $answer ) {
 153         $fraction = $this->getpath( $answer, array('@','fraction'),0 );
 154         $text = $this->getpath( $answer, array('#','text',0,'#'), '', true );
 155         $feedback = $this->getpath( $answer, array('#','feedback',0,'#','text',0,'#'), '', true );
 156
 157         $ans = null;
 158         $ans->answer = $text;
 159         $ans->fraction = $fraction / 100;
 160         $ans->feedback = $feedback;
 161         return $ans;
 162     }
 163
 164     /**
 165      * import multiple choice question
 166      * @param array question question array from xml tree
 167      * @return object question object
 168      */
 169     function import_multichoice( $question ) {
 170         // get common parts
 171         $qo = $this->import_headers( $question );
 172
 173         // 'header' parts particular to multichoice
 174         $qo->qtype = MULTICHOICE;
 175         $single = $this->getpath( $question, array('#','single',0,'#'), 'true' );
 176         $qo->single = $this->trans_single( $single );
 177         $shuffleanswers = $this->getpath( $question, array('#','shuffleanswers',0,'#'), 'false' );
 178         $qo->answernumbering = $this->getpath( $question, array('#','answernumbering',0,'#'), 'abc' );
 179         $qo->shuffleanswers = $this->trans_single($shuffleanswers);
 180         $qo->correctfeedback = $this->getpath( $question, array('#','correctfeedback',0,'#','text',0,'#'), '', true );
 181         $qo->partiallycorrectfeedback = $this->getpath( $question, array('#','partiallycorrectfeedback',0,'#','text',0,'#'), '', true );
 182         $qo->incorrectfeedback = $this->getpath( $question, array('#','incorrectfeedback',0,'#','text',0,'#'), '', true );
 183
 184         // run through the answers
 185         $answers = $question['#']['answer'];
 186         $a_count = 0;
 187         foreach ($answers as $answer) {
 188             $ans = $this->import_answer( $answer );
 189             $qo->answer[$a_count] = $ans->answer;
 190             $qo->fraction[$a_count] = $ans->fraction;
 191             $qo->feedback[$a_count] = $ans->feedback;
 192             ++$a_count;
 193         }
 194         return $qo;
 195     }
 196
 197     /**
 198      * import cloze type question
 199      * @param array question question array from xml tree
 200      * @return object question object
 201      */
 202     function import_multianswer( $questions ) {
 203         $questiontext = $questions['#']['questiontext'][0]['#']['text'];
 204         $qo = qtype_multianswer_extract_question($this->import_text($questiontext));
 205
 206         // 'header' parts particular to multianswer
 207         $qo->qtype = MULTIANSWER;
 208         $qo->course = $this->course;
 209         $qo->generalfeedback = $this->getpath( $questions, array('#','generalfeedback',0,'#','text',0,'#'), '', true );
 210
 211         if (!empty($questions)) {
 212             $qo->name = $this->import_text( $questions['#']['name'][0]['#']['text'] );
 213         }
 214
 215         return $qo;
 216     }
 217
 218     /**
 219      * import true/false type question
 220      * @param array question question array from xml tree
 221      * @return object question object
 222      */
 223     function import_truefalse( $question ) {
 224         // get common parts
 225         $qo = $this->import_headers( $question );
 226
 227         // 'header' parts particular to true/false
 228         $qo->qtype = TRUEFALSE;
 229
 230         // get answer info
 231         //
 232         // In the past, it used to be assumed that the two answers were in the file
 233         // true first, then false. Howevever that was not always true. Now, we
 234         // try to match on the answer text, but in old exports, this will be a localised
 235         // string, so if we don't find true or false, we fall back to the old system.
 236         $first = true;
 237         $warning = false;
 238         foreach ($question['#']['answer'] as $answer) {
 239             $answertext = $this->getpath( $answer, array('#','text',0,'#'), '', true );
 240             $feedback = $this->getpath($answer, array('#','feedback',0,'#','text',0,'#'), '', true );
 241             if ($answertext != 'true' && $answertext != 'false') {
 242                 $warning = true;
 243                 $answertext = $first ? 'true' : 'false'; // Old style file, assume order is true/false.
 244             }
 245             if ($answertext == 'true') {
 246                 $qo->answer = ($answer['@']['fraction'] == 100);
 247                 $qo->correctanswer = $qo->answer;
 248                 $qo->feedbacktrue = $feedback;
 249             } else {
 250                 $qo->answer = ($answer['@']['fraction'] != 100);
 251                 $qo->correctanswer = $qo->answer;
 252                 $qo->feedbackfalse = $feedback;
 253             }
 254             $first = false;
 255         }
 256
 257         if ($warning) {
 258             $a = new stdClass;
 259             $a->questiontext = $qo->questiontext;
 260             $a->answer = get_string($qo->answer ? 'true' : 'false', 'quiz');
 261             notify(get_string('truefalseimporterror', 'quiz', $a));
 262         }
 263         return $qo;
 264     }
 265
 266     /**
 267      * import short answer type question
 268      * @param array question question array from xml tree
 269      * @return object question object
 270      */
 271     function import_shortanswer( $question ) {
 272         // get common parts
 273         $qo = $this->import_headers( $question );
 274
 275         // header parts particular to shortanswer
 276         $qo->qtype = SHORTANSWER;
 277
 278         // get usecase
 279         $qo->usecase = $this->getpath($question, array('#','usecase',0,'#'), $qo->usecase );
 280
 281         // run through the answers
 282         $answers = $question['#']['answer'];
 283         $a_count = 0;
 284         foreach ($answers as $answer) {
 285             $ans = $this->import_answer( $answer );
 286             $qo->answer[$a_count] = $ans->answer;
 287             $qo->fraction[$a_count] = $ans->fraction;
 288             $qo->feedback[$a_count] = $ans->feedback;
 289             ++$a_count;
 290         }
 291
 292         return $qo;
 293     }
 294
 295     /**
 296      * import description type question
 297      * @param array question question array from xml tree
 298      * @return object question object
 299      */
 300     function import_description( $question ) {
 301         // get common parts
 302         $qo = $this->import_headers( $question );
 303         // header parts particular to shortanswer
 304         $qo->qtype = DESCRIPTION;
 305         $qo->defaultgrade = 0;
 306         $qo->length = 0;
 307         return $qo;
 308     }
 309
 310     /**
 311      * import numerical type question
 312      * @param array question question array from xml tree
 313      * @return object question object
 314      */
 315     function import_numerical( $question ) {
 316         // get common parts
 317         $qo = $this->import_headers( $question );
 318
 319         // header parts particular to numerical
 320         $qo->qtype = NUMERICAL;
 321
 322         // get answers array
 323         $answers = $question['#']['answer'];
 324         $qo->answer = array();
 325         $qo->feedback = array();
 326         $qo->fraction = array();
 327         $qo->tolerance = array();
 328         foreach ($answers as $answer) {
 329             // answer outside of <text> is deprecated
 330             $answertext = trim( $this->getpath( $answer, array('#',0), '' ) );
 331             $qo->answer[] = $this->getpath( $answer, array('#','text',0,'#'), $answertext, true );
 332             if (empty($qo->answer)) {
 333                 $qo->answer = '*';
 334             }
 335             $qo->feedback[] = $this->getpath( $answer, array('#','feedback',0,'#','text',0,'#'), '', true );
 336             $qo->tolerance[] = $this->getpath( $answer, array('#','tolerance',0,'#'), 0 );
 337
 338             // fraction as a tag is deprecated
 339             $fraction = $this->getpath( $answer, array('@','fraction'), 0 ) / 100;
 340             $qo->fraction[] = $this->getpath( $answer, array('#','fraction',0,'#'), $fraction ); // deprecated
 341         }
 342
 343         // get units array
 344         $qo->unit = array();
 345         $units = $this->getpath( $question, array('#','units',0,'#','unit'), array() );
 346         if (!empty($units)) {
 347             $qo->multiplier = array();
 348             foreach ($units as $unit) {
 349                 $qo->multiplier[] = $this->getpath( $unit, array('#','multiplier',0,'#'), 1 );
 350                 $qo->unit[] = $this->getpath( $unit, array('#','unit_name',0,'#'), '', true );
 351             }
 352         }
 353         return $qo;
 354     }
 355
 356     /**
 357      * import matching type question
 358      * @param array question question array from xml tree
 359      * @return object question object
 360      */
 361     function import_matching( $question ) {
 362         // get common parts
 363         $qo = $this->import_headers( $question );
 364
 365         // header parts particular to matching
 366         $qo->qtype = MATCH;
 367         $qo->shuffleanswers = $this->getpath( $question, array( '#','shuffleanswers',0,'#' ), 1 );
 368
 369         // get subquestions
 370         $subquestions = $question['#']['subquestion'];
 371         $qo->subquestions = array();
 372         $qo->subanswers = array();
 373
 374         // run through subquestions
 375         foreach ($subquestions as $subquestion) {
 376             $qo->subquestions[] = $this->getpath( $subquestion, array('#','text',0,'#'), '', true );
 377             $qo->subanswers[] = $this->getpath( $subquestion, array('#','answer',0,'#','text',0,'#'), '', true);
 378         }
 379         return $qo;
 380     }
 381
 382     /**
 383      * import  essay type question
 384      * @param array question question array from xml tree
 385      * @return object question object
 386      */
 387     function import_essay( $question ) {
 388         // get common parts
 389         $qo = $this->import_headers( $question );
 390
 391         // header parts particular to essay
 392         $qo->qtype = ESSAY;
 393
 394         // get feedback
 395         $qo->feedback = $this->import_text( $question['#']['answer'][0]['#']['feedback'][0]['#']['text'] );
 396
 397         // handle answer
 398         $answer = $question['#']['answer'][0];
 399
 400         // get fraction - <fraction> tag is deprecated
 401         $qo->fraction = $this->getpath( $question, array('@','fraction'), 0 ) / 100;
 402         $q0->fraction = $this->getpath( $question, array('#','fraction',0,'#'), $qo->fraction );
 403
 404         return $qo;
 405     }
 406
 407     function import_calculated( $question ) {
 408     // import numerical question
 409
 410         // get common parts
 411         $qo = $this->import_headers( $question );
 412
 413         // header parts particular to numerical
 414         $qo->qtype = CALCULATED ;//CALCULATED;
 415
 416         // get answers array
 417        // echo "<pre> question";print_r($question);echo "</pre>";
 418         $answers = $question['#']['answer'];
 419         $qo->answers = array();
 420         $qo->feedback = array();
 421         $qo->fraction = array();
 422         $qo->tolerance = array();
 423         $qo->tolerancetype = array();
 424         $qo->correctanswerformat = array();
 425         $qo->correctanswerlength = array();
 426         $qo->feedback = array();
 427         foreach ($answers as $answer) {
 428             // answer outside of <text> is deprecated
 429             if (!empty( $answer['#']['text'] )) {
 430                 $answertext = $this->import_text( $answer['#']['text'] );
 431             }
 432             else {
 433                 $answertext = trim($answer['#'][0]);
 434             }
 435             if ($answertext == '') {
 436                 $qo->answers[] = '*';
 437             } else {
 438                 $qo->answers[] = $answertext;
 439             }
 440             $qo->feedback[] = $this->import_text( $answer['#']['feedback'][0]['#']['text'] );
 441             $qo->tolerance[] = $answer['#']['tolerance'][0]['#'];
 442             // fraction as a tag is deprecated
 443             if (!empty($answer['#']['fraction'][0]['#'])) {
 444                 $qo->fraction[] = $answer['#']['fraction'][0]['#'];
 445             }
 446             else {
 447                 $qo->fraction[] = $answer['@']['fraction'] / 100;
 448             }
 449             $qo->tolerancetype[] = $answer['#']['tolerancetype'][0]['#'];
 450             $qo->correctanswerformat[] = $answer['#']['correctanswerformat'][0]['#'];
 451             $qo->correctanswerlength[] = $answer['#']['correctanswerlength'][0]['#'];
 452         }
 453         // get units array
 454         $qo->unit = array();
 455         if (isset($question['#']['units'][0]['#']['unit'])) {
 456             $units = $question['#']['units'][0]['#']['unit'];
 457             $qo->multiplier = array();
 458             foreach ($units as $unit) {
 459                 $qo->multiplier[] = $unit['#']['multiplier'][0]['#'];
 460                 $qo->unit[] = $unit['#']['unit_name'][0]['#'];
 461             }
 462         }
 463                 $datasets = $question['#']['dataset_definitions'][0]['#']['dataset_definition'];
 464                 $qo->dataset = array();
 465                 $qo->datasetindex= 0 ;
 466         foreach ($datasets as $dataset) {
 467             $qo->datasetindex++;
 468             $qo->dataset[$qo->datasetindex] = new stdClass();
 469             $qo->dataset[$qo->datasetindex]->status = $this->import_text( $dataset['#']['status'][0]['#']['text']);
 470             $qo->dataset[$qo->datasetindex]->name = $this->import_text( $dataset['#']['name'][0]['#']['text']);
 471             $qo->dataset[$qo->datasetindex]->type =  $dataset['#']['type'][0]['#'];
 472             $qo->dataset[$qo->datasetindex]->distribution = $this->import_text( $dataset['#']['distribution'][0]['#']['text']);
 473             $qo->dataset[$qo->datasetindex]->max = $this->import_text( $dataset['#']['maximum'][0]['#']['text']);
 474             $qo->dataset[$qo->datasetindex]->min = $this->import_text( $dataset['#']['minimum'][0]['#']['text']);
 475             $qo->dataset[$qo->datasetindex]->length = $this->import_text( $dataset['#']['decimals'][0]['#']['text']);
 476             $qo->dataset[$qo->datasetindex]->distribution = $this->import_text( $dataset['#']['distribution'][0]['#']['text']);
 477             $qo->dataset[$qo->datasetindex]->itemcount = $dataset['#']['itemcount'][0]['#'];
 478             $qo->dataset[$qo->datasetindex]->datasetitem = array();
 479             $qo->dataset[$qo->datasetindex]->itemindex = 0;
 480             $qo->dataset[$qo->datasetindex]->number_of_items=$dataset['#']['number_of_items'][0]['#'];
 481             $datasetitems = $dataset['#']['dataset_items'][0]['#']['dataset_item'];
 482             foreach ($datasetitems as $datasetitem) {
 483                 $qo->dataset[$qo->datasetindex]->itemindex++;
 484               $qo->dataset[$qo->datasetindex]->datasetitem[$qo->dataset[$qo->datasetindex]->itemindex] = new stdClass();
 485               $qo->dataset[$qo->datasetindex]->datasetitem[$qo->dataset[$qo->datasetindex]->itemindex]->itemnumber =  $datasetitem['#']['number'][0]['#']; //[0]['#']['number'][0]['#'] ; // [0]['numberitems'] ;//['#']['number'][0]['#'];// $datasetitems['#']['number'][0]['#'];
 486               $qo->dataset[$qo->datasetindex]->datasetitem[$qo->dataset[$qo->datasetindex]->itemindex]->value = $datasetitem['#']['value'][0]['#'] ;//$datasetitem['#']['value'][0]['#'];
 487           }
 488         }
 489
 490                 // echo "<pre>loaded qo";print_r($qo);echo "</pre>";
 491
 492         return $qo;
 493     }
 494
 495     /**
 496      * this is not a real question type. It's a dummy type used
 497      * to specify the import category
 498      * format is:
 499      * <question type="category">
 500      *     <category>tom/dick/harry</category>
 501      * </question>
 502      */
 503     function import_category( $question ) {
 504         $qo = new stdClass;
 505         $qo->qtype = 'category';
 506         $qo->category = $this->import_text($question['#']['category'][0]['#']['text']);
 507         return $qo;
 508     }
 509
 510     /**
 511      * parse the array of lines into an array of questions
 512      * this *could* burn memory - but it won't happen that much
 513      * so fingers crossed!
 514      * @param array lines array of lines from the input file
 515      * @return array (of objects) question objects
 516      */
 517     function readquestions($lines) {
 518         // we just need it as one big string
 519         $text = implode($lines, " ");
 520         unset( $lines );
 521
 522         // this converts xml to big nasty data structure
 523         // the 0 means keep white space as it is (important for markdown format)
 524         // print_r it if you want to see what it looks like!
 525         $xml = xmlize( $text, 0 );
 526
 527         // set up array to hold all our questions
 528         $questions = array();
 529
 530         // iterate through questions
 531         foreach ($xml['quiz']['#']['question'] as $question) {
 532             $question_type = $question['@']['type'];
 533             $questiontype = get_string( 'questiontype','quiz',$question_type );
 534
 535             if ($question_type=='multichoice') {
 536                 $qo = $this->import_multichoice( $question );
 537             }
 538             elseif ($question_type=='truefalse') {
 539                 $qo = $this->import_truefalse( $question );
 540             }
 541             elseif ($question_type=='shortanswer') {
 542                 $qo = $this->import_shortanswer( $question );
 543             }
 544             elseif ($question_type=='numerical') {
 545                 $qo = $this->import_numerical( $question );
 546             }
 547             elseif ($question_type=='description') {
 548                 $qo = $this->import_description( $question );
 549             }
 550             elseif ($question_type=='matching') {
 551                 $qo = $this->import_matching( $question );
 552             }
 553             elseif ($question_type=='cloze') {
 554                 $qo = $this->import_multianswer( $question );
 555             }
 556             elseif ($question_type=='essay') {
 557                 $qo = $this->import_essay( $question );
 558             }
 559             elseif ($question_type=='calculated') {
 560                 $qo = $this->import_calculated( $question );
 561             }
 562             elseif ($question_type=='category') {
 563                 $qo = $this->import_category( $question );
 564             }
 565             else {
 566                 // try for plugin support
 567                 // no default question, as the plugin can call
 568                 // import_headers() itself if it wants to
 569                 if (!$qo=$this->try_importing_using_qtypes( $question )) {
 570                     $notsupported = get_string( 'xmltypeunsupported','quiz',$question_type );
 571                     $this->error( $notsupported );
 572                     $qo = null;
 573                 }
 574             }
 575
 576             // stick the result in the $questions array
 577             if ($qo) {
 578                 $questions[] = $qo;
 579             }
 580         }
 581         return $questions;
 582     }
 583
 584     // EXPORT FUNCTIONS START HERE
 585
 586     function export_file_extension() {
 587     // override default type so extension is .xml
 588
 589         return ".xml";
 590     }
 591
 592
 593     /**
 594      * Turn the internal question code into a human readable form
 595      * (The code used to be numeric, but this remains as some of
 596      * the names don't match the new internal format)
 597      * @param mixed type_id Internal code
 598      * @return string question type string
 599      */
 600     function get_qtype( $type_id ) {
 601         switch( $type_id ) {
 602         case TRUEFALSE:
 603             $name = 'truefalse';
 604             break;
 605         case MULTICHOICE:
 606             $name = 'multichoice';
 607             break;
 608         case SHORTANSWER:
 609             $name = 'shortanswer';
 610             break;
 611         case NUMERICAL:
 612             $name = 'numerical';
 613             break;
 614         case MATCH:
 615             $name = 'matching';
 616             break;
 617         case DESCRIPTION:
 618             $name = 'description';
 619             break;
 620         case MULTIANSWER:
 621             $name = 'cloze';
 622             break;
 623         case ESSAY:
 624             $name = 'essay';
 625             break;
 626         case CALCULATED:
 627             $name = 'calculated';
 628             break;
 629         default:
 630             $name = false;
 631         }
 632         return $name;
 633     }
 634
 635     /**
 636      * Convert internal Moodle text format code into
 637      * human readable form
 638      * @param int id internal code
 639      * @return string format text
 640      */
 641     function get_format( $id ) {
 642         switch( $id ) {
 643         case 0:
 644             $name = "moodle_auto_format";
 645             break;
 646         case 1:
 647             $name = "html";
 648             break;
 649         case 2:
 650             $name = "plain_text";
 651             break;
 652         case 3:
 653             $name = "wiki_like";
 654             break;
 655         case 4:
 656             $name = "markdown";
 657             break;
 658         default:
 659             $name = "unknown";
 660         }
 661         return $name;
 662     }
 663
 664     /**
 665      * Convert internal single question code into
 666      * human readable form
 667      * @param int id single question code
 668      * @return string single question string
 669      */
 670     function get_single( $id ) {
 671         switch( $id ) {
 672         case 0:
 673             $name = "false";
 674             break;
 675         case 1:
 676             $name = "true";
 677             break;
 678         default:
 679             $name = "unknown";
 680         }
 681         return $name;
 682     }
 683
 684     /**
 685      * generates <text></text> tags, processing raw text therein
 686      * @param int ilev the current indent level
 687      * @param boolean short stick it on one line
 688      * @return string formatted text
 689      */
 690     function writetext( $raw, $ilev=0, $short=true) {
 691         $indent = str_repeat( "  ",$ilev );
 692
 693         // encode the text to 'disguise' HTML content
 694         $raw = htmlspecialchars( $raw );
 695
 696         if ($short) {
 697             $xml = "$indent<text>$raw</text>\n";
 698         }
 699         else {
 700             $xml = "$indent<text>\n$raw\n$indent</text>\n";
 701         }
 702
 703         return $xml;
 704     }
 705
 706     function xmltidy( $content ) {
 707         // can only do this if tidy is installed
 708         if (extension_loaded('tidy')) {
 709             $config = array( 'input-xml'=>true, 'output-xml'=>true, 'indent'=>true, 'wrap'=>0 );
 710             $tidy = new tidy;
 711             $tidy->parseString($content, $config, 'utf8');
 712             $tidy->cleanRepair();
 713             return $tidy->value;
 714         }
 715         else {
 716             return $content;
 717         }
 718     }
 719
 720
 721     function presave_process( $content ) {
 722     // override method to allow us to add xml headers and footers
 723
 724         // add the xml headers and footers
 725         $content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" .
 726                        "<quiz>\n" .
 727                        $content . "\n" .
 728                        "</quiz>";
 729
 730         // make the xml look nice
 731         $content = $this->xmltidy( $content );
 732
 733         return $content;
 734     }
 735
 736     /**
 737      * Include an image encoded in base 64
 738      * @param string imagepath The location of the image file
 739      * @return string xml code segment
 740      */
 741     function writeimage( $imagepath ) {
 742         global $CFG;
 743
 744         if (empty($imagepath)) {
 745             return '';
 746         }
 747
 748         $courseid = $this->course->id;
 749         if (!$binary = file_get_contents( "{$CFG->dataroot}/$courseid/$imagepath" )) {
 750             return '';
 751         }
 752
 753         $content = "    <image_base64>\n".addslashes(base64_encode( $binary ))."\n".
 754             "\n    </image_base64>\n";
 755         return $content;
 756     }
 757
 758     /**
 759      * Turns question into an xml segment
 760      * @param array question question array
 761      * @return string xml segment
 762      */
 763     function writequestion( $question ) {
 764     global $CFG,$QTYPES;
 765         // initial string;
 766         $expout = "";
 767
 768         // add comment
 769         $expout .= "\n\n<!-- question: $question->id  -->\n";
 770
 771         // check question type
 772         if (!$question_type = $this->get_qtype( $question->qtype )) {
 773             // must be a plugin then, so just accept the name supplied
 774             $question_type = $question->qtype;
 775         }
 776
 777         // add opening tag
 778         // generates specific header for Cloze and category type question
 779         if ($question->qtype == 'category') {
 780             $categorypath = $this->writetext( $question->category );
 781             $expout .= "  <question type=\"category\">\n";
 782             $expout .= "    <category>\n";
 783             $expout .= "        $categorypath\n";
 784             $expout .= "    </category>\n";
 785             $expout .= "  </question>\n";
 786             return $expout;
 787         }
 788         elseif ($question->qtype != MULTIANSWER) {
 789             // for all question types except Close
 790             $name_text = $this->writetext( $question->name );
 791             $qtformat = $this->get_format($question->questiontextformat);
 792             $question_text = $this->writetext( $question->questiontext );
 793             $generalfeedback = $this->writetext( $question->generalfeedback );
 794             $expout .= "  <question type=\"$question_type\">\n";
 795             $expout .= "    <name>$name_text</name>\n";
 796             $expout .= "    <questiontext format=\"$qtformat\">\n";
 797             $expout .= $question_text;
 798             $expout .= "    </questiontext>\n";
 799             $expout .= "    <image>{$question->image}</image>\n";
 800             $expout .= $this->writeimage($question->image);
 801             $expout .= "    <generalfeedback>\n";
 802             $expout .= $generalfeedback;
 803             $expout .= "    </generalfeedback>\n";
 804             $expout .= "    <defaultgrade>{$question->defaultgrade}</defaultgrade>\n";
 805             $expout .= "    <penalty>{$question->penalty}</penalty>\n";
 806             $expout .= "    <hidden>{$question->hidden}</hidden>\n";
 807         }
 808         else {
 809             // for Cloze type only
 810             $name_text = $this->writetext( $question->name );
 811             $question_text = $this->writetext( $question->questiontext );
 812             $generalfeedback = $this->writetext( $question->generalfeedback );
 813             $expout .= "  <question type=\"$question_type\">\n";
 814             $expout .= "    <name>$name_text</name>\n";
 815             $expout .= "    <questiontext>\n";
 816             $expout .= $question_text;
 817             $expout .= "    </questiontext>\n";
 818             $expout .= "    <generalfeedback>\n";
 819             $expout .= $generalfeedback;
 820             $expout .= "    </generalfeedback>\n";
 821         }
 822
 823         if (!empty($question->options->shuffleanswers)) {
 824             $expout .= "    <shuffleanswers>{$question->options->shuffleanswers}</shuffleanswers>\n";
 825         }
 826         else {
 827             $expout .= "    <shuffleanswers>0</shuffleanswers>\n";
 828         }
 829
 830         // output depends on question type
 831         switch($question->qtype) {
 832         case 'category':
 833             // not a qtype really - dummy used for category switching
 834             break;
 835         case TRUEFALSE:
 836             foreach ($question->options->answers as $answer) {
 837                 $fraction_pc = round( $answer->fraction * 100 );
 838                 if ($answer->id == $question->options->trueanswer) {
 839                     $answertext = 'true';
 840                 } else {
 841                     $answertext = 'false';
 842                 }
 843                 $expout .= "    <answer fraction=\"$fraction_pc\">\n";
 844                 $expout .= $this->writetext($answertext, 3) . "\n";
 845                 $expout .= "      <feedback>\n";
 846                 $expout .= $this->writetext( $answer->feedback,4,false );
 847                 $expout .= "      </feedback>\n";
 848                 $expout .= "    </answer>\n";
 849             }
 850             break;
 851         case MULTICHOICE:
 852             $expout .= "    <single>".$this->get_single($question->options->single)."</single>\n";
 853             $expout .= "    <shuffleanswers>".$this->get_single($question->options->shuffleanswers)."</shuffleanswers>\n";
 854             $expout .= "    <correctfeedback>".$this->writetext($question->options->correctfeedback, 3)."</correctfeedback>\n";
 855             $expout .= "    <partiallycorrectfeedback>".$this->writetext($question->options->partiallycorrectfeedback, 3)."</partiallycorrectfeedback>\n";
 856             $expout .= "    <incorrectfeedback>".$this->writetext($question->options->incorrectfeedback, 3)."</incorrectfeedback>\n";
 857             $expout .= "    <answernumbering>{$question->options->answernumbering}</answernumbering>\n";
 858             foreach($question->options->answers as $answer) {
 859                 $percent = $answer->fraction * 100;
 860                 $expout .= "      <answer fraction=\"$percent\">\n";
 861                 $expout .= $this->writetext( $answer->answer,4,false );
 862                 $expout .= "      <feedback>\n";
 863                 $expout .= $this->writetext( $answer->feedback,5,false );
 864                 $expout .= "      </feedback>\n";
 865                 $expout .= "    </answer>\n";
 866                 }
 867             break;
 868         case SHORTANSWER:
 869         $expout .= "    <usecase>{$question->options->usecase}</usecase>\n ";
 870             foreach($question->options->answers as $answer) {
 871                 $percent = 100 * $answer->fraction;
 872                 $expout .= "    <answer fraction=\"$percent\">\n";
 873                 $expout .= $this->writetext( $answer->answer,3,false );
 874                 $expout .= "      <feedback>\n";
 875                 $expout .= $this->writetext( $answer->feedback,4,false );
 876                 $expout .= "      </feedback>\n";
 877                 $expout .= "    </answer>\n";
 878             }
 879             break;
 880         case NUMERICAL:
 881             foreach ($question->options->answers as $answer) {
 882                 $tolerance = $answer->tolerance;
 883                 $percent = 100 * $answer->fraction;
 884                 $expout .= "<answer fraction=\"$percent\">\n";
 885                 // <text> tags are an added feature, old filed won't have them
 886                 $expout .= "    <text>{$answer->answer}</text>\n";
 887                 $expout .= "    <tolerance>$tolerance</tolerance>\n";
 888                 $expout .= "    <feedback>".$this->writetext( $answer->feedback )."</feedback>\n";
 889                 // fraction tag is deprecated
 890                 // $expout .= "    <fraction>{$answer->fraction}</fraction>\n";
 891                 $expout .= "</answer>\n";
 892             }
 893
 894             $units = $question->options->units;
 895             if (count($units)) {
 896                 $expout .= "<units>\n";
 897                 foreach ($units as $unit) {
 898                     $expout .= "  <unit>\n";
 899                     $expout .= "    <multiplier>{$unit->multiplier}</multiplier>\n";
 900                     $expout .= "    <unit_name>{$unit->unit}</unit_name>\n";
 901                     $expout .= "  </unit>\n";
 902                 }
 903                 $expout .= "</units>\n";
 904             }
 905             break;
 906         case MATCH:
 907             foreach($question->options->subquestions as $subquestion) {
 908                 $expout .= "<subquestion>\n";
 909                 $expout .= $this->writetext( $subquestion->questiontext );
 910                 $expout .= "<answer>".$this->writetext( $subquestion->answertext )."</answer>\n";
 911                 $expout .= "</subquestion>\n";
 912             }
 913             break;
 914         case DESCRIPTION:
 915             // nothing more to do for this type
 916             break;
 917         case MULTIANSWER:
 918             $a_count=1;
 919             foreach($question->options->questions as $question) {
 920                 $thispattern = addslashes("{#".$a_count."}");
 921                 $thisreplace = $question->questiontext;
 922                 $expout=ereg_replace($thispattern, $thisreplace, $expout );
 923                 $a_count++;
 924             }
 925         break;
 926         case ESSAY:
 927             foreach ($question->options->answers as $answer) {
 928                 $percent = 100 * $answer->fraction;
 929                 $expout .= "<answer fraction=\"$percent\">\n";
 930                 $expout .= "    <feedback>".$this->writetext( $answer->feedback )."</feedback>\n";
 931                 // fraction tag is deprecated
 932                 // $expout .= "    <fraction>{$answer->fraction}</fraction>\n";
 933                 $expout .= "</answer>\n";
 934             }
 935
 936             break;
 937         case CALCULATED:
 938             foreach ($question->options->answers as $answer) {
 939                 $tolerance = $answer->tolerance;
 940                 $tolerancetype = $answer->tolerancetype;
 941                 $correctanswerlength= $answer->correctanswerlength ;
 942                 $correctanswerformat= $answer->correctanswerformat;
 943                 $percent = 100 * $answer->fraction;
 944                 $expout .= "<answer fraction=\"$percent\">\n";
 945                 // "<text/>" tags are an added feature, old files won't have them
 946                 $expout .= "    <text>{$answer->answer}</text>\n";
 947                 $expout .= "    <tolerance>$tolerance</tolerance>\n";
 948                 $expout .= "    <tolerancetype>$tolerancetype</tolerancetype>\n";
 949                 $expout .= "    <correctanswerformat>$correctanswerformat</correctanswerformat>\n";
 950                 $expout .= "    <correctanswerlength>$correctanswerformat</correctanswerlength>\n";
 951                 $expout .= "    <feedback>".$this->writetext( $answer->feedback )."</feedback>\n";
 952                 $expout .= "</answer>\n";
 953             }
 954             $units = $question->options->units;
 955             if (count($units)) {
 956                 $expout .= "<units>\n";
 957                 foreach ($units as $unit) {
 958                     $expout .= "  <unit>\n";
 959                     $expout .= "    <multiplier>{$unit->multiplier}</multiplier>\n";
 960                     $expout .= "    <unit_name>{$unit->unit}</unit_name>\n";
 961                     $expout .= "  </unit>\n";
 962                 }
 963                 $expout .= "</units>\n";
 964              }
 965         //echo "<pre> question calc";print_r($question);echo "</pre>";
 966         //First, we a new function to get all the   data itmes in the database
 967          //   $question_datasetdefs =$QTYPES['calculated']->get_datasets_for_export ($question);
 968         //    echo "<pre> question defs";print_r($question_datasetdefs);echo "</pre>";
 969         //If there are question_datasets
 970             if( isset($question->options->datasets)&&count($question->options->datasets)){// there should be
 971                 $expout .= "<dataset_definitions>\n";
 972                 foreach ($question->options->datasets as $def) {
 973                     $expout .= "<dataset_definition>\n";
 974                     $expout .= "    <status>".$this->writetext($def->status)."</status>\n";
 975                     $expout .= "    <name>".$this->writetext($def->name)."</name>\n";
 976                     $expout .= "    <type>calculated</type>\n";
 977                     $expout .= "    <distribution>".$this->writetext($def->distribution)."</distribution>\n";
 978                     $expout .= "    <minimum>".$this->writetext($def->minimum)."</minimum>\n";
 979                     $expout .= "    <maximum>".$this->writetext($def->maximum)."</maximum>\n";
 980                     $expout .= "    <decimals>".$this->writetext($def->decimals)."</decimals>\n";
 981                     $expout .= "    <itemcount>$def->itemcount</itemcount>\n";
 982                     if ($def->itemcount > 0 ) {
 983                         $expout .= "    <dataset_items>\n";
 984                         foreach ($def->items as $item ){
 985                               $expout .= "        <dataset_item>\n";
 986                               $expout .= "           <number>".$item->itemnumber."</number>\n";
 987                               $expout .= "           <value>".$item->value."</value>\n";
 988                               $expout .= "        </dataset_item>\n";
 989                         }
 990                         $expout .= "    </dataset_items>\n";
 991                         $expout .= "    <number_of_items>".$def-> number_of_items."</number_of_items>\n";
 992                      }
 993                     $expout .= "</dataset_definition>\n";
 994                 }
 995                 $expout .= "</dataset_definitions>\n";
 996             }
 997             break;
 998         default:
 999             // try support by optional plugin
1000             if (!$data = $this->try_exporting_using_qtypes( $question->qtype, $question )) {
1001                 error( "Unsupported question type $question->qtype" );
1002             }
1003             $expout .= $data;
1004         }
1005
1006         // close the question tag
1007         $expout .= "</question>\n";
1008
1009         return $expout;
1010     }
1011 }
1012
1013 ?>