PageRenderTime 58ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 1ms

/mod/forum/restorelib.php

https://bitbucket.org/ceu/moodle_demo
PHP | 1203 lines | 806 code | 131 blank | 266 comment | 177 complexity | 4b99c9a8f2e8441d2573656a26554628 MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.0, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

    

  1. <?php //$Id: restorelib.php,v 1.60.4.6 2011/02/23 20:23:53 moodlerobot Exp $

    2. 

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

    3. 

  3.     //forum mods

    4. 

  4. 

    5. 

  5.     //This is the "graphical" structure of the forum mod:

    6. 

  6.     //

    7. 

  7.     //                               forum                                      

    8. 

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

    9. 

  9.     //                                 |

    10. 

  10.     //         ---------------------------------------------------        

    11. 

  11.     //         |                                                 |

    12. 

  12.     //    subscriptions                                  forum_discussions

    13. 

  13.     //(UL,pk->id, fk->forum)           ---------------(UL,pk->id, fk->forum)

    14. 

  14.     //                                 |                         |

    15. 

  15.     //                                 |                         |

    16. 

  16.     //                                 |                         |

    17. 

  17.     //                                 |                     forum_posts

    18. 

  18.     //                                 |-------------(UL,pk->id,fk->discussion,

    19. 

  19.     //                                 |                  nt->parent,files) 

    20. 

  20.     //                                 |                         |

    21. 

  21.     //                                 |                         |

    22. 

  22.     //                                 |                         |

    23. 

  23.     //                            forum_read                forum_ratings

    24. 

  24.     //                       (UL,pk->id,fk->post        (UL,pk->id,fk->post)

    25. 

  25.     //

    26. 

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

    27. 

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

    28. 

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

    29. 

  29.     //          CL->course level info

    30. 

  30.     //          UL->user level info

    31. 

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

    32. 

  32.     //

    33. 

  33.     //-----------------------------------------------------------

    34. 

  34. 

    35. 

  35.     function forum_restore_mods($mod,$restore) {

    36. 

  36.         

    37. 

  37.         global $CFG,$db;

    38. 

  38. 

    39. 

  39.         $status = true;

    40. 

  40. 

    41. 

  41.         //Get record from backup_ids

    42. 

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

    43. 

  43. 

    44. 

  44.         if ($data) {

    45. 

  45.             //Now get completed xmlized object

    46. 

  46.             $info = $data->info;

    47. 

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

    48. 

  48.             if ($restore->course_startdateoffset) {

    49. 

  49.                 restore_log_date_changes('Forum', $restore, $info['MOD']['#'], array('ASSESSTIMESTART', 'ASSESSTIMEFINISH'));

    50. 

  50.             }

    51. 

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

    52. 

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

    53. 

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

    54. 

  54. 

    55. 

  55.             //Now, build the FORUM record structure

    56. 

  56.             $forum->course = $restore->course_id;

    57. 

  57.             $forum->type = backup_todb($info['MOD']['#']['TYPE']['0']['#']);

    58. 

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

    59. 

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

    60. 

  60.             

    61. 

  61.             // These get dropped in Moodle 1.7 when the new Roles System gets

    62. 

  62.             // set up. Therefore they might or not be there depending on whether

    63. 

  63.             // we are restoring a 1.6+ forum or a 1.7 or later forum backup.

    64. 

  64.             if (isset($info['MOD']['#']['OPEN']['0']['#'])) {

    65. 

  65.                 $forum->open = backup_todb($info['MOD']['#']['OPEN']['0']['#']);

    66. 

  66.             }

    67. 

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

    68. 

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

    69. 

  69.             }

    70. 

  70.             

    71. 

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

    72. 

  72.             $forum->assesstimestart = backup_todb($info['MOD']['#']['ASSESSTIMESTART']['0']['#']);

    73. 

  73.             $forum->assesstimefinish = backup_todb($info['MOD']['#']['ASSESSTIMEFINISH']['0']['#']);

    74. 

  74.             $forum->maxbytes = backup_todb($info['MOD']['#']['MAXBYTES']['0']['#']);

    75. 

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

    76. 

  76.             $forum->forcesubscribe = backup_todb($info['MOD']['#']['FORCESUBSCRIBE']['0']['#']);

    77. 

  77.             $forum->trackingtype = backup_todb($info['MOD']['#']['TRACKINGTYPE']['0']['#']);

    78. 

  78.             $forum->rsstype = backup_todb($info['MOD']['#']['RSSTYPE']['0']['#']);

    79. 

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

    80. 

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

    81. 

  81.             $forum->warnafter = isset($info['MOD']['#']['WARNAFTER']['0']['#'])?backup_todb($info['MOD']['#']['WARNAFTER']['0']['#']):'';

    82. 

  82.             $forum->blockafter = isset($info['MOD']['#']['BLOCKAFTER']['0']['#'])?backup_todb($info['MOD']['#']['BLOCKAFTER']['0']['#']):'';

    83. 

  83.             $forum->blockperiod = isset($info['MOD']['#']['BLOCKPERIOD']['0']['#'])?backup_todb($info['MOD']['#']['BLOCKPERIOD']['0']['#']):'';

    84. 

  84. 

    85. 

  85. 

    86. 

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

    87. 

  87.             if ($forum->scale < 0) {

    88. 

  88.                 $scale = backup_getid($restore->backup_unique_code,"scale",abs($forum->scale));

    89. 

  89.                 if ($scale) {

    90. 

  90.                     $forum->scale = -($scale->new_id);

    91. 

  91.                 }

    92. 

  92.             }

    93. 

  93.             

    94. 

  94.             $newid = insert_record("forum", $forum);

    95. 

  95. 

    96. 

  96. 

    97. 

  97.             //Do some output

    98. 

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

    99. 

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

    100. 

  100.             }

    101. 

  101.             backup_flush(300);

    102. 

  102. 

    103. 

  103.             if ($newid) {

    104. 

  104.                 //We have the newid, update backup_ids

    105. 

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

    106. 

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

    107. 

  107. 

    108. 

  108.                 $forum->id = $newid;

    109. 

  109. 

    110. 

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

    111. 

  111.                 if (restore_userdata_selected($restore,'forum',$mod->id)) {

    112. 

  112.                     //Restore forum_subscriptions

    113. 

  113.                     $status = forum_subscriptions_restore_mods ($newid,$info,$restore);

    114. 

  114.                     if ($status) {

    115. 

  115.                         //Restore forum_discussions

    116. 

  116.                         $status = forum_discussions_restore_mods ($newid,$info,$restore);

    117. 

  117.                     }

    118. 

  118.                     if ($status) {

    119. 

  119.                         //Restore forum_read

    120. 

  120.                         $status = forum_read_restore_mods ($newid,$info,$restore);

    121. 

  121.                     }

    122. 

  122.                 }

    123. 

  123. 

    124. 

  124.                 // If forum type is single, just recreate the initial discussion/post automatically

    125. 

  125.                 // if it hasn't been created still (because no user data was selected on backup or

    126. 

  126.                 // restore.

    127. 

  127.                 if ($forum->type == 'single' && !record_exists('forum_discussions', 'forum', $newid)) {

    128. 

  128.                     //Load forum/lib.php

    129. 

  129.                     require_once ($CFG->dirroot.'/mod/forum/lib.php');

    130. 

  130.                     // Calculate the default format

    131. 

  131.                     if (can_use_html_editor()) {

    132. 

  132.                         $defaultformat = FORMAT_HTML;

    133. 

  133.                     } else {

    134. 

  134.                         $defaultformat = FORMAT_MOODLE;

    135. 

  135.                     }

    136. 

  136.                     //Create discussion/post data

    137. 

  137.                     $sd = new stdClass;

    138. 

  138.                     $sd->course   = $forum->course;

    139. 

  139.                     $sd->forum    = $newid;

    140. 

  140.                     $sd->name     = $forum->name;

    141. 

  141.                     $sd->intro    = $forum->intro;

    142. 

  142.                     $sd->assessed = $forum->assessed;

    143. 

  143.                     $sd->format   = $defaultformat;

    144. 

  144.                     $sd->mailnow  = false;

    145. 

  145.                     //Insert dicussion/post data

    146. 

  146.                     $sdid = forum_add_discussion($sd, $sd->intro, $forum);

    147. 

  147.                     //Now, mark the initial post of the discussion as mailed!

    148. 

  148.                     if ($sdid) {

    149. 

  149.                         set_field ('forum_posts','mailed', '1', 'discussion', $sdid);

    150. 

  150.                     }

    151. 

  151.                 }

    152. 

  152.             

    153. 

  153.             } else {

    154. 

  154.                 $status = false;

    155. 

  155.             }

    156. 

  156. 

    157. 

  157.             // If the backup contained $forum->open and $forum->assesspublic,

    158. 

  158.             // we need to convert the forum to use Roles. It means the backup

    159. 

  159.             // was made pre Moodle 1.7.

    160. 

  160.             if (isset($forum->open) && isset($forum->assesspublic)) {

    161. 

  161. 

    162. 

  162.                 $forummod = get_record('modules', 'name', 'forum');

    163. 

  163.                 

    164. 

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

    165. 

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

    166. 

  166.                              'for all your forums will have to be manually set.');

    167. 

  167.                 }

    168. 

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

    169. 

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

    170. 

  170.                              'for all your forums will have to be manually set.');

    171. 

  171.                 }

    172. 

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

    173. 

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

    174. 

  174.                              'for teacher forums will have to be manually set.');

    175. 

  175.                 }

    176. 

  176.                 require_once($CFG->dirroot.'/mod/forum/lib.php');

    177. 

  177.                 forum_convert_to_roles($forum, $forummod->id,

    178. 

  178.                                        $teacherroles, $studentroles, $guestroles,

    179. 

  179.                                        $restore->mods['forum']->instances[$mod->id]->restored_as_course_module);

    180. 

  180.             }

    181. 

  181.             

    182. 

  182.         } else {

    183. 

  183.             $status = false;

    184. 

  184.         }

    185. 

  185. 

    186. 

  186.         return $status;

    187. 

  187.     }

    188. 

  188. 

    189. 

  189.     //This function restores the forum_subscriptions

    190. 

  190.     function forum_subscriptions_restore_mods($forum_id,$info,$restore) {

    191. 

  191. 

    192. 

  192.         global $CFG;

    193. 

  193. 

    194. 

  194.         $status = true;

    195. 

  195. 

    196. 

  196.         //Get the discussions array

    197. 

  197.         $subscriptions = array();

    198. 

  198.         if (isset($info['MOD']['#']['SUBSCRIPTIONS']['0']['#']['SUBSCRIPTION'])) {

    199. 

  199.             $subscriptions = $info['MOD']['#']['SUBSCRIPTIONS']['0']['#']['SUBSCRIPTION'];

    200. 

  200.         }

    201. 

  201. 

    202. 

  202.         //Iterate over subscriptions

    203. 

  203.         for($i = 0; $i < sizeof($subscriptions); $i++) {

    204. 

  204.             $sus_info = $subscriptions[$i];

    205. 

  205.             //traverse_xmlize($sus_info);                                                                 //Debug

    206. 

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

    207. 

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

    208. 

  208. 

    209. 

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

    210. 

  210.             $oldid = backup_todb($sus_info['#']['ID']['0']['#']);

    211. 

  211.             $olduserid = backup_todb($sus_info['#']['USERID']['0']['#']);

    212. 

  212. 

    213. 

  213.             //Now, build the FORUM_SUBSCRIPTIONS record structure

    214. 

  214.             $subscription->forum = $forum_id;

    215. 

  215.             $subscription->userid = backup_todb($sus_info['#']['USERID']['0']['#']);

    216. 

  216. 

    217. 

  217.             //We have to recode the userid field

    218. 

  218.             $user = backup_getid($restore->backup_unique_code,"user",$subscription->userid);

    219. 

  219.             if ($user) {

    220. 

  220.                 $subscription->userid = $user->new_id;

    221. 

  221.             }

    222. 

  222. 

    223. 

  223.             //The structure is equal to the db, so insert the forum_subscription

    224. 

  224.             $newid = insert_record ("forum_subscriptions",$subscription);

    225. 

  225. 

    226. 

  226.             //Do some output

    227. 

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

    228. 

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

    229. 

  229.                     echo ".";

    230. 

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

    231. 

  231.                         echo "<br />";

    232. 

  232.                     }

    233. 

  233.                 }

    234. 

  234.                 backup_flush(300);

    235. 

  235.             }

    236. 

  236. 

    237. 

  237.             if ($newid) {

    238. 

  238.                 //We have the newid, update backup_ids

    239. 

  239.                 backup_putid($restore->backup_unique_code,"forum_subscriptions",$oldid,

    240. 

  240.                              $newid);

    241. 

  241.             } else {

    242. 

  242.                 $status = false;

    243. 

  243.             }

    244. 

  244.         }

    245. 

  245. 

    246. 

  246.         return $status;

    247. 

  247.     }

    248. 

  248. 

    249. 

  249.     //This function restores the forum_discussions

    250. 

  250.     function forum_discussions_restore_mods($forum_id,$info,$restore) {

    251. 

  251. 

    252. 

  252.         global $CFG;

    253. 

  253. 

    254. 

  254.         $status = true;

    255. 

  255. 

    256. 

  256.         //Get the discussions array

    257. 

  257.         $discussions = array();

    258. 

  258.         

    259. 

  259.         if (!empty($info['MOD']['#']['DISCUSSIONS']['0']['#']['DISCUSSION'])) {

    260. 

  260.             $discussions = $info['MOD']['#']['DISCUSSIONS']['0']['#']['DISCUSSION'];

    261. 

  261.         }

    262. 

  262. 

    263. 

  263.         //Iterate over discussions

    264. 

  264.         for($i = 0; $i < sizeof($discussions); $i++) {

    265. 

  265.             $dis_info = $discussions[$i];

    266. 

  266.             //traverse_xmlize($dis_info);                                                                 //Debug

    267. 

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

    268. 

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

    269. 

  269. 

    270. 

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

    271. 

  271.             $oldid = backup_todb($dis_info['#']['ID']['0']['#']);

    272. 

  272.             $olduserid = backup_todb($dis_info['#']['USERID']['0']['#']);

    273. 

  273. 

    274. 

  274.             //Now, build the FORUM_DISCUSSIONS record structure

    275. 

  275.             $discussion = new object();

    276. 

  276.             $discussion->forum = $forum_id;

    277. 

  277.             $discussion->course = $restore->course_id;

    278. 

  278.             $discussion->name = backup_todb($dis_info['#']['NAME']['0']['#']);

    279. 

  279.             $discussion->firstpost = backup_todb($dis_info['#']['FIRSTPOST']['0']['#']);

    280. 

  280.             $discussion->userid = backup_todb($dis_info['#']['USERID']['0']['#']);

    281. 

  281.             $discussion->groupid = backup_todb($dis_info['#']['GROUPID']['0']['#']);

    282. 

  282.             $discussion->assessed = backup_todb($dis_info['#']['ASSESSED']['0']['#']);

    283. 

  283.             $discussion->timemodified = backup_todb($dis_info['#']['TIMEMODIFIED']['0']['#']);

    284. 

  284.             $discussion->timemodified += $restore->course_startdateoffset;

    285. 

  285.             $discussion->usermodified = backup_todb($dis_info['#']['USERMODIFIED']['0']['#']);  

    286. 

  286.             $discussion->timestart = backup_todb($dis_info['#']['TIMESTART']['0']['#']);

    287. 

  287.             $discussion->timestart += $restore->course_startdateoffset;

    288. 

  288.             $discussion->timeend = backup_todb($dis_info['#']['TIMEEND']['0']['#']);

    289. 

  289.             $discussion->timeend += $restore->course_startdateoffset;

    290. 

  290.             //We have to recode the userid field

    291. 

  291.             $user = backup_getid($restore->backup_unique_code,"user",$discussion->userid);

    292. 

  292.             if ($user) {

    293. 

  293.                 $discussion->userid = $user->new_id;

    294. 

  294.             }

    295. 

  295. 

    296. 

  296.             //We have to recode the groupid field

    297. 

  297.             $group = restore_group_getid($restore, $discussion->groupid);

    298. 

  298.             if ($group) {

    299. 

  299.                 $discussion->groupid = $group->new_id;

    300. 

  300.             }

    301. 

  301. 

    302. 

  302.             //We have to recode the usermodified field

    303. 

  303.             $user = backup_getid($restore->backup_unique_code,"user",$discussion->usermodified);

    304. 

  304.             if ($user) {

    305. 

  305.                 $discussion->usermodified = $user->new_id;

    306. 

  306.             }

    307. 

  307. 

    308. 

  308.             //The structure is equal to the db, so insert the forum_discussions

    309. 

  309.             $newid = insert_record ("forum_discussions",$discussion);

    310. 

  310. 

    311. 

  311.             //Do some output

    312. 

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

    313. 

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

    314. 

  314.                     echo ".";

    315. 

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

    316. 

  316.                         echo "<br />";

    317. 

  317.                     }

    318. 

  318.                 }

    319. 

  319.                 backup_flush(300);

    320. 

  320.             }

    321. 

  321. 

    322. 

  322.             if ($newid) {

    323. 

  323.                 //We have the newid, update backup_ids

    324. 

  324.                 backup_putid($restore->backup_unique_code,"forum_discussions",$oldid,

    325. 

  325.                              $newid);

    326. 

  326.                 //Restore forum_posts

    327. 

  327.                 $status = forum_posts_restore_mods ($forum_id,$newid,$dis_info,$restore);

    328. 

  328.                 //Now recalculate firstpost field

    329. 

  329.                 $old_firstpost = $discussion->firstpost;

    330. 

  330.                 //Get its new post_id from backup_ids table

    331. 

  331.                 $rec = backup_getid($restore->backup_unique_code,"forum_posts",$old_firstpost);

    332. 

  332.                 if ($rec) {

    333. 

  333.                     //Put its new firstpost

    334. 

  334.                     $discussion->firstpost = $rec->new_id;

    335. 

  335.                     if ($post = get_record("forum_posts", "id", $discussion->firstpost)) {

    336. 

  336.                         $discussion->userid = $post->userid;

    337. 

  337.                     }

    338. 

  338.                 } else {

    339. 

  339.                      $discussion->firstpost = 0;

    340. 

  340.                      $discussion->userid = 0;

    341. 

  341.                 }

    342. 

  342.                 //Create temp discussion record

    343. 

  343.                 $temp_discussion->id = $newid;

    344. 

  344.                 $temp_discussion->firstpost = $discussion->firstpost;

    345. 

  345.                 $temp_discussion->userid = $discussion->userid;

    346. 

  346.                 //Update discussion (only firstpost and userid will be changed)

    347. 

  347.                 $status = update_record("forum_discussions",$temp_discussion);

    348. 

  348.                 //echo "Updated firstpost ".$old_firstpost." to ".$temp_discussion->firstpost."<br />";                //Debug

    349. 

  349.             } else {

    350. 

  350.                 $status = false;

    351. 

  351.             }

    352. 

  352.         }

    353. 

  353. 

    354. 

  354.         return $status;

    355. 

  355.     }

    356. 

  356. 

    357. 

  357.     //This function restores the forum_read

    358. 

  358.     function forum_read_restore_mods($forum_id,$info,$restore) {

    359. 

  359. 

    360. 

  360.         global $CFG;

    361. 

  361. 

    362. 

  362.         $status = true;

    363. 

  363. 

    364. 

  364.         //Get the read array

    365. 

  365.         $readposts = array();

    366. 

  366.         if (isset($info['MOD']['#']['READPOSTS']['0']['#']['READ'])) {

    367. 

  367.             $readposts = $info['MOD']['#']['READPOSTS']['0']['#']['READ'];

    368. 

  368.         }

    369. 

  369. 

    370. 

  370.         //Iterate over readposts

    371. 

  371.         for($i = 0; $i < sizeof($readposts); $i++) {

    372. 

  372.             $rea_info = $readposts[$i];

    373. 

  373.             //traverse_xmlize($rea_info);                                                                 //Debug

    374. 

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

    375. 

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

    376. 

  376. 

    377. 

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

    378. 

  378.             $oldid = backup_todb($rea_info['#']['ID']['0']['#']);

    379. 

  379. 

    380. 

  380.             //Now, build the FORUM_READ record structure

    381. 

  381.             $read->forumid = $forum_id;

    382. 

  382.             $read->userid = backup_todb($rea_info['#']['USERID']['0']['#']);

    383. 

  383.             $read->discussionid = backup_todb($rea_info['#']['DISCUSSIONID']['0']['#']);

    384. 

  384.             $read->postid = backup_todb($rea_info['#']['POSTID']['0']['#']);

    385. 

  385.             $read->firstread = backup_todb($rea_info['#']['FIRSTREAD']['0']['#']);

    386. 

  386.             $read->lastread = backup_todb($rea_info['#']['LASTREAD']['0']['#']);

    387. 

  387. 

    388. 

  388.             //We have to recode the userid field

    389. 

  389.             $user = backup_getid($restore->backup_unique_code,"user",$read->userid);

    390. 

  390.             if ($user) {

    391. 

  391.                 $read->userid = $user->new_id;

    392. 

  392.             } else {

    393. 

  393.                 continue; // Skip this forum_read record

    394. 

  394.             }

    395. 

  395. 

    396. 

  396.             //We have to recode the discussionid field

    397. 

  397.             $discussion = backup_getid($restore->backup_unique_code,"forum_discussions",$read->discussionid);

    398. 

  398.             if ($discussion) {

    399. 

  399.                 $read->discussionid = $discussion->new_id;

    400. 

  400.             } else {

    401. 

  401.                 continue; // Skip this forum_read record

    402. 

  402.             }

    403. 

  403. 

    404. 

  404.             //We have to recode the postid field

    405. 

  405.             $post = backup_getid($restore->backup_unique_code,"forum_posts",$read->postid);

    406. 

  406.             if ($post) {

    407. 

  407.                 $read->postid = $post->new_id;

    408. 

  408.             } else {

    409. 

  409.                 continue; // Skip this forum_read record

    410. 

  410.             }

    411. 

  411. 

    412. 

  412.             // Arrived here, the structure is equal to the db, so insert the forum_read

    413. 

  413.             $newid = 0;

    414. 

  414.             $newid = insert_record ("forum_read",$read);

    415. 

  415. 

    416. 

  416.             //Do some output

    417. 

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

    418. 

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

    419. 

  419.                     echo ".";

    420. 

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

    421. 

  421.                         echo "<br />";

    422. 

  422.                     }

    423. 

  423.                 }

    424. 

  424.                 backup_flush(300);

    425. 

  425.             }

    426. 

  426. 

    427. 

  427.             if ($newid) {

    428. 

  428.                 //We have the newid, update backup_ids

    429. 

  429.                 backup_putid($restore->backup_unique_code,"forum_read",$oldid,

    430. 

  430.                              $newid);

    431. 

  431.             } else {

    432. 

  432.                 $status = false;

    433. 

  433.             }

    434. 

  434.         }

    435. 

  435. 

    436. 

  436.         return $status;

    437. 

  437.     }

    438. 

  438. 

    439. 

  439.     //This function restores the forum_posts

    440. 

  440.     function forum_posts_restore_mods($new_forum_id,$discussion_id,$info,$restore) {

    441. 

  441. 

    442. 

  442.         global $CFG;

    443. 

  443. 

    444. 

  444.         $status = true;

    445. 

  445. 

    446. 

  446.         //Get the posts array

    447. 

  447.         $posts = $info['#']['POSTS']['0']['#']['POST'];

    448. 

  448. 

    449. 

  449.         //Iterate over posts

    450. 

  450.         for($i = 0; $i < sizeof($posts); $i++) {

    451. 

  451.             $pos_info = $posts[$i];

    452. 

  452.             //traverse_xmlize($pos_info);                                                                 //Debug

    453. 

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

    454. 

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

    455. 

  455. 

    456. 

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

    457. 

  457.             $oldid = backup_todb($pos_info['#']['ID']['0']['#']);

    458. 

  458.             $olduserid = backup_todb($pos_info['#']['USERID']['0']['#']);

    459. 

  459. 

    460. 

  460.             //Now, build the FORUM_POSTS record structure

    461. 

  461.             $post->discussion = $discussion_id;

    462. 

  462.             $post->parent = backup_todb($pos_info['#']['PARENT']['0']['#']);

    463. 

  463.             $post->userid = backup_todb($pos_info['#']['USERID']['0']['#']);   

    464. 

  464.             $post->created = backup_todb($pos_info['#']['CREATED']['0']['#']);

    465. 

  465.             $post->created += $restore->course_startdateoffset;

    466. 

  466.             $post->modified = backup_todb($pos_info['#']['MODIFIED']['0']['#']);

    467. 

  467.             $post->modified += $restore->course_startdateoffset;             

    468. 

  468.             $post->mailed = backup_todb($pos_info['#']['MAILED']['0']['#']);

    469. 

  469.             $post->subject = backup_todb($pos_info['#']['SUBJECT']['0']['#']);

    470. 

  470.             $post->message = backup_todb($pos_info['#']['MESSAGE']['0']['#']);

    471. 

  471.             $post->format = backup_todb($pos_info['#']['FORMAT']['0']['#']);

    472. 

  472.             $post->attachment = backup_todb($pos_info['#']['ATTACHMENT']['0']['#']);

    473. 

  473.             $post->totalscore = backup_todb($pos_info['#']['TOTALSCORE']['0']['#']);

    474. 

  474.             $post->mailnow = backup_todb($pos_info['#']['MAILNOW']['0']['#']);

    475. 

  475. 

    476. 

  476.             //We have to recode the userid field

    477. 

  477.             $user = backup_getid($restore->backup_unique_code,"user",$post->userid);

    478. 

  478.             if ($user) {

    479. 

  479.                 $post->userid = $user->new_id;

    480. 

  480.             }

    481. 

  481. 

    482. 

  482.             //The structure is equal to the db, so insert the forum_posts

    483. 

  483.             $newid = insert_record ("forum_posts",$post);

    484. 

  484. 

    485. 

  485.             //Do some output

    486. 

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

    487. 

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

    488. 

  488.                     echo ".";

    489. 

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

    490. 

  490.                         echo "<br />";

    491. 

  491.                     }

    492. 

  492.                 }

    493. 

  493.                 backup_flush(300);

    494. 

  494.             }

    495. 

  495. 

    496. 

  496.             if ($newid) {

    497. 

  497.                 //We have the newid, update backup_ids

    498. 

  498.                 backup_putid($restore->backup_unique_code,"forum_posts",$oldid,

    499. 

  499.                              $newid);

    500. 

  500. 

    501. 

  501.                 //Get old forum id from backup_ids

    502. 

  502.                 $rec = get_record("backup_ids","backup_code",$restore->backup_unique_code,

    503. 

  503.                                                "table_name","forum",

    504. 

  504.                                                "new_id",$new_forum_id);

    505. 

  505.                 //Now copy moddata associated files

    506. 

  506.                 $status = forum_restore_files ($rec->old_id, $new_forum_id,

    507. 

  507.                                                     $oldid, $newid, $restore);

    508. 

  508. 

    509. 

  509.                 //Now restore post ratings

    510. 

  510.                 $status = forum_ratings_restore_mods($newid,$pos_info,$restore);

    511. 

  511. 

    512. 

  512.             } else {

    513. 

  513.                 $status = false;

    514. 

  514.             }

    515. 

  515.         }

    516. 

  516. 

    517. 

  517.         //Now we get every post in this discussion_id and recalculate its parent post

    518. 

  518.         $posts = get_records ("forum_posts","discussion",$discussion_id);

    519. 

  519.         if ($posts) {

    520. 

  520.             //Iterate over each post

    521. 

  521.             foreach ($posts as $post) {

    522. 

  522.                 //Get its parent

    523. 

  523.                 $old_parent = $post->parent;

    524. 

  524.                 //Get its new post_id from backup_ids table

    525. 

  525.                 $rec = backup_getid($restore->backup_unique_code,"forum_posts",$old_parent);

    526. 

  526.                 if ($rec) {

    527. 

  527.                     //Put its new parent

    528. 

  528.                     $post->parent = $rec->new_id;

    529. 

  529.                 } else {

    530. 

  530.                      $post->parent = 0;

    531. 

  531.                 }

    532. 

  532.                 //Create temp post record

    533. 

  533.                 $temp_post->id = $post->id;

    534. 

  534.                 $temp_post->parent = $post->parent;

    535. 

  535.                 //echo "Updated parent ".$old_parent." to ".$temp_post->parent."<br />";                //Debug

    536. 

  536.                 //Update post (only parent will be changed)

    537. 

  537.                 $status = update_record("forum_posts",$temp_post);

    538. 

  538.             }

    539. 

  539.         }

    540. 

  540. 

    541. 

  541.         return $status;

    542. 

  542.     }

    543. 

  543. 

    544. 

  544.     //This function copies the forum related info from backup temp dir to course moddata folder,

    545. 

  545.     //creating it if needed and recoding everything (forum id and post id)

    546. 

  546.     function forum_restore_files ($oldforid, $newforid, $oldpostid, $newpostid, $restore) {

    547. 

  547. 

    548. 

  548.         global $CFG;

    549. 

  549. 

    550. 

  550.         $status = true;

    551. 

  551.         $todo = false;

    552. 

  552.         $moddata_path = "";

    553. 

  553.         $forum_path = "";

    554. 

  554.         $temp_path = "";

    555. 

  555. 

    556. 

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

    557. 

  557.         //in CFG->dataroot

    558. 

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

    559. 

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

    560. 

  560. 

    561. 

  561.         //First, locate course's moddata directory

    562. 

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

    563. 

  563. 

    564. 

  564.         //Check it exists and create it

    565. 

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

    566. 

  566. 

    567. 

  567.         //Now, locate forum directory

    568. 

  568.         if ($status) {

    569. 

  569.             $forum_path = $moddata_path."/forum";

    570. 

  570.             //Check it exists and create it

    571. 

  571.             $status = check_dir_exists($forum_path,true);

    572. 

  572.         }

    573. 

  573. 

    574. 

  574.         //Now locate the temp dir we are restoring from

    575. 

  575.         if ($status) {

    576. 

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

    577. 

  577.                          "/moddata/forum/".$oldforid."/".$oldpostid;

    578. 

  578.             //Check it exists

    579. 

  579.             if (is_dir($temp_path)) {

    580. 

  580.                 $todo = true;

    581. 

  581.             }

    582. 

  582.         }

    583. 

  583. 

    584. 

  584.         //If todo, we create the neccesary dirs in course moddata/forum

    585. 

  585.         if ($status and $todo) {

    586. 

  586.             //First this forum id

    587. 

  587.             $this_forum_path = $forum_path."/".$newforid;

    588. 

  588.             $status = check_dir_exists($this_forum_path,true);

    589. 

  589.             //Now this post id

    590. 

  590.             $post_forum_path = $this_forum_path."/".$newpostid;

    591. 

  591.             //And now, copy temp_path to post_forum_path

    592. 

  592.             $status = backup_copy_file($temp_path, $post_forum_path);

    593. 

  593.         }

    594. 

  594. 

    595. 

  595.         return $status;

    596. 

  596.     }

    597. 

  597. 

    598. 

  598.     //This function restores the forum_ratings

    599. 

  599.     function forum_ratings_restore_mods($new_post_id,$info,$restore) {

    600. 

  600. 

    601. 

  601.         global $CFG;

    602. 

  602. 

    603. 

  603.         $status = true;

    604. 

  604. 

    605. 

  605.         //Get the ratings array

    606. 

  606.         $ratings = array();

    607. 

  607.         if (isset($info['#']['RATINGS']['0']['#']['RATING'])) {

    608. 

  608.             $ratings = $info['#']['RATINGS']['0']['#']['RATING'];

    609. 

  609.         }

    610. 

  610. 

    611. 

  611.         //Iterate over ratings

    612. 

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

    613. 

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

    614. 

  614.             //traverse_xmlize($rat_info);                                                                 //Debug

    615. 

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

    616. 

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

    617. 

  617. 

    618. 

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

    619. 

  619.             $oldid = backup_todb($rat_info['#']['ID']['0']['#']);

    620. 

  620.             $olduserid = backup_todb($rat_info['#']['USERID']['0']['#']);

    621. 

  621. 

    622. 

  622.             //Now, build the FORM_RATINGS record structure

    623. 

  623.             $rating->post = $new_post_id;

    624. 

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

    625. 

  625.             $rating->time = backup_todb($rat_info['#']['TIME']['0']['#']);

    626. 

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

    627. 

  627. 

    628. 

  628.             //We have to recode the userid field

    629. 

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

    630. 

  630.             if ($user) {

    631. 

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

    632. 

  632.             }

    633. 

  633. 

    634. 

  634.             //The structure is equal to the db, so insert the forum_ratings

    635. 

  635.             $newid = insert_record ("forum_ratings",$rating);

    636. 

  636. 

    637. 

  637.             //Do some output

    638. 

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

    639. 

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

    640. 

  640.                     echo ".";

    641. 

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

    642. 

  642.                         echo "<br />";

    643. 

  643.                     }

    644. 

  644.                 }

    645. 

  645.                 backup_flush(300);

    646. 

  646.             }

    647. 

  647. 

    648. 

  648.             if ($newid) {

    649. 

  649.                 //We have the newid, update backup_ids

    650. 

  650.                 backup_putid($restore->backup_unique_code,"forum_ratings",$oldid,

    651. 

  651.                              $newid);

    652. 

  652.             } else {

    653. 

  653.                 $status = false;

    654. 

  654.             }

    655. 

  655.         }

    656. 

  656. 

    657. 

  657.         return $status;

    658. 

  658.     }

    659. 

  659. 

    660. 

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

    661. 

  661.     //some texts in the module

    662. 

  662.     function forum_restore_wiki2markdown ($restore) {

    663. 

  663.     

    664. 

  664.         global $CFG;

    665. 

  665. 

    666. 

  666.         $status = true;

    667. 

  667. 

    668. 

  668.         //Convert forum_posts->message

    669. 

  669.         if ($records = get_records_sql ("SELECT p.id, p.message, p.format

    670. 

  670.                                          FROM {$CFG->prefix}forum_posts p,

    671. 

  671.                                               {$CFG->prefix}forum_discussions d,

    672. 

  672.                                               {$CFG->prefix}forum f,

    673. 

  673.                                               {$CFG->prefix}backup_ids b

    674. 

  674.                                          WHERE d.id = p.discussion AND

    675. 

  675.                                                f.id = d.forum AND

    676. 

  676.                                                f.course = $restore->course_id AND

    677. 

  677.                                                p.format = ".FORMAT_WIKI. " AND

    678. 

  678.                                                b.backup_code = $restore->backup_unique_code AND

    679. 

  679.                                                b.table_name = 'forum_posts' AND

    680. 

  680.                                                b.new_id = p.id")) {

    681. 

  681.             foreach ($records as $record) {

    682. 

  682.                 //Rebuild wiki links

    683. 

  683.                 $record->message = restore_decode_wiki_content($record->message, $restore);

    684. 

  684.                 //Convert to Markdown

    685. 

  685.                 $wtm = new WikiToMarkdown();

    686. 

  686.                 $record->message = $wtm->convert($record->message, $restore->course_id);

    687. 

  687.                 $record->format = FORMAT_MARKDOWN;

    688. 

  688.                 $status = update_record('forum_posts', addslashes_object($record));

    689. 

  689.                 //Do some output

    690. 

  690.                 $i++;

    691. 

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

    692. 

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

    693. 

  693.                         echo ".";

    694. 

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

    695. 

  695.                             echo "<br />";

    696. 

  696.                         }

    697. 

  697.                     }

    698. 

  698.                     backup_flush(300);

    699. 

  699.                 }

    700. 

  700.             }

    701. 

  701. 

    702. 

  702.         }

    703. 

  703.         return $status;

    704. 

  704.     }

    705. 

  705. 

    706. 

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

    707. 

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

    708. 

  708.     function forum_restore_logs($restore,$log) {

    709. 

  709. 

    710. 

  710.         $status = false;

    711. 

  711. 

    712. 

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

    713. 

  713.         switch ($log->action) {

    714. 

  714.         case "add":

    715. 

  715.             if ($log->cmid) {

    716. 

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

    717. 

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

    718. 

  718.                 if ($mod) {

    719. 

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

    720. 

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

    721. 

  721.                     $status = true;

    722. 

  722.                 }

    723. 

  723.             }

    724. 

  724.             break;

    725. 

  725.         case "mark read":

    726. 

  726.             if ($log->cmid) {

    727. 

  727.                 //Get the new_id of the module (to recode the url and info fields)

    728. 

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

    729. 

  729.                 if ($mod) {

    730. 

  730.                     $log->url = "view.php?f=".$mod->new_id;

    731. 

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

    732. 

  732.                     $status = true;

    733. 

  733.                 }

    734. 

  734.             }

    735. 

  735.             break;

    736. 

  736.         case "start tracking":

    737. 

  737.             if ($log->cmid) {

    738. 

  738.                 //Get the new_id of the module (to recode the url and info fields)

    739. 

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

    740. 

  740.                 if ($mod) {

    741. 

  741.                     $log->url = "view.php?f=".$mod->new_id;

    742. 

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

    743. 

  743.                     $status = true;

    744. 

  744.                 }

    745. 

  745.             }

    746. 

  746.             break;

    747. 

  747.         case "stop tracking":

    748. 

  748.             if ($log->cmid) {

    749. 

  749.                 //Get the new_id of the module (to recode the url and info fields)

    750. 

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

    751. 

  751.                 if ($mod) {

    752. 

  752.                     $log->url = "view.php?f=".$mod->new_id;

    753. 

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

    754. 

  754.                     $status = true;

    755. 

  755.                 }

    756. 

  756.             }

    757. 

  757.             break;

    758. 

  758.         case "update":

    759. 

  759.             if ($log->cmid) {

    760. 

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

    761. 

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

    762. 

  762.                 if ($mod) {

    763. 

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

    764. 

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

    765. 

  765.                     $status = true;

    766. 

  766.                 }

    767. 

  767.             }

    768. 

  768.             break;

    769. 

  769.         case "view forum":

    770. 

  770.             if ($log->cmid) {

    771. 

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

    772. 

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

    773. 

  773.                 if ($mod) {

    774. 

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

    775. 

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

    776. 

  776.                     $status = true;

    777. 

  777.                 }

    778. 

  778.             }

    779. 

  779.             break;

    780. 

  780.         case "view forums":

    781. 

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

    782. 

  782.             $status = true;

    783. 

  783.             break;

    784. 

  784.         case "subscribeall":

    785. 

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

    786. 

  786.             $status = true;

    787. 

  787.             break;

    788. 

  788.         case "unsubscribeall":

    789. 

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

    790. 

  790.             $status = true;

    791. 

  791.             break;

    792. 

  792.         case "subscribe":

    793. 

  793.             if ($log->cmid) {

    794. 

  794.                 //Get the new_id of the module (to recode the info and url field)

    795. 

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

    796. 

  796.                 if ($mod) {

    797. 

  797.                     $log->url = "view.php?f=".$mod->new_id;

    798. 

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

    799. 

  799.                     $status = true;

    800. 

  800.                 }

    801. 

  801.             }

    802. 

  802.             break;

    803. 

  803.         case "view subscriber":

    804. 

  804.         case "view subscribers":

    805. 

  805.             if ($log->cmid) {

    806. 

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

    807. 

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

    808. 

  808.                 if ($mod) {

    809. 

  809.                     $log->url = "subscribers.php?id=".$mod->new_id;

    810. 

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

    811. 

  811.                     $status = true;

    812. 

  812.                 }

    813. 

  813.             }

    814. 

  814.             break;

    815. 

  815.         case "unsubscribe":

    816. 

  816.             if ($log->cmid) {

    817. 

  817.                 //Get the new_id of the module (to recode the info and url field)

    818. 

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

    819. 

  819.                 if ($mod) {

    820. 

  820.                     $log->url = "view.php?f=".$mod->new_id;

    821. 

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

    822. 

  822.                     $status = true;

    823. 

  823.                 }

    824. 

  824.             }

    825. 

  825.             break;

    826. 

  826.         case "add discussion":

    827. 

  827.             if ($log->cmid) {

    828. 

  828.                 //Get the new_id of the discussion (to recode the info and url field)

    829. 

  829.                 $dis = backup_getid($restore->backup_unique_code,"forum_discussions",$log->info);

    830. 

  830.                 if ($dis) {

    831. 

  831.                     $log->url = "discuss.php?d=".$dis->new_id;

    832. 

  832.                     $log->info = $dis->new_id;

    833. 

  833.                     $status = true;

    834. 

  834.                 }

    835. 

  835.             }

    836. 

  836.             break;

    837. 

  837.         case "view discussion":

    838. 

  838.             if ($log->cmid) {

    839. 

  839.                 //Get the new_id of the discussion (to recode the info and url field)

    840. 

  840.                 $dis = backup_getid($restore->backup_unique_code,"forum_discussions",$log->info);

    841. 

  841.                 if ($dis) {

    842. 

  842.                     $log->url = "discuss.php?d=".$dis->new_id;

    843. 

  843.                     $log->info = $dis->new_id;

    844. 

  844.                     $status = true;

    845. 

  845.                 }

    846. 

  846.             }

    847. 

  847.             break;

    848. 

  848.         case "move discussion":

    849. 

  849.             if ($log->cmid) {

    850. 

  850.                 //Get the new_id of the discussion (to recode the info and url field)

    851. 

  851.                 $dis = backup_getid($restore->backup_unique_code,"forum_discussions",$log->info);

    852. 

  852.                 if ($dis) {

    853. 

  853.                     $log->url = "discuss.php?d=".$dis->new_id;

    854. 

  854.                     $log->info = $dis->new_id;

    855. 

  855.                     $status = true;

    856. 

  856.                 }

    857. 

  857.             }

    858. 

  858.             break;

    859. 

  859.         case "delete discussi":

    860. 

  860.         case "delete discussion":

    861. 

  861.             if ($log->cmid) {

    862. 

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

    863. 

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

    864. 

  864.                 if ($mod) {

    865. 

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

    866. 

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

    867. 

  867.                     $status = true;

    868. 

  868.                 }

    869. 

  869.             }

    870. 

  870.             break;

    871. 

  871.         case "add post":

    872. 

  872.             if ($log->cmid) {

    873. 

  873.                 //Get the new_id of the post (to recode the url and info field)

    874. 

  874.                 $pos = backup_getid($restore->backup_unique_code,"forum_posts",$log->info);

    875. 

  875.                 if ($pos) {

    876. 

  876.                     //Get the post record from database

    877. 

  877.                     $dbpos = get_record("forum_posts","id","$pos->new_id");

    878. 

  878.                     if ($dbpos) {

    879. 

  879.                         $log->url = "discuss.php?d=".$dbpos->discussion."&parent=".$pos->new_id;

    880. 

  880.                         $log->info = $pos->new_id;

    881. 

  881.                         $status = true;

    882. 

  882.                     }

    883. 

  883.                 }

    884. 

  884.             }

    885. 

  885.             break;

    886. 

  886.         case "prune post":

    887. 

  887.             if ($log->cmid) {

    888. 

  888.                 //Get the new_id of the post (to recode the url and info field)

    889. 

  889.                 $pos = backup_getid($restore->backup_unique_code,"forum_posts",$log->info);

    890. 

  890.                 if ($pos) {

    891. 

  891.                     //Get the post record from database

    892. 

  892.                     $dbpos = get_record("forum_posts","id","$pos->new_id");

    893. 

  893.                     if ($dbpos) {

    894. 

  894.                         $log->url = "discuss.php?d=".$dbpos->discussion;

    895. 

  895.                         $log->info = $pos->new_id;

    896. 

  896.                         $status = true;

    897. 

  897.                     }

    898. 

  898.                 }

    899. 

  899.             }

    900. 

  900.             break;

    901. 

  901.         case "update post":

    902. 

  902.             if ($log->cmid) {

    903. 

  903.                 //Get the new_id of the post (to recode the url and info field)

    904. 

  904.                 $pos = backup_getid($restore->backup_unique_code,"forum_posts",$log->info);

    905. 

  905.                 if ($pos) {

    906. 

  906.                     //Get the post record from database

    907. 

  907.                     $dbpos = get_record("forum_posts","id","$pos->new_id");

    908. 

  908.                     if ($dbpos) {

    909. 

  909.                         $log->url = "discuss.php?d=".$dbpos->discussion."&parent=".$pos->new_id;

    910. 

  910.                         $log->info = $pos->new_id;

    911. 

  911.                         $status = true;

    912. 

  912.                     }

    913. 

  913.                 }

    914. 

  914.             }

    915. 

  915.             break;

    916. 

  916.         case "delete post":

    917. 

  917.             if ($log->cmid) {

    918. 

  918.                 //Extract the discussion id from the url field

    919. 

  919.                 $disid = substr(strrchr($log->url,"="),1);

    920. 

  920.                 //Get the new_id of the discussion (to recode the url field)

    921. 

  921.                 $dis = backup_getid($restore->backup_unique_code,"quiz_discussions",$disid);

    922. 

  922.                 if ($dis) {

    923. 

  923.                     $log->url = "discuss.php?d=".$dis->new_id;

    924. 

  924.                     $status = true;

    925. 

  925.                 }

    926. 

  926.             }

    927. 

  927.             break;

    928. 

  928.         case "user report":

    929. 

  929.             //Extract mode from url

    930. 

  930.             $mode = substr(strrchr($log->url,"="),1);

    931. 

  931.             //Get new user id

    932. 

  932.             if ($use = backup_getid($restore->backup_unique_code, 'user', $log->info)) {

    933. 

  933.                 $log->url = 'user.php?course=' . $log->course . '&id=' . $use->new_id . '&mode=' . $mode;

    934. 

  934.                 $log->info = $use->new_id;

    935. 

  935.                 $status = true;

    936. 

  936.             }

    937. 

  937.             break;

    938. 

  938.         case "search":

    939. 

  939.             $log->url = "search.php?id=".$log->course."&search=".urlencode($log->info);

    940. 

  940.             $status = true;

    941. 

  941.             break;

    942. 

  942.         default:

    943. 

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

    944. 

  944.                 echo "action (".$log->module."-".$log->action.") unknown. Not restored<br />";                 //Debug

    945. 

  945.             }

    946. 

  946.             break;

    947. 

  947.         }

    948. 

  948. 

    949. 

  949.         if ($status) {

    950. 

  950.             $status = $log;

    951. 

  951.         }

    952. 

  952.         return $status;

    953. 

  953.     }

    954. 

  954. 

    955. 

  955.     //Return a content decoded to support interactivities linking. Every module

    956. 

  956.     //should have its own. They are called automatically from

    957. 

  957.     //forum_decode_content_links_caller() function in each module

    958. 

  958.     //in the restore process

    959. 

  959.     function forum_decode_content_links ($content,$restore) {

    960. 

  960. 

    961. 

  961.         global $CFG;

    962. 

  962. 

    963. 

  963.         $result = $content;

    964. 

  964. 

    965. 

  965.         //Link to the list of forums

    966. 

  966. 

    967. 

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

    968. 

  968.         //We look for it

    969. 

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

    970. 

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

    971. 

  971.         if ($foundset[0]) {

    972. 

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

    973. 

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

    974. 

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

    975. 

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

    976. 

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

    977. 

  977.                 //Personalize the searchstring

    978. 

  978.                 $searchstring='/\$@(FORUMINDEX)\*('.$old_id.')@\$/';

    979. 

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

    980. 

  980.                 if($rec->new_id) {

    981. 

  981.                     //Now replace it

    982. 

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

    983. 

  983.                 } else {

    984. 

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

    985. 

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

    986. 

  986.                 }

    987. 

  987.             }

    988. 

  988.         }

    989. 

  989. 

    990. 

  990.         //Link to forum view by moduleid

    991. 

  991. 

    992. 

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

    993. 

  993.         //We look for it

    994. 

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

    995. 

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

    996. 

  996.         if ($foundset[0]) {

    997. 

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

    998. 

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

    999. 

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

    1000. 

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

    1001. 

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

    1002. 

  1002.                 //Personalize the searchstring

    1003. 

  1003.                 $searchstring='/\$@(FORUMVIEWBYID)\*('.$old_id.')@\$/';

    1004. 

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

    1005. 

  1005.                 if($rec->new_id) {

    1006. 

  1006.                     //Now replace it

    1007. 

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

    1008. 

  1008.                 } else {

    1009. 

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

    1010. 

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

    1011. 

  1011.                 }

    1012. 

  1012.             }

    1013. 

  1013.         }

    1014. 

  1014. 

    1015. 

  1015.         //Link to forum view by forumid

    1016. 

  1016. 

    1017. 

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

    1018. 

  1018.         //We look for it

    1019. 

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

    1020. 

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

    1021. 

  1021.         if ($foundset[0]) {

    1022. 

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

    1023. 

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

    1024. 

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

    1025. 

  1025.                 //We get the needed variables here (forum id)

    1026. 

  1026.                 $rec = backup_getid($restore->backup_unique_code,"forum",$old_id);

    1027. 

  1027.                 //Personalize the searchstring

    1028. 

  1028.                 $searchstring='/\$@(FORUMVIEWBYF)\*('.$old_id.')@\$/';

    1029. 

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

    1030. 

  1030.                 if($rec->new_id) {

    1031. 

  1031.                     //Now replace it

    1032. 

  1032.                     $result= preg_replace($searchstring,$CFG->wwwroot.'/mod/forum/view.php?f='.$rec->new_id,$result);

    1033. 

  1033.                 } else {

    1034. 

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

    1035. 

  1035.                     $result= preg_replace($searchstring,$restore->original_wwwroot.'/mod/forum/view.php?f='.$old_id,$result);

    1036. 

  1036.                 }

    1037. 

  1037.             }

    1038. 

  1038.         }

    1039. 

  1039. 

    1040. 

  1040.         //Link to forum discussion by discussionid

    1041. 

  1041. 

    1042. 

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

    1043. 

  1043.         //We look for it

    1044. 

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

    1045. 

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

    1046. 

  1046.         if ($foundset[0]) {

    1047. 

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

    1048. 

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

    1049. 

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

    1050. 

  1050.                 //We get the needed variables here (discussion id)

    1051. 

  1051.                 $rec = backup_getid($restore->backup_unique_code,"forum_discussions",$old_id);

    1052. 

  1052.                 //Personalize the searchstring

    1053. 

  1053.                 $searchstring='/\$@(FORUMDISCUSSIONVIEW)\*('.$old_id.')@\$/';

    1054. 

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

    1055. 

  1055.                 if($rec->new_id) {

    1056. 

  1056.                     //Now replace it

    1057. 

  1057.                     $result= preg_replace($searchstring,$CFG->wwwroot.'/mod/forum/discuss.php?d='.$rec->new_id,$result);

    1058. 

  1058.                 } else {

    1059. 

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

    1060. 

  1060.                     $result= preg_replace($searchstring,$restore->original_wwwroot.'/mod/forum/discuss.php?d='.$old_id,$result);

    1061. 

  1061.                 }

    1062. 

  1062.             }

    1063. 

  1063.         }

    1064. 

  1064. 

    1065. 

  1065.         //Link to forum discussion with parent syntax

    1066. 

  1066. 

    1067. 

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

    1068. 

  1068.         //We look for it

    1069. 

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

    1070. 

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

    1071. 

  1071.         if ($foundset[0]) {

    1072. 

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

    1073. 

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

    1074. 

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

    1075. 

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

    1076. 

  1076.                 //We get the needed variables here (discussion id and post id)

    1077. 

  1077.                 $rec = backup_getid($restore->backup_unique_code,"forum_discussions",$old_id);

    1078. 

  1078.                 $rec2 = backup_getid($restore->backup_unique_code,"forum_posts",$old_id2);

    1079. 

  1079.                 //Personalize the searchstring

    1080. 

  1080.                 $searchstring='/\$@(FORUMDISCUSSIONVIEWPARENT)\*('.$old_id.')\*('.$old_id2.')@\$/';

    1081. 

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

    1082. 

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

    1083. 

  1083.                     //Now replace it

    1084. 

  1084.                     $result= preg_replace($searchstring,$CFG->wwwroot.'/mod/forum/discuss.php?d='.$rec->new_id.'&parent='.$rec2->new_id,$result);

    1085. 

  1085.                 } else {

    1086. 

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

    1087. 

  1087.                     $result= preg_replace($searchstring,$restore->original_wwwroot.'/mod/forum/discuss.php?d='.$old_id.'&parent='.$old_id2,$result);

    1088. 

  1088.             …
    1089.

Large files files are truncated, but you can click here to view the full file