question/restorelib.php

   1 <?php //$Id$
   2     //This php script contains all the stuff to restore questions
   3
   4 // Todo:
   5     // the restoration of the parent and sortorder fields in the category table needs
   6     // a lot more thought. We should probably use a library function to add the category
   7     // rather than just writing it to the database
   8
   9     // whereever it says "/// We have to recode the .... field" we should put in a check
  10     // to see if the recoding was successful and throw an appropriate error otherwise
  11
  12 //This is the "graphical" structure of the question database:
  13     //To see, put your terminal to 160cc
  14
  15     // The following holds student-independent information about the questions
  16     //
  17     //          question_categories
  18     //             (CL,pk->id)
  19     //                  |
  20     //                  |
  21     //                  |.......................................
  22     //                  |                                      .
  23     //                  |                                      .
  24     //                  |    -------question_datasets------    .
  25     //                  |    |  (CL,pk->id,fk->question,  |    .
  26     //                  |    |   fk->dataset_definition)  |    .
  27     //                  |    |                            |    .
  28     //                  |    |                            |    .
  29     //                  |    |                            |    .
  30     //                  |    |                    question_dataset_definitions
  31     //                  |    |                      (CL,pk->id,fk->category)
  32     //              question                                   |
  33     //        (CL,pk->id,fk->category,files)                   |
  34     //                  |                             question_dataset_items
  35     //                  |                          (CL,pk->id,fk->definition)
  36     //                  |                                                                                                           question_rqp_type
  37     //                  |                                                                                                            (SL,pk->id)
  38     //                  |                                                                                                                  |
  39     //             --------------------------------------------------------------------------------------------------------------          |
  40     //             |             |              |              |                       |                  |                     |        question_rqp
  41     //             |             |              |              |                       |                  |                     |--(CL,pk->id,fk->question)
  42     //             |             |              |              |             question_calculated          |                     |
  43     //      question_truefalse   |     question_multichoice    |          (CL,pl->id,fk->question)        |                     |
  44     // (CL,pk->id,fk->question)  |   (CL,pk->id,fk->question)  |                       .                  |                     |  question_randomsamatch
  45     //             .             |              .              |                       .                  |                     |--(CL,pk->id,fk->question)
  46     //             .    question_shortanswer    .      question_numerical              .         question_multianswer.          |
  47     //             .  (CL,pk->id,fk->question)  .  (CL,pk->id,fk->question)            .        (CL,pk->id,fk->question)        |
  48     //             .             .              .              .                       .                  .                     |       question_match
  49     //             .             .              .              .                       .                  .                     |--(CL,pk->id,fk->question)
  50     //             .             .              .              .                       .                  .                     |             .
  51     //             .             .              .              .                       .                  .                     |             .
  52     //             .             .              .              .                       .                  .                     |             .
  53     //             .             .              .              .                       .                  .                     |    question_match_sub
  54     //             ........................................................................................                     |--(CL,pk->id,fk->question)
  55     //                                                   .                                                                      |
  56     //                                                   .                                                                      |
  57     //                                                   .                                                                      |  question_numerical_units
  58     //                                             question_answers                                                             |--(CL,pk->id,fk->question)
  59     //                                         (CL,pk->id,fk->question)----------------------------------------------------------
  60     //
  61     //
  62     // The following holds the information about student interaction with the questions
  63     //
  64     //             question_sessions
  65     //      (UL,pk->id,fk->attempt,question)
  66     //                    .
  67     //                    .
  68     //             question_states
  69     //       (UL,pk->id,fk->attempt,question)
  70     //                |
  71     //           question_rqp_states
  72     //        (UL,pk->id,fk->stateid)
  73     //
  74     // Meaning: pk->primary key field of the table
  75     //          fk->foreign key to link with parent
  76     //          nt->nested field (recursive data)
  77     //          SL->site level info
  78     //          CL->course level info
  79     //          UL->user level info
  80     //          files->table may have files
  81     //
  82     //-----------------------------------------------------------
  83
  84     include_once($CFG->libdir.'/questionlib.php');
  85
  86     function restore_question_categories($category,$restore) {
  87
  88         global $CFG;
  89
  90         $status = true;
  91
  92         //Hook to call Moodle < 1.5 Quiz Restore
  93         if ($restore->backup_version < 2005043000) {
  94             include_once($CFG->dirroot.'/mod/quiz/restorelibpre15.php');
  95             return quiz_restore_pre15_question_categories($category,$restore);
  96         }
  97
  98         //Get record from backup_ids
  99         $data = backup_getid($restore->backup_unique_code,"question_categories",$category->id);
 100
 101         if ($data) {
 102             //Now get completed xmlized object
 103             $info = $data->info;
 104             //traverse_xmlize($info);                                                                     //Debug
 105             //print_object ($GLOBALS['traverse_array']);                                                  //Debug
 106             //$GLOBALS['traverse_array']="";                                                              //Debug
 107
 108             //Now, build the question_categories record structure
 109             $question_cat = new stdClass;
 110             $question_cat->course = $restore->course_id;
 111             $question_cat->name = backup_todb($info['QUESTION_CATEGORY']['#']['NAME']['0']['#']);
 112             $question_cat->info = backup_todb($info['QUESTION_CATEGORY']['#']['INFO']['0']['#']);
 113             $question_cat->publish = backup_todb($info['QUESTION_CATEGORY']['#']['PUBLISH']['0']['#']);
 114             $question_cat->stamp = backup_todb($info['QUESTION_CATEGORY']['#']['STAMP']['0']['#']);
 115             $question_cat->parent = backup_todb($info['QUESTION_CATEGORY']['#']['PARENT']['0']['#']);
 116             $question_cat->sortorder = backup_todb($info['QUESTION_CATEGORY']['#']['SORTORDER']['0']['#']);
 117
 118             if ($catfound = restore_get_best_question_category($question_cat, $restore->course_id)) {
 119                 $newid = $catfound;
 120             } else {
 121                 if (!$question_cat->stamp) {
 122                     $question_cat->stamp = make_unique_id_code();
 123                 }
 124                 $newid = insert_record ("question_categories",$question_cat);
 125             }
 126
 127             //Do some output
 128             if ($newid) {
 129                 if (!defined('RESTORE_SILENTLY')) {
 130                     echo "<li>".get_string('category', 'quiz')." \"".$question_cat->name."\"<br />";
 131                 }
 132             } else {
 133                 //We must never arrive here !!
 134                 if (!defined('RESTORE_SILENTLY')) {
 135                     echo "<li>".get_string('category', 'quiz')." \"".$question_cat->name."\" Error!<br />";
 136                 }
 137                 $status = false;
 138             }
 139             backup_flush(300);
 140
 141             //Here category has been created or selected, so save results in backup_ids and start with questions
 142             if ($newid and $status) {
 143                 //We have the newid, update backup_ids
 144                 backup_putid($restore->backup_unique_code,"question_categories",
 145                              $category->id, $newid);
 146                 //Now restore question
 147                 $status = restore_questions ($category->id, $newid,$info,$restore);
 148             } else {
 149                 $status = false;
 150             }
 151             if (!defined('RESTORE_SILENTLY')) {
 152                 echo '</li>';
 153             }
 154         } else {
 155             echo 'Could not get backup info for question category'. $category->id;
 156         }
 157
 158         return $status;
 159     }
 160
 161     function restore_questions ($old_category_id,$new_category_id,$info,$restore) {
 162
 163         global $CFG, $QTYPES;
 164
 165         $status = true;
 166         $restored_questions = array();
 167
 168         //Get the questions array
 169         if (!empty($info['QUESTION_CATEGORY']['#']['QUESTIONS'])) {
 170             $questions = $info['QUESTION_CATEGORY']['#']['QUESTIONS']['0']['#']['QUESTION'];
 171         } else {
 172             $questions = array();
 173         }
 174
 175         //Iterate over questions
 176         for($i = 0; $i < sizeof($questions); $i++) {
 177             $que_info = $questions[$i];
 178             //traverse_xmlize($que_info);                                                                 //Debug
 179             //print_object ($GLOBALS['traverse_array']);                                                  //Debug
 180             //$GLOBALS['traverse_array']="";                                                              //Debug
 181
 182             //We'll need this later!!
 183             $oldid = backup_todb($que_info['#']['ID']['0']['#']);
 184
 185             //Now, build the question record structure
 186             $question = new object;
 187             $question->category = $new_category_id;
 188             $question->parent = backup_todb($que_info['#']['PARENT']['0']['#']);
 189             $question->name = backup_todb($que_info['#']['NAME']['0']['#']);
 190             $question->questiontext = backup_todb($que_info['#']['QUESTIONTEXT']['0']['#']);
 191             $question->questiontextformat = backup_todb($que_info['#']['QUESTIONTEXTFORMAT']['0']['#']);
 192             $question->image = backup_todb($que_info['#']['IMAGE']['0']['#']);
 193             if (array_key_exists('GENERALFEEDBACK', $que_info['#'])) {
 194                 $question->generalfeedback = backup_todb($que_info['#']['GENERALFEEDBACK']['0']['#']);
 195             } else {
 196                 $question->generalfeedback = '';
 197             }
 198             $question->defaultgrade = backup_todb($que_info['#']['DEFAULTGRADE']['0']['#']);
 199             $question->penalty = backup_todb($que_info['#']['PENALTY']['0']['#']);
 200             $question->qtype = backup_todb($que_info['#']['QTYPE']['0']['#']);
 201             $question->length = backup_todb($que_info['#']['LENGTH']['0']['#']);
 202             $question->stamp = backup_todb($que_info['#']['STAMP']['0']['#']);
 203             $question->version = backup_todb($que_info['#']['VERSION']['0']['#']);
 204             $question->hidden = backup_todb($que_info['#']['HIDDEN']['0']['#']);
 205
 206             if ($restore->backup_version < 2006032200) {
 207                 // The qtype was an integer that now needs to be converted to the name
 208                 $qtypenames = array(1=>'shortanswer',2=>'truefalse',3=>'multichoice',4=>'random',5=>'match',
 209                  6=>'randomsamatch',7=>'description',8=>'numerical',9=>'multianswer',10=>'calculated',
 210                  11=>'rqp',12=>'essay');
 211                 $question->qtype = $qtypenames[$question->qtype];
 212             }
 213
 214             //Check if the question exists
 215             //by category, stamp, and version
 216             $question_exists = get_record ("question","category",$question->category,
 217                                                  "stamp",$question->stamp,"version",$question->version);
 218
 219             //If the question exists, only record its id
 220             if ($question_exists) {
 221                 $newid = $question_exists->id;
 222                 $creatingnewquestion = false;
 223             //Else, create a new question
 224             } else {
 225                 //The structure is equal to the db, so insert the question
 226                 $newid = insert_record ("question",$question);
 227                 $creatingnewquestion = true;
 228             }
 229
 230             //Save newid to backup tables
 231             if ($newid) {
 232                 //We have the newid, update backup_ids
 233                 backup_putid($restore->backup_unique_code,"question",$oldid,
 234                              $newid);
 235             }
 236
 237             $restored_questions[$i] = new stdClass;
 238             $restored_questions[$i]->newid  = $newid;
 239             $restored_questions[$i]->oldid  = $oldid;
 240             $restored_questions[$i]->qtype  = $question->qtype;
 241             $restored_questions[$i]->parent  = $question->parent;
 242             $restored_questions[$i]->is_new = $creatingnewquestion;
 243         }
 244
 245         // Loop again, now all the question id mappings exist, so everything can
 246         // be restored.
 247         for($i = 0; $i < sizeof($questions); $i++) {
 248             $que_info = $questions[$i];
 249
 250             $newid = $restored_questions[$i]->newid;
 251             $oldid = $restored_questions[$i]->oldid;
 252
 253             $question = new object;
 254             $question->qtype = $restored_questions[$i]->qtype;
 255             $question->parent = $restored_questions[$i]->parent;
 256
 257
 258             //If it's a new question in the DB, restore it
 259             if ($restored_questions[$i]->is_new) {
 260
 261                 ////We have to recode the parent field
 262                 if ($question->parent) {
 263                     if ($parent = backup_getid($restore->backup_unique_code,"question",$question->parent)) {
 264                         $question->parent = $parent->new_id;
 265                     } elseif ($question->parent = $oldid) {
 266                         $question->parent = $newid;
 267                     } else {
 268                         echo 'Could not recode parent '.$question->parent.' for question '.$oldid.'<br />';
 269                     }
 270                 }
 271
 272                 //Now, restore every question_answers in this question
 273                 $status = question_restore_answers($oldid,$newid,$que_info,$restore);
 274                 // Restore questiontype specific data
 275                 if (array_key_exists($question->qtype, $QTYPES)) {
 276                     $status = $QTYPES[$question->qtype]->restore($oldid,$newid,$que_info,$restore);
 277                 } else {
 278                     echo 'Unknown question type '.$question->qtype.' for question '.$oldid.'<br />';
 279                     $status = false;
 280                 }
 281             } else {
 282                 //We are NOT creating the question, but we need to know every question_answers
 283                 //map between the XML file and the database to be able to restore the states
 284                 //in each attempt.
 285                 $status = question_restore_map_answers($oldid,$newid,$que_info,$restore);
 286                 // Do the questiontype specific mapping
 287                 if (array_key_exists($question->qtype, $QTYPES)) {
 288                     $status = $QTYPES[$question->qtype]->restore_map($oldid,$newid,$que_info,$restore);
 289                 } else {
 290                     echo 'Unknown question type '.$question->qtype.' for question '.$oldid.'<br />';
 291                     $status = false;
 292                 }
 293             }
 294
 295             //Do some output
 296             if (($i+1) % 2 == 0) {
 297                 if (!defined('RESTORE_SILENTLY')) {
 298                     echo ".";
 299                     if (($i+1) % 40 == 0) {
 300                         echo "<br />";
 301                     }
 302                 }
 303                 backup_flush(300);
 304             }
 305         }
 306         return $status;
 307     }
 308
 309     function question_restore_answers ($old_question_id,$new_question_id,$info,$restore) {
 310
 311         global $CFG;
 312
 313         $status = true;
 314         $qtype = backup_todb($info['#']['QTYPE']['0']['#']);
 315
 316         //Get the answers array
 317         if (isset($info['#']['ANSWERS']['0']['#']['ANSWER'])) {
 318             $answers = $info['#']['ANSWERS']['0']['#']['ANSWER'];
 319
 320             //Iterate over answers
 321             for($i = 0; $i < sizeof($answers); $i++) {
 322                 $ans_info = $answers[$i];
 323                 //traverse_xmlize($ans_info);                                                                 //Debug
 324                 //print_object ($GLOBALS['traverse_array']);                                                  //Debug
 325                 //$GLOBALS['traverse_array']="";                                                              //Debug
 326
 327                 //We'll need this later!!
 328                 $oldid = backup_todb($ans_info['#']['ID']['0']['#']);
 329
 330                 //Now, build the question_answers record structure
 331                 $answer = new stdClass;
 332                 $answer->question = $new_question_id;
 333                 $answer->answer = backup_todb($ans_info['#']['ANSWER_TEXT']['0']['#']);
 334                 $answer->fraction = backup_todb($ans_info['#']['FRACTION']['0']['#']);
 335                 $answer->feedback = backup_todb($ans_info['#']['FEEDBACK']['0']['#']);
 336
 337                 // Update 'match everything' answers for numerical questions coming from old backup files.
 338                 if ($qtype == 'numerical' && $answer->answer == '') {
 339                     $answer->answer = '*';
 340                 }
 341
 342                 //The structure is equal to the db, so insert the question_answers
 343                 $newid = insert_record ("question_answers",$answer);
 344
 345                 //Do some output
 346                 if (($i+1) % 50 == 0) {
 347                     if (!defined('RESTORE_SILENTLY')) {
 348                         echo ".";
 349                         if (($i+1) % 1000 == 0) {
 350                             echo "<br />";
 351                         }
 352                     }
 353                     backup_flush(300);
 354                 }
 355
 356                 if ($newid) {
 357                     //We have the newid, update backup_ids
 358                     backup_putid($restore->backup_unique_code,"question_answers",$oldid,
 359                                  $newid);
 360                 } else {
 361                     $status = false;
 362                 }
 363             }
 364         }
 365
 366         return $status;
 367     }
 368
 369     function question_restore_map_answers ($old_question_id,$new_question_id,$info,$restore) {
 370
 371         global $CFG;
 372
 373         $status = true;
 374
 375         if (!isset($info['#']['ANSWERS'])) {    // No answers in this question (eg random)
 376             return $status;
 377         }
 378
 379         //Get the answers array
 380         $answers = $info['#']['ANSWERS']['0']['#']['ANSWER'];
 381
 382         //Iterate over answers
 383         for($i = 0; $i < sizeof($answers); $i++) {
 384             $ans_info = $answers[$i];
 385             //traverse_xmlize($ans_info);                                                                 //Debug
 386             //print_object ($GLOBALS['traverse_array']);                                                  //Debug
 387             //$GLOBALS['traverse_array']="";                                                              //Debug
 388
 389             //We'll need this later!!
 390             $oldid = backup_todb($ans_info['#']['ID']['0']['#']);
 391
 392             //Now, build the question_answers record structure
 393             $answer->question = $new_question_id;
 394             $answer->answer = backup_todb($ans_info['#']['ANSWER_TEXT']['0']['#']);
 395             $answer->fraction = backup_todb($ans_info['#']['FRACTION']['0']['#']);
 396             $answer->feedback = backup_todb($ans_info['#']['FEEDBACK']['0']['#']);
 397
 398             //If we are in this method is because the question exists in DB, so its
 399             //answers must exist too.
 400             //Now, we are going to look for that answer in DB and to create the
 401             //mappings in backup_ids to use them later where restoring states (user level).
 402
 403             //Get the answer from DB (by question and answer)
 404             $db_answer = get_record ("question_answers","question",$new_question_id,
 405                                                     "answer",$answer->answer);
 406
 407             //Do some output
 408             if (($i+1) % 50 == 0) {
 409                 if (!defined('RESTORE_SILENTLY')) {
 410                     echo ".";
 411                     if (($i+1) % 1000 == 0) {
 412                         echo "<br />";
 413                     }
 414                 }
 415                 backup_flush(300);
 416             }
 417
 418             if ($db_answer) {
 419                 //We have the database answer, update backup_ids
 420                 backup_putid($restore->backup_unique_code,"question_answers",$oldid,
 421                              $db_answer->id);
 422             } else {
 423                 $status = false;
 424             }
 425         }
 426
 427         return $status;
 428     }
 429
 430     function question_restore_numerical_units($old_question_id,$new_question_id,$info,$restore) {
 431
 432         global $CFG;
 433
 434         $status = true;
 435
 436         //Get the numerical array
 437         if (!empty($info['#']['NUMERICAL_UNITS'])) {
 438             $numerical_units = $info['#']['NUMERICAL_UNITS']['0']['#']['NUMERICAL_UNIT'];
 439         } else {
 440             $numerical_units = array();
 441         }
 442
 443         //Iterate over numerical_units
 444         for($i = 0; $i < sizeof($numerical_units); $i++) {
 445             $nu_info = $numerical_units[$i];
 446             //traverse_xmlize($nu_info);                                                                  //Debug
 447             //print_object ($GLOBALS['traverse_array']);                                                  //Debug
 448             //$GLOBALS['traverse_array']="";                                                              //Debug
 449
 450             // Check to see if this until already exists in the database, which it might, for
 451             // Historical reasons.
 452             $unit = backup_todb($nu_info['#']['UNIT']['0']['#']);
 453             if (!record_exists('question_numerical_units', 'question', $new_question_id, 'unit', $unit)) {
 454
 455                 //Now, build the question_numerical_UNITS record structure.
 456                 $numerical_unit = new stdClass;
 457                 $numerical_unit->question = $new_question_id;
 458                 $numerical_unit->multiplier = backup_todb($nu_info['#']['MULTIPLIER']['0']['#']);
 459                 $numerical_unit->unit = $unit;
 460
 461                 //The structure is equal to the db, so insert the question_numerical_units
 462                 $newid = insert_record("question_numerical_units", $numerical_unit);
 463
 464                 if (!$newid) {
 465                     $status = false;
 466                 }
 467             }
 468         }
 469
 470         return $status;
 471     }
 472
 473     function question_restore_dataset_definitions ($old_question_id,$new_question_id,$info,$restore) {
 474
 475         global $CFG;
 476
 477         $status = true;
 478
 479         //Get the dataset_definitions array
 480         $dataset_definitions = $info['#']['DATASET_DEFINITIONS']['0']['#']['DATASET_DEFINITION'];
 481
 482         //Iterate over dataset_definitions
 483         for($i = 0; $i < sizeof($dataset_definitions); $i++) {
 484             $dd_info = $dataset_definitions[$i];
 485             //traverse_xmlize($dd_info);                                                                  //Debug
 486             //print_object ($GLOBALS['traverse_array']);                                                  //Debug
 487             //$GLOBALS['traverse_array']="";                                                              //Debug
 488
 489             //Now, build the question_dataset_DEFINITION record structure
 490             $dataset_definition = new stdClass;
 491             $dataset_definition->category = backup_todb($dd_info['#']['CATEGORY']['0']['#']);
 492             $dataset_definition->name = backup_todb($dd_info['#']['NAME']['0']['#']);
 493             $dataset_definition->type = backup_todb($dd_info['#']['TYPE']['0']['#']);
 494             $dataset_definition->options = backup_todb($dd_info['#']['OPTIONS']['0']['#']);
 495             $dataset_definition->itemcount = backup_todb($dd_info['#']['ITEMCOUNT']['0']['#']);
 496
 497             //We have to recode the category field (only if the category != 0)
 498             if ($dataset_definition->category != 0) {
 499                 $category = backup_getid($restore->backup_unique_code,"question_categories",$dataset_definition->category);
 500                 if ($category) {
 501                     $dataset_definition->category = $category->new_id;
 502                 } else {
 503                     echo 'Could not recode category id '.$dataset_definition->category.' for dataset definition'.$dataset_definition->name.'<br />';
 504                 }
 505             }
 506
 507             //Now, we hace to decide when to create the new records or reuse an existing one
 508             $create_definition = false;
 509
 510             //If the dataset_definition->category = 0, it's a individual question dataset_definition, so we'll create it
 511             if ($dataset_definition->category == 0) {
 512                 $create_definition = true;
 513             } else {
 514                 //The category isn't 0, so it's a category question dataset_definition, we have to see if it exists
 515                 //Look for a definition with the same category, name and type
 516                 if ($definitionrec = get_record_sql("SELECT d.*
 517                                                      FROM {$CFG->prefix}question_dataset_definitions d
 518                                                      WHERE d.category = '$dataset_definition->category' AND
 519                                                            d.name = '$dataset_definition->name' AND
 520                                                            d.type = '$dataset_definition->type'")) {
 521                     //Such dataset_definition exist. Now we must check if it has enough itemcount
 522                     if ($definitionrec->itemcount < $dataset_definition->itemcount) {
 523                         //We haven't enough itemcount, so we have to create the definition as an individual question one.
 524                         $dataset_definition->category = 0;
 525                         $create_definition = true;
 526                     } else {
 527                         //We have enough itemcount, so we'll reuse the existing definition
 528                         $create_definition = false;
 529                         $newid = $definitionrec->id;
 530                     }
 531                 } else {
 532                     //Such dataset_definition doesn't exist. We'll create it.
 533                     $create_definition = true;
 534                 }
 535             }
 536
 537             //If we've to create the definition, do it
 538             if ($create_definition) {
 539                 //The structure is equal to the db, so insert the question_dataset_definitions
 540                 $newid = insert_record ("question_dataset_definitions",$dataset_definition);
 541                 if ($newid) {
 542                     //Restore question_dataset_items
 543                     $status = question_restore_dataset_items($newid,$dd_info,$restore);
 544                 }
 545             }
 546
 547             //Now, we must have a definition (created o reused). Its id is in newid. Create the question_datasets record
 548             //to join the question and the dataset_definition
 549             if ($newid) {
 550                 $question_dataset = new stdClass;
 551                 $question_dataset->question = $new_question_id;
 552                 $question_dataset->datasetdefinition = $newid;
 553                 $newid = insert_record ("question_datasets",$question_dataset);
 554             }
 555
 556             if (!$newid) {
 557                 $status = false;
 558             }
 559         }
 560
 561         return $status;
 562     }
 563
 564     function question_restore_dataset_items ($definitionid,$info,$restore) {
 565
 566         global $CFG;
 567
 568         $status = true;
 569
 570         //Get the items array
 571         $dataset_items = $info['#']['DATASET_ITEMS']['0']['#']['DATASET_ITEM'];
 572
 573         //Iterate over dataset_items
 574         for($i = 0; $i < sizeof($dataset_items); $i++) {
 575             $di_info = $dataset_items[$i];
 576             //traverse_xmlize($di_info);                                                                  //Debug
 577             //print_object ($GLOBALS['traverse_array']);                                                  //Debug
 578             //$GLOBALS['traverse_array']="";                                                              //Debug
 579
 580             //Now, build the question_dataset_ITEMS record structure
 581             $dataset_item = new stdClass;
 582             $dataset_item->definition = $definitionid;
 583             $dataset_item->itemnumber = backup_todb($di_info['#']['NUMBER']['0']['#']);
 584             $dataset_item->value = backup_todb($di_info['#']['VALUE']['0']['#']);
 585
 586             //The structure is equal to the db, so insert the question_dataset_items
 587             $newid = insert_record ("question_dataset_items",$dataset_item);
 588
 589             if (!$newid) {
 590                 $status = false;
 591             }
 592         }
 593
 594         return $status;
 595     }
 596
 597
 598     //This function restores the question_states
 599     function question_states_restore_mods($attempt_id,$info,$restore) {
 600
 601         global $CFG, $QTYPES;
 602
 603         $status = true;
 604
 605         //Get the question_states array
 606         $states = $info['#']['STATES']['0']['#']['STATE'];
 607         //Iterate over states
 608         for($i = 0; $i < sizeof($states); $i++) {
 609             $res_info = $states[$i];
 610             //traverse_xmlize($res_info);                                                                 //Debug
 611             //print_object ($GLOBALS['traverse_array']);                                                  //Debug
 612             //$GLOBALS['traverse_array']="";                                                              //Debug
 613
 614             //We'll need this later!!
 615             $oldid = backup_todb($res_info['#']['ID']['0']['#']);
 616
 617             //Now, build the STATES record structure
 618             $state = new stdClass;
 619             $state->attempt = $attempt_id;
 620             $state->question = backup_todb($res_info['#']['QUESTION']['0']['#']);
 621             $state->originalquestion = backup_todb($res_info['#']['ORIGINALQUESTION']['0']['#']);
 622             $state->seq_number = backup_todb($res_info['#']['SEQ_NUMBER']['0']['#']);
 623             $state->answer = backup_todb($res_info['#']['ANSWER']['0']['#']);
 624             $state->timestamp = backup_todb($res_info['#']['TIMESTAMP']['0']['#']);
 625             $state->event = backup_todb($res_info['#']['EVENT']['0']['#']);
 626             $state->grade = backup_todb($res_info['#']['GRADE']['0']['#']);
 627             $state->raw_grade = backup_todb($res_info['#']['RAW_GRADE']['0']['#']);
 628             $state->penalty = backup_todb($res_info['#']['PENALTY']['0']['#']);
 629             $state->oldid = $oldid; // So it is available to restore_recode_answer.
 630
 631             //We have to recode the question field
 632             $question = backup_getid($restore->backup_unique_code,"question",$state->question);
 633             if ($question) {
 634                 $state->question = $question->new_id;
 635             } else {
 636                 echo 'Could not recode question id '.$state->question.' for state '.$oldid.'<br />';
 637             }
 638
 639             //We have to recode the originalquestion field if it is nonzero
 640             if ($state->originalquestion) {
 641                 $question = backup_getid($restore->backup_unique_code,"question",$state->originalquestion);
 642                 if ($question) {
 643                     $state->originalquestion = $question->new_id;
 644                 } else {
 645                     echo 'Could not recode originalquestion id '.$state->question.' for state '.$oldid.'<br />';
 646                 }
 647             }
 648
 649             //We have to recode the answer field
 650             //It depends of the question type !!
 651             //We get the question first
 652             if (!$question = get_record("question","id",$state->question)) {
 653                 error("Can't find the record for question $state->question for which I am trying to restore a state");
 654             }
 655             //Depending on the qtype, we make different recodes
 656             if ($state->answer) {
 657                 $state->answer = $QTYPES[$question->qtype]->restore_recode_answer($state, $restore);
 658             }
 659
 660             //The structure is equal to the db, so insert the question_states
 661             $newid = insert_record ("question_states",$state);
 662
 663             //Do some output
 664             if (($i+1) % 10 == 0) {
 665                 if (!defined('RESTORE_SILENTLY')) {
 666                     echo ".";
 667                     if (($i+1) % 200 == 0) {
 668                         echo "<br />";
 669                     }
 670                 }
 671                 backup_flush(300);
 672             }
 673
 674             if ($newid) {
 675                 //We have the newid, update backup_ids
 676                 backup_putid($restore->backup_unique_code,"question_states",$oldid,
 677                              $newid);
 678                 //Now process question type specific state information
 679                 $qtype = get_field('question', 'qtype', 'id', $state->question);
 680                 $status = $QTYPES[$qtype]->restore_state($newid,$res_info,$restore);
 681             } else {
 682                 $status = false;
 683             }
 684         }
 685
 686         //Get the question_sessions array
 687         $sessions = $info['#']['NEWEST_STATES']['0']['#']['NEWEST_STATE'];
 688         //Iterate over question_sessions
 689         for($i = 0; $i < sizeof($sessions); $i++) {
 690             $res_info = $sessions[$i];
 691             //traverse_xmlize($res_info);                                                                 //Debug
 692             //print_object ($GLOBALS['traverse_array']);                                                  //Debug
 693             //$GLOBALS['traverse_array']="";                                                              //Debug
 694
 695             //Now, build the NEWEST_STATES record structure
 696             $session = new stdClass;
 697             $session->attemptid = $attempt_id;
 698             $session->questionid = backup_todb($res_info['#']['QUESTIONID']['0']['#']);
 699             $session->newest = backup_todb($res_info['#']['NEWEST']['0']['#']);
 700             $session->newgraded = backup_todb($res_info['#']['NEWGRADED']['0']['#']);
 701             $session->sumpenalty = backup_todb($res_info['#']['SUMPENALTY']['0']['#']);
 702
 703             if ($res_info['#']['MANUALCOMMENT']['0']['#']) {
 704                 $session->manualcomment = backup_todb($res_info['#']['MANUALCOMMENT']['0']['#']);
 705             } else { // pre 1.7 backups
 706                 $session->manualcomment = backup_todb($res_info['#']['COMMENT']['0']['#']);
 707             }
 708
 709             //We have to recode the question field
 710             $question = backup_getid($restore->backup_unique_code,"question",$session->questionid);
 711             if ($question) {
 712                 $session->questionid = $question->new_id;
 713             } else {
 714                 echo 'Could not recode question id '.$session->questionid.'<br />';
 715             }
 716
 717             //We have to recode the newest field
 718             $state = backup_getid($restore->backup_unique_code,"question_states",$session->newest);
 719             if ($state) {
 720                 $session->newest = $state->new_id;
 721             } else {
 722                 echo 'Could not recode newest state id '.$session->newest.'<br />';
 723             }
 724
 725             //If the session has been graded we have to recode the newgraded field
 726             if ($session->newgraded) {
 727                 $state = backup_getid($restore->backup_unique_code,"question_states",$session->newgraded);
 728                 if ($state) {
 729                     $session->newgraded = $state->new_id;
 730                 } else {
 731                     echo 'Could not recode newest graded state id '.$session->newgraded.'<br />';
 732                 }
 733             }
 734
 735             //The structure is equal to the db, so insert the question_sessions
 736             $newid = insert_record ("question_sessions",$session);
 737
 738         }
 739
 740         return $status;
 741     }
 742
 743 ?>