436f19f36dd25dbe1b51f30f284e4bed3a43a4c2
[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  * Defines various backup steps that will be used by common tasks in backup
20  *
21  * @package     core_backup
22  * @subpackage  moodle2
23  * @category    backup
24  * @copyright   2010 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
25  * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
26  */
28 defined('MOODLE_INTERNAL') || die();
30 /**
31  * Create the temp dir where backup/restore will happen and create temp ids table.
32  */
33 class create_and_clean_temp_stuff extends backup_execution_step {
35     protected function define_execution() {
36         $progress = $this->task->get_progress();
37         $progress->start_progress('Deleting backup directories');
38         backup_helper::check_and_create_backup_dir($this->get_backupid());// Create backup temp dir
39         backup_helper::clear_backup_dir($this->get_backupid(), $progress);           // Empty temp dir, just in case
40         backup_controller_dbops::drop_backup_ids_temp_table($this->get_backupid()); // Drop ids temp table
41         backup_controller_dbops::create_backup_ids_temp_table($this->get_backupid()); // Create ids temp table
42         $progress->end_progress();
43     }
44 }
46 /**
47  * Delete the temp dir used by backup/restore (conditionally),
48  * delete old directories and drop temp ids table. Note we delete
49  * the directory but not the corresponding log file that will be
50  * there for, at least, 1 week - only delete_old_backup_dirs() or cron
51  * deletes log files (for easier access to them).
52  */
53 class drop_and_clean_temp_stuff extends backup_execution_step {
55     protected $skipcleaningtempdir = false;
57     protected function define_execution() {
58         global $CFG;
60         backup_controller_dbops::drop_backup_ids_temp_table($this->get_backupid()); // Drop ids temp table
61         backup_helper::delete_old_backup_dirs(strtotime('-1 week'));                // Delete > 1 week old temp dirs.
62         // Delete temp dir conditionally:
63         // 1) If $CFG->keeptempdirectoriesonbackup is not enabled
64         // 2) If backup temp dir deletion has been marked to be avoided
65         if (empty($CFG->keeptempdirectoriesonbackup) && !$this->skipcleaningtempdir) {
66             $progress = $this->task->get_progress();
67             $progress->start_progress('Deleting backup dir');
68             backup_helper::delete_backup_dir($this->get_backupid(), $progress); // Empty backup dir
69             $progress->end_progress();
70         }
71     }
73     public function skip_cleaning_temp_dir($skip) {
74         $this->skipcleaningtempdir = $skip;
75     }
76 }
78 /**
79  * Create the directory where all the task (activity/block...) information will be stored
80  */
81 class create_taskbasepath_directory extends backup_execution_step {
83     protected function define_execution() {
84         global $CFG;
85         $basepath = $this->task->get_taskbasepath();
86         if (!check_dir_exists($basepath, true, true)) {
87             throw new backup_step_exception('cannot_create_taskbasepath_directory', $basepath);
88         }
89     }
90 }
92 /**
93  * Abstract structure step, parent of all the activity structure steps. Used to wrap the
94  * activity structure definition within the main <activity ...> tag.
95  */
96 abstract class backup_activity_structure_step extends backup_structure_step {
98     /**
99      * Wraps any activity backup structure within the common 'activity' element
100      * that will include common to all activities information like id, context...
101      *
102      * @param backup_nested_element $activitystructure the element to wrap
103      * @return backup_nested_element the $activitystructure wrapped by the common 'activity' element
104      */
105     protected function prepare_activity_structure($activitystructure) {
107         // Create the wrap element
108         $activity = new backup_nested_element('activity', array('id', 'moduleid', 'modulename', 'contextid'), null);
110         // Build the tree
111         $activity->add_child($activitystructure);
113         // Set the source
114         $activityarr = array((object)array(
115             'id'         => $this->task->get_activityid(),
116             'moduleid'   => $this->task->get_moduleid(),
117             'modulename' => $this->task->get_modulename(),
118             'contextid'  => $this->task->get_contextid()));
120         $activity->set_source_array($activityarr);
122         // Return the root element (activity)
123         return $activity;
124     }
127 /**
128  * Abstract structure step, to be used by all the activities using core questions stuff
129  * (namely quiz module), supporting question plugins, states and sessions
130  */
131 abstract class backup_questions_activity_structure_step extends backup_activity_structure_step {
133     /**
134      * Attach to $element (usually attempts) the needed backup structures
135      * for question_usages and all the associated data.
136      *
137      * @param backup_nested_element $element the element that will contain all the question_usages data.
138      * @param string $usageidname the name of the element that holds the usageid.
139      *      This must be child of $element, and must be a final element.
140      * @param string $nameprefix this prefix is added to all the element names we create.
141      *      Element names in the XML must be unique, so if you are using usages in
142      *      two different ways, you must give a prefix to at least one of them. If
143      *      you only use one sort of usage, then you can just use the default empty prefix.
144      *      This should include a trailing underscore. For example "myprefix_"
145      */
146     protected function add_question_usages($element, $usageidname, $nameprefix = '') {
147         global $CFG;
148         require_once($CFG->dirroot . '/question/engine/lib.php');
150         // Check $element is one nested_backup_element
151         if (! $element instanceof backup_nested_element) {
152             throw new backup_step_exception('question_states_bad_parent_element', $element);
153         }
154         if (! $element->get_final_element($usageidname)) {
155             throw new backup_step_exception('question_states_bad_question_attempt_element', $usageidname);
156         }
158         $quba = new backup_nested_element($nameprefix . 'question_usage', array('id'),
159                 array('component', 'preferredbehaviour'));
161         $qas = new backup_nested_element($nameprefix . 'question_attempts');
162         $qa = new backup_nested_element($nameprefix . 'question_attempt', array('id'), array(
163                 'slot', 'behaviour', 'questionid', 'variant', 'maxmark', 'minfraction', 'maxfraction',
164                 'flagged', 'questionsummary', 'rightanswer', 'responsesummary',
165                 'timemodified'));
167         $steps = new backup_nested_element($nameprefix . 'steps');
168         $step = new backup_nested_element($nameprefix . 'step', array('id'), array(
169                 'sequencenumber', 'state', 'fraction', 'timecreated', 'userid'));
171         $response = new backup_nested_element($nameprefix . 'response');
172         $variable = new backup_nested_element($nameprefix . 'variable', null,  array('name', 'value'));
174         // Build the tree
175         $element->add_child($quba);
176         $quba->add_child($qas);
177         $qas->add_child($qa);
178         $qa->add_child($steps);
179         $steps->add_child($step);
180         $step->add_child($response);
181         $response->add_child($variable);
183         // Set the sources
184         $quba->set_source_table('question_usages',
185                 array('id'                => '../' . $usageidname));
186         $qa->set_source_table('question_attempts', array('questionusageid' => backup::VAR_PARENTID), 'slot ASC');
187         $step->set_source_table('question_attempt_steps', array('questionattemptid' => backup::VAR_PARENTID), 'sequencenumber ASC');
188         $variable->set_source_table('question_attempt_step_data', array('attemptstepid' => backup::VAR_PARENTID));
190         // Annotate ids
191         $qa->annotate_ids('question', 'questionid');
192         $step->annotate_ids('user', 'userid');
194         // Annotate files
195         $fileareas = question_engine::get_all_response_file_areas();
196         foreach ($fileareas as $filearea) {
197             $step->annotate_files('question', $filearea, 'id');
198         }
199     }
203 /**
204  * backup structure step in charge of calculating the categories to be
205  * included in backup, based in the context being backuped (module/course)
206  * and the already annotated questions present in backup_ids_temp
207  */
208 class backup_calculate_question_categories extends backup_execution_step {
210     protected function define_execution() {
211         backup_question_dbops::calculate_question_categories($this->get_backupid(), $this->task->get_contextid());
212     }
215 /**
216  * backup structure step in charge of deleting all the questions annotated
217  * in the backup_ids_temp table
218  */
219 class backup_delete_temp_questions extends backup_execution_step {
221     protected function define_execution() {
222         backup_question_dbops::delete_temp_questions($this->get_backupid());
223     }
226 /**
227  * Abstract structure step, parent of all the block structure steps. Used to wrap the
228  * block structure definition within the main <block ...> tag
229  */
230 abstract class backup_block_structure_step extends backup_structure_step {
232     protected function prepare_block_structure($blockstructure) {
234         // Create the wrap element
235         $block = new backup_nested_element('block', array('id', 'blockname', 'contextid'), null);
237         // Build the tree
238         $block->add_child($blockstructure);
240         // Set the source
241         $blockarr = array((object)array(
242             'id'         => $this->task->get_blockid(),
243             'blockname'  => $this->task->get_blockname(),
244             'contextid'  => $this->task->get_contextid()));
246         $block->set_source_array($blockarr);
248         // Return the root element (block)
249         return $block;
250     }
253 /**
254  * structure step that will generate the module.xml file for the activity,
255  * accumulating various information about the activity, annotating groupings
256  * and completion/avail conf
257  */
258 class backup_module_structure_step extends backup_structure_step {
260     protected function define_structure() {
261         global $DB;
263         // Define each element separated
265         $module = new backup_nested_element('module', array('id', 'version'), array(
266             'modulename', 'sectionid', 'sectionnumber', 'idnumber',
267             'added', 'score', 'indent', 'visible',
268             'visibleold', 'groupmode', 'groupingid',
269             'completion', 'completiongradeitemnumber', 'completionview', 'completionexpected',
270             'availability', 'showdescription'));
272         // attach format plugin structure to $module element, only one allowed
273         $this->add_plugin_structure('format', $module, false);
275         // attach plagiarism plugin structure to $module element, there can be potentially
276         // many plagiarism plugins storing information about this course
277         $this->add_plugin_structure('plagiarism', $module, true);
279         // attach local plugin structure to $module, multiple allowed
280         $this->add_plugin_structure('local', $module, true);
282         // Set the sources
283         $concat = $DB->sql_concat("'mod_'", 'm.name');
284         $module->set_source_sql("
285             SELECT cm.*, cp.value AS version, m.name AS modulename, s.id AS sectionid, s.section AS sectionnumber
286               FROM {course_modules} cm
287               JOIN {modules} m ON m.id = cm.module
288               JOIN {config_plugins} cp ON cp.plugin = $concat AND cp.name = 'version'
289               JOIN {course_sections} s ON s.id = cm.section
290              WHERE cm.id = ?", array(backup::VAR_MODID));
292         // Define annotations
293         $module->annotate_ids('grouping', 'groupingid');
295         // Return the root element ($module)
296         return $module;
297     }
300 /**
301  * structure step that will generate the section.xml file for the section
302  * annotating files
303  */
304 class backup_section_structure_step extends backup_structure_step {
306     protected function define_structure() {
308         // Define each element separated
310         $section = new backup_nested_element('section', array('id'), array(
311                 'number', 'name', 'summary', 'summaryformat', 'sequence', 'visible',
312                 'availabilityjson'));
314         // attach format plugin structure to $section element, only one allowed
315         $this->add_plugin_structure('format', $section, false);
317         // attach local plugin structure to $section element, multiple allowed
318         $this->add_plugin_structure('local', $section, true);
320         // Add nested elements for course_format_options table
321         $formatoptions = new backup_nested_element('course_format_options', array('id'), array(
322             'format', 'name', 'value'));
323         $section->add_child($formatoptions);
325         // Define sources.
326         $section->set_source_table('course_sections', array('id' => backup::VAR_SECTIONID));
327         $formatoptions->set_source_sql('SELECT cfo.id, cfo.format, cfo.name, cfo.value
328               FROM {course} c
329               JOIN {course_format_options} cfo
330               ON cfo.courseid = c.id AND cfo.format = c.format
331               WHERE c.id = ? AND cfo.sectionid = ?',
332                 array(backup::VAR_COURSEID, backup::VAR_SECTIONID));
334         // Aliases
335         $section->set_source_alias('section', 'number');
336         // The 'availability' field needs to be renamed because it clashes with
337         // the old nested element structure for availability data.
338         $section->set_source_alias('availability', 'availabilityjson');
340         // Set annotations
341         $section->annotate_files('course', 'section', 'id');
343         return $section;
344     }
347 /**
348  * structure step that will generate the course.xml file for the course, including
349  * course category reference, tags, modules restriction information
350  * and some annotations (files & groupings)
351  */
352 class backup_course_structure_step extends backup_structure_step {
354     protected function define_structure() {
355         global $DB;
357         // Define each element separated
359         $course = new backup_nested_element('course', array('id', 'contextid'), array(
360             'shortname', 'fullname', 'idnumber',
361             'summary', 'summaryformat', 'format', 'showgrades',
362             'newsitems', 'startdate',
363             'marker', 'maxbytes', 'legacyfiles', 'showreports',
364             'visible', 'groupmode', 'groupmodeforce',
365             'defaultgroupingid', 'lang', 'theme',
366             'timecreated', 'timemodified',
367             'requested',
368             'enablecompletion', 'completionstartonenrol', 'completionnotify'));
370         $category = new backup_nested_element('category', array('id'), array(
371             'name', 'description'));
373         $tags = new backup_nested_element('tags');
375         $tag = new backup_nested_element('tag', array('id'), array(
376             'name', 'rawname'));
378         // attach format plugin structure to $course element, only one allowed
379         $this->add_plugin_structure('format', $course, false);
381         // attach theme plugin structure to $course element; multiple themes can
382         // save course data (in case of user theme, legacy theme, etc)
383         $this->add_plugin_structure('theme', $course, true);
385         // attach general report plugin structure to $course element; multiple
386         // reports can save course data if required
387         $this->add_plugin_structure('report', $course, true);
389         // attach course report plugin structure to $course element; multiple
390         // course reports can save course data if required
391         $this->add_plugin_structure('coursereport', $course, true);
393         // attach plagiarism plugin structure to $course element, there can be potentially
394         // many plagiarism plugins storing information about this course
395         $this->add_plugin_structure('plagiarism', $course, true);
397         // attach local plugin structure to $course element; multiple local plugins
398         // can save course data if required
399         $this->add_plugin_structure('local', $course, true);
401         // Build the tree
403         $course->add_child($category);
405         $course->add_child($tags);
406         $tags->add_child($tag);
408         // Set the sources
410         $courserec = $DB->get_record('course', array('id' => $this->task->get_courseid()));
411         $courserec->contextid = $this->task->get_contextid();
413         $formatoptions = course_get_format($courserec)->get_format_options();
414         $course->add_final_elements(array_keys($formatoptions));
415         foreach ($formatoptions as $key => $value) {
416             $courserec->$key = $value;
417         }
419         $course->set_source_array(array($courserec));
421         $categoryrec = $DB->get_record('course_categories', array('id' => $courserec->category));
423         $category->set_source_array(array($categoryrec));
425         $tag->set_source_sql('SELECT t.id, t.name, t.rawname
426                                 FROM {tag} t
427                                 JOIN {tag_instance} ti ON ti.tagid = t.id
428                                WHERE ti.itemtype = ?
429                                  AND ti.itemid = ?', array(
430                                      backup_helper::is_sqlparam('course'),
431                                      backup::VAR_PARENTID));
433         // Some annotations
435         $course->annotate_ids('grouping', 'defaultgroupingid');
437         $course->annotate_files('course', 'summary', null);
438         $course->annotate_files('course', 'overviewfiles', null);
439         $course->annotate_files('course', 'legacy', null);
441         // Return root element ($course)
443         return $course;
444     }
447 /**
448  * structure step that will generate the enrolments.xml file for the given course
449  */
450 class backup_enrolments_structure_step extends backup_structure_step {
452     /**
453      * Skip enrolments on the front page.
454      * @return bool
455      */
456     protected function execute_condition() {
457         return ($this->get_courseid() != SITEID);
458     }
460     protected function define_structure() {
462         // To know if we are including users
463         $users = $this->get_setting_value('users');
465         // Define each element separated
467         $enrolments = new backup_nested_element('enrolments');
469         $enrols = new backup_nested_element('enrols');
471         $enrol = new backup_nested_element('enrol', array('id'), array(
472             'enrol', 'status', 'name', 'enrolperiod', 'enrolstartdate',
473             'enrolenddate', 'expirynotify', 'expirythreshold', 'notifyall',
474             'password', 'cost', 'currency', 'roleid',
475             'customint1', 'customint2', 'customint3', 'customint4', 'customint5', 'customint6', 'customint7', 'customint8',
476             'customchar1', 'customchar2', 'customchar3',
477             'customdec1', 'customdec2',
478             'customtext1', 'customtext2', 'customtext3', 'customtext4',
479             'timecreated', 'timemodified'));
481         $userenrolments = new backup_nested_element('user_enrolments');
483         $enrolment = new backup_nested_element('enrolment', array('id'), array(
484             'status', 'userid', 'timestart', 'timeend', 'modifierid',
485             'timemodified'));
487         // Build the tree
488         $enrolments->add_child($enrols);
489         $enrols->add_child($enrol);
490         $enrol->add_child($userenrolments);
491         $userenrolments->add_child($enrolment);
493         // Define sources - the instances are restored using the same sortorder, we do not need to store it in xml and deal with it afterwards.
494         $enrol->set_source_table('enrol', array('courseid' => backup::VAR_COURSEID), 'sortorder ASC');
496         // User enrolments only added only if users included
497         if ($users) {
498             $enrolment->set_source_table('user_enrolments', array('enrolid' => backup::VAR_PARENTID));
499             $enrolment->annotate_ids('user', 'userid');
500         }
502         $enrol->annotate_ids('role', 'roleid');
504         // Add enrol plugin structure.
505         $this->add_plugin_structure('enrol', $enrol, false);
507         return $enrolments;
508     }
511 /**
512  * structure step that will generate the roles.xml file for the given context, observing
513  * the role_assignments setting to know if that part needs to be included
514  */
515 class backup_roles_structure_step extends backup_structure_step {
517     protected function define_structure() {
519         // To know if we are including role assignments
520         $roleassignments = $this->get_setting_value('role_assignments');
522         // Define each element separated
524         $roles = new backup_nested_element('roles');
526         $overrides = new backup_nested_element('role_overrides');
528         $override = new backup_nested_element('override', array('id'), array(
529             'roleid', 'capability', 'permission', 'timemodified',
530             'modifierid'));
532         $assignments = new backup_nested_element('role_assignments');
534         $assignment = new backup_nested_element('assignment', array('id'), array(
535             'roleid', 'userid', 'timemodified', 'modifierid', 'component', 'itemid',
536             'sortorder'));
538         // Build the tree
539         $roles->add_child($overrides);
540         $roles->add_child($assignments);
542         $overrides->add_child($override);
543         $assignments->add_child($assignment);
545         // Define sources
547         $override->set_source_table('role_capabilities', array('contextid' => backup::VAR_CONTEXTID));
549         // Assignments only added if specified
550         if ($roleassignments) {
551             $assignment->set_source_table('role_assignments', array('contextid' => backup::VAR_CONTEXTID));
552         }
554         // Define id annotations
555         $override->annotate_ids('role', 'roleid');
557         $assignment->annotate_ids('role', 'roleid');
559         $assignment->annotate_ids('user', 'userid');
561         //TODO: how do we annotate the itemid? the meaning depends on the content of component table (skodak)
563         return $roles;
564     }
567 /**
568  * structure step that will generate the roles.xml containing the
569  * list of roles used along the whole backup process. Just raw
570  * list of used roles from role table
571  */
572 class backup_final_roles_structure_step extends backup_structure_step {
574     protected function define_structure() {
576         // Define elements
578         $rolesdef = new backup_nested_element('roles_definition');
580         $role = new backup_nested_element('role', array('id'), array(
581             'name', 'shortname', 'nameincourse', 'description',
582             'sortorder', 'archetype'));
584         // Build the tree
586         $rolesdef->add_child($role);
588         // Define sources
590         $role->set_source_sql("SELECT r.*, rn.name AS nameincourse
591                                  FROM {role} r
592                                  JOIN {backup_ids_temp} bi ON r.id = bi.itemid
593                             LEFT JOIN {role_names} rn ON r.id = rn.roleid AND rn.contextid = ?
594                                 WHERE bi.backupid = ?
595                                   AND bi.itemname = 'rolefinal'", array(backup::VAR_CONTEXTID, backup::VAR_BACKUPID));
597         // Return main element (rolesdef)
598         return $rolesdef;
599     }
602 /**
603  * structure step that will generate the scales.xml containing the
604  * list of scales used along the whole backup process.
605  */
606 class backup_final_scales_structure_step extends backup_structure_step {
608     protected function define_structure() {
610         // Define elements
612         $scalesdef = new backup_nested_element('scales_definition');
614         $scale = new backup_nested_element('scale', array('id'), array(
615             'courseid', 'userid', 'name', 'scale',
616             'description', 'descriptionformat', 'timemodified'));
618         // Build the tree
620         $scalesdef->add_child($scale);
622         // Define sources
624         $scale->set_source_sql("SELECT s.*
625                                   FROM {scale} s
626                                   JOIN {backup_ids_temp} bi ON s.id = bi.itemid
627                                  WHERE bi.backupid = ?
628                                    AND bi.itemname = 'scalefinal'", array(backup::VAR_BACKUPID));
630         // Annotate scale files (they store files in system context, so pass it instead of default one)
631         $scale->annotate_files('grade', 'scale', 'id', context_system::instance()->id);
633         // Return main element (scalesdef)
634         return $scalesdef;
635     }
638 /**
639  * structure step that will generate the outcomes.xml containing the
640  * list of outcomes used along the whole backup process.
641  */
642 class backup_final_outcomes_structure_step extends backup_structure_step {
644     protected function define_structure() {
646         // Define elements
648         $outcomesdef = new backup_nested_element('outcomes_definition');
650         $outcome = new backup_nested_element('outcome', array('id'), array(
651             'courseid', 'userid', 'shortname', 'fullname',
652             'scaleid', 'description', 'descriptionformat', 'timecreated',
653             'timemodified','usermodified'));
655         // Build the tree
657         $outcomesdef->add_child($outcome);
659         // Define sources
661         $outcome->set_source_sql("SELECT o.*
662                                     FROM {grade_outcomes} o
663                                     JOIN {backup_ids_temp} bi ON o.id = bi.itemid
664                                    WHERE bi.backupid = ?
665                                      AND bi.itemname = 'outcomefinal'", array(backup::VAR_BACKUPID));
667         // Annotate outcome files (they store files in system context, so pass it instead of default one)
668         $outcome->annotate_files('grade', 'outcome', 'id', context_system::instance()->id);
670         // Return main element (outcomesdef)
671         return $outcomesdef;
672     }
675 /**
676  * structure step in charge of constructing the filters.xml file for all the filters found
677  * in activity
678  */
679 class backup_filters_structure_step extends backup_structure_step {
681     protected function define_structure() {
683         // Define each element separated
685         $filters = new backup_nested_element('filters');
687         $actives = new backup_nested_element('filter_actives');
689         $active = new backup_nested_element('filter_active', null, array('filter', 'active'));
691         $configs = new backup_nested_element('filter_configs');
693         $config = new backup_nested_element('filter_config', null, array('filter', 'name', 'value'));
695         // Build the tree
697         $filters->add_child($actives);
698         $filters->add_child($configs);
700         $actives->add_child($active);
701         $configs->add_child($config);
703         // Define sources
705         list($activearr, $configarr) = filter_get_all_local_settings($this->task->get_contextid());
707         $active->set_source_array($activearr);
708         $config->set_source_array($configarr);
710         // Return the root element (filters)
711         return $filters;
712     }
715 /**
716  * structure step in charge of constructing the comments.xml file for all the comments found
717  * in a given context
718  */
719 class backup_comments_structure_step extends backup_structure_step {
721     protected function define_structure() {
723         // Define each element separated
725         $comments = new backup_nested_element('comments');
727         $comment = new backup_nested_element('comment', array('id'), array(
728             'commentarea', 'itemid', 'content', 'format',
729             'userid', 'timecreated'));
731         // Build the tree
733         $comments->add_child($comment);
735         // Define sources
737         $comment->set_source_table('comments', array('contextid' => backup::VAR_CONTEXTID));
739         // Define id annotations
741         $comment->annotate_ids('user', 'userid');
743         // Return the root element (comments)
744         return $comments;
745     }
748 /**
749  * structure step in charge of constructing the badges.xml file for all the badges found
750  * in a given context
751  */
752 class backup_badges_structure_step extends backup_structure_step {
754     protected function execute_condition() {
755         // Check that all activities have been included.
756         if ($this->task->is_excluding_activities()) {
757             return false;
758         }
759         return true;
760     }
762     protected function define_structure() {
764         // Define each element separated.
766         $badges = new backup_nested_element('badges');
767         $badge = new backup_nested_element('badge', array('id'), array('name', 'description',
768                 'timecreated', 'timemodified', 'usercreated', 'usermodified', 'issuername',
769                 'issuerurl', 'issuercontact', 'expiredate', 'expireperiod', 'type', 'courseid',
770                 'message', 'messagesubject', 'attachment', 'notification', 'status', 'nextcron'));
772         $criteria = new backup_nested_element('criteria');
773         $criterion = new backup_nested_element('criterion', array('id'), array('badgeid',
774                 'criteriatype', 'method', 'description', 'descriptionformat'));
776         $parameters = new backup_nested_element('parameters');
777         $parameter = new backup_nested_element('parameter', array('id'), array('critid',
778                 'name', 'value', 'criteriatype'));
780         $manual_awards = new backup_nested_element('manual_awards');
781         $manual_award = new backup_nested_element('manual_award', array('id'), array('badgeid',
782                 'recipientid', 'issuerid', 'issuerrole', 'datemet'));
784         // Build the tree.
786         $badges->add_child($badge);
787         $badge->add_child($criteria);
788         $criteria->add_child($criterion);
789         $criterion->add_child($parameters);
790         $parameters->add_child($parameter);
791         $badge->add_child($manual_awards);
792         $manual_awards->add_child($manual_award);
794         // Define sources.
796         $badge->set_source_table('badge', array('courseid' => backup::VAR_COURSEID));
797         $criterion->set_source_table('badge_criteria', array('badgeid' => backup::VAR_PARENTID));
799         $parametersql = 'SELECT cp.*, c.criteriatype
800                              FROM {badge_criteria_param} cp JOIN {badge_criteria} c
801                                  ON cp.critid = c.id
802                              WHERE critid = :critid';
803         $parameterparams = array('critid' => backup::VAR_PARENTID);
804         $parameter->set_source_sql($parametersql, $parameterparams);
806         $manual_award->set_source_table('badge_manual_award', array('badgeid' => backup::VAR_PARENTID));
808         // Define id annotations.
810         $badge->annotate_ids('user', 'usercreated');
811         $badge->annotate_ids('user', 'usermodified');
812         $criterion->annotate_ids('badge', 'badgeid');
813         $parameter->annotate_ids('criterion', 'critid');
814         $badge->annotate_files('badges', 'badgeimage', 'id');
815         $manual_award->annotate_ids('badge', 'badgeid');
816         $manual_award->annotate_ids('user', 'recipientid');
817         $manual_award->annotate_ids('user', 'issuerid');
818         $manual_award->annotate_ids('role', 'issuerrole');
820         // Return the root element ($badges).
821         return $badges;
822     }
825 /**
826  * structure step in charge of constructing the calender.xml file for all the events found
827  * in a given context
828  */
829 class backup_calendarevents_structure_step extends backup_structure_step {
831     protected function define_structure() {
833         // Define each element separated
835         $events = new backup_nested_element('events');
837         $event = new backup_nested_element('event', array('id'), array(
838                 'name', 'description', 'format', 'courseid', 'groupid', 'userid',
839                 'repeatid', 'modulename', 'instance', 'eventtype', 'timestart',
840                 'timeduration', 'visible', 'uuid', 'sequence', 'timemodified'));
842         // Build the tree
843         $events->add_child($event);
845         // Define sources
846         if ($this->name == 'course_calendar') {
847             $calendar_items_sql ="SELECT * FROM {event}
848                         WHERE courseid = :courseid
849                         AND (eventtype = 'course' OR eventtype = 'group')";
850             $calendar_items_params = array('courseid'=>backup::VAR_COURSEID);
851             $event->set_source_sql($calendar_items_sql, $calendar_items_params);
852         } else {
853             $event->set_source_table('event', array('courseid' => backup::VAR_COURSEID, 'instance' => backup::VAR_ACTIVITYID, 'modulename' => backup::VAR_MODNAME));
854         }
856         // Define id annotations
858         $event->annotate_ids('user', 'userid');
859         $event->annotate_ids('group', 'groupid');
860         $event->annotate_files('calendar', 'event_description', 'id');
862         // Return the root element (events)
863         return $events;
864     }
867 /**
868  * structure step in charge of constructing the gradebook.xml file for all the gradebook config in the course
869  * NOTE: the backup of the grade items themselves is handled by backup_activity_grades_structure_step
870  */
871 class backup_gradebook_structure_step extends backup_structure_step {
873     /**
874      * We need to decide conditionally, based on dynamic information
875      * about the execution of this step. Only will be executed if all
876      * the module gradeitems have been already included in backup
877      */
878     protected function execute_condition() {
879         $courseid = $this->get_courseid();
880         if ($courseid == SITEID) {
881             return false;
882         }
884         return backup_plan_dbops::require_gradebook_backup($courseid, $this->get_backupid());
885     }
887     protected function define_structure() {
888         global $CFG, $DB;
890         // are we including user info?
891         $userinfo = $this->get_setting_value('users');
893         $gradebook = new backup_nested_element('gradebook');
895         //grade_letters are done in backup_activity_grades_structure_step()
897         //calculated grade items
898         $grade_items = new backup_nested_element('grade_items');
899         $grade_item = new backup_nested_element('grade_item', array('id'), array(
900             'categoryid', 'itemname', 'itemtype', 'itemmodule',
901             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
902             'calculation', 'gradetype', 'grademax', 'grademin',
903             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
904             'plusfactor', 'aggregationcoef', 'aggregationcoef2', 'weightoverride',
905             'sortorder', 'display', 'decimals', 'hidden', 'locked', 'locktime',
906             'needsupdate', 'timecreated', 'timemodified'));
908         $grade_grades = new backup_nested_element('grade_grades');
909         $grade_grade = new backup_nested_element('grade_grade', array('id'), array(
910             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
911             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
912             'locked', 'locktime', 'exported', 'overridden',
913             'excluded', 'feedback', 'feedbackformat', 'information',
914             'informationformat', 'timecreated', 'timemodified',
915             'aggregationstatus', 'aggregationweight'));
917         //grade_categories
918         $grade_categories = new backup_nested_element('grade_categories');
919         $grade_category   = new backup_nested_element('grade_category', array('id'), array(
920                 //'courseid',
921                 'parent', 'depth', 'path', 'fullname', 'aggregation', 'keephigh',
922                 'droplow', 'aggregateonlygraded', 'aggregateoutcomes',
923                 'timecreated', 'timemodified', 'hidden'));
925         $letters = new backup_nested_element('grade_letters');
926         $letter = new backup_nested_element('grade_letter', 'id', array(
927             'lowerboundary', 'letter'));
929         $grade_settings = new backup_nested_element('grade_settings');
930         $grade_setting = new backup_nested_element('grade_setting', 'id', array(
931             'name', 'value'));
934         // Build the tree
935         $gradebook->add_child($grade_categories);
936         $grade_categories->add_child($grade_category);
938         $gradebook->add_child($grade_items);
939         $grade_items->add_child($grade_item);
940         $grade_item->add_child($grade_grades);
941         $grade_grades->add_child($grade_grade);
943         $gradebook->add_child($letters);
944         $letters->add_child($letter);
946         $gradebook->add_child($grade_settings);
947         $grade_settings->add_child($grade_setting);
949         // Add attribute with gradebook calculation freeze date if needed.
950         $gradebookcalculationfreeze = get_config('core', 'gradebook_calculations_freeze_' . $this->get_courseid());
951         if ($gradebookcalculationfreeze) {
952             $gradebook->add_attributes(array('calculations_freeze'));
953             $gradebook->get_attribute('calculations_freeze')->set_value($gradebookcalculationfreeze);
954         }
956         // Define sources
958         //Include manual, category and the course grade item
959         $grade_items_sql ="SELECT * FROM {grade_items}
960                            WHERE courseid = :courseid
961                            AND (itemtype='manual' OR itemtype='course' OR itemtype='category')";
962         $grade_items_params = array('courseid'=>backup::VAR_COURSEID);
963         $grade_item->set_source_sql($grade_items_sql, $grade_items_params);
965         if ($userinfo) {
966             $grade_grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
967         }
969         $grade_category_sql = "SELECT gc.*, gi.sortorder
970                                FROM {grade_categories} gc
971                                JOIN {grade_items} gi ON (gi.iteminstance = gc.id)
972                                WHERE gc.courseid = :courseid
973                                AND (gi.itemtype='course' OR gi.itemtype='category')
974                                ORDER BY gc.parent ASC";//need parent categories before their children
975         $grade_category_params = array('courseid'=>backup::VAR_COURSEID);
976         $grade_category->set_source_sql($grade_category_sql, $grade_category_params);
978         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
980         // Set the grade settings source, forcing the inclusion of minmaxtouse if not present.
981         $settings = array();
982         $rs = $DB->get_recordset('grade_settings', array('courseid' => $this->get_courseid()));
983         foreach ($rs as $record) {
984             $settings[$record->name] = $record;
985         }
986         $rs->close();
987         if (!isset($settings['minmaxtouse'])) {
988             $settings['minmaxtouse'] = (object) array('name' => 'minmaxtouse', 'value' => $CFG->grade_minmaxtouse);
989         }
990         $grade_setting->set_source_array($settings);
993         // Annotations (both as final as far as they are going to be exported in next steps)
994         $grade_item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
995         $grade_item->annotate_ids('outcomefinal', 'outcomeid');
997         //just in case there are any users not already annotated by the activities
998         $grade_grade->annotate_ids('userfinal', 'userid');
1000         // Return the root element
1001         return $gradebook;
1002     }
1005 /**
1006  * Step in charge of constructing the grade_history.xml file containing the grade histories.
1007  */
1008 class backup_grade_history_structure_step extends backup_structure_step {
1010     /**
1011      * Limit the execution.
1012      *
1013      * This applies the same logic than the one applied to {@link backup_gradebook_structure_step},
1014      * because we do not want to save the history of items which are not backed up. At least for now.
1015      */
1016     protected function execute_condition() {
1017         $courseid = $this->get_courseid();
1018         if ($courseid == SITEID) {
1019             return false;
1020         }
1022         return backup_plan_dbops::require_gradebook_backup($courseid, $this->get_backupid());
1023     }
1025     protected function define_structure() {
1027         // Settings to use.
1028         $userinfo = $this->get_setting_value('users');
1029         $history = $this->get_setting_value('grade_histories');
1031         // Create the nested elements.
1032         $bookhistory = new backup_nested_element('grade_history');
1033         $grades = new backup_nested_element('grade_grades');
1034         $grade = new backup_nested_element('grade_grade', array('id'), array(
1035             'action', 'oldid', 'source', 'loggeduser', 'itemid', 'userid',
1036             'rawgrade', 'rawgrademax', 'rawgrademin', 'rawscaleid',
1037             'usermodified', 'finalgrade', 'hidden', 'locked', 'locktime', 'exported', 'overridden',
1038             'excluded', 'feedback', 'feedbackformat', 'information',
1039             'informationformat', 'timemodified'));
1041         // Build the tree.
1042         $bookhistory->add_child($grades);
1043         $grades->add_child($grade);
1045         // This only happens if we are including user info and history.
1046         if ($userinfo && $history) {
1047             // Only keep the history of grades related to items which have been backed up, The query is
1048             // similar (but not identical) to the one used in backup_gradebook_structure_step::define_structure().
1049             $gradesql = "SELECT ggh.*
1050                            FROM {grade_grades_history} ggh
1051                            JOIN {grade_items} gi ON ggh.itemid = gi.id
1052                           WHERE gi.courseid = :courseid
1053                             AND (gi.itemtype = 'manual' OR gi.itemtype = 'course' OR gi.itemtype = 'category')";
1054             $grade->set_source_sql($gradesql, array('courseid' => backup::VAR_COURSEID));
1055         }
1057         // Annotations. (Final annotations as this step is part of the final task).
1058         $grade->annotate_ids('scalefinal', 'rawscaleid');
1059         $grade->annotate_ids('userfinal', 'loggeduser');
1060         $grade->annotate_ids('userfinal', 'userid');
1061         $grade->annotate_ids('userfinal', 'usermodified');
1063         // Return the root element.
1064         return $bookhistory;
1065     }
1069 /**
1070  * structure step in charge if constructing the completion.xml file for all the users completion
1071  * information in a given activity
1072  */
1073 class backup_userscompletion_structure_step extends backup_structure_step {
1075     /**
1076      * Skip completion on the front page.
1077      * @return bool
1078      */
1079     protected function execute_condition() {
1080         return ($this->get_courseid() != SITEID);
1081     }
1083     protected function define_structure() {
1085         // Define each element separated
1087         $completions = new backup_nested_element('completions');
1089         $completion = new backup_nested_element('completion', array('id'), array(
1090             'userid', 'completionstate', 'viewed', 'timemodified'));
1092         // Build the tree
1094         $completions->add_child($completion);
1096         // Define sources
1098         $completion->set_source_table('course_modules_completion', array('coursemoduleid' => backup::VAR_MODID));
1100         // Define id annotations
1102         $completion->annotate_ids('user', 'userid');
1104         // Return the root element (completions)
1105         return $completions;
1106     }
1109 /**
1110  * structure step in charge of constructing the main groups.xml file for all the groups and
1111  * groupings information already annotated
1112  */
1113 class backup_groups_structure_step extends backup_structure_step {
1115     protected function define_structure() {
1117         // To know if we are including users.
1118         $userinfo = $this->get_setting_value('users');
1119         // To know if we are including groups and groupings.
1120         $groupinfo = $this->get_setting_value('groups');
1122         // Define each element separated
1124         $groups = new backup_nested_element('groups');
1126         $group = new backup_nested_element('group', array('id'), array(
1127             'name', 'idnumber', 'description', 'descriptionformat', 'enrolmentkey',
1128             'picture', 'hidepicture', 'timecreated', 'timemodified'));
1130         $members = new backup_nested_element('group_members');
1132         $member = new backup_nested_element('group_member', array('id'), array(
1133             'userid', 'timeadded', 'component', 'itemid'));
1135         $groupings = new backup_nested_element('groupings');
1137         $grouping = new backup_nested_element('grouping', 'id', array(
1138             'name', 'idnumber', 'description', 'descriptionformat', 'configdata',
1139             'timecreated', 'timemodified'));
1141         $groupinggroups = new backup_nested_element('grouping_groups');
1143         $groupinggroup = new backup_nested_element('grouping_group', array('id'), array(
1144             'groupid', 'timeadded'));
1146         // Build the tree
1148         $groups->add_child($group);
1149         $groups->add_child($groupings);
1151         $group->add_child($members);
1152         $members->add_child($member);
1154         $groupings->add_child($grouping);
1155         $grouping->add_child($groupinggroups);
1156         $groupinggroups->add_child($groupinggroup);
1158         // Define sources
1160         // This only happens if we are including groups/groupings.
1161         if ($groupinfo) {
1162             $group->set_source_sql("
1163                 SELECT g.*
1164                   FROM {groups} g
1165                   JOIN {backup_ids_temp} bi ON g.id = bi.itemid
1166                  WHERE bi.backupid = ?
1167                    AND bi.itemname = 'groupfinal'", array(backup::VAR_BACKUPID));
1169             $grouping->set_source_sql("
1170                 SELECT g.*
1171                   FROM {groupings} g
1172                   JOIN {backup_ids_temp} bi ON g.id = bi.itemid
1173                  WHERE bi.backupid = ?
1174                    AND bi.itemname = 'groupingfinal'", array(backup::VAR_BACKUPID));
1175             $groupinggroup->set_source_table('groupings_groups', array('groupingid' => backup::VAR_PARENTID));
1177             // This only happens if we are including users.
1178             if ($userinfo) {
1179                 $member->set_source_table('groups_members', array('groupid' => backup::VAR_PARENTID));
1180             }
1181         }
1183         // Define id annotations (as final)
1185         $member->annotate_ids('userfinal', 'userid');
1187         // Define file annotations
1189         $group->annotate_files('group', 'description', 'id');
1190         $group->annotate_files('group', 'icon', 'id');
1191         $grouping->annotate_files('grouping', 'description', 'id');
1193         // Return the root element (groups)
1194         return $groups;
1195     }
1198 /**
1199  * structure step in charge of constructing the main users.xml file for all the users already
1200  * annotated (final). Includes custom profile fields, preferences, tags, role assignments and
1201  * overrides.
1202  */
1203 class backup_users_structure_step extends backup_structure_step {
1205     protected function define_structure() {
1206         global $CFG;
1208         // To know if we are anonymizing users
1209         $anonymize = $this->get_setting_value('anonymize');
1210         // To know if we are including role assignments
1211         $roleassignments = $this->get_setting_value('role_assignments');
1213         // Define each element separate.
1215         $users = new backup_nested_element('users');
1217         // Create the array of user fields by hand, as far as we have various bits to control
1218         // anonymize option, password backup, mnethostid...
1220         // First, the fields not needing anonymization nor special handling
1221         $normalfields = array(
1222             'confirmed', 'policyagreed', 'deleted',
1223             'lang', 'theme', 'timezone', 'firstaccess',
1224             'lastaccess', 'lastlogin', 'currentlogin',
1225             'mailformat', 'maildigest', 'maildisplay',
1226             'autosubscribe', 'trackforums', 'timecreated',
1227             'timemodified', 'trustbitmask');
1229         // Then, the fields potentially needing anonymization
1230         $anonfields = array(
1231             'username', 'idnumber', 'email', 'icq', 'skype',
1232             'yahoo', 'aim', 'msn', 'phone1',
1233             'phone2', 'institution', 'department', 'address',
1234             'city', 'country', 'lastip', 'picture',
1235             'url', 'description', 'descriptionformat', 'imagealt', 'auth');
1236         $anonfields = array_merge($anonfields, get_all_user_name_fields());
1238         // Add anonymized fields to $userfields with custom final element
1239         foreach ($anonfields as $field) {
1240             if ($anonymize) {
1241                 $userfields[] = new anonymizer_final_element($field);
1242             } else {
1243                 $userfields[] = $field; // No anonymization, normally added
1244             }
1245         }
1247         // mnethosturl requires special handling (custom final element)
1248         $userfields[] = new mnethosturl_final_element('mnethosturl');
1250         // password added conditionally
1251         if (!empty($CFG->includeuserpasswordsinbackup)) {
1252             $userfields[] = 'password';
1253         }
1255         // Merge all the fields
1256         $userfields = array_merge($userfields, $normalfields);
1258         $user = new backup_nested_element('user', array('id', 'contextid'), $userfields);
1260         $customfields = new backup_nested_element('custom_fields');
1262         $customfield = new backup_nested_element('custom_field', array('id'), array(
1263             'field_name', 'field_type', 'field_data'));
1265         $tags = new backup_nested_element('tags');
1267         $tag = new backup_nested_element('tag', array('id'), array(
1268             'name', 'rawname'));
1270         $preferences = new backup_nested_element('preferences');
1272         $preference = new backup_nested_element('preference', array('id'), array(
1273             'name', 'value'));
1275         $roles = new backup_nested_element('roles');
1277         $overrides = new backup_nested_element('role_overrides');
1279         $override = new backup_nested_element('override', array('id'), array(
1280             'roleid', 'capability', 'permission', 'timemodified',
1281             'modifierid'));
1283         $assignments = new backup_nested_element('role_assignments');
1285         $assignment = new backup_nested_element('assignment', array('id'), array(
1286             'roleid', 'userid', 'timemodified', 'modifierid', 'component', //TODO: MDL-22793 add itemid here
1287             'sortorder'));
1289         // Build the tree
1291         $users->add_child($user);
1293         $user->add_child($customfields);
1294         $customfields->add_child($customfield);
1296         $user->add_child($tags);
1297         $tags->add_child($tag);
1299         $user->add_child($preferences);
1300         $preferences->add_child($preference);
1302         $user->add_child($roles);
1304         $roles->add_child($overrides);
1305         $roles->add_child($assignments);
1307         $overrides->add_child($override);
1308         $assignments->add_child($assignment);
1310         // Define sources
1312         $user->set_source_sql('SELECT u.*, c.id AS contextid, m.wwwroot AS mnethosturl
1313                                  FROM {user} u
1314                                  JOIN {backup_ids_temp} bi ON bi.itemid = u.id
1315                             LEFT JOIN {context} c ON c.instanceid = u.id AND c.contextlevel = ' . CONTEXT_USER . '
1316                             LEFT JOIN {mnet_host} m ON m.id = u.mnethostid
1317                                 WHERE bi.backupid = ?
1318                                   AND bi.itemname = ?', array(
1319                                       backup_helper::is_sqlparam($this->get_backupid()),
1320                                       backup_helper::is_sqlparam('userfinal')));
1322         // All the rest on information is only added if we arent
1323         // in an anonymized backup
1324         if (!$anonymize) {
1325             $customfield->set_source_sql('SELECT f.id, f.shortname, f.datatype, d.data
1326                                             FROM {user_info_field} f
1327                                             JOIN {user_info_data} d ON d.fieldid = f.id
1328                                            WHERE d.userid = ?', array(backup::VAR_PARENTID));
1330             $customfield->set_source_alias('shortname', 'field_name');
1331             $customfield->set_source_alias('datatype',  'field_type');
1332             $customfield->set_source_alias('data',      'field_data');
1334             $tag->set_source_sql('SELECT t.id, t.name, t.rawname
1335                                     FROM {tag} t
1336                                     JOIN {tag_instance} ti ON ti.tagid = t.id
1337                                    WHERE ti.itemtype = ?
1338                                      AND ti.itemid = ?', array(
1339                                          backup_helper::is_sqlparam('user'),
1340                                          backup::VAR_PARENTID));
1342             $preference->set_source_table('user_preferences', array('userid' => backup::VAR_PARENTID));
1344             $override->set_source_table('role_capabilities', array('contextid' => '/users/user/contextid'));
1346             // Assignments only added if specified
1347             if ($roleassignments) {
1348                 $assignment->set_source_table('role_assignments', array('contextid' => '/users/user/contextid'));
1349             }
1351             // Define id annotations (as final)
1352             $override->annotate_ids('rolefinal', 'roleid');
1353         }
1355         // Return root element (users)
1356         return $users;
1357     }
1360 /**
1361  * structure step in charge of constructing the block.xml file for one
1362  * given block (instance and positions). If the block has custom DB structure
1363  * that will go to a separate file (different step defined in block class)
1364  */
1365 class backup_block_instance_structure_step extends backup_structure_step {
1367     protected function define_structure() {
1368         global $DB;
1370         // Define each element separated
1372         $block = new backup_nested_element('block', array('id', 'contextid', 'version'), array(
1373             'blockname', 'parentcontextid', 'showinsubcontexts', 'pagetypepattern',
1374             'subpagepattern', 'defaultregion', 'defaultweight', 'configdata'));
1376         $positions = new backup_nested_element('block_positions');
1378         $position = new backup_nested_element('block_position', array('id'), array(
1379             'contextid', 'pagetype', 'subpage', 'visible',
1380             'region', 'weight'));
1382         // Build the tree
1384         $block->add_child($positions);
1385         $positions->add_child($position);
1387         // Transform configdata information if needed (process links and friends)
1388         $blockrec = $DB->get_record('block_instances', array('id' => $this->task->get_blockid()));
1389         if ($attrstotransform = $this->task->get_configdata_encoded_attributes()) {
1390             $configdata = (array)unserialize(base64_decode($blockrec->configdata));
1391             foreach ($configdata as $attribute => $value) {
1392                 if (in_array($attribute, $attrstotransform)) {
1393                     $configdata[$attribute] = $this->contenttransformer->process($value);
1394                 }
1395             }
1396             $blockrec->configdata = base64_encode(serialize((object)$configdata));
1397         }
1398         $blockrec->contextid = $this->task->get_contextid();
1399         // Get the version of the block
1400         $blockrec->version = get_config('block_'.$this->task->get_blockname(), 'version');
1402         // Define sources
1404         $block->set_source_array(array($blockrec));
1406         $position->set_source_table('block_positions', array('blockinstanceid' => backup::VAR_PARENTID));
1408         // File anotations (for fileareas specified on each block)
1409         foreach ($this->task->get_fileareas() as $filearea) {
1410             $block->annotate_files('block_' . $this->task->get_blockname(), $filearea, null);
1411         }
1413         // Return the root element (block)
1414         return $block;
1415     }
1418 /**
1419  * structure step in charge of constructing the logs.xml file for all the log records found
1420  * in course. Note that we are sending to backup ALL the log records having cmid = 0. That
1421  * includes some records that won't be restoreable (like 'upload', 'calendar'...) but we do
1422  * that just in case they become restored some day in the future
1423  */
1424 class backup_course_logs_structure_step extends backup_structure_step {
1426     protected function define_structure() {
1428         // Define each element separated
1430         $logs = new backup_nested_element('logs');
1432         $log = new backup_nested_element('log', array('id'), array(
1433             'time', 'userid', 'ip', 'module',
1434             'action', 'url', 'info'));
1436         // Build the tree
1438         $logs->add_child($log);
1440         // Define sources (all the records belonging to the course, having cmid = 0)
1442         $log->set_source_table('log', array('course' => backup::VAR_COURSEID, 'cmid' => backup_helper::is_sqlparam(0)));
1444         // Annotations
1445         // NOTE: We don't annotate users from logs as far as they MUST be
1446         //       always annotated by the course (enrol, ras... whatever)
1448         // Return the root element (logs)
1450         return $logs;
1451     }
1454 /**
1455  * structure step in charge of constructing the logs.xml file for all the log records found
1456  * in activity
1457  */
1458 class backup_activity_logs_structure_step extends backup_structure_step {
1460     protected function define_structure() {
1462         // Define each element separated
1464         $logs = new backup_nested_element('logs');
1466         $log = new backup_nested_element('log', array('id'), array(
1467             'time', 'userid', 'ip', 'module',
1468             'action', 'url', 'info'));
1470         // Build the tree
1472         $logs->add_child($log);
1474         // Define sources
1476         $log->set_source_table('log', array('cmid' => backup::VAR_MODID));
1478         // Annotations
1479         // NOTE: We don't annotate users from logs as far as they MUST be
1480         //       always annotated by the activity (true participants).
1482         // Return the root element (logs)
1484         return $logs;
1485     }
1488 /**
1489  * Structure step in charge of constructing the logstores.xml file for the course logs.
1490  *
1491  * This backup step will backup the logs for all the enabled logstore subplugins supporting
1492  * it, for logs belonging to the course level.
1493  */
1494 class backup_course_logstores_structure_step extends backup_structure_step {
1496     protected function define_structure() {
1498         // Define the structure of logstores container.
1499         $logstores = new backup_nested_element('logstores');
1500         $logstore = new backup_nested_element('logstore');
1501         $logstores->add_child($logstore);
1503         // Add the tool_log logstore subplugins information to the logstore element.
1504         $this->add_subplugin_structure('logstore', $logstore, true, 'tool', 'log');
1506         return $logstores;
1507     }
1510 /**
1511  * Structure step in charge of constructing the logstores.xml file for the activity logs.
1512  *
1513  * Note: Activity structure is completely equivalent to the course one, so just extend it.
1514  */
1515 class backup_activity_logstores_structure_step extends backup_course_logstores_structure_step {
1518 /**
1519  * structure in charge of constructing the inforef.xml file for all the items we want
1520  * to have referenced there (users, roles, files...)
1521  */
1522 class backup_inforef_structure_step extends backup_structure_step {
1524     protected function define_structure() {
1526         // Items we want to include in the inforef file.
1527         $items = backup_helper::get_inforef_itemnames();
1529         // Build the tree
1531         $inforef = new backup_nested_element('inforef');
1533         // For each item, conditionally, if there are already records, build element
1534         foreach ($items as $itemname) {
1535             if (backup_structure_dbops::annotations_exist($this->get_backupid(), $itemname)) {
1536                 $elementroot = new backup_nested_element($itemname . 'ref');
1537                 $element = new backup_nested_element($itemname, array(), array('id'));
1538                 $inforef->add_child($elementroot);
1539                 $elementroot->add_child($element);
1540                 $element->set_source_sql("
1541                     SELECT itemid AS id
1542                      FROM {backup_ids_temp}
1543                     WHERE backupid = ?
1544                       AND itemname = ?",
1545                    array(backup::VAR_BACKUPID, backup_helper::is_sqlparam($itemname)));
1546             }
1547         }
1549         // We don't annotate anything there, but rely in the next step
1550         // (move_inforef_annotations_to_final) that will change all the
1551         // already saved 'inforref' entries to their 'final' annotations.
1552         return $inforef;
1553     }
1556 /**
1557  * This step will get all the annotations already processed to inforef.xml file and
1558  * transform them into 'final' annotations.
1559  */
1560 class move_inforef_annotations_to_final extends backup_execution_step {
1562     protected function define_execution() {
1564         // Items we want to include in the inforef file
1565         $items = backup_helper::get_inforef_itemnames();
1566         $progress = $this->task->get_progress();
1567         $progress->start_progress($this->get_name(), count($items));
1568         $done = 1;
1569         foreach ($items as $itemname) {
1570             // Delegate to dbops
1571             backup_structure_dbops::move_annotations_to_final($this->get_backupid(),
1572                     $itemname, $progress);
1573             $progress->progress($done++);
1574         }
1575         $progress->end_progress();
1576     }
1579 /**
1580  * structure in charge of constructing the files.xml file with all the
1581  * annotated (final) files along the process. At, the same time, and
1582  * using one specialised nested_element, will copy them form moodle storage
1583  * to backup storage
1584  */
1585 class backup_final_files_structure_step extends backup_structure_step {
1587     protected function define_structure() {
1589         // Define elements
1591         $files = new backup_nested_element('files');
1593         $file = new file_nested_element('file', array('id'), array(
1594             'contenthash', 'contextid', 'component', 'filearea', 'itemid',
1595             'filepath', 'filename', 'userid', 'filesize',
1596             'mimetype', 'status', 'timecreated', 'timemodified',
1597             'source', 'author', 'license', 'sortorder',
1598             'repositorytype', 'repositoryid', 'reference'));
1600         // Build the tree
1602         $files->add_child($file);
1604         // Define sources
1606         $file->set_source_sql("SELECT f.*, r.type AS repositorytype, fr.repositoryid, fr.reference
1607                                  FROM {files} f
1608                                       LEFT JOIN {files_reference} fr ON fr.id = f.referencefileid
1609                                       LEFT JOIN {repository_instances} ri ON ri.id = fr.repositoryid
1610                                       LEFT JOIN {repository} r ON r.id = ri.typeid
1611                                       JOIN {backup_ids_temp} bi ON f.id = bi.itemid
1612                                 WHERE bi.backupid = ?
1613                                   AND bi.itemname = 'filefinal'", array(backup::VAR_BACKUPID));
1615         return $files;
1616     }
1619 /**
1620  * Structure step in charge of creating the main moodle_backup.xml file
1621  * where all the information related to the backup, settings, license and
1622  * other information needed on restore is added*/
1623 class backup_main_structure_step extends backup_structure_step {
1625     protected function define_structure() {
1627         global $CFG;
1629         $info = array();
1631         $info['name'] = $this->get_setting_value('filename');
1632         $info['moodle_version'] = $CFG->version;
1633         $info['moodle_release'] = $CFG->release;
1634         $info['backup_version'] = $CFG->backup_version;
1635         $info['backup_release'] = $CFG->backup_release;
1636         $info['backup_date']    = time();
1637         $info['backup_uniqueid']= $this->get_backupid();
1638         $info['mnet_remoteusers']=backup_controller_dbops::backup_includes_mnet_remote_users($this->get_backupid());
1639         $info['include_files'] = backup_controller_dbops::backup_includes_files($this->get_backupid());
1640         $info['include_file_references_to_external_content'] =
1641                 backup_controller_dbops::backup_includes_file_references($this->get_backupid());
1642         $info['original_wwwroot']=$CFG->wwwroot;
1643         $info['original_site_identifier_hash'] = md5(get_site_identifier());
1644         $info['original_course_id'] = $this->get_courseid();
1645         $originalcourseinfo = backup_controller_dbops::backup_get_original_course_info($this->get_courseid());
1646         $info['original_course_format'] = $originalcourseinfo->format;
1647         $info['original_course_fullname']  = $originalcourseinfo->fullname;
1648         $info['original_course_shortname'] = $originalcourseinfo->shortname;
1649         $info['original_course_startdate'] = $originalcourseinfo->startdate;
1650         $info['original_course_contextid'] = context_course::instance($this->get_courseid())->id;
1651         $info['original_system_contextid'] = context_system::instance()->id;
1653         // Get more information from controller
1654         list($dinfo, $cinfo, $sinfo) = backup_controller_dbops::get_moodle_backup_information(
1655                 $this->get_backupid(), $this->get_task()->get_progress());
1657         // Define elements
1659         $moodle_backup = new backup_nested_element('moodle_backup');
1661         $information = new backup_nested_element('information', null, array(
1662             'name', 'moodle_version', 'moodle_release', 'backup_version',
1663             'backup_release', 'backup_date', 'mnet_remoteusers', 'include_files', 'include_file_references_to_external_content', 'original_wwwroot',
1664             'original_site_identifier_hash', 'original_course_id', 'original_course_format',
1665             'original_course_fullname', 'original_course_shortname', 'original_course_startdate',
1666             'original_course_contextid', 'original_system_contextid'));
1668         $details = new backup_nested_element('details');
1670         $detail = new backup_nested_element('detail', array('backup_id'), array(
1671             'type', 'format', 'interactive', 'mode',
1672             'execution', 'executiontime'));
1674         $contents = new backup_nested_element('contents');
1676         $activities = new backup_nested_element('activities');
1678         $activity = new backup_nested_element('activity', null, array(
1679             'moduleid', 'sectionid', 'modulename', 'title',
1680             'directory'));
1682         $sections = new backup_nested_element('sections');
1684         $section = new backup_nested_element('section', null, array(
1685             'sectionid', 'title', 'directory'));
1687         $course = new backup_nested_element('course', null, array(
1688             'courseid', 'title', 'directory'));
1690         $settings = new backup_nested_element('settings');
1692         $setting = new backup_nested_element('setting', null, array(
1693             'level', 'section', 'activity', 'name', 'value'));
1695         // Build the tree
1697         $moodle_backup->add_child($information);
1699         $information->add_child($details);
1700         $details->add_child($detail);
1702         $information->add_child($contents);
1703         if (!empty($cinfo['activities'])) {
1704             $contents->add_child($activities);
1705             $activities->add_child($activity);
1706         }
1707         if (!empty($cinfo['sections'])) {
1708             $contents->add_child($sections);
1709             $sections->add_child($section);
1710         }
1711         if (!empty($cinfo['course'])) {
1712             $contents->add_child($course);
1713         }
1715         $information->add_child($settings);
1716         $settings->add_child($setting);
1719         // Set the sources
1721         $information->set_source_array(array((object)$info));
1723         $detail->set_source_array($dinfo);
1725         $activity->set_source_array($cinfo['activities']);
1727         $section->set_source_array($cinfo['sections']);
1729         $course->set_source_array($cinfo['course']);
1731         $setting->set_source_array($sinfo);
1733         // Prepare some information to be sent to main moodle_backup.xml file
1734         return $moodle_backup;
1735     }
1739 /**
1740  * Execution step that will generate the final zip (.mbz) file with all the contents
1741  */
1742 class backup_zip_contents extends backup_execution_step implements file_progress {
1743     /**
1744      * @var bool True if we have started tracking progress
1745      */
1746     protected $startedprogress;
1748     protected function define_execution() {
1750         // Get basepath
1751         $basepath = $this->get_basepath();
1753         // Get the list of files in directory
1754         $filestemp = get_directory_list($basepath, '', false, true, true);
1755         $files = array();
1756         foreach ($filestemp as $file) { // Add zip paths and fs paths to all them
1757             $files[$file] = $basepath . '/' . $file;
1758         }
1760         // Add the log file if exists
1761         $logfilepath = $basepath . '.log';
1762         if (file_exists($logfilepath)) {
1763              $files['moodle_backup.log'] = $logfilepath;
1764         }
1766         // Calculate the zip fullpath (in OS temp area it's always backup.mbz)
1767         $zipfile = $basepath . '/backup.mbz';
1769         // Get the zip packer
1770         $zippacker = get_file_packer('application/vnd.moodle.backup');
1772         // Track overall progress for the 2 long-running steps (archive to
1773         // pathname, get backup information).
1774         $reporter = $this->task->get_progress();
1775         $reporter->start_progress('backup_zip_contents', 2);
1777         // Zip files
1778         $result = $zippacker->archive_to_pathname($files, $zipfile, true, $this);
1780         // If any sub-progress happened, end it.
1781         if ($this->startedprogress) {
1782             $this->task->get_progress()->end_progress();
1783             $this->startedprogress = false;
1784         } else {
1785             // No progress was reported, manually move it on to the next overall task.
1786             $reporter->progress(1);
1787         }
1789         // Something went wrong.
1790         if ($result === false) {
1791             @unlink($zipfile);
1792             throw new backup_step_exception('error_zip_packing', '', 'An error was encountered while trying to generate backup zip');
1793         }
1794         // Read to make sure it is a valid backup. Refer MDL-37877 . Delete it, if found not to be valid.
1795         try {
1796             backup_general_helper::get_backup_information_from_mbz($zipfile, $this);
1797         } catch (backup_helper_exception $e) {
1798             @unlink($zipfile);
1799             throw new backup_step_exception('error_zip_packing', '', $e->debuginfo);
1800         }
1802         // If any sub-progress happened, end it.
1803         if ($this->startedprogress) {
1804             $this->task->get_progress()->end_progress();
1805             $this->startedprogress = false;
1806         } else {
1807             $reporter->progress(2);
1808         }
1809         $reporter->end_progress();
1810     }
1812     /**
1813      * Implementation for file_progress interface to display unzip progress.
1814      *
1815      * @param int $progress Current progress
1816      * @param int $max Max value
1817      */
1818     public function progress($progress = file_progress::INDETERMINATE, $max = file_progress::INDETERMINATE) {
1819         $reporter = $this->task->get_progress();
1821         // Start tracking progress if necessary.
1822         if (!$this->startedprogress) {
1823             $reporter->start_progress('extract_file_to_dir', ($max == file_progress::INDETERMINATE)
1824                     ? \core\progress\base::INDETERMINATE : $max);
1825             $this->startedprogress = true;
1826         }
1828         // Pass progress through to whatever handles it.
1829         $reporter->progress(($progress == file_progress::INDETERMINATE)
1830                 ? \core\progress\base::INDETERMINATE : $progress);
1831      }
1834 /**
1835  * This step will send the generated backup file to its final destination
1836  */
1837 class backup_store_backup_file extends backup_execution_step {
1839     protected function define_execution() {
1841         // Get basepath
1842         $basepath = $this->get_basepath();
1844         // Calculate the zip fullpath (in OS temp area it's always backup.mbz)
1845         $zipfile = $basepath . '/backup.mbz';
1847         $has_file_references = backup_controller_dbops::backup_includes_file_references($this->get_backupid());
1848         // Perform storage and return it (TODO: shouldn't be array but proper result object)
1849         return array(
1850             'backup_destination' => backup_helper::store_backup_file($this->get_backupid(), $zipfile,
1851                     $this->task->get_progress()),
1852             'include_file_references_to_external_content' => $has_file_references
1853         );
1854     }
1858 /**
1859  * This step will search for all the activity (not calculations, categories nor aggregations) grade items
1860  * and put them to the backup_ids tables, to be used later as base to backup them
1861  */
1862 class backup_activity_grade_items_to_ids extends backup_execution_step {
1864     protected function define_execution() {
1866         // Fetch all activity grade items
1867         if ($items = grade_item::fetch_all(array(
1868                          'itemtype' => 'mod', 'itemmodule' => $this->task->get_modulename(),
1869                          'iteminstance' => $this->task->get_activityid(), 'courseid' => $this->task->get_courseid()))) {
1870             // Annotate them in backup_ids
1871             foreach ($items as $item) {
1872                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grade_item', $item->id);
1873             }
1874         }
1875     }
1879 /**
1880  * This step allows enrol plugins to annotate custom fields.
1881  *
1882  * @package   core_backup
1883  * @copyright 2014 University of Wisconsin
1884  * @author    Matt Petro
1885  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1886  */
1887 class backup_enrolments_execution_step extends backup_execution_step {
1889     /**
1890      * Function that will contain all the code to be executed.
1891      */
1892     protected function define_execution() {
1893         global $DB;
1895         $plugins = enrol_get_plugins(true);
1896         $enrols = $DB->get_records('enrol', array(
1897                 'courseid' => $this->task->get_courseid()));
1899         // Allow each enrol plugin to add annotations.
1900         foreach ($enrols as $enrol) {
1901             if (isset($plugins[$enrol->enrol])) {
1902                 $plugins[$enrol->enrol]->backup_annotate_custom_fields($this, $enrol);
1903             }
1904         }
1905     }
1907     /**
1908      * Annotate a single name/id pair.
1909      * This can be called from {@link enrol_plugin::backup_annotate_custom_fields()}.
1910      *
1911      * @param string $itemname
1912      * @param int $itemid
1913      */
1914     public function annotate_id($itemname, $itemid) {
1915         backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), $itemname, $itemid);
1916     }
1919 /**
1920  * This step will annotate all the groups and groupings belonging to the course
1921  */
1922 class backup_annotate_course_groups_and_groupings extends backup_execution_step {
1924     protected function define_execution() {
1925         global $DB;
1927         // Get all the course groups
1928         if ($groups = $DB->get_records('groups', array(
1929                 'courseid' => $this->task->get_courseid()))) {
1930             foreach ($groups as $group) {
1931                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->id);
1932             }
1933         }
1935         // Get all the course groupings
1936         if ($groupings = $DB->get_records('groupings', array(
1937                 'courseid' => $this->task->get_courseid()))) {
1938             foreach ($groupings as $grouping) {
1939                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grouping', $grouping->id);
1940             }
1941         }
1942     }
1945 /**
1946  * This step will annotate all the groups belonging to already annotated groupings
1947  */
1948 class backup_annotate_groups_from_groupings extends backup_execution_step {
1950     protected function define_execution() {
1951         global $DB;
1953         // Fetch all the annotated groupings
1954         if ($groupings = $DB->get_records('backup_ids_temp', array(
1955                 'backupid' => $this->get_backupid(), 'itemname' => 'grouping'))) {
1956             foreach ($groupings as $grouping) {
1957                 if ($groups = $DB->get_records('groupings_groups', array(
1958                         'groupingid' => $grouping->itemid))) {
1959                     foreach ($groups as $group) {
1960                         backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->groupid);
1961                     }
1962                 }
1963             }
1964         }
1965     }
1968 /**
1969  * This step will annotate all the scales belonging to already annotated outcomes
1970  */
1971 class backup_annotate_scales_from_outcomes extends backup_execution_step {
1973     protected function define_execution() {
1974         global $DB;
1976         // Fetch all the annotated outcomes
1977         if ($outcomes = $DB->get_records('backup_ids_temp', array(
1978                 'backupid' => $this->get_backupid(), 'itemname' => 'outcome'))) {
1979             foreach ($outcomes as $outcome) {
1980                 if ($scale = $DB->get_record('grade_outcomes', array(
1981                         'id' => $outcome->itemid))) {
1982                     // Annotate as scalefinal because it's > 0
1983                     backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'scalefinal', $scale->scaleid);
1984                 }
1985             }
1986         }
1987     }
1990 /**
1991  * This step will generate all the file annotations for the already
1992  * annotated (final) question_categories. It calculates the different
1993  * contexts that are being backup and, annotates all the files
1994  * on every context belonging to the "question" component. As far as
1995  * we are always including *complete* question banks it is safe and
1996  * optimal to do that in this (one pass) way
1997  */
1998 class backup_annotate_all_question_files extends backup_execution_step {
2000     protected function define_execution() {
2001         global $DB;
2003         // Get all the different contexts for the final question_categories
2004         // annotated along the whole backup
2005         $rs = $DB->get_recordset_sql("SELECT DISTINCT qc.contextid
2006                                         FROM {question_categories} qc
2007                                         JOIN {backup_ids_temp} bi ON bi.itemid = qc.id
2008                                        WHERE bi.backupid = ?
2009                                          AND bi.itemname = 'question_categoryfinal'", array($this->get_backupid()));
2010         // To know about qtype specific components/fileareas
2011         $components = backup_qtype_plugin::get_components_and_fileareas();
2012         // Let's loop
2013         foreach($rs as $record) {
2014             // Backup all the file areas the are managed by the core question component.
2015             // That is, by the question_type base class. In particular, we don't want
2016             // to include files belonging to responses here.
2017             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', 'questiontext', null);
2018             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', 'generalfeedback', null);
2019             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', 'answer', null);
2020             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', 'answerfeedback', null);
2021             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', 'hint', null);
2022             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', 'correctfeedback', null);
2023             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', 'partiallycorrectfeedback', null);
2024             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', 'incorrectfeedback', null);
2026             // For files belonging to question types, we make the leap of faith that
2027             // all the files belonging to the question type are part of the question definition,
2028             // so we can just backup all the files in bulk, without specifying each
2029             // file area name separately.
2030             foreach ($components as $component => $fileareas) {
2031                 backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, $component, null, null);
2032             }
2033         }
2034         $rs->close();
2035     }
2038 /**
2039  * structure step in charge of constructing the questions.xml file for all the
2040  * question categories and questions required by the backup
2041  * and letters related to one activity
2042  */
2043 class backup_questions_structure_step extends backup_structure_step {
2045     protected function define_structure() {
2047         // Define each element separated
2049         $qcategories = new backup_nested_element('question_categories');
2051         $qcategory = new backup_nested_element('question_category', array('id'), array(
2052             'name', 'contextid', 'contextlevel', 'contextinstanceid',
2053             'info', 'infoformat', 'stamp', 'parent',
2054             'sortorder'));
2056         $questions = new backup_nested_element('questions');
2058         $question = new backup_nested_element('question', array('id'), array(
2059             'parent', 'name', 'questiontext', 'questiontextformat',
2060             'generalfeedback', 'generalfeedbackformat', 'defaultmark', 'penalty',
2061             'qtype', 'length', 'stamp', 'version',
2062             'hidden', 'timecreated', 'timemodified', 'createdby', 'modifiedby'));
2064         // attach qtype plugin structure to $question element, only one allowed
2065         $this->add_plugin_structure('qtype', $question, false);
2067         // attach local plugin stucture to $question element, multiple allowed
2068         $this->add_plugin_structure('local', $question, true);
2070         $qhints = new backup_nested_element('question_hints');
2072         $qhint = new backup_nested_element('question_hint', array('id'), array(
2073             'hint', 'hintformat', 'shownumcorrect', 'clearwrong', 'options'));
2075         $tags = new backup_nested_element('tags');
2077         $tag = new backup_nested_element('tag', array('id'), array('name', 'rawname'));
2079         // Build the tree
2081         $qcategories->add_child($qcategory);
2082         $qcategory->add_child($questions);
2083         $questions->add_child($question);
2084         $question->add_child($qhints);
2085         $qhints->add_child($qhint);
2087         $question->add_child($tags);
2088         $tags->add_child($tag);
2090         // Define the sources
2092         $qcategory->set_source_sql("
2093             SELECT gc.*, contextlevel, instanceid AS contextinstanceid
2094               FROM {question_categories} gc
2095               JOIN {backup_ids_temp} bi ON bi.itemid = gc.id
2096               JOIN {context} co ON co.id = gc.contextid
2097              WHERE bi.backupid = ?
2098                AND bi.itemname = 'question_categoryfinal'", array(backup::VAR_BACKUPID));
2100         $question->set_source_table('question', array('category' => backup::VAR_PARENTID));
2102         $qhint->set_source_sql('
2103                 SELECT *
2104                 FROM {question_hints}
2105                 WHERE questionid = :questionid
2106                 ORDER BY id',
2107                 array('questionid' => backup::VAR_PARENTID));
2109         $tag->set_source_sql("SELECT t.id, t.name, t.rawname
2110                               FROM {tag} t
2111                               JOIN {tag_instance} ti ON ti.tagid = t.id
2112                               WHERE ti.itemid = ?
2113                               AND ti.itemtype = 'question'", array(backup::VAR_PARENTID));
2115         // don't need to annotate ids nor files
2116         // (already done by {@link backup_annotate_all_question_files}
2118         return $qcategories;
2119     }
2124 /**
2125  * This step will generate all the file  annotations for the already
2126  * annotated (final) users. Need to do this here because each user
2127  * has its own context and structure tasks only are able to handle
2128  * one context. Also, this step will guarantee that every user has
2129  * its context created (req for other steps)
2130  */
2131 class backup_annotate_all_user_files extends backup_execution_step {
2133     protected function define_execution() {
2134         global $DB;
2136         // List of fileareas we are going to annotate
2137         $fileareas = array('profile', 'icon');
2139         // Fetch all annotated (final) users
2140         $rs = $DB->get_recordset('backup_ids_temp', array(
2141             'backupid' => $this->get_backupid(), 'itemname' => 'userfinal'));
2142         $progress = $this->task->get_progress();
2143         $progress->start_progress($this->get_name());
2144         foreach ($rs as $record) {
2145             $userid = $record->itemid;
2146             $userctx = context_user::instance($userid, IGNORE_MISSING);
2147             if (!$userctx) {
2148                 continue; // User has not context, sure it's a deleted user, so cannot have files
2149             }
2150             // Proceed with every user filearea
2151             foreach ($fileareas as $filearea) {
2152                 // We don't need to specify itemid ($userid - 5th param) as far as by
2153                 // context we can get all the associated files. See MDL-22092
2154                 backup_structure_dbops::annotate_files($this->get_backupid(), $userctx->id, 'user', $filearea, null);
2155                 $progress->progress();
2156             }
2157         }
2158         $progress->end_progress();
2159         $rs->close();
2160     }
2164 /**
2165  * Defines the backup step for advanced grading methods attached to the activity module
2166  */
2167 class backup_activity_grading_structure_step extends backup_structure_step {
2169     /**
2170      * Include the grading.xml only if the module supports advanced grading
2171      */
2172     protected function execute_condition() {
2174         // No grades on the front page.
2175         if ($this->get_courseid() == SITEID) {
2176             return false;
2177         }
2179         return plugin_supports('mod', $this->get_task()->get_modulename(), FEATURE_ADVANCED_GRADING, false);
2180     }
2182     /**
2183      * Declares the gradable areas structures and data sources
2184      */
2185     protected function define_structure() {
2187         // To know if we are including userinfo
2188         $userinfo = $this->get_setting_value('userinfo');
2190         // Define the elements
2192         $areas = new backup_nested_element('areas');
2194         $area = new backup_nested_element('area', array('id'), array(
2195             'areaname', 'activemethod'));
2197         $definitions = new backup_nested_element('definitions');
2199         $definition = new backup_nested_element('definition', array('id'), array(
2200             'method', 'name', 'description', 'descriptionformat', 'status',
2201             'timecreated', 'timemodified', 'options'));
2203         $instances = new backup_nested_element('instances');
2205         $instance = new backup_nested_element('instance', array('id'), array(
2206             'raterid', 'itemid', 'rawgrade', 'status', 'feedback',
2207             'feedbackformat', 'timemodified'));
2209         // Build the tree including the method specific structures
2210         // (beware - the order of how gradingform plugins structures are attached is important)
2211         $areas->add_child($area);
2212         // attach local plugin stucture to $area element, multiple allowed
2213         $this->add_plugin_structure('local', $area, true);
2214         $area->add_child($definitions);
2215         $definitions->add_child($definition);
2216         $this->add_plugin_structure('gradingform', $definition, true);
2217         // attach local plugin stucture to $definition element, multiple allowed
2218         $this->add_plugin_structure('local', $definition, true);
2219         $definition->add_child($instances);
2220         $instances->add_child($instance);
2221         $this->add_plugin_structure('gradingform', $instance, false);
2222         // attach local plugin stucture to $instance element, multiple allowed
2223         $this->add_plugin_structure('local', $instance, true);
2225         // Define data sources
2227         $area->set_source_table('grading_areas', array('contextid' => backup::VAR_CONTEXTID,
2228             'component' => array('sqlparam' => 'mod_'.$this->get_task()->get_modulename())));
2230         $definition->set_source_table('grading_definitions', array('areaid' => backup::VAR_PARENTID));
2232         if ($userinfo) {
2233             $instance->set_source_table('grading_instances', array('definitionid' => backup::VAR_PARENTID));
2234         }
2236         // Annotate references
2237         $definition->annotate_files('grading', 'description', 'id');
2238         $instance->annotate_ids('user', 'raterid');
2240         // Return the root element
2241         return $areas;
2242     }
2246 /**
2247  * structure step in charge of constructing the grades.xml file for all the grade items
2248  * and letters related to one activity
2249  */
2250 class backup_activity_grades_structure_step extends backup_structure_step {
2252     /**
2253      * No grades on the front page.
2254      * @return bool
2255      */
2256     protected function execute_condition() {
2257         return ($this->get_courseid() != SITEID);
2258     }
2260     protected function define_structure() {
2262         // To know if we are including userinfo
2263         $userinfo = $this->get_setting_value('userinfo');
2265         // Define each element separated
2267         $book = new backup_nested_element('activity_gradebook');
2269         $items = new backup_nested_element('grade_items');
2271         $item = new backup_nested_element('grade_item', array('id'), array(
2272             'categoryid', 'itemname', 'itemtype', 'itemmodule',
2273             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
2274             'calculation', 'gradetype', 'grademax', 'grademin',
2275             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
2276             'plusfactor', 'aggregationcoef', 'aggregationcoef2', 'weightoverride',
2277             'sortorder', 'display', 'decimals', 'hidden', 'locked', 'locktime',
2278             'needsupdate', 'timecreated', 'timemodified'));
2280         $grades = new backup_nested_element('grade_grades');
2282         $grade = new backup_nested_element('grade_grade', array('id'), array(
2283             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
2284             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
2285             'locked', 'locktime', 'exported', 'overridden',
2286             'excluded', 'feedback', 'feedbackformat', 'information',
2287             'informationformat', 'timecreated', 'timemodified',
2288             'aggregationstatus', 'aggregationweight'));
2290         $letters = new backup_nested_element('grade_letters');
2292         $letter = new backup_nested_element('grade_letter', 'id', array(
2293             'lowerboundary', 'letter'));
2295         // Build the tree
2297         $book->add_child($items);
2298         $items->add_child($item);
2300         $item->add_child($grades);
2301         $grades->add_child($grade);
2303         $book->add_child($letters);
2304         $letters->add_child($letter);
2306         // Define sources
2308         $item->set_source_sql("SELECT gi.*
2309                                FROM {grade_items} gi
2310                                JOIN {backup_ids_temp} bi ON gi.id = bi.itemid
2311                                WHERE bi.backupid = ?
2312                                AND bi.itemname = 'grade_item'", array(backup::VAR_BACKUPID));
2314         // This only happens if we are including user info
2315         if ($userinfo) {
2316             $grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
2317         }
2319         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
2321         // Annotations
2323         $item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
2324         $item->annotate_ids('outcome', 'outcomeid');
2326         $grade->annotate_ids('user', 'userid');
2327         $grade->annotate_ids('user', 'usermodified');
2329         // Return the root element (book)
2331         return $book;
2332     }
2335 /**
2336  * Structure step in charge of constructing the grade history of an activity.
2337  *
2338  * This step is added to the task regardless of the setting 'grade_histories'.
2339  * The reason is to allow for a more flexible step in case the logic needs to be
2340  * split accross different settings to control the history of items and/or grades.
2341  */
2342 class backup_activity_grade_history_structure_step extends backup_structure_step {
2344     /**
2345      * No grades on the front page.
2346      * @return bool
2347      */
2348     protected function execute_condition() {
2349         return ($this->get_courseid() != SITEID);
2350     }
2352     protected function define_structure() {
2354         // Settings to use.
2355         $userinfo = $this->get_setting_value('userinfo');
2356         $history = $this->get_setting_value('grade_histories');
2358         // Create the nested elements.
2359         $bookhistory = new backup_nested_element('grade_history');
2360         $grades = new backup_nested_element('grade_grades');
2361         $grade = new backup_nested_element('grade_grade', array('id'), array(
2362             'action', 'oldid', 'source', 'loggeduser', 'itemid', 'userid',
2363             'rawgrade', 'rawgrademax', 'rawgrademin', 'rawscaleid',
2364             'usermodified', 'finalgrade', 'hidden', 'locked', 'locktime', 'exported', 'overridden',
2365             'excluded', 'feedback', 'feedbackformat', 'information',
2366             'informationformat', 'timemodified'));
2368         // Build the tree.
2369         $bookhistory->add_child($grades);
2370         $grades->add_child($grade);
2372         // This only happens if we are including user info and history.
2373         if ($userinfo && $history) {
2374             // Define sources. Only select the history related to existing activity items.
2375             $grade->set_source_sql("SELECT ggh.*
2376                                      FROM {grade_grades_history} ggh
2377                                      JOIN {backup_ids_temp} bi ON ggh.itemid = bi.itemid
2378                                     WHERE bi.backupid = ?
2379                                       AND bi.itemname = 'grade_item'", array(backup::VAR_BACKUPID));
2380         }
2382         // Annotations.
2383         $grade->annotate_ids('scalefinal', 'rawscaleid'); // Straight as scalefinal because it's > 0.
2384         $grade->annotate_ids('user', 'loggeduser');
2385         $grade->annotate_ids('user', 'userid');
2386         $grade->annotate_ids('user', 'usermodified');
2388         // Return the root element.
2389         return $bookhistory;
2390     }
2393 /**
2394  * Backups up the course completion information for the course.
2395  */
2396 class backup_course_completion_structure_step extends backup_structure_step {
2398     protected function execute_condition() {
2400         // No completion on front page.
2401         if ($this->get_courseid() == SITEID) {
2402             return false;
2403         }
2405         // Check that all activities have been included
2406         if ($this->task->is_excluding_activities()) {
2407             return false;
2408         }
2409         return true;
2410     }
2412     /**
2413      * The structure of the course completion backup
2414      *
2415      * @return backup_nested_element
2416      */
2417     protected function define_structure() {
2419         // To know if we are including user completion info
2420         $userinfo = $this->get_setting_value('userscompletion');
2422         $cc = new backup_nested_element('course_completion');
2424         $criteria = new backup_nested_element('course_completion_criteria', array('id'), array(
2425             'course', 'criteriatype', 'module', 'moduleinstance', 'courseinstanceshortname', 'enrolperiod',
2426             'timeend', 'gradepass', 'role', 'roleshortname'
2427         ));
2429         $criteriacompletions = new backup_nested_element('course_completion_crit_completions');
2431         $criteriacomplete = new backup_nested_element('course_completion_crit_compl', array('id'), array(
2432             'criteriaid', 'userid', 'gradefinal', 'unenrolled', 'timecompleted'
2433         ));
2435         $coursecompletions = new backup_nested_element('course_completions', array('id'), array(
2436             'userid', 'course', 'timeenrolled', 'timestarted', 'timecompleted', 'reaggregate'
2437         ));
2439         $aggregatemethod = new backup_nested_element('course_completion_aggr_methd', array('id'), array(
2440             'course','criteriatype','method','value'
2441         ));
2443         $cc->add_child($criteria);
2444             $criteria->add_child($criteriacompletions);
2445                 $criteriacompletions->add_child($criteriacomplete);
2446         $cc->add_child($coursecompletions);
2447         $cc->add_child($aggregatemethod);
2449         // We need some extra data for the restore.
2450         // - courseinstances shortname rather than an ID.
2451         // - roleshortname in case restoring on a different site.
2452         $sourcesql = "SELECT ccc.*, c.shortname AS courseinstanceshortname, r.shortname AS roleshortname
2453                         FROM {course_completion_criteria} ccc
2454                    LEFT JOIN {course} c ON c.id = ccc.courseinstance
2455                    LEFT JOIN {role} r ON r.id = ccc.role
2456                        WHERE ccc.course = ?";
2457         $criteria->set_source_sql($sourcesql, array(backup::VAR_COURSEID));
2459         $aggregatemethod->set_source_table('course_completion_aggr_methd', array('course' => backup::VAR_COURSEID));
2461         if ($userinfo) {
2462             $criteriacomplete->set_source_table('course_completion_crit_compl', array('criteriaid' => backup::VAR_PARENTID));
2463             $coursecompletions->set_source_table('course_completions', array('course' => backup::VAR_COURSEID));
2464         }
2466         $criteria->annotate_ids('role', 'role');
2467         $criteriacomplete->annotate_ids('user', 'userid');
2468         $coursecompletions->annotate_ids('user', 'userid');
2470         return $cc;
2472     }