3 // This file is part of Moodle - http://moodle.org/
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.
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.
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/>.
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
26 * Define all the backup steps that will be used by common tasks in backup
30 * create the temp dir where backup/restore will happen,
31 * delete old directories and create temp ids table
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
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)
50 class drop_and_clean_temp_stuff extends backup_execution_step {
52 protected function define_execution() {
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
63 * Create the directory where all the task (activity/block...) information will be stored
65 class create_taskbasepath_directory extends backup_execution_step {
67 protected function define_execution() {
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);
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)
81 abstract class backup_activity_structure_step extends backup_structure_step {
84 * Add subplugin structure to any element in the activity backup tree
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)
92 protected function add_subplugin_structure($subplugintype, $element, $multiple) {
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());
101 include($subpluginsfile);
102 if (!array_key_exists($subplugintype, $subplugins)) {
103 throw new backup_step_exception('incorrect_subplugin_type', $subplugintype);
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
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());
127 * Wraps any activity backup structure within the common 'activity' element
128 * that will include common to all activities information like id, context...
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);
136 $activity->add_child($activitystructure);
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)
153 * Abstract structure step, parent of all the block structure steps. Used to wrap the
154 * block structure definition within the main <block ...> tag
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);
164 $block->add_child($blockstructure);
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)
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
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'));
202 $module->add_child($availinfo);
203 $availinfo->add_child($availability);
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)
225 * structure step that will generate the section.xml file for the section
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'));
239 $section->set_source_table('course_sections', array('id' => backup::VAR_SECTIONID));
242 $section->set_source_alias('section', 'number');
245 $section->annotate_files('course', 'section', 'id');
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)
256 class backup_course_structure_step extends backup_structure_step {
258 protected function define_structure() {
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'));
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(
282 $allowedmodules = new backup_nested_element('allowed_modules');
284 $module = new backup_nested_element('module', array('modulename'));
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);
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
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
317 JOIN {course_allowed_modules} cam ON m.id = cam.module
318 WHERE course = ?', array(backup::VAR_COURSEID));
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)
334 * structure step that will generate the enrolments.xml file for the given course
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',
363 $enrolments->add_child($enrols);
364 $enrols->add_child($enrol);
365 $enrol->add_child($userenrolments);
366 $userenrolments->add_child($enrolment);
370 $enrol->set_source_table('enrol', array('courseid' => backup::VAR_COURSEID));
372 // User enrolments only added only if users included
374 $enrolment->set_source_table('user_enrolments', array('enrolid' => backup::VAR_PARENTID));
375 $enrolment->annotate_ids('user', 'userid');
378 $enrol->annotate_ids('role', 'roleid');
380 //TODO: let plugins annotate custom fields too and add more children
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
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',
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',
414 $roles->add_child($overrides);
415 $roles->add_child($assignments);
417 $overrides->add_child($override);
418 $assignments->add_child($assignment);
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));
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)
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
447 class backup_final_roles_structure_step extends backup_structure_step {
449 protected function define_structure() {
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'));
461 $rolesdef->add_child($role);
465 $role->set_source_sql("SELECT r.*, rn.name AS nameincourse
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)
478 * structure step that will generate the scales.xml containing the
479 * list of scales used along the whole backup process.
481 class backup_final_scales_structure_step extends backup_structure_step {
483 protected function define_structure() {
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'));
495 $scalesdef->add_child($scale);
499 $scale->set_source_sql("SELECT 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)
514 * structure step that will generate the outcomes.xml containing the
515 * list of outcomes used along the whole backup process.
517 class backup_final_outcomes_structure_step extends backup_structure_step {
519 protected function define_structure() {
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'));
532 $outcomesdef->add_child($outcome);
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)
551 * structure step in charge of constructing the filters.xml file for all the filters found
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'));
572 $filters->add_child($actives);
573 $filters->add_child($configs);
575 $actives->add_child($active);
576 $configs->add_child($config);
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)
591 * structure step in charge of constructing the comments.xml file for all the comments found
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'));
608 $comments->add_child($comment);
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)
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
627 class backup_gradebook_structure_step extends backup_structure_step {
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
634 protected function execute_condition() {
635 return backup_plan_dbops::require_gradebook_backup($this->get_courseid(), $this->get_backupid());
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'));
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'));
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);
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);
703 $grade_grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
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
727 * structure step in charge if constructing the completion.xml file for all the users completion
728 * information in a given activity
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'));
743 $completions->add_child($completion);
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)
759 * structure step in charge of constructing the main groups.xml file for all the groups and
760 * groupings information already annotated
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'));
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);
807 $group->set_source_sql("
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
816 $member->set_source_table('groups_members', array('groupid' => backup::VAR_PARENTID));
819 $grouping->set_source_sql("
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)
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
848 class backup_users_structure_step extends backup_structure_step {
850 protected function define_structure() {
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
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) {
886 $userfields[] = new anonymizer_final_element($field);
888 $userfields[] = $field; // No anonymization, normally added
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';
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(
915 $preferences = new backup_nested_element('preferences');
917 $preference = new backup_nested_element('preference', array('id'), array(
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',
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
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);
957 $user->set_source_sql('SELECT u.*, c.id AS contextid, m.wwwroot AS mnethosturl
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 = ?
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
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
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'));
998 // Define id annotations (as final)
999 $override->annotate_ids('rolefinal', 'roleid');
1002 // Return root element (users)
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)
1012 class backup_block_instance_structure_step extends backup_structure_step {
1014 protected function define_structure() {
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', null, array(
1024 'contextid', 'pagetype', 'subpage', 'visible',
1025 'region', 'weight'));
1029 $block->add_child($positions);
1031 // Transform configdata information if needed (process links and friends)
1032 $blockrec = $DB->get_record('block_instances', array('id' => $this->task->get_blockid()));
1033 if ($attrstotransform = $this->task->get_configdata_encoded_attributes()) {
1034 $configdata = (array)unserialize(base64_decode($blockrec->configdata));
1035 foreach ($configdata as $attribute => $value) {
1036 if (in_array($attribute, $attrstotransform)) {
1037 $configdata[$attribute] = $this->contenttransformer->process($value);
1040 $blockrec->configdata = base64_encode(serialize((object)$configdata));
1042 $blockrec->contextid = $this->task->get_contextid();
1043 // Get the version of the block
1044 $blockrec->version = $DB->get_field('block', 'version', array('name' => $this->task->get_blockname()));
1048 $block->set_source_array(array($blockrec));
1050 $positions->set_source_table('block_positions', array('blockinstanceid' => backup::VAR_PARENTID));
1052 // Return the root element (block)
1058 * structure step in charge of constructing the logs.xml file for all the log records found
1061 class backup_activity_logs_structure_step extends backup_structure_step {
1063 protected function define_structure() {
1065 // Define each element separated
1067 $logs = new backup_nested_element('logs');
1069 $log = new backup_nested_element('log', array('id'), array(
1070 'time', 'userid', 'ip', 'module',
1071 'action', 'url', 'info'));
1075 $logs->add_child($log);
1079 $log->set_source_table('log', array('cmid' => backup::VAR_MODID));
1082 // NOTE: We don't annotate users from logs as far as they MUST be
1083 // always annotated by the activity.
1085 // Return the root element (logs)
1092 * structure in charge of constructing the inforef.xml file for all the items we want
1093 * to have referenced there (users, roles, files...)
1095 class backup_inforef_structure_step extends backup_structure_step {
1097 protected function define_structure() {
1099 // Items we want to include in the inforef file.
1100 $items = backup_helper::get_inforef_itemnames();
1104 $inforef = new backup_nested_element('inforef');
1106 // For each item, conditionally, if there are already records, build element
1107 foreach ($items as $itemname) {
1108 if (backup_structure_dbops::annotations_exist($this->get_backupid(), $itemname)) {
1109 $elementroot = new backup_nested_element($itemname . 'ref');
1110 $element = new backup_nested_element($itemname, array(), array('id'));
1111 $inforef->add_child($elementroot);
1112 $elementroot->add_child($element);
1113 $element->set_source_sql("
1115 FROM {backup_ids_temp}
1118 array(backup::VAR_BACKUPID, backup_helper::is_sqlparam($itemname)));
1122 // We don't annotate anything there, but rely in the next step
1123 // (move_inforef_annotations_to_final) that will change all the
1124 // already saved 'inforref' entries to their 'final' annotations.
1130 * This step will get all the annotations already processed to inforef.xml file and
1131 * transform them into 'final' annotations.
1133 class move_inforef_annotations_to_final extends backup_execution_step {
1135 protected function define_execution() {
1137 // Items we want to include in the inforef file
1138 $items = backup_helper::get_inforef_itemnames();
1139 foreach ($items as $itemname) {
1140 // Delegate to dbops
1141 backup_structure_dbops::move_annotations_to_final($this->get_backupid(), $itemname);
1147 * structure in charge of constructing the files.xml file with all the
1148 * annotated (final) files along the process. At, the same time, and
1149 * using one specialised nested_element, will copy them form moodle storage
1152 class backup_final_files_structure_step extends backup_structure_step {
1154 protected function define_structure() {
1158 $files = new backup_nested_element('files');
1160 $file = new file_nested_element('file', array('id'), array(
1161 'contenthash', 'contextid', 'component', 'filearea', 'itemid',
1162 'filepath', 'filename', 'userid', 'filesize',
1163 'mimetype', 'status', 'timecreated', 'timemodified',
1164 'source', 'author', 'license', 'sortorder'));
1168 $files->add_child($file);
1172 $file->set_source_sql("SELECT f.*
1174 JOIN {backup_ids_temp} bi ON f.id = bi.itemid
1175 WHERE bi.backupid = ?
1176 AND bi.itemname = 'filefinal'", array(backup::VAR_BACKUPID));
1183 * Structure step in charge of creating the main moodle_backup.xml file
1184 * where all the information related to the backup, settings, license and
1185 * other information needed on restore is added*/
1186 class backup_main_structure_step extends backup_structure_step {
1188 protected function define_structure() {
1194 $info['name'] = $this->get_setting_value('filename');
1195 $info['moodle_version'] = $CFG->version;
1196 $info['moodle_release'] = $CFG->release;
1197 $info['backup_version'] = $CFG->backup_version;
1198 $info['backup_release'] = $CFG->backup_release;
1199 $info['backup_date'] = time();
1200 $info['backup_uniqueid']= $this->get_backupid();
1201 $info['mnet_remoteusers']=backup_controller_dbops::backup_includes_mnet_remote_users($this->get_backupid());
1202 $info['original_wwwroot']=$CFG->wwwroot;
1203 $info['original_site_identifier_hash'] = md5(get_site_identifier());
1204 $info['original_course_id'] = $this->get_courseid();
1205 $info['original_course_contextid'] = get_context_instance(CONTEXT_COURSE, $this->get_courseid())->id;
1206 $info['original_system_contextid'] = get_context_instance(CONTEXT_SYSTEM)->id;
1208 // Get more information from controller
1209 list($dinfo, $cinfo, $sinfo) = backup_controller_dbops::get_moodle_backup_information($this->get_backupid());
1213 $moodle_backup = new backup_nested_element('moodle_backup');
1215 $information = new backup_nested_element('information', null, array(
1216 'name', 'moodle_version', 'moodle_release', 'backup_version',
1217 'backup_release', 'backup_date', 'mnet_remoteusers', 'original_wwwroot',
1218 'original_site_identifier_hash', 'original_course_id', 'original_course_contextid', 'original_system_contextid'));
1220 $details = new backup_nested_element('details');
1222 $detail = new backup_nested_element('detail', array('backup_id'), array(
1223 'type', 'format', 'interactive', 'mode',
1224 'execution', 'executiontime'));
1226 $contents = new backup_nested_element('contents');
1228 $activities = new backup_nested_element('activities');
1230 $activity = new backup_nested_element('activity', null, array(
1231 'moduleid', 'sectionid', 'modulename', 'title',
1234 $sections = new backup_nested_element('sections');
1236 $section = new backup_nested_element('section', null, array(
1237 'sectionid', 'title', 'directory'));
1239 $course = new backup_nested_element('course', null, array(
1240 'courseid', 'title', 'directory'));
1242 $settings = new backup_nested_element('settings');
1244 $setting = new backup_nested_element('setting', null, array(
1245 'level', 'section', 'activity', 'name', 'value'));
1249 $moodle_backup->add_child($information);
1251 $information->add_child($details);
1252 $details->add_child($detail);
1254 $information->add_child($contents);
1255 if (!empty($cinfo['activities'])) {
1256 $contents->add_child($activities);
1257 $activities->add_child($activity);
1259 if (!empty($cinfo['sections'])) {
1260 $contents->add_child($sections);
1261 $sections->add_child($section);
1263 if (!empty($cinfo['course'])) {
1264 $contents->add_child($course);
1267 $information->add_child($settings);
1268 $settings->add_child($setting);
1273 $information->set_source_array(array((object)$info));
1275 $detail->set_source_array($dinfo);
1277 $activity->set_source_array($cinfo['activities']);
1279 $section->set_source_array($cinfo['sections']);
1281 $course->set_source_array($cinfo['course']);
1283 $setting->set_source_array($sinfo);
1285 // Prepare some information to be sent to main moodle_backup.xml file
1286 return $moodle_backup;
1292 * Execution step that will generate the final zip file with all the contents
1294 class backup_zip_contents extends backup_execution_step {
1296 protected function define_execution() {
1299 $basepath = $this->get_basepath();
1301 // Get the list of files in directory
1302 $filestemp = get_directory_list($basepath, '', false, true, true);
1304 foreach ($filestemp as $file) { // Add zip paths and fs paths to all them
1305 $files[$file] = $basepath . '/' . $file;
1308 // Add the log file if exists
1309 $logfilepath = $basepath . '.log';
1310 if (file_exists($logfilepath)) {
1311 $files['moodle_backup.log'] = $logfilepath;
1314 // Calculate the zip fullpath (in OS temp area it's always backup.zip)
1315 $zipfile = $basepath . '/backup.zip';
1317 // Get the zip packer
1318 $zippacker = get_file_packer('application/zip');
1321 $zippacker->archive_to_pathname($files, $zipfile);
1326 * This step will send the generated backup file to its final destination
1328 class backup_store_backup_file extends backup_execution_step {
1330 protected function define_execution() {
1333 $basepath = $this->get_basepath();
1335 // Calculate the zip fullpath (in OS temp area it's always backup.zip)
1336 $zipfile = $basepath . '/backup.zip';
1338 // Perform storage and return it (TODO: shouldn't be array but proper result object)
1339 return array('backup_destination' => backup_helper::store_backup_file($this->get_backupid(), $zipfile));
1345 * This step will search for all the activity (not calculations, categories nor aggregations) grade items
1346 * and put them to the backup_ids tables, to be used later as base to backup them
1348 class backup_activity_grade_items_to_ids extends backup_execution_step {
1350 protected function define_execution() {
1352 // Fetch all activity grade items
1353 if ($items = grade_item::fetch_all(array(
1354 'itemtype' => 'mod', 'itemmodule' => $this->task->get_modulename(),
1355 'iteminstance' => $this->task->get_activityid(), 'courseid' => $this->task->get_courseid()))) {
1356 // Annotate them in backup_ids
1357 foreach ($items as $item) {
1358 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grade_item', $item->id);
1365 * This step will annotate all the groups belonging to already annotated groupings
1367 class backup_annotate_groups_from_groupings extends backup_execution_step {
1369 protected function define_execution() {
1372 // Fetch all the annotated groupings
1373 if ($groupings = $DB->get_records('backup_ids_temp', array(
1374 'backupid' => $this->get_backupid(), 'itemname' => 'grouping'))) {
1375 foreach ($groupings as $grouping) {
1376 if ($groups = $DB->get_records('groupings_groups', array(
1377 'groupingid' => $grouping->itemid))) {
1378 foreach ($groups as $group) {
1379 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->groupid);
1388 * This step will annotate all the scales belonging to already annotated outcomes
1390 class backup_annotate_scales_from_outcomes extends backup_execution_step {
1392 protected function define_execution() {
1395 // Fetch all the annotated outcomes
1396 if ($outcomes = $DB->get_records('backup_ids_temp', array(
1397 'backupid' => $this->get_backupid(), 'itemname' => 'outcome'))) {
1398 foreach ($outcomes as $outcome) {
1399 if ($scale = $DB->get_record('grade_outcomes', array(
1400 'id' => $outcome->itemid))) {
1401 // Annotate as scalefinal because it's > 0
1402 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'scalefinal', $scale->scaleid);
1410 * This step will generate all the file annotations for the already
1411 * annotated (final) users. Need to do this here because each user
1412 * has its own context and structure tasks only are able to handle
1413 * one context. Also, this step will guarantee that every user has
1414 * its context created (req for other steps)
1416 class backup_annotate_all_user_files extends backup_execution_step {
1418 protected function define_execution() {
1421 // List of fileareas we are going to annotate
1422 $fileareas = array('profile', 'icon');
1424 if ($this->get_setting_value('user_files')) { // private files only if enabled in settings
1425 $fileareas[] = 'private';
1428 // Fetch all annotated (final) users
1429 $rs = $DB->get_recordset('backup_ids_temp', array(
1430 'backupid' => $this->get_backupid(), 'itemname' => 'userfinal'));
1431 foreach ($rs as $record) {
1432 $userid = $record->itemid;
1433 $userctxid = get_context_instance(CONTEXT_USER, $userid)->id;
1434 // Proceed with every user filearea
1435 foreach ($fileareas as $filearea) {
1436 // We don't need to specify itemid ($userid - 5th param) as far as by
1437 // context we can get all the associated files. See MDL-22092
1438 backup_structure_dbops::annotate_files($this->get_backupid(), $userctxid, 'user', $filearea, null);
1446 * structure step in charge of constructing the grades.xml file for all the grade items
1447 * and letters related to one activity
1449 class backup_activity_grades_structure_step extends backup_structure_step {
1451 protected function define_structure() {
1453 // To know if we are including userinfo
1454 $userinfo = $this->get_setting_value('userinfo');
1456 // Define each element separated
1458 $book = new backup_nested_element('activity_gradebook');
1460 $items = new backup_nested_element('grade_items');
1462 $item = new backup_nested_element('grade_item', array('id'), array(
1463 'categoryid', 'itemname', 'itemtype', 'itemmodule',
1464 'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
1465 'calculation', 'gradetype', 'grademax', 'grademin',
1466 'scaleid', 'outcomeid', 'gradepass', 'multfactor',
1467 'plusfactor', 'aggregationcoef', 'sortorder', 'display',
1468 'decimals', 'hidden', 'locked', 'locktime',
1469 'needsupdate', 'timecreated', 'timemodified'));
1471 $grades = new backup_nested_element('grade_grades');
1473 $grade = new backup_nested_element('grade_grade', array('id'), array(
1474 'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
1475 'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
1476 'locked', 'locktime', 'exported', 'overridden',
1477 'excluded', 'feedback', 'feedbackformat', 'information',
1478 'informationformat', 'timecreated', 'timemodified'));
1480 $letters = new backup_nested_element('grade_letters');
1482 $letter = new backup_nested_element('grade_letter', 'id', array(
1483 'lowerboundary', 'letter'));
1487 $book->add_child($items);
1488 $items->add_child($item);
1490 $item->add_child($grades);
1491 $grades->add_child($grade);
1493 $book->add_child($letters);
1494 $letters->add_child($letter);
1498 $item->set_source_sql("SELECT gi.*
1499 FROM {grade_items} gi
1500 JOIN {backup_ids_temp} bi ON gi.id = bi.itemid
1501 WHERE bi.backupid = ?
1502 AND bi.itemname = 'grade_item'", array(backup::VAR_BACKUPID));
1504 // This only happens if we are including user info
1506 $grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
1509 $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
1513 $item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
1514 $item->annotate_ids('outcome', 'outcomeid');
1516 $grade->annotate_ids('user', 'userid');
1517 $grade->annotate_ids('user', 'usermodified');
1519 // Return the root element (book)