162b8fcf9f9ef0a50fe8a32b2451967c2992f87f
[moodle.git] / backup / moodle2 / restore_stepslib.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * @package moodlecore
20  * @subpackage backup-moodle2
21  * @copyright 2010 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 /**
26  * Define all the restore steps that will be used by common tasks in restore
27  */
29 /**
30  * delete old directories and conditionally create backup_temp_ids table
31  */
32 class restore_create_and_clean_temp_stuff extends restore_execution_step {
34     protected function define_execution() {
35         $exists = restore_controller_dbops::create_restore_temp_tables($this->get_restoreid()); // temp tables conditionally
36         // If the table already exists, it's because restore_prechecks have been executed in the same
37         // request (without problems) and it already contains a bunch of preloaded information (users...)
38         // that we aren't going to execute again
39         if ($exists) { // Inform plan about preloaded information
40             $this->task->set_preloaded_information();
41         }
42         // Create the old-course-ctxid to new-course-ctxid mapping, we need that available since the beginning
43         $itemid = $this->task->get_old_contextid();
44         $newitemid = get_context_instance(CONTEXT_COURSE, $this->get_courseid())->id;
45         restore_dbops::set_backup_ids_record($this->get_restoreid(), 'context', $itemid, $newitemid);
46         // Create the old-system-ctxid to new-system-ctxid mapping, we need that available since the beginning
47         $itemid = $this->task->get_old_system_contextid();
48         $newitemid = get_context_instance(CONTEXT_SYSTEM)->id;
49         restore_dbops::set_backup_ids_record($this->get_restoreid(), 'context', $itemid, $newitemid);
50     }
51 }
53 /**
54  * delete the temp dir used by backup/restore (conditionally),
55  * delete old directories and drop temp ids table
56  */
57 class restore_drop_and_clean_temp_stuff extends restore_execution_step {
59     protected function define_execution() {
60         global $CFG;
61         restore_controller_dbops::drop_restore_temp_tables($this->get_restoreid()); // Drop ids temp table
62         backup_helper::delete_old_backup_dirs(time() - (4 * 60 * 60));              // Delete > 4 hours temp dirs
63         if (empty($CFG->keeptempdirectoriesonbackup)) { // Conditionally
64             backup_helper::delete_backup_dir($this->task->get_tempdir()); // Empty restore dir
65         }
66     }
67 }
69 /**
70  * Restore calculated grade items, grade categories etc
71  */
72 class restore_gradebook_structure_step extends restore_structure_step {
74     /**
75      * To conditionally decide if this step must be executed
76      * Note the "settings" conditions are evaluated in the
77      * corresponding task. Here we check for other conditions
78      * not being restore settings (files, site settings...)
79      */
80      protected function execute_condition() {
81         global $CFG, $DB;
83         // No gradebook info found, don't execute
84         $fullpath = $this->task->get_taskbasepath();
85         $fullpath = rtrim($fullpath, '/') . '/' . $this->filename;
86         if (!file_exists($fullpath)) {
87             return false;
88         }
90         // Some module present in backup file isn't available to restore
91         // in this site, don't execute
92         if ($this->task->is_missing_modules()) {
93             return false;
94         }
96         // Some activity has been excluded to be restored, don't execute
97         if ($this->task->is_excluding_activities()) {
98             return false;
99         }
101         // There should only be one grade category (the 1 associated with the course itself)
102         // If other categories already exist we're restoring into an existing course.
103         // Restoring categories into a course with an existing category structure is unlikely to go well
104         $category = new stdclass();
105         $category->courseid  = $this->get_courseid();
106         $catcount = $DB->count_records('grade_categories', (array)$category);
107         if ($catcount>1) {
108             return false;
109         }
111         // Arrived here, execute the step
112         return true;
113      }
115     protected function define_structure() {
116         $paths = array();
117         $userinfo = $this->task->get_setting_value('users');
119         $paths[] = new restore_path_element('gradebook', '/gradebook');
120         $paths[] = new restore_path_element('grade_category', '/gradebook/grade_categories/grade_category');
121         $paths[] = new restore_path_element('grade_item', '/gradebook/grade_items/grade_item');
122         if ($userinfo) {
123             $paths[] = new restore_path_element('grade_grade', '/gradebook/grade_items/grade_item/grade_grades/grade_grade');
124         }
125         $paths[] = new restore_path_element('grade_letter', '/gradebook/grade_letters/grade_letter');
127         return $paths;
128     }
130     protected function process_gradebook($data) {
131     }
133     protected function process_grade_item($data) {
134         global $DB;
136         $data = (object)$data;
138         $oldid = $data->id;
139         $data->course = $this->get_courseid();
141         $data->courseid = $this->get_courseid();
143         //manual grade items store category id in categoryid
144         if ($data->itemtype=='manual') {
145             $data->categoryid = $this->get_mappingid('grade_category', $data->categoryid);
146         } //course and category grade items store their category id in iteminstance
147         else if ($data->itemtype=='course' || $data->itemtype=='category') {
148             $data->iteminstance = $this->get_mappingid('grade_category', $data->iteminstance);
149         }
151         $data->scaleid   = $this->get_mappingid('scale', $data->scaleid);
152         $data->outcomeid = $this->get_mappingid('outcome', $data->outcomeid);
154         $data->locktime     = $this->apply_date_offset($data->locktime);
155         $data->timecreated  = $this->apply_date_offset($data->timecreated);
156         $data->timemodified = $this->apply_date_offset($data->timemodified);
158         $coursecategory = $newitemid = null;
159         //course grade item should already exist so updating instead of inserting
160         if($data->itemtype=='course') {
162             //get the ID of the already created grade item
163             $gi = new stdclass();
164             $gi->courseid  = $this->get_courseid();
166             $gi->itemtype  = $data->itemtype;
167             if ($data->itemtype=='course') {
168                 //need to get the id of the grade_category that was automatically created for the course
169                 $category = new stdclass();
170                 $category->courseid  = $this->get_courseid();
171                 $category->parent  = null;
172                 //course category fullname starts out as ? but may be edited
173                 //$category->fullname  = '?';
175                 $coursecategory = $DB->get_record('grade_categories', (array)$category);
176                 $gi->iteminstance = $coursecategory->id;
177             }
179             $existinggradeitem = $DB->get_record('grade_items', (array)$gi);
180             if (!empty($existinggradeitem)) {
181                 $data->id = $newitemid = $existinggradeitem->id;
182                 $DB->update_record('grade_items', $data);
183             }
184         }
186         if (empty($newitemid)) {
187             //in case we found the course category but still need to insert the course grade item
188             if ($data->itemtype=='course' && !empty($coursecategory)) {
189                 $data->iteminstance = $coursecategory->id;
190             }
191             
192             $newitemid = $DB->insert_record('grade_items', $data);
193         }
194         $this->set_mapping('grade_item', $oldid, $newitemid);
195     }
197     protected function process_grade_grade($data) {
198         global $DB;
200         $data = (object)$data;
201         $oldid = $data->id;
203         $data->itemid = $this->get_new_parentid('grade_item');
205         $data->userid = $this->get_mappingid('user', $data->userid);
206         $data->usermodified = $this->get_mappingid('user', $data->usermodified);
207         $data->locktime     = $this->apply_date_offset($data->locktime);
208         // TODO: Ask, all the rest of locktime/exported... work with time... to be rolled?
209         $data->overridden = $this->apply_date_offset($data->overridden);
210         $data->timecreated  = $this->apply_date_offset($data->timecreated);
211         $data->timemodified = $this->apply_date_offset($data->timemodified);
213         $newitemid = $DB->insert_record('grade_grades', $data);
214         $this->set_mapping('grade_grade', $oldid, $newitemid);
215     }
216     protected function process_grade_category($data) {
217         global $DB;
219         $data = (object)$data;
220         $oldid = $data->id;
222         $data->course = $this->get_courseid();
223         $data->courseid = $data->course;
225         $data->timecreated  = $this->apply_date_offset($data->timecreated);
226         $data->timemodified = $this->apply_date_offset($data->timemodified);
228         $newitemid = null;
229         //no parent means a course level grade category. That may have been created when the course was created
230         if(empty($data->parent)) {
231             //parent was being saved as 0 when it should be null
232             $data->parent = null;
234             //get the already created course level grade category
235             $category = new stdclass();
236             $category->courseid = $this->get_courseid();
238             $coursecategory = $DB->get_record('grade_categories', (array)$category);
239             if (!empty($coursecategory)) {
240                 $data->id = $newitemid = $coursecategory->id;
241                 $DB->update_record('grade_categories', $data);
242             }
243         }
245         //need to insert a course category
246         if (empty($newitemid)) {
247             $newitemid = $DB->insert_record('grade_categories', $data);
248         }
249         $this->set_mapping('grade_category', $oldid, $newitemid);
250     }
251     protected function process_grade_letter($data) {
252         global $DB;
254         $data = (object)$data;
255         $oldid = $data->id;
257         $data->contextid = $this->get_mappingid('context', $data->contextid);
258         //$data->contextid = $this->task->get_contextid();
260         $newitemid = $DB->insert_record('grade_letters', $data);
261         $this->set_mapping('grade_letter', $oldid, $newitemid);
262     }
264     //put all activity grade items in the correct grade category and mark all for recalculation
265     protected function after_execute() {
266         global $DB;
268         $conditions = array(
269             'backupid' => $this->get_restoreid(),
270             'itemname' => 'grade_item'//,
271             //'itemid'   => $itemid
272         );
273         $rs = $DB->get_recordset('backup_ids_temp', $conditions);
275         if (!empty($rs)) {
276             foreach($rs as $grade_item_backup) {
277                 $updateobj = new stdclass();
278                 $updateobj->id = $grade_item_backup->newitemid;
280                 //if this is an activity grade item that needs to be put back in its correct category
281                 if (!empty($grade_item_backup->parentitemid)) {
282                     $updateobj->categoryid = $this->get_mappingid('grade_category', $grade_item_backup->parentitemid);
283                 } else {
284                     //mark course and category items as needing to be recalculated
285                     $updateobj->needsupdate=1;
286                 }
287                 $DB->update_record('grade_items', $updateobj);
288             }
289         }
290         $rs->close();
292         //need to correct the grade category path and parent
293         $conditions = array(
294             'courseid' => $this->get_courseid()
295         );
296         $grade_category = new stdclass();
297         
298         $rs = $DB->get_recordset('grade_categories', $conditions);
299         if (!empty($rs)) {
300             //get all the parents correct first as grade_category::build_path() loads category parents from the DB
301             foreach($rs as $gc) {
302                 if (!empty($gc->parent)) {
303                     $grade_category->id = $gc->id;
304                     $grade_category->parent = $this->get_mappingid('grade_category', $gc->parent);
305                     $DB->update_record('grade_categories', $grade_category);
306                 }
307             }
308         }
309         if (isset($grade_category->parent)) {
310             unset($grade_category->parent);
311         }
312         $rs->close();
314         $rs = $DB->get_recordset('grade_categories', $conditions);
315         if (!empty($rs)) {
316             //now we can rebuild all the paths
317             foreach($rs as $gc) {
318                 $grade_category->id = $gc->id;
319                 $grade_category->path = grade_category::build_path($gc);
320                 $DB->update_record('grade_categories', $grade_category);
321             }
322         }
323         $rs->close();
324     }
327 /**
328  * decode all the interlinks present in restored content
329  * relying 100% in the restore_decode_processor that handles
330  * both the contents to modify and the rules to be applied
331  */
332 class restore_decode_interlinks extends restore_execution_step {
334     protected function define_execution() {
335         // Just that
336         $this->task->get_decoder()->execute();
337     }
340 /**
341  * rebuid the course cache
342  */
343 class restore_rebuild_course_cache extends restore_execution_step {
345     protected function define_execution() {
346         // Just that
347         rebuild_course_cache($this->get_courseid());
348     }
352 /**
353  * Review all the (pending) block positions in backup_ids, matching by
354  * contextid, creating positions as needed. This is executed by the
355  * final task, once all the contexts have been created
356  */
357 class restore_review_pending_block_positions extends restore_execution_step {
359     protected function define_execution() {
360         global $DB;
362         // Get all the block_position objects pending to match
363         $params = array('backupid' => $this->get_restoreid(), 'itemname' => 'block_position');
364         $rs = $DB->get_recordset('backup_ids_temp', $params, '', 'itemid');
365         // Process block positions, creating them or accumulating for final step
366         foreach($rs as $posrec) {
367             // Get the complete position object (stored as info)
368             $position = restore_dbops::get_backup_ids_record($this->get_restoreid(), 'block_position', $posrec->itemid)->info;
369             // If position is for one already mapped (known) contextid
370             // process it now, creating the position, else nothing to
371             // do, position finally discarded
372             if ($newctx = restore_dbops::get_backup_ids_record($this->get_restoreid(), 'context', $position->contextid)) {
373                 $position->contextid = $newctx->newitemid;
374                 // Create the block position
375                 $DB->insert_record('block_positions', $position);
376             }
377         }
378         $rs->close();
379     }
382 /**
383  * Process all the saved module availability records in backup_ids, matching
384  * course modules and grade item id once all them have been already restored.
385  * only if all matchings are satisfied the availability condition will be created.
386  * At the same time, it is required for the site to have that functionality enabled.
387  */
388 class restore_process_course_modules_availability extends restore_execution_step {
390     protected function define_execution() {
391         global $CFG, $DB;
393         // Site hasn't availability enabled
394         if (empty($CFG->enableavailability)) {
395             return;
396         }
398         // Get all the module_availability objects to process
399         $params = array('backupid' => $this->get_restoreid(), 'itemname' => 'module_availability');
400         $rs = $DB->get_recordset('backup_ids_temp', $params, '', 'itemid');
401         // Process availabilities, creating them if everything matches ok
402         foreach($rs as $availrec) {
403             $allmatchesok = true;
404             // Get the complete availabilityobject
405             $availability = restore_dbops::get_backup_ids_record($this->get_restoreid(), 'module_availability', $availrec->itemid)->info;
406             // Map the sourcecmid if needed and possible
407             if (!empty($availability->sourcecmid)) {
408                 $newcm = restore_dbops::get_backup_ids_record($this->get_restoreid(), 'course_module', $availability->sourcecmid);
409                 if ($newcm) {
410                     $availability->sourcecmid = $newcm->newitemid;
411                 } else {
412                     $allmatchesok = false; // Failed matching, we won't create this availability rule
413                 }
414             }
415             // Map the gradeitemid if needed and possible
416             if (!empty($availability->gradeitemid)) {
417                 $newgi = restore_dbops::get_backup_ids_record($this->get_restoreid(), 'grade_item', $availability->gradeitemid);
418                 if ($newgi) {
419                     $availability->gradeitemid = $newgi->newitemid;
420                 } else {
421                     $allmatchesok = false; // Failed matching, we won't create this availability rule
422                 }
423             }
424             if ($allmatchesok) { // Everything ok, create the availability rule
425                 $DB->insert_record('course_modules_availability', $availability);
426             }
427         }
428         $rs->close();
429     }
433 /*
434  * Execution step that, *conditionally* (if there isn't preloaded information)
435  * will load the inforef files for all the included course/section/activity tasks
436  * to backup_temp_ids. They will be stored with "xxxxref" as itemname
437  */
438 class restore_load_included_inforef_records extends restore_execution_step {
440     protected function define_execution() {
442         if ($this->task->get_preloaded_information()) { // if info is already preloaded, nothing to do
443             return;
444         }
446         // Get all the included inforef files
447         $files = restore_dbops::get_needed_inforef_files($this->get_restoreid());
448         foreach ($files as $file) {
449             restore_dbops::load_inforef_to_tempids($this->get_restoreid(), $file); // Load each inforef file to temp_ids
450         }
451     }
454 /*
455  * Execution step that will load all the needed files into backup_files_temp
456  *   - info: contains the whole original object (times, names...)
457  * (all them being original ids as loaded from xml)
458  */
459 class restore_load_included_files extends restore_structure_step {
461     protected function define_structure() {
463         $file = new restore_path_element('file', '/files/file');
465         return array($file);
466     }
468     // Processing functions go here
469     public function process_file($data) {
471         $data = (object)$data; // handy
473         // load it if needed:
474         //   - it it is one of the annotated inforef files (course/section/activity/block)
475         //   - it is one "user", "group", "grouping" or "grade" component file (that aren't sent to inforef ever)
476         $isfileref   = restore_dbops::get_backup_ids_record($this->get_restoreid(), 'fileref', $data->id);
477         $iscomponent = ($data->component == 'user' || $data->component == 'group' ||
478                         $data->component == 'grouping' || $data->component == 'grade');
479         if ($isfileref || $iscomponent) {
480             restore_dbops::set_backup_files_record($this->get_restoreid(), $data);
481         }
482     }
485 /**
486  * Execution step that, *conditionally* (if there isn't preloaded information),
487  * will load all the needed roles to backup_temp_ids. They will be stored with
488  * "role" itemname. Also it will perform one automatic mapping to roles existing
489  * in the target site, based in permissions of the user performing the restore,
490  * archetypes and other bits. At the end, each original role will have its associated
491  * target role or 0 if it's going to be skipped. Note we wrap everything over one
492  * restore_dbops method, as far as the same stuff is going to be also executed
493  * by restore prechecks
494  */
495 class restore_load_and_map_roles extends restore_execution_step {
497     protected function define_execution() {
498         if ($this->task->get_preloaded_information()) { // if info is already preloaded
499             return;
500         }
502         $file = $this->get_basepath() . '/roles.xml';
503         // Load needed toles to temp_ids
504         restore_dbops::load_roles_to_tempids($this->get_restoreid(), $file);
506         // Process roles, mapping/skipping. Any error throws exception
507         // Note we pass controller's info because it can contain role mapping information
508         // about manual mappings performed by UI
509         restore_dbops::process_included_roles($this->get_restoreid(), $this->task->get_courseid(), $this->task->get_userid(), $this->task->is_samesite(), $this->task->get_info()->role_mappings);
510     }
513 /**
514  * Execution step that, *conditionally* (if there isn't preloaded information
515  * and users have been selected in settings, will load all the needed users
516  * to backup_temp_ids. They will be stored with "user" itemname and with
517  * their original contextid as paremitemid
518  */
519 class restore_load_included_users extends restore_execution_step {
521     protected function define_execution() {
523         if ($this->task->get_preloaded_information()) { // if info is already preloaded, nothing to do
524             return;
525         }
526         if (!$this->task->get_setting_value('users')) { // No userinfo being restored, nothing to do
527             return;
528         }
529         $file = $this->get_basepath() . '/users.xml';
530         restore_dbops::load_users_to_tempids($this->get_restoreid(), $file); // Load needed users to temp_ids
531     }
534 /**
535  * Execution step that, *conditionally* (if there isn't preloaded information
536  * and users have been selected in settings, will process all the needed users
537  * in order to decide and perform any action with them (create / map / error)
538  * Note: Any error will cause exception, as far as this is the same processing
539  * than the one into restore prechecks (that should have stopped process earlier)
540  */
541 class restore_process_included_users extends restore_execution_step {
543     protected function define_execution() {
545         if ($this->task->get_preloaded_information()) { // if info is already preloaded, nothing to do
546             return;
547         }
548         if (!$this->task->get_setting_value('users')) { // No userinfo being restored, nothing to do
549             return;
550         }
551         restore_dbops::process_included_users($this->get_restoreid(), $this->task->get_courseid(), $this->task->get_userid(), $this->task->is_samesite());
552     }
555 /**
556  * Execution step that will create all the needed users as calculated
557  * by @restore_process_included_users (those having newiteind = 0)
558  */
559 class restore_create_included_users extends restore_execution_step {
561     protected function define_execution() {
563         restore_dbops::create_included_users($this->get_basepath(), $this->get_restoreid(), $this->get_setting_value('user_files'), $this->task->get_userid());
564     }
567 /**
568  * Structure step that will create all the needed groups and groupings
569  * by loading them from the groups.xml file performing the required matches.
570  * Note group members only will be added if restoring user info
571  */
572 class restore_groups_structure_step extends restore_structure_step {
574     protected function define_structure() {
576         $paths = array(); // Add paths here
578         $paths[] = new restore_path_element('group', '/groups/group');
579         if ($this->get_setting_value('users')) {
580             $paths[] = new restore_path_element('member', '/groups/group/group_members/group_member');
581         }
582         $paths[] = new restore_path_element('grouping', '/groups/groupings/grouping');
583         $paths[] = new restore_path_element('grouping_group', '/groups/groupings/grouping/grouping_groups/grouping_group');
585         return $paths;
586     }
588     // Processing functions go here
589     public function process_group($data) {
590         global $DB;
592         $data = (object)$data; // handy
593         $data->courseid = $this->get_courseid();
595         $oldid = $data->id;    // need this saved for later
597         $restorefiles = false; // Only if we end creating the group
599         // Search if the group already exists (by name & description) in the target course
600         $description_clause = '';
601         $params = array('courseid' => $this->get_courseid(), 'grname' => $data->name);
602         if (!empty($data->description)) {
603             $description_clause = ' AND ' .
604                                   $DB->sql_compare_text('description') . ' = ' . $DB->sql_compare_text(':desc');
605            $params['desc'] = $data->description;
606         }
607         if (!$groupdb = $DB->get_record_sql("SELECT *
608                                                FROM {groups}
609                                               WHERE courseid = :courseid
610                                                 AND name = :grname $description_clause", $params)) {
611             // group doesn't exist, create
612             $newitemid = $DB->insert_record('groups', $data);
613             $restorefiles = true; // We'll restore the files
614         } else {
615             // group exists, use it
616             $newitemid = $groupdb->id;
617         }
618         // Save the id mapping
619         $this->set_mapping('group', $oldid, $newitemid, $restorefiles);
620     }
622     public function process_member($data) {
623         global $DB;
625         $data = (object)$data; // handy
627         // get parent group->id
628         $data->groupid = $this->get_new_parentid('group');
630         // map user newitemid and insert if not member already
631         if ($data->userid = $this->get_mappingid('user', $data->userid)) {
632             if (!$DB->record_exists('groups_members', array('groupid' => $data->groupid, 'userid' => $data->userid))) {
633                 $DB->insert_record('groups_members', $data);
634             }
635         }
636     }
638     public function process_grouping($data) {
639         global $DB;
641         $data = (object)$data; // handy
642         $data->courseid = $this->get_courseid();
644         $oldid = $data->id;    // need this saved for later
645         $restorefiles = false; // Only if we end creating the grouping
647         // Search if the grouping already exists (by name & description) in the target course
648         $description_clause = '';
649         $params = array('courseid' => $this->get_courseid(), 'grname' => $data->name);
650         if (!empty($data->description)) {
651             $description_clause = ' AND ' .
652                                   $DB->sql_compare_text('description') . ' = ' . $DB->sql_compare_text(':desc');
653            $params['desc'] = $data->description;
654         }
655         if (!$groupingdb = $DB->get_record_sql("SELECT *
656                                                   FROM {groupings}
657                                                  WHERE courseid = :courseid
658                                                    AND name = :grname $description_clause", $params)) {
659             // grouping doesn't exist, create
660             $newitemid = $DB->insert_record('groupings', $data);
661             $restorefiles = true; // We'll restore the files
662         } else {
663             // grouping exists, use it
664             $newitemid = $groupingdb->id;
665         }
666         // Save the id mapping
667         $this->set_mapping('grouping', $oldid, $newitemid, $restorefiles);
668     }
670     public function process_grouping_group($data) {
671         global $DB;
673         $data = (object)$data;
675         $data->groupingid = $this->get_new_parentid('grouping'); // Use new parentid
676         $data->groupid    = $this->get_mappingid('group', $data->groupid); // Get from mappings
677         $DB->insert_record('groupings_groups', $data);  // No need to set this mapping (no child info nor files)
678     }
680     protected function after_execute() {
681         // Add group related files, matching with "group" mappings
682         $this->add_related_files('group', 'icon', 'group');
683         $this->add_related_files('group', 'description', 'group');
684         // Add grouping related files, matching with "grouping" mappings
685         $this->add_related_files('grouping', 'description', 'grouping');
686     }
690 /**
691  * Structure step that will create all the needed scales
692  * by loading them from the scales.xml
693  */
694 class restore_scales_structure_step extends restore_structure_step {
696     protected function define_structure() {
698         $paths = array(); // Add paths here
699         $paths[] = new restore_path_element('scale', '/scales_definition/scale');
700         return $paths;
701     }
703     protected function process_scale($data) {
704         global $DB;
706         $data = (object)$data;
708         $restorefiles = false; // Only if we end creating the group
710         $oldid = $data->id;    // need this saved for later
712         // Look for scale (by 'scale' both in standard (course=0) and current course
713         // with priority to standard scales (ORDER clause)
714         // scale is not course unique, use get_record_sql to suppress warning
715         // Going to compare LOB columns so, use the cross-db sql_compare_text() in both sides
716         $compare_scale_clause = $DB->sql_compare_text('scale')  . ' = ' . $DB->sql_compare_text(':scaledesc');
717         $params = array('courseid' => $this->get_courseid(), 'scaledesc' => $data->scale);
718         if (!$scadb = $DB->get_record_sql("SELECT *
719                                             FROM {scale}
720                                            WHERE courseid IN (0, :courseid)
721                                              AND $compare_scale_clause
722                                         ORDER BY courseid", $params, IGNORE_MULTIPLE)) {
723             // Remap the user if possible, defaut to user performing the restore if not
724             $userid = $this->get_mappingid('user', $data->userid);
725             $data->userid = $userid ? $userid : $this->task->get_userid();
726             // Remap the course if course scale
727             $data->courseid = $data->courseid ? $this->get_courseid() : 0;
728             // If global scale (course=0), check the user has perms to create it
729             // falling to course scale if not
730             $systemctx = get_context_instance(CONTEXT_SYSTEM);
731             if ($data->courseid == 0 && !has_capability('moodle/course:managescales', $systemctx , $this->task->get_userid())) {
732                 $data->courseid = $this->get_courseid();
733             }
734             // scale doesn't exist, create
735             $newitemid = $DB->insert_record('scale', $data);
736             $restorefiles = true; // We'll restore the files
737         } else {
738             // scale exists, use it
739             $newitemid = $scadb->id;
740         }
741         // Save the id mapping (with files support at system context)
742         $this->set_mapping('scale', $oldid, $newitemid, $restorefiles, $this->task->get_old_system_contextid());
743     }
745     protected function after_execute() {
746         // Add scales related files, matching with "scale" mappings
747         $this->add_related_files('grade', 'scale', 'scale', $this->task->get_old_system_contextid());
748     }
752 /**
753  * Structure step that will create all the needed outocomes
754  * by loading them from the outcomes.xml
755  */
756 class restore_outcomes_structure_step extends restore_structure_step {
758     protected function define_structure() {
760         $paths = array(); // Add paths here
761         $paths[] = new restore_path_element('outcome', '/outcomes_definition/outcome');
762         return $paths;
763     }
765     protected function process_outcome($data) {
766         global $DB;
768         $data = (object)$data;
770         $restorefiles = false; // Only if we end creating the group
772         $oldid = $data->id;    // need this saved for later
774         // Look for outcome (by shortname both in standard (courseid=null) and current course
775         // with priority to standard outcomes (ORDER clause)
776         // outcome is not course unique, use get_record_sql to suppress warning
777         $params = array('courseid' => $this->get_courseid(), 'shortname' => $data->shortname);
778         if (!$outdb = $DB->get_record_sql('SELECT *
779                                              FROM {grade_outcomes}
780                                             WHERE shortname = :shortname
781                                               AND (courseid = :courseid OR courseid IS NULL)
782                                          ORDER BY COALESCE(courseid, 0)', $params, IGNORE_MULTIPLE)) {
783             // Remap the user
784             $userid = $this->get_mappingid('user', $data->usermodified);
785             $data->usermodified = $userid ? $userid : $this->task->get_userid();
786             // Remap the scale
787             $data->scaleid = $this->get_mappingid('scale', $data->scaleid);
788             // Remap the course if course outcome
789             $data->courseid = $data->courseid ? $this->get_courseid() : null;
790             // If global outcome (course=null), check the user has perms to create it
791             // falling to course outcome if not
792             $systemctx = get_context_instance(CONTEXT_SYSTEM);
793             if (is_null($data->courseid) && !has_capability('moodle/grade:manageoutcomes', $systemctx , $this->task->get_userid())) {
794                 $data->courseid = $this->get_courseid();
795             }
796             // outcome doesn't exist, create
797             $newitemid = $DB->insert_record('grade_outcomes', $data);
798             $restorefiles = true; // We'll restore the files
799         } else {
800             // scale exists, use it
801             $newitemid = $outdb->id;
802         }
803         // Set the corresponding grade_outcomes_courses record
804         $outcourserec = new stdclass();
805         $outcourserec->courseid  = $this->get_courseid();
806         $outcourserec->outcomeid = $newitemid;
807         if (!$DB->record_exists('grade_outcomes_courses', (array)$outcourserec)) {
808             $DB->insert_record('grade_outcomes_courses', $outcourserec);
809         }
810         // Save the id mapping (with files support at system context)
811         $this->set_mapping('outcome', $oldid, $newitemid, $restorefiles, $this->task->get_old_system_contextid());
812     }
814     protected function after_execute() {
815         // Add outcomes related files, matching with "outcome" mappings
816         $this->add_related_files('grade', 'outcome', 'outcome', $this->task->get_old_system_contextid());
817     }
820 /**
821  * Structure step that will read the section.xml creating/updating sections
822  * as needed, rebuilding course cache and other friends
823  */
824 class restore_section_structure_step extends restore_structure_step {
826     protected function define_structure() {
827         return array(new restore_path_element('section', '/section'));
828     }
830     public function process_section($data) {
831         global $DB;
832         $data = (object)$data;
833         $oldid = $data->id; // We'll need this later
835         $restorefiles = false;
837         // Look for the section
838         $section = new stdclass();
839         $section->course  = $this->get_courseid();
840         $section->section = $data->number;
841         // Section doesn't exist, create it with all the info from backup
842         if (!$secrec = $DB->get_record('course_sections', (array)$section)) {
843             $section->name = $data->name;
844             $section->summary = $data->summary;
845             $section->summaryformat = $data->summaryformat;
846             $section->sequence = '';
847             $section->visible = $data->visible;
848             $newitemid = $DB->insert_record('course_sections', $section);
849             $restorefiles = true;
851         // Section exists, update non-empty information
852         } else {
853             $section->id = $secrec->id;
854             if (empty($secrec->name)) {
855                 $section->name = $data->name;
856             }
857             if (empty($secrec->summary)) {
858                 $section->summary = $data->summary;
859                 $section->summaryformat = $data->summaryformat;
860                 $restorefiles = true;
861             }
862             $DB->update_record('course_sections', $section);
863             $newitemid = $secrec->id;
864         }
866         // Annotate the section mapping, with restorefiles option if needed
867         $this->set_mapping('course_section', $oldid, $newitemid, $restorefiles);
869         // If needed, adjust course->numsections
870         if ($numsections = $DB->get_field('course', 'numsections', array('id' => $this->get_courseid()))) {
871             if ($numsections < $section->section) {
872                 $DB->set_field('course', 'numsections', $section->section, array('id' => $this->get_courseid()));
873             }
874         }
875     }
877     protected function after_execute() {
878         // Add section related files, with 'course_section' itemid to match
879         $this->add_related_files('course', 'section', 'course_section');
880     }
884 /**
885  * Structure step that will read the course.xml file, loading it and performing
886  * various actions depending of the site/restore settings. Note that target
887  * course always exist before arriving here so this step will be updating
888  * the course record (never inserting)
889  */
890 class restore_course_structure_step extends restore_structure_step {
892     protected function define_structure() {
894         $course = new restore_path_element('course', '/course', true); // Grouped
895         $category = new restore_path_element('category', '/course/category');
896         $tag = new restore_path_element('tag', '/course/tags/tag');
897         $allowed = new restore_path_element('allowed', '/course/allowed_modules/module');
899         return array($course, $category, $tag, $allowed);
900     }
902     /**
903      * Processing functions go here
904      *
905      * @global moodledatabase $DB
906      * @param stdClass $data
907      */
908     public function process_course($data) {
909         global $CFG, $DB;
911         $data = (object)$data;
912         $coursetags = isset($data->tags['tag']) ? $data->tags['tag'] : array();
913         $coursemodules = isset($data->allowed_modules['module']) ? $data->allowed_modules['module'] : array();
914         $oldid = $data->id; // We'll need this later
916         $fullname  = $this->get_setting_value('course_fullname');
917         $shortname = $this->get_setting_value('course_shortname');
918         $startdate = $this->get_setting_value('course_startdate');
920         // Calculate final course names, to avoid dupes
921         list($fullname, $shortname) = restore_dbops::calculate_course_names($this->get_courseid(), $fullname, $shortname);
923         // Need to change some fields before updating the course record
924         $data->id = $this->get_courseid();
925         $data->fullname = $fullname;
926         $data->shortname= $shortname;
927         $data->idnumber = '';
929         // Category is set by UI when choosing the destination
930         unset($data->category);
932         $data->startdate= $this->apply_date_offset($data->startdate);
933         if ($data->defaultgroupingid) {
934             $data->defaultgroupingid = $this->get_mappingid('grouping', $data->defaultgroupingid);
935         }
936         if (empty($CFG->enablecompletion)) {
937             $data->enablecompletion = 0;
938             $data->completionstartonenrol = 0;
939             $data->completionnotify = 0;
940         }
941         $languages = get_string_manager()->get_list_of_translations(); // Get languages for quick search
942         if (!array_key_exists($data->lang, $languages)) {
943             $data->lang = '';
944         }
945         $themes = get_list_of_themes(); // Get themes for quick search later
946         if (!in_array($data->theme, $themes) || empty($CFG->allowcoursethemes)) {
947             $data->theme = '';
948         }
950         // Course record ready, update it
951         $DB->update_record('course', $data);
953         // Set course mapping
954         $this->set_mapping('course', $oldid, $data->id);
956         // Course tags
957         if (!empty($CFG->usetags) && isset($coursetags)) { // if enabled in server and present in backup
958             $tags = array();
959             foreach ($coursetags as $coursetag) {
960                 $coursetag = (object)$coursetag;
961                 $tags[] = $coursetag->rawname;
962             }
963             tag_set('course', $this->get_courseid(), $tags);
964         }
965         // Course allowed modules
966         if (!empty($data->restrictmodules) && !empty($coursemodules)) {
967             $available = get_plugin_list('mod');
968             foreach ($coursemodules as $coursemodule) {
969                 $mname = $coursemodule['modulename'];
970                 if (array_key_exists($mname, $available)) {
971                     if ($module = $DB->get_record('modules', array('name' => $mname, 'visible' => 1))) {
972                         $rec = new stdclass();
973                         $rec->course = $this->get_courseid();
974                         $rec->module = $module->id;
975                         if (!$DB->record_exists('course_allowed_modules', (array)$rec)) {
976                             $DB->insert_record('course_allowed_modules', $rec);
977                         }
978                     }
979                 }
980             }
981         }
982         // Role name aliases
983         restore_dbops::set_course_role_names($this->get_restoreid(), $this->get_courseid());
984     }
986     protected function after_execute() {
987         // Add course related files, without itemid to match
988         $this->add_related_files('course', 'summary', null);
989         $this->add_related_files('course', 'legacy', null);
990     }
994 /*
995  * Structure step that will read the roles.xml file (at course/activity/block levels)
996  * containig all the role_assignments and overrides for that context. If corresponding to
997  * one mapped role, they will be applied to target context. Will observe the role_assignments
998  * setting to decide if ras are restored.
999  * Note: only ras with component == null are restored as far as the any ra with component
1000  * is handled by one enrolment plugin, hence it will createt the ras later
1001  */
1002 class restore_ras_and_caps_structure_step extends restore_structure_step {
1004     protected function define_structure() {
1006         $paths = array();
1008         // Observe the role_assignments setting
1009         if ($this->get_setting_value('role_assignments')) {
1010             $paths[] = new restore_path_element('assignment', '/roles/role_assignments/assignment');
1011         }
1012         $paths[] = new restore_path_element('override', '/roles/role_overrides/override');
1014         return $paths;
1015     }
1017     public function process_assignment($data) {
1018         global $DB;
1020         $data = (object)$data;
1022         // Check roleid, userid are one of the mapped ones
1023         $newroleid = $this->get_mappingid('role', $data->roleid);
1024         $newuserid = $this->get_mappingid('user', $data->userid);
1025         // If newroleid and newuserid and component is empty and context valid assign via API (handles dupes and friends)
1026         if ($newroleid && $newuserid && empty($data->component) && $this->task->get_contextid()) {
1027             // Only assign roles to not deleted users
1028             if ($DB->record_exists('user', array('id' => $newuserid, 'deleted' => 0))) {
1029                 // TODO: role_assign() needs one userid param to be able to specify our restore userid
1030                 role_assign($newroleid, $newuserid, $this->task->get_contextid());
1031             }
1032         }
1033     }
1035     public function process_override($data) {
1036         $data = (object)$data;
1038         // Check roleid is one of the mapped ones
1039         $newroleid = $this->get_mappingid('role', $data->roleid);
1040         // If newroleid and context are valid assign it via API (it handles dupes and so on)
1041         if ($newroleid && $this->task->get_contextid()) {
1042             // TODO: assign_capability() needs one userid param to be able to specify our restore userid
1043             // TODO: it seems that assign_capability() doesn't check for valid capabilities at all ???
1044             assign_capability($data->capability, $data->permission, $newroleid, $this->task->get_contextid());
1045         }
1046     }
1049 /**
1050  * This structure steps restores the enrol plugins and their underlying
1051  * enrolments, performing all the mappings and/or movements required
1052  */
1053 class restore_enrolments_structure_step extends restore_structure_step {
1055     protected function define_structure() {
1057         $paths = array();
1059         $paths[] = new restore_path_element('enrol', '/enrolments/enrols/enrol');
1060         $paths[] = new restore_path_element('enrolment', '/enrolments/enrols/enrol/user_enrolments/enrolment');
1062         return $paths;
1063     }
1065     public function process_enrol($data) {
1066         global $DB;
1068         $data = (object)$data;
1069         $oldid = $data->id; // We'll need this later
1071         // TODO: Just one quick process of manual enrol_plugin. Add the rest (complex ones) and fix this
1072         if ($data->enrol !== 'manual') {
1073             debugging("Skipping '{$data->enrol}' enrolment plugin. Must be implemented", DEBUG_DEVELOPER);
1074             return;
1075         }
1077         // Perform various checks to decide what to do with the enrol plugin
1078         $installed = array_key_exists($data->enrol, enrol_get_plugins(false));
1079         $enabled   = enrol_is_enabled($data->enrol);
1080         $exists    = 0;
1081         $roleid    = $this->get_mappingid('role', $data->roleid);
1082         if ($rec = $DB->get_record('enrol', array('courseid' => $this->get_courseid(), 'enrol' => $data->enrol))) {
1083             $exists = $rec->id;
1084         }
1085         // If installed and enabled, continue processing
1086         if ($installed && $enabled) {
1087             // If not exists in course and we have a target role mapping
1088             if (!$exists && $roleid) {
1089                 $data->roleid = $roleid;
1090                 $enrol = enrol_get_plugin($data->enrol);
1091                 $courserec = $DB->get_record('course', array('id' => $this->get_courseid())); // Requires object, uses only id!!
1092                 $newitemid = $enrol->add_instance($courserec, array($data));
1094             // Already exists, user it for enrolments
1095             } else {
1096                 $newitemid = $exists;
1097             }
1099         // Not installed and enabled, map to 0
1100         } else {
1101             $newitemid = 0;
1102         }
1103         // Perform the simple mapping and done
1104         $this->set_mapping('enrol', $oldid, $newitemid);
1105     }
1107     public function process_enrolment($data) {
1108         global $DB;
1110         $data = (object)$data;
1112         // Process only if parent instance have been mapped
1113         if ($enrolid = $this->get_new_parentid('enrol')) {
1114             // And only if user is a mapped one
1115             if ($userid = $this->get_mappingid('user', $data->userid)) {
1116                 // TODO: Surely need to use API (enrol_user) here, instead of the current low-level impl
1117                 // TODO: Note enrol_user() sticks to $USER->id (need to add userid param)
1118                 $enrolment = new stdclass();
1119                 $enrolment->enrolid = $enrolid;
1120                 $enrolment->userid  = $userid;
1121                 if (!$DB->record_exists('user_enrolments', (array)$enrolment)) {
1122                     $enrolment->status = $data->status;
1123                     $enrolment->timestart = $data->timestart;
1124                     $enrolment->timeend = $data->timeend;
1125                     $enrolment->modifierid = $this->task->get_userid();
1126                     $enrolment->timecreated = time();
1127                     $enrolment->timemodified = 0;
1128                     $DB->insert_record('user_enrolments', $enrolment);
1129                 }
1130             }
1131         }
1132     }
1136 /**
1137  * This structure steps restores the filters and their configs
1138  */
1139 class restore_filters_structure_step extends restore_structure_step {
1141     protected function define_structure() {
1143         $paths = array();
1145         $paths[] = new restore_path_element('active', '/filters/filter_actives/filter_active');
1146         $paths[] = new restore_path_element('config', '/filters/filter_configs/filter_config');
1148         return $paths;
1149     }
1151     public function process_active($data) {
1153         $data = (object)$data;
1155         if (!filter_is_enabled($data->filter)) { // Not installed or not enabled, nothing to do
1156             return;
1157         }
1158         filter_set_local_state($data->filter, $this->task->get_contextid(), $data->active);
1159     }
1161     public function process_config($data) {
1163         $data = (object)$data;
1165         if (!filter_is_enabled($data->filter)) { // Not installed or not enabled, nothing to do
1166             return;
1167         }
1168         filter_set_local_config($data->filter, $this->task->get_contextid(), $data->name, $data->value);
1169     }
1173 /**
1174  * This structure steps restores the comments
1175  * Note: Cannot use the comments API because defaults to USER->id.
1176  * That should change allowing to pass $userid
1177  */
1178 class restore_comments_structure_step extends restore_structure_step {
1180     protected function define_structure() {
1182         $paths = array();
1184         $paths[] = new restore_path_element('comment', '/comments/comment');
1186         return $paths;
1187     }
1189     public function process_comment($data) {
1190         global $DB;
1192         $data = (object)$data;
1194         // First of all, if the comment has some itemid, ask to the task what to map
1195         $mapping = false;
1196         if ($data->itemid) {
1197             $mapping = $this->task->get_comment_mapping_itemname($data->commentarea);
1198             $data->itemid = $this->get_mappingid($mapping, $data->itemid);
1199         }
1200         // Only restore the comment if has no mapping OR we have found the matching mapping
1201         if (!$mapping || $data->itemid) {
1202             // Only if user mapping and context
1203             $data->userid = $this->get_mappingid('user', $data->userid);
1204             if ($data->userid && $this->task->get_contextid()) {
1205                 $data->contextid = $this->task->get_contextid();
1206                 // Only if there is another comment with same context/user/timecreated
1207                 $params = array('contextid' => $data->contextid, 'userid' => $data->userid, 'timecreated' => $data->timecreated);
1208                 if (!$DB->record_exists('comments', $params)) {
1209                     $DB->insert_record('comments', $data);
1210                 }
1211             }
1212         }
1213     }
1216 /**
1217  * This structure step restores the grade items associated with one activity
1218  * All the grade items are made child of the "course" grade item but the original
1219  * categoryid is saved as parentitemid in the backup_ids table, so, when restoring
1220  * the complete gradebook (categories and calculations), that information is
1221  * available there
1222  */
1223 class restore_activity_grades_structure_step extends restore_structure_step {
1225     protected function define_structure() {
1227         $paths = array();
1228         $userinfo = $this->get_setting_value('userinfo');
1230         $paths[] = new restore_path_element('grade_item', '/activity_gradebook/grade_items/grade_item');
1231         $paths[] = new restore_path_element('grade_letter', '/activity_gradebook/grade_letters/grade_letter');
1232         if ($userinfo) {
1233             $paths[] = new restore_path_element('grade_grade',
1234                            '/activity_gradebook/grade_items/grade_item/grade_grades/grade_grade');
1235         }
1236         return $paths;
1237     }
1239     protected function process_grade_item($data) {
1241         $data = (object)($data);
1242         $oldid       = $data->id;        // We'll need these later
1243         $oldparentid = $data->categoryid;
1245         // make sure top course category exists, all grade items will be associated
1246         // to it. Later, if restoring the whole gradebook, categories will be introduced
1247         $coursecat = grade_category::fetch_course_category($this->get_courseid());
1248         $coursecatid = $coursecat->id; // Get the categoryid to be used
1250         unset($data->id);
1251         $data->categoryid   = $coursecatid;
1252         $data->courseid     = $this->get_courseid();
1253         $data->iteminstance = $this->task->get_activityid();
1254         // Don't get any idnumber from course module. Keep them as they are in grade_item->idnumber
1255         // Reason: it's not clear what happens with outcomes->idnumber or activities with multiple items (workshop)
1256         // so the best is to keep the ones already in the gradebook
1257         // Potential problem: duplicates if same items are restored more than once. :-(
1258         // This needs to be fixed in some way (outcomes & activities with multiple items)
1259         // $data->idnumber     = get_coursemodule_from_instance($data->itemmodule, $data->iteminstance)->idnumber;
1260         // In any case, verify always for uniqueness
1261         $data->idnumber = grade_verify_idnumber($data->idnumber, $this->get_courseid()) ? $data->idnumber : null;
1262         $data->scaleid      = $this->get_mappingid('scale', $data->scaleid);
1263         $data->outcomeid    = $this->get_mappingid('outcome', $data->outcomeid);
1264         $data->timecreated  = $this->apply_date_offset($data->timecreated);
1265         $data->timemodified = $this->apply_date_offset($data->timemodified);
1267         $gradeitem = new grade_item($data);
1268         $gradeitem->insert('restore');
1270         //sortorder is automatically assigned when inserting. Re-instate the previous sortorder
1271         $gradeitem->sortorder = $data->sortorder;
1272         $gradeitem->update('restore');
1274         // Set mapping, saving the original category id into parentitemid
1275         // gradebook restore (final task) will need it to reorganise items
1276         $this->set_mapping('grade_item', $oldid, $gradeitem->id, false, null, $oldparentid);
1277     }
1279     protected function process_grade_grade($data) {
1280         $data = (object)($data);
1282         unset($data->id);
1283         $data->itemid = $this->get_new_parentid('grade_item');
1284         $data->userid = $this->get_mappingid('user', $data->userid);
1285         $data->usermodified = $this->get_mappingid('user', $data->usermodified);
1286         $data->rawscaleid = $this->get_mappingid('scale', $data->rawscaleid);
1287         // TODO: Ask, all the rest of locktime/exported... work with time... to be rolled?
1288         $data->overridden = $this->apply_date_offset($data->overridden);
1290         $grade = new grade_grade($data);
1291         $grade->insert('restore');
1292         // no need to save any grade_grade mapping
1293     }
1295     /**
1296      * process activity grade_letters. Note that, while these are possible,
1297      * because grade_letters are contextid based, in proctice, only course
1298      * context letters can be defined. So we keep here this method knowing
1299      * it won't be executed ever. gradebook restore will restore course letters.
1300      */
1301     protected function process_grade_letter($data) {
1302         global $DB;
1304         $data = (object)$data;
1306         $data->contextid = $this->task->get_contextid();
1307         $newitemid = $DB->insert_record('grade_letters', $data);
1308         // no need to save any grade_letter mapping
1309     }
1313 /**
1314  * This structure steps restores one instance + positions of one block
1315  * Note: Positions corresponding to one existing context are restored
1316  * here, but all the ones having unknown contexts are sent to backup_ids
1317  * for a later chance to be restored at the end (final task)
1318  */
1319 class restore_block_instance_structure_step extends restore_structure_step {
1321     protected function define_structure() {
1323         $paths = array();
1325         $paths[] = new restore_path_element('block', '/block', true); // Get the whole XML together
1326         $paths[] = new restore_path_element('block_position', '/block/block_positions/block_position');
1328         return $paths;
1329     }
1331     public function process_block($data) {
1332         global $DB;
1334         $data = (object)$data; // Handy
1335         $oldcontextid = $data->contextid;
1336         $oldid        = $data->id;
1337         $positions = isset($data->block_positions['block_position']) ? $data->block_positions['block_position'] : array();
1339         // Look for the parent contextid
1340         if (!$data->parentcontextid = $this->get_mappingid('context', $data->parentcontextid)) {
1341             throw new restore_step_exception('restore_block_missing_parent_ctx', $data->parentcontextid);
1342         }
1344         // If there is already one block of that type in the parent context
1345         // and the block is not multiple, stop processing
1346         if ($DB->record_exists_sql("SELECT bi.id
1347                                       FROM {block_instances} bi
1348                                       JOIN {block} b ON b.name = bi.blockname
1349                                      WHERE bi.parentcontextid = ?
1350                                        AND bi.blockname = ?
1351                                        AND b.multiple = 0", array($data->parentcontextid, $data->blockname))) {
1352             return false;
1353         }
1355         // If there is already one block of that type in the parent context
1356         // with the same showincontexts, pagetypepattern, subpagepattern, defaultregion and configdata
1357         // stop processing
1358         $params = array(
1359             'blockname' => $data->blockname, 'parentcontextid' => $data->parentcontextid,
1360             'showinsubcontexts' => $data->showinsubcontexts, 'pagetypepattern' => $data->pagetypepattern,
1361             'subpagepattern' => $data->subpagepattern, 'defaultregion' => $data->defaultregion);
1362         if ($birecs = $DB->get_records('block_instances', $params)) {
1363             foreach($birecs as $birec) {
1364                 if ($birec->configdata == $data->configdata) {
1365                     return false;
1366                 }
1367             }
1368         }
1370         // Set task old contextid, blockid and blockname once we know them
1371         $this->task->set_old_contextid($oldcontextid);
1372         $this->task->set_old_blockid($oldid);
1373         $this->task->set_blockname($data->blockname);
1375         // Let's look for anything within configdata neededing processing
1376         // (nulls and uses of legacy file.php)
1377         if ($attrstotransform = $this->task->get_configdata_encoded_attributes()) {
1378             $configdata = (array)unserialize(base64_decode($data->configdata));
1379             foreach ($configdata as $attribute => $value) {
1380                 if (in_array($attribute, $attrstotransform)) {
1381                     $configdata[$attribute] = $this->contentprocessor->process_cdata($value);
1382                 }
1383             }
1384             $data->configdata = base64_encode(serialize((object)$configdata));
1385         }
1387         // Create the block instance
1388         $newitemid = $DB->insert_record('block_instances', $data);
1389         // Save the mapping (with restorefiles support)
1390         $this->set_mapping('block_instance', $oldid, $newitemid, true);
1391         // Create the block context
1392         $newcontextid = get_context_instance(CONTEXT_BLOCK, $newitemid)->id;
1393         // Save the block contexts mapping and sent it to task
1394         $this->set_mapping('context', $oldcontextid, $newcontextid);
1395         $this->task->set_contextid($newcontextid);
1396         $this->task->set_blockid($newitemid);
1398         // Restore block fileareas if declared
1399         $component = 'block_' . $this->task->get_blockname();
1400         foreach ($this->task->get_fileareas() as $filearea) { // Simple match by contextid. No itemname needed
1401             $this->add_related_files($component, $filearea, null);
1402         }
1404         // Process block positions, creating them or accumulating for final step
1405         foreach($positions as $position) {
1406             $position = (object)$position;
1407             $position->blockinstanceid = $newitemid; // The instance is always the restored one
1408             // If position is for one already mapped (known) contextid
1409             // process it now, creating the position
1410             if ($newpositionctxid = $this->get_mappingid('context', $position->contextid)) {
1411                 $position->contextid = $newpositionctxid;
1412                 // Create the block position
1413                 $DB->insert_record('block_positions', $position);
1415             // The position belongs to an unknown context, send it to backup_ids
1416             // to process them as part of the final steps of restore. We send the
1417             // whole $position object there, hence use the low level method.
1418             } else {
1419                 restore_dbops::set_backup_ids_record($this->get_restoreid(), 'block_position', $position->id, 0, null, $position);
1420             }
1421         }
1422     }
1425 /**
1426  * Structure step to restore common course_module information
1427  *
1428  * This step will process the module.xml file for one activity, in order to restore
1429  * the corresponding information to the course_modules table, skipping various bits
1430  * of information based on CFG settings (groupings, completion...) in order to fullfill
1431  * all the reqs to be able to create the context to be used by all the rest of steps
1432  * in the activity restore task
1433  */
1434 class restore_module_structure_step extends restore_structure_step {
1436     protected function define_structure() {
1437         global $CFG;
1439         $paths = array();
1441         $paths[] = new restore_path_element('module', '/module');
1442         if ($CFG->enableavailability) {
1443             $paths[] = new restore_path_element('availability', '/module/availability_info/availability');
1444         }
1446         return $paths;
1447     }
1449     protected function process_module($data) {
1450         global $CFG, $DB;
1452         $data = (object)$data;
1453         $oldid = $data->id;
1455         $data->course = $this->task->get_courseid();
1456         $data->module = $DB->get_field('modules', 'id', array('name' => $data->modulename));
1457         // Map section (first try by course_section mapping match. Useful in course and section restores)
1458         $data->section = $this->get_mappingid('course_section', $data->sectionid);
1459         if (!$data->section) { // mapping failed, try to get section by sectionnumber matching
1460             $params = array(
1461                 'course' => $this->get_courseid(),
1462                 'section' => $data->sectionnumber);
1463             $data->section = $DB->get_field('course_sections', 'id', $params);
1464         }
1465         if (!$data->section) { // sectionnumber failed, try to get first section in course
1466             $params = array(
1467                 'course' => $this->get_courseid());
1468             $data->section = $DB->get_field('course_sections', 'MIN(id)', $params);
1469         }
1470         if (!$data->section) { // no sections in course, create section 0 and 1 and assign module to 1
1471             $sectionrec = array(
1472                 'course' => $this->get_courseid(),
1473                 'section' => 0);
1474             $DB->insert_record('course_sections', $sectionrec); // section 0
1475             $sectionrec = array(
1476                 'course' => $this->get_courseid(),
1477                 'section' => 1);
1478             $data->section = $DB->insert_record('course_sections', $sectionrec); // section 1
1479         }
1480         $data->groupingid= $this->get_mappingid('grouping', $data->groupingid);      // grouping
1481         if (!$CFG->enablegroupmembersonly) {                                         // observe groupsmemberonly
1482             $data->groupmembersonly = 0;
1483         }
1484         if (!grade_verify_idnumber($data->idnumber, $this->get_courseid())) {        // idnumber uniqueness
1485             $data->idnumber = '';
1486         }
1487         if (empty($CFG->enablecompletion)) { // completion
1488             $data->completion = 0;
1489             $data->completiongradeitemnumber = null;
1490             $data->completionview = 0;
1491             $data->completionexpected = 0;
1492         } else {
1493             $data->completionexpected = $this->apply_date_offset($data->completionexpected);
1494         }
1495         if (empty($CFG->enableavailability)) {
1496             $data->availablefrom = 0;
1497             $data->availableuntil = 0;
1498             $data->showavailability = 0;
1499         } else {
1500             $data->availablefrom = $this->apply_date_offset($data->availablefrom);
1501             $data->availableuntil= $this->apply_date_offset($data->availableuntil);
1502         }
1503         $data->instance = 0; // Set to 0 for now, going to create it soon (next step)
1505         // course_module record ready, insert it
1506         $newitemid = $DB->insert_record('course_modules', $data);
1507         // save mapping
1508         $this->set_mapping('course_module', $oldid, $newitemid);
1509         // set the new course_module id in the task
1510         $this->task->set_moduleid($newitemid);
1511         // we can now create the context safely
1512         $ctxid = get_context_instance(CONTEXT_MODULE, $newitemid)->id;
1513         // set the new context id in the task
1514         $this->task->set_contextid($ctxid);
1515         // update sequence field in course_section
1516         if ($sequence = $DB->get_field('course_sections', 'sequence', array('id' => $data->section))) {
1517             $sequence .= ',' . $newitemid;
1518         } else {
1519             $sequence = $newitemid;
1520         }
1521         $DB->set_field('course_sections', 'sequence', $sequence, array('id' => $data->section));
1522     }
1525     protected function process_availability($data) {
1526         $data = (object)$data;
1527         // Simply going to store the whole availability record now, we'll process
1528         // all them later in the final task (once all actvivities have been restored)
1529         // Let's call the low level one to be able to store the whole object
1530         $data->coursemoduleid = $this->task->get_moduleid(); // Let add the availability cmid
1531         restore_dbops::set_backup_ids_record($this->get_restoreid(), 'module_availability', $data->id, 0, null, $data);
1532     }
1535 /**
1536  * Structure step that will process the user activity completion
1537  * information if all these conditions are met:
1538  *  - Target site has completion enabled ($CFG->enablecompletion)
1539  *  - Activity includes completion info (file_exists)
1540  */
1541 class restore_userscompletion_structure_step extends restore_structure_step {
1543     /**
1544      * To conditionally decide if this step must be executed
1545      * Note the "settings" conditions are evaluated in the
1546      * corresponding task. Here we check for other conditions
1547      * not being restore settings (files, site settings...)
1548      */
1549      protected function execute_condition() {
1550          global $CFG;
1552          // Completion disabled in this site, don't execute
1553          if (empty($CFG->enablecompletion)) {
1554              return false;
1555          }
1557          // No user completion info found, don't execute
1558         $fullpath = $this->task->get_taskbasepath();
1559         $fullpath = rtrim($fullpath, '/') . '/' . $this->filename;
1560          if (!file_exists($fullpath)) {
1561              return false;
1562          }
1564          // Arrived here, execute the step
1565          return true;
1566      }
1568      protected function define_structure() {
1570         $paths = array();
1572         $paths[] = new restore_path_element('completion', '/completions/completion');
1574         return $paths;
1575     }
1577     protected function process_completion($data) {
1578         global $DB;
1580         $data = (object)$data;
1582         $data->coursemoduleid = $this->task->get_moduleid();
1583         $data->userid = $this->get_mappingid('user', $data->userid);
1584         $data->timemodified = $this->apply_date_offset($data->timemodified);
1586         $DB->insert_record('course_modules_completion', $data);
1587     }
1590 /**
1591  * Abstract structure step, parent of all the activity structure steps. Used to suuport
1592  * the main <activity ...> tag and process it. Also provides subplugin support for
1593  * activities.
1594  */
1595 abstract class restore_activity_structure_step extends restore_structure_step {
1597     protected function add_subplugin_structure($subplugintype, $element) {
1599         global $CFG;
1601         // Check the requested subplugintype is a valid one
1602         $subpluginsfile = $CFG->dirroot . '/mod/' . $this->task->get_modulename() . '/db/subplugins.php';
1603         if (!file_exists($subpluginsfile)) {
1604              throw new restore_step_exception('activity_missing_subplugins_php_file', $this->task->get_modulename());
1605         }
1606         include($subpluginsfile);
1607         if (!array_key_exists($subplugintype, $subplugins)) {
1608              throw new restore_step_exception('incorrect_subplugin_type', $subplugintype);
1609         }
1610         // Get all the restore path elements, looking across all the subplugin dirs
1611         $subpluginsdirs = get_plugin_list($subplugintype);
1612         foreach ($subpluginsdirs as $name => $subpluginsdir) {
1613             $classname = 'restore_' . $subplugintype . '_' . $name . '_subplugin';
1614             $restorefile = $subpluginsdir . '/backup/moodle2/' . $classname . '.class.php';
1615             if (file_exists($restorefile)) {
1616                 require_once($restorefile);
1617                 $restoresubplugin = new $classname($subplugintype, $name, $this);
1618                 // Add subplugin paths to the step
1619                 $this->prepare_pathelements($restoresubplugin->define_subplugin_structure($element));
1620             }
1621         }
1622     }
1624     /**
1625      * As far as activity restore steps are implementing restore_subplugin stuff, they need to
1626      * have the parent task available for wrapping purposes (get course/context....)
1627      */
1628     public function get_task() {
1629         return $this->task;
1630     }
1632     /**
1633      * Adds support for the 'activity' path that is common to all the activities
1634      * and will be processed globally here
1635      */
1636     protected function prepare_activity_structure($paths) {
1638         $paths[] = new restore_path_element('activity', '/activity');
1640         return $paths;
1641     }
1643     /**
1644      * Process the activity path, informing the task about various ids, needed later
1645      */
1646     protected function process_activity($data) {
1647         $data = (object)$data;
1648         $this->task->set_old_contextid($data->contextid); // Save old contextid in task
1649         $this->set_mapping('context', $data->contextid, $this->task->get_contextid()); // Set the mapping
1650         $this->task->set_old_activityid($data->id); // Save old activityid in task
1651     }
1653     /**
1654      * This must be invoked inmediately after creating the "module" activity record (forum, choice...)
1655      * and will adjust the new activity id (the instance) in various places
1656      */
1657     protected function apply_activity_instance($newitemid) {
1658         global $DB;
1660         $this->task->set_activityid($newitemid); // Save activity id in task
1661         // Apply the id to course_sections->instanceid
1662         $DB->set_field('course_modules', 'instance', $newitemid, array('id' => $this->task->get_moduleid()));
1663         // Do the mapping for modulename, preparing it for files by oldcontext
1664         $modulename = $this->task->get_modulename();
1665         $oldid = $this->task->get_old_activityid();
1666         $this->set_mapping($modulename, $oldid, $newitemid, true);
1667     }