9437714206f3d8acbb3a95db6fad7b53b8e66ade
[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,
32  * delete old directories and create temp ids table
33  */
34 class create_and_clean_temp_stuff extends backup_execution_step {
36     protected function define_execution() {
37         backup_helper::check_and_create_backup_dir($this->get_backupid());// Create backup temp dir
38         backup_helper::clear_backup_dir($this->get_backupid());           // Empty temp dir, just in case
39         backup_helper::delete_old_backup_dirs(time() - (4 * 60 * 60));    // Delete > 4 hours temp dirs
40         backup_controller_dbops::create_backup_ids_temp_table($this->get_backupid()); // Create ids temp table
41     }
42 }
44 /**
45  * delete the temp dir used by backup/restore (conditionally),
46  * delete old directories and drop tem ids table. Note we delete
47  * the directory but not the corresponding log file that will be
48  * there for, at least, 4 hours - only delete_old_backup_dirs()
49  * deletes log files (for easier access to them)
50  */
51 class drop_and_clean_temp_stuff extends backup_execution_step {
53     protected $skipcleaningtempdir = false;
55     protected function define_execution() {
56         global $CFG;
58         backup_controller_dbops::drop_backup_ids_temp_table($this->get_backupid()); // Drop ids temp table
59         backup_helper::delete_old_backup_dirs(time() - (4 * 60 * 60));              // Delete > 4 hours temp dirs
60         // Delete temp dir conditionally:
61         // 1) If $CFG->keeptempdirectoriesonbackup is not enabled
62         // 2) If backup temp dir deletion has been marked to be avoided
63         if (empty($CFG->keeptempdirectoriesonbackup) && !$this->skipcleaningtempdir) {
64             backup_helper::delete_backup_dir($this->get_backupid()); // Empty backup dir
65         }
66     }
68     public function skip_cleaning_temp_dir($skip) {
69         $this->skipcleaningtempdir = $skip;
70     }
71 }
73 /**
74  * Create the directory where all the task (activity/block...) information will be stored
75  */
76 class create_taskbasepath_directory extends backup_execution_step {
78     protected function define_execution() {
79         global $CFG;
80         $basepath = $this->task->get_taskbasepath();
81         if (!check_dir_exists($basepath, true, true)) {
82             throw new backup_step_exception('cannot_create_taskbasepath_directory', $basepath);
83         }
84     }
85 }
87 /**
88  * Abstract structure step, parent of all the activity structure steps. Used to wrap the
89  * activity structure definition within the main <activity ...> tag. Also provides
90  * subplugin support for activities (that must be properly declared)
91  */
92 abstract class backup_activity_structure_step extends backup_structure_step {
94     /**
95      * Add subplugin structure to any element in the activity backup tree
96      *
97      * @param string $subplugintype type of subplugin as defined in activity db/subplugins.php
98      * @param backup_nested_element $element element in the activity backup tree that
99      *                                       we are going to add subplugin information to
100      * @param bool $multiple to define if multiple subplugins can produce information
101      *                       for each instance of $element (true) or no (false)
102      * @return void
103      */
104     protected function add_subplugin_structure($subplugintype, $element, $multiple) {
106         global $CFG;
108         // Check the requested subplugintype is a valid one
109         $subpluginsfile = $CFG->dirroot . '/mod/' . $this->task->get_modulename() . '/db/subplugins.php';
110         if (!file_exists($subpluginsfile)) {
111              throw new backup_step_exception('activity_missing_subplugins_php_file', $this->task->get_modulename());
112         }
113         include($subpluginsfile);
114         if (!array_key_exists($subplugintype, $subplugins)) {
115              throw new backup_step_exception('incorrect_subplugin_type', $subplugintype);
116         }
118         // Arrived here, subplugin is correct, let's create the optigroup
119         $optigroupname = $subplugintype . '_' . $element->get_name() . '_subplugin';
120         $optigroup = new backup_optigroup($optigroupname, null, $multiple);
121         $element->add_child($optigroup); // Add optigroup to stay connected since beginning
123         // Get all the optigroup_elements, looking across all the subplugin dirs
124         $subpluginsdirs = core_component::get_plugin_list($subplugintype);
125         foreach ($subpluginsdirs as $name => $subpluginsdir) {
126             $classname = 'backup_' . $subplugintype . '_' . $name . '_subplugin';
127             $backupfile = $subpluginsdir . '/backup/moodle2/' . $classname . '.class.php';
128             if (file_exists($backupfile)) {
129                 require_once($backupfile);
130                 $backupsubplugin = new $classname($subplugintype, $name, $optigroup, $this);
131                 // Add subplugin returned structure to optigroup
132                 $backupsubplugin->define_subplugin_structure($element->get_name());
133             }
134         }
135     }
137     /**
138      * As far as activity backup steps are implementing backup_subplugin stuff, they need to
139      * have the parent task available for wrapping purposes (get course/context....)
140      *
141      * @return backup_activity_task
142      */
143     public function get_task() {
144         return $this->task;
145     }
147     /**
148      * Wraps any activity backup structure within the common 'activity' element
149      * that will include common to all activities information like id, context...
150      *
151      * @param backup_nested_element $activitystructure the element to wrap
152      * @return backup_nested_element the $activitystructure wrapped by the common 'activity' element
153      */
154     protected function prepare_activity_structure($activitystructure) {
156         // Create the wrap element
157         $activity = new backup_nested_element('activity', array('id', 'moduleid', 'modulename', 'contextid'), null);
159         // Build the tree
160         $activity->add_child($activitystructure);
162         // Set the source
163         $activityarr = array((object)array(
164             'id'         => $this->task->get_activityid(),
165             'moduleid'   => $this->task->get_moduleid(),
166             'modulename' => $this->task->get_modulename(),
167             'contextid'  => $this->task->get_contextid()));
169         $activity->set_source_array($activityarr);
171         // Return the root element (activity)
172         return $activity;
173     }
176 /**
177  * Abstract structure step, to be used by all the activities using core questions stuff
178  * (namely quiz module), supporting question plugins, states and sessions
179  */
180 abstract class backup_questions_activity_structure_step extends backup_activity_structure_step {
182     /**
183      * Attach to $element (usually attempts) the needed backup structures
184      * for question_usages and all the associated data.
185      *
186      * @param backup_nested_element $element the element that will contain all the question_usages data.
187      * @param string $usageidname the name of the element that holds the usageid.
188      *      This must be child of $element, and must be a final element.
189      * @param string $nameprefix this prefix is added to all the element names we create.
190      *      Element names in the XML must be unique, so if you are using usages in
191      *      two different ways, you must give a prefix to at least one of them. If
192      *      you only use one sort of usage, then you can just use the default empty prefix.
193      *      This should include a trailing underscore. For example "myprefix_"
194      */
195     protected function add_question_usages($element, $usageidname, $nameprefix = '') {
196         global $CFG;
197         require_once($CFG->dirroot . '/question/engine/lib.php');
199         // Check $element is one nested_backup_element
200         if (! $element instanceof backup_nested_element) {
201             throw new backup_step_exception('question_states_bad_parent_element', $element);
202         }
203         if (! $element->get_final_element($usageidname)) {
204             throw new backup_step_exception('question_states_bad_question_attempt_element', $usageidname);
205         }
207         $quba = new backup_nested_element($nameprefix . 'question_usage', array('id'),
208                 array('component', 'preferredbehaviour'));
210         $qas = new backup_nested_element($nameprefix . 'question_attempts');
211         $qa = new backup_nested_element($nameprefix . 'question_attempt', array('id'), array(
212                 'slot', 'behaviour', 'questionid', 'maxmark', 'minfraction',
213                 'flagged', 'questionsummary', 'rightanswer', 'responsesummary',
214                 'timemodified'));
216         $steps = new backup_nested_element($nameprefix . 'steps');
217         $step = new backup_nested_element($nameprefix . 'step', array('id'), array(
218                 'sequencenumber', 'state', 'fraction', 'timecreated', 'userid'));
220         $response = new backup_nested_element($nameprefix . 'response');
221         $variable = new backup_nested_element($nameprefix . 'variable', null,  array('name', 'value'));
223         // Build the tree
224         $element->add_child($quba);
225         $quba->add_child($qas);
226         $qas->add_child($qa);
227         $qa->add_child($steps);
228         $steps->add_child($step);
229         $step->add_child($response);
230         $response->add_child($variable);
232         // Set the sources
233         $quba->set_source_table('question_usages',
234                 array('id'                => '../' . $usageidname));
235         $qa->set_source_table('question_attempts', array('questionusageid' => backup::VAR_PARENTID), 'slot ASC');
236         $step->set_source_table('question_attempt_steps', array('questionattemptid' => backup::VAR_PARENTID), 'sequencenumber ASC');
237         $variable->set_source_table('question_attempt_step_data', array('attemptstepid' => backup::VAR_PARENTID));
239         // Annotate ids
240         $qa->annotate_ids('question', 'questionid');
241         $step->annotate_ids('user', 'userid');
243         // Annotate files
244         $fileareas = question_engine::get_all_response_file_areas();
245         foreach ($fileareas as $filearea) {
246             $step->annotate_files('question', $filearea, 'id');
247         }
248     }
252 /**
253  * backup structure step in charge of calculating the categories to be
254  * included in backup, based in the context being backuped (module/course)
255  * and the already annotated questions present in backup_ids_temp
256  */
257 class backup_calculate_question_categories extends backup_execution_step {
259     protected function define_execution() {
260         backup_question_dbops::calculate_question_categories($this->get_backupid(), $this->task->get_contextid());
261     }
264 /**
265  * backup structure step in charge of deleting all the questions annotated
266  * in the backup_ids_temp table
267  */
268 class backup_delete_temp_questions extends backup_execution_step {
270     protected function define_execution() {
271         backup_question_dbops::delete_temp_questions($this->get_backupid());
272     }
275 /**
276  * Abstract structure step, parent of all the block structure steps. Used to wrap the
277  * block structure definition within the main <block ...> tag
278  */
279 abstract class backup_block_structure_step extends backup_structure_step {
281     protected function prepare_block_structure($blockstructure) {
283         // Create the wrap element
284         $block = new backup_nested_element('block', array('id', 'blockname', 'contextid'), null);
286         // Build the tree
287         $block->add_child($blockstructure);
289         // Set the source
290         $blockarr = array((object)array(
291             'id'         => $this->task->get_blockid(),
292             'blockname'  => $this->task->get_blockname(),
293             'contextid'  => $this->task->get_contextid()));
295         $block->set_source_array($blockarr);
297         // Return the root element (block)
298         return $block;
299     }
302 /**
303  * structure step that will generate the module.xml file for the activity,
304  * accumulating various information about the activity, annotating groupings
305  * and completion/avail conf
306  */
307 class backup_module_structure_step extends backup_structure_step {
309     protected function define_structure() {
311         // Define each element separated
313         $module = new backup_nested_element('module', array('id', 'version'), array(
314             'modulename', 'sectionid', 'sectionnumber', 'idnumber',
315             'added', 'score', 'indent', 'visible',
316             'visibleold', 'groupmode', 'groupingid', 'groupmembersonly',
317             'completion', 'completiongradeitemnumber', 'completionview', 'completionexpected',
318             'availablefrom', 'availableuntil', 'showavailability', 'showdescription'));
320         $availinfo = new backup_nested_element('availability_info');
321         $availability = new backup_nested_element('availability', array('id'), array(
322             'sourcecmid', 'requiredcompletion', 'gradeitemid', 'grademin', 'grademax'));
323         $availabilityfield = new backup_nested_element('availability_field', array('id'), array(
324             'userfield', 'customfield', 'customfieldtype', 'operator', 'value'));
326         // attach format plugin structure to $module element, only one allowed
327         $this->add_plugin_structure('format', $module, false);
329         // attach plagiarism plugin structure to $module element, there can be potentially
330         // many plagiarism plugins storing information about this course
331         $this->add_plugin_structure('plagiarism', $module, true);
333         // attach local plugin structure to $module, multiple allowed
334         $this->add_plugin_structure('local', $module, true);
336         // Define the tree
337         $module->add_child($availinfo);
338         $availinfo->add_child($availability);
339         $availinfo->add_child($availabilityfield);
341         // Set the sources
342         $module->set_source_sql('
343             SELECT cm.*, m.version, m.name AS modulename, s.id AS sectionid, s.section AS sectionnumber
344               FROM {course_modules} cm
345               JOIN {modules} m ON m.id = cm.module
346               JOIN {course_sections} s ON s.id = cm.section
347              WHERE cm.id = ?', array(backup::VAR_MODID));
349         $availability->set_source_table('course_modules_availability', array('coursemoduleid' => backup::VAR_MODID));
350         $availabilityfield->set_source_sql('
351             SELECT cmaf.*, uif.shortname AS customfield, uif.datatype AS customfieldtype
352               FROM {course_modules_avail_fields} cmaf
353          LEFT JOIN {user_info_field} uif ON uif.id = cmaf.customfieldid
354              WHERE cmaf.coursemoduleid = ?', array(backup::VAR_MODID));
356         // Define annotations
357         $module->annotate_ids('grouping', 'groupingid');
359         // Return the root element ($module)
360         return $module;
361     }
364 /**
365  * structure step that will generate the section.xml file for the section
366  * annotating files
367  */
368 class backup_section_structure_step extends backup_structure_step {
370     protected function define_structure() {
372         // Define each element separated
374         $section = new backup_nested_element('section', array('id'), array(
375                 'number', 'name', 'summary', 'summaryformat', 'sequence', 'visible',
376                 'availablefrom', 'availableuntil', 'showavailability', 'groupingid'));
378         // attach format plugin structure to $section element, only one allowed
379         $this->add_plugin_structure('format', $section, false);
381         // attach local plugin structure to $section element, multiple allowed
382         $this->add_plugin_structure('local', $section, true);
384         // Add nested elements for _availability table
385         $avail = new backup_nested_element('availability', array('id'), array(
386                 'sourcecmid', 'requiredcompletion', 'gradeitemid', 'grademin', 'grademax'));
387         $availfield = new backup_nested_element('availability_field', array('id'), array(
388             'userfield', 'operator', 'value', 'customfield', 'customfieldtype'));
389         $section->add_child($avail);
390         $section->add_child($availfield);
392         // Add nested elements for course_format_options table
393         $formatoptions = new backup_nested_element('course_format_options', array('id'), array(
394             'format', 'name', 'value'));
395         $section->add_child($formatoptions);
397         // Define sources
398         $section->set_source_table('course_sections', array('id' => backup::VAR_SECTIONID));
399         $avail->set_source_table('course_sections_availability', array('coursesectionid' => backup::VAR_SECTIONID));
400         $availfield->set_source_sql('
401             SELECT csaf.*, uif.shortname AS customfield, uif.datatype AS customfieldtype
402               FROM {course_sections_avail_fields} csaf
403          LEFT JOIN {user_info_field} uif ON uif.id = csaf.customfieldid
404              WHERE csaf.coursesectionid = ?', array(backup::VAR_SECTIONID));
405         $formatoptions->set_source_sql('SELECT cfo.id, cfo.format, cfo.name, cfo.value
406               FROM {course} c
407               JOIN {course_format_options} cfo
408               ON cfo.courseid = c.id AND cfo.format = c.format
409               WHERE c.id = ? AND cfo.sectionid = ?',
410                 array(backup::VAR_COURSEID, backup::VAR_SECTIONID));
412         // Aliases
413         $section->set_source_alias('section', 'number');
415         // Set annotations
416         $section->annotate_ids('grouping', 'groupingid');
417         $section->annotate_files('course', 'section', 'id');
419         return $section;
420     }
423 /**
424  * structure step that will generate the course.xml file for the course, including
425  * course category reference, tags, modules restriction information
426  * and some annotations (files & groupings)
427  */
428 class backup_course_structure_step extends backup_structure_step {
430     protected function define_structure() {
431         global $DB;
433         // Define each element separated
435         $course = new backup_nested_element('course', array('id', 'contextid'), array(
436             'shortname', 'fullname', 'idnumber',
437             'summary', 'summaryformat', 'format', 'showgrades',
438             'newsitems', 'startdate',
439             'marker', 'maxbytes', 'legacyfiles', 'showreports',
440             'visible', 'groupmode', 'groupmodeforce',
441             'defaultgroupingid', 'lang', 'theme',
442             'timecreated', 'timemodified',
443             'requested',
444             'enablecompletion', 'completionstartonenrol', 'completionnotify'));
446         $category = new backup_nested_element('category', array('id'), array(
447             'name', 'description'));
449         $tags = new backup_nested_element('tags');
451         $tag = new backup_nested_element('tag', array('id'), array(
452             'name', 'rawname'));
454         // attach format plugin structure to $course element, only one allowed
455         $this->add_plugin_structure('format', $course, false);
457         // attach theme plugin structure to $course element; multiple themes can
458         // save course data (in case of user theme, legacy theme, etc)
459         $this->add_plugin_structure('theme', $course, true);
461         // attach general report plugin structure to $course element; multiple
462         // reports can save course data if required
463         $this->add_plugin_structure('report', $course, true);
465         // attach course report plugin structure to $course element; multiple
466         // course reports can save course data if required
467         $this->add_plugin_structure('coursereport', $course, true);
469         // attach plagiarism plugin structure to $course element, there can be potentially
470         // many plagiarism plugins storing information about this course
471         $this->add_plugin_structure('plagiarism', $course, true);
473         // attach local plugin structure to $course element; multiple local plugins
474         // can save course data if required
475         $this->add_plugin_structure('local', $course, true);
477         // Build the tree
479         $course->add_child($category);
481         $course->add_child($tags);
482         $tags->add_child($tag);
484         // Set the sources
486         $courserec = $DB->get_record('course', array('id' => $this->task->get_courseid()));
487         $courserec->contextid = $this->task->get_contextid();
489         $formatoptions = course_get_format($courserec)->get_format_options();
490         $course->add_final_elements(array_keys($formatoptions));
491         foreach ($formatoptions as $key => $value) {
492             $courserec->$key = $value;
493         }
495         $course->set_source_array(array($courserec));
497         $categoryrec = $DB->get_record('course_categories', array('id' => $courserec->category));
499         $category->set_source_array(array($categoryrec));
501         $tag->set_source_sql('SELECT t.id, t.name, t.rawname
502                                 FROM {tag} t
503                                 JOIN {tag_instance} ti ON ti.tagid = t.id
504                                WHERE ti.itemtype = ?
505                                  AND ti.itemid = ?', array(
506                                      backup_helper::is_sqlparam('course'),
507                                      backup::VAR_PARENTID));
509         // Some annotations
511         $course->annotate_ids('grouping', 'defaultgroupingid');
513         $course->annotate_files('course', 'summary', null);
514         $course->annotate_files('course', 'overviewfiles', null);
515         $course->annotate_files('course', 'legacy', null);
517         // Return root element ($course)
519         return $course;
520     }
523 /**
524  * structure step that will generate the enrolments.xml file for the given course
525  */
526 class backup_enrolments_structure_step extends backup_structure_step {
528     protected function define_structure() {
530         // To know if we are including users
531         $users = $this->get_setting_value('users');
533         // Define each element separated
535         $enrolments = new backup_nested_element('enrolments');
537         $enrols = new backup_nested_element('enrols');
539         $enrol = new backup_nested_element('enrol', array('id'), array(
540             'enrol', 'status', 'name', 'enrolperiod', 'enrolstartdate',
541             'enrolenddate', 'expirynotify', 'expirytreshold', 'notifyall',
542             'password', 'cost', 'currency', 'roleid',
543             'customint1', 'customint2', 'customint3', 'customint4', 'customint5', 'customint6', 'customint7', 'customint8',
544             'customchar1', 'customchar2', 'customchar3',
545             'customdec1', 'customdec2',
546             'customtext1', 'customtext2', 'customtext3', 'customtext4',
547             'timecreated', 'timemodified'));
549         $userenrolments = new backup_nested_element('user_enrolments');
551         $enrolment = new backup_nested_element('enrolment', array('id'), array(
552             'status', 'userid', 'timestart', 'timeend', 'modifierid',
553             'timemodified'));
555         // Build the tree
556         $enrolments->add_child($enrols);
557         $enrols->add_child($enrol);
558         $enrol->add_child($userenrolments);
559         $userenrolments->add_child($enrolment);
561         // Define sources - the instances are restored using the same sortorder, we do not need to store it in xml and deal with it afterwards.
562         $enrol->set_source_table('enrol', array('courseid' => backup::VAR_COURSEID), 'sortorder ASC');
564         // User enrolments only added only if users included
565         if ($users) {
566             $enrolment->set_source_table('user_enrolments', array('enrolid' => backup::VAR_PARENTID));
567             $enrolment->annotate_ids('user', 'userid');
568         }
570         $enrol->annotate_ids('role', 'roleid');
572         //TODO: let plugins annotate custom fields too and add more children
574         return $enrolments;
575     }
578 /**
579  * structure step that will generate the roles.xml file for the given context, observing
580  * the role_assignments setting to know if that part needs to be included
581  */
582 class backup_roles_structure_step extends backup_structure_step {
584     protected function define_structure() {
586         // To know if we are including role assignments
587         $roleassignments = $this->get_setting_value('role_assignments');
589         // Define each element separated
591         $roles = new backup_nested_element('roles');
593         $overrides = new backup_nested_element('role_overrides');
595         $override = new backup_nested_element('override', array('id'), array(
596             'roleid', 'capability', 'permission', 'timemodified',
597             'modifierid'));
599         $assignments = new backup_nested_element('role_assignments');
601         $assignment = new backup_nested_element('assignment', array('id'), array(
602             'roleid', 'userid', 'timemodified', 'modifierid', 'component', 'itemid',
603             'sortorder'));
605         // Build the tree
606         $roles->add_child($overrides);
607         $roles->add_child($assignments);
609         $overrides->add_child($override);
610         $assignments->add_child($assignment);
612         // Define sources
614         $override->set_source_table('role_capabilities', array('contextid' => backup::VAR_CONTEXTID));
616         // Assignments only added if specified
617         if ($roleassignments) {
618             $assignment->set_source_table('role_assignments', array('contextid' => backup::VAR_CONTEXTID));
619         }
621         // Define id annotations
622         $override->annotate_ids('role', 'roleid');
624         $assignment->annotate_ids('role', 'roleid');
626         $assignment->annotate_ids('user', 'userid');
628         //TODO: how do we annotate the itemid? the meaning depends on the content of component table (skodak)
630         return $roles;
631     }
634 /**
635  * structure step that will generate the roles.xml containing the
636  * list of roles used along the whole backup process. Just raw
637  * list of used roles from role table
638  */
639 class backup_final_roles_structure_step extends backup_structure_step {
641     protected function define_structure() {
643         // Define elements
645         $rolesdef = new backup_nested_element('roles_definition');
647         $role = new backup_nested_element('role', array('id'), array(
648             'name', 'shortname', 'nameincourse', 'description',
649             'sortorder', 'archetype'));
651         // Build the tree
653         $rolesdef->add_child($role);
655         // Define sources
657         $role->set_source_sql("SELECT r.*, rn.name AS nameincourse
658                                  FROM {role} r
659                                  JOIN {backup_ids_temp} bi ON r.id = bi.itemid
660                             LEFT JOIN {role_names} rn ON r.id = rn.roleid AND rn.contextid = ?
661                                 WHERE bi.backupid = ?
662                                   AND bi.itemname = 'rolefinal'", array(backup::VAR_CONTEXTID, backup::VAR_BACKUPID));
664         // Return main element (rolesdef)
665         return $rolesdef;
666     }
669 /**
670  * structure step that will generate the scales.xml containing the
671  * list of scales used along the whole backup process.
672  */
673 class backup_final_scales_structure_step extends backup_structure_step {
675     protected function define_structure() {
677         // Define elements
679         $scalesdef = new backup_nested_element('scales_definition');
681         $scale = new backup_nested_element('scale', array('id'), array(
682             'courseid', 'userid', 'name', 'scale',
683             'description', 'descriptionformat', 'timemodified'));
685         // Build the tree
687         $scalesdef->add_child($scale);
689         // Define sources
691         $scale->set_source_sql("SELECT s.*
692                                   FROM {scale} s
693                                   JOIN {backup_ids_temp} bi ON s.id = bi.itemid
694                                  WHERE bi.backupid = ?
695                                    AND bi.itemname = 'scalefinal'", array(backup::VAR_BACKUPID));
697         // Annotate scale files (they store files in system context, so pass it instead of default one)
698         $scale->annotate_files('grade', 'scale', 'id', context_system::instance()->id);
700         // Return main element (scalesdef)
701         return $scalesdef;
702     }
705 /**
706  * structure step that will generate the outcomes.xml containing the
707  * list of outcomes used along the whole backup process.
708  */
709 class backup_final_outcomes_structure_step extends backup_structure_step {
711     protected function define_structure() {
713         // Define elements
715         $outcomesdef = new backup_nested_element('outcomes_definition');
717         $outcome = new backup_nested_element('outcome', array('id'), array(
718             'courseid', 'userid', 'shortname', 'fullname',
719             'scaleid', 'description', 'descriptionformat', 'timecreated',
720             'timemodified','usermodified'));
722         // Build the tree
724         $outcomesdef->add_child($outcome);
726         // Define sources
728         $outcome->set_source_sql("SELECT o.*
729                                     FROM {grade_outcomes} o
730                                     JOIN {backup_ids_temp} bi ON o.id = bi.itemid
731                                    WHERE bi.backupid = ?
732                                      AND bi.itemname = 'outcomefinal'", array(backup::VAR_BACKUPID));
734         // Annotate outcome files (they store files in system context, so pass it instead of default one)
735         $outcome->annotate_files('grade', 'outcome', 'id', context_system::instance()->id);
737         // Return main element (outcomesdef)
738         return $outcomesdef;
739     }
742 /**
743  * structure step in charge of constructing the filters.xml file for all the filters found
744  * in activity
745  */
746 class backup_filters_structure_step extends backup_structure_step {
748     protected function define_structure() {
750         // Define each element separated
752         $filters = new backup_nested_element('filters');
754         $actives = new backup_nested_element('filter_actives');
756         $active = new backup_nested_element('filter_active', null, array('filter', 'active'));
758         $configs = new backup_nested_element('filter_configs');
760         $config = new backup_nested_element('filter_config', null, array('filter', 'name', 'value'));
762         // Build the tree
764         $filters->add_child($actives);
765         $filters->add_child($configs);
767         $actives->add_child($active);
768         $configs->add_child($config);
770         // Define sources
772         list($activearr, $configarr) = filter_get_all_local_settings($this->task->get_contextid());
774         $active->set_source_array($activearr);
775         $config->set_source_array($configarr);
777         // Return the root element (filters)
778         return $filters;
779     }
782 /**
783  * structure step in charge of constructing the comments.xml file for all the comments found
784  * in a given context
785  */
786 class backup_comments_structure_step extends backup_structure_step {
788     protected function define_structure() {
790         // Define each element separated
792         $comments = new backup_nested_element('comments');
794         $comment = new backup_nested_element('comment', array('id'), array(
795             'commentarea', 'itemid', 'content', 'format',
796             'userid', 'timecreated'));
798         // Build the tree
800         $comments->add_child($comment);
802         // Define sources
804         $comment->set_source_table('comments', array('contextid' => backup::VAR_CONTEXTID));
806         // Define id annotations
808         $comment->annotate_ids('user', 'userid');
810         // Return the root element (comments)
811         return $comments;
812     }
815 /**
816  * structure step in charge of constructing the badges.xml file for all the badges found
817  * in a given context
818  */
819 class backup_badges_structure_step extends backup_structure_step {
821     protected function execute_condition() {
822         // Check that all activities have been included.
823         if ($this->task->is_excluding_activities()) {
824             return false;
825         }
826         return true;
827     }
829     protected function define_structure() {
831         // Define each element separated.
833         $badges = new backup_nested_element('badges');
834         $badge = new backup_nested_element('badge', array('id'), array('name', 'description',
835                 'timecreated', 'timemodified', 'usercreated', 'usermodified', 'issuername',
836                 'issuerurl', 'issuercontact', 'expiredate', 'expireperiod', 'type', 'courseid',
837                 'message', 'messagesubject', 'attachment', 'notification', 'status', 'nextcron'));
839         $criteria = new backup_nested_element('criteria');
840         $criterion = new backup_nested_element('criterion', array('id'), array('badgeid',
841                 'criteriatype', 'method'));
843         $parameters = new backup_nested_element('parameters');
844         $parameter = new backup_nested_element('parameter', array('id'), array('critid',
845                 'name', 'value', 'criteriatype'));
847         $manual_awards = new backup_nested_element('manual_awards');
848         $manual_award = new backup_nested_element('manual_award', array('id'), array('badgeid',
849                 'recipientid', 'issuerid', 'issuerrole', 'datemet'));
851         // Build the tree.
853         $badges->add_child($badge);
854         $badge->add_child($criteria);
855         $criteria->add_child($criterion);
856         $criterion->add_child($parameters);
857         $parameters->add_child($parameter);
858         $badge->add_child($manual_awards);
859         $manual_awards->add_child($manual_award);
861         // Define sources.
863         $badge->set_source_table('badge', array('courseid' => backup::VAR_COURSEID));
864         $criterion->set_source_table('badge_criteria', array('badgeid' => backup::VAR_PARENTID));
866         $parametersql = 'SELECT cp.*, c.criteriatype
867                              FROM {badge_criteria_param} cp JOIN {badge_criteria} c
868                                  ON cp.critid = c.id
869                              WHERE critid = :critid';
870         $parameterparams = array('critid' => backup::VAR_PARENTID);
871         $parameter->set_source_sql($parametersql, $parameterparams);
873         $manual_award->set_source_table('badge_manual_award', array('badgeid' => backup::VAR_PARENTID));
875         // Define id annotations.
877         $badge->annotate_ids('user', 'usercreated');
878         $badge->annotate_ids('user', 'usermodified');
879         $criterion->annotate_ids('badge', 'badgeid');
880         $parameter->annotate_ids('criterion', 'critid');
881         $badge->annotate_files('badges', 'badgeimage', 'id');
882         $manual_award->annotate_ids('badge', 'badgeid');
883         $manual_award->annotate_ids('user', 'recipientid');
884         $manual_award->annotate_ids('user', 'issuerid');
885         $manual_award->annotate_ids('role', 'issuerrole');
887         // Return the root element ($badges).
888         return $badges;
889     }
892 /**
893  * structure step in charge of constructing the calender.xml file for all the events found
894  * in a given context
895  */
896 class backup_calendarevents_structure_step extends backup_structure_step {
898     protected function define_structure() {
900         // Define each element separated
902         $events = new backup_nested_element('events');
904         $event = new backup_nested_element('event', array('id'), array(
905                 'name', 'description', 'format', 'courseid', 'groupid', 'userid',
906                 'repeatid', 'modulename', 'instance', 'eventtype', 'timestart',
907                 'timeduration', 'visible', 'uuid', 'sequence', 'timemodified'));
909         // Build the tree
910         $events->add_child($event);
912         // Define sources
913         if ($this->name == 'course_calendar') {
914             $calendar_items_sql ="SELECT * FROM {event}
915                         WHERE courseid = :courseid
916                         AND (eventtype = 'course' OR eventtype = 'group')";
917             $calendar_items_params = array('courseid'=>backup::VAR_COURSEID);
918             $event->set_source_sql($calendar_items_sql, $calendar_items_params);
919         } else {
920             $event->set_source_table('event', array('courseid' => backup::VAR_COURSEID, 'instance' => backup::VAR_ACTIVITYID, 'modulename' => backup::VAR_MODNAME));
921         }
923         // Define id annotations
925         $event->annotate_ids('user', 'userid');
926         $event->annotate_ids('group', 'groupid');
927         $event->annotate_files('calendar', 'event_description', 'id');
929         // Return the root element (events)
930         return $events;
931     }
934 /**
935  * structure step in charge of constructing the gradebook.xml file for all the gradebook config in the course
936  * NOTE: the backup of the grade items themselves is handled by backup_activity_grades_structure_step
937  */
938 class backup_gradebook_structure_step extends backup_structure_step {
940     /**
941      * We need to decide conditionally, based on dynamic information
942      * about the execution of this step. Only will be executed if all
943      * the module gradeitems have been already included in backup
944      */
945     protected function execute_condition() {
946         return backup_plan_dbops::require_gradebook_backup($this->get_courseid(), $this->get_backupid());
947     }
949     protected function define_structure() {
951         // are we including user info?
952         $userinfo = $this->get_setting_value('users');
954         $gradebook = new backup_nested_element('gradebook');
956         //grade_letters are done in backup_activity_grades_structure_step()
958         //calculated grade items
959         $grade_items = new backup_nested_element('grade_items');
960         $grade_item = new backup_nested_element('grade_item', array('id'), array(
961             'categoryid', 'itemname', 'itemtype', 'itemmodule',
962             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
963             'calculation', 'gradetype', 'grademax', 'grademin',
964             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
965             'plusfactor', 'aggregationcoef', 'sortorder', 'display',
966             'decimals', 'hidden', 'locked', 'locktime',
967             'needsupdate', 'timecreated', 'timemodified'));
969         $grade_grades = new backup_nested_element('grade_grades');
970         $grade_grade = new backup_nested_element('grade_grade', array('id'), array(
971             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
972             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
973             'locked', 'locktime', 'exported', 'overridden',
974             'excluded', 'feedback', 'feedbackformat', 'information',
975             'informationformat', 'timecreated', 'timemodified'));
977         //grade_categories
978         $grade_categories = new backup_nested_element('grade_categories');
979         $grade_category   = new backup_nested_element('grade_category', array('id'), array(
980                 //'courseid',
981                 'parent', 'depth', 'path', 'fullname', 'aggregation', 'keephigh',
982                 'droplow', 'aggregateonlygraded', 'aggregateoutcomes', 'aggregatesubcats',
983                 'timecreated', 'timemodified', 'hidden'));
985         $letters = new backup_nested_element('grade_letters');
986         $letter = new backup_nested_element('grade_letter', 'id', array(
987             'lowerboundary', 'letter'));
989         $grade_settings = new backup_nested_element('grade_settings');
990         $grade_setting = new backup_nested_element('grade_setting', 'id', array(
991             'name', 'value'));
994         // Build the tree
995         $gradebook->add_child($grade_categories);
996         $grade_categories->add_child($grade_category);
998         $gradebook->add_child($grade_items);
999         $grade_items->add_child($grade_item);
1000         $grade_item->add_child($grade_grades);
1001         $grade_grades->add_child($grade_grade);
1003         $gradebook->add_child($letters);
1004         $letters->add_child($letter);
1006         $gradebook->add_child($grade_settings);
1007         $grade_settings->add_child($grade_setting);
1009         // Define sources
1011         //Include manual, category and the course grade item
1012         $grade_items_sql ="SELECT * FROM {grade_items}
1013                            WHERE courseid = :courseid
1014                            AND (itemtype='manual' OR itemtype='course' OR itemtype='category')";
1015         $grade_items_params = array('courseid'=>backup::VAR_COURSEID);
1016         $grade_item->set_source_sql($grade_items_sql, $grade_items_params);
1018         if ($userinfo) {
1019             $grade_grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
1020         }
1022         $grade_category_sql = "SELECT gc.*, gi.sortorder
1023                                FROM {grade_categories} gc
1024                                JOIN {grade_items} gi ON (gi.iteminstance = gc.id)
1025                                WHERE gc.courseid = :courseid
1026                                AND (gi.itemtype='course' OR gi.itemtype='category')
1027                                ORDER BY gc.parent ASC";//need parent categories before their children
1028         $grade_category_params = array('courseid'=>backup::VAR_COURSEID);
1029         $grade_category->set_source_sql($grade_category_sql, $grade_category_params);
1031         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
1033         $grade_setting->set_source_table('grade_settings', array('courseid' => backup::VAR_COURSEID));
1035         // Annotations (both as final as far as they are going to be exported in next steps)
1036         $grade_item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
1037         $grade_item->annotate_ids('outcomefinal', 'outcomeid');
1039         //just in case there are any users not already annotated by the activities
1040         $grade_grade->annotate_ids('userfinal', 'userid');
1042         // Return the root element
1043         return $gradebook;
1044     }
1047 /**
1048  * structure step in charge if constructing the completion.xml file for all the users completion
1049  * information in a given activity
1050  */
1051 class backup_userscompletion_structure_step extends backup_structure_step {
1053     protected function define_structure() {
1055         // Define each element separated
1057         $completions = new backup_nested_element('completions');
1059         $completion = new backup_nested_element('completion', array('id'), array(
1060             'userid', 'completionstate', 'viewed', 'timemodified'));
1062         // Build the tree
1064         $completions->add_child($completion);
1066         // Define sources
1068         $completion->set_source_table('course_modules_completion', array('coursemoduleid' => backup::VAR_MODID));
1070         // Define id annotations
1072         $completion->annotate_ids('user', 'userid');
1074         // Return the root element (completions)
1075         return $completions;
1076     }
1079 /**
1080  * structure step in charge of constructing the main groups.xml file for all the groups and
1081  * groupings information already annotated
1082  */
1083 class backup_groups_structure_step extends backup_structure_step {
1085     protected function define_structure() {
1087         // To know if we are including users
1088         $users = $this->get_setting_value('users');
1090         // Define each element separated
1092         $groups = new backup_nested_element('groups');
1094         $group = new backup_nested_element('group', array('id'), array(
1095             'name', 'idnumber', 'description', 'descriptionformat', 'enrolmentkey',
1096             'picture', 'hidepicture', 'timecreated', 'timemodified'));
1098         $members = new backup_nested_element('group_members');
1100         $member = new backup_nested_element('group_member', array('id'), array(
1101             'userid', 'timeadded', 'component', 'itemid'));
1103         $groupings = new backup_nested_element('groupings');
1105         $grouping = new backup_nested_element('grouping', 'id', array(
1106             'name', 'idnumber', 'description', 'descriptionformat', 'configdata',
1107             'timecreated', 'timemodified'));
1109         $groupinggroups = new backup_nested_element('grouping_groups');
1111         $groupinggroup = new backup_nested_element('grouping_group', array('id'), array(
1112             'groupid', 'timeadded'));
1114         // Build the tree
1116         $groups->add_child($group);
1117         $groups->add_child($groupings);
1119         $group->add_child($members);
1120         $members->add_child($member);
1122         $groupings->add_child($grouping);
1123         $grouping->add_child($groupinggroups);
1124         $groupinggroups->add_child($groupinggroup);
1126         // Define sources
1128         $group->set_source_sql("
1129             SELECT g.*
1130               FROM {groups} g
1131               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
1132              WHERE bi.backupid = ?
1133                AND bi.itemname = 'groupfinal'", array(backup::VAR_BACKUPID));
1135         // This only happens if we are including users
1136         if ($users) {
1137             $member->set_source_table('groups_members', array('groupid' => backup::VAR_PARENTID));
1138         }
1140         $grouping->set_source_sql("
1141             SELECT g.*
1142               FROM {groupings} g
1143               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
1144              WHERE bi.backupid = ?
1145                AND bi.itemname = 'groupingfinal'", array(backup::VAR_BACKUPID));
1147         $groupinggroup->set_source_table('groupings_groups', array('groupingid' => backup::VAR_PARENTID));
1149         // Define id annotations (as final)
1151         $member->annotate_ids('userfinal', 'userid');
1153         // Define file annotations
1155         $group->annotate_files('group', 'description', 'id');
1156         $group->annotate_files('group', 'icon', 'id');
1157         $grouping->annotate_files('grouping', 'description', 'id');
1159         // Return the root element (groups)
1160         return $groups;
1161     }
1164 /**
1165  * structure step in charge of constructing the main users.xml file for all the users already
1166  * annotated (final). Includes custom profile fields, preferences, tags, role assignments and
1167  * overrides.
1168  */
1169 class backup_users_structure_step extends backup_structure_step {
1171     protected function define_structure() {
1172         global $CFG;
1174         // To know if we are anonymizing users
1175         $anonymize = $this->get_setting_value('anonymize');
1176         // To know if we are including role assignments
1177         $roleassignments = $this->get_setting_value('role_assignments');
1179         // Define each element separated
1181         $users = new backup_nested_element('users');
1183         // Create the array of user fields by hand, as far as we have various bits to control
1184         // anonymize option, password backup, mnethostid...
1186         // First, the fields not needing anonymization nor special handling
1187         $normalfields = array(
1188             'confirmed', 'policyagreed', 'deleted',
1189             'lang', 'theme', 'timezone', 'firstaccess',
1190             'lastaccess', 'lastlogin', 'currentlogin',
1191             'mailformat', 'maildigest', 'maildisplay', 'htmleditor',
1192             'autosubscribe', 'trackforums', 'timecreated',
1193             'timemodified', 'trustbitmask');
1195         // Then, the fields potentially needing anonymization
1196         $anonfields = array(
1197             'username', 'idnumber', 'email', 'icq', 'skype',
1198             'yahoo', 'aim', 'msn', 'phone1',
1199             'phone2', 'institution', 'department', 'address',
1200             'city', 'country', 'lastip', 'picture',
1201             'url', 'description', 'descriptionformat', 'imagealt', 'auth');
1202         $anonfields = array_merge($anonfields, get_all_user_name_fields());
1204         // Add anonymized fields to $userfields with custom final element
1205         foreach ($anonfields as $field) {
1206             if ($anonymize) {
1207                 $userfields[] = new anonymizer_final_element($field);
1208             } else {
1209                 $userfields[] = $field; // No anonymization, normally added
1210             }
1211         }
1213         // mnethosturl requires special handling (custom final element)
1214         $userfields[] = new mnethosturl_final_element('mnethosturl');
1216         // password added conditionally
1217         if (!empty($CFG->includeuserpasswordsinbackup)) {
1218             $userfields[] = 'password';
1219         }
1221         // Merge all the fields
1222         $userfields = array_merge($userfields, $normalfields);
1224         $user = new backup_nested_element('user', array('id', 'contextid'), $userfields);
1226         $customfields = new backup_nested_element('custom_fields');
1228         $customfield = new backup_nested_element('custom_field', array('id'), array(
1229             'field_name', 'field_type', 'field_data'));
1231         $tags = new backup_nested_element('tags');
1233         $tag = new backup_nested_element('tag', array('id'), array(
1234             'name', 'rawname'));
1236         $preferences = new backup_nested_element('preferences');
1238         $preference = new backup_nested_element('preference', array('id'), array(
1239             'name', 'value'));
1241         $roles = new backup_nested_element('roles');
1243         $overrides = new backup_nested_element('role_overrides');
1245         $override = new backup_nested_element('override', array('id'), array(
1246             'roleid', 'capability', 'permission', 'timemodified',
1247             'modifierid'));
1249         $assignments = new backup_nested_element('role_assignments');
1251         $assignment = new backup_nested_element('assignment', array('id'), array(
1252             'roleid', 'userid', 'timemodified', 'modifierid', 'component', //TODO: MDL-22793 add itemid here
1253             'sortorder'));
1255         // Build the tree
1257         $users->add_child($user);
1259         $user->add_child($customfields);
1260         $customfields->add_child($customfield);
1262         $user->add_child($tags);
1263         $tags->add_child($tag);
1265         $user->add_child($preferences);
1266         $preferences->add_child($preference);
1268         $user->add_child($roles);
1270         $roles->add_child($overrides);
1271         $roles->add_child($assignments);
1273         $overrides->add_child($override);
1274         $assignments->add_child($assignment);
1276         // Define sources
1278         $user->set_source_sql('SELECT u.*, c.id AS contextid, m.wwwroot AS mnethosturl
1279                                  FROM {user} u
1280                                  JOIN {backup_ids_temp} bi ON bi.itemid = u.id
1281                             LEFT JOIN {context} c ON c.instanceid = u.id AND c.contextlevel = ' . CONTEXT_USER . '
1282                             LEFT JOIN {mnet_host} m ON m.id = u.mnethostid
1283                                 WHERE bi.backupid = ?
1284                                   AND bi.itemname = ?', array(
1285                                       backup_helper::is_sqlparam($this->get_backupid()),
1286                                       backup_helper::is_sqlparam('userfinal')));
1288         // All the rest on information is only added if we arent
1289         // in an anonymized backup
1290         if (!$anonymize) {
1291             $customfield->set_source_sql('SELECT f.id, f.shortname, f.datatype, d.data
1292                                             FROM {user_info_field} f
1293                                             JOIN {user_info_data} d ON d.fieldid = f.id
1294                                            WHERE d.userid = ?', array(backup::VAR_PARENTID));
1296             $customfield->set_source_alias('shortname', 'field_name');
1297             $customfield->set_source_alias('datatype',  'field_type');
1298             $customfield->set_source_alias('data',      'field_data');
1300             $tag->set_source_sql('SELECT t.id, t.name, t.rawname
1301                                     FROM {tag} t
1302                                     JOIN {tag_instance} ti ON ti.tagid = t.id
1303                                    WHERE ti.itemtype = ?
1304                                      AND ti.itemid = ?', array(
1305                                          backup_helper::is_sqlparam('user'),
1306                                          backup::VAR_PARENTID));
1308             $preference->set_source_table('user_preferences', array('userid' => backup::VAR_PARENTID));
1310             $override->set_source_table('role_capabilities', array('contextid' => '/users/user/contextid'));
1312             // Assignments only added if specified
1313             if ($roleassignments) {
1314                 $assignment->set_source_table('role_assignments', array('contextid' => '/users/user/contextid'));
1315             }
1317             // Define id annotations (as final)
1318             $override->annotate_ids('rolefinal', 'roleid');
1319         }
1321         // Return root element (users)
1322         return $users;
1323     }
1326 /**
1327  * structure step in charge of constructing the block.xml file for one
1328  * given block (instance and positions). If the block has custom DB structure
1329  * that will go to a separate file (different step defined in block class)
1330  */
1331 class backup_block_instance_structure_step extends backup_structure_step {
1333     protected function define_structure() {
1334         global $DB;
1336         // Define each element separated
1338         $block = new backup_nested_element('block', array('id', 'contextid', 'version'), array(
1339             'blockname', 'parentcontextid', 'showinsubcontexts', 'pagetypepattern',
1340             'subpagepattern', 'defaultregion', 'defaultweight', 'configdata'));
1342         $positions = new backup_nested_element('block_positions');
1344         $position = new backup_nested_element('block_position', array('id'), array(
1345             'contextid', 'pagetype', 'subpage', 'visible',
1346             'region', 'weight'));
1348         // Build the tree
1350         $block->add_child($positions);
1351         $positions->add_child($position);
1353         // Transform configdata information if needed (process links and friends)
1354         $blockrec = $DB->get_record('block_instances', array('id' => $this->task->get_blockid()));
1355         if ($attrstotransform = $this->task->get_configdata_encoded_attributes()) {
1356             $configdata = (array)unserialize(base64_decode($blockrec->configdata));
1357             foreach ($configdata as $attribute => $value) {
1358                 if (in_array($attribute, $attrstotransform)) {
1359                     $configdata[$attribute] = $this->contenttransformer->process($value);
1360                 }
1361             }
1362             $blockrec->configdata = base64_encode(serialize((object)$configdata));
1363         }
1364         $blockrec->contextid = $this->task->get_contextid();
1365         // Get the version of the block
1366         $blockrec->version = $DB->get_field('block', 'version', array('name' => $this->task->get_blockname()));
1368         // Define sources
1370         $block->set_source_array(array($blockrec));
1372         $position->set_source_table('block_positions', array('blockinstanceid' => backup::VAR_PARENTID));
1374         // File anotations (for fileareas specified on each block)
1375         foreach ($this->task->get_fileareas() as $filearea) {
1376             $block->annotate_files('block_' . $this->task->get_blockname(), $filearea, null);
1377         }
1379         // Return the root element (block)
1380         return $block;
1381     }
1384 /**
1385  * structure step in charge of constructing the logs.xml file for all the log records found
1386  * in course. Note that we are sending to backup ALL the log records having cmid = 0. That
1387  * includes some records that won't be restoreable (like 'upload', 'calendar'...) but we do
1388  * that just in case they become restored some day in the future
1389  */
1390 class backup_course_logs_structure_step extends backup_structure_step {
1392     protected function define_structure() {
1394         // Define each element separated
1396         $logs = new backup_nested_element('logs');
1398         $log = new backup_nested_element('log', array('id'), array(
1399             'time', 'userid', 'ip', 'module',
1400             'action', 'url', 'info'));
1402         // Build the tree
1404         $logs->add_child($log);
1406         // Define sources (all the records belonging to the course, having cmid = 0)
1408         $log->set_source_table('log', array('course' => backup::VAR_COURSEID, 'cmid' => backup_helper::is_sqlparam(0)));
1410         // Annotations
1411         // NOTE: We don't annotate users from logs as far as they MUST be
1412         //       always annotated by the course (enrol, ras... whatever)
1414         // Return the root element (logs)
1416         return $logs;
1417     }
1420 /**
1421  * structure step in charge of constructing the logs.xml file for all the log records found
1422  * in activity
1423  */
1424 class backup_activity_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
1442         $log->set_source_table('log', array('cmid' => backup::VAR_MODID));
1444         // Annotations
1445         // NOTE: We don't annotate users from logs as far as they MUST be
1446         //       always annotated by the activity (true participants).
1448         // Return the root element (logs)
1450         return $logs;
1451     }
1454 /**
1455  * structure in charge of constructing the inforef.xml file for all the items we want
1456  * to have referenced there (users, roles, files...)
1457  */
1458 class backup_inforef_structure_step extends backup_structure_step {
1460     protected function define_structure() {
1462         // Items we want to include in the inforef file.
1463         $items = backup_helper::get_inforef_itemnames();
1465         // Build the tree
1467         $inforef = new backup_nested_element('inforef');
1469         // For each item, conditionally, if there are already records, build element
1470         foreach ($items as $itemname) {
1471             if (backup_structure_dbops::annotations_exist($this->get_backupid(), $itemname)) {
1472                 $elementroot = new backup_nested_element($itemname . 'ref');
1473                 $element = new backup_nested_element($itemname, array(), array('id'));
1474                 $inforef->add_child($elementroot);
1475                 $elementroot->add_child($element);
1476                 $element->set_source_sql("
1477                     SELECT itemid AS id
1478                      FROM {backup_ids_temp}
1479                     WHERE backupid = ?
1480                       AND itemname = ?",
1481                    array(backup::VAR_BACKUPID, backup_helper::is_sqlparam($itemname)));
1482             }
1483         }
1485         // We don't annotate anything there, but rely in the next step
1486         // (move_inforef_annotations_to_final) that will change all the
1487         // already saved 'inforref' entries to their 'final' annotations.
1488         return $inforef;
1489     }
1492 /**
1493  * This step will get all the annotations already processed to inforef.xml file and
1494  * transform them into 'final' annotations.
1495  */
1496 class move_inforef_annotations_to_final extends backup_execution_step {
1498     protected function define_execution() {
1500         // Items we want to include in the inforef file
1501         $items = backup_helper::get_inforef_itemnames();
1502         $progress = $this->task->get_progress();
1503         $progress->start_progress($this->get_name(), count($items));
1504         $done = 1;
1505         foreach ($items as $itemname) {
1506             // Delegate to dbops
1507             backup_structure_dbops::move_annotations_to_final($this->get_backupid(),
1508                     $itemname, $progress);
1509             $progress->progress($done++);
1510         }
1511         $progress->end_progress();
1512     }
1515 /**
1516  * structure in charge of constructing the files.xml file with all the
1517  * annotated (final) files along the process. At, the same time, and
1518  * using one specialised nested_element, will copy them form moodle storage
1519  * to backup storage
1520  */
1521 class backup_final_files_structure_step extends backup_structure_step {
1523     protected function define_structure() {
1525         // Define elements
1527         $files = new backup_nested_element('files');
1529         $file = new file_nested_element('file', array('id'), array(
1530             'contenthash', 'contextid', 'component', 'filearea', 'itemid',
1531             'filepath', 'filename', 'userid', 'filesize',
1532             'mimetype', 'status', 'timecreated', 'timemodified',
1533             'source', 'author', 'license', 'sortorder',
1534             'repositorytype', 'repositoryid', 'reference'));
1536         // Build the tree
1538         $files->add_child($file);
1540         // Define sources
1542         $file->set_source_sql("SELECT f.*, r.type AS repositorytype, fr.repositoryid, fr.reference
1543                                  FROM {files} f
1544                                       LEFT JOIN {files_reference} fr ON fr.id = f.referencefileid
1545                                       LEFT JOIN {repository_instances} ri ON ri.id = fr.repositoryid
1546                                       LEFT JOIN {repository} r ON r.id = ri.typeid
1547                                       JOIN {backup_ids_temp} bi ON f.id = bi.itemid
1548                                 WHERE bi.backupid = ?
1549                                   AND bi.itemname = 'filefinal'", array(backup::VAR_BACKUPID));
1551         return $files;
1552     }
1555 /**
1556  * Structure step in charge of creating the main moodle_backup.xml file
1557  * where all the information related to the backup, settings, license and
1558  * other information needed on restore is added*/
1559 class backup_main_structure_step extends backup_structure_step {
1561     protected function define_structure() {
1563         global $CFG;
1565         $info = array();
1567         $info['name'] = $this->get_setting_value('filename');
1568         $info['moodle_version'] = $CFG->version;
1569         $info['moodle_release'] = $CFG->release;
1570         $info['backup_version'] = $CFG->backup_version;
1571         $info['backup_release'] = $CFG->backup_release;
1572         $info['backup_date']    = time();
1573         $info['backup_uniqueid']= $this->get_backupid();
1574         $info['mnet_remoteusers']=backup_controller_dbops::backup_includes_mnet_remote_users($this->get_backupid());
1575         $info['include_files'] = backup_controller_dbops::backup_includes_files($this->get_backupid());
1576         $info['include_file_references_to_external_content'] =
1577                 backup_controller_dbops::backup_includes_file_references($this->get_backupid());
1578         $info['original_wwwroot']=$CFG->wwwroot;
1579         $info['original_site_identifier_hash'] = md5(get_site_identifier());
1580         $info['original_course_id'] = $this->get_courseid();
1581         $originalcourseinfo = backup_controller_dbops::backup_get_original_course_info($this->get_courseid());
1582         $info['original_course_fullname']  = $originalcourseinfo->fullname;
1583         $info['original_course_shortname'] = $originalcourseinfo->shortname;
1584         $info['original_course_startdate'] = $originalcourseinfo->startdate;
1585         $info['original_course_contextid'] = context_course::instance($this->get_courseid())->id;
1586         $info['original_system_contextid'] = context_system::instance()->id;
1588         // Get more information from controller
1589         list($dinfo, $cinfo, $sinfo) = backup_controller_dbops::get_moodle_backup_information($this->get_backupid());
1591         // Define elements
1593         $moodle_backup = new backup_nested_element('moodle_backup');
1595         $information = new backup_nested_element('information', null, array(
1596             'name', 'moodle_version', 'moodle_release', 'backup_version',
1597             'backup_release', 'backup_date', 'mnet_remoteusers', 'include_files', 'include_file_references_to_external_content', 'original_wwwroot',
1598             'original_site_identifier_hash', 'original_course_id',
1599             'original_course_fullname', 'original_course_shortname', 'original_course_startdate',
1600             'original_course_contextid', 'original_system_contextid'));
1602         $details = new backup_nested_element('details');
1604         $detail = new backup_nested_element('detail', array('backup_id'), array(
1605             'type', 'format', 'interactive', 'mode',
1606             'execution', 'executiontime'));
1608         $contents = new backup_nested_element('contents');
1610         $activities = new backup_nested_element('activities');
1612         $activity = new backup_nested_element('activity', null, array(
1613             'moduleid', 'sectionid', 'modulename', 'title',
1614             'directory'));
1616         $sections = new backup_nested_element('sections');
1618         $section = new backup_nested_element('section', null, array(
1619             'sectionid', 'title', 'directory'));
1621         $course = new backup_nested_element('course', null, array(
1622             'courseid', 'title', 'directory'));
1624         $settings = new backup_nested_element('settings');
1626         $setting = new backup_nested_element('setting', null, array(
1627             'level', 'section', 'activity', 'name', 'value'));
1629         // Build the tree
1631         $moodle_backup->add_child($information);
1633         $information->add_child($details);
1634         $details->add_child($detail);
1636         $information->add_child($contents);
1637         if (!empty($cinfo['activities'])) {
1638             $contents->add_child($activities);
1639             $activities->add_child($activity);
1640         }
1641         if (!empty($cinfo['sections'])) {
1642             $contents->add_child($sections);
1643             $sections->add_child($section);
1644         }
1645         if (!empty($cinfo['course'])) {
1646             $contents->add_child($course);
1647         }
1649         $information->add_child($settings);
1650         $settings->add_child($setting);
1653         // Set the sources
1655         $information->set_source_array(array((object)$info));
1657         $detail->set_source_array($dinfo);
1659         $activity->set_source_array($cinfo['activities']);
1661         $section->set_source_array($cinfo['sections']);
1663         $course->set_source_array($cinfo['course']);
1665         $setting->set_source_array($sinfo);
1667         // Prepare some information to be sent to main moodle_backup.xml file
1668         return $moodle_backup;
1669     }
1673 /**
1674  * Execution step that will generate the final zip (.mbz) file with all the contents
1675  */
1676 class backup_zip_contents extends backup_execution_step implements file_progress {
1677     /**
1678      * @var bool True if we have started tracking progress
1679      */
1680     protected $startedprogress;
1682     protected function define_execution() {
1684         // Get basepath
1685         $basepath = $this->get_basepath();
1687         // Get the list of files in directory
1688         $filestemp = get_directory_list($basepath, '', false, true, true);
1689         $files = array();
1690         foreach ($filestemp as $file) { // Add zip paths and fs paths to all them
1691             $files[$file] = $basepath . '/' . $file;
1692         }
1694         // Add the log file if exists
1695         $logfilepath = $basepath . '.log';
1696         if (file_exists($logfilepath)) {
1697              $files['moodle_backup.log'] = $logfilepath;
1698         }
1700         // Calculate the zip fullpath (in OS temp area it's always backup.mbz)
1701         $zipfile = $basepath . '/backup.mbz';
1703         // Get the zip packer
1704         $zippacker = get_file_packer('application/zip');
1706         // Zip files
1707         $zippacker->archive_to_pathname($files, $zipfile, true, $this);
1709         // If any progress happened, end it.
1710         if ($this->startedprogress) {
1711             $this->task->get_progress()->end_progress();
1712         }
1713     }
1715     /**
1716      * Implementation for file_progress interface to display unzip progress.
1717      *
1718      * @param int $progress Current progress
1719      * @param int $max Max value
1720      */
1721     public function progress($progress = file_progress::INDETERMINATE, $max = file_progress::INDETERMINATE) {
1722         $reporter = $this->task->get_progress();
1724         // Start tracking progress if necessary.
1725         if (!$this->startedprogress) {
1726             $reporter->start_progress('extract_file_to_dir', ($max == file_progress::INDETERMINATE)
1727                     ? core_backup_progress::INDETERMINATE : $max);
1728             $this->startedprogress = true;
1729         }
1731         // Pass progress through to whatever handles it.
1732         $reporter->progress(($progress == file_progress::INDETERMINATE)
1733                 ? core_backup_progress::INDETERMINATE : $progress);
1734      }
1737 /**
1738  * This step will send the generated backup file to its final destination
1739  */
1740 class backup_store_backup_file extends backup_execution_step {
1742     protected function define_execution() {
1744         // Get basepath
1745         $basepath = $this->get_basepath();
1747         // Calculate the zip fullpath (in OS temp area it's always backup.mbz)
1748         $zipfile = $basepath . '/backup.mbz';
1750         $has_file_references = backup_controller_dbops::backup_includes_file_references($this->get_backupid());
1751         // Perform storage and return it (TODO: shouldn't be array but proper result object)
1752         return array(
1753             'backup_destination' => backup_helper::store_backup_file($this->get_backupid(), $zipfile),
1754             'include_file_references_to_external_content' => $has_file_references
1755         );
1756     }
1760 /**
1761  * This step will search for all the activity (not calculations, categories nor aggregations) grade items
1762  * and put them to the backup_ids tables, to be used later as base to backup them
1763  */
1764 class backup_activity_grade_items_to_ids extends backup_execution_step {
1766     protected function define_execution() {
1768         // Fetch all activity grade items
1769         if ($items = grade_item::fetch_all(array(
1770                          'itemtype' => 'mod', 'itemmodule' => $this->task->get_modulename(),
1771                          'iteminstance' => $this->task->get_activityid(), 'courseid' => $this->task->get_courseid()))) {
1772             // Annotate them in backup_ids
1773             foreach ($items as $item) {
1774                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grade_item', $item->id);
1775             }
1776         }
1777     }
1780 /**
1781  * This step will annotate all the groups and groupings belonging to the course
1782  */
1783 class backup_annotate_course_groups_and_groupings extends backup_execution_step {
1785     protected function define_execution() {
1786         global $DB;
1788         // Get all the course groups
1789         if ($groups = $DB->get_records('groups', array(
1790                 'courseid' => $this->task->get_courseid()))) {
1791             foreach ($groups as $group) {
1792                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->id);
1793             }
1794         }
1796         // Get all the course groupings
1797         if ($groupings = $DB->get_records('groupings', array(
1798                 'courseid' => $this->task->get_courseid()))) {
1799             foreach ($groupings as $grouping) {
1800                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grouping', $grouping->id);
1801             }
1802         }
1803     }
1806 /**
1807  * This step will annotate all the groups belonging to already annotated groupings
1808  */
1809 class backup_annotate_groups_from_groupings extends backup_execution_step {
1811     protected function define_execution() {
1812         global $DB;
1814         // Fetch all the annotated groupings
1815         if ($groupings = $DB->get_records('backup_ids_temp', array(
1816                 'backupid' => $this->get_backupid(), 'itemname' => 'grouping'))) {
1817             foreach ($groupings as $grouping) {
1818                 if ($groups = $DB->get_records('groupings_groups', array(
1819                         'groupingid' => $grouping->itemid))) {
1820                     foreach ($groups as $group) {
1821                         backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->groupid);
1822                     }
1823                 }
1824             }
1825         }
1826     }
1829 /**
1830  * This step will annotate all the scales belonging to already annotated outcomes
1831  */
1832 class backup_annotate_scales_from_outcomes extends backup_execution_step {
1834     protected function define_execution() {
1835         global $DB;
1837         // Fetch all the annotated outcomes
1838         if ($outcomes = $DB->get_records('backup_ids_temp', array(
1839                 'backupid' => $this->get_backupid(), 'itemname' => 'outcome'))) {
1840             foreach ($outcomes as $outcome) {
1841                 if ($scale = $DB->get_record('grade_outcomes', array(
1842                         'id' => $outcome->itemid))) {
1843                     // Annotate as scalefinal because it's > 0
1844                     backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'scalefinal', $scale->scaleid);
1845                 }
1846             }
1847         }
1848     }
1851 /**
1852  * This step will generate all the file annotations for the already
1853  * annotated (final) question_categories. It calculates the different
1854  * contexts that are being backup and, annotates all the files
1855  * on every context belonging to the "question" component. As far as
1856  * we are always including *complete* question banks it is safe and
1857  * optimal to do that in this (one pass) way
1858  */
1859 class backup_annotate_all_question_files extends backup_execution_step {
1861     protected function define_execution() {
1862         global $DB;
1864         // Get all the different contexts for the final question_categories
1865         // annotated along the whole backup
1866         $rs = $DB->get_recordset_sql("SELECT DISTINCT qc.contextid
1867                                         FROM {question_categories} qc
1868                                         JOIN {backup_ids_temp} bi ON bi.itemid = qc.id
1869                                        WHERE bi.backupid = ?
1870                                          AND bi.itemname = 'question_categoryfinal'", array($this->get_backupid()));
1871         // To know about qtype specific components/fileareas
1872         $components = backup_qtype_plugin::get_components_and_fileareas();
1873         // Let's loop
1874         foreach($rs as $record) {
1875             // We don't need to specify filearea nor itemid as far as by
1876             // component and context it's enough to annotate the whole bank files
1877             // This backups "questiontext", "generalfeedback" and "answerfeedback" fileareas (all them
1878             // belonging to the "question" component
1879             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', null, null);
1880             // Again, it is enough to pick files only by context and component
1881             // Do it for qtype specific components
1882             foreach ($components as $component => $fileareas) {
1883                 backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, $component, null, null);
1884             }
1885         }
1886         $rs->close();
1887     }
1890 /**
1891  * structure step in charge of constructing the questions.xml file for all the
1892  * question categories and questions required by the backup
1893  * and letters related to one activity
1894  */
1895 class backup_questions_structure_step extends backup_structure_step {
1897     protected function define_structure() {
1899         // Define each element separated
1901         $qcategories = new backup_nested_element('question_categories');
1903         $qcategory = new backup_nested_element('question_category', array('id'), array(
1904             'name', 'contextid', 'contextlevel', 'contextinstanceid',
1905             'info', 'infoformat', 'stamp', 'parent',
1906             'sortorder'));
1908         $questions = new backup_nested_element('questions');
1910         $question = new backup_nested_element('question', array('id'), array(
1911             'parent', 'name', 'questiontext', 'questiontextformat',
1912             'generalfeedback', 'generalfeedbackformat', 'defaultmark', 'penalty',
1913             'qtype', 'length', 'stamp', 'version',
1914             'hidden', 'timecreated', 'timemodified', 'createdby', 'modifiedby'));
1916         // attach qtype plugin structure to $question element, only one allowed
1917         $this->add_plugin_structure('qtype', $question, false);
1919         // attach local plugin stucture to $question element, multiple allowed
1920         $this->add_plugin_structure('local', $question, true);
1922         $qhints = new backup_nested_element('question_hints');
1924         $qhint = new backup_nested_element('question_hint', array('id'), array(
1925             'hint', 'hintformat', 'shownumcorrect', 'clearwrong', 'options'));
1927         $tags = new backup_nested_element('tags');
1929         $tag = new backup_nested_element('tag', array('id'), array('name', 'rawname'));
1931         // Build the tree
1933         $qcategories->add_child($qcategory);
1934         $qcategory->add_child($questions);
1935         $questions->add_child($question);
1936         $question->add_child($qhints);
1937         $qhints->add_child($qhint);
1939         $question->add_child($tags);
1940         $tags->add_child($tag);
1942         // Define the sources
1944         $qcategory->set_source_sql("
1945             SELECT gc.*, contextlevel, instanceid AS contextinstanceid
1946               FROM {question_categories} gc
1947               JOIN {backup_ids_temp} bi ON bi.itemid = gc.id
1948               JOIN {context} co ON co.id = gc.contextid
1949              WHERE bi.backupid = ?
1950                AND bi.itemname = 'question_categoryfinal'", array(backup::VAR_BACKUPID));
1952         $question->set_source_table('question', array('category' => backup::VAR_PARENTID));
1954         $qhint->set_source_sql('
1955                 SELECT *
1956                 FROM {question_hints}
1957                 WHERE questionid = :questionid
1958                 ORDER BY id',
1959                 array('questionid' => backup::VAR_PARENTID));
1961         $tag->set_source_sql("SELECT t.id, t.name, t.rawname
1962                               FROM {tag} t
1963                               JOIN {tag_instance} ti ON ti.tagid = t.id
1964                               WHERE ti.itemid = ?
1965                               AND ti.itemtype = 'question'", array(backup::VAR_PARENTID));
1967         // don't need to annotate ids nor files
1968         // (already done by {@link backup_annotate_all_question_files}
1970         return $qcategories;
1971     }
1976 /**
1977  * This step will generate all the file  annotations for the already
1978  * annotated (final) users. Need to do this here because each user
1979  * has its own context and structure tasks only are able to handle
1980  * one context. Also, this step will guarantee that every user has
1981  * its context created (req for other steps)
1982  */
1983 class backup_annotate_all_user_files extends backup_execution_step {
1985     protected function define_execution() {
1986         global $DB;
1988         // List of fileareas we are going to annotate
1989         $fileareas = array('profile', 'icon');
1991         // Fetch all annotated (final) users
1992         $rs = $DB->get_recordset('backup_ids_temp', array(
1993             'backupid' => $this->get_backupid(), 'itemname' => 'userfinal'));
1994         $progress = $this->task->get_progress();
1995         $progress->start_progress($this->get_name());
1996         foreach ($rs as $record) {
1997             $userid = $record->itemid;
1998             $userctx = context_user::instance($userid, IGNORE_MISSING);
1999             if (!$userctx) {
2000                 continue; // User has not context, sure it's a deleted user, so cannot have files
2001             }
2002             // Proceed with every user filearea
2003             foreach ($fileareas as $filearea) {
2004                 // We don't need to specify itemid ($userid - 5th param) as far as by
2005                 // context we can get all the associated files. See MDL-22092
2006                 backup_structure_dbops::annotate_files($this->get_backupid(), $userctx->id, 'user', $filearea, null);
2007                 $progress->progress();
2008             }
2009         }
2010         $progress->end_progress();
2011         $rs->close();
2012     }
2016 /**
2017  * Defines the backup step for advanced grading methods attached to the activity module
2018  */
2019 class backup_activity_grading_structure_step extends backup_structure_step {
2021     /**
2022      * Include the grading.xml only if the module supports advanced grading
2023      */
2024     protected function execute_condition() {
2025         return plugin_supports('mod', $this->get_task()->get_modulename(), FEATURE_ADVANCED_GRADING, false);
2026     }
2028     /**
2029      * Declares the gradable areas structures and data sources
2030      */
2031     protected function define_structure() {
2033         // To know if we are including userinfo
2034         $userinfo = $this->get_setting_value('userinfo');
2036         // Define the elements
2038         $areas = new backup_nested_element('areas');
2040         $area = new backup_nested_element('area', array('id'), array(
2041             'areaname', 'activemethod'));
2043         $definitions = new backup_nested_element('definitions');
2045         $definition = new backup_nested_element('definition', array('id'), array(
2046             'method', 'name', 'description', 'descriptionformat', 'status',
2047             'timecreated', 'timemodified', 'options'));
2049         $instances = new backup_nested_element('instances');
2051         $instance = new backup_nested_element('instance', array('id'), array(
2052             'raterid', 'itemid', 'rawgrade', 'status', 'feedback',
2053             'feedbackformat', 'timemodified'));
2055         // Build the tree including the method specific structures
2056         // (beware - the order of how gradingform plugins structures are attached is important)
2057         $areas->add_child($area);
2058         // attach local plugin stucture to $area element, multiple allowed
2059         $this->add_plugin_structure('local', $area, true);
2060         $area->add_child($definitions);
2061         $definitions->add_child($definition);
2062         $this->add_plugin_structure('gradingform', $definition, true);
2063         // attach local plugin stucture to $definition element, multiple allowed
2064         $this->add_plugin_structure('local', $definition, true);
2065         $definition->add_child($instances);
2066         $instances->add_child($instance);
2067         $this->add_plugin_structure('gradingform', $instance, false);
2068         // attach local plugin stucture to $instance element, multiple allowed
2069         $this->add_plugin_structure('local', $instance, true);
2071         // Define data sources
2073         $area->set_source_table('grading_areas', array('contextid' => backup::VAR_CONTEXTID,
2074             'component' => array('sqlparam' => 'mod_'.$this->get_task()->get_modulename())));
2076         $definition->set_source_table('grading_definitions', array('areaid' => backup::VAR_PARENTID));
2078         if ($userinfo) {
2079             $instance->set_source_table('grading_instances', array('definitionid' => backup::VAR_PARENTID));
2080         }
2082         // Annotate references
2083         $definition->annotate_files('grading', 'description', 'id');
2084         $instance->annotate_ids('user', 'raterid');
2086         // Return the root element
2087         return $areas;
2088     }
2092 /**
2093  * structure step in charge of constructing the grades.xml file for all the grade items
2094  * and letters related to one activity
2095  */
2096 class backup_activity_grades_structure_step extends backup_structure_step {
2098     protected function define_structure() {
2100         // To know if we are including userinfo
2101         $userinfo = $this->get_setting_value('userinfo');
2103         // Define each element separated
2105         $book = new backup_nested_element('activity_gradebook');
2107         $items = new backup_nested_element('grade_items');
2109         $item = new backup_nested_element('grade_item', array('id'), array(
2110             'categoryid', 'itemname', 'itemtype', 'itemmodule',
2111             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
2112             'calculation', 'gradetype', 'grademax', 'grademin',
2113             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
2114             'plusfactor', 'aggregationcoef', 'sortorder', 'display',
2115             'decimals', 'hidden', 'locked', 'locktime',
2116             'needsupdate', 'timecreated', 'timemodified'));
2118         $grades = new backup_nested_element('grade_grades');
2120         $grade = new backup_nested_element('grade_grade', array('id'), array(
2121             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
2122             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
2123             'locked', 'locktime', 'exported', 'overridden',
2124             'excluded', 'feedback', 'feedbackformat', 'information',
2125             'informationformat', 'timecreated', 'timemodified'));
2127         $letters = new backup_nested_element('grade_letters');
2129         $letter = new backup_nested_element('grade_letter', 'id', array(
2130             'lowerboundary', 'letter'));
2132         // Build the tree
2134         $book->add_child($items);
2135         $items->add_child($item);
2137         $item->add_child($grades);
2138         $grades->add_child($grade);
2140         $book->add_child($letters);
2141         $letters->add_child($letter);
2143         // Define sources
2145         $item->set_source_sql("SELECT gi.*
2146                                FROM {grade_items} gi
2147                                JOIN {backup_ids_temp} bi ON gi.id = bi.itemid
2148                                WHERE bi.backupid = ?
2149                                AND bi.itemname = 'grade_item'", array(backup::VAR_BACKUPID));
2151         // This only happens if we are including user info
2152         if ($userinfo) {
2153             $grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
2154         }
2156         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
2158         // Annotations
2160         $item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
2161         $item->annotate_ids('outcome', 'outcomeid');
2163         $grade->annotate_ids('user', 'userid');
2164         $grade->annotate_ids('user', 'usermodified');
2166         // Return the root element (book)
2168         return $book;
2169     }
2172 /**
2173  * Backups up the course completion information for the course.
2174  */
2175 class backup_course_completion_structure_step extends backup_structure_step {
2177     protected function execute_condition() {
2178         // Check that all activities have been included
2179         if ($this->task->is_excluding_activities()) {
2180             return false;
2181         }
2182         return true;
2183     }
2185     /**
2186      * The structure of the course completion backup
2187      *
2188      * @return backup_nested_element
2189      */
2190     protected function define_structure() {
2192         // To know if we are including user completion info
2193         $userinfo = $this->get_setting_value('userscompletion');
2195         $cc = new backup_nested_element('course_completion');
2197         $criteria = new backup_nested_element('course_completion_criteria', array('id'), array(
2198             'course','criteriatype', 'module', 'moduleinstance', 'courseinstanceshortname', 'enrolperiod', 'timeend', 'gradepass', 'role'
2199         ));
2201         $criteriacompletions = new backup_nested_element('course_completion_crit_completions');
2203         $criteriacomplete = new backup_nested_element('course_completion_crit_compl', array('id'), array(
2204             'criteriaid', 'userid', 'gradefinal', 'unenrolled', 'timecompleted'
2205         ));
2207         $coursecompletions = new backup_nested_element('course_completions', array('id'), array(
2208             'userid', 'course', 'timeenrolled', 'timestarted', 'timecompleted', 'reaggregate'
2209         ));
2211         $aggregatemethod = new backup_nested_element('course_completion_aggr_methd', array('id'), array(
2212             'course','criteriatype','method','value'
2213         ));
2215         $cc->add_child($criteria);
2216             $criteria->add_child($criteriacompletions);
2217                 $criteriacompletions->add_child($criteriacomplete);
2218         $cc->add_child($coursecompletions);
2219         $cc->add_child($aggregatemethod);
2221         // We need to get the courseinstances shortname rather than an ID for restore
2222         $criteria->set_source_sql("SELECT ccc.*, c.shortname AS courseinstanceshortname
2223                                    FROM {course_completion_criteria} ccc
2224                                    LEFT JOIN {course} c ON c.id = ccc.courseinstance
2225                                    WHERE ccc.course = ?", array(backup::VAR_COURSEID));
2228         $aggregatemethod->set_source_table('course_completion_aggr_methd', array('course' => backup::VAR_COURSEID));
2230         if ($userinfo) {
2231             $criteriacomplete->set_source_table('course_completion_crit_compl', array('criteriaid' => backup::VAR_PARENTID));
2232             $coursecompletions->set_source_table('course_completions', array('course' => backup::VAR_COURSEID));
2233         }
2235         $criteria->annotate_ids('role', 'role');
2236         $criteriacomplete->annotate_ids('user', 'userid');
2237         $coursecompletions->annotate_ids('user', 'userid');
2239         return $cc;
2241     }