PageRenderTime 91ms CodeModel.GetById 48ms RepoModel.GetById 14ms app.codeStats 0ms

/mod/data/restorelib.php

https://bitbucket.org/ceu/moodle_demo
PHP | 766 lines | 494 code | 117 blank | 155 comment | 119 complexity | 91b400904731caf9f1b351ef08ccaca7 MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.0, LGPL-2.1 
    

  1. <?php // $Id

    2. 

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

    3. 

  3. 

    4. 

  4.     //This is the "graphical" structure of the data mod:

    5. 

  5.     //

    6. 

  6.     //                     data

    7. 

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

    8. 

  8.     //                        |

    9. 

  9.     //                        |

    10. 

  10.     //                        |

    11. 

  11.     //      ---------------------------------------------------------------------------------

    12. 

  12.     //      |                                                                               |

    13. 

  13.     //data_records (UL,pk->id, fk->data)                                      data_fields (pk->id, fk->data)

    14. 

  14.     //               |                                                                      |

    15. 

  15.     //               |                                                                      |

    16. 

  16.     //     -----------------------------------------------------------------------------    |

    17. 

  17.     //     |                                  |                                        |    |

    18. 

  18.     //data_ratings(fk->recordid, pk->id) data_comments (fk->recordid, pk->id)          |    |

    19. 

  19.     //                                                                  data_content(pk->id, fk->recordid, fk->fieldid)

    20. 

  20.     //

    21. 

  21.     //

    22. 

  22.     //

    23. 

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

    24. 

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

    25. 

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

    26. 

  26.     //          CL->course level info

    27. 

  27.     //          UL->user level info

    28. 

  28.     //          files->table may have files)

    29. 

  29.     //

    30. 

  30.     //-----------------------------------------------------------

    31. 

  31. 

    32. 

  32.     //Backup data files because we've selected to backup user info

    33. 

  33.     //and files are user info's level

    34. 

  34. 

    35. 

  35. $fieldids = array();    //array in the format of $fieldids[$oldid]=$newid. This is needed because of double dependencies of multiple tables.

    36. 

  36. 

    37. 

  37. 

    38. 

  38.     //Return a content encoded to support interactivities linking. Every module

    39. 

  39. function data_restore_mods($mod,$restore) {

    40. 

  40. 

    41. 

  41.     global $CFG;

    42. 

  42. 

    43. 

  43.     $status = true;

    44. 

  44. 

    45. 

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

    46. 

  46. 

    47. 

  47.     if ($data) {

    48. 

  48.         //Now get completed xmlized object

    49. 

  49.         $info = $data->info;

    50. 

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

    51. 

  51.         if ($restore->course_startdateoffset) {

    52. 

  52.             restore_log_date_changes('Database', $restore, $info['MOD']['#'], array('TIMEAVAILABLEFROM', 'TIMEAVAILABLETO','TIMEVIEWFROM', 'TIMEVIEWTO'));

    53. 

  53.         }

    54. 

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

    55. 

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

    56. 

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

    57. 

  57. 

    58. 

  58.         $database->course = $restore->course_id;

    59. 

  59. 

    60. 

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

    61. 

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

    62. 

  62.         // Only relevant for restoring backups from 1.6 in a 1.7 install.

    63. 

  63.         if (isset($info['MOD']['#']['RATINGS']['0']['#'])) {

    64. 

  64.             $database->ratings = backup_todb($info['MOD']['#']['RATINGS']['0']['#']);

    65. 

  65.         }

    66. 

  66.         $database->comments = backup_todb($info['MOD']['#']['COMMENTS']['0']['#']);

    67. 

  67.         $database->timeavailablefrom = backup_todb($info['MOD']['#']['TIMEAVAILABLEFROM']['0']['#']);

    68. 

  68.         $database->timeavailableto = backup_todb($info['MOD']['#']['TIMEAVAILABLETO']['0']['#']);

    69. 

  69.         $database->timeviewfrom = backup_todb($info['MOD']['#']['TIMEVIEWFROM']['0']['#']);

    70. 

  70.         $database->timeviewto = backup_todb($info['MOD']['#']['TIMEVIEWTO']['0']['#']);

    71. 

  71.         // Only relevant for restoring backups from 1.6 in a 1.7 install.

    72. 

  72.         if (isset($info['MOD']['#']['PARTICIPANTS']['0']['#'])) {

    73. 

  73.             $database->participants = backup_todb($info['MOD']['#']['PARTICIPANTS']['0']['#']);

    74. 

  74.         }

    75. 

  75.         $database->requiredentries = backup_todb($info['MOD']['#']['REQUIREDENTRIES']['0']['#']);

    76. 

  76.         $database->requiredentriestoview = backup_todb($info['MOD']['#']['REQUIREDENTRIESTOVIEW']['0']['#']);

    77. 

  77.         $database->maxentries = backup_todb($info['MOD']['#']['MAXENTRIES']['0']['#']);

    78. 

  78.         $database->rssarticles = backup_todb($info['MOD']['#']['RSSARTICLES']['0']['#']);

    79. 

  79.         $database->singletemplate = backup_todb($info['MOD']['#']['SINGLETEMPLATE']['0']['#']);

    80. 

  80.         $database->listtemplate = backup_todb($info['MOD']['#']['LISTTEMPLATE']['0']['#']);

    81. 

  81.         $database->listtemplateheader = backup_todb($info['MOD']['#']['LISTTEMPLATEHEADER']['0']['#']);

    82. 

  82.         $database->listtemplatefooter = backup_todb($info['MOD']['#']['LISTTEMPLATEFOOTER']['0']['#']);

    83. 

  83.         $database->addtemplate = backup_todb($info['MOD']['#']['ADDTEMPLATE']['0']['#']);

    84. 

  84.         $database->rsstemplate = backup_todb($info['MOD']['#']['RSSTEMPLATE']['0']['#']);

    85. 

  85.         $database->rsstitletemplate = backup_todb($info['MOD']['#']['RSSTITLETEMPLATE']['0']['#']);

    86. 

  86.         $database->csstemplate = backup_todb($info['MOD']['#']['CSSTEMPLATE']['0']['#']);

    87. 

  87.         $database->jstemplate = backup_todb($info['MOD']['#']['JSTEMPLATE']['0']['#']);

    88. 

  88.         $database->asearchtemplate = backup_todb($info['MOD']['#']['ASEARCHTEMPLATE']['0']['#']);

    89. 

  89.         $database->approval = backup_todb($info['MOD']['#']['APPROVAL']['0']['#']);

    90. 

  90.         $database->scale = backup_todb($info['MOD']['#']['SCALE']['0']['#']);

    91. 

  91.         $database->assessed = backup_todb($info['MOD']['#']['ASSESSED']['0']['#']);

    92. 

  92.         // Only relevant for restoring backups from 1.6 in a 1.7 install.

    93. 

  93.         if (isset($info['MOD']['#']['ASSESSPUBLIC']['0']['#'])) {

    94. 

  94.             $database->assesspublic = backup_todb($info['MOD']['#']['ASSESSPUBLIC']['0']['#']);

    95. 

  95.         }

    96. 

  96.         $database->defaultsort = backup_todb($info['MOD']['#']['DEFAULTSORT']['0']['#']);

    97. 

  97.         $database->defaultsortdir = backup_todb($info['MOD']['#']['DEFAULTSORTDIR']['0']['#']);

    98. 

  98.         $database->editany = backup_todb($info['MOD']['#']['EDITANY']['0']['#']);

    99. 

  99.         $database->notification = backup_todb($info['MOD']['#']['NOTIFICATION']['0']['#']);

    100. 

  100.         

    101. 

  101.         //fix related to MDL-24470: if someone restore a backup previous to this fix it would fail

    102. 

  102.         //if notification = NULL as the column can not be NULL anymore

    103. 

  103.         if (empty($database->notification)) {

    104. 

  104.             $database->notification = 0;

    105. 

  105.         }

    106. 

  106. 

    107. 

  107.         // We have to recode the scale field if it's <0 (positive is a grade, not a scale)

    108. 

  108.         if ($database->scale < 0) {

    109. 

  109.             $scale = backup_getid($restore->backup_unique_code, 'scale', abs($database->scale));

    110. 

  110.             if ($scale) {

    111. 

  111.                 $database->scale = -($scale->new_id);

    112. 

  112.             }

    113. 

  113.         }

    114. 

  114. 

    115. 

  115.         $newid = insert_record ('data', $database);

    116. 

  116. 

    117. 

  117.         //Do some output

    118. 

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

    119. 

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

    120. 

  120.         }

    121. 

  121. 

    122. 

  122.         if ($newid) {

    123. 

  123.             //We have the newid, update backup_ids

    124. 

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

    125. 

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

    126. 

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

    127. 

  127.             if (function_exists('restore_userdata_selected')) {

    128. 

  128.                 // Moodle 1.6

    129. 

  129.                 $restore_userdata_selected = restore_userdata_selected($restore, 'data', $mod->id);

    130. 

  130.             } else {

    131. 

  131.                 // Moodle 1.5

    132. 

  132.                 $restore_userdata_selected = $restore->mods['data']->userinfo;

    133. 

  133.             }

    134. 

  134. 

    135. 

  135.             global $fieldids;

    136. 

  136.             //Restore data_fields first!!! need to hold an array of [oldid]=>newid due to double dependencies

    137. 

  137.             $status = $status and data_fields_restore_mods ($mod->id, $newid, $info, $restore);

    138. 

  138. 

    139. 

  139.             // now use the new field in the defaultsort

    140. 

  140.             $newdefaultsort = empty($fieldids[$database->defaultsort]) ? 0 : $fieldids[$database->defaultsort];

    141. 

  141.             set_field('data', 'defaultsort', $newdefaultsort, 'id', $newid);

    142. 

  142. 

    143. 

  143.             if ($restore_userdata_selected) {

    144. 

  144.                 $status = $status and data_records_restore_mods ($mod->id, $newid, $info, $restore);

    145. 

  145.             }

    146. 

  146. 

    147. 

  147.             // If the backup contained $data->participants, $data->assesspublic

    148. 

  148.             // and $data->groupmode, we need to convert the data to use Roles.

    149. 

  149.             // It means the backup was made pre Moodle 1.7. We check the

    150. 

  150.             // backup_version to make sure.

    151. 

  151.             if (isset($database->participants) && isset($database->assesspublic)) {

    152. 

  152. 

    153. 

  153.                 if (!$teacherroles = get_roles_with_capability('moodle/legacy:teacher', CAP_ALLOW)) {

    154. 

  154.                       notice('Default teacher role was not found. Roles and permissions '.

    155. 

  155.                              'for your database modules will have to be manually set.');

    156. 

  156.                 }

    157. 

  157.                 if (!$studentroles = get_roles_with_capability('moodle/legacy:student', CAP_ALLOW)) {

    158. 

  158.                       notice('Default student role was not found. Roles and permissions '.

    159. 

  159.                              'for all your database modules will have to be manually set.');

    160. 

  160.                 }

    161. 

  161.                 if (!$guestroles = get_roles_with_capability('moodle/legacy:guest', CAP_ALLOW)) {

    162. 

  162.                       notice('Default guest role was not found. Roles and permissions '.

    163. 

  163.                              'for all your database modules will have to be manually set.');

    164. 

  164.                 }

    165. 

  165.                 require_once($CFG->dirroot.'/mod/data/lib.php');

    166. 

  166.                 data_convert_to_roles($database, $teacherroles, $studentroles,

    167. 

  167.                                       $restore->mods['data']->instances[$mod->id]->restored_as_course_module);

    168. 

  168.             }

    169. 

  169. 

    170. 

  170.         } else {

    171. 

  171.             $status = false;

    172. 

  172.         }

    173. 

  173.     } else {

    174. 

  174.         $status = false;

    175. 

  175.     }

    176. 

  176. 

    177. 

  177.     return $status;

    178. 

  178. }

    179. 

  179. 

    180. 

  180. function data_fields_restore_mods ($old_data_id, $new_data_id, $info, $restore) {

    181. 

  181. 

    182. 

  182.     global $CFG, $fieldids;

    183. 

  183. 

    184. 

  184. 

    185. 

  185.     $fields = $info['MOD']['#']['FIELDS']['0']['#']['FIELD'];

    186. 

  186. 

    187. 

  187.     for ($i = 0; $i < sizeof($fields); $i++) {

    188. 

  188. 

    189. 

  189.         $fie_info = $fields[$i];

    190. 

  190.         $oldid = backup_todb($fie_info['#']['ID']['0']['#']);

    191. 

  191. 

    192. 

  192.         $field -> dataid = $new_data_id;

    193. 

  193.         $field -> type = backup_todb($fie_info['#']['TYPE']['0']['#']);

    194. 

  194.         $field -> name = backup_todb($fie_info['#']['NAME']['0']['#']);

    195. 

  195.         $field -> description = backup_todb($fie_info['#']['DESCRIPTION']['0']['#']);

    196. 

  196.         $field -> param1 = backup_todb($fie_info['#']['PARAM1']['0']['#']);

    197. 

  197.         $field -> param2 = backup_todb($fie_info['#']['PARAM2']['0']['#']);

    198. 

  198.         $field -> param3 = backup_todb($fie_info['#']['PARAM3']['0']['#']);

    199. 

  199.         $field -> param4 = backup_todb($fie_info['#']['PARAM4']['0']['#']);

    200. 

  200.         $field -> param5 = backup_todb($fie_info['#']['PARAM5']['0']['#']);

    201. 

  201.         $field -> param6 = backup_todb($fie_info['#']['PARAM6']['0']['#']);

    202. 

  202.         $field -> param7 = backup_todb($fie_info['#']['PARAM7']['0']['#']);

    203. 

  203.         $field -> param8 = backup_todb($fie_info['#']['PARAM8']['0']['#']);

    204. 

  204.         $field -> param9 = backup_todb($fie_info['#']['PARAM9']['0']['#']);

    205. 

  205.         $field -> param10 = backup_todb($fie_info['#']['PARAM10']['0']['#']);

    206. 

  206. 

    207. 

  207.         $newid = insert_record ("data_fields",$field);

    208. 

  208. 

    209. 

  209.         $fieldids[$oldid] = $newid;    //so we can use them in sub tables that depends on both fieldid and recordid

    210. 

  210. 

    211. 

  211.         //Do some output

    212. 

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

    213. 

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

    214. 

  214.                 echo ".";

    215. 

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

    216. 

  216.                     echo "<br />";

    217. 

  217.                 }

    218. 

  218.             }

    219. 

  219.             backup_flush(300);

    220. 

  220.         }

    221. 

  221. 

    222. 

  222.         if ($newid) {

    223. 

  223.             //We have the newid, update backup_ids

    224. 

  224.             $status = backup_putid($restore->backup_unique_code,"data_fields",$oldid, $newid);

    225. 

  225.         } else {

    226. 

  226.             $status = false;

    227. 

  227.         }

    228. 

  228. 

    229. 

  229.     }

    230. 

  230.     return $status;

    231. 

  231. 

    232. 

  232. }

    233. 

  233. 

    234. 

  234. function data_records_restore_mods ($old_data_id, $new_data_id, $info, $restore) {

    235. 

  235. 

    236. 

  236.     global $CFG, $fieldids;

    237. 

  237. 

    238. 

  238.     $status = true;

    239. 

  239. 

    240. 

  240.     $records = isset($info['MOD']['#']['RECORDS']['0']['#']['RECORD']) ? $info['MOD']['#']['RECORDS']['0']['#']['RECORD'] : array();

    241. 

  241. 

    242. 

  242.     if (empty($records)) { // no records to restore

    243. 

  243.         return true;

    244. 

  244.     }

    245. 

  245. 

    246. 

  246.     for ($i = 0; $i < sizeof($records); $i++) {

    247. 

  247. 

    248. 

  248.         $rec_info = $records[$i];

    249. 

  249.         $oldid = backup_todb($rec_info['#']['ID']['0']['#']);

    250. 

  250. 

    251. 

  251.         $record = new object();

    252. 

  252.         $record -> dataid = $new_data_id;

    253. 

  253.         $record -> userid = backup_todb($rec_info['#']['USERID']['0']['#']);

    254. 

  254.         $record -> groupid = backup_todb($rec_info['#']['GROUPID']['0']['#']);

    255. 

  255.         $record -> timecreated = backup_todb($rec_info['#']['TIMECREATED']['0']['#']);

    256. 

  256.         $record -> timemodified = backup_todb($rec_info['#']['TIMEMODIFIED']['0']['#']);

    257. 

  257.         $record -> approved = backup_todb($rec_info['#']['APPROVED']['0']['#']);

    258. 

  258.         $user = backup_getid($restore->backup_unique_code,"user",$record->userid);

    259. 

  259.         $group= restore_group_getid($restore, $record->groupid);

    260. 

  260. 

    261. 

  261.         if ($user) {

    262. 

  262.             $record->userid = $user->new_id;

    263. 

  263.         }

    264. 

  264.         if ($group) {

    265. 

  265.             $record->groupid= $group->new_id;

    266. 

  266.         }

    267. 

  267. 

    268. 

  268.         $newid = insert_record ("data_records",$record);

    269. 

  269. 

    270. 

  270.         //Do some output

    271. 

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

    272. 

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

    273. 

  273.                 echo ".";

    274. 

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

    275. 

  275.                     echo "<br />";

    276. 

  276.                 }

    277. 

  277.             }

    278. 

  278.             backup_flush(300);

    279. 

  279.         }

    280. 

  280. 

    281. 

  281.         if ($newid) {

    282. 

  282.             //We have the newid, update backup_ids

    283. 

  283.             $status = $status and backup_putid($restore->backup_unique_code,"data_records",$oldid, $newid);

    284. 

  284. 

    285. 

  285.             $status = $status and data_content_restore_mods ($oldid, $newid, $old_data_id, $new_data_id, $rec_info, $restore);

    286. 

  286.             $status = $status and data_ratings_restore_mods ($oldid, $newid, $info, $rec_info);

    287. 

  287.             $status = $status and data_comments_restore_mods ($oldid, $newid, $info, $rec_info);

    288. 

  288. 

    289. 

  289.         } else {

    290. 

  290.             $status = false;

    291. 

  291.         }

    292. 

  292.     }

    293. 

  293.     return $status;

    294. 

  294. }

    295. 

  295. 

    296. 

  296. function data_content_restore_mods ($old_record_id, $new_record_id, $old_data_id, $new_data_id, $recinfo, $restore) {

    297. 

  297. 

    298. 

  298.     global $CFG, $fieldids;

    299. 

  299. 

    300. 

  300.     $status = true;

    301. 

  301. 

    302. 

  302.     $contents = $recinfo['#']['CONTENTS']['0']['#']['CONTENT'];

    303. 

  303. 

    304. 

  304.     for ($i = 0; $i < sizeof($contents); $i++) {

    305. 

  305. 

    306. 

  306.         $con_info = $contents[$i];

    307. 

  307.         $oldid = backup_todb($con_info['#']['ID']['0']['#']);

    308. 

  308.         $oldfieldid = backup_todb($con_info['#']['FIELDID']['0']['#']);

    309. 

  309.         $oldrecordid = backup_todb($con_info['#']['RECORDID']['0']['#']);

    310. 

  310. 

    311. 

  311.         $content -> recordid = $new_record_id;

    312. 

  312.         $content -> fieldid = $fieldids[$oldfieldid];

    313. 

  313.         $content -> content = backup_todb($con_info['#']['CONTENT']['0']['#']);

    314. 

  314.         $content -> content1 = backup_todb($con_info['#']['CONTENT1']['0']['#']);

    315. 

  315.         $content -> content2 = backup_todb($con_info['#']['CONTENT2']['0']['#']);

    316. 

  316.         $content -> content3 = backup_todb($con_info['#']['CONTENT3']['0']['#']);

    317. 

  317.         $content -> content4 = backup_todb($con_info['#']['CONTENT4']['0']['#']);

    318. 

  318.         $newid = insert_record ("data_content",$content);

    319. 

  319. 

    320. 

  320.         //Do some output

    321. 

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

    322. 

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

    323. 

  323.                 echo ".";

    324. 

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

    325. 

  325.                     echo "<br />";

    326. 

  326.                 }

    327. 

  327.             }

    328. 

  328.             backup_flush(300);

    329. 

  329.         }

    330. 

  330. 

    331. 

  331.         if ($newid) {

    332. 

  332.             //We have the newid, update backup_ids

    333. 

  333. 

    334. 

  334.             $status = $status and data_restore_files ($old_data_id, $new_data_id, $oldfieldid, $content->fieldid, $oldrecordid, $content->recordid, $recinfo, $restore);

    335. 

  335.             $status = $status and backup_putid($restore->backup_unique_code,"data_content",$oldid, $newid);

    336. 

  336.         } else {

    337. 

  337.             $status = false;

    338. 

  338.         }

    339. 

  339.     }

    340. 

  340.     return $status;

    341. 

  341. }

    342. 

  342. 

    343. 

  343. 

    344. 

  344. function data_restore_files ($old_data_id, $new_data_id, $old_field_id, $new_field_id, $old_record_id, $new_record_id, $recinfo, $restore) {

    345. 

  345. 

    346. 

  346.     global $CFG, $db;

    347. 

  347. 

    348. 

  348.     $status = true;

    349. 

  349.     $todo = false;

    350. 

  350.     $moddata_path = "";

    351. 

  351.     $data_path = "";

    352. 

  352.     $temp_path = "";

    353. 

  353. 

    354. 

  354.     //First, we check to "course_id" exists and create is as necessary

    355. 

  355.     //in CFG->dataroot

    356. 

  356.     $dest_dir = $CFG->dataroot."/".$restore->course_id;

    357. 

  357.     $status = check_dir_exists($dest_dir,true);

    358. 

  358. 

    359. 

  359.     //Now, locate course's moddata directory

    360. 

  360.     $moddata_path = $CFG->dataroot."/".$restore->course_id."/".$CFG->moddata;

    361. 

  361. 

    362. 

  362.     //Check it exists and create it

    363. 

  363.     $status = check_dir_exists($moddata_path,true);

    364. 

  364. 

    365. 

  365.     //Now, locate data directory

    366. 

  366.     if ($status) {

    367. 

  367.         $data_path = $moddata_path."/data";

    368. 

  368.         //Check it exists and create it

    369. 

  369.         $status = check_dir_exists($data_path,true);

    370. 

  370.     }

    371. 

  371. 

    372. 

  372.     //Now locate the temp dir we are gong to restore

    373. 

  373.     if ($status) {

    374. 

  374.         $temp_path = $CFG->dataroot."/temp/backup/".$restore->backup_unique_code.

    375. 

  375.                     "/moddata/data/".$old_data_id."/".$old_field_id."/".$old_record_id;

    376. 

  376.         $todo = check_dir_exists($temp_path);

    377. 

  377.     }

    378. 

  378. 

    379. 

  379.     //If todo, we create the neccesary dirs in course moddata/data

    380. 

  380.     if ($status and $todo) {

    381. 

  381.         //First this data id

    382. 

  382.         $this_data_path = $data_path."/".$new_data_id;

    383. 

  383. 

    384. 

  384.         $status = check_dir_exists($this_data_path,true);

    385. 

  385.         //Now this user id

    386. 

  386.         $this_field_path = $this_data_path."/".$new_field_id;

    387. 

  387.         $status = check_dir_exists($this_field_path,true);

    388. 

  388.         $this_record_path = $this_field_path = $this_field_path."/".$new_record_id;

    389. 

  389.         $status = check_dir_exists($this_record_path,true);

    390. 

  390.         //And now, copy temp_path to user_data_path

    391. 

  391. 

    392. 

  392.         $status = @backup_copy_file($temp_path, $this_record_path);

    393. 

  393.     }

    394. 

  394. 

    395. 

  395.     return $status;

    396. 

  396. }

    397. 

  397. 

    398. 

  398. function data_ratings_restore_mods ($oldid, $newid, $info, $rec_info) {

    399. 

  399. 

    400. 

  400.     global $CFG;

    401. 

  401. 

    402. 

  402.     $status = true;

    403. 

  403. 

    404. 

  404.     $ratings= isset($rec_info['#']['RATINGS']['0']['#']['RATING']) ? $rec_info['#']['RATINGS']['0']['#']['RATING'] : array();

    405. 

  405. 

    406. 

  406.     if (empty($ratings)) { // no ratings to restore

    407. 

  407.         return true;

    408. 

  408.     }

    409. 

  409.     for ($i = 0; $i < sizeof($ratings); $i++) {

    410. 

  410. 

    411. 

  411.         $rat_info = $ratings[$i];

    412. 

  412. 

    413. 

  413.         $rating->recordid = $newid;

    414. 

  414.         $rating->userid = backup_todb($rat_info['#']['USERID']['0']['#']);

    415. 

  415.         $rating->rating = backup_todb($rat_info['#']['RATING']['0']['#']);

    416. 

  416. 

    417. 

  417.         // Need to remap the user

    418. 

  418.         $user = backup_getid($restore->backup_unique_code,"user",$rating->userid);

    419. 

  419.         if ($user) {

    420. 

  420.             $rating->userid = $user->new_id;

    421. 

  421.         }

    422. 

  422. 

    423. 

  423.         if (! insert_record ("data_ratings",$rating)) {

    424. 

  424.             $status = false;

    425. 

  425.         }

    426. 

  426.     }

    427. 

  427.     return $status;

    428. 

  428. }

    429. 

  429. 

    430. 

  430. function data_comments_restore_mods ($oldid, $newid, $info, $rec_info) {

    431. 

  431. 

    432. 

  432.     global $CFG;

    433. 

  433. 

    434. 

  434.     $status = true;

    435. 

  435. 

    436. 

  436.     $comments= isset($rec_info['#']['COMMENTS']['0']['#']['COMMENT']) ? $rec_info['#']['COMMENTS']['0']['#']['COMMENT'] : array();

    437. 

  437. 

    438. 

  438.     if (empty($comments)) { // no comments to restore

    439. 

  439.         return true;

    440. 

  440.     }

    441. 

  441. 

    442. 

  442.     for ($i = 0; $i < sizeof($comments); $i++) {

    443. 

  443. 

    444. 

  444.         $com_info = $comments[$i];

    445. 

  445. 

    446. 

  446.         $comment->recordid = $newid;

    447. 

  447.         $comment->userid = backup_todb($com_info['#']['USERID']['0']['#']);

    448. 

  448.         $comment->content = backup_todb($com_info['#']['CONTENT']['0']['#']);

    449. 

  449.         $comment->format = backup_todb($com_info['#']['FORMAT']['0']['#']);

    450. 

  450.         $comment->created = backup_todb($com_info['#']['CREATED']['0']['#']);

    451. 

  451.         $comment->modified = backup_todb($com_info['#']['MODIFIED']['0']['#']);

    452. 

  452. 

    453. 

  453.         // Need to remap the user

    454. 

  454.         $user = backup_getid($restore->backup_unique_code,"user",$comment->userid);

    455. 

  455.         if ($user) {

    456. 

  456.             $comment->userid = $user->new_id;

    457. 

  457.         }

    458. 

  458. 

    459. 

  459.         if (! insert_record ("data_comments",$comment)) {

    460. 

  460.             $status = false;

    461. 

  461.         }

    462. 

  462. 

    463. 

  463.     }

    464. 

  464.     return $status;

    465. 

  465. 

    466. 

  466. }

    467. 

  467. 

    468. 

  468. /**

    469. 

  469.  * Returns a content decoded to support interactivities linking. Every module

    470. 

  470.  * should have its own. They are called automatically from

    471. 

  471.  * xxxx_decode_content_links_caller() function in each module

    472. 

  472.  * in the restore process.

    473. 

  473.  *

    474. 

  474.  * @param string $content the content to be decoded

    475. 

  475.  * @param object $restore the preferences used in restore

    476. 

  476.  * @return string the decoded string

    477. 

  477.  */

    478. 

  478. function data_decode_content_links ($content,$restore) {

    479. 

  479. 

    480. 

  480.     global $CFG;

    481. 

  481. 

    482. 

  482.     $result = $content;

    483. 

  483. 

    484. 

  484. /// Link to the list of datas

    485. 

  485. 

    486. 

  486.     $searchstring='/\$@(DATAINDEX)\*([0-9]+)@\$/';

    487. 

  487. /// We look for it

    488. 

  488.     preg_match_all($searchstring,$content,$foundset);

    489. 

  489. /// If found, then we are going to look for its new id (in backup tables)

    490. 

  490.     if ($foundset[0]) {

    491. 

  491.     /// print_object($foundset);                                     //Debug

    492. 

  492.     /// Iterate over foundset[2]. They are the old_ids

    493. 

  493.         foreach($foundset[2] as $old_id) {

    494. 

  494.         /// We get the needed variables here (course id)

    495. 

  495.             $rec = backup_getid($restore->backup_unique_code,"course",$old_id);

    496. 

  496.         /// Personalize the searchstring

    497. 

  497.             $searchstring='/\$@(DATAINDEX)\*('.$old_id.')@\$/';

    498. 

  498.         /// If it is a link to this course, update the link to its new location

    499. 

  499.             if($rec->new_id) {

    500. 

  500.             /// Now replace it

    501. 

  501.                 $result= preg_replace($searchstring,$CFG->wwwroot.'/mod/data/index.php?id='.$rec->new_id,$result);

    502. 

  502.             } else {

    503. 

  503.             /// It's a foreign link so leave it as original

    504. 

  504.                 $result= preg_replace($searchstring,$restore->original_wwwroot.'/mod/data/index.php?id='.$old_id,$result);

    505. 

  505.             }

    506. 

  506.         }

    507. 

  507.     }

    508. 

  508. 

    509. 

  509. /// Link to data view by moduleid

    510. 

  510. 

    511. 

  511.     $searchstring='/\$@(DATAVIEWBYID)\*([0-9]+)@\$/';

    512. 

  512. /// We look for it

    513. 

  513.     preg_match_all($searchstring,$result,$foundset);

    514. 

  514. /// If found, then we are going to look for its new id (in backup tables)

    515. 

  515.     if ($foundset[0]) {

    516. 

  516.     /// print_object($foundset);                                     //Debug

    517. 

  517.     /// Iterate over foundset[2]. They are the old_ids

    518. 

  518.         foreach($foundset[2] as $old_id) {

    519. 

  519.         /// We get the needed variables here (course_modules id)

    520. 

  520.             $rec = backup_getid($restore->backup_unique_code,"course_modules",$old_id);

    521. 

  521.         /// Personalize the searchstring

    522. 

  522.             $searchstring='/\$@(DATAVIEWBYID)\*('.$old_id.')@\$/';

    523. 

  523.         /// If it is a link to this course, update the link to its new location

    524. 

  524.             if($rec->new_id) {

    525. 

  525.             /// Now replace it

    526. 

  526.                 $result= preg_replace($searchstring,$CFG->wwwroot.'/mod/data/view.php?id='.$rec->new_id,$result);

    527. 

  527.             } else {

    528. 

  528.             /// It's a foreign link so leave it as original

    529. 

  529.                 $result= preg_replace($searchstring,$restore->original_wwwroot.'/mod/data/view.php?id='.$old_id,$result);

    530. 

  530.             }

    531. 

  531.         }

    532. 

  532.     }

    533. 

  533. 

    534. 

  534. /// Link to data view by dataid

    535. 

  535. 

    536. 

  536.     $searchstring='/\$@(DATAVIEWBYD)\*([0-9]+)@\$/';

    537. 

  537. /// We look for it

    538. 

  538.     preg_match_all($searchstring,$result,$foundset);

    539. 

  539. /// If found, then we are going to look for its new id (in backup tables)

    540. 

  540.     if ($foundset[0]) {

    541. 

  541.     /// print_object($foundset);                                     //Debug

    542. 

  542.     /// Iterate over foundset[2]. They are the old_ids

    543. 

  543.         foreach($foundset[2] as $old_id) {

    544. 

  544.         /// We get the needed variables here (data id)

    545. 

  545.             $rec = backup_getid($restore->backup_unique_code,"data",$old_id);

    546. 

  546.         /// Personalize the searchstring

    547. 

  547.             $searchstring='/\$@(DATAVIEWBYD)\*('.$old_id.')@\$/';

    548. 

  548.         /// If it is a link to this course, update the link to its new location

    549. 

  549.             if($rec->new_id) {

    550. 

  550.             /// Now replace it

    551. 

  551.                 $result= preg_replace($searchstring,$CFG->wwwroot.'/mod/data/view.php?d='.$rec->new_id,$result);

    552. 

  552.             } else {

    553. 

  553.             /// It's a foreign link so leave it as original

    554. 

  554.                 $result= preg_replace($searchstring,$restore->original_wwwroot.'/mod/data/view.php?d='.$old_id,$result);

    555. 

  555.             }

    556. 

  556.         }

    557. 

  557.     }

    558. 

  558. 

    559. 

  559. /// Link to data record (element)

    560. 

  560. 

    561. 

  561.     $searchstring='/\$@(DATAVIEWRECORD)\*([0-9]+)\*([0-9]+)@\$/';

    562. 

  562. /// We look for it

    563. 

  563.     preg_match_all($searchstring,$result,$foundset);

    564. 

  564. /// If found, then we are going to look for its new id (in backup tables)

    565. 

  565.     if ($foundset[0]) {

    566. 

  566.     /// print_object($foundset);                                     //Debug

    567. 

  567.     /// Iterate over foundset[2] and foundset[3]. They are the old_ids

    568. 

  568.         foreach($foundset[2] as $key => $old_id) {

    569. 

  569.             $old_id2 = $foundset[3][$key];

    570. 

  570.         /// We get the needed variables here (data id and record id)

    571. 

  571.             $rec = backup_getid($restore->backup_unique_code,"data",$old_id);

    572. 

  572.             $rec2 = backup_getid($restore->backup_unique_code,"data_records",$old_id2);

    573. 

  573.         /// Personalize the searchstring

    574. 

  574.             $searchstring='/\$@(DATAVIEWRECORD)\*('.$old_id.')\*('.$old_id2.')@\$/';

    575. 

  575.         /// If it is a link to this course, update the link to its new location

    576. 

  576.             if($rec->new_id && $rec2->new_id) {

    577. 

  577.             /// Now replace it

    578. 

  578.                 $result= preg_replace($searchstring,$CFG->wwwroot.'/mod/data/view.php?d='.$rec->new_id.'&amp;rid='.$rec2->new_id,$result);

    579. 

  579.             } else {

    580. 

  580.             /// It's a foreign link so leave it as original

    581. 

  581.                 $result= preg_replace($searchstring,$restore->original_wwwroot.'/mod/data/view.php?d='.$old_id.'&amp;rid='.$old_id2,$result);

    582. 

  582.             }

    583. 

  583.         }

    584. 

  584.     }

    585. 

  585. 

    586. 

  586.     return $result;

    587. 

  587. }

    588. 

  588. 

    589. 

  589. /**

    590. 

  590.  * This function makes all the necessary calls to xxxx_decode_content_links()

    591. 

  591.  * function in each module, passing them the desired contents to be decoded

    592. 

  592.  * from backup format to destination site/course in order to mantain inter-activities

    593. 

  593.  * working in the backup/restore process. It's called from restore_decode_content_links()

    594. 

  594.  * function in restore process

    595. 

  595.  *

    596. 

  596.  * @param object $restore the preferences used in restore

    597. 

  597.  * @return boolean status of the execution

    598. 

  598.  */

    599. 

  599. function data_decode_content_links_caller($restore) {

    600. 

  600. 

    601. 

  601.     global $CFG;

    602. 

  602.     $status = true;

    603. 

  603. 

    604. 

  604. /// Process every DATA (intro, all HTML templates) in the course

    605. 

  605. /// Supported fields for main table:

    606. 

  606.     $supportedfields = array('intro','singletemplate','listtemplate',

    607. 

  607.         'listtemplateheader','addtemplate','rsstemplate','rsstitletemplate');

    608. 

  608.     if ($datas = get_records_sql ("SELECT d.id, ".implode(',',$supportedfields)."

    609. 

  609.                                   FROM {$CFG->prefix}data d

    610. 

  610.                                   WHERE d.course = $restore->course_id")) {

    611. 

  611.     /// Iterate over each data

    612. 

  612.         $i = 0;   //Counter to send some output to the browser to avoid timeouts

    613. 

  613.         foreach ($datas as $data) {

    614. 

  614.         /// Increment counter

    615. 

  615.             $i++;

    616. 

  616. 

    617. 

  617.         /// Make a new copy of the data object with nothing in, to use if

    618. 

  618.         /// changes are necessary (allows us to do update_record without

    619. 

  619.         /// worrying about every single field being included and needing

    620. 

  620.         /// slashes).

    621. 

  621.             $newdata = new stdClass;

    622. 

  622.             $newdata->id=$data->id;

    623. 

  623. 

    624. 

  624.         /// Loop through handling each supported field

    625. 

  625.             $changed = false;

    626. 

  626.             foreach($supportedfields as $field) {

    627. 

  627.                 $result = restore_decode_content_links_worker($data->{$field},$restore);

    628. 

  628.                 if ($result != $data->{$field}) {

    629. 

  629.                     $newdata->{$field} = addslashes($result);

    630. 

  630.                     $changed = true;

    631. 

  631.                     if (debugging()) {

    632. 

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

    633. 

  633.                             echo '<br /><hr />'.s($data->{$field}).'<br />changed to<br />'.s($result).'<hr /><br />';

    634. 

  634.                         }

    635. 

  635.                     }

    636. 

  636.                 }

    637. 

  637.             }

    638. 

  638. 

    639. 

  639.         /// Update record if any field changed

    640. 

  640.             if($changed) {

    641. 

  641.                 $status = update_record("data",$newdata);

    642. 

  642.             }

    643. 

  643. 

    644. 

  644.         /// Do some output

    645. 

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

    646. 

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

    647. 

  647.                     echo ".";

    648. 

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

    649. 

  649.                         echo "<br />";

    650. 

  650.                     }

    651. 

  651.                 }

    652. 

  652.                 backup_flush(300);

    653. 

  653.             }

    654. 

  654.         }

    655. 

  655.     }

    656. 

  656. 

    657. 

  657. /// Process every COMMENT (content) in the course

    658. 

  658.     if ($comments = get_records_sql ("SELECT dc.id, dc.content

    659. 

  659.                                       FROM {$CFG->prefix}data d,

    660. 

  660.                                            {$CFG->prefix}data_records dr,

    661. 

  661.                                            {$CFG->prefix}data_comments dc

    662. 

  662.                                       WHERE d.course = $restore->course_id

    663. 

  663.                                         AND dr.dataid = d.id

    664. 

  664.                                         AND dc.recordid = dr.id")) {

    665. 

  665.     /// Iterate over each data_comments->content

    666. 

  666.         $i = 0;   //Counter to send some output to the browser to avoid timeouts

    667. 

  667.         foreach ($comments as $comment) {

    668. 

  668.         /// Increment counter

    669. 

  669.             $i++;

    670. 

  670.             $content = $comment->content;

    671. 

  671.             $result = restore_decode_content_links_worker($content,$restore);

    672. 

  672.             if ($result != $content) {

    673. 

  673.             /// Update record

    674. 

  674.                 $comment->content = addslashes($result);

    675. 

  675.                 $status = update_record("data_comments",$comment);

    676. 

  676.                 if (debugging()) {

    677. 

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

    678. 

  678.                         echo '<br /><hr />'.s($content).'<br />changed to<br />'.s($result).'<hr /><br />';

    679. 

  679.                     }

    680. 

  680.                 }

    681. 

  681.             }

    682. 

  682.         /// Do some output

    683. 

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

    684. 

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

    685. 

  685.                     echo ".";

    686. 

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

    687. 

  687.                         echo "<br />";

    688. 

  688.                     }

    689. 

  689.                 }

    690. 

  690.                 backup_flush(300);

    691. 

  691.             }

    692. 

  692.         }

    693. 

  693.     }

    694. 

  694. 

    695. 

  695. /// Process every CONTENT (content, content1, content2, content3, content4) in the course

    696. 

  696.     if ($contents = get_records_sql ("SELECT dc.id, dc.content, dc.content1, dc.content2, dc.content3, dc.content4

    697. 

  697.                                       FROM {$CFG->prefix}data d,

    698. 

  698.                                            {$CFG->prefix}data_records dr,

    699. 

  699.                                            {$CFG->prefix}data_content dc

    700. 

  700.                                       WHERE d.course = $restore->course_id

    701. 

  701.                                         AND dr.dataid = d.id

    702. 

  702.                                         AND dc.recordid = dr.id")) {

    703. 

  703.     /// Iterate over each data_content->content, content1, content2, content3 and content4

    704. 

  704.         $i = 0;   //Counter to send some output to the browser to avoid timeouts

    705. 

  705.         foreach ($contents as $cnt) {

    706. 

  706.         /// Increment counter

    707. 

  707.             $i++;

    708. 

  708.             $content = $cnt->content;

    709. 

  709.             $content1 = $cnt->content1;

    710. 

  710.             $content2 = $cnt->content2;

    711. 

  711.             $content3 = $cnt->content3;

    712. 

  712.             $content4 = $cnt->content4;

    713. 

  713.             $result = restore_decode_content_links_worker($content,$restore);

    714. 

  714.             $result1 = restore_decode_content_links_worker($content1,$restore);

    715. 

  715.             $result2 = restore_decode_content_links_worker($content2,$restore);

    716. 

  716.             $result3 = restore_decode_content_links_worker($content3,$restore);

    717. 

  717.             $result4 = restore_decode_content_links_worker($content4,$restore);

    718. 

  718.             if ($result != $content || $result1 != $content1 || $result2 != $content2 ||

    719. 

  719.                 $result3 != $content3 || $result4 != $content4) {

    720. 

  720.             /// Unset fields to update only the necessary ones

    721. 

  721.                 unset($cnt->content);

    722. 

  722.                 unset($cnt->content1);

    723. 

  723.                 unset($cnt->content2);

    724. 

  724.                 unset($cnt->content3);

    725. 

  725.                 unset($cnt->content4);

    726. 

  726.             /// Conditionally set the fields

    727. 

  727.                 if ($result != $content) {

    728. 

  728.                     $cnt->content = addslashes($result);

    729. 

  729.                 }

    730. 

  730.                 if ($result1 != $content1) {

    731. 

  731.                     $cnt->content1 = addslashes($result1);

    732. 

  732.                 }

    733. 

  733.                 if ($result2 != $content2) {

    734. 

  734.                     $cnt->content2 = addslashes($result2);

    735. 

  735.                 }

    736. 

  736.                 if ($result3 != $content3) {

    737. 

  737.                     $cnt->content3 = addslashes($result3);

    738. 

  738.                 }

    739. 

  739.                 if ($result4 != $content4) {

    740. 

  740.                     $cnt->content4 = addslashes($result4);

    741. 

  741.                 }

    742. 

  742.             /// Update record with the changed fields

    743. 

  743.                 $status = update_record("data_content",$cnt);

    744. 

  744.                 if (debugging()) {

    745. 

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

    746. 

  746.                         echo '<br /><hr />'.s($content).'<br />changed to<br />'.s($result).'<hr /><br />';

    747. 

  747.                     }

    748. 

  748.                 }

    749. 

  749.             }

    750. 

  750.         /// Do some output

    751. 

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

    752. 

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

    753. 

  753.                     echo ".";

    754. 

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

    755. 

  755.                         echo "<br />";

    756. 

  756.                     }

    757. 

  757.                 }

    758. 

  758.                 backup_flush(300);

    759. 

  759.             }

    760. 

  760.         }

    761. 

  761.     }

    762. 

  762. 

    763. 

  763.     return $status;

    764. 

  764. }

    765. 

  765. 

    766. 

  766. ?>

    767. 

  767.