PageRenderTime 35ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 1ms

/mod/quiz/restorelibpre15.php

https://bitbucket.org/ceu/moodle_demo
PHP | 2014 lines | 1237 code | 292 blank | 485 comment | 368 complexity | d9055e1a34d03a90ed67ce962e59eaf6 MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.0, LGPL-2.1 
    

  1. <?php // $Id: restorelibpre15.php,v 1.26.8.1 2007/11/02 16:19:57 tjhunt Exp $

    2. 

  2.     //This php script contains all the stuff to backup/restore

    3. 

  3.     //quiz mods

    4. 

  4. 

    5. 

  5.     //To see, put your terminal to 160cc

    6. 

  6. 

    7. 

  7.     //This is the "graphical" structure of the quiz mod:

    8. 

  8.     //

    9. 

  9.     //                           quiz                                                      question_categories

    10. 

  10.     //                        (CL,pk->id)                                                   (CL,pk->id)

    11. 

  11.     //                            |                                                              |

    12. 

  12.     //           -------------------------------------------------------------------             |

    13. 

  13.     //           |                        |                    |                   |             |.......................................

    14. 

  14.     //           |                        |                    |                   |             |                                      .

    15. 

  15.     //           |                        |                    |                   |             |                                      .

    16. 

  16.     //      quiz_attempts        quiz_grades       quiz_question_grades   quiz_question_versions |    ----question_datasets----    .

    17. 

  17.     // (UL,pk->id, fk->quiz) (UL,pk->id,fk->quiz)  (CL,pk->id,fk->quiz)    (CL,pk->id,fk->quiz)  |    |  (CL,pk->id,fk->question,  |    .

    18. 

  18.     //             |                                              |                      .       |    |   fk->dataset_definition)  |    .

    19. 

  19.     //             |                                              |                      .       |    |                            |    .

    20. 

  20.     //             |                                              |                      .       |    |                            |    .

    21. 

  21.     //             |                                              |                      .       |    |                            |    .

    22. 

  22.     //       quiz_responses                                       |                      question                       question_dataset_definitions

    23. 

  23.     //  (UL,pk->id, fk->attempt)----------------------------------------------------(CL,pk->id,fk->category,files)            (CL,pk->id,fk->category)

    24. 

  24.     //                                                                                           |                                      |

    25. 

  25.     //                                                                                           |                                      |

    26. 

  26.     //                                                                                           |                                      |

    27. 

  27.     //                                                                                           |                               question_dataset_items

    28. 

  28.     //                                                                                           |                            (CL,pk->id,fk->definition)

    29. 

  29.     //                                                                                           |

    30. 

  30.     //                                                                                           |

    31. 

  31.     //                                                                                           |

    32. 

  32.     //             --------------------------------------------------------------------------------------------------------------

    33. 

  33.     //             |             |              |              |                       |                  |                     |

    34. 

  34.     //             |             |              |              |                       |                  |                     |

    35. 

  35.     //             |             |              |              |                 question_calculated          |                     |    question_randomsamatch

    36. 

  36.     //      question_truefalse       |       question_multichoice      |             (CL,pl->id,fk->question)     |                     |--(CL,pl->id,fk->question)

    37. 

  37.     // (CL,pl->id,fk->question)  |   (CL,pl->id,fk->question)  |                       .                  |                     |

    38. 

  38.     //             .             |              .              |                       .                  |                     |

    39. 

  39.     //             .      question_shortanswer      .       question_numerical                 .            question_multianswer.           |

    40. 

  40.     //             .  (CL,pl->id,fk->question)  .  (CL,pl->id,fk->question)            .        (CL,pl->id,fk->question)        |         question_match

    41. 

  41.     //             .             .              .              .                       .                  .                     |--(CL,pl->id,fk->question)

    42. 

  42.     //             .             .              .              .                       .                  .                     |             .

    43. 

  43.     //             .             .              .              .                       .                  .                     |             .

    44. 

  44.     //             .             .              .              .                       .                  .                     |             .

    45. 

  45.     //             .             .              .              .                       .                  .                     |       question_match_sub

    46. 

  46.     //             .             .              .              .                       .                  .                     |--(CL,pl->id,fk->question)

    47. 

  47.     //             ........................................................................................                     |

    48. 

  48.     //                                                   .                                                                      |

    49. 

  49.     //                                                   .                                                                      |

    50. 

  50.     //                                                   .                                                                      |    question_numerical_units

    51. 

  51.     //                                                question_answers                                                              |--(CL,pl->id,fk->question)

    52. 

  52.     //                                         (CL,pk->id,fk->question)----------------------------------------------------------

    53. 

  53.     //

    54. 

  54.     // Meaning: pk->primary key field of the table

    55. 

  55.     //          fk->foreign key to link with parent

    56. 

  56.     //          nt->nested field (recursive data)

    57. 

  57.     //          CL->course level info

    58. 

  58.     //          UL->user level info

    59. 

  59.     //          files->table may have files

    60. 

  60.     //

    61. 

  61.     //-----------------------------------------------------------

    62. 

  62. 

    63. 

  63.     //This module is special, because we make the restore in two steps:

    64. 

  64.     // 1.-We restore every category and their questions (complete structure). It includes this tables:

    65. 

  65.     //     - question_categories

    66. 

  66.     //     - question

    67. 

  67.     //     - question_truefalse

    68. 

  68.     //     - question_shortanswer

    69. 

  69.     //     - question_multianswer

    70. 

  70.     //     - question_multichoice

    71. 

  71.     //     - question_numerical

    72. 

  72.     //     - question_randomsamatch

    73. 

  73.     //     - question_match

    74. 

  74.     //     - question_match_sub

    75. 

  75.     //     - question_calculated

    76. 

  76.     //     - question_answers

    77. 

  77.     //     - question_numerical_units

    78. 

  78.     //     - question_datasets

    79. 

  79.     //     - question_dataset_definitions

    80. 

  80.     //     - question_dataset_items

    81. 

  81.     //    All this backup info have its own section in moodle.xml (QUESTION_CATEGORIES) and it's generated

    82. 

  82.     //    before every module backup standard invocation. And only if to restore quizzes has been selected !!

    83. 

  83.     //    It's invoked with quiz_restore_question_categories. (course independent).

    84. 

  84. 

    85. 

  85.     // 2.-Standard module restore (Invoked via quiz_restore_mods). It includes this tables:

    86. 

  86.     //     - quiz

    87. 

  87.     //     - quiz_question_versions

    88. 

  88.     //     - quiz_question_grades

    89. 

  89.     //     - quiz_attempts

    90. 

  90.     //     - quiz_grades

    91. 

  91.     //     - quiz_responses

    92. 

  92.     //    This step is the standard mod backup. (course dependent).

    93. 

  93. 

    94. 

  94.     //We are going to nedd quiz libs to be able to mimic the upgrade process

    95. 

  95.     require_once("$CFG->dirroot/mod/quiz/locallib.php");

    96. 

  96. 

    97. 

  97.     //STEP 1. Restore categories/questions and associated structures

    98. 

  98.     //    (course independent)

    99. 

  99.     function quiz_restore_pre15_question_categories($category,$restore) {

    100. 

  100. 

    101. 

  101.         global $CFG;

    102. 

  102. 

    103. 

  103.         $status = true;

    104. 

  104. 

    105. 

  105.         //Get record from backup_ids

    106. 

  106.         $data = backup_getid($restore->backup_unique_code,"question_categories",$category->id);

    107. 

  107. 

    108. 

  108.         if ($data) {

    109. 

  109.             //Now get completed xmlized object

    110. 

  110.             $info = $data->info;

    111. 

  111.             //traverse_xmlize($info);                                                                     //Debug

    112. 

  112.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    113. 

  113.             //$GLOBALS['traverse_array']="";                                                              //Debug

    114. 

  114. 

    115. 

  115.             //Now, build the question_categories record structure

    116. 

  116.             $quiz_cat->course = $restore->course_id;

    117. 

  117.             $quiz_cat->name = backup_todb($info['QUESTION_CATEGORY']['#']['NAME']['0']['#']);

    118. 

  118.             $quiz_cat->info = backup_todb($info['QUESTION_CATEGORY']['#']['INFO']['0']['#']);

    119. 

  119.             $quiz_cat->publish = backup_todb($info['QUESTION_CATEGORY']['#']['PUBLISH']['0']['#']);

    120. 

  120.             $quiz_cat->stamp = backup_todb($info['QUESTION_CATEGORY']['#']['STAMP']['0']['#']);

    121. 

  121.             $quiz_cat->parent = backup_todb($info['QUESTION_CATEGORY']['#']['PARENT']['0']['#']);

    122. 

  122.             $quiz_cat->sortorder = backup_todb($info['QUESTION_CATEGORY']['#']['SORTORDER']['0']['#']);

    123. 

  123. 

    124. 

  124.             if ($catfound = restore_get_best_question_category($quiz_cat, $restore->course_id)) {

    125. 

  125.                 $newid = $catfound;

    126. 

  126.             } else {

    127. 

  127.                 if (!$quiz_cat->stamp) {

    128. 

  128.                     $quiz_cat->stamp = make_unique_id_code();   

    129. 

  129.                 }

    130. 

  130.                 $newid = insert_record ("question_categories",$quiz_cat);

    131. 

  131.             }

    132. 

  132. 

    133. 

  133.             //Do some output

    134. 

  134.             if ($newid) {

    135. 

  135.                 if (!defined('RESTORE_SILENTLY')) {

    136. 

  136.                     echo "<li>".get_string('category', 'quiz')." \"".$quiz_cat->name."\"<br />";

    137. 

  137.                 }

    138. 

  138.             } else {

    139. 

  139.                 if (!defined('RESTORE_SILENTLY')) {

    140. 

  140.                     //We must never arrive here !!

    141. 

  141.                     echo "<li>".get_string('category', 'quiz')." \"".$quiz_cat->name."\" Error!<br />";

    142. 

  142.                 }

    143. 

  143.                 $status = false;

    144. 

  144.             }

    145. 

  145.             backup_flush(300);

    146. 

  146. 

    147. 

  147.             //Here category has been created or selected, so save results in backup_ids and start with questions

    148. 

  148.             if ($newid and $status) {

    149. 

  149.                 //We have the newid, update backup_ids

    150. 

  150.                 backup_putid($restore->backup_unique_code,"question_categories",

    151. 

  151.                              $category->id, $newid);

    152. 

  152.                 //Now restore question

    153. 

  153.                 $status = quiz_restore_pre15_questions ($category->id, $newid,$info,$restore);

    154. 

  154.             } else {

    155. 

  155.                 $status = false;

    156. 

  156.             }

    157. 

  157.             if (!defined('RESTORE_SILENTLY')) {

    158. 

  158.                 echo '</li>';

    159. 

  159.             }

    160. 

  160.         }

    161. 

  161. 

    162. 

  162.         return $status;

    163. 

  163.     }

    164. 

  164. 

    165. 

  165.     function quiz_restore_pre15_questions ($old_category_id,$new_category_id,$info,$restore) {

    166. 

  166. 

    167. 

  167.         global $CFG;

    168. 

  168. 

    169. 

  169.         $status = true;

    170. 

  170. 

    171. 

  171.         //Get the questions array

    172. 

  172.         $questions = $info['QUESTION_CATEGORY']['#']['QUESTIONS']['0']['#']['QUESTION'];

    173. 

  173. 

    174. 

  174.         //Iterate over questions

    175. 

  175.         for($i = 0; $i < sizeof($questions); $i++) {

    176. 

  176.             $question = new object;

    177. 

  177.             $que_info = $questions[$i];

    178. 

  178.             //traverse_xmlize($que_info);                                                                 //Debug

    179. 

  179.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    180. 

  180.             //$GLOBALS['traverse_array']="";                                                              //Debug

    181. 

  181. 

    182. 

  182.             //We'll need this later!!

    183. 

  183.             $oldid = backup_todb($que_info['#']['ID']['0']['#']);

    184. 

  184. 

    185. 

  185.             //Now, build the question record structure

    186. 

  186.             $question->category = $new_category_id;

    187. 

  187.             $question->parent = backup_todb($que_info['#']['PARENT']['0']['#']);

    188. 

  188.             $question->name = backup_todb($que_info['#']['NAME']['0']['#']);

    189. 

  189.             $question->questiontext = backup_todb($que_info['#']['QUESTIONTEXT']['0']['#']);

    190. 

  190.             $question->questiontextformat = backup_todb($que_info['#']['QUESTIONTEXTFORMAT']['0']['#']);

    191. 

  191.             $question->image = backup_todb($que_info['#']['IMAGE']['0']['#']);

    192. 

  192.             $question->defaultgrade = backup_todb($que_info['#']['DEFAULTGRADE']['0']['#']);

    193. 

  193.             if (isset($que_info['#']['PENALTY']['0']['#'])) { //Only if it's set, to apply DB default else.

    194. 

  194.                 $question->penalty = backup_todb($que_info['#']['PENALTY']['0']['#']);

    195. 

  195.             }

    196. 

  196.             $question->qtype = backup_todb($que_info['#']['QTYPE']['0']['#']);

    197. 

  197.             if (isset($que_info['#']['LENGTH']['0']['#'])) { //Only if it's set, to apply DB default else.

    198. 

  198.                 $question->length = backup_todb($que_info['#']['LENGTH']['0']['#']);

    199. 

  199.             }

    200. 

  200.             $question->stamp = backup_todb($que_info['#']['STAMP']['0']['#']);

    201. 

  201.             if (isset($que_info['#']['VERSION']['0']['#'])) { //Only if it's set, to apply DB default else.

    202. 

  202.                 $question->version = backup_todb($que_info['#']['VERSION']['0']['#']);

    203. 

  203.             }

    204. 

  204.             if (isset($que_info['#']['HIDDEN']['0']['#'])) { //Only if it's set, to apply DB default else.

    205. 

  205.                 $question->hidden = backup_todb($que_info['#']['HIDDEN']['0']['#']);

    206. 

  206.             }

    207. 

  207. 

    208. 

  208.             //Although only a few backups can have questions with parent, we try to recode it

    209. 

  209.             //if it contains something

    210. 

  210.             if ($question->parent and $parent = backup_getid($restore->backup_unique_code,"question",$question->parent)) {

    211. 

  211.                 $question->parent = $parent->new_id;

    212. 

  212.             }

    213. 

  213. 

    214. 

  214.             // If it is a random question then hide it

    215. 

  215.             if ($question->qtype == RANDOM) {

    216. 

  216.                 $question->hidden = 1;

    217. 

  217.             }

    218. 

  218. 

    219. 

  219.             //If it is a description question, length = 0

    220. 

  220.             if ($question->qtype == DESCRIPTION) {

    221. 

  221.                 $question->length = 0;

    222. 

  222.             }

    223. 

  223. 

    224. 

  224.             //Check if the question exists

    225. 

  225.             //by category and stamp

    226. 

  226.             $question_exists = get_record ("question","category",$question->category,

    227. 

  227.                                                             "stamp",$question->stamp);

    228. 

  228.             //If the stamp doesn't exists, check if question exists

    229. 

  229.             //by category, name and questiontext and calculate stamp

    230. 

  230.             //Mantains pre Beta 1.1 compatibility !!

    231. 

  231.             if (!$question->stamp) {

    232. 

  232.                 $question->stamp = make_unique_id_code();

    233. 

  233.                 $question->version = 1;

    234. 

  234.                 $question_exists = get_record ("question","category",$question->category,

    235. 

  235.                                                                 "name",$question->name,

    236. 

  236.                                                                 "questiontext",$question->questiontext);

    237. 

  237.             }

    238. 

  238. 

    239. 

  239.             //If the question exists, only record its id

    240. 

  240.             if ($question_exists) {

    241. 

  241.                 $newid = $question_exists->id;

    242. 

  242.                 $creatingnewquestion = false;

    243. 

  243.             //Else, create a new question

    244. 

  244.             } else {

    245. 

  245.                 //The structure is equal to the db, so insert the question

    246. 

  246.                 $newid = insert_record ("question",$question);

    247. 

  247.                 //If it is a random question, parent = id

    248. 

  248.                 if ($newid && $question->qtype == RANDOM) {

    249. 

  249.                     set_field ('question', 'parent', $newid, 'id', $newid);

    250. 

  250.                 }

    251. 

  251.                 $creatingnewquestion = true;

    252. 

  252.             }

    253. 

  253. 

    254. 

  254.             //Do some output

    255. 

  255.             if (($i+1) % 2 == 0) {

    256. 

  256.                 if (!defined('RESTORE_SILENTLY')) {

    257. 

  257.                     echo ".";

    258. 

  258.                     if (($i+1) % 40 == 0) {

    259. 

  259.                         echo "<br />";

    260. 

  260.                     }

    261. 

  261.                 }

    262. 

  262.                 backup_flush(300);

    263. 

  263.             }

    264. 

  264.             //Save newid to backup tables

    265. 

  265.             if ($newid) {

    266. 

  266.                 //We have the newid, update backup_ids

    267. 

  267.                 backup_putid($restore->backup_unique_code,"question",$oldid,

    268. 

  268.                              $newid);

    269. 

  269.             }

    270. 

  270.             //If it's a new question in the DB, restore it

    271. 

  271.             if ($creatingnewquestion) {

    272. 

  272.                 //Now, restore every question_answers in this question

    273. 

  273.                 $status = quiz_restore_pre15_answers($oldid,$newid,$que_info,$restore);

    274. 

  274.                 //Now, depending of the type of questions, invoke different functions

    275. 

  275.                 if ($question->qtype == "1") {

    276. 

  276.                     $status = quiz_restore_pre15_shortanswer($oldid,$newid,$que_info,$restore);

    277. 

  277.                 } else if ($question->qtype == "2") {

    278. 

  278.                     $status = quiz_restore_pre15_truefalse($oldid,$newid,$que_info,$restore);

    279. 

  279.                 } else if ($question->qtype == "3") {

    280. 

  280.                     $status = quiz_restore_pre15_multichoice($oldid,$newid,$que_info,$restore);

    281. 

  281.                 } else if ($question->qtype == "4") {

    282. 

  282.                     //Random question. Nothing to do.

    283. 

  283.                 } else if ($question->qtype == "5") {

    284. 

  284.                     $status = quiz_restore_pre15_match($oldid,$newid,$que_info,$restore);

    285. 

  285.                 } else if ($question->qtype == "6") {

    286. 

  286.                     $status = quiz_restore_pre15_randomsamatch($oldid,$newid,$que_info,$restore);

    287. 

  287.                 } else if ($question->qtype == "7") {

    288. 

  288.                     //Description question. Nothing to do.

    289. 

  289.                 } else if ($question->qtype == "8") {

    290. 

  290.                     $status = quiz_restore_pre15_numerical($oldid,$newid,$que_info,$restore);

    291. 

  291.                 } else if ($question->qtype == "9") {

    292. 

  292.                     $status = quiz_restore_pre15_multianswer($oldid,$newid,$que_info,$restore);

    293. 

  293.                 } else if ($question->qtype == "10") {

    294. 

  294.                     $status = quiz_restore_pre15_calculated($oldid,$newid,$que_info,$restore);

    295. 

  295.                 }

    296. 

  296.             } else {

    297. 

  297.                 //We are NOT creating the question, but we need to know every question_answers

    298. 

  298.                 //map between the XML file and the database to be able to restore the responses

    299. 

  299.                 //in each attempt.

    300. 

  300.                 $status = quiz_restore_pre15_map_answers($oldid,$newid,$que_info,$restore);

    301. 

  301.                 //Now, depending of the type of questions, invoke different functions

    302. 

  302.                 //to create the necessary mappings in backup_ids, because we are not

    303. 

  303.                 //creating the question, but need some records in backup table

    304. 

  304.                 if ($question->qtype == "1") {

    305. 

  305.                     //Shortanswer question. Nothing to remap

    306. 

  306.                 } else if ($question->qtype == "2") {

    307. 

  307.                     //Truefalse question. Nothing to remap

    308. 

  308.                 } else if ($question->qtype == "3") {

    309. 

  309.                     //Multichoice question. Nothing to remap

    310. 

  310.                 } else if ($question->qtype == "4") {

    311. 

  311.                     //Random question. Nothing to remap

    312. 

  312.                 } else if ($question->qtype == "5") {

    313. 

  313.                     $status = quiz_restore_pre15_map_match($oldid,$newid,$que_info,$restore);

    314. 

  314.                 } else if ($question->qtype == "6") {

    315. 

  315.                     //Randomsamatch question. Nothing to remap

    316. 

  316.                 } else if ($question->qtype == "7") {

    317. 

  317.                     //Description question. Nothing to remap

    318. 

  318.                 } else if ($question->qtype == "8") {

    319. 

  319.                     //Numerical question. Nothing to remap

    320. 

  320.                 } else if ($question->qtype == "9") {

    321. 

  321.                     //Multianswer question. Nothing to remap

    322. 

  322.                 } else if ($question->qtype == "10") {

    323. 

  323.                     //Calculated question. Nothing to remap

    324. 

  324.                 }

    325. 

  325.             }

    326. 

  326.         }

    327. 

  327.         return $status;

    328. 

  328.     }

    329. 

  329. 

    330. 

  330.     function quiz_restore_pre15_answers ($old_question_id,$new_question_id,$info,$restore) {

    331. 

  331. 

    332. 

  332.         global $CFG;

    333. 

  333. 

    334. 

  334.         $status = true;

    335. 

  335. 

    336. 

  336.         //Get the answers array

    337. 

  337.         if (isset($info['#']['ANSWERS']['0']['#']['ANSWER'])) {

    338. 

  338.             $answers = $info['#']['ANSWERS']['0']['#']['ANSWER'];

    339. 

  339. 

    340. 

  340.             //Iterate over answers

    341. 

  341.             for($i = 0; $i < sizeof($answers); $i++) {

    342. 

  342.                 $ans_info = $answers[$i];

    343. 

  343.                 //traverse_xmlize($ans_info);                                                                 //Debug

    344. 

  344.                 //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    345. 

  345.                 //$GLOBALS['traverse_array']="";                                                              //Debug

    346. 

  346. 

    347. 

  347.                 //We'll need this later!!

    348. 

  348.                 $oldid = backup_todb($ans_info['#']['ID']['0']['#']);

    349. 

  349. 

    350. 

  350.                 //Now, build the question_answers record structure

    351. 

  351.                 $answer->question = $new_question_id;

    352. 

  352.                 $answer->answer = backup_todb($ans_info['#']['ANSWER_TEXT']['0']['#']);

    353. 

  353.                 $answer->fraction = backup_todb($ans_info['#']['FRACTION']['0']['#']);

    354. 

  354.                 $answer->feedback = backup_todb($ans_info['#']['FEEDBACK']['0']['#']);

    355. 

  355. 

    356. 

  356.                 //The structure is equal to the db, so insert the question_answers

    357. 

  357.                 $newid = insert_record ("question_answers",$answer);

    358. 

  358. 

    359. 

  359.                 //Do some output

    360. 

  360.                 if (($i+1) % 50 == 0) {

    361. 

  361.                     if (!defined('RESTORE_SILENTLY')) {

    362. 

  362.                         echo ".";

    363. 

  363.                         if (($i+1) % 1000 == 0) {

    364. 

  364.                             echo "<br />";

    365. 

  365.                         }

    366. 

  366.                     }

    367. 

  367.                     backup_flush(300);

    368. 

  368.                 }

    369. 

  369. 

    370. 

  370.                 if ($newid) {

    371. 

  371.                     //We have the newid, update backup_ids

    372. 

  372.                     backup_putid($restore->backup_unique_code,"question_answers",$oldid,

    373. 

  373.                                  $newid);

    374. 

  374.                 } else {

    375. 

  375.                     $status = false;

    376. 

  376.                 }

    377. 

  377.             }

    378. 

  378.         }

    379. 

  379. 

    380. 

  380.         return $status;

    381. 

  381.     }

    382. 

  382. 

    383. 

  383.     function quiz_restore_pre15_map_answers ($old_question_id,$new_question_id,$info,$restore) {

    384. 

  384. 

    385. 

  385.         global $CFG;

    386. 

  386. 

    387. 

  387.         $status = true;

    388. 

  388. 

    389. 

  389.         if (!isset($info['#']['ANSWERS'])) {    // No answers in this question (eg random)

    390. 

  390.             return $status;

    391. 

  391.         }

    392. 

  392. 

    393. 

  393.         //Get the answers array

    394. 

  394.         $answers = $info['#']['ANSWERS']['0']['#']['ANSWER'];

    395. 

  395. 

    396. 

  396.         //Iterate over answers

    397. 

  397.         for($i = 0; $i < sizeof($answers); $i++) {

    398. 

  398.             $ans_info = $answers[$i];

    399. 

  399.             //traverse_xmlize($ans_info);                                                                 //Debug

    400. 

  400.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    401. 

  401.             //$GLOBALS['traverse_array']="";                                                              //Debug

    402. 

  402. 

    403. 

  403.             //We'll need this later!!

    404. 

  404.             $oldid = backup_todb($ans_info['#']['ID']['0']['#']);

    405. 

  405. 

    406. 

  406.             //Now, build the question_answers record structure

    407. 

  407.             $answer->question = $new_question_id;

    408. 

  408.             $answer->answer = backup_todb($ans_info['#']['ANSWER_TEXT']['0']['#']);

    409. 

  409.             $answer->fraction = backup_todb($ans_info['#']['FRACTION']['0']['#']);

    410. 

  410.             $answer->feedback = backup_todb($ans_info['#']['FEEDBACK']['0']['#']);

    411. 

  411. 

    412. 

  412.             //If we are in this method is because the question exists in DB, so its

    413. 

  413.             //answers must exist too.

    414. 

  414.             //Now, we are going to look for that answer in DB and to create the

    415. 

  415.             //mappings in backup_ids to use them later where restoring responses (user level).

    416. 

  416. 

    417. 

  417.             //Get the answer from DB (by question, answer and fraction)

    418. 

  418.             $db_answer = get_record ("question_answers","question",$new_question_id,

    419. 

  419.                                                     "answer",$answer->answer,

    420. 

  420.                                                     "fraction",$answer->fraction);

    421. 

  421. 

    422. 

  422.             //Do some output

    423. 

  423.             if (($i+1) % 50 == 0) {

    424. 

  424.                 if (!defined('RESTORE_SILENTLY')) {

    425. 

  425.                     echo ".";

    426. 

  426.                     if (($i+1) % 1000 == 0) {

    427. 

  427.                         echo "<br />";

    428. 

  428.                     }

    429. 

  429.                 }

    430. 

  430.                 backup_flush(300);

    431. 

  431.             }

    432. 

  432. 

    433. 

  433.             if ($db_answer) {

    434. 

  434.                 //We have the database answer, update backup_ids

    435. 

  435.                 backup_putid($restore->backup_unique_code,"question_answers",$oldid,

    436. 

  436.                              $db_answer->id);

    437. 

  437.             } else {

    438. 

  438.                 $status = false;

    439. 

  439.             }

    440. 

  440.         }

    441. 

  441. 

    442. 

  442.         return $status;

    443. 

  443.     }

    444. 

  444. 

    445. 

  445.     function quiz_restore_pre15_shortanswer ($old_question_id,$new_question_id,$info,$restore,$restrictto = '') {

    446. 

  446. 

    447. 

  447.         global $CFG;

    448. 

  448. 

    449. 

  449.         $status = true;

    450. 

  450. 

    451. 

  451.         //Get the shortanswers array

    452. 

  452.         $shortanswers = $info['#']['SHORTANSWER'];

    453. 

  453. 

    454. 

  454.         //Iterate over shortanswers

    455. 

  455.         for($i = 0; $i < sizeof($shortanswers); $i++) {

    456. 

  456.             $sho_info = $shortanswers[$i];

    457. 

  457.             //traverse_xmlize($sho_info);                                                                 //Debug

    458. 

  458.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    459. 

  459.             //$GLOBALS['traverse_array']="";                                                              //Debug

    460. 

  460. 

    461. 

  461.             //Now, build the question_shortanswer record structure

    462. 

  462.             $shortanswer->question = $new_question_id;

    463. 

  463.             $shortanswer->answers = backup_todb($sho_info['#']['ANSWERS']['0']['#']);

    464. 

  464.             $shortanswer->usecase = backup_todb($sho_info['#']['USECASE']['0']['#']);

    465. 

  465. 

    466. 

  466.             //We have to recode the answers field (a list of answers id)

    467. 

  467.             //Extracts answer id from sequence

    468. 

  468.             $answers_field = "";

    469. 

  469.             $in_first = true;

    470. 

  470.             $tok = strtok($shortanswer->answers,",");

    471. 

  471.             while ($tok) {

    472. 

  472.                 //Get the answer from backup_ids

    473. 

  473.                 $answer = backup_getid($restore->backup_unique_code,"question_answers",$tok);

    474. 

  474.                 if ($answer) {

    475. 

  475.                     if ($in_first) {

    476. 

  476.                         $answers_field .= $answer->new_id;

    477. 

  477.                         $in_first = false;

    478. 

  478.                     } else {

    479. 

  479.                         $answers_field .= ",".$answer->new_id;

    480. 

  480.                     }

    481. 

  481.                 }

    482. 

  482.                 //check for next

    483. 

  483.                 $tok = strtok(",");

    484. 

  484.             }

    485. 

  485.             //We have the answers field recoded to its new ids

    486. 

  486.             $shortanswer->answers = $answers_field;

    487. 

  487. 

    488. 

  488.             //The structure is equal to the db, so insert the question_shortanswer

    489. 

  489.             //Only if there aren't restrictions or there are restriction concordance

    490. 

  490.             if (empty($restrictto) || (!empty($restrictto) && $shortanswer->answers == $restrictto)) {

    491. 

  491.                 $newid = insert_record ("question_shortanswer",$shortanswer);

    492. 

  492.             } 

    493. 

  493. 

    494. 

  494.             //Do some output

    495. 

  495.             if (($i+1) % 50 == 0) {

    496. 

  496.                 if (!defined('RESTORE_SILENTLY')) {

    497. 

  497.                     echo ".";

    498. 

  498.                     if (($i+1) % 1000 == 0) {

    499. 

  499.                         echo "<br />";

    500. 

  500.                     }

    501. 

  501.                 }

    502. 

  502.                 backup_flush(300);

    503. 

  503.             }

    504. 

  504. 

    505. 

  505.             if (!$newid && !$restrictto) {

    506. 

  506.                 $status = false;

    507. 

  507.             }

    508. 

  508.         }

    509. 

  509. 

    510. 

  510.         return $status;

    511. 

  511.     }

    512. 

  512. 

    513. 

  513.     function quiz_restore_pre15_truefalse ($old_question_id,$new_question_id,$info,$restore) {

    514. 

  514. 

    515. 

  515.         global $CFG;

    516. 

  516. 

    517. 

  517.         $status = true;

    518. 

  518. 

    519. 

  519.         //Get the truefalse array

    520. 

  520.         $truefalses = $info['#']['TRUEFALSE'];

    521. 

  521. 

    522. 

  522.         //Iterate over truefalse

    523. 

  523.         for($i = 0; $i < sizeof($truefalses); $i++) {

    524. 

  524.             $tru_info = $truefalses[$i];

    525. 

  525.             //traverse_xmlize($tru_info);                                                                 //Debug

    526. 

  526.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    527. 

  527.             //$GLOBALS['traverse_array']="";                                                              //Debug

    528. 

  528. 

    529. 

  529.             //Now, build the question_truefalse record structure

    530. 

  530.             $truefalse->question = $new_question_id;

    531. 

  531.             $truefalse->trueanswer = backup_todb($tru_info['#']['TRUEANSWER']['0']['#']);

    532. 

  532.             $truefalse->falseanswer = backup_todb($tru_info['#']['FALSEANSWER']['0']['#']);

    533. 

  533. 

    534. 

  534.             ////We have to recode the trueanswer field

    535. 

  535.             $answer = backup_getid($restore->backup_unique_code,"question_answers",$truefalse->trueanswer);

    536. 

  536.             if ($answer) {

    537. 

  537.                 $truefalse->trueanswer = $answer->new_id;

    538. 

  538.             }

    539. 

  539. 

    540. 

  540.             ////We have to recode the falseanswer field

    541. 

  541.             $answer = backup_getid($restore->backup_unique_code,"question_answers",$truefalse->falseanswer);

    542. 

  542.             if ($answer) {

    543. 

  543.                 $truefalse->falseanswer = $answer->new_id;

    544. 

  544.             }

    545. 

  545. 

    546. 

  546.             //The structure is equal to the db, so insert the question_truefalse

    547. 

  547.             $newid = insert_record ("question_truefalse",$truefalse);

    548. 

  548. 

    549. 

  549.             //Do some output

    550. 

  550.             if (($i+1) % 50 == 0) {

    551. 

  551.                 if (!defined('RESTORE_SILENTLY')) {

    552. 

  552.                     echo ".";

    553. 

  553.                     if (($i+1) % 1000 == 0) {

    554. 

  554.                         echo "<br />";

    555. 

  555.                     }

    556. 

  556.                 }

    557. 

  557.                 backup_flush(300);

    558. 

  558.             }

    559. 

  559. 

    560. 

  560.             if (!$newid) {

    561. 

  561.                 $status = false;

    562. 

  562.             }

    563. 

  563.         }

    564. 

  564. 

    565. 

  565.         return $status;

    566. 

  566.     }

    567. 

  567. 

    568. 

  568.     function quiz_restore_pre15_multichoice ($old_question_id,$new_question_id,$info,$restore, $restrictto = '') {

    569. 

  569. 

    570. 

  570.         global $CFG;

    571. 

  571. 

    572. 

  572.         $status = true;

    573. 

  573. 

    574. 

  574.         //Get the multichoices array

    575. 

  575.         $multichoices = $info['#']['MULTICHOICE'];

    576. 

  576. 

    577. 

  577.         //Iterate over multichoices

    578. 

  578.         for($i = 0; $i < sizeof($multichoices); $i++) {

    579. 

  579.             $mul_info = $multichoices[$i];

    580. 

  580.             //traverse_xmlize($mul_info);                                                                 //Debug

    581. 

  581.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    582. 

  582.             //$GLOBALS['traverse_array']="";                                                              //Debug

    583. 

  583. 

    584. 

  584.             //Now, build the question_multichoice record structure

    585. 

  585.             $multichoice->question = $new_question_id;

    586. 

  586.             $multichoice->layout = backup_todb($mul_info['#']['LAYOUT']['0']['#']);

    587. 

  587.             $multichoice->answers = backup_todb($mul_info['#']['ANSWERS']['0']['#']);

    588. 

  588.             $multichoice->single = backup_todb($mul_info['#']['SINGLE']['0']['#']);

    589. 

  589. 

    590. 

  590.             //We have to recode the answers field (a list of answers id)

    591. 

  591.             //Extracts answer id from sequence

    592. 

  592.             $answers_field = "";

    593. 

  593.             $in_first = true;

    594. 

  594.             $tok = strtok($multichoice->answers,",");

    595. 

  595.             while ($tok) {

    596. 

  596.                 //Get the answer from backup_ids

    597. 

  597.                 $answer = backup_getid($restore->backup_unique_code,"question_answers",$tok);

    598. 

  598.                 if ($answer) {

    599. 

  599.                     if ($in_first) {

    600. 

  600.                         $answers_field .= $answer->new_id;

    601. 

  601.                         $in_first = false;

    602. 

  602.                     } else {

    603. 

  603.                         $answers_field .= ",".$answer->new_id;

    604. 

  604.                     }

    605. 

  605.                 }

    606. 

  606.                 //check for next

    607. 

  607.                 $tok = strtok(",");

    608. 

  608.             }

    609. 

  609.             //We have the answers field recoded to its new ids

    610. 

  610.             $multichoice->answers = $answers_field;

    611. 

  611. 

    612. 

  612.             //The structure is equal to the db, so insert the question_shortanswer

    613. 

  613.             //Only if there aren't restrictions or there are restriction concordance

    614. 

  614.             if (empty($restrictto) || (!empty($restrictto) && $multichoice->answers == $restrictto)) {

    615. 

  615.                 $newid = insert_record ("question_multichoice",$multichoice);

    616. 

  616.             }

    617. 

  617. 

    618. 

  618.             //Do some output

    619. 

  619.             if (($i+1) % 50 == 0) {

    620. 

  620.                 if (!defined('RESTORE_SILENTLY')) {

    621. 

  621.                     echo ".";

    622. 

  622.                     if (($i+1) % 1000 == 0) {

    623. 

  623.                         echo "<br />";

    624. 

  624.                     }

    625. 

  625.                 }

    626. 

  626.                 backup_flush(300);

    627. 

  627.             }

    628. 

  628. 

    629. 

  629.             if (!$newid && !$restrictto) {

    630. 

  630.                 $status = false;

    631. 

  631.             }

    632. 

  632.         }

    633. 

  633. 

    634. 

  634.         return $status;

    635. 

  635.     }

    636. 

  636. 

    637. 

  637.     function quiz_restore_pre15_match ($old_question_id,$new_question_id,$info,$restore) {

    638. 

  638. 

    639. 

  639.         global $CFG;

    640. 

  640. 

    641. 

  641.         $status = true;

    642. 

  642. 

    643. 

  643.         //Get the matchs array

    644. 

  644.         $matchs = $info['#']['MATCHS']['0']['#']['MATCH'];

    645. 

  645. 

    646. 

  646.         //We have to build the subquestions field (a list of match_sub id)

    647. 

  647.         $subquestions_field = "";

    648. 

  648.         $in_first = true;

    649. 

  649. 

    650. 

  650.         //Iterate over matchs

    651. 

  651.         for($i = 0; $i < sizeof($matchs); $i++) {

    652. 

  652.             $mat_info = $matchs[$i];

    653. 

  653.             //traverse_xmlize($mat_info);                                                                 //Debug

    654. 

  654.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    655. 

  655.             //$GLOBALS['traverse_array']="";                                                              //Debug

    656. 

  656. 

    657. 

  657.             //We'll need this later!!

    658. 

  658.             $oldid = backup_todb($mat_info['#']['ID']['0']['#']);

    659. 

  659. 

    660. 

  660.             //Now, build the question_match_SUB record structure

    661. 

  661.             $match_sub->question = $new_question_id;

    662. 

  662.             $match_sub->questiontext = backup_todb($mat_info['#']['QUESTIONTEXT']['0']['#']);

    663. 

  663.             $match_sub->answertext = backup_todb($mat_info['#']['ANSWERTEXT']['0']['#']);

    664. 

  664. 

    665. 

  665.             //The structure is equal to the db, so insert the question_match_sub

    666. 

  666.             $newid = insert_record ("question_match_sub",$match_sub);

    667. 

  667. 

    668. 

  668.             //Do some output

    669. 

  669.             if (($i+1) % 50 == 0) {

    670. 

  670.                 if (!defined('RESTORE_SILENTLY')) {

    671. 

  671.                     echo ".";

    672. 

  672.                     if (($i+1) % 1000 == 0) {

    673. 

  673.                         echo "<br />";

    674. 

  674.                     }

    675. 

  675.                 }

    676. 

  676.                 backup_flush(300);

    677. 

  677.             }

    678. 

  678. 

    679. 

  679.             if ($newid) {

    680. 

  680.                 //We have the newid, update backup_ids

    681. 

  681.                 backup_putid($restore->backup_unique_code,"question_match_sub",$oldid,

    682. 

  682.                              $newid);

    683. 

  683.                 //We have a new match_sub, append it to subquestions_field

    684. 

  684.                 if ($in_first) {

    685. 

  685.                     $subquestions_field .= $newid;

    686. 

  686.                     $in_first = false;

    687. 

  687.                 } else {

    688. 

  688.                     $subquestions_field .= ",".$newid;

    689. 

  689.                 }

    690. 

  690.             } else {

    691. 

  691.                 $status = false;

    692. 

  692.             }

    693. 

  693.         }

    694. 

  694. 

    695. 

  695.         //We have created every match_sub, now create the match

    696. 

  696.         $match->question = $new_question_id;

    697. 

  697.         $match->subquestions = $subquestions_field;

    698. 

  698. 

    699. 

  699.         //The structure is equal to the db, so insert the question_match_sub

    700. 

  700.         $newid = insert_record ("question_match",$match);

    701. 

  701. 

    702. 

  702.         if (!$newid) {

    703. 

  703.             $status = false;

    704. 

  704.         }

    705. 

  705. 

    706. 

  706.         return $status;

    707. 

  707.     }

    708. 

  708. 

    709. 

  709.     function quiz_restore_pre15_map_match ($old_question_id,$new_question_id,$info,$restore) {

    710. 

  710. 

    711. 

  711.         global $CFG;

    712. 

  712. 

    713. 

  713.         $status = true;

    714. 

  714. 

    715. 

  715.         //Get the matchs array

    716. 

  716.         $matchs = $info['#']['MATCHS']['0']['#']['MATCH'];

    717. 

  717. 

    718. 

  718.         //We have to build the subquestions field (a list of match_sub id)

    719. 

  719.         $subquestions_field = "";

    720. 

  720.         $in_first = true;

    721. 

  721. 

    722. 

  722.         //Iterate over matchs

    723. 

  723.         for($i = 0; $i < sizeof($matchs); $i++) {

    724. 

  724.             $mat_info = $matchs[$i];

    725. 

  725.             //traverse_xmlize($mat_info);                                                                 //Debug

    726. 

  726.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    727. 

  727.             //$GLOBALS['traverse_array']="";                                                              //Debug

    728. 

  728. 

    729. 

  729.             //We'll need this later!!

    730. 

  730.             $oldid = backup_todb($mat_info['#']['ID']['0']['#']);

    731. 

  731. 

    732. 

  732.             //Now, build the question_match_SUB record structure

    733. 

  733.             $match_sub->question = $new_question_id;

    734. 

  734.             $match_sub->questiontext = backup_todb($mat_info['#']['QUESTIONTEXT']['0']['#']);

    735. 

  735.             $match_sub->answertext = backup_todb($mat_info['#']['ANSWERTEXT']['0']['#']);

    736. 

  736. 

    737. 

  737.             //If we are in this method is because the question exists in DB, so its

    738. 

  738.             //match_sub must exist too.

    739. 

  739.             //Now, we are going to look for that match_sub in DB and to create the

    740. 

  740.             //mappings in backup_ids to use them later where restoring responses (user level).

    741. 

  741. 

    742. 

  742.             //Get the match_sub from DB (by question, questiontext and answertext)

    743. 

  743.             $db_match_sub = get_record ("question_match_sub","question",$new_question_id,

    744. 

  744.                                                       "questiontext",$match_sub->questiontext,

    745. 

  745.                                                       "answertext",$match_sub->answertext);

    746. 

  746.             //Do some output

    747. 

  747.             if (($i+1) % 50 == 0) {

    748. 

  748.                 if (!defined('RESTORE_SILENTLY')) {

    749. 

  749.                     echo ".";

    750. 

  750.                     if (($i+1) % 1000 == 0) {

    751. 

  751.                         echo "<br />";

    752. 

  752.                     }

    753. 

  753.                 }

    754. 

  754.                 backup_flush(300);

    755. 

  755.             }

    756. 

  756. 

    757. 

  757.             //We have the database match_sub, so update backup_ids

    758. 

  758.             if ($db_match_sub) {

    759. 

  759.                 //We have the newid, update backup_ids

    760. 

  760.                 backup_putid($restore->backup_unique_code,"question_match_sub",$oldid,

    761. 

  761.                              $db_match_sub->id);

    762. 

  762.             } else {

    763. 

  763.                 $status = false;

    764. 

  764.             }

    765. 

  765.         }

    766. 

  766. 

    767. 

  767.         return $status;

    768. 

  768.     }

    769. 

  769. 

    770. 

  770.     function quiz_restore_pre15_randomsamatch ($old_question_id,$new_question_id,$info,$restore) {

    771. 

  771. 

    772. 

  772.         global $CFG;

    773. 

  773. 

    774. 

  774.         $status = true;

    775. 

  775. 

    776. 

  776.         //Get the randomsamatchs array

    777. 

  777.         $randomsamatchs = $info['#']['RANDOMSAMATCH'];

    778. 

  778. 

    779. 

  779.         //Iterate over randomsamatchs

    780. 

  780.         for($i = 0; $i < sizeof($randomsamatchs); $i++) {

    781. 

  781.             $ran_info = $randomsamatchs[$i];

    782. 

  782.             //traverse_xmlize($ran_info);                                                                 //Debug

    783. 

  783.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    784. 

  784.             //$GLOBALS['traverse_array']="";                                                              //Debug

    785. 

  785. 

    786. 

  786.             //Now, build the question_randomsamatch record structure

    787. 

  787.             $randomsamatch->question = $new_question_id;

    788. 

  788.             $randomsamatch->choose = backup_todb($ran_info['#']['CHOOSE']['0']['#']);

    789. 

  789. 

    790. 

  790.             //The structure is equal to the db, so insert the question_randomsamatch

    791. 

  791.             $newid = insert_record ("question_randomsamatch",$randomsamatch);

    792. 

  792. 

    793. 

  793.             //Do some output

    794. 

  794.             if (($i+1) % 50 == 0) {

    795. 

  795.                 if (!defined('RESTORE_SILENTLY')) {

    796. 

  796.                     echo ".";

    797. 

  797.                     if (($i+1) % 1000 == 0) {

    798. 

  798.                         echo "<br />";

    799. 

  799.                     }

    800. 

  800.                 }

    801. 

  801.                 backup_flush(300);

    802. 

  802.             }

    803. 

  803. 

    804. 

  804.             if (!$newid) {

    805. 

  805.                 $status = false;

    806. 

  806.             }

    807. 

  807.         }

    808. 

  808. 

    809. 

  809.         return $status;

    810. 

  810.     }

    811. 

  811. 

    812. 

  812.     function quiz_restore_pre15_numerical ($old_question_id,$new_question_id,$info,$restore, $restrictto = '') {

    813. 

  813. 

    814. 

  814.         global $CFG;

    815. 

  815. 

    816. 

  816.         $status = true;

    817. 

  817. 

    818. 

  818.         //Get the numerical array

    819. 

  819.         $numericals = $info['#']['NUMERICAL'];

    820. 

  820. 

    821. 

  821.         //Iterate over numericals

    822. 

  822.         for($i = 0; $i < sizeof($numericals); $i++) {

    823. 

  823.             $num_info = $numericals[$i];

    824. 

  824.             //traverse_xmlize($num_info);                                                                 //Debug

    825. 

  825.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    826. 

  826.             //$GLOBALS['traverse_array']="";                                                              //Debug

    827. 

  827. 

    828. 

  828.             //Now, build the question_numerical record structure

    829. 

  829.             $numerical->question = $new_question_id;

    830. 

  830.             $numerical->answer = backup_todb($num_info['#']['ANSWER']['0']['#']);

    831. 

  831.             $numerical->min = backup_todb($num_info['#']['MIN']['0']['#']);

    832. 

  832.             $numerical->max = backup_todb($num_info['#']['MAX']['0']['#']);

    833. 

  833. 

    834. 

  834.             ////We have to recode the answer field

    835. 

  835.             $answer = backup_getid($restore->backup_unique_code,"question_answers",$numerical->answer);

    836. 

  836.             if ($answer) {

    837. 

  837.                 $numerical->answer = $answer->new_id;

    838. 

  838.             }

    839. 

  839. 

    840. 

  840.             //Answer goes to answers in 1.5 (although it continues being only one!)

    841. 

  841.             //Changed 12-05 (chating with Gustav and Julian this remains = pre15 = answer)

    842. 

  842.             //$numerical->answers = $numerical->answer;

    843. 

  843. 

    844. 

  844.             //We have to calculate the tolerance field of the numerical question

    845. 

  845.             $numerical->tolerance = ($numerical->max - $numerical->min)/2;

    846. 

  846. 

    847. 

  847.             //The structure is equal to the db, so insert the question_numerical

    848. 

  848.             //Only if there aren't restrictions or there are restriction concordance

    849. 

  849.             if (empty($restrictto) || (!empty($restrictto) && in_array($numerical->answer,explode(",",$restrictto)))) {

    850. 

  850.                 $newid = insert_record ("question_numerical",$numerical);

    851. 

  851.             }

    852. 

  852. 

    853. 

  853.             //Do some output

    854. 

  854.             if (($i+1) % 50 == 0) {

    855. 

  855.                 if (!defined('RESTORE_SILENTLY')) {

    856. 

  856.                     echo ".";

    857. 

  857.                     if (($i+1) % 1000 == 0) {

    858. 

  858.                         echo "<br />";

    859. 

  859.                     }

    860. 

  860.                 }

    861. 

  861.                 backup_flush(300);

    862. 

  862.             }

    863. 

  863. 

    864. 

  864.             //Now restore numerical_units

    865. 

  865.             if ($newid) {

    866. 

  866.                 $status = quiz_restore_pre15_numerical_units ($old_question_id,$new_question_id,$num_info,$restore);

    867. 

  867.             }

    868. 

  868. 

    869. 

  869.             if (!$newid && !$restrictto) {

    870. 

  870.                 $status = false;

    871. 

  871.             }

    872. 

  872.         }

    873. 

  873. 

    874. 

  874.         return $status;

    875. 

  875.     }

    876. 

  876. 

    877. 

  877.     function quiz_restore_pre15_calculated ($old_question_id,$new_question_id,$info,$restore) {

    878. 

  878. 

    879. 

  879.         global $CFG;

    880. 

  880. 

    881. 

  881.         $status = true;

    882. 

  882. 

    883. 

  883.         //Get the calculated-s array

    884. 

  884.         $calculateds = $info['#']['CALCULATED'];

    885. 

  885. 

    886. 

  886.         //Iterate over calculateds

    887. 

  887.         for($i = 0; $i < sizeof($calculateds); $i++) {

    888. 

  888.             $cal_info = $calculateds[$i];

    889. 

  889.             //traverse_xmlize($cal_info);                                                                 //Debug

    890. 

  890.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    891. 

  891.             //$GLOBALS['traverse_array']="";                                                              //Debug

    892. 

  892. 

    893. 

  893.             //Now, build the question_calculated record structure

    894. 

  894.             $calculated->question = $new_question_id;

    895. 

  895.             $calculated->answer = backup_todb($cal_info['#']['ANSWER']['0']['#']);

    896. 

  896.             $calculated->tolerance = backup_todb($cal_info['#']['TOLERANCE']['0']['#']);

    897. 

  897.             $calculated->tolerancetype = backup_todb($cal_info['#']['TOLERANCETYPE']['0']['#']);

    898. 

  898.             $calculated->correctanswerlength = backup_todb($cal_info['#']['CORRECTANSWERLENGTH']['0']['#']);

    899. 

  899.             $calculated->correctanswerformat = backup_todb($cal_info['#']['CORRECTANSWERFORMAT']['0']['#']);

    900. 

  900. 

    901. 

  901.             ////We have to recode the answer field

    902. 

  902.             $answer = backup_getid($restore->backup_unique_code,"question_answers",$calculated->answer);

    903. 

  903.             if ($answer) {

    904. 

  904.                 $calculated->answer = $answer->new_id;

    905. 

  905.             }

    906. 

  906. 

    907. 

  907.             //If we haven't correctanswerformat, it defaults to 2 (in DB)

    908. 

  908.             if (empty($calculated->correctanswerformat)) {

    909. 

  909.                 $calculated->correctanswerformat = 2;

    910. 

  910.             }

    911. 

  911. 

    912. 

  912.             //The structure is equal to the db, so insert the question_calculated

    913. 

  913.             $newid = insert_record ("question_calculated",$calculated);

    914. 

  914. 

    915. 

  915.             //Do some output

    916. 

  916.             if (($i+1) % 50 == 0) {

    917. 

  917.                 if (!defined('RESTORE_SILENTLY')) {

    918. 

  918.                     echo ".";

    919. 

  919.                     if (($i+1) % 1000 == 0) {

    920. 

  920.                         echo "<br />";

    921. 

  921.                     }

    922. 

  922.                 }

    923. 

  923.                 backup_flush(300);

    924. 

  924.             }

    925. 

  925. 

    926. 

  926.             //Now restore numerical_units

    927. 

  927.             $status = quiz_restore_pre15_numerical_units ($old_question_id,$new_question_id,$cal_info,$restore);

    928. 

  928. 

    929. 

  929.             //Now restore dataset_definitions

    930. 

  930.             if ($status && $newid) {

    931. 

  931.                 $status = quiz_restore_pre15_dataset_definitions ($old_question_id,$new_question_id,$cal_info,$restore);

    932. 

  932.             }

    933. 

  933. 

    934. 

  934.             if (!$newid) {

    935. 

  935.                 $status = false;

    936. 

  936.             }

    937. 

  937.         }

    938. 

  938. 

    939. 

  939.         return $status;

    940. 

  940.     }

    941. 

  941. 

    942. 

  942.     function quiz_restore_pre15_multianswer ($old_question_id,$new_question_id,$info,$restore) {

    943. 

  943. 

    944. 

  944.         global $CFG;

    945. 

  945. 

    946. 

  946.         $status = true;

    947. 

  947. 

    948. 

  948.         //We need some question fields here so we get the full record from DB

    949. 

  949.         $parentquestion = get_record('question','id',$new_question_id);

    950. 

  950. 

    951. 

  951.         //We need to store all the positions with their created questions

    952. 

  952.         //to be able to calculate the sequence field

    953. 

  953.         $createdquestions = array();

    954. 

  954. 

    955. 

  955.         //Under 1.5, every multianswer record becomes a question itself

    956. 

  956.         //with its parent set to the cloze question. And there is only

    957. 

  957.         //ONE multianswer record with the sequence of questions used.

    958. 

  958. 

    959. 

  959.         //Get the multianswers array

    960. 

  960.         $multianswers_array = $info['#']['MULTIANSWERS']['0']['#']['MULTIANSWER'];

    961. 

  961.         //Iterate over multianswers_array

    962. 

  962.         for($i = 0; $i < sizeof($multianswers_array); $i++) {

    963. 

  963.             $mul_info = $multianswers_array[$i];

    964. 

  964.             //traverse_xmlize($mul_info);                                                                 //Debug

    965. 

  965.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    966. 

  966.             //$GLOBALS['traverse_array']="";                                                              //Debug

    967. 

  967. 

    968. 

  968.             //We need this later

    969. 

  969.             $oldid = backup_todb($mul_info['#']['ID']['0']['#']);

    970. 

  970. 

    971. 

  971.             //Now, build the question_multianswer record structure

    972. 

  972.             $multianswer->question = $new_question_id;

    973. 

  973.             $multianswer->answers = backup_todb($mul_info['#']['ANSWERS']['0']['#']);

    974. 

  974.             $multianswer->positionkey = backup_todb($mul_info['#']['POSITIONKEY']['0']['#']);

    975. 

  975.             $multianswer->answertype = backup_todb($mul_info['#']['ANSWERTYPE']['0']['#']);

    976. 

  976.             $multianswer->norm = backup_todb($mul_info['#']['NORM']['0']['#']);

    977. 

  977. 

    978. 

  978.             //Saving multianswer and positionkey to use them later restoring states

    979. 

  979.             backup_putid ($restore->backup_unique_code,'multianswer-pos',$oldid,$multianswer->positionkey);

    980. 

  980. 

    981. 

  981.             //We have to recode all the answers to their new ids

    982. 

  982.             $ansarr = explode(",", $multianswer->answers);

    983. 

  983.             foreach ($ansarr as $key => $value) {

    984. 

  984.                 //Get the answer from backup_ids

    985. 

  985.                 $answer = backup_getid($restore->backup_unique_code,'question_answers',$value);

    986. 

  986.                 $ansarr[$key] = $answer->new_id;

    987. 

  987.             }

    988. 

  988.             $multianswer->answers = implode(",",$ansarr);

    989. 

  989. 

    990. 

  990.             //Build the new question structure

    991. 

  991.             $question = new object;

    992. 

  992.             $question->category           = $parentquestion->category;

    993. 

  993.             $question->parent             = $parentquestion->id;

    994. 

  994.             $question->name               = $parentquestion->name;

    995. 

  995.             $question->questiontextformat = $parentquestion->questiontextformat;

    996. 

  996.             $question->defaultgrade       = $multianswer->norm;

    997. 

  997.             $question->penalty            = $parentquestion->penalty;

    998. 

  998.             $question->qtype              = $multianswer->answertype;

    999. 

  999.             $question->version            = $parentquestion->version;

    1000. 

  1000.             $question->hidden             = $parentquestion->hidden;

    1001. 

  1001.             $question->length             = 0;

    1002. 

  1002.             $question->questiontext       = '';

    1003. 

  1003.             $question->stamp              = make_unique_id_code();

    1004. 

  1004. 

    1005. 

  1005.             //Save the new question to DB

    1006. 

  1006.             $newid = insert_record('question', $question);

    1007. 

  1007. 

    1008. 

  1008.             if ($newid) {

    1009. 

  1009.                 $createdquestions[$multianswer->positionkey] = $newid;

    1010. 

  1010.             }

    1011. 

  1011. 

    1012. 

  1012.             //Do some output

    1013. 

  1013.             if (($i+1) % 50 == 0) {

    1014. 

  1014.                 if (!defined('RESTORE_SILENTLY')) {

    1015. 

  1015.                     echo ".";

    1016. 

  1016.                     if (($i+1) % 1000 == 0) {

    1017. 

  1017.                         echo "<br />";

    1018. 

  1018.                     }

    1019. 

  1019.                 }

    1020. 

  1020.                 backup_flush(300);

    1021. 

  1021.             }

    1022. 

  1022. 

    1023. 

  1023.             //Remap question_answers records from the original multianswer question

    1024. 

  1024.             //to their newly created question

    1025. 

  1025.             if ($newid) {

    1026. 

  1026.                 $answersdb = get_records_list('question_answers','id',$multianswer->answers);

    1027. 

  1027.                 foreach ($answersdb as $answerdb) {

    1028. 

  1028.                     set_field('question_answers','question',$newid,'id',$answerdb->id);

    1029. 

  1029.                 }

    1030. 

  1030.             }

    1031. 

  1031. 

    1032. 

  1032.             //If we have created the question record, now, depending of the

    1033. 

  1033.             //answertype, delegate the restore to every qtype function

    1034. 

  1034.             if ($newid) {

    1035. 

  1035.                 if ($multianswer->answertype == "1") {

    1036. 

  1036.                     $status = quiz_restore_pre15_shortanswer ($old_question_id,$newid,$mul_info,$restore,$multianswer->answers);

    1037. 

  1037.                 } else if ($multianswer->answertype == "3") {

    1038. 

  1038.                     $status = quiz_restore_pre15_multichoice ($old_question_id,$newid,$mul_info,$restore,$multianswer->answers);

    1039. 

  1039.                 } else if ($multianswer->answertype == "8") {

    1040. 

  1040.                     $status = quiz_restore_pre15_numerical ($old_question_id,$newid,$mul_info,$restore,$multianswer->answers);

    1041. 

  1041.                 }

    1042. 

  1042.             } else {

    1043. 

  1043.                 $status = false;

    1044. 

  1044.             }

    1045. 

  1045.         }

    1046. 

  1046. 

    1047. 

  1047.         //Everything is created, just going to create the multianswer record

    1048. 

  1048.         if ($status) {

    1049. 

  1049.             ksort($createdquestions);

    1050. 

  1050.            

    1051. 

  1051.             $multianswerdb = new object;

    1052. 

  1052.             $multianswerdb->question = $parentquestion->id;

    1053. 

  1053.             $multianswerdb->sequence = implode(",",$createdquestions);

    1054. 

  1054.             $mid = insert_record('question_multianswer', $multianswerdb);

    1055. 

  1055.   

    1056. 

  1056.             if (!$mid) {

    1057. 

  1057.                 $status = false;

    1058. 

  1058.             }

    1059. 

  1059.         }

    1060. 

  1060. 

    1061. 

  1061.         return $status;

    1062. 

  1062.     }

    1063. 

  1063. 

    1064. 

  1064.     function quiz_restore_pre15_numerical_units ($old_question_id,$new_question_id,$info,$restore) {

    1065. 

  1065. 

    1066. 

  1066.         global $CFG;

    1067. 

  1067. 

    1068. 

  1068.         $status = true;

    1069. 

  1069. 

    1070. 

  1070.         //Get the numerical array

    1071. 

  1071.         $numerical_units = $info['#']['NUMERICAL_UNITS']['0']['#']['NUMERICAL_UNIT'];

    1072. 

  1072. 

    1073. 

  1073.         //Iterate over numerical_units

    1074. 

  1074.         for($i = 0; $i < sizeof($numerical_units); $i++) {

    1075. 

  1075.             $nu_info = $numerical_units[$i];

    1076. 

  1076.             //traverse_xmlize($nu_info);                                                                  //Debug

    1077. 

  1077.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    1078. 

  1078.             //$GLOBALS['traverse_array']="";                                                              //Debug

    1079. 

  1079. 

    1080. 

  1080.             //Now, build the question_numerical_UNITS record structure

    1081. 

  1081.             $numerical_unit->question = $new_question_id;

    1082. 

  1082.             $numerical_unit->multiplier = backup_todb($nu_info['#']['MULTIPLIER']['0']['#']);

    1083. 

  1083.             $numerical_unit->unit = backup_todb($nu_info['#']['UNIT']['0']['#']);

    1084. 

  1084. 

    1085. 

  1085.             //The structure is equal to the db, so insert the question_numerical_units

    1086. 

  1086.             $newid = insert_record ("question_numerical_units",$numerical_unit);

    1087. 

  1087. 

    1088. 

  1088.             if (!$newid) {

    1089. 

  1089.                 $status = false;

    1090. 

  1090.             }

    1091. 

  1091.         }

    1092. 

  1092. 

    1093. 

  1093.         return $status;

    1094. 

  1094.     }

    1095. 

  1095. 

    1096. 

  1096.     function quiz_restore_pre15_dataset_definitions ($old_question_id,$new_question_id,$info,$restore) {

    1097. 

  1097. 

    1098. 

  1098.         global $CFG;

    1099. 

  1099. 

    1100. 

  1100.         $status = true;

    1101. 

  1101. 

    1102. 

  1102.         //Get the dataset_definitions array

    1103. 

  1103.         $dataset_definitions = $info['#']['DATASET_DEFINITIONS']['0']['#']['DATASET_DEFINITION'];

    1104. 

  1104. 

    1105. 

  1105.         //Iterate over dataset_definitions

    1106. 

  1106.         for($i = 0; $i < sizeof($dataset_definitions); $i++) {

    1107. 

  1107.             $dd_info = $dataset_definitions[$i];

    1108. 

  1108.             //traverse_xmlize($dd_info);                                                                  //Debug

    1109. 

  1109.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    1110. 

  1110.             //$GLOBALS['traverse_array']="";                                                              //Debug

    1111. 

  1111. 

    1112. 

  1112.             //Now, build the question_dataset_DEFINITION record structure

    1113. 

  1113.             $dataset_definition->category = backup_todb($dd_info['#']['CATEGORY']['0']['#']);

    1114. 

  1114.             $dataset_definition->name = backup_todb($dd_info['#']['NAME']['0']['#']);

    1115. 

  1115.             $dataset_definition->type = backup_todb($dd_info['#']['TYPE']['0']['#']);

    1116. 

  1116.             $dataset_definition->options = backup_todb($dd_info['#']['OPTIONS']['0']['#']);

    1117. 

  1117.             $dataset_definition->itemcount = backup_todb($dd_info['#']['ITEMCOUNT']['0']['#']);

    1118. 

  1118. 

    1119. 

  1119.             //We have to recode the category field (only if the category != 0)

    1120. 

  1120.             if ($dataset_definition->category != 0) {

    1121. 

  1121.                 $category = backup_getid($restore->backup_unique_code,"question_categories",$dataset_definition->category);

    1122. 

  1122.                 if ($category) {

    1123. 

  1123.                     $dataset_definition->category = $category->new_id;

    1124. 

  1124.                 }

    1125. 

  1125.             }

    1126. 

  1126. 

    1127. 

  1127.             //Now, we hace to decide when to create the new records or reuse an existing one

    1128. 

  1128.             $create_definition = false;

    1129. 

  1129. 

    1130. 

  1130.             //If the dataset_definition->category = 0, it's a individual question dataset_definition, so we'll create it

    1131. 

  1131.             if ($dataset_definition->category == 0) {

    1132. 

  1132.                 $create_definition = true;

    1133. 

  1133.             } else {

    1134. 

  1134.                 //The category isn't 0, so it's a category question dataset_definition, we have to see if it exists

    1135. 

  1135.                 //Look for a definition with the same category, name and type

    1136. 

  1136.                 if ($definitionrec = get_record_sql("SELECT d.*

    1137. 

  1137.                                                      FROM {$CFG->prefix}question_dataset_definitions d

    1138. 

  1138.                                                      WHERE d.category = '$dataset_definition->category' AND

    1139. 

  1139.                                                            d.name = '$dataset_definition->name' AND

    1140. 

  1140.                                                            d.type = '$dataset_definition->type'")) {

    1141. 

  1141.                     //Such dataset_definition exist. Now we must check if it has enough itemcount

    1142. 

  1142.                     if ($definitionrec->itemcount < $dataset_definition->itemcount) {

    1143. 

  1143.                         //We haven't enough itemcount, so we have to create the definition as an individual question one.

    1144. 

  1144.                         $dataset_definition->category = 0;

    1145. 

  1145.                         $create_definition = true;

    1146. 

  1146.                     } else {

    1147. 

  1147.                         //We have enough itemcount, so we'll reuse the existing definition

    1148. 

  1148.                         $create_definition = false;

    1149. 

  1149.                         $newid = $definitionrec->id;

    1150. 

  1150.                     }

    1151. 

  1151.                 } else {

    1152. 

  1152.                     //Such dataset_definition doesn't exist. We'll create it.

    1153. 

  1153.                     $create_definition = true;

    1154. 

  1154.                 }

    1155. 

  1155.             }

    1156. 

  1156. 

    1157. 

  1157.             //If we've to create the definition, do it

    1158. 

  1158.             if ($create_definition) {

    1159. 

  1159.                 //The structure is equal to the db, so insert the question_dataset_definitions

    1160. 

  1160.                 $newid = insert_record ("question_dataset_definitions",$dataset_definition);

    1161. 

  1161.                 if ($newid) {

    1162. 

  1162.                     //Restore question_dataset_items

    1163. 

  1163.                     $status = quiz_restore_pre15_dataset_items($newid,$dd_info,$restore);

    1164. 

  1164.                 }

    1165. 

  1165.             }

    1166. 

  1166. 

    1167. 

  1167.             //Now, we must have a definition (created o reused). Its id is in newid. Create the question_datasets record

    1168. 

  1168.             //to join the question and the dataset_definition

    1169. 

  1169.             if ($newid) {

    1170. 

  1170.                 $question_dataset->question = $new_question_id;

    1171. 

  1171.                 $question_dataset->datasetdefinition = $newid;

    1172. 

  1172.                 $newid = insert_record ("question_datasets",$question_dataset);

    1173. 

  1173.             }

    1174. 

  1174. 

    1175. 

  1175.             if (!$newid) {

    1176. 

  1176.                 $status = false;

    1177. 

  1177.             }

    1178. 

  1178.         }

    1179. 

  1179. 

    1180. 

  1180.         return $status;

    1181. 

  1181.     }

    1182. 

  1182. 

    1183. 

  1183.     function quiz_restore_pre15_dataset_items ($definitionid,$info,$restore) {

    1184. 

  1184. 

    1185. 

  1185.         global $CFG;

    1186. 

  1186. 

    1187. 

  1187.         $status = true;

    1188. 

  1188. 

    1189. 

  1189.         //Get the items array

    1190. 

  1190.         $dataset_items = $info['#']['DATASET_ITEMS']['0']['#']['DATASET_ITEM'];

    1191. 

  1191. 

    1192. 

  1192.         //Iterate over dataset_items

    1193. 

  1193.         for($i = 0; $i < sizeof($dataset_items); $i++) {

    1194. 

  1194.             $di_info = $dataset_items[$i];

    1195. 

  1195.             //traverse_xmlize($di_info);                                                                  //Debug

    1196. 

  1196.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    1197. 

  1197.             //$GLOBALS['traverse_array']="";                                                              //Debug

    1198. 

  1198. 

    1199. 

  1199.             //Now, build the question_dataset_ITEMS record structure

    1200. 

  1200.             $dataset_item->definition = $definitionid;

    1201. 

  1201.             $dataset_item->itemnumber = backup_todb($di_info['#']['NUMBER']['0']['#']);

    1202. 

  1202.             $dataset_item->value = backup_todb($di_info['#']['VALUE']['0']['#']);

    1203. 

  1203. 

    1204. 

  1204.             //The structure is equal to the db, so insert the question_dataset_items

    1205. 

  1205.             $newid = insert_record ("question_dataset_items",$dataset_item);

    1206. 

  1206. 

    1207. 

  1207.             if (!$newid) {

    1208. 

  1208.                 $status = false;

    1209. 

  1209.             }

    1210. 

  1210.         }

    1211. 

  1211. 

    1212. 

  1212.         return $status;

    1213. 

  1213.     }

    1214. 

  1214. 

    1215. 

  1215.     //STEP 2. Restore quizzes and associated structures

    1216. 

  1216.     //    (course dependent)

    1217. 

  1217.     function quiz_restore_pre15_mods($mod,$restore) {

    1218. 

  1218. 

    1219. 

  1219.         global $CFG;

    1220. 

  1220. 

    1221. 

  1221.         $status = true;

    1222. 

  1222. 

    1223. 

  1223.         //Get record from backup_ids

    1224. 

  1224.         $data = backup_getid($restore->backup_unique_code,$mod->modtype,$mod->id);

    1225. 

  1225. 

    1226. 

  1226.         if ($data) {

    1227. 

  1227.             //Now get completed xmlized object

    1228. 

  1228.             $info = $data->info;

    1229. 

  1229.             //if necessary, write to restorelog and adjust date/time fields

    1230. 

  1230.             if ($restore->course_startdateoffset) {

    1231. 

  1231.                 restore_log_date_changes('Quiz', $restore, $info['MOD']['#'], array('TIMEOPEN', 'TIMECLOSE'));

    1232. 

  1232.             }            

    1233. 

  1233.             //traverse_xmlize($info);                                                                     //Debug

    1234. 

  1234.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    1235. 

  1235.             //$GLOBALS['traverse_array']="";                                                              //Debug

    1236. 

  1236. 

    1237. 

  1237.             //Now, build the QUIZ record structure

    1238. 

  1238.             $quiz->course = $restore->course_id;

    1239. 

  1239.             $quiz->name = backup_todb($info['MOD']['#']['NAME']['0']['#']);

    1240. 

  1240.             $quiz->intro = backup_todb($info['MOD']['#']['INTRO']['0']['#']);

    1241. 

  1241.             $quiz->timeopen = backup_todb($info['MOD']['#']['TIMEOPEN']['0']['#']);

    1242. 

  1242.             $quiz->timeclose = backup_todb($info['MOD']['#']['TIMECLOSE']['0']['#']);

    1243. 

  1243.             $quiz->attempts = backup_todb($info['MOD']['#']['ATTEMPTS_NUMBER']['0']['#']);

    1244. 

  1244.             $quiz->attemptonlast = backup_todb($info['MOD']['#']['ATTEMPTONLAST']['0']['#']);

    1245. 

  1245.             $quiz->feedback = backup_todb($info['MOD']['#']['FEEDBACK']['0']['#']);

    1246. 

  1246.             $quiz->correctanswers = backup_todb($info['MOD']['#']['CORRECTANSWERS']['0']['#']);

    1247. 

  1247.             $quiz->grademethod = backup_todb($info['MOD']['#']['GRADEMETHOD']['0']['#']);

    1248. 

  1248.             if (isset($info['MOD']['#']['DECIMALPOINTS']['0']['#'])) { //Only if it's set, to apply DB default else.

    1249. 

  1249.                 $quiz->decimalpoints = backup_todb($info['MOD']['#']['DECIMALPOINTS']['0']['#']);

    1250. 

  1250.             }

    1251. 

  1251.             $quiz->review = backup_todb($info['MOD']['#']['REVIEW']['0']['#']);

    1252. 

  1252.             $quiz->questionsperpage = backup_todb($info['MOD']['#']['QUESTIONSPERPAGE']['0']['#']);

    1253. 

  1253.             $quiz->shufflequestions = backup_todb($info['MOD']['#']['SHUFFLEQUESTIONS']['0']['#']);

    1254. 

  1254.             $quiz->shuffleanswers = backup_todb($info['MOD']['#']['SHUFFLEANSWERS']['0']['#']);

    1255. 

  1255.             $quiz->questions = backup_todb($info['MOD']['#']['QUESTIONS']['0']['#']);

    1256. 

  1256.             $quiz->sumgrades = backup_todb($info['MOD']['#']['SUMGRADES']['0']['#']);

    1257. 

  1257.             $quiz->grade = backup_todb($info['MOD']['#']['GRADE']['0']['#']);

    1258. 

  1258.             $quiz->timecreated = backup_todb($info['MOD']['#']['TIMECREATED']['0']['#']);

    1259. 

  1259.             $quiz->timemodified = backup_todb($info['MOD']['#']['TIMEMODIFIED']['0']['#']);

    1260. 

  1260.             $quiz->timelimit = backup_todb($info['MOD']['#']['TIMELIMIT']['0']['#']);

    1261. 

  1261.             $quiz->password = backup_todb($info['MOD']['#']['PASSWORD']['0']['#']);

    1262. 

  1262.             $quiz->subnet = backup_todb($info['MOD']['#']['SUBNET']['0']['#']);

    1263. 

  1263.             $quiz->popup = backup_todb($info['MOD']['#']['POPUP']['0']['#']);

    1264. 

  1264. 

    1265. 

  1265.             //We have to recode the questions field (a list of questions id)

    1266. 

  1266.             $newquestions = array();

    1267. 

  1267.             if ($questionsarr = explode (",",$quiz->questions)) {

    1268. 

  1268.                 foreach ($questionsarr as $key => $value) {

    1269. 

  1269.                     if ($question = backup_getid($restore->backup_unique_code,"question",$value)) {

    1270. 

  1270.                         $newquestions[] = $question->new_id;

    1271. 

  1271.                     }

    1272. 

  1272.                 }

    1273. 

  1273.             }

    1274. 

  1274.             $quiz->questions = implode (",", $newquestions);

    1275. 

  1275. 

    1276. 

  1276.             //Recalculate the questions field to include page breaks if necessary

    1277. 

  1277.             $quiz->questions = quiz_repaginate($quiz->questions, $quiz->questionsperpage);

    1278. 

  1278. 

    1279. 

  1279.             //Calculate the new review field contents (logic extracted from upgrade)

    1280. 

  1280.             $review = (QUIZ_REVIEW_IMMEDIATELY & (QUIZ_REVIEW_RESPONSES + QUIZ_REVIEW_SCORES));

    1281. 

  1281.             if ($quiz->feedback) {

    1282. 

  1282.                 $review += (QUIZ_REVIEW_IMMEDIATELY & QUIZ_REVIEW_FEEDBACK);

    1283. 

  1283.             }

    1284. 

  1284.             if ($quiz->correctanswers) {

    1285. 

  1285.                 $review += (QUIZ_REVIEW_IMMEDIATELY & QUIZ_REVIEW_ANSWERS);

    1286. 

  1286.             }

    1287. 

  1287.             if ($quiz->review & 1) {

    1288. 

  1288.                 $review += QUIZ_REVIEW_CLOSED;

    1289. 

  1289.             }

    1290. 

  1290.             if ($quiz->review & 2) {

    1291. 

  1291.                 $review += QUIZ_REVIEW_OPEN;

    1292. 

  1292.             }

    1293. 

  1293.             $quiz->review = $review;

    1294. 

  1294. 

    1295. 

  1295.             //The structure is equal to the db, so insert the quiz

    1296. 

  1296.             $newid = insert_record ("quiz",$quiz);

    1297. 

  1297. 

    1298. 

  1298.             //Do some output

    1299. 

  1299.             if (!defined('RESTORE_SILENTLY')) {

    1300. 

  1300.                 echo "<li>".get_string("modulename","quiz")." \"".format_string(stripslashes($quiz->name),true)."\"</li>";

    1301. 

  1301.             }

    1302. 

  1302.             backup_flush(300);

    1303. 

  1303. 

    1304. 

  1304.             if ($newid) {

    1305. 

  1305.                 //We have the newid, update backup_ids

    1306. 

  1306.                 backup_putid($restore->backup_unique_code,$mod->modtype,

    1307. 

  1307.                              $mod->id, $newid);

    1308. 

  1308.                 //We have to restore the quiz_question_instances now (old quiz_question_grades, course level)

    1309. 

  1309.                 $status = quiz_question_instances_restore_pre15_mods($newid,$info,$restore);

    1310. 

  1310.                 //We have to restore the question_versions now (course level table)

    1311. 

  1311.                 $status = quiz_question_versions_restore_pre15_mods($newid,$info,$restore);

    1312. 

  1312.                 //Now check if want to restore user data and do it.

    1313. 

  1313.                 if (restore_userdata_selected($restore,'quiz',$mod->id)) {

    1314. 

  1314.                     //Restore quiz_attempts

    1315. 

  1315.                     $status = quiz_attempts_restore_pre15_mods ($newid,$info,$restore, $quiz->questions);

    1316. 

  1316.                     if ($status) {

    1317. 

  1317.                         //Restore quiz_grades

    1318. 

  1318.                         $status = quiz_grades_restore_pre15_mods ($newid,$info,$restore);

    1319. 

  1319.                     }

    1320. 

  1320.                 }

    1321. 

  1321.             } else {

    1322. 

  1322.                 $status = false;

    1323. 

  1323.             }

    1324. 

  1324.         } else {

    1325. 

  1325.             $status = false;

    1326. 

  1326.         }

    1327. 

  1327. 

    1328. 

  1328.         return $status;

    1329. 

  1329.     }

    1330. 

  1330. 

    1331. 

  1331.     //This function restores the quiz_question_instances (old quiz_question_grades)

    1332. 

  1332.     function quiz_question_instances_restore_pre15_mods($quiz_id,$info,$restore) {

    1333. 

  1333. 

    1334. 

  1334.         global $CFG;

    1335. 

  1335. 

    1336. 

  1336.         $status = true;

    1337. 

  1337. 

    1338. 

  1338.         //Get the quiz_question_grades array

    1339. 

  1339.         $grades = $info['MOD']['#']['QUESTION_GRADES']['0']['#']['QUESTION_GRADE'];

    1340. 

  1340. 

    1341. 

  1341.         //Iterate over question_grades

    1342. 

  1342.         for($i = 0; $i < sizeof($grades); $i++) {

    1343. 

  1343.             $gra_info = $grades[$i];

    1344. 

  1344.             //traverse_xmlize($gra_info);                                                                 //Debug

    1345. 

  1345.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    1346. 

  1346.             //$GLOBALS['traverse_array']="";                                                              //Debug

    1347. 

  1347. 

    1348. 

  1348.             //We'll need this later!!

    1349. 

  1349.             $oldid = backup_todb($gra_info['#']['ID']['0']['#']);

    1350. 

  1350. 

    1351. 

  1351.             //Now, build the QUESTION_GRADES record structure

    1352. 

  1352.             $grade->quiz = $quiz_id;

    1353. 

  1353.             $grade->question = backup_todb($gra_info['#']['QUESTION']['0']['#']);

    1354. 

  1354.             $grade->grade = backup_todb($gra_info['#']['GRADE']['0']['#']);

    1355. 

  1355. 

    1356. 

  1356.             //We have to recode the question field

    1357. 

  1357.             $question = backup_getid($restore->backup_unique_code,"question",$grade->question);

    1358. 

  1358.             if ($question) {

    1359. 

  1359.                 $grade->question = $question->new_id;

    1360. 

  1360.             }

    1361. 

  1361. 

    1362. 

  1362.             //The structure is equal to the db, so insert the quiz_question_grades

    1363. 

  1363.             $newid = insert_record ("quiz_question_instances",$grade);

    1364. 

  1364. 

    1365. 

  1365.             //Do some output

    1366. 

  1366.             if (($i+1) % 10 == 0) {

    1367. 

  1367.                 if (!defined('RESTORE_SILENTLY')) {

    1368. 

  1368.                     echo ".";

    1369. 

  1369.                     if (($i+1) % 200 == 0) {

    1370. 

  1370.                         echo "<br />";

    1371. 

  1371.                     }

    1372. 

  1372.                 }

    1373. 

  1373.                 backup_flush(300);

    1374. 

  1374.             }

    1375. 

  1375. 

    1376. 

  1376.             if ($newid) {

    1377. 

  1377.                 //We have the newid, update backup_ids

    1378. 

  1378.                 backup_putid($restore->backup_unique_code,"quiz_question_instances",$oldid,

    1379. 

  1379.                              $newid);

    1380. 

  1380.             } else {

    1381. 

  1381.                 $status = false;

    1382. 

  1382.             }

    1383. 

  1383.         }

    1384. 

  1384. 

    1385. 

  1385.         return $status;

    1386. 

  1386.     }

    1387. 

  1387. 

    1388. 

  1388.     //This function restores the quiz_question_versions

    1389. 

  1389.     function quiz_question_versions_restore_pre15_mods($quiz_id,$info,$restore) {

    1390. 

  1390. 

    1391. 

  1391.         global $CFG, $USER;

    1392. 

  1392. 

    1393. 

  1393.         $status = true;

    1394. 

  1394. 

    1395. 

  1395.         //Get the quiz_question_versions array

    1396. 

  1396.         $versions = $info['MOD']['#']['QUESTION_VERSIONS']['0']['#']['QUESTION_VERSION'];

    1397. 

  1397. 

    1398. 

  1398.         //Iterate over question_versions

    1399. 

  1399.         for($i = 0; $i < sizeof($versions); $i++) {

    1400. 

  1400.             $ver_info = $versions[$i];

    1401. 

  1401.             //traverse_xmlize($ver_info);                                                                 //Debug

    1402. 

  1402.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    1403. 

  1403.             //$GLOBALS['traverse_array']="";                                                              //Debug

    1404. 

  1404. 

    1405. 

  1405.             //We'll need this later!!

    1406. 

  1406.             $oldid = backup_todb($ver_info['#']['ID']['0']['#']);

    1407. 

  1407. 

    1408. 

  1408.             //Now, build the QUESTION_VERSIONS record structure

    1409. 

  1409.             $version->quiz = $quiz_id;

    1410. 

  1410.             $version->oldquestion = backup_todb($ver_info['#']['OLDQUESTION']['0']['#']);

    1411. 

  1411.             $version->newquestion = backup_todb($ver_info['#']['NEWQUESTION']['0']['#']);

    1412. 

  1412.             $version->userid = backup_todb($ver_info['#']['USERID']['0']['#']);

    1413. 

  1413.             $version->timestamp = backup_todb($ver_info['#']['TIMESTAMP']['0']['#']);

    1414. 

  1414. 

    1415. 

  1415.             //We have to recode the oldquestion field

    1416. 

  1416.             $question = backup_getid($restore->backup_unique_code,"question",$version->oldquestion);

    1417. 

  1417.             if ($question) {

    1418. 

  1418.                 $version->oldquestion = $question->new_id;

    1419. 

  1419.             }

    1420. 

  1420. 

    1421. 

  1421.             //We have to recode the newquestion field

    1422. 

  1422.             $question = backup_getid($restore->backup_unique_code,"question",$version->newquestion);

    1423. 

  1423.             if ($question) {

    1424. 

  1424.                 $version->newquestion = $question->new_id;

    1425. 

  1425.             }

    1426. 

  1426. 

    1427. 

  1427.             //We have to recode the userid field

    1428. 

  1428.             $user = backup_getid($restore->backup_unique_code,"user",$version->userid);

    1429. 

  1429.             if ($user) {

    1430. 

  1430.                 $version->userid = $user->new_id;

    1431. 

  1431.             } else {  //Assign to current user

    1432. 

  1432.                 $version->userid = $USER->id;

    1433. 

  1433.             }

    1434. 

  1434. 

    1435. 

  1435.             //The structure is equal to the db, so insert the quiz_question_versions

    1436. 

  1436.             $newid = insert_record ("quiz_question_versions",$version);

    1437. 

  1437. 

    1438. 

  1438.             //Do some output

    1439. 

  1439.             if (($i+1) % 10 == 0) {

    1440. 

  1440.                 if (!defined('RESTORE_SILENTLY')) {

    1441. 

  1441.                     echo ".";

    1442. 

  1442.                     if (($i+1) % 200 == 0) {

    1443. 

  1443.                         echo "<br />";

    1444. 

  1444.                     }

    1445. 

  1445.                 }

    1446. 

  1446.                 backup_flush(300);

    1447. 

  1447.             }

    1448. 

  1448. 

    1449. 

  1449.             if ($newid) {

    1450. 

  1450.                 //We have the newid, update backup_ids

    1451. 

  1451.                 backup_putid($restore->backup_unique_code,"quiz_question_versions",$oldid,

    1452. 

  1452.                              $newid);

    1453. 

  1453.             } else {

    1454. 

  1454.                 $status = false;

    1455. 

  1455.             }

    1456. 

  1456.         }

    1457. 

  1457. 

    1458. 

  1458.         return $status;

    1459. 

  1459.     }

    1460. 

  1460. 

    1461. 

  1461.     //This function restores the quiz_attempts

    1462. 

  1462.     function quiz_attempts_restore_pre15_mods($quiz_id,$info,$restore,$quizquestions) {

    1463. 

  1463. 

    1464. 

  1464.         global $CFG;

    1465. 

  1465. 

    1466. 

  1466.         $status = true;

    1467. 

  1467. 

    1468. 

  1468.         //Get the quiz_attempts array

    1469. 

  1469.         $attempts = $info['MOD']['#']['ATTEMPTS']['0']['#']['ATTEMPT'];

    1470. 

  1470. 

    1471. 

  1471.         //Iterate over attempts

    1472. 

  1472.         for($i = 0; $i < sizeof($attempts); $i++) {

    1473. 

  1473.             $att_info = $attempts[$i];

    1474. 

  1474.             //traverse_xmlize($att_info);                                                                 //Debug

    1475. 

  1475.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    1476. 

  1476.             //$GLOBALS['traverse_array']="";                                                              //Debug

    1477. 

  1477. 

    1478. 

  1478.             //We'll need this later!!

    1479. 

  1479.             $oldid = backup_todb($att_info['#']['ID']['0']['#']);

    1480. 

  1480.             $olduserid = backup_todb($att_info['#']['USERID']['0']['#']);

    1481. 

  1481. 

    1482. 

  1482.             //Now, build the ATTEMPTS record structure

    1483. 

  1483.             $attempt->quiz = $quiz_id;

    1484. 

  1484.             $attempt->userid = backup_todb($att_info['#']['USERID']['0']['#']);

    1485. 

  1485.             $attempt->attempt = backup_todb($att_info['#']['ATTEMPTNUM']['0']['#']);

    1486. 

  1486.             $attempt->sumgrades = backup_todb($att_info['#']['SUMGRADES']['0']['#']);

    1487. 

  1487.             $attempt->timestart = backup_todb($att_info['#']['TIMESTART']['0']['#']);

    1488. 

  1488.             $attempt->timefinish = backup_todb($att_info['#']['TIMEFINISH']['0']['#']);

    1489. 

  1489.             $attempt->timemodified = backup_todb($att_info['#']['TIMEMODIFIED']['0']['#']);

    1490. 

  1490. 

    1491. 

  1491.             //We have to recode the userid field

    1492. 

  1492.             $user = backup_getid($restore->backup_unique_code,"user",$attempt->userid);

    1493. 

  1493.             if ($user) {

    1494. 

  1494.                 $attempt->userid = $user->new_id;

    1495. 

  1495.             }

    1496. 

  1496. 

    1497. 

  1497.             //Set the layout field (inherited from quiz by default)

    1498. 

  1498.             $attempt->layout = $quizquestions;

    1499. 

  1499. 

    1500. 

  1500.             //Set the preview field (code from upgrade)

    1501. 

  1501.             $cm = get_coursemodule_from_instance('quiz', $quiz_id);

    1502. 

  1502.             if (has_capability('mod/quiz:preview', get_context_instance(CONTEXT_MODULE, $cm->id))) {

    1503. 

  1503.                 $attempt->preview = 1;

    1504. 

  1504.             }

    1505. 

  1505. 

    1506. 

  1506.             //Set the uniqueid field

    1507. 

  1507.             $attempt->uniqueid = question_new_attempt_uniqueid();

    1508. 

  1508. 

    1509. 

  1509.             //The structure is equal to the db, so insert the quiz_attempts

    1510. 

  1510.             $newid = insert_record ("quiz_attempts",$attempt);

    1511. 

  1511. 

    1512. 

  1512.             //Do some output

    1513. 

  1513.             if (($i+1) % 10 == 0) {

    1514. 

  1514.                 if (!defined('RESTORE_SILENTLY')) {

    1515. 

  1515.                     echo ".";

    1516. 

  1516.                     if (($i+1) % 200 == 0) {

    1517. 

  1517.                         echo "<br />";

    1518. 

  1518.                     }

    1519. 

  1519.                 }

    1520. 

  1520.                 backup_flush(300);

    1521. 

  1521.             }

    1522. 

  1522. 

    1523. 

  1523.             if ($newid) {

    1524. 

  1524.                 //We have the newid, update backup_ids

    1525. 

  1525.                 backup_putid($restore->backup_unique_code,"quiz_attempts",$oldid,

    1526. 

  1526.                              $newid);

    1527. 

  1527.                 //Now process question_states (old quiz_responses table)

    1528. 

  1528.                 $status = question_states_restore_pre15_mods($newid,$att_info,$restore);

    1529. 

  1529.             } else {

    1530. 

  1530.                 $status = false;

    1531. 

  1531.             }

    1532. 

  1532.         }

    1533. 

  1533. 

    1534. 

  1534.         return $status;

    1535. 

  1535.     }

    1536. 

  1536. 

    1537. 

  1537.     //This function restores the question_states (old quiz_responses)

    1538. 

  1538.     function question_states_restore_pre15_mods($attempt_id,$info,$restore) {

    1539. 

  1539. 

    1540. 

  1540.         global $CFG;

    1541. 

  1541. 

    1542. 

  1542.         $status = true;

    1543. 

  1543. 

    1544. 

  1544.         //Get the quiz_responses array

    1545. 

  1545.         $responses = $info['#']['RESPONSES']['0']['#']['RESPONSE'];

    1546. 

  1546.         //Iterate over responses

    1547. 

  1547.         for($i = 0; $i < sizeof($responses); $i++) {

    1548. 

  1548.             $res_info = $responses[$i];

    1549. 

  1549.             //traverse_xmlize($res_info);                                                                 //Debug

    1550. 

  1550.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    1551. 

  1551.             //$GLOBALS['traverse_array']="";                                                              //Debug

    1552. 

  1552. 

    1553. 

  1553.             //We'll need this later!!

    1554. 

  1554.             $oldid = backup_todb($res_info['#']['ID']['0']['#']);

    1555. 

  1555. 

    1556. 

  1556.             //Now, build the RESPONSES record structure

    1557. 

  1557.             $response->attempt = $attempt_id;

    1558. 

  1558.             $response->question = backup_todb($res_info['#']['QUESTION']['0']['#']);

    1559. 

  1559.             $response->originalquestion = backup_todb($res_info['#']['ORIGINALQUESTION']['0']['#']);

    1560. 

  1560.             $response->answer = backup_todb($res_info['#']['ANSWER']['0']['#']);

    1561. 

  1561.             $response->grade = backup_todb($res_info['#']['GRADE']['0']['#']);

    1562. 

  1562. 

    1563. 

  1563.             //We have to recode the question field

    1564. 

  1564.             $question = backup_getid($restore->backup_unique_code,"question",$response->question);

    1565. 

  1565.             if ($question) {

    1566. 

  1566.                 $response->question = $question->new_id;

    1567. 

  1567.             }

    1568. 

  1568. 

    1569. 

  1569.             //We have to recode the originalquestion field

    1570. 

  1570.             $question = backup_getid($restore->backup_unique_code,"question",$response->originalquestion);

    1571. 

  1571.             if ($question) {

    1572. 

  1572.                 $response->originalquestion = $question->new_id;

    1573. 

  1573.             }

    1574. 

  1574. 

    1575. 

  1575.             //Set the raw_grade field (default to the existing grade one, no penalty in pre15 backups)

    1576. 

  1576.             $response->raw_grade = $response->grade;

    1577. 

  1577. 

    1578. 

  1578.             //We have to recode the answer field

    1579. 

  1579.             //It depends of the question type !!

    1580. 

  1580.             //We get the question first

    1581. 

  1581.             $question = get_record("question","id",$response->question);

    1582. 

  1582.             //It exists

    1583. 

  1583.             if ($question) {

    1584. 

  1584.                 //Depending of the qtype, we make different recodes

    1585. 

  1585.                 switch ($question->qtype) {

    1586. 

  1586.                     case 1:    //SHORTANSWER QTYPE

    1587. 

  1587.                         //Nothing to do. The response is a text.

    1588. 

  1588.                         break;

    1589. 

  1589.                     case 2:    //TRUEFALSE QTYPE

    1590. 

  1590.                         //The answer is one answer id. We must recode it

    1591. 

  1591.                         $answer = backup_getid($restore->backup_unique_code,"question_answers",$response->answer);

    1592. 

  1592.                         if ($answer) {

    1593. 

  1593.                             $response->answer = $answer->new_id;

    1594. 

  1594.                         }

    1595. 

  1595.                         break;

    1596. 

  1596.                     case 3:    //MULTICHOICE QTYPE

    1597. 

  1597.                         //The answer is a comma separated list of answers. We must recode them

    1598. 

  1598.                         $answer_field = "";

    1599. 

  1599.                         $in_first = true;

    1600. 

  1600.                         $tok = strtok($response->answer,",");

    1601. 

  1601.                         while ($tok) {

    1602. 

  1602.                             //Get the answer from backup_ids

    1603. 

  1603.                             $answer = backup_getid($restore->backup_unique_code,"question_answers",$tok);

    1604. 

  1604.                             if ($answer) {

    1605. 

  1605.                                 if ($in_first) {

    1606. 

  1606.                                     $answer_field .= $answer->new_id;

    1607. 

  1607.                                     $in_first = false;

    1608. 

  1608.                                 } else {

    1609. 

  1609.                                     $answer_field .= ",".$answer->new_id;

    1610. 

  1610.                                 }

    1611. 

  1611.                             }

    1612. 

  1612.                             //check for next

    1613. 

  1613.                             $tok = strtok(",");

    1614. 

  1614.                         }

    1615. 

  1615.                         $response->answer = $answer_field;

    1616. 

  1616.                         break;

    1617. 

  1617.                     case 4:    //RANDOM QTYPE

    1618. 

  1618.                         //The answer links to another question id, we must recode it

    1619. 

  1619.                         $answer_link = backup_getid($restore->backup_unique_code,"question",$response->answer);

    1620. 

  1620.                         if ($answer_link) {

    1621. 

  1621.                             $response->answer = $answer_link->new_id;

    1622. 

  1622.                         }

    1623. 

  1623.                         break;

    1624. 

  1624.                     case 5:    //MATCH QTYPE

    1625. 

  1625.                         //The answer is a comma separated list of hypen separated math_subs (for question and answer)

    1626. 

  1626.                         $answer_field = "";

    1627. 

  1627.                         $in_first = true;

    1628. 

  1628.                         $tok = strtok($response->answer,",");

    1629. 

  1629.                         while ($tok) {

    1630. 

  1630.                             //Extract the match_sub for the question and the answer

    1631. 

  1631.                             $exploded = explode("-",$tok);

    1632. 

  1632.                             $match_question_id = $exploded[0];

    1633. 

  1633.                             $match_answer_id = $exploded[1];

    1634. 

  1634.                             //Get the match_sub from backup_ids (for the question)

    1635. 

  1635.                             $match_que = backup_getid($restore->backup_unique_code,"question_match_sub",$match_question_id);

    1636. 

  1636.                             //Get the match_sub from backup_ids (for the answer)

    1637. 

  1637.                             $match_ans = backup_getid($restore->backup_unique_code,"question_match_sub",$match_answer_id);

    1638. 

  1638.                             if ($match_que) {

    1639. 

  1639.                                 //It the question hasn't response, it must be 0

    1640. 

  1640.                                 if (!$match_ans and $match_answer_id == 0) {

    1641. 

  1641.                                     $match_ans->new_id = 0;

    1642. 

  1642.                                 }

    1643. 

  1643.                                 if ($in_first) {

    1644. 

  1644.                                     $answer_field .= $match_que->new_id."-".$match_ans->new_id;

    1645. 

  1645.                                     $in_first = false;

    1646. 

  1646.                                 } else {

    1647. 

  1647.                                     $answer_field .= ",".$match_que->new_id."-".$match_ans->new_id;

    1648. 

  1648.                                 }

    1649. 

  1649.                             }

    1650. 

  1650.                             //check for next

    1651. 

  1651.                             $tok = strtok(",");

    1652. 

  1652.                         }

    1653. 

  1653.                         $response->answer = $answer_field;

    1654. 

  1654.                         break;

    1655. 

  1655.                     case 6:    //RANDOMSAMATCH QTYPE

    1656. 

  1656.                         //The answer is a comma separated list of hypen separated question_id and answer_id. We must recode them

    1657. 

  1657.                         $answer_field = "";

    1658. 

  1658.                         $in_first = true;

    1659. 

  1659.                         $tok = strtok($response->answer,",");

    1660. 

  1660.                         while ($tok) {

    1661. 

  1661.                             //Extract the question_id and the answer_id

    1662. 

  1662.                             $exploded = explode("-",$tok);

    1663. 

  1663.                             $question_id = $exploded[0];

    1664. 

  1664.                             $answer_id = $exploded[1];

    1665. 

  1665.                             //Get the question from backup_ids

    1666. 

  1666.                             $que = backup_getid($restore->backup_unique_code,"question",$question_id);

    1667. 

  1667.                             //Get the answer from backup_ids

    1668. 

  1668.                             $ans = backup_getid($restore->backup_unique_code,"question_answers",$answer_id);

    1669. 

  1669.                             if ($que) {

    1670. 

  1670.                                 //It the question hasn't response, it must be 0

    1671. 

  1671.                                 if (!$ans and $answer_id == 0) {

    1672. 

  1672.                                     $ans->new_id = 0;

    1673. 

  1673.                                 }

    1674. 

  1674.                                 if ($in_first) {

    1675. 

  1675.                                     $answer_field .= $que->new_id."-".$ans->new_id;

    1676. 

  1676.                                     $in_first = false;

    1677. 

  1677.                                 } else {

    1678. 

  1678.                                     $answer_field .= ",".$que->new_id."-".$ans->new_id;

    1679. 

  1679.                                 }

    1680. 

  1680.                             }

    1681. 

  1681.                             //check for next

    1682. 

  1682.                             $tok = strtok(",");

    1683. 

  1683.                         }

    1684. 

  1684.                         $response->answer = $answer_field;

    1685. 

  1685.                         break;

    1686. 

  1686.                     case 7:    //DESCRIPTION QTYPE

    1687. 

  1687.                         //Nothing to do (there is no awser to this qtype)

    1688. 

  1688.                         //But this case must exist !!

    1689. 

  1689.                         break;

    1690. 

  1690.                     case 8:    //NUMERICAL QTYPE

    1691. 

  1691.                         //Nothing to do. The response is a text.

    1692. 

  1692.                         break;

    1693. 

  1693.                     case 9:    //MULTIANSWER QTYPE

    1694. 

  1694.                         //The answer is a comma separated list of hypen separated multianswer ids and answers. We must recode them.

    1695. 

  1695.                         //We need to have the sequence of questions here to be able to detect qtypes

    1696. 

  1696.                         $multianswerdb = get_record('question_multianswer','question',$response->question);

    1697. 

  1697.                         //Make an array of sequence to easy access

    1698. 

  1698.                         $sequencearr = explode(",",$multianswerdb->sequence);

    1699. 

  1699.                         $answer_field = "";

    1700. 

  1700.                         $in_first = true;

    1701. 

  1701.                         $tok = strtok($response->answer,",");

    1702. 

  1702.                         $counter = 1;

    1703. 

  1703.                         while ($tok) {

    1704. 

  1704.                             //Extract the multianswer_id and the answer

    1705. 

  1705.                             $exploded = explode("-",$tok);

    1706. 

  1706.                             $multianswer_id = $exploded[0];

    1707. 

  1707.                             $answer = $exploded[1];

    1708. 

  1708.                             //Get position key (if it fails, next iteration)

    1709. 

  1709.                             if ($oldposrec = backup_getid($restore->backup_unique_code,'multianswer-pos',$multianswer_id)) {

    1710. 

  1710.                                 $positionkey = $oldposrec->new_id;

    1711. 

  1711.                             } else {

    1712. 

  1712.                                 //Next iteration

    1713. 

  1713.                                 $tok = strtok(",");

    1714. 

  1714.                                 continue;

    1715. 

  1715.                             }

    1716. 

  1716.                             //Calculate question type

    1717. 

  1717.                             $questiondb = get_record('question','id',$sequencearr[$counter-1]);

    1718. 

  1718.                             $questiontype = $questiondb->qtype;

    1719. 

  1719.                             //Now, depending of the answertype field in question_multianswer

    1720. 

  1720.                             //we do diferent things

    1721. 

  1721.                             if ($questiontype == "1") {

    1722. 

  1722.                                 //Shortanswer

    1723. 

  1723.                                 //The answer is text, do nothing

    1724. 

  1724.                             } else if ($questiontype == "3") {

    1725. 

  1725.                                 //Multichoice

    1726. 

  1726.                                 //The answer is an answer_id, look for it in backup_ids

    1727. 

  1727.                                 $ans = backup_getid($restore->backup_unique_code,"question_answers",$answer);

    1728. 

  1728.                                 $answer = $ans->new_id;

    1729. 

  1729.                             } else if ($questiontype == "8") {

    1730. 

  1730.                                 //Numeric

    1731. 

  1731.                                 //The answer is text, do nothing

    1732. 

  1732.                             }

    1733. 

  1733. 

    1734. 

  1734.                             //Finaly, build the new answer field for each pair

    1735. 

  1735.                             if ($in_first) {

    1736. 

  1736.                                 $answer_field .= $positionkey."-".$answer;

    1737. 

  1737.                                 $in_first = false;

    1738. 

  1738.                             } else {

    1739. 

  1739.                                 $answer_field .= ",".$positionkey."-".$answer;

    1740. 

  1740.                             }

    1741. 

  1741.                             //check for next

    1742. 

  1742.                             $tok = strtok(",");

    1743. 

  1743.                             $counter++;

    1744. 

  1744.                         }

    1745. 

  1745.                         $response->answer = $answer_field;

    1746. 

  1746.                         break;

    1747. 

  1747.                     case 10:    //CALCULATED QTYPE

    1748. 

  1748.                         //Nothing to do. The response is a text.

    1749. 

  1749.                         break;

    1750. 

  1750.                     default:   //UNMATCHED QTYPE.

    1751. 

  1751.                         //This is an error (unimplemented qtype)

    1752. 

  1752.                         $status = false;

    1753. 

  1753.                         break;

    1754. 

  1754.                 }

    1755. 

  1755.             } else {

    1756. 

  1756.                 $status = false;

    1757. 

  1757.             }

    1758. 

  1758. 

    1759. 

  1759.             //The structure is equal to the db, so insert the question_states

    1760. 

  1760.             $newid = insert_record ("question_states",$response);

    1761. 

  1761. 

    1762. 

  1762.             //Do some output

    1763. 

  1763.             if (($i+1) % 10 == 0) {

    1764. 

  1764.                 if (!defined('RESTORE_SILENTLY')) {

    1765. 

  1765.                     echo ".";

    1766. 

  1766.                     if (($i+1) % 200 == 0) {

    1767. 

  1767.                         echo "<br />";

    1768. 

  1768.                     }

    1769. 

  1769.                 }

    1770. 

  1770.                 backup_flush(300);

    1771. 

  1771.             }

    1772. 

  1772. 

    1773. 

  1773.             if ($newid) {

    1774. 

  1774.                 //We have the newid, update backup_ids

    1775. 

  1775.                 backup_putid($restore->backup_unique_code,"question_states",$oldid,

    1776. 

  1776.                              $newid);

    1777. 

  1777.             } else {

    1778. 

  1778.                 $status = false;

    1779. 

  1779.             }

    1780. 

  1780.         }

    1781. 

  1781. 

    1782. 

  1782.         return $status;

    1783. 

  1783.     }

    1784. 

  1784. 

    1785. 

  1785.     //This function restores the quiz_grades

    1786. 

  1786.     function quiz_grades_restore_pre15_mods($quiz_id,$info,$restore) {

    1787. 

  1787. 

    1788. 

  1788.         global $CFG;

    1789. 

  1789. 

    1790. 

  1790.         $status = true;

    1791. 

  1791. 

    1792. 

  1792.         //Get the quiz_grades array

    1793. 

  1793.         $grades = $info['MOD']['#']['GRADES']['0']['#']['GRADE'];

    1794. 

  1794. 

    1795. 

  1795.         //Iterate over grades

    1796. 

  1796.         for($i = 0; $i < sizeof($grades); $i++) {

    1797. 

  1797.             $gra_info = $grades[$i];

    1798. 

  1798.             //traverse_xmlize($gra_info);                                                                 //Debug

    1799. 

  1799.             //print_object ($GLOBALS['traverse_array']);                                                  //Debug

    1800. 

  1800.             //$GLOBALS['traverse_array']="";                                                              //Debug

    1801. 

  1801. 

    1802. 

  1802.             //We'll need this later!!

    1803. 

  1803.             $oldid = backup_todb($gra_info['#']['ID']['0']['#']);

    1804. 

  1804.             $olduserid = backup_todb($gra_info['#']['USERID']['0']['#']);

    1805. 

  1805. 

    1806. 

  1806.             //Now, build the GRADES record structure

    1807. 

  1807.             $grade->quiz = $quiz_id;

    1808. 

  1808.             $grade->userid = backup_todb($gra_info['#']['USERID']['0']['#']);

    1809. 

  1809.             $grade->grade = backup_todb($gra_info['#']['GRADEVAL']['0']['#']);

    1810. 

  1810.             $grade->timemodified = backup_todb($gra_info['#']['TIMEMODIFIED']['0']['#']);

    1811. 

  1811. 

    1812. 

  1812.             //We have to recode the userid field

    1813. 

  1813.             $user = backup_getid($restore->backup_unique_code,"user",$grade->userid);

    1814. 

  1814.             if ($user) {

    1815. 

  1815.                 $grade->userid = $user->new_id;

    1816. 

  1816.             }

    1817. 

  1817. 

    1818. 

  1818.             //The structure is equal to the db, so insert the quiz_grades

    1819. 

  1819.             $newid = insert_record ("quiz_grades",$grade);

    1820. 

  1820. 

    1821. 

  1821.             //Do some output

    1822. 

  1822.             if (($i+1) % 10 == 0) {

    1823. 

  1823.                 if (!defined('RESTORE_SILENTLY')) {

    1824. 

  1824.                     echo ".";

    1825. 

  1825.                     if (($i+1) % 200 == 0) {

    1826. 

  1826.                         echo "<br />";

    1827. 

  1827.                     }

    1828. 

  1828.                 }

    1829. 

  1829.                 backup_flush(300);

    1830. 

  1830.             }

    1831. 

  1831. 

    1832. 

  1832.             if ($newid) {

    1833. 

  1833.                 //We have the newid, update backup_ids

    1834. 

  1834.                 backup_putid($restore->backup_unique_code,"quiz_grades",$oldid,

    1835. 

  1835.                              $newid);

    1836. 

  1836.             } else {

    1837. 

  1837.                 $status = false;

    1838. 

  1838.             }

    1839. 

  1839.         }

    1840. 

  1840. 

    1841. 

  1841.         return $status;

    1842. 

  1842.     }

    1843. 

  1843. 

    1844. 

  1844.     //This function converts texts in FORMAT_WIKI to FORMAT_MARKDOWN for

    1845. 

  1845.     //some texts in the module

    1846. 

  1846.     function quiz_restore_pre15_wiki2markdown ($restore) {

    1847. 

  1847. 

    1848. 

  1848.         global $CFG;

    1849. 

  1849. 

    1850. 

  1850.         $status = true;

    1851. 

  1851. 

    1852. 

  1852.         //Convert question->questiontext

    1853. 

  1853.         if ($records = get_records_sql ("SELECT q.id, q.questiontext, q.questiontextformat

    1854. 

  1854.                                          FROM {$CFG->prefix}question q,

    1855. 

  1855.                                               {$CFG->prefix}backup_ids b

    1856. 

  1856.                                          WHERE b.backup_code = $restore->backup_unique_code AND

    1857. 

  1857.                                                b.table_name = 'question' AND

    1858. 

  1858.                                                q.id = b.new_id AND

    1859. 

  1859.                                                q.questiontextformat = ".FORMAT_WIKI)) {

    1860. 

  1860.             foreach ($records as $record) {

    1861. 

  1861.                 //Rebuild wiki links

    1862. 

  1862.                 $record->questiontext = restore_decode_wiki_content($record->questiontext, $restore);

    1863. 

  1863.                 //Convert to Markdown

    1864. 

  1864.                 $wtm = new WikiToMarkdown();

    1865. 

  1865.                 $record->questiontext = $wtm->convert($record->questiontext, $restore->course_id);

    1866. 

  1866.                 $record->questiontextformat = FORMAT_MARKDOWN;

    1867. 

  1867.                 $status = update_record('question', addslashes_object($record));

    1868. 

  1868.                 //Do some output

    1869. 

  1869.                 $i++;

    1870. 

  1870.                 if (($i+1) % 1 == 0) {

    1871. 

  1871.                     if (!defined('RESTORE_SILENTLY')) {

    1872. 

  1872.                         echo ".";

    1873. 

  1873.                         if (($i+1) % 20 == 0) {

    1874. 

  1874.                             echo "<br />";

    1875. 

  1875.                         }

    1876. 

  1876.                     }

    1877. 

  1877.                     backup_flush(300);

    1878. 

  1878.                 }

    1879. 

  1879.             }

    1880. 

  1880.         }

    1881. 

  1881.         return $status;

    1882. 

  1882.     }

    1883. 

  1883. 

    1884. 

  1884.     //This function returns a log record with all the necessay transformations

    1885. 

  1885.     //done. It's used by restore_log_module() to restore modules log.

    1886. 

  1886.     function quiz_restore_pre15_logs($restore,$log) {

    1887. 

  1887. 

    1888. 

  1888.         $status = false;

    1889. 

  1889. 

    1890. 

  1890.         //Depending of the action, we recode different things

    1891. 

  1891.         switch ($log->action) {

    1892. 

  1892.         case "add":

    1893. 

  1893.             if ($log->cmid) {

    1894. 

  1894.                 //Get the new_id of the module (to recode the info field)

    1895. 

  1895.                 $mod = backup_getid($restore->backup_unique_code,$log->module,$log->info);

    1896. 

  1896.                 if ($mod) {

    1897. 

  1897.                     $log->url = "view.php?id=".$log->cmid;

    1898. 

  1898.                     $log->info = $mod->new_id;

    1899. 

  1899.                     $status = true;

    1900. 

  1900.                 }

    1901. 

  1901.             }

    1902. 

  1902.             break;

    1903. 

  1903.         case "update":

    1904. 

  1904.             if ($log->cmid) {

    1905. 

  1905.                 //Get the new_id of the module (to recode the info field)

    1906. 

  1906.                 $mod = backup_getid($restore->backup_unique_code,$log->module,$log->info);

    1907. 

  1907.                 if ($mod) {

    1908. 

  1908.                     $log->url = "view.php?id=".$log->cmid;

    1909. 

  1909.                     $log->info = $mod->new_id;

    1910. 

  1910.                     $status = true;

    1911. 

  1911.                 }

    1912. 

  1912.             }

    1913. 

  1913.             break;

    1914. 

  1914.         case "view":

    1915. 

  1915.             if ($log->cmid) {

    1916. 

  1916.                 //Get the new_id of the module (to recode the info field)

    1917. 

  1917.                 $mod = backup_getid($restore->backup_unique_code,$log->module,$log->info);

    1918. 

  1918.                 if ($mod) {

    1919. 

  1919.                     $log->url = "view.php?id=".$log->cmid;

    1920. 

  1920.                     $log->info = $mod->new_id;

    1921. 

  1921.                     $status = true;

    1922. 

  1922.                 }

    1923. 

  1923.             }

    1924. 

  1924.             break;

    1925. 

  1925.         case "view all":

    1926. 

  1926.             $log->url = "index.php?id=".$log->course;

    1927. 

  1927.             $status = true;

    1928. 

  1928.             break;

    1929. 

  1929.         case "report":

    1930. 

  1930.             if ($log->cmid) {

    1931. 

  1931.                 //Get the new_id of the module (to recode the info field)

    1932. 

  1932.                 $mod = backup_getid($restore->backup_unique_code,$log->module,$log->info);

    1933. 

  1933.                 if ($mod) {

    1934. 

  1934.                     $log->url = "report.php?id=".$log->cmid;

    1935. 

  1935.                     $log->info = $mod->new_id;

    1936. 

  1936.                     $status = true;

    1937. 

  1937.                 }

    1938. 

  1938.             }

    1939. 

  1939.             break;

    1940. 

  1940.         case "attempt":

    1941. 

  1941.             if ($log->cmid) {

    1942. 

  1942.                 //Get the new_id of the module (to recode the info field)

    1943. 

  1943.                 $mod = backup_getid($restore->backup_unique_code,$log->module,$log->info);

    1944. 

  1944.                 if ($mod) {

    1945. 

  1945.                     //Extract the attempt id from the url field

    1946. 

  1946.                     $attid = substr(strrchr($log->url,"="),1);

    1947. 

  1947.                     //Get the new_id of the attempt (to recode the url field)

    1948. 

  1948.                     $att = backup_getid($restore->backup_unique_code,"quiz_attempts",$attid);

    1949. 

  1949.                     if ($att) {

    1950. 

  1950.                         $log->url = "review.php?id=".$log->cmid."&attempt=".$att->new_id;

    1951. 

  1951.                         $log->info = $mod->new_id;

    1952. 

  1952.                         $status = true;

    1953. 

  1953.                     }

    1954. 

  1954.                 }

    1955. 

  1955.             }

    1956. 

  1956.             break;

    1957. 

  1957.         case "submit":

    1958. 

  1958.             if ($log->cmid) {

    1959. 

  1959.                 //Get the new_id of the module (to recode the info field)

    1960. 

  1960.                 $mod = backup_getid($restore->backup_unique_code,$log->module,$log->info);

    1961. 

  1961.                 if ($mod) {

    1962. 

  1962.                     //Extract the attempt id from the url field

    1963. 

  1963.                     $attid = substr(strrchr($log->url,"="),1);

    1964. 

  1964.                     //Get the new_id of the attempt (to recode the url field)

    1965. 

  1965.                     $att = backup_getid($restore->backup_unique_code,"quiz_attempts",$attid);

    1966. 

  1966.                     if ($att) {

    1967. 

  1967.                         $log->url = "review.php?id=".$log->cmid."&attempt=".$att->new_id;

    1968. 

  1968.                         $log->info = $mod->new_id;

    1969. 

  1969.                         $status = true;

    1970. 

  1970.                     }

    1971. 

  1971.                 }

    1972. 

  1972.             }

    1973. 

  1973.             break;

    1974. 

  1974.         case "review":

    1975. 

  1975.             if ($log->cmid) {

    1976. 

  1976.                 //Get the new_id of the module (to recode the info field)

    1977. 

  1977.                 $mod = backup_getid($restore->backup_unique_code,$log->module,$log->info);

    1978. 

  1978.                 if ($mod) {

    1979. 

  1979.                     //Extract the attempt id from the url field

    1980. 

  1980.                     $attid = substr(strrchr($log->url,"="),1);

    1981. 

  1981.                     //Get the new_id of the attempt (to recode the url field)

    1982. 

  1982.                     $att = backup_getid($restore->backup_unique_code,"quiz_attempts",$attid);

    1983. 

  1983.                     if ($att) {

    1984. 

  1984.                         $log->url = "review.php?id=".$log->cmid."&attempt=".$att->new_id;

    1985. 

  1985.                         $log->info = $mod->new_id;

    1986. 

  1986.                         $status = true;

    1987. 

  1987.                     }

    1988. 

  1988.                 }

    1989. 

  1989.             }

    1990. 

  1990.             break;

    1991. 

  1991.         case "editquestions":

    1992. 

  1992.             if ($log->cmid) {

    1993. 

  1993.                 //Get the new_id of the module (to recode the url field)

    1994. 

  1994.                 $mod = backup_getid($restore->backup_unique_code,$log->module,$log->info);

    1995. 

  1995.                 if ($mod) {

    1996. 

  1996.                     $log->url = "view.php?id=".$log->cmid;

    1997. 

  1997.                     $log->info = $mod->new_id;

    1998. 

  1998.                     $status = true;

    1999. 

  1999.                 }

    2000. 

  2000.             }

    2001. 

  2001.             break;

    2002. 

  2002.         default:

    2003. 

  2003.             if (!defined('RESTORE_SILENTLY')) {

    2004. 

  2004.                 echo "action (".$log->module."-".$log->action.") unknow. Not restored<br />";                 //Debug

    2005. 

  2005.             }

    2006. 

  2006.             break;

    2007. 

  2007.         }

    2008. 

  2008. 

    2009. 

  2009.         if ($status) {

    2010. 

  2010.             $status = $log;

    2011. 

  2011.         }

    2012. 

  2012.         return $status;

    2013. 

  2013.     }

    2014. 

  2014. ?>

    2015. 

  2015.