324d824c6835c770bbcc1ddfde1ccf74fb2caf15
[moodle.git] / backup / moodle2 / backup_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 backup steps that will be used by common tasks in backup
27  */
29 /**
30  * create the temp dir where backup/restore will happen,
31  * delete old directories and create temp ids table
32  */
33 class create_and_clean_temp_stuff extends backup_execution_step {
35     protected function define_execution() {
36         backup_helper::check_and_create_backup_dir($this->get_backupid());// Create backup temp dir
37         backup_helper::clear_backup_dir($this->get_backupid());           // Empty temp dir, just in case
38         backup_helper::delete_old_backup_dirs(time() - (4 * 60 * 60));    // Delete > 4 hours temp dirs
39         backup_controller_dbops::create_backup_ids_temp_table($this->get_backupid()); // Create ids temp table
40     }
41 }
43 /**
44  * delete the temp dir used by backup/restore (conditionally),
45  * delete old directories and drop tem ids table. Note we delete
46  * the directory but not the corresponding log file that will be
47  * there for, at least, 4 hours - only delete_old_backup_dirs()
48  * deletes log files (for easier access to them)
49  */
50 class drop_and_clean_temp_stuff extends backup_execution_step {
52     protected function define_execution() {
53         global $CFG;
54         backup_controller_dbops::drop_backup_ids_temp_table($this->get_backupid()); // Drop ids temp table
55         backup_helper::delete_old_backup_dirs(time() - (4 * 60 * 60));              // Delete > 4 hours temp dirs
56         if (empty($CFG->keeptempdirectoriesonbackup)) { // Conditionally
57             backup_helper::delete_backup_dir($this->get_backupid()); // Empty backup dir
58         }
59     }
60 }
62 /**
63  * Create the directory where all the task (activity/block...) information will be stored
64  */
65 class create_taskbasepath_directory extends backup_execution_step {
67     protected function define_execution() {
68         global $CFG;
69         $basepath = $this->task->get_taskbasepath();
70         if (!check_dir_exists($basepath, true, true)) {
71             throw new backup_step_exception('cannot_create_taskbasepath_directory', $basepath);
72         }
73     }
74 }
76 /**
77  * Abstract structure step, parent of all the activity structure steps. Used to wrap the
78  * activity structure definition within the main <activity ...> tag. Also provides
79  * subplugin support for activities (that must be properly declared)
80  */
81 abstract class backup_activity_structure_step extends backup_structure_step {
83     /**
84      * Add subplugin structure to any element in the activity backup tree
85      *
86      * @param string $subplugintype type of subplugin as defined in activity db/subplugins.php
87      * @param backup_nested_element $element element in the activity backup tree that
88      *                                       we are going to add subplugin information to
89      * @param bool $multiple to define if multiple subplugins can produce information
90      *                       for each instance of $element (true) or no (false)
91      */
92     protected function add_subplugin_structure($subplugintype, $element, $multiple) {
94         global $CFG;
96         // Check the requested subplugintype is a valid one
97         $subpluginsfile = $CFG->dirroot . '/mod/' . $this->task->get_modulename() . '/db/subplugins.php';
98         if (!file_exists($subpluginsfile)) {
99              throw new backup_step_exception('activity_missing_subplugins_php_file', $this->task->get_modulename());
100         }
101         include($subpluginsfile);
102         if (!array_key_exists($subplugintype, $subplugins)) {
103              throw new backup_step_exception('incorrect_subplugin_type', $subplugintype);
104         }
106         // Arrived here, subplugin is correct, let's create the optigroup
107         $optigroupname = $subplugintype . '_' . $element->get_name() . '_subplugin';
108         $optigroup = new backup_optigroup($optigroupname, null, $multiple);
109         $element->add_child($optigroup); // Add optigroup to stay connected since beginning
111         // Get all the optigroup_elements, looking across all the subplugin dirs
112         $elements = array();
113         $subpluginsdirs = get_plugin_list($subplugintype);
114         foreach ($subpluginsdirs as $name => $subpluginsdir) {
115             $classname = 'backup_' . $subplugintype . '_' . $name . '_subplugin';
116             $backupfile = $subpluginsdir . '/backup/moodle2/' . $classname . '.class.php';
117             if (file_exists($backupfile)) {
118                 require_once($backupfile);
119                 $backupsubplugin = new $classname($subplugintype, $name, $optigroup);
120                 // Add subplugin returned structure to optigroup
121                 $backupsubplugin->define_subplugin_structure($element->get_name());
122             }
123         }
124     }
126     /**
127      * Wraps any activity backup structure within the common 'activity' element
128      * that will include common to all activities information like id, context...
129      */
130     protected function prepare_activity_structure($activitystructure) {
132         // Create the wrap element
133         $activity = new backup_nested_element('activity', array('id', 'moduleid', 'modulename', 'contextid'), null);
135         // Build the tree
136         $activity->add_child($activitystructure);
138         // Set the source
139         $activityarr = array((object)array(
140             'id'         => $this->task->get_activityid(),
141             'moduleid'   => $this->task->get_moduleid(),
142             'modulename' => $this->task->get_modulename(),
143             'contextid'  => $this->task->get_contextid()));
145         $activity->set_source_array($activityarr);
147         // Return the root element (activity)
148         return $activity;
149     }
152 /**
153  * Abstract structure step, parent of all the block structure steps. Used to wrap the
154  * block structure definition within the main <block ...> tag
155  */
156 abstract class backup_block_structure_step extends backup_structure_step {
158     protected function prepare_block_structure($blockstructure) {
160         // Create the wrap element
161         $block = new backup_nested_element('block', array('id', 'blockname', 'contextid'), null);
163         // Build the tree
164         $block->add_child($blockstructure);
166         // Set the source
167         $blockarr = array((object)array(
168             'id'         => $this->task->get_blockid(),
169             'blockname'  => $this->task->get_blockname(),
170             'contextid'  => $this->task->get_contextid()));
172         $block->set_source_array($blockarr);
174         // Return the root element (block)
175         return $block;
176     }
179 /**
180  * structure step that will generate the module.xml file for the activity,
181  * accumulating various information about the activity, annotating groupings
182  * and completion/avail conf
183  */
184 class backup_module_structure_step extends backup_structure_step {
186     protected function define_structure() {
188         // Define each element separated
190         $module = new backup_nested_element('module', array('id', 'version'), array(
191             'modulename', 'sectionid', 'sectionnumber', 'idnumber',
192             'added', 'score', 'indent', 'visible',
193             'visibleold', 'groupmode', 'groupingid', 'groupmembersonly',
194             'completion', 'completiongradeitemnumber', 'completionview', 'completionexpected',
195             'availablefrom', 'availableuntil', 'showavailability'));
197         $availinfo = new backup_nested_element('availability_info');
198         $availability = new backup_nested_element('availability', array('id'), array(
199             'sourcecmid', 'requiredcompletion', 'gradeitemid', 'grademin', 'grademax'));
201         // Define the tree
202         $module->add_child($availinfo);
203         $availinfo->add_child($availability);
205         // Set the sources
207         $module->set_source_sql('
208             SELECT cm.*, m.version, m.name AS modulename, s.id AS sectionid, s.section AS sectionnumber
209               FROM {course_modules} cm
210               JOIN {modules} m ON m.id = cm.module
211               JOIN {course_sections} s ON s.id = cm.section
212              WHERE cm.id = ?', array(backup::VAR_MODID));
214         $availability->set_source_table('course_modules_availability', array('coursemoduleid' => backup::VAR_MODID));
216         // Define annotations
217         $module->annotate_ids('grouping', 'groupingid');
219         // Return the root element ($module)
220         return $module;
221     }
224 /**
225  * structure step that will generate the section.xml file for the section
226  * annotating files
227  */
228 class backup_section_structure_step extends backup_structure_step {
230     protected function define_structure() {
232         // Define each element separated
234         $section = new backup_nested_element('section', array('id'), array(
235             'number', 'name', 'summary', 'summaryformat', 'sequence', 'visible'));
237         // Define sources
239         $section->set_source_table('course_sections', array('id' => backup::VAR_SECTIONID));
241         // Aliases
242         $section->set_source_alias('section', 'number');
244         // Set annotations
245         $section->annotate_files('course', 'section', 'id');
247         return $section;
248     }
251 /**
252  * structure step that will generate the course.xml file for the course, including
253  * course category reference, tags, modules restriction information
254  * and some annotations (files & groupings)
255  */
256 class backup_course_structure_step extends backup_structure_step {
258     protected function define_structure() {
259         global $DB;
261         // Define each element separated
263         $course = new backup_nested_element('course', array('id', 'contextid'), array(
264             'shortname', 'fullname', 'idnumber',
265             'summary', 'summaryformat', 'format', 'showgrades',
266             'newsitems', 'startdate',
267             'numsections', 'marker', 'maxbytes', 'showreports',
268             'visible', 'hiddensections', 'groupmode', 'groupmodeforce',
269             'defaultgroupingid', 'lang', 'theme',
270             'timecreated', 'timemodified',
271             'requested', 'restrictmodules',
272             'enablecompletion', 'completionstartonenrol', 'completionnotify'));
274         $category = new backup_nested_element('category', array('id'), array(
275             'name', 'description'));
277         $tags = new backup_nested_element('tags');
279         $tag = new backup_nested_element('tag', array('id'), array(
280             'name', 'rawname'));
282         $allowedmodules = new backup_nested_element('allowed_modules');
284         $module = new backup_nested_element('module', array(), array('modulename'));
286         // Build the tree
288         $course->add_child($category);
290         $course->add_child($tags);
291         $tags->add_child($tag);
293         $course->add_child($allowedmodules);
294         $allowedmodules->add_child($module);
296         // Set the sources
298         $courserec = $DB->get_record('course', array('id' => $this->task->get_courseid()));
299         $courserec->contextid = $this->task->get_contextid();
301         $course->set_source_array(array($courserec));
303         $categoryrec = $DB->get_record('course_categories', array('id' => $courserec->category));
305         $category->set_source_array(array($categoryrec));
307         $tag->set_source_sql('SELECT t.id, t.name, t.rawname
308                                 FROM {tag} t
309                                 JOIN {tag_instance} ti ON ti.tagid = t.id
310                                WHERE ti.itemtype = ?
311                                  AND ti.itemid = ?', array(
312                                      backup_helper::is_sqlparam('course'),
313                                      backup::VAR_PARENTID));
315         $module->set_source_sql('SELECT m.name AS modulename
316                                    FROM {modules} m
317                                    JOIN {course_allowed_modules} cam ON m.id = cam.module
318                                   WHERE course = ?', array(backup::VAR_COURSEID));
320         // Some annotations
322         $course->annotate_ids('grouping', 'defaultgroupingid');
324         $course->annotate_files('course', 'summary', null);
325         $course->annotate_files('course', 'legacy', null);
327         // Return root element ($course)
329         return $course;
330     }
333 /**
334  * structure step that will generate the enrolments.xml file for the given course
335  */
336 class backup_enrolments_structure_step extends backup_structure_step {
338     protected function define_structure() {
340         // To know if we are including users
341         $users = $this->get_setting_value('users');
343         // Define each element separated
345         $enrolments = new backup_nested_element('enrolments');
347         $enrols = new backup_nested_element('enrols');
349         $enrol = new backup_nested_element('enrol', array('id'), array(
350             'enrol', 'status', 'sortorder', 'name', 'enrolperiod', 'enrolstartdate',
351             'enrolenddate', 'expirynotify', 'expirytreshold', 'notifyall',
352             'password', 'cost', 'currency', 'roleid', 'customint1', 'customint2', 'customint3',
353             'customint4', 'customchar1', 'customchar2', 'customdec1', 'customdec2',
354             'customtext1', 'customtext2', 'timecreated', 'timemodified'));
356         $userenrolments = new backup_nested_element('user_enrolments');
358         $enrolment = new backup_nested_element('enrolment', array('id'), array(
359             'status', 'userid', 'timestart', 'timeend', 'modifierid',
360             'timemodified'));
362         // Build the tree
363         $enrolments->add_child($enrols);
364         $enrols->add_child($enrol);
365         $enrol->add_child($userenrolments);
366         $userenrolments->add_child($enrolment);
368         // Define sources
370         $enrol->set_source_table('enrol', array('courseid' => backup::VAR_COURSEID));
372         // User enrolments only added only if users included
373         if ($users) {
374             $enrolment->set_source_table('user_enrolments', array('enrolid' => backup::VAR_PARENTID));
375             $enrolment->annotate_ids('user', 'userid');
376         }
378         $enrol->annotate_ids('role', 'roleid');
380         //TODO: let plugins annotate custom fields too and add more children
382         return $enrolments;
383     }
386 /**
387  * structure step that will generate the roles.xml file for the given context, observing
388  * the role_assignments setting to know if that part needs to be included
389  */
390 class backup_roles_structure_step extends backup_structure_step {
392     protected function define_structure() {
394         // To know if we are including role assignments
395         $roleassignments = $this->get_setting_value('role_assignments');
397         // Define each element separated
399         $roles = new backup_nested_element('roles');
401         $overrides = new backup_nested_element('role_overrides');
403         $override = new backup_nested_element('override', array('id'), array(
404             'roleid', 'capability', 'permission', 'timemodified',
405             'modifierid'));
407         $assignments = new backup_nested_element('role_assignments');
409         $assignment = new backup_nested_element('assignment', array('id'), array(
410             'roleid', 'userid', 'timemodified', 'modifierid', 'component', 'itemid',
411             'sortorder'));
413         // Build the tree
414         $roles->add_child($overrides);
415         $roles->add_child($assignments);
417         $overrides->add_child($override);
418         $assignments->add_child($assignment);
420         // Define sources
422         $override->set_source_table('role_capabilities', array('contextid' => backup::VAR_CONTEXTID));
424         // Assignments only added if specified
425         if ($roleassignments) {
426             $assignment->set_source_table('role_assignments', array('contextid' => backup::VAR_CONTEXTID));
427         }
429         // Define id annotations
430         $override->annotate_ids('role', 'roleid');
432         $assignment->annotate_ids('role', 'roleid');
434         $assignment->annotate_ids('user', 'userid');
436         //TODO: how do we annotate the itemid? the meaning depends on the content of component table (skodak)
438         return $roles;
439     }
442 /**
443  * structure step that will generate the roles.xml containing the
444  * list of roles used along the whole backup process. Just raw
445  * list of used roles from role table
446  */
447 class backup_final_roles_structure_step extends backup_structure_step {
449     protected function define_structure() {
451         // Define elements
453         $rolesdef = new backup_nested_element('roles_definition');
455         $role = new backup_nested_element('role', array('id'), array(
456             'name', 'shortname', 'nameincourse', 'description',
457             'sortorder', 'archetype'));
459         // Build the tree
461         $rolesdef->add_child($role);
463         // Define sources
465         $role->set_source_sql("SELECT r.*, rn.name AS nameincourse
466                                  FROM {role} r
467                                  JOIN {backup_ids_temp} bi ON r.id = bi.itemid
468                             LEFT JOIN {role_names} rn ON r.id = rn.roleid AND rn.contextid = ?
469                                 WHERE bi.backupid = ?
470                                   AND bi.itemname = 'rolefinal'", array(backup::VAR_CONTEXTID, backup::VAR_BACKUPID));
472         // Return main element (rolesdef)
473         return $rolesdef;
474     }
477 /**
478  * structure step that will generate the scales.xml containing the
479  * list of scales used along the whole backup process.
480  */
481 class backup_final_scales_structure_step extends backup_structure_step {
483     protected function define_structure() {
485         // Define elements
487         $scalesdef = new backup_nested_element('scales_definition');
489         $scale = new backup_nested_element('scale', array('id'), array(
490             'courseid', 'userid', 'name', 'scale',
491             'description', 'descriptionformat', 'timemodified'));
493         // Build the tree
495         $scalesdef->add_child($scale);
497         // Define sources
499         $scale->set_source_sql("SELECT s.*
500                                   FROM {scale} s
501                                   JOIN {backup_ids_temp} bi ON s.id = bi.itemid
502                                  WHERE bi.backupid = ?
503                                    AND bi.itemname = 'scalefinal'", array(backup::VAR_BACKUPID));
505         // Annotate scale files (they store files in system context, so pass it instead of default one)
506         $scale->annotate_files('grade', 'scale', 'id', get_context_instance(CONTEXT_SYSTEM)->id);
508         // Return main element (scalesdef)
509         return $scalesdef;
510     }
513 /**
514  * structure step that will generate the outcomes.xml containing the
515  * list of outcomes used along the whole backup process.
516  */
517 class backup_final_outcomes_structure_step extends backup_structure_step {
519     protected function define_structure() {
521         // Define elements
523         $outcomesdef = new backup_nested_element('outcomes_definition');
525         $outcome = new backup_nested_element('outcome', array('id'), array(
526             'courseid', 'userid', 'shortname', 'fullname',
527             'scaleid', 'description', 'descriptionformat', 'timecreated',
528             'timemodified','usermodified'));
530         // Build the tree
532         $outcomesdef->add_child($outcome);
534         // Define sources
536         $outcome->set_source_sql("SELECT o.*
537                                     FROM {grade_outcomes} o
538                                     JOIN {backup_ids_temp} bi ON o.id = bi.itemid
539                                    WHERE bi.backupid = ?
540                                      AND bi.itemname = 'outcomefinal'", array(backup::VAR_BACKUPID));
542         // Annotate outcome files (they store files in system context, so pass it instead of default one)
543         $outcome->annotate_files('grade', 'outcome', 'id', get_context_instance(CONTEXT_SYSTEM)->id);
545         // Return main element (outcomesdef)
546         return $outcomesdef;
547     }
550 /**
551  * structure step in charge of constructing the filters.xml file for all the filters found
552  * in activity
553  */
554 class backup_filters_structure_step extends backup_structure_step {
556     protected function define_structure() {
558         // Define each element separated
560         $filters = new backup_nested_element('filters');
562         $actives = new backup_nested_element('filter_actives');
564         $active = new backup_nested_element('filter_active', null, array('filter', 'active'));
566         $configs = new backup_nested_element('filter_configs');
568         $config = new backup_nested_element('filter_config', null, array('filter', 'name', 'value'));
570         // Build the tree
572         $filters->add_child($actives);
573         $filters->add_child($configs);
575         $actives->add_child($active);
576         $configs->add_child($config);
578         // Define sources
580         list($activearr, $configarr) = filter_get_all_local_settings($this->task->get_contextid());
582         $active->set_source_array($activearr);
583         $config->set_source_array($configarr);
585         // Return the root element (filters)
586         return $filters;
587     }
590 /**
591  * structure step in charge of constructing the comments.xml file for all the comments found
592  * in a given context
593  */
594 class backup_comments_structure_step extends backup_structure_step {
596     protected function define_structure() {
598         // Define each element separated
600         $comments = new backup_nested_element('comments');
602         $comment = new backup_nested_element('comment', array('id'), array(
603             'commentarea', 'itemid', 'content', 'format',
604             'userid', 'timecreated'));
606         // Build the tree
608         $comments->add_child($comment);
610         // Define sources
612         $comment->set_source_table('comments', array('contextid' => backup::VAR_CONTEXTID));
614         // Define id annotations
616         $comment->annotate_ids('user', 'userid');
618         // Return the root element (comments)
619         return $comments;
620     }
623 /**
624  * structure step in charge of constructing the gradebook.xml file for all the gradebook config in the course
625  * NOTE: the backup of the grade items themselves is handled by backup_activity_grades_structure_step
626  */
627 class backup_gradebook_structure_step extends backup_structure_step {
629     /**
630      * We need to decide conditionally, based on dynamic information
631      * about the execution of this step. Only will be executed if all
632      * the module gradeitems have been already included in backup
633      */
634     protected function execute_condition() {
635         return backup_plan_dbops::require_gradebook_backup($this->get_courseid(), $this->get_backupid());
636     }
638     protected function define_structure() {
640         // are we including user info?
641         $userinfo = $this->get_setting_value('users');
643         $gradebook = new backup_nested_element('gradebook');
645         //grade_letters are done in backup_activity_grades_structure_step()
647         //calculated grade items
648         $grade_items = new backup_nested_element('grade_items');
649         $grade_item = new backup_nested_element('grade_item', array('id'), array(
650             'categoryid', 'itemname', 'itemtype', 'itemmodule',
651             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
652             'calculation', 'gradetype', 'grademax', 'grademin',
653             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
654             'plusfactor', 'aggregationcoef', 'sortorder', 'display',
655             'decimals', 'hidden', 'locked', 'locktime',
656             'needsupdate', 'timecreated', 'timemodified'));
658         $grade_grades = new backup_nested_element('grade_grades');
659         $grade_grade = new backup_nested_element('grade_grade', array('id'), array(
660             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
661             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
662             'locked', 'locktime', 'exported', 'overridden',
663             'excluded', 'feedback', 'feedbackformat', 'information',
664             'informationformat', 'timecreated', 'timemodified'));
666         //grade_categories
667         $grade_categories = new backup_nested_element('grade_categories');
668         $grade_category   = new backup_nested_element('grade_category', null, array('courseid',
669                 'parent', 'depth', 'path', 'fullname', 'aggregation', 'keephigh',
670                 'dropload', 'aggregateonlygraded', 'aggregateoutcomes', 'aggregatesubcats',
671                 'timecreated', 'timemodified'));
673         $letters = new backup_nested_element('grade_letters');
674         $letter = new backup_nested_element('grade_letter', 'id', array(
675             'lowerboundary', 'letter'));
678         // Build the tree
680         $gradebook->add_child($grade_items);
681         $grade_items->add_child($grade_item);
682         $grade_item->add_child($grade_grades);
683         $grade_grades->add_child($grade_grade);
685         //$grade_item->add_child($grade_scale);
687         $gradebook->add_child($grade_categories);
688         $grade_categories->add_child($grade_category);
690         $gradebook->add_child($letters);
691         $letters->add_child($letter);
693         // Define sources
695         //Include manual, category and the course grade item
696         $grade_items_sql ="SELECT * FROM {grade_items} 
697                            WHERE courseid = :courseid
698                            AND (itemtype='manual' OR itemtype='course' OR itemtype='category')";
699         $grade_items_params = array('courseid'=>backup::VAR_COURSEID);
700         $grade_item->set_source_sql($grade_items_sql, $grade_items_params);
702         if ($userinfo) {
703             $grade_grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
704         }
706         $grade_category_sql = "SELECT gc.*, gi.sortorder
707                                FROM {grade_categories} gc
708                                JOIN {grade_items} gi ON (gi.iteminstance = gc.id)
709                                WHERE gc.courseid = :courseid
710                                AND (gi.itemtype='course' OR gi.itemtype='category')
711                                ORDER BY gc.parent ASC";//need parent categories before their children
712         $grade_category_params = array('courseid'=>backup::VAR_COURSEID);
713         $grade_category->set_source_sql($grade_category_sql, $grade_category_params);
715         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
717         // Annotations (both as final as far as they are going to be exported in next steps)
718         $grade_item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
719         $grade_item->annotate_ids('outcomefinal', 'outcomeid');
721         // Return the root element
722         return $gradebook;
723     }
726 /**
727  * structure step in charge if constructing the completion.xml file for all the users completion
728  * information in a given activity
729  */
730 class backup_userscompletion_structure_step extends backup_structure_step {
732     protected function define_structure() {
734         // Define each element separated
736         $completions = new backup_nested_element('completions');
738         $completion = new backup_nested_element('completion', array('id'), array(
739             'userid', 'completionstate', 'viewed', 'timemodified'));
741         // Build the tree
743         $completions->add_child($completion);
745         // Define sources
747         $completion->set_source_table('course_modules_completion', array('coursemoduleid' => backup::VAR_MODID));
749         // Define id annotations
751         $completion->annotate_ids('user', 'userid');
753         // Return the root element (completions)
754         return $completions;
755     }
758 /**
759  * structure step in charge of constructing the main groups.xml file for all the groups and
760  * groupings information already annotated
761  */
762 class backup_groups_structure_step extends backup_structure_step {
764     protected function define_structure() {
766         // To know if we are including users
767         $users = $this->get_setting_value('users');
769         // Define each element separated
771         $groups = new backup_nested_element('groups');
773         $group = new backup_nested_element('group', array('id'), array(
774             'name', 'description', 'descriptionformat', 'enrolmentkey',
775             'picture', 'hidepicture', 'timecreated', 'timemodified'));
777         $members = new backup_nested_element('group_members');
779         $member = new backup_nested_element('group_member', array('id'), array(
780             'userid', 'timeadded'));
782         $groupings = new backup_nested_element('groupings');
784         $grouping = new backup_nested_element('grouping', 'id', array(
785             'name', 'description', 'descriptionformat', 'configdata',
786             'timecreated', 'timemodified'));
788         $groupinggroups = new backup_nested_element('grouping_groups');
790         $groupinggroup = new backup_nested_element('grouping_group', array('id'), array(
791             'groupid', 'timeadded'));
793         // Build the tree
795         $groups->add_child($group);
796         $groups->add_child($groupings);
798         $group->add_child($members);
799         $members->add_child($member);
801         $groupings->add_child($grouping);
802         $grouping->add_child($groupinggroups);
803         $groupinggroups->add_child($groupinggroup);
805         // Define sources
807         $group->set_source_sql("
808             SELECT g.*
809               FROM {groups} g
810               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
811              WHERE bi.backupid = ?
812                AND bi.itemname = 'groupfinal'", array(backup::VAR_BACKUPID));
814         // This only happens if we are including users
815         if ($users) {
816             $member->set_source_table('groups_members', array('groupid' => backup::VAR_PARENTID));
817         }
819         $grouping->set_source_sql("
820             SELECT g.*
821               FROM {groupings} g
822               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
823              WHERE bi.backupid = ?
824                AND bi.itemname = 'groupingfinal'", array(backup::VAR_BACKUPID));
826         $groupinggroup->set_source_table('groupings_groups', array('groupingid' => backup::VAR_PARENTID));
828         // Define id annotations (as final)
830         $member->annotate_ids('userfinal', 'userid');
832         // Define file annotations
834         $group->annotate_files('group', 'description', 'id');
835         $group->annotate_files('group', 'icon', 'id');
836         $grouping->annotate_files('grouping', 'description', 'id');
838         // Return the root element (groups)
839         return $groups;
840     }
843 /**
844  * structure step in charge of constructing the main users.xml file for all the users already
845  * annotated (final). Includes custom profile fields, preferences, tags, role assignments and
846  * overrides.
847  */
848 class backup_users_structure_step extends backup_structure_step {
850     protected function define_structure() {
851         global $CFG;
853         // To know if we are anonymizing users
854         $anonymize = $this->get_setting_value('anonymize');
855         // To know if we are including role assignments
856         $roleassignments = $this->get_setting_value('role_assignments');
858         // Define each element separated
860         $users = new backup_nested_element('users');
862         // Create the array of user fields by hand, as far as we have various bits to control
863         // anonymize option, password backup, mnethostid...
865         // First, the fields not needing anonymization nor special handling
866         $normalfields = array(
867             'confirmed', 'policyagreed', 'deleted',
868             'lang', 'theme', 'timezone', 'firstaccess',
869             'lastaccess', 'lastlogin', 'currentlogin',
870             'mailformat', 'maildigest', 'maildisplay', 'htmleditor',
871             'ajax', 'autosubscribe', 'trackforums', 'timecreated',
872             'timemodified', 'trustbitmask', 'screenreader');
874         // Then, the fields potentially needing anonymization
875         $anonfields = array(
876             'username', 'idnumber', 'firstname', 'lastname',
877             'email', 'emailstop', 'icq', 'skype',
878             'yahoo', 'aim', 'msn', 'phone1',
879             'phone2', 'institution', 'department', 'address',
880             'city', 'country', 'lastip', 'picture',
881             'url', 'description', 'descriptionformat', 'imagealt', 'auth');
883         // Add anonymized fields to $userfields with custom final element
884         foreach ($anonfields as $field) {
885             if ($anonymize) {
886                 $userfields[] = new anonymizer_final_element($field);
887             } else {
888                 $userfields[] = $field; // No anonymization, normally added
889             }
890         }
892         // mnethosturl requires special handling (custom final element)
893         $userfields[] = new mnethosturl_final_element('mnethosturl');
895         // password added conditionally
896         if (!empty($CFG->includeuserpasswordsinbackup)) {
897             $userfields[] = 'password';
898         }
900         // Merge all the fields
901         $userfields = array_merge($userfields, $normalfields);
903         $user = new backup_nested_element('user', array('id', 'contextid'), $userfields);
905         $customfields = new backup_nested_element('custom_fields');
907         $customfield = new backup_nested_element('custom_field', array('id'), array(
908             'field_name', 'field_type', 'field_data'));
910         $tags = new backup_nested_element('tags');
912         $tag = new backup_nested_element('tag', array('id'), array(
913             'name', 'rawname'));
915         $preferences = new backup_nested_element('preferences');
917         $preference = new backup_nested_element('preference', array('id'), array(
918             'name', 'value'));
920         $roles = new backup_nested_element('roles');
922         $overrides = new backup_nested_element('role_overrides');
924         $override = new backup_nested_element('override', array('id'), array(
925             'roleid', 'capability', 'permission', 'timemodified',
926             'modifierid'));
928         $assignments = new backup_nested_element('role_assignments');
930         $assignment = new backup_nested_element('assignment', array('id'), array(
931             'roleid', 'userid', 'timemodified', 'modifierid', 'component', //TODO: MDL-22793 add itemid here
932             'sortorder'));
934         // Build the tree
936         $users->add_child($user);
938         $user->add_child($customfields);
939         $customfields->add_child($customfield);
941         $user->add_child($tags);
942         $tags->add_child($tag);
944         $user->add_child($preferences);
945         $preferences->add_child($preference);
947         $user->add_child($roles);
949         $roles->add_child($overrides);
950         $roles->add_child($assignments);
952         $overrides->add_child($override);
953         $assignments->add_child($assignment);
955         // Define sources
957         $user->set_source_sql('SELECT u.*, c.id AS contextid, m.wwwroot AS mnethosturl
958                                  FROM {user} u
959                                  JOIN {backup_ids_temp} bi ON bi.itemid = u.id
960                                  JOIN {context} c ON c.instanceid = u.id
961                             LEFT JOIN {mnet_host} m ON m.id = u.mnethostid
962                                 WHERE bi.backupid = ?
963                                   AND bi.itemname = ?
964                                   AND c.contextlevel = ?', array(
965                                       backup_helper::is_sqlparam($this->get_backupid()),
966                                       backup_helper::is_sqlparam('userfinal'),
967                                       backup_helper::is_sqlparam(CONTEXT_USER)));
969         // All the rest on information is only added if we arent
970         // in an anonymized backup
971         if (!$anonymize) {
972             $customfield->set_source_sql('SELECT f.id, f.shortname, f.datatype, d.data
973                                             FROM {user_info_field} f
974                                             JOIN {user_info_data} d ON d.fieldid = f.id
975                                            WHERE d.userid = ?', array(backup::VAR_PARENTID));
977             $customfield->set_source_alias('shortname', 'field_name');
978             $customfield->set_source_alias('datatype',  'field_type');
979             $customfield->set_source_alias('data',      'field_data');
981             $tag->set_source_sql('SELECT t.id, t.name, t.rawname
982                                     FROM {tag} t
983                                     JOIN {tag_instance} ti ON ti.tagid = t.id
984                                    WHERE ti.itemtype = ?
985                                      AND ti.itemid = ?', array(
986                                          backup_helper::is_sqlparam('user'),
987                                          backup::VAR_PARENTID));
989             $preference->set_source_table('user_preferences', array('userid' => backup::VAR_PARENTID));
991             $override->set_source_table('role_capabilities', array('contextid' => '/users/user/contextid'));
993             // Assignments only added if specified
994             if ($roleassignments) {
995                 $assignment->set_source_table('role_assignments', array('contextid' => '/users/user/contextid'));
996             }
998             // Define id annotations (as final)
999             $override->annotate_ids('rolefinal', 'roleid');
1000         }
1002         // Return root element (users)
1003         return $users;
1004     }
1007 /**
1008  * structure step in charge of constructing the block.xml file for one
1009  * given block (instance and positions). If the block has custom DB structure
1010  * that will go to a separate file (different step defined in block class)
1011  */
1012 class backup_block_instance_structure_step extends backup_structure_step {
1014     protected function define_structure() {
1015         global $DB;
1017         // Define each element separated
1019         $block = new backup_nested_element('block', array('id', 'contextid', 'version'), array(
1020             'blockname', 'parentcontextid', 'showinsubcontexts', 'pagetypepattern',
1021             'subpagepattern', 'defaultregion', 'defaultweight', 'configdata'));
1023         $positions = new backup_nested_element('block_positions');
1025         $position = new backup_nested_element('block_position', array('id'), array(
1026             'contextid', 'pagetype', 'subpage', 'visible',
1027             'region', 'weight'));
1029         // Build the tree
1031         $block->add_child($positions);
1032         $positions->add_child($position);
1034         // Transform configdata information if needed (process links and friends)
1035         $blockrec = $DB->get_record('block_instances', array('id' => $this->task->get_blockid()));
1036         if ($attrstotransform = $this->task->get_configdata_encoded_attributes()) {
1037             $configdata = (array)unserialize(base64_decode($blockrec->configdata));
1038             foreach ($configdata as $attribute => $value) {
1039                 if (in_array($attribute, $attrstotransform)) {
1040                     $configdata[$attribute] = $this->contenttransformer->process($value);
1041                 }
1042             }
1043             $blockrec->configdata = base64_encode(serialize((object)$configdata));
1044         }
1045         $blockrec->contextid = $this->task->get_contextid();
1046         // Get the version of the block
1047         $blockrec->version = $DB->get_field('block', 'version', array('name' => $this->task->get_blockname()));
1049         // Define sources
1051         $block->set_source_array(array($blockrec));
1053         $position->set_source_table('block_positions', array('blockinstanceid' => backup::VAR_PARENTID));
1055         // File anotations (for fileareas specified on each block)
1056         foreach ($this->task->get_fileareas() as $filearea) {
1057             $block->annotate_files('block_' . $this->task->get_blockname(), $filearea, null);
1058         }
1060         // Return the root element (block)
1061         return $block;
1062     }
1065 /**
1066  * structure step in charge of constructing the logs.xml file for all the log records found
1067  * in activity
1068  */
1069 class backup_activity_logs_structure_step extends backup_structure_step {
1071     protected function define_structure() {
1073         // Define each element separated
1075         $logs = new backup_nested_element('logs');
1077         $log = new backup_nested_element('log', array('id'), array(
1078             'time', 'userid', 'ip', 'module',
1079             'action', 'url', 'info'));
1081         // Build the tree
1083         $logs->add_child($log);
1085         // Define sources
1087         $log->set_source_table('log', array('cmid' => backup::VAR_MODID));
1089         // Annotations
1090         // NOTE: We don't annotate users from logs as far as they MUST be
1091         //       always annotated by the activity.
1093         // Return the root element (logs)
1095         return $logs;
1096     }
1099 /**
1100  * structure in charge of constructing the inforef.xml file for all the items we want
1101  * to have referenced there (users, roles, files...)
1102  */
1103 class backup_inforef_structure_step extends backup_structure_step {
1105     protected function define_structure() {
1107         // Items we want to include in the inforef file.
1108         $items = backup_helper::get_inforef_itemnames();
1110         // Build the tree
1112         $inforef = new backup_nested_element('inforef');
1114         // For each item, conditionally, if there are already records, build element
1115         foreach ($items as $itemname) {
1116             if (backup_structure_dbops::annotations_exist($this->get_backupid(), $itemname)) {
1117                 $elementroot = new backup_nested_element($itemname . 'ref');
1118                 $element = new backup_nested_element($itemname, array(), array('id'));
1119                 $inforef->add_child($elementroot);
1120                 $elementroot->add_child($element);
1121                 $element->set_source_sql("
1122                     SELECT itemid AS id
1123                      FROM {backup_ids_temp}
1124                     WHERE backupid = ?
1125                       AND itemname = ?",
1126                    array(backup::VAR_BACKUPID, backup_helper::is_sqlparam($itemname)));
1127             }
1128         }
1130         // We don't annotate anything there, but rely in the next step
1131         // (move_inforef_annotations_to_final) that will change all the
1132         // already saved 'inforref' entries to their 'final' annotations.
1133         return $inforef;
1134     }
1137 /**
1138  * This step will get all the annotations already processed to inforef.xml file and
1139  * transform them into 'final' annotations.
1140  */
1141 class move_inforef_annotations_to_final extends backup_execution_step {
1143     protected function define_execution() {
1145         // Items we want to include in the inforef file
1146         $items = backup_helper::get_inforef_itemnames();
1147         foreach ($items as $itemname) {
1148             // Delegate to dbops
1149             backup_structure_dbops::move_annotations_to_final($this->get_backupid(), $itemname);
1150         }
1151     }
1154 /**
1155  * structure in charge of constructing the files.xml file with all the
1156  * annotated (final) files along the process. At, the same time, and
1157  * using one specialised nested_element, will copy them form moodle storage
1158  * to backup storage
1159  */
1160 class backup_final_files_structure_step extends backup_structure_step {
1162     protected function define_structure() {
1164         // Define elements
1166         $files = new backup_nested_element('files');
1168         $file = new file_nested_element('file', array('id'), array(
1169             'contenthash', 'contextid', 'component', 'filearea', 'itemid',
1170             'filepath', 'filename', 'userid', 'filesize',
1171             'mimetype', 'status', 'timecreated', 'timemodified',
1172             'source', 'author', 'license', 'sortorder'));
1174         // Build the tree
1176         $files->add_child($file);
1178         // Define sources
1180         $file->set_source_sql("SELECT f.*
1181                                  FROM {files} f
1182                                  JOIN {backup_ids_temp} bi ON f.id = bi.itemid
1183                                 WHERE bi.backupid = ?
1184                                   AND bi.itemname = 'filefinal'", array(backup::VAR_BACKUPID));
1186         return $files;
1187     }
1190 /**
1191  * Structure step in charge of creating the main moodle_backup.xml file
1192  * where all the information related to the backup, settings, license and
1193  * other information needed on restore is added*/
1194 class backup_main_structure_step extends backup_structure_step {
1196     protected function define_structure() {
1198         global $CFG;
1200         $info = array();
1202         $info['name'] = $this->get_setting_value('filename');
1203         $info['moodle_version'] = $CFG->version;
1204         $info['moodle_release'] = $CFG->release;
1205         $info['backup_version'] = $CFG->backup_version;
1206         $info['backup_release'] = $CFG->backup_release;
1207         $info['backup_date']    = time();
1208         $info['backup_uniqueid']= $this->get_backupid();
1209         $info['mnet_remoteusers']=backup_controller_dbops::backup_includes_mnet_remote_users($this->get_backupid());
1210         $info['original_wwwroot']=$CFG->wwwroot;
1211         $info['original_site_identifier_hash'] = md5(get_site_identifier());
1212         $info['original_course_id'] = $this->get_courseid();
1213         $originalcourseinfo = backup_controller_dbops::backup_get_original_course_info($this->get_courseid());
1214         $info['original_course_fullname']  = $originalcourseinfo->fullname;
1215         $info['original_course_shortname'] = $originalcourseinfo->shortname;
1216         $info['original_course_startdate'] = $originalcourseinfo->startdate;
1217         $info['original_course_contextid'] = get_context_instance(CONTEXT_COURSE, $this->get_courseid())->id;
1218         $info['original_system_contextid'] = get_context_instance(CONTEXT_SYSTEM)->id;
1220         // Get more information from controller
1221         list($dinfo, $cinfo, $sinfo) = backup_controller_dbops::get_moodle_backup_information($this->get_backupid());
1223         // Define elements
1225         $moodle_backup = new backup_nested_element('moodle_backup');
1227         $information = new backup_nested_element('information', null, array(
1228             'name', 'moodle_version', 'moodle_release', 'backup_version',
1229             'backup_release', 'backup_date', 'mnet_remoteusers', 'original_wwwroot',
1230             'original_site_identifier_hash', 'original_course_id',
1231             'original_course_fullname', 'original_course_shortname', 'original_course_startdate',
1232             'original_course_contextid', 'original_system_contextid'));
1234         $details = new backup_nested_element('details');
1236         $detail = new backup_nested_element('detail', array('backup_id'), array(
1237             'type', 'format', 'interactive', 'mode',
1238             'execution', 'executiontime'));
1240         $contents = new backup_nested_element('contents');
1242         $activities = new backup_nested_element('activities');
1244         $activity = new backup_nested_element('activity', null, array(
1245             'moduleid', 'sectionid', 'modulename', 'title',
1246             'directory'));
1248         $sections = new backup_nested_element('sections');
1250         $section = new backup_nested_element('section', null, array(
1251             'sectionid', 'title', 'directory'));
1253         $course = new backup_nested_element('course', null, array(
1254             'courseid', 'title', 'directory'));
1256         $settings = new backup_nested_element('settings');
1258         $setting = new backup_nested_element('setting', null, array(
1259             'level', 'section', 'activity', 'name', 'value'));
1261         // Build the tree
1263         $moodle_backup->add_child($information);
1265         $information->add_child($details);
1266         $details->add_child($detail);
1268         $information->add_child($contents);
1269         if (!empty($cinfo['activities'])) {
1270             $contents->add_child($activities);
1271             $activities->add_child($activity);
1272         }
1273         if (!empty($cinfo['sections'])) {
1274             $contents->add_child($sections);
1275             $sections->add_child($section);
1276         }
1277         if (!empty($cinfo['course'])) {
1278             $contents->add_child($course);
1279         }
1281         $information->add_child($settings);
1282         $settings->add_child($setting);
1285         // Set the sources
1287         $information->set_source_array(array((object)$info));
1289         $detail->set_source_array($dinfo);
1291         $activity->set_source_array($cinfo['activities']);
1293         $section->set_source_array($cinfo['sections']);
1295         $course->set_source_array($cinfo['course']);
1297         $setting->set_source_array($sinfo);
1299         // Prepare some information to be sent to main moodle_backup.xml file
1300         return $moodle_backup;
1301     }
1305 /**
1306  * Execution step that will generate the final zip file with all the contents
1307  */
1308 class backup_zip_contents extends backup_execution_step {
1310     protected function define_execution() {
1312         // Get basepath
1313         $basepath = $this->get_basepath();
1315         // Get the list of files in directory
1316         $filestemp = get_directory_list($basepath, '', false, true, true);
1317         $files = array();
1318         foreach ($filestemp as $file) { // Add zip paths and fs paths to all them
1319             $files[$file] = $basepath . '/' . $file;
1320         }
1322         // Add the log file if exists
1323         $logfilepath = $basepath . '.log';
1324         if (file_exists($logfilepath)) {
1325              $files['moodle_backup.log'] = $logfilepath;
1326         }
1328         // Calculate the zip fullpath (in OS temp area it's always backup.zip)
1329         $zipfile = $basepath . '/backup.zip';
1331         // Get the zip packer
1332         $zippacker = get_file_packer('application/zip');
1334         // Zip files
1335         $zippacker->archive_to_pathname($files, $zipfile);
1336     }
1339 /**
1340  * This step will send the generated backup file to its final destination
1341  */
1342 class backup_store_backup_file extends backup_execution_step {
1344     protected function define_execution() {
1346         // Get basepath
1347         $basepath = $this->get_basepath();
1349         // Calculate the zip fullpath (in OS temp area it's always backup.zip)
1350         $zipfile = $basepath . '/backup.zip';
1352         // Perform storage and return it (TODO: shouldn't be array but proper result object)
1353         return array('backup_destination' => backup_helper::store_backup_file($this->get_backupid(), $zipfile));
1354     }
1358 /**
1359  * This step will search for all the activity (not calculations, categories nor aggregations) grade items
1360  * and put them to the backup_ids tables, to be used later as base to backup them
1361  */
1362 class backup_activity_grade_items_to_ids extends backup_execution_step {
1364     protected function define_execution() {
1366         // Fetch all activity grade items
1367         if ($items = grade_item::fetch_all(array(
1368                          'itemtype' => 'mod', 'itemmodule' => $this->task->get_modulename(),
1369                          'iteminstance' => $this->task->get_activityid(), 'courseid' => $this->task->get_courseid()))) {
1370             // Annotate them in backup_ids
1371             foreach ($items as $item) {
1372                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grade_item', $item->id);
1373             }
1374         }
1375     }
1378 /**
1379  * This step will annotate all the groups belonging to already annotated groupings
1380  */
1381 class backup_annotate_groups_from_groupings extends backup_execution_step {
1383     protected function define_execution() {
1384         global $DB;
1386         // Fetch all the annotated groupings
1387         if ($groupings = $DB->get_records('backup_ids_temp', array(
1388                 'backupid' => $this->get_backupid(), 'itemname' => 'grouping'))) {
1389             foreach ($groupings as $grouping) {
1390                 if ($groups = $DB->get_records('groupings_groups', array(
1391                         'groupingid' => $grouping->itemid))) {
1392                     foreach ($groups as $group) {
1393                         backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->groupid);
1394                     }
1395                 }
1396             }
1397         }
1398     }
1401 /**
1402  * This step will annotate all the scales belonging to already annotated outcomes
1403  */
1404 class backup_annotate_scales_from_outcomes extends backup_execution_step {
1406     protected function define_execution() {
1407         global $DB;
1409         // Fetch all the annotated outcomes
1410         if ($outcomes = $DB->get_records('backup_ids_temp', array(
1411                 'backupid' => $this->get_backupid(), 'itemname' => 'outcome'))) {
1412             foreach ($outcomes as $outcome) {
1413                 if ($scale = $DB->get_record('grade_outcomes', array(
1414                         'id' => $outcome->itemid))) {
1415                     // Annotate as scalefinal because it's > 0
1416                     backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'scalefinal', $scale->scaleid);
1417                 }
1418             }
1419         }
1420     }
1423 /**
1424  * This step will generate all the file  annotations for the already
1425  * annotated (final) users. Need to do this here because each user
1426  * has its own context and structure tasks only are able to handle
1427  * one context. Also, this step will guarantee that every user has
1428  * its context created (req for other steps)
1429  */
1430 class backup_annotate_all_user_files extends backup_execution_step {
1432     protected function define_execution() {
1433         global $DB;
1435         // List of fileareas we are going to annotate
1436         $fileareas = array('profile', 'icon');
1438         if ($this->get_setting_value('user_files')) { // private files only if enabled in settings
1439             $fileareas[] = 'private';
1440         }
1442         // Fetch all annotated (final) users
1443         $rs = $DB->get_recordset('backup_ids_temp', array(
1444             'backupid' => $this->get_backupid(), 'itemname' => 'userfinal'));
1445         foreach ($rs as $record) {
1446             $userid = $record->itemid;
1447             $userctxid = get_context_instance(CONTEXT_USER, $userid)->id;
1448             // Proceed with every user filearea
1449             foreach ($fileareas as $filearea) {
1450                 // We don't need to specify itemid ($userid - 5th param) as far as by
1451                 // context we can get all the associated files. See MDL-22092
1452                 backup_structure_dbops::annotate_files($this->get_backupid(), $userctxid, 'user', $filearea, null);
1453             }
1454         }
1455         $rs->close();
1456     }
1459 /**
1460  * structure step in charge of constructing the grades.xml file for all the grade items
1461  * and letters related to one activity
1462  */
1463 class backup_activity_grades_structure_step extends backup_structure_step {
1465     protected function define_structure() {
1467         // To know if we are including userinfo
1468         $userinfo = $this->get_setting_value('userinfo');
1470         // Define each element separated
1472         $book = new backup_nested_element('activity_gradebook');
1474         $items = new backup_nested_element('grade_items');
1476         $item = new backup_nested_element('grade_item', array('id'), array(
1477             'categoryid', 'itemname', 'itemtype', 'itemmodule',
1478             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
1479             'calculation', 'gradetype', 'grademax', 'grademin',
1480             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
1481             'plusfactor', 'aggregationcoef', 'sortorder', 'display',
1482             'decimals', 'hidden', 'locked', 'locktime',
1483             'needsupdate', 'timecreated', 'timemodified'));
1485         $grades = new backup_nested_element('grade_grades');
1487         $grade = new backup_nested_element('grade_grade', array('id'), array(
1488             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
1489             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
1490             'locked', 'locktime', 'exported', 'overridden',
1491             'excluded', 'feedback', 'feedbackformat', 'information',
1492             'informationformat', 'timecreated', 'timemodified'));
1494         $letters = new backup_nested_element('grade_letters');
1496         $letter = new backup_nested_element('grade_letter', 'id', array(
1497             'lowerboundary', 'letter'));
1499         // Build the tree
1501         $book->add_child($items);
1502         $items->add_child($item);
1504         $item->add_child($grades);
1505         $grades->add_child($grade);
1507         $book->add_child($letters);
1508         $letters->add_child($letter);
1510         // Define sources
1512         $item->set_source_sql("SELECT gi.*
1513                                FROM {grade_items} gi
1514                                JOIN {backup_ids_temp} bi ON gi.id = bi.itemid
1515                                WHERE bi.backupid = ?
1516                                AND bi.itemname = 'grade_item'", array(backup::VAR_BACKUPID));
1518         // This only happens if we are including user info
1519         if ($userinfo) {
1520             $grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
1521         }
1523         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
1525         // Annotations
1527         $item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
1528         $item->annotate_ids('outcome', 'outcomeid');
1530         $grade->annotate_ids('user', 'userid');
1531         $grade->annotate_ids('user', 'usermodified');
1533         // Return the root element (book)
1535         return $book;
1536     }