backup MDL-22254 Added backup and restore of course completion information
[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         $subpluginsdirs = get_plugin_list($subplugintype);
113         foreach ($subpluginsdirs as $name => $subpluginsdir) {
114             $classname = 'backup_' . $subplugintype . '_' . $name . '_subplugin';
115             $backupfile = $subpluginsdir . '/backup/moodle2/' . $classname . '.class.php';
116             if (file_exists($backupfile)) {
117                 require_once($backupfile);
118                 $backupsubplugin = new $classname($subplugintype, $name, $optigroup);
119                 // Add subplugin returned structure to optigroup
120                 $backupsubplugin->define_subplugin_structure($element->get_name());
121             }
122         }
123     }
125     /**
126      * Wraps any activity backup structure within the common 'activity' element
127      * that will include common to all activities information like id, context...
128      */
129     protected function prepare_activity_structure($activitystructure) {
131         // Create the wrap element
132         $activity = new backup_nested_element('activity', array('id', 'moduleid', 'modulename', 'contextid'), null);
134         // Build the tree
135         $activity->add_child($activitystructure);
137         // Set the source
138         $activityarr = array((object)array(
139             'id'         => $this->task->get_activityid(),
140             'moduleid'   => $this->task->get_moduleid(),
141             'modulename' => $this->task->get_modulename(),
142             'contextid'  => $this->task->get_contextid()));
144         $activity->set_source_array($activityarr);
146         // Return the root element (activity)
147         return $activity;
148     }
151 /**
152  * Abstract structure step, parent of all the block structure steps. Used to wrap the
153  * block structure definition within the main <block ...> tag
154  */
155 abstract class backup_block_structure_step extends backup_structure_step {
157     protected function prepare_block_structure($blockstructure) {
159         // Create the wrap element
160         $block = new backup_nested_element('block', array('id', 'blockname', 'contextid'), null);
162         // Build the tree
163         $block->add_child($blockstructure);
165         // Set the source
166         $blockarr = array((object)array(
167             'id'         => $this->task->get_blockid(),
168             'blockname'  => $this->task->get_blockname(),
169             'contextid'  => $this->task->get_contextid()));
171         $block->set_source_array($blockarr);
173         // Return the root element (block)
174         return $block;
175     }
178 /**
179  * structure step that will generate the module.xml file for the activity,
180  * accumulating various information about the activity, annotating groupings
181  * and completion/avail conf
182  */
183 class backup_module_structure_step extends backup_structure_step {
185     protected function define_structure() {
187         // Define each element separated
189         $module = new backup_nested_element('module', array('id', 'version'), array(
190             'modulename', 'sectionid', 'sectionnumber', 'idnumber',
191             'added', 'score', 'indent', 'visible',
192             'visibleold', 'groupmode', 'groupingid', 'groupmembersonly',
193             'completion', 'completiongradeitemnumber', 'completionview', 'completionexpected',
194             'availablefrom', 'availableuntil', 'showavailability'));
196         $availinfo = new backup_nested_element('availability_info');
197         $availability = new backup_nested_element('availability', array('id'), array(
198             'sourcecmid', 'requiredcompletion', 'gradeitemid', 'grademin', 'grademax'));
200         // Define the tree
201         $module->add_child($availinfo);
202         $availinfo->add_child($availability);
204         // Set the sources
206         $module->set_source_sql('
207             SELECT cm.*, m.version, m.name AS modulename, s.id AS sectionid, s.section AS sectionnumber
208               FROM {course_modules} cm
209               JOIN {modules} m ON m.id = cm.module
210               JOIN {course_sections} s ON s.id = cm.section
211              WHERE cm.id = ?', array(backup::VAR_MODID));
213         $availability->set_source_table('course_modules_availability', array('coursemoduleid' => backup::VAR_MODID));
215         // Define annotations
216         $module->annotate_ids('grouping', 'groupingid');
218         // Return the root element ($module)
219         return $module;
220     }
223 /**
224  * structure step that will generate the section.xml file for the section
225  * annotating files
226  */
227 class backup_section_structure_step extends backup_structure_step {
229     protected function define_structure() {
231         // Define each element separated
233         $section = new backup_nested_element('section', array('id'), array(
234             'number', 'name', 'summary', 'summaryformat', 'sequence', 'visible'));
236         // Define sources
238         $section->set_source_table('course_sections', array('id' => backup::VAR_SECTIONID));
240         // Aliases
241         $section->set_source_alias('section', 'number');
243         // Set annotations
244         $section->annotate_files('course', 'section', 'id');
246         return $section;
247     }
250 /**
251  * structure step that will generate the course.xml file for the course, including
252  * course category reference, tags, modules restriction information
253  * and some annotations (files & groupings)
254  */
255 class backup_course_structure_step extends backup_structure_step {
257     protected function define_structure() {
258         global $DB;
260         // Define each element separated
262         $course = new backup_nested_element('course', array('id', 'contextid'), array(
263             'shortname', 'fullname', 'idnumber',
264             'summary', 'summaryformat', 'format', 'showgrades',
265             'newsitems', 'startdate', 'numsections',
266             'marker', 'maxbytes', 'legacyfiles', 'showreports',
267             'visible', 'hiddensections', 'groupmode', 'groupmodeforce',
268             'defaultgroupingid', 'lang', 'theme',
269             'timecreated', 'timemodified',
270             'requested', 'restrictmodules',
271             'enablecompletion', 'completionstartonenrol', 'completionnotify'));
273         $category = new backup_nested_element('category', array('id'), array(
274             'name', 'description'));
276         $tags = new backup_nested_element('tags');
278         $tag = new backup_nested_element('tag', array('id'), array(
279             'name', 'rawname'));
281         $allowedmodules = new backup_nested_element('allowed_modules');
283         $module = new backup_nested_element('module', array(), array('modulename'));
285         // Build the tree
287         $course->add_child($category);
289         $course->add_child($tags);
290         $tags->add_child($tag);
292         $course->add_child($allowedmodules);
293         $allowedmodules->add_child($module);
295         // Set the sources
297         $courserec = $DB->get_record('course', array('id' => $this->task->get_courseid()));
298         $courserec->contextid = $this->task->get_contextid();
300         $course->set_source_array(array($courserec));
302         $categoryrec = $DB->get_record('course_categories', array('id' => $courserec->category));
304         $category->set_source_array(array($categoryrec));
306         $tag->set_source_sql('SELECT t.id, t.name, t.rawname
307                                 FROM {tag} t
308                                 JOIN {tag_instance} ti ON ti.tagid = t.id
309                                WHERE ti.itemtype = ?
310                                  AND ti.itemid = ?', array(
311                                      backup_helper::is_sqlparam('course'),
312                                      backup::VAR_PARENTID));
314         $module->set_source_sql('SELECT m.name AS modulename
315                                    FROM {modules} m
316                                    JOIN {course_allowed_modules} cam ON m.id = cam.module
317                                   WHERE course = ?', array(backup::VAR_COURSEID));
319         // Some annotations
321         $course->annotate_ids('grouping', 'defaultgroupingid');
323         $course->annotate_files('course', 'summary', null);
324         $course->annotate_files('course', 'legacy', null);
326         // Return root element ($course)
328         return $course;
329     }
332 /**
333  * structure step that will generate the enrolments.xml file for the given course
334  */
335 class backup_enrolments_structure_step extends backup_structure_step {
337     protected function define_structure() {
339         // To know if we are including users
340         $users = $this->get_setting_value('users');
342         // Define each element separated
344         $enrolments = new backup_nested_element('enrolments');
346         $enrols = new backup_nested_element('enrols');
348         $enrol = new backup_nested_element('enrol', array('id'), array(
349             'enrol', 'status', 'sortorder', 'name', 'enrolperiod', 'enrolstartdate',
350             'enrolenddate', 'expirynotify', 'expirytreshold', 'notifyall',
351             'password', 'cost', 'currency', 'roleid', 'customint1', 'customint2', 'customint3',
352             'customint4', 'customchar1', 'customchar2', 'customdec1', 'customdec2',
353             'customtext1', 'customtext2', 'timecreated', 'timemodified'));
355         $userenrolments = new backup_nested_element('user_enrolments');
357         $enrolment = new backup_nested_element('enrolment', array('id'), array(
358             'status', 'userid', 'timestart', 'timeend', 'modifierid',
359             'timemodified'));
361         // Build the tree
362         $enrolments->add_child($enrols);
363         $enrols->add_child($enrol);
364         $enrol->add_child($userenrolments);
365         $userenrolments->add_child($enrolment);
367         // Define sources
369         $enrol->set_source_table('enrol', array('courseid' => backup::VAR_COURSEID));
371         // User enrolments only added only if users included
372         if ($users) {
373             $enrolment->set_source_table('user_enrolments', array('enrolid' => backup::VAR_PARENTID));
374             $enrolment->annotate_ids('user', 'userid');
375         }
377         $enrol->annotate_ids('role', 'roleid');
379         //TODO: let plugins annotate custom fields too and add more children
381         return $enrolments;
382     }
385 /**
386  * structure step that will generate the roles.xml file for the given context, observing
387  * the role_assignments setting to know if that part needs to be included
388  */
389 class backup_roles_structure_step extends backup_structure_step {
391     protected function define_structure() {
393         // To know if we are including role assignments
394         $roleassignments = $this->get_setting_value('role_assignments');
396         // Define each element separated
398         $roles = new backup_nested_element('roles');
400         $overrides = new backup_nested_element('role_overrides');
402         $override = new backup_nested_element('override', array('id'), array(
403             'roleid', 'capability', 'permission', 'timemodified',
404             'modifierid'));
406         $assignments = new backup_nested_element('role_assignments');
408         $assignment = new backup_nested_element('assignment', array('id'), array(
409             'roleid', 'userid', 'timemodified', 'modifierid', 'component', 'itemid',
410             'sortorder'));
412         // Build the tree
413         $roles->add_child($overrides);
414         $roles->add_child($assignments);
416         $overrides->add_child($override);
417         $assignments->add_child($assignment);
419         // Define sources
421         $override->set_source_table('role_capabilities', array('contextid' => backup::VAR_CONTEXTID));
423         // Assignments only added if specified
424         if ($roleassignments) {
425             $assignment->set_source_table('role_assignments', array('contextid' => backup::VAR_CONTEXTID));
426         }
428         // Define id annotations
429         $override->annotate_ids('role', 'roleid');
431         $assignment->annotate_ids('role', 'roleid');
433         $assignment->annotate_ids('user', 'userid');
435         //TODO: how do we annotate the itemid? the meaning depends on the content of component table (skodak)
437         return $roles;
438     }
441 /**
442  * structure step that will generate the roles.xml containing the
443  * list of roles used along the whole backup process. Just raw
444  * list of used roles from role table
445  */
446 class backup_final_roles_structure_step extends backup_structure_step {
448     protected function define_structure() {
450         // Define elements
452         $rolesdef = new backup_nested_element('roles_definition');
454         $role = new backup_nested_element('role', array('id'), array(
455             'name', 'shortname', 'nameincourse', 'description',
456             'sortorder', 'archetype'));
458         // Build the tree
460         $rolesdef->add_child($role);
462         // Define sources
464         $role->set_source_sql("SELECT r.*, rn.name AS nameincourse
465                                  FROM {role} r
466                                  JOIN {backup_ids_temp} bi ON r.id = bi.itemid
467                             LEFT JOIN {role_names} rn ON r.id = rn.roleid AND rn.contextid = ?
468                                 WHERE bi.backupid = ?
469                                   AND bi.itemname = 'rolefinal'", array(backup::VAR_CONTEXTID, backup::VAR_BACKUPID));
471         // Return main element (rolesdef)
472         return $rolesdef;
473     }
476 /**
477  * structure step that will generate the scales.xml containing the
478  * list of scales used along the whole backup process.
479  */
480 class backup_final_scales_structure_step extends backup_structure_step {
482     protected function define_structure() {
484         // Define elements
486         $scalesdef = new backup_nested_element('scales_definition');
488         $scale = new backup_nested_element('scale', array('id'), array(
489             'courseid', 'userid', 'name', 'scale',
490             'description', 'descriptionformat', 'timemodified'));
492         // Build the tree
494         $scalesdef->add_child($scale);
496         // Define sources
498         $scale->set_source_sql("SELECT s.*
499                                   FROM {scale} s
500                                   JOIN {backup_ids_temp} bi ON s.id = bi.itemid
501                                  WHERE bi.backupid = ?
502                                    AND bi.itemname = 'scalefinal'", array(backup::VAR_BACKUPID));
504         // Annotate scale files (they store files in system context, so pass it instead of default one)
505         $scale->annotate_files('grade', 'scale', 'id', get_context_instance(CONTEXT_SYSTEM)->id);
507         // Return main element (scalesdef)
508         return $scalesdef;
509     }
512 /**
513  * structure step that will generate the outcomes.xml containing the
514  * list of outcomes used along the whole backup process.
515  */
516 class backup_final_outcomes_structure_step extends backup_structure_step {
518     protected function define_structure() {
520         // Define elements
522         $outcomesdef = new backup_nested_element('outcomes_definition');
524         $outcome = new backup_nested_element('outcome', array('id'), array(
525             'courseid', 'userid', 'shortname', 'fullname',
526             'scaleid', 'description', 'descriptionformat', 'timecreated',
527             'timemodified','usermodified'));
529         // Build the tree
531         $outcomesdef->add_child($outcome);
533         // Define sources
535         $outcome->set_source_sql("SELECT o.*
536                                     FROM {grade_outcomes} o
537                                     JOIN {backup_ids_temp} bi ON o.id = bi.itemid
538                                    WHERE bi.backupid = ?
539                                      AND bi.itemname = 'outcomefinal'", array(backup::VAR_BACKUPID));
541         // Annotate outcome files (they store files in system context, so pass it instead of default one)
542         $outcome->annotate_files('grade', 'outcome', 'id', get_context_instance(CONTEXT_SYSTEM)->id);
544         // Return main element (outcomesdef)
545         return $outcomesdef;
546     }
549 /**
550  * structure step in charge of constructing the filters.xml file for all the filters found
551  * in activity
552  */
553 class backup_filters_structure_step extends backup_structure_step {
555     protected function define_structure() {
557         // Define each element separated
559         $filters = new backup_nested_element('filters');
561         $actives = new backup_nested_element('filter_actives');
563         $active = new backup_nested_element('filter_active', null, array('filter', 'active'));
565         $configs = new backup_nested_element('filter_configs');
567         $config = new backup_nested_element('filter_config', null, array('filter', 'name', 'value'));
569         // Build the tree
571         $filters->add_child($actives);
572         $filters->add_child($configs);
574         $actives->add_child($active);
575         $configs->add_child($config);
577         // Define sources
579         list($activearr, $configarr) = filter_get_all_local_settings($this->task->get_contextid());
581         $active->set_source_array($activearr);
582         $config->set_source_array($configarr);
584         // Return the root element (filters)
585         return $filters;
586     }
589 /**
590  * structure step in charge of constructing the comments.xml file for all the comments found
591  * in a given context
592  */
593 class backup_comments_structure_step extends backup_structure_step {
595     protected function define_structure() {
597         // Define each element separated
599         $comments = new backup_nested_element('comments');
601         $comment = new backup_nested_element('comment', array('id'), array(
602             'commentarea', 'itemid', 'content', 'format',
603             'userid', 'timecreated'));
605         // Build the tree
607         $comments->add_child($comment);
609         // Define sources
611         $comment->set_source_table('comments', array('contextid' => backup::VAR_CONTEXTID));
613         // Define id annotations
615         $comment->annotate_ids('user', 'userid');
617         // Return the root element (comments)
618         return $comments;
619     }
622 /**
623  * structure step in charge of constructing the gradebook.xml file for all the gradebook config in the course
624  * NOTE: the backup of the grade items themselves is handled by backup_activity_grades_structure_step
625  */
626 class backup_gradebook_structure_step extends backup_structure_step {
628     /**
629      * We need to decide conditionally, based on dynamic information
630      * about the execution of this step. Only will be executed if all
631      * the module gradeitems have been already included in backup
632      */
633     protected function execute_condition() {
634         return backup_plan_dbops::require_gradebook_backup($this->get_courseid(), $this->get_backupid());
635     }
637     protected function define_structure() {
639         // are we including user info?
640         $userinfo = $this->get_setting_value('users');
642         $gradebook = new backup_nested_element('gradebook');
644         //grade_letters are done in backup_activity_grades_structure_step()
646         //calculated grade items
647         $grade_items = new backup_nested_element('grade_items');
648         $grade_item = new backup_nested_element('grade_item', array('id'), array(
649             'categoryid', 'itemname', 'itemtype', 'itemmodule',
650             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
651             'calculation', 'gradetype', 'grademax', 'grademin',
652             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
653             'plusfactor', 'aggregationcoef', 'sortorder', 'display',
654             'decimals', 'hidden', 'locked', 'locktime',
655             'needsupdate', 'timecreated', 'timemodified'));
657         $grade_grades = new backup_nested_element('grade_grades');
658         $grade_grade = new backup_nested_element('grade_grade', array('id'), array(
659             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
660             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
661             'locked', 'locktime', 'exported', 'overridden',
662             'excluded', 'feedback', 'feedbackformat', 'information',
663             'informationformat', 'timecreated', 'timemodified'));
665         //grade_categories
666         $grade_categories = new backup_nested_element('grade_categories');
667         $grade_category   = new backup_nested_element('grade_category', array('id'), array(
668                 //'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'));
677         $grade_settings = new backup_nested_element('grade_settings');
678         $grade_setting = new backup_nested_element('grade_setting', 'id', array(
679             'name', 'value'));
682         // Build the tree
683         $gradebook->add_child($grade_categories);
684         $grade_categories->add_child($grade_category);
686         $gradebook->add_child($grade_items);
687         $grade_items->add_child($grade_item);
688         $grade_item->add_child($grade_grades);
689         $grade_grades->add_child($grade_grade);
691         $gradebook->add_child($letters);
692         $letters->add_child($letter);
694         $gradebook->add_child($grade_settings);
695         $grade_settings->add_child($grade_setting);
697         // Define sources
699         //Include manual, category and the course grade item
700         $grade_items_sql ="SELECT * FROM {grade_items}
701                            WHERE courseid = :courseid
702                            AND (itemtype='manual' OR itemtype='course' OR itemtype='category')";
703         $grade_items_params = array('courseid'=>backup::VAR_COURSEID);
704         $grade_item->set_source_sql($grade_items_sql, $grade_items_params);
706         if ($userinfo) {
707             $grade_grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
708         }
710         $grade_category_sql = "SELECT gc.*, gi.sortorder
711                                FROM {grade_categories} gc
712                                JOIN {grade_items} gi ON (gi.iteminstance = gc.id)
713                                WHERE gc.courseid = :courseid
714                                AND (gi.itemtype='course' OR gi.itemtype='category')
715                                ORDER BY gc.parent ASC";//need parent categories before their children
716         $grade_category_params = array('courseid'=>backup::VAR_COURSEID);
717         $grade_category->set_source_sql($grade_category_sql, $grade_category_params);
719         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
721         $grade_setting->set_source_table('grade_settings', array('courseid' => backup::VAR_COURSEID));
723         // Annotations (both as final as far as they are going to be exported in next steps)
724         $grade_item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
725         $grade_item->annotate_ids('outcomefinal', 'outcomeid');
727         //just in case there are any users not already annotated by the activities
728         $grade_grade->annotate_ids('userfinal', 'userid');
730         // Return the root element
731         return $gradebook;
732     }
735 /**
736  * structure step in charge if constructing the completion.xml file for all the users completion
737  * information in a given activity
738  */
739 class backup_userscompletion_structure_step extends backup_structure_step {
741     protected function define_structure() {
743         // Define each element separated
745         $completions = new backup_nested_element('completions');
747         $completion = new backup_nested_element('completion', array('id'), array(
748             'userid', 'completionstate', 'viewed', 'timemodified'));
750         // Build the tree
752         $completions->add_child($completion);
754         // Define sources
756         $completion->set_source_table('course_modules_completion', array('coursemoduleid' => backup::VAR_MODID));
758         // Define id annotations
760         $completion->annotate_ids('user', 'userid');
762         // Return the root element (completions)
763         return $completions;
764     }
767 /**
768  * structure step in charge of constructing the main groups.xml file for all the groups and
769  * groupings information already annotated
770  */
771 class backup_groups_structure_step extends backup_structure_step {
773     protected function define_structure() {
775         // To know if we are including users
776         $users = $this->get_setting_value('users');
778         // Define each element separated
780         $groups = new backup_nested_element('groups');
782         $group = new backup_nested_element('group', array('id'), array(
783             'name', 'description', 'descriptionformat', 'enrolmentkey',
784             'picture', 'hidepicture', 'timecreated', 'timemodified'));
786         $members = new backup_nested_element('group_members');
788         $member = new backup_nested_element('group_member', array('id'), array(
789             'userid', 'timeadded'));
791         $groupings = new backup_nested_element('groupings');
793         $grouping = new backup_nested_element('grouping', 'id', array(
794             'name', 'description', 'descriptionformat', 'configdata',
795             'timecreated', 'timemodified'));
797         $groupinggroups = new backup_nested_element('grouping_groups');
799         $groupinggroup = new backup_nested_element('grouping_group', array('id'), array(
800             'groupid', 'timeadded'));
802         // Build the tree
804         $groups->add_child($group);
805         $groups->add_child($groupings);
807         $group->add_child($members);
808         $members->add_child($member);
810         $groupings->add_child($grouping);
811         $grouping->add_child($groupinggroups);
812         $groupinggroups->add_child($groupinggroup);
814         // Define sources
816         $group->set_source_sql("
817             SELECT g.*
818               FROM {groups} g
819               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
820              WHERE bi.backupid = ?
821                AND bi.itemname = 'groupfinal'", array(backup::VAR_BACKUPID));
823         // This only happens if we are including users
824         if ($users) {
825             $member->set_source_table('groups_members', array('groupid' => backup::VAR_PARENTID));
826         }
828         $grouping->set_source_sql("
829             SELECT g.*
830               FROM {groupings} g
831               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
832              WHERE bi.backupid = ?
833                AND bi.itemname = 'groupingfinal'", array(backup::VAR_BACKUPID));
835         $groupinggroup->set_source_table('groupings_groups', array('groupingid' => backup::VAR_PARENTID));
837         // Define id annotations (as final)
839         $member->annotate_ids('userfinal', 'userid');
841         // Define file annotations
843         $group->annotate_files('group', 'description', 'id');
844         $group->annotate_files('group', 'icon', 'id');
845         $grouping->annotate_files('grouping', 'description', 'id');
847         // Return the root element (groups)
848         return $groups;
849     }
852 /**
853  * structure step in charge of constructing the main users.xml file for all the users already
854  * annotated (final). Includes custom profile fields, preferences, tags, role assignments and
855  * overrides.
856  */
857 class backup_users_structure_step extends backup_structure_step {
859     protected function define_structure() {
860         global $CFG;
862         // To know if we are anonymizing users
863         $anonymize = $this->get_setting_value('anonymize');
864         // To know if we are including role assignments
865         $roleassignments = $this->get_setting_value('role_assignments');
867         // Define each element separated
869         $users = new backup_nested_element('users');
871         // Create the array of user fields by hand, as far as we have various bits to control
872         // anonymize option, password backup, mnethostid...
874         // First, the fields not needing anonymization nor special handling
875         $normalfields = array(
876             'confirmed', 'policyagreed', 'deleted',
877             'lang', 'theme', 'timezone', 'firstaccess',
878             'lastaccess', 'lastlogin', 'currentlogin',
879             'mailformat', 'maildigest', 'maildisplay', 'htmleditor',
880             'ajax', 'autosubscribe', 'trackforums', 'timecreated',
881             'timemodified', 'trustbitmask', 'screenreader');
883         // Then, the fields potentially needing anonymization
884         $anonfields = array(
885             'username', 'idnumber', 'firstname', 'lastname',
886             'email', 'emailstop', 'icq', 'skype',
887             'yahoo', 'aim', 'msn', 'phone1',
888             'phone2', 'institution', 'department', 'address',
889             'city', 'country', 'lastip', 'picture',
890             'url', 'description', 'descriptionformat', 'imagealt', 'auth');
892         // Add anonymized fields to $userfields with custom final element
893         foreach ($anonfields as $field) {
894             if ($anonymize) {
895                 $userfields[] = new anonymizer_final_element($field);
896             } else {
897                 $userfields[] = $field; // No anonymization, normally added
898             }
899         }
901         // mnethosturl requires special handling (custom final element)
902         $userfields[] = new mnethosturl_final_element('mnethosturl');
904         // password added conditionally
905         if (!empty($CFG->includeuserpasswordsinbackup)) {
906             $userfields[] = 'password';
907         }
909         // Merge all the fields
910         $userfields = array_merge($userfields, $normalfields);
912         $user = new backup_nested_element('user', array('id', 'contextid'), $userfields);
914         $customfields = new backup_nested_element('custom_fields');
916         $customfield = new backup_nested_element('custom_field', array('id'), array(
917             'field_name', 'field_type', 'field_data'));
919         $tags = new backup_nested_element('tags');
921         $tag = new backup_nested_element('tag', array('id'), array(
922             'name', 'rawname'));
924         $preferences = new backup_nested_element('preferences');
926         $preference = new backup_nested_element('preference', array('id'), array(
927             'name', 'value'));
929         $roles = new backup_nested_element('roles');
931         $overrides = new backup_nested_element('role_overrides');
933         $override = new backup_nested_element('override', array('id'), array(
934             'roleid', 'capability', 'permission', 'timemodified',
935             'modifierid'));
937         $assignments = new backup_nested_element('role_assignments');
939         $assignment = new backup_nested_element('assignment', array('id'), array(
940             'roleid', 'userid', 'timemodified', 'modifierid', 'component', //TODO: MDL-22793 add itemid here
941             'sortorder'));
943         // Build the tree
945         $users->add_child($user);
947         $user->add_child($customfields);
948         $customfields->add_child($customfield);
950         $user->add_child($tags);
951         $tags->add_child($tag);
953         $user->add_child($preferences);
954         $preferences->add_child($preference);
956         $user->add_child($roles);
958         $roles->add_child($overrides);
959         $roles->add_child($assignments);
961         $overrides->add_child($override);
962         $assignments->add_child($assignment);
964         // Define sources
966         $user->set_source_sql('SELECT u.*, c.id AS contextid, m.wwwroot AS mnethosturl
967                                  FROM {user} u
968                                  JOIN {backup_ids_temp} bi ON bi.itemid = u.id
969                                  JOIN {context} c ON c.instanceid = u.id
970                             LEFT JOIN {mnet_host} m ON m.id = u.mnethostid
971                                 WHERE bi.backupid = ?
972                                   AND bi.itemname = ?
973                                   AND c.contextlevel = ?', array(
974                                       backup_helper::is_sqlparam($this->get_backupid()),
975                                       backup_helper::is_sqlparam('userfinal'),
976                                       backup_helper::is_sqlparam(CONTEXT_USER)));
978         // All the rest on information is only added if we arent
979         // in an anonymized backup
980         if (!$anonymize) {
981             $customfield->set_source_sql('SELECT f.id, f.shortname, f.datatype, d.data
982                                             FROM {user_info_field} f
983                                             JOIN {user_info_data} d ON d.fieldid = f.id
984                                            WHERE d.userid = ?', array(backup::VAR_PARENTID));
986             $customfield->set_source_alias('shortname', 'field_name');
987             $customfield->set_source_alias('datatype',  'field_type');
988             $customfield->set_source_alias('data',      'field_data');
990             $tag->set_source_sql('SELECT t.id, t.name, t.rawname
991                                     FROM {tag} t
992                                     JOIN {tag_instance} ti ON ti.tagid = t.id
993                                    WHERE ti.itemtype = ?
994                                      AND ti.itemid = ?', array(
995                                          backup_helper::is_sqlparam('user'),
996                                          backup::VAR_PARENTID));
998             $preference->set_source_table('user_preferences', array('userid' => backup::VAR_PARENTID));
1000             $override->set_source_table('role_capabilities', array('contextid' => '/users/user/contextid'));
1002             // Assignments only added if specified
1003             if ($roleassignments) {
1004                 $assignment->set_source_table('role_assignments', array('contextid' => '/users/user/contextid'));
1005             }
1007             // Define id annotations (as final)
1008             $override->annotate_ids('rolefinal', 'roleid');
1009         }
1011         // Return root element (users)
1012         return $users;
1013     }
1016 /**
1017  * structure step in charge of constructing the block.xml file for one
1018  * given block (instance and positions). If the block has custom DB structure
1019  * that will go to a separate file (different step defined in block class)
1020  */
1021 class backup_block_instance_structure_step extends backup_structure_step {
1023     protected function define_structure() {
1024         global $DB;
1026         // Define each element separated
1028         $block = new backup_nested_element('block', array('id', 'contextid', 'version'), array(
1029             'blockname', 'parentcontextid', 'showinsubcontexts', 'pagetypepattern',
1030             'subpagepattern', 'defaultregion', 'defaultweight', 'configdata'));
1032         $positions = new backup_nested_element('block_positions');
1034         $position = new backup_nested_element('block_position', array('id'), array(
1035             'contextid', 'pagetype', 'subpage', 'visible',
1036             'region', 'weight'));
1038         // Build the tree
1040         $block->add_child($positions);
1041         $positions->add_child($position);
1043         // Transform configdata information if needed (process links and friends)
1044         $blockrec = $DB->get_record('block_instances', array('id' => $this->task->get_blockid()));
1045         if ($attrstotransform = $this->task->get_configdata_encoded_attributes()) {
1046             $configdata = (array)unserialize(base64_decode($blockrec->configdata));
1047             foreach ($configdata as $attribute => $value) {
1048                 if (in_array($attribute, $attrstotransform)) {
1049                     $configdata[$attribute] = $this->contenttransformer->process($value);
1050                 }
1051             }
1052             $blockrec->configdata = base64_encode(serialize((object)$configdata));
1053         }
1054         $blockrec->contextid = $this->task->get_contextid();
1055         // Get the version of the block
1056         $blockrec->version = $DB->get_field('block', 'version', array('name' => $this->task->get_blockname()));
1058         // Define sources
1060         $block->set_source_array(array($blockrec));
1062         $position->set_source_table('block_positions', array('blockinstanceid' => backup::VAR_PARENTID));
1064         // File anotations (for fileareas specified on each block)
1065         foreach ($this->task->get_fileareas() as $filearea) {
1066             $block->annotate_files('block_' . $this->task->get_blockname(), $filearea, null);
1067         }
1069         // Return the root element (block)
1070         return $block;
1071     }
1074 /**
1075  * structure step in charge of constructing the logs.xml file for all the log records found
1076  * in activity
1077  */
1078 class backup_activity_logs_structure_step extends backup_structure_step {
1080     protected function define_structure() {
1082         // Define each element separated
1084         $logs = new backup_nested_element('logs');
1086         $log = new backup_nested_element('log', array('id'), array(
1087             'time', 'userid', 'ip', 'module',
1088             'action', 'url', 'info'));
1090         // Build the tree
1092         $logs->add_child($log);
1094         // Define sources
1096         $log->set_source_table('log', array('cmid' => backup::VAR_MODID));
1098         // Annotations
1099         // NOTE: We don't annotate users from logs as far as they MUST be
1100         //       always annotated by the activity.
1102         // Return the root element (logs)
1104         return $logs;
1105     }
1108 /**
1109  * structure in charge of constructing the inforef.xml file for all the items we want
1110  * to have referenced there (users, roles, files...)
1111  */
1112 class backup_inforef_structure_step extends backup_structure_step {
1114     protected function define_structure() {
1116         // Items we want to include in the inforef file.
1117         $items = backup_helper::get_inforef_itemnames();
1119         // Build the tree
1121         $inforef = new backup_nested_element('inforef');
1123         // For each item, conditionally, if there are already records, build element
1124         foreach ($items as $itemname) {
1125             if (backup_structure_dbops::annotations_exist($this->get_backupid(), $itemname)) {
1126                 $elementroot = new backup_nested_element($itemname . 'ref');
1127                 $element = new backup_nested_element($itemname, array(), array('id'));
1128                 $inforef->add_child($elementroot);
1129                 $elementroot->add_child($element);
1130                 $element->set_source_sql("
1131                     SELECT itemid AS id
1132                      FROM {backup_ids_temp}
1133                     WHERE backupid = ?
1134                       AND itemname = ?",
1135                    array(backup::VAR_BACKUPID, backup_helper::is_sqlparam($itemname)));
1136             }
1137         }
1139         // We don't annotate anything there, but rely in the next step
1140         // (move_inforef_annotations_to_final) that will change all the
1141         // already saved 'inforref' entries to their 'final' annotations.
1142         return $inforef;
1143     }
1146 /**
1147  * This step will get all the annotations already processed to inforef.xml file and
1148  * transform them into 'final' annotations.
1149  */
1150 class move_inforef_annotations_to_final extends backup_execution_step {
1152     protected function define_execution() {
1154         // Items we want to include in the inforef file
1155         $items = backup_helper::get_inforef_itemnames();
1156         foreach ($items as $itemname) {
1157             // Delegate to dbops
1158             backup_structure_dbops::move_annotations_to_final($this->get_backupid(), $itemname);
1159         }
1160     }
1163 /**
1164  * structure in charge of constructing the files.xml file with all the
1165  * annotated (final) files along the process. At, the same time, and
1166  * using one specialised nested_element, will copy them form moodle storage
1167  * to backup storage
1168  */
1169 class backup_final_files_structure_step extends backup_structure_step {
1171     protected function define_structure() {
1173         // Define elements
1175         $files = new backup_nested_element('files');
1177         $file = new file_nested_element('file', array('id'), array(
1178             'contenthash', 'contextid', 'component', 'filearea', 'itemid',
1179             'filepath', 'filename', 'userid', 'filesize',
1180             'mimetype', 'status', 'timecreated', 'timemodified',
1181             'source', 'author', 'license', 'sortorder'));
1183         // Build the tree
1185         $files->add_child($file);
1187         // Define sources
1189         $file->set_source_sql("SELECT f.*
1190                                  FROM {files} f
1191                                  JOIN {backup_ids_temp} bi ON f.id = bi.itemid
1192                                 WHERE bi.backupid = ?
1193                                   AND bi.itemname = 'filefinal'", array(backup::VAR_BACKUPID));
1195         return $files;
1196     }
1199 /**
1200  * Structure step in charge of creating the main moodle_backup.xml file
1201  * where all the information related to the backup, settings, license and
1202  * other information needed on restore is added*/
1203 class backup_main_structure_step extends backup_structure_step {
1205     protected function define_structure() {
1207         global $CFG;
1209         $info = array();
1211         $info['name'] = $this->get_setting_value('filename');
1212         $info['moodle_version'] = $CFG->version;
1213         $info['moodle_release'] = $CFG->release;
1214         $info['backup_version'] = $CFG->backup_version;
1215         $info['backup_release'] = $CFG->backup_release;
1216         $info['backup_date']    = time();
1217         $info['backup_uniqueid']= $this->get_backupid();
1218         $info['mnet_remoteusers']=backup_controller_dbops::backup_includes_mnet_remote_users($this->get_backupid());
1219         $info['original_wwwroot']=$CFG->wwwroot;
1220         $info['original_site_identifier_hash'] = md5(get_site_identifier());
1221         $info['original_course_id'] = $this->get_courseid();
1222         $originalcourseinfo = backup_controller_dbops::backup_get_original_course_info($this->get_courseid());
1223         $info['original_course_fullname']  = $originalcourseinfo->fullname;
1224         $info['original_course_shortname'] = $originalcourseinfo->shortname;
1225         $info['original_course_startdate'] = $originalcourseinfo->startdate;
1226         $info['original_course_contextid'] = get_context_instance(CONTEXT_COURSE, $this->get_courseid())->id;
1227         $info['original_system_contextid'] = get_context_instance(CONTEXT_SYSTEM)->id;
1229         // Get more information from controller
1230         list($dinfo, $cinfo, $sinfo) = backup_controller_dbops::get_moodle_backup_information($this->get_backupid());
1232         // Define elements
1234         $moodle_backup = new backup_nested_element('moodle_backup');
1236         $information = new backup_nested_element('information', null, array(
1237             'name', 'moodle_version', 'moodle_release', 'backup_version',
1238             'backup_release', 'backup_date', 'mnet_remoteusers', 'original_wwwroot',
1239             'original_site_identifier_hash', 'original_course_id',
1240             'original_course_fullname', 'original_course_shortname', 'original_course_startdate',
1241             'original_course_contextid', 'original_system_contextid'));
1243         $details = new backup_nested_element('details');
1245         $detail = new backup_nested_element('detail', array('backup_id'), array(
1246             'type', 'format', 'interactive', 'mode',
1247             'execution', 'executiontime'));
1249         $contents = new backup_nested_element('contents');
1251         $activities = new backup_nested_element('activities');
1253         $activity = new backup_nested_element('activity', null, array(
1254             'moduleid', 'sectionid', 'modulename', 'title',
1255             'directory'));
1257         $sections = new backup_nested_element('sections');
1259         $section = new backup_nested_element('section', null, array(
1260             'sectionid', 'title', 'directory'));
1262         $course = new backup_nested_element('course', null, array(
1263             'courseid', 'title', 'directory'));
1265         $settings = new backup_nested_element('settings');
1267         $setting = new backup_nested_element('setting', null, array(
1268             'level', 'section', 'activity', 'name', 'value'));
1270         // Build the tree
1272         $moodle_backup->add_child($information);
1274         $information->add_child($details);
1275         $details->add_child($detail);
1277         $information->add_child($contents);
1278         if (!empty($cinfo['activities'])) {
1279             $contents->add_child($activities);
1280             $activities->add_child($activity);
1281         }
1282         if (!empty($cinfo['sections'])) {
1283             $contents->add_child($sections);
1284             $sections->add_child($section);
1285         }
1286         if (!empty($cinfo['course'])) {
1287             $contents->add_child($course);
1288         }
1290         $information->add_child($settings);
1291         $settings->add_child($setting);
1294         // Set the sources
1296         $information->set_source_array(array((object)$info));
1298         $detail->set_source_array($dinfo);
1300         $activity->set_source_array($cinfo['activities']);
1302         $section->set_source_array($cinfo['sections']);
1304         $course->set_source_array($cinfo['course']);
1306         $setting->set_source_array($sinfo);
1308         // Prepare some information to be sent to main moodle_backup.xml file
1309         return $moodle_backup;
1310     }
1314 /**
1315  * Execution step that will generate the final zip (.mbz) file with all the contents
1316  */
1317 class backup_zip_contents extends backup_execution_step {
1319     protected function define_execution() {
1321         // Get basepath
1322         $basepath = $this->get_basepath();
1324         // Get the list of files in directory
1325         $filestemp = get_directory_list($basepath, '', false, true, true);
1326         $files = array();
1327         foreach ($filestemp as $file) { // Add zip paths and fs paths to all them
1328             $files[$file] = $basepath . '/' . $file;
1329         }
1331         // Add the log file if exists
1332         $logfilepath = $basepath . '.log';
1333         if (file_exists($logfilepath)) {
1334              $files['moodle_backup.log'] = $logfilepath;
1335         }
1337         // Calculate the zip fullpath (in OS temp area it's always backup.mbz)
1338         $zipfile = $basepath . '/backup.mbz';
1340         // Get the zip packer
1341         $zippacker = get_file_packer('application/zip');
1343         // Zip files
1344         $zippacker->archive_to_pathname($files, $zipfile);
1345     }
1348 /**
1349  * This step will send the generated backup file to its final destination
1350  */
1351 class backup_store_backup_file extends backup_execution_step {
1353     protected function define_execution() {
1355         // Get basepath
1356         $basepath = $this->get_basepath();
1358         // Calculate the zip fullpath (in OS temp area it's always backup.mbz)
1359         $zipfile = $basepath . '/backup.mbz';
1361         // Perform storage and return it (TODO: shouldn't be array but proper result object)
1362         return array('backup_destination' => backup_helper::store_backup_file($this->get_backupid(), $zipfile));
1363     }
1367 /**
1368  * This step will search for all the activity (not calculations, categories nor aggregations) grade items
1369  * and put them to the backup_ids tables, to be used later as base to backup them
1370  */
1371 class backup_activity_grade_items_to_ids extends backup_execution_step {
1373     protected function define_execution() {
1375         // Fetch all activity grade items
1376         if ($items = grade_item::fetch_all(array(
1377                          'itemtype' => 'mod', 'itemmodule' => $this->task->get_modulename(),
1378                          'iteminstance' => $this->task->get_activityid(), 'courseid' => $this->task->get_courseid()))) {
1379             // Annotate them in backup_ids
1380             foreach ($items as $item) {
1381                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grade_item', $item->id);
1382             }
1383         }
1384     }
1387 /**
1388  * This step will annotate all the groups belonging to already annotated groupings
1389  */
1390 class backup_annotate_groups_from_groupings extends backup_execution_step {
1392     protected function define_execution() {
1393         global $DB;
1395         // Fetch all the annotated groupings
1396         if ($groupings = $DB->get_records('backup_ids_temp', array(
1397                 'backupid' => $this->get_backupid(), 'itemname' => 'grouping'))) {
1398             foreach ($groupings as $grouping) {
1399                 if ($groups = $DB->get_records('groupings_groups', array(
1400                         'groupingid' => $grouping->itemid))) {
1401                     foreach ($groups as $group) {
1402                         backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->groupid);
1403                     }
1404                 }
1405             }
1406         }
1407     }
1410 /**
1411  * This step will annotate all the scales belonging to already annotated outcomes
1412  */
1413 class backup_annotate_scales_from_outcomes extends backup_execution_step {
1415     protected function define_execution() {
1416         global $DB;
1418         // Fetch all the annotated outcomes
1419         if ($outcomes = $DB->get_records('backup_ids_temp', array(
1420                 'backupid' => $this->get_backupid(), 'itemname' => 'outcome'))) {
1421             foreach ($outcomes as $outcome) {
1422                 if ($scale = $DB->get_record('grade_outcomes', array(
1423                         'id' => $outcome->itemid))) {
1424                     // Annotate as scalefinal because it's > 0
1425                     backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'scalefinal', $scale->scaleid);
1426                 }
1427             }
1428         }
1429     }
1432 /**
1433  * This step will generate all the file  annotations for the already
1434  * annotated (final) users. Need to do this here because each user
1435  * has its own context and structure tasks only are able to handle
1436  * one context. Also, this step will guarantee that every user has
1437  * its context created (req for other steps)
1438  */
1439 class backup_annotate_all_user_files extends backup_execution_step {
1441     protected function define_execution() {
1442         global $DB;
1444         // List of fileareas we are going to annotate
1445         $fileareas = array('profile', 'icon');
1447         if ($this->get_setting_value('user_files')) { // private files only if enabled in settings
1448             $fileareas[] = 'private';
1449         }
1451         // Fetch all annotated (final) users
1452         $rs = $DB->get_recordset('backup_ids_temp', array(
1453             'backupid' => $this->get_backupid(), 'itemname' => 'userfinal'));
1454         foreach ($rs as $record) {
1455             $userid = $record->itemid;
1456             $userctxid = get_context_instance(CONTEXT_USER, $userid)->id;
1457             // Proceed with every user filearea
1458             foreach ($fileareas as $filearea) {
1459                 // We don't need to specify itemid ($userid - 5th param) as far as by
1460                 // context we can get all the associated files. See MDL-22092
1461                 backup_structure_dbops::annotate_files($this->get_backupid(), $userctxid, 'user', $filearea, null);
1462             }
1463         }
1464         $rs->close();
1465     }
1468 /**
1469  * structure step in charge of constructing the grades.xml file for all the grade items
1470  * and letters related to one activity
1471  */
1472 class backup_activity_grades_structure_step extends backup_structure_step {
1474     protected function define_structure() {
1476         // To know if we are including userinfo
1477         $userinfo = $this->get_setting_value('userinfo');
1479         // Define each element separated
1481         $book = new backup_nested_element('activity_gradebook');
1483         $items = new backup_nested_element('grade_items');
1485         $item = new backup_nested_element('grade_item', array('id'), array(
1486             'categoryid', 'itemname', 'itemtype', 'itemmodule',
1487             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
1488             'calculation', 'gradetype', 'grademax', 'grademin',
1489             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
1490             'plusfactor', 'aggregationcoef', 'sortorder', 'display',
1491             'decimals', 'hidden', 'locked', 'locktime',
1492             'needsupdate', 'timecreated', 'timemodified'));
1494         $grades = new backup_nested_element('grade_grades');
1496         $grade = new backup_nested_element('grade_grade', array('id'), array(
1497             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
1498             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
1499             'locked', 'locktime', 'exported', 'overridden',
1500             'excluded', 'feedback', 'feedbackformat', 'information',
1501             'informationformat', 'timecreated', 'timemodified'));
1503         $letters = new backup_nested_element('grade_letters');
1505         $letter = new backup_nested_element('grade_letter', 'id', array(
1506             'lowerboundary', 'letter'));
1508         // Build the tree
1510         $book->add_child($items);
1511         $items->add_child($item);
1513         $item->add_child($grades);
1514         $grades->add_child($grade);
1516         $book->add_child($letters);
1517         $letters->add_child($letter);
1519         // Define sources
1521         $item->set_source_sql("SELECT gi.*
1522                                FROM {grade_items} gi
1523                                JOIN {backup_ids_temp} bi ON gi.id = bi.itemid
1524                                WHERE bi.backupid = ?
1525                                AND bi.itemname = 'grade_item'", array(backup::VAR_BACKUPID));
1527         // This only happens if we are including user info
1528         if ($userinfo) {
1529             $grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
1530         }
1532         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
1534         // Annotations
1536         $item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
1537         $item->annotate_ids('outcome', 'outcomeid');
1539         $grade->annotate_ids('user', 'userid');
1540         $grade->annotate_ids('user', 'usermodified');
1542         // Return the root element (book)
1544         return $book;
1545     }
1548 /**
1549  * Backups up the course completion information for the course.
1550  */
1551 class backup_course_completion_structure_step extends backup_structure_step {
1553     protected function execute_condition() {
1554         // Check that all activities have been included
1555         if ($this->task->is_excluding_activities()) {
1556             return false;
1557         }
1558         return true;
1559     }
1561     /**
1562      * The structure of the course completion backup
1563      *
1564      * @return backup_nested_element
1565      */
1566     protected function define_structure() {
1568         // To know if we are including user completion info
1569         $userinfo = $this->get_setting_value('userscompletion');
1571         $cc = new backup_nested_element('course_completion');
1573         $criteria = new backup_nested_element('course_completion_criteria', array('id'), array(
1574             'course','criteriatype', 'module', 'moduleinstance', 'courseinstanceshortname', 'enrolperiod', 'timeend', 'gradepass', 'role'
1575         ));
1577         $criteriacompletions = new backup_nested_element('course_completion_crit_completions');
1579         $criteriacomplete = new backup_nested_element('course_completion_crit_compl', array('id'), array(
1580             'criteriaid', 'userid','gradefinal','unenrolled','deleted','timecompleted'
1581         ));
1583         $coursecompletions = new backup_nested_element('course_completions', array('id'), array(
1584             'userid', 'course', 'deleted', 'timenotified', 'timeenrolled','timestarted','timecompleted','reaggregate'
1585         ));
1587         $notify = new backup_nested_element('course_completion_notify', array('id'), array(
1588             'course','role','message','timesent'
1589         ));
1591         $aggregatemethod = new backup_nested_element('course_completion_aggr_methd', array('id'), array(
1592             'course','criteriatype','method','value'
1593         ));
1595         $cc->add_child($criteria);
1596             $criteria->add_child($criteriacompletions);
1597                 $criteriacompletions->add_child($criteriacomplete);
1598         $cc->add_child($coursecompletions);
1599         $cc->add_child($notify);
1600         $cc->add_child($aggregatemethod);
1602         // We need to get the courseinstances shortname rather than an ID for restore
1603         $criteria->set_source_sql("SELECT ccc.*, c.shortname courseinstanceshortname
1604                                    FROM {course_completion_criteria} ccc
1605                                    LEFT JOIN {course} c ON c.id = ccc.courseinstance
1606                                    WHERE ccc.course = ?", array(backup::VAR_COURSEID));
1609         $notify->set_source_table('course_completion_notify', array('course' => backup::VAR_COURSEID));
1610         $aggregatemethod->set_source_table('course_completion_aggr_methd', array('course' => backup::VAR_COURSEID));
1612         if ($userinfo) {
1613             $criteriacomplete->set_source_table('course_completion_crit_compl', array('criteriaid' => backup::VAR_PARENTID));
1614             $coursecompletions->set_source_table('course_completions', array('course' => backup::VAR_COURSEID));
1615         }
1617         $criteria->annotate_ids('role', 'role');
1618         $criteriacomplete->annotate_ids('user', 'userid');
1619         $coursecompletions->annotate_ids('user', 'userid');
1620         $notify->annotate_ids('role', 'role');
1622         return $cc;
1624     }