MDL-36540 - Survey language pack typo
[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 = 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_sql('
236                 SELECT *
237                 FROM {question_attempts}
238                 WHERE questionusageid = :questionusageid
239                 ORDER BY slot',
240                 array('questionusageid'   => backup::VAR_PARENTID));
241         $step->set_source_sql('
242                 SELECT *
243                 FROM {question_attempt_steps}
244                 WHERE questionattemptid = :questionattemptid
245                 ORDER BY sequencenumber',
246                 array('questionattemptid' => backup::VAR_PARENTID));
247         $variable->set_source_table('question_attempt_step_data',
248                 array('attemptstepid'     => backup::VAR_PARENTID));
250         // Annotate ids
251         $qa->annotate_ids('question', 'questionid');
252         $step->annotate_ids('user', 'userid');
254         // Annotate files
255         $fileareas = question_engine::get_all_response_file_areas();
256         foreach ($fileareas as $filearea) {
257             $step->annotate_files('question', $filearea, 'id');
258         }
259     }
263 /**
264  * backup structure step in charge of calculating the categories to be
265  * included in backup, based in the context being backuped (module/course)
266  * and the already annotated questions present in backup_ids_temp
267  */
268 class backup_calculate_question_categories extends backup_execution_step {
270     protected function define_execution() {
271         backup_question_dbops::calculate_question_categories($this->get_backupid(), $this->task->get_contextid());
272     }
275 /**
276  * backup structure step in charge of deleting all the questions annotated
277  * in the backup_ids_temp table
278  */
279 class backup_delete_temp_questions extends backup_execution_step {
281     protected function define_execution() {
282         backup_question_dbops::delete_temp_questions($this->get_backupid());
283     }
286 /**
287  * Abstract structure step, parent of all the block structure steps. Used to wrap the
288  * block structure definition within the main <block ...> tag
289  */
290 abstract class backup_block_structure_step extends backup_structure_step {
292     protected function prepare_block_structure($blockstructure) {
294         // Create the wrap element
295         $block = new backup_nested_element('block', array('id', 'blockname', 'contextid'), null);
297         // Build the tree
298         $block->add_child($blockstructure);
300         // Set the source
301         $blockarr = array((object)array(
302             'id'         => $this->task->get_blockid(),
303             'blockname'  => $this->task->get_blockname(),
304             'contextid'  => $this->task->get_contextid()));
306         $block->set_source_array($blockarr);
308         // Return the root element (block)
309         return $block;
310     }
313 /**
314  * structure step that will generate the module.xml file for the activity,
315  * accumulating various information about the activity, annotating groupings
316  * and completion/avail conf
317  */
318 class backup_module_structure_step extends backup_structure_step {
320     protected function define_structure() {
322         // Define each element separated
324         $module = new backup_nested_element('module', array('id', 'version'), array(
325             'modulename', 'sectionid', 'sectionnumber', 'idnumber',
326             'added', 'score', 'indent', 'visible',
327             'visibleold', 'groupmode', 'groupingid', 'groupmembersonly',
328             'completion', 'completiongradeitemnumber', 'completionview', 'completionexpected',
329             'availablefrom', 'availableuntil', 'showavailability', 'showdescription'));
331         $availinfo = new backup_nested_element('availability_info');
332         $availability = new backup_nested_element('availability', array('id'), array(
333             'sourcecmid', 'requiredcompletion', 'gradeitemid', 'grademin', 'grademax'));
334         $availabilityfield = new backup_nested_element('availability_field', array('id'), array(
335             'userfield', 'customfield', 'customfieldtype', 'operator', 'value'));
337         // attach format plugin structure to $module element, only one allowed
338         $this->add_plugin_structure('format', $module, false);
340         // attach plagiarism plugin structure to $module element, there can be potentially
341         // many plagiarism plugins storing information about this course
342         $this->add_plugin_structure('plagiarism', $module, true);
344         // attach local plugin structure to $module, multiple allowed
345         $this->add_plugin_structure('local', $module, true);
347         // Define the tree
348         $module->add_child($availinfo);
349         $availinfo->add_child($availability);
350         $availinfo->add_child($availabilityfield);
352         // Set the sources
353         $module->set_source_sql('
354             SELECT cm.*, m.version, m.name AS modulename, s.id AS sectionid, s.section AS sectionnumber
355               FROM {course_modules} cm
356               JOIN {modules} m ON m.id = cm.module
357               JOIN {course_sections} s ON s.id = cm.section
358              WHERE cm.id = ?', array(backup::VAR_MODID));
360         $availability->set_source_table('course_modules_availability', array('coursemoduleid' => backup::VAR_MODID));
361         $availabilityfield->set_source_sql('
362             SELECT cmaf.*, uif.shortname AS customfield, uif.datatype AS customfieldtype
363               FROM {course_modules_avail_fields} cmaf
364          LEFT JOIN {user_info_field} uif ON uif.id = cmaf.customfieldid
365              WHERE cmaf.coursemoduleid = ?', array(backup::VAR_MODID));
367         // Define annotations
368         $module->annotate_ids('grouping', 'groupingid');
370         // Return the root element ($module)
371         return $module;
372     }
375 /**
376  * structure step that will generate the section.xml file for the section
377  * annotating files
378  */
379 class backup_section_structure_step extends backup_structure_step {
381     protected function define_structure() {
383         // Define each element separated
385         $section = new backup_nested_element('section', array('id'), array(
386                 'number', 'name', 'summary', 'summaryformat', 'sequence', 'visible',
387                 'availablefrom', 'availableuntil', 'showavailability', 'groupingid'));
389         // attach format plugin structure to $section element, only one allowed
390         $this->add_plugin_structure('format', $section, false);
392         // attach local plugin structure to $section element, multiple allowed
393         $this->add_plugin_structure('local', $section, true);
395         // Add nested elements for _availability table
396         $avail = new backup_nested_element('availability', array('id'), array(
397                 'sourcecmid', 'requiredcompletion', 'gradeitemid', 'grademin', 'grademax'));
398         $availfield = new backup_nested_element('availability_field', array('id'), array(
399             'userfield', 'operator', 'value', 'customfield', 'customfieldtype'));
400         $section->add_child($avail);
401         $section->add_child($availfield);
403         // Add nested elements for course_format_options table
404         $formatoptions = new backup_nested_element('course_format_options', array('id'), array(
405             'format', 'name', 'value'));
406         $section->add_child($formatoptions);
408         // Define sources
409         $section->set_source_table('course_sections', array('id' => backup::VAR_SECTIONID));
410         $avail->set_source_table('course_sections_availability', array('coursesectionid' => backup::VAR_SECTIONID));
411         $availfield->set_source_sql('
412             SELECT csaf.*, uif.shortname AS customfield, uif.datatype AS customfieldtype
413               FROM {course_sections_avail_fields} csaf
414          LEFT JOIN {user_info_field} uif ON uif.id = csaf.customfieldid
415              WHERE csaf.coursesectionid = ?', array(backup::VAR_SECTIONID));
416         $formatoptions->set_source_sql('SELECT cfo.id, cfo.format, cfo.name, cfo.value
417               FROM {course} c
418               JOIN {course_format_options} cfo
419               ON cfo.courseid = c.id AND cfo.format = c.format
420               WHERE c.id = ? AND cfo.sectionid = ?',
421                 array(backup::VAR_COURSEID, backup::VAR_SECTIONID));
423         // Aliases
424         $section->set_source_alias('section', 'number');
426         // Set annotations
427         $section->annotate_ids('grouping', 'groupingid');
428         $section->annotate_files('course', 'section', 'id');
430         return $section;
431     }
434 /**
435  * structure step that will generate the course.xml file for the course, including
436  * course category reference, tags, modules restriction information
437  * and some annotations (files & groupings)
438  */
439 class backup_course_structure_step extends backup_structure_step {
441     protected function define_structure() {
442         global $DB;
444         // Define each element separated
446         $course = new backup_nested_element('course', array('id', 'contextid'), array(
447             'shortname', 'fullname', 'idnumber',
448             'summary', 'summaryformat', 'format', 'showgrades',
449             'newsitems', 'startdate',
450             'marker', 'maxbytes', 'legacyfiles', 'showreports',
451             'visible', 'groupmode', 'groupmodeforce',
452             'defaultgroupingid', 'lang', 'theme',
453             'timecreated', 'timemodified',
454             'requested',
455             'enablecompletion', 'completionstartonenrol', 'completionnotify'));
457         $category = new backup_nested_element('category', array('id'), array(
458             'name', 'description'));
460         $tags = new backup_nested_element('tags');
462         $tag = new backup_nested_element('tag', array('id'), array(
463             'name', 'rawname'));
465         // attach format plugin structure to $course element, only one allowed
466         $this->add_plugin_structure('format', $course, false);
468         // attach theme plugin structure to $course element; multiple themes can
469         // save course data (in case of user theme, legacy theme, etc)
470         $this->add_plugin_structure('theme', $course, true);
472         // attach general report plugin structure to $course element; multiple
473         // reports can save course data if required
474         $this->add_plugin_structure('report', $course, true);
476         // attach course report plugin structure to $course element; multiple
477         // course reports can save course data if required
478         $this->add_plugin_structure('coursereport', $course, true);
480         // attach plagiarism plugin structure to $course element, there can be potentially
481         // many plagiarism plugins storing information about this course
482         $this->add_plugin_structure('plagiarism', $course, true);
484         // attach local plugin structure to $course element; multiple local plugins
485         // can save course data if required
486         $this->add_plugin_structure('local', $course, true);
488         // Build the tree
490         $course->add_child($category);
492         $course->add_child($tags);
493         $tags->add_child($tag);
495         // Set the sources
497         $courserec = $DB->get_record('course', array('id' => $this->task->get_courseid()));
498         $courserec->contextid = $this->task->get_contextid();
500         $formatoptions = course_get_format($courserec)->get_format_options();
501         $course->add_final_elements(array_keys($formatoptions));
502         foreach ($formatoptions as $key => $value) {
503             $courserec->$key = $value;
504         }
506         $course->set_source_array(array($courserec));
508         $categoryrec = $DB->get_record('course_categories', array('id' => $courserec->category));
510         $category->set_source_array(array($categoryrec));
512         $tag->set_source_sql('SELECT t.id, t.name, t.rawname
513                                 FROM {tag} t
514                                 JOIN {tag_instance} ti ON ti.tagid = t.id
515                                WHERE ti.itemtype = ?
516                                  AND ti.itemid = ?', array(
517                                      backup_helper::is_sqlparam('course'),
518                                      backup::VAR_PARENTID));
520         // Some annotations
522         $course->annotate_ids('grouping', 'defaultgroupingid');
524         $course->annotate_files('course', 'summary', null);
525         $course->annotate_files('course', 'legacy', null);
527         // Return root element ($course)
529         return $course;
530     }
533 /**
534  * structure step that will generate the enrolments.xml file for the given course
535  */
536 class backup_enrolments_structure_step extends backup_structure_step {
538     protected function define_structure() {
540         // To know if we are including users
541         $users = $this->get_setting_value('users');
543         // Define each element separated
545         $enrolments = new backup_nested_element('enrolments');
547         $enrols = new backup_nested_element('enrols');
549         $enrol = new backup_nested_element('enrol', array('id'), array(
550             'enrol', 'status', 'name', 'enrolperiod', 'enrolstartdate',
551             'enrolenddate', 'expirynotify', 'expirytreshold', 'notifyall',
552             'password', 'cost', 'currency', 'roleid',
553             'customint1', 'customint2', 'customint3', 'customint4', 'customint5', 'customint6', 'customint7', 'customint8',
554             'customchar1', 'customchar2', 'customchar3',
555             'customdec1', 'customdec2',
556             'customtext1', 'customtext2', 'customtext3', 'customtext4',
557             'timecreated', 'timemodified'));
559         $userenrolments = new backup_nested_element('user_enrolments');
561         $enrolment = new backup_nested_element('enrolment', array('id'), array(
562             'status', 'userid', 'timestart', 'timeend', 'modifierid',
563             'timemodified'));
565         // Build the tree
566         $enrolments->add_child($enrols);
567         $enrols->add_child($enrol);
568         $enrol->add_child($userenrolments);
569         $userenrolments->add_child($enrolment);
571         // Define sources - the instances are restored using the same sortorder, we do not need to store it in xml and deal with it afterwards.
572         $enrol->set_source_sql("SELECT * FROM {enrol} WHERE courseid = :courseid ORDER BY sortorder", array('courseid' => backup::VAR_COURSEID));
574         // User enrolments only added only if users included
575         if ($users) {
576             $enrolment->set_source_table('user_enrolments', array('enrolid' => backup::VAR_PARENTID));
577             $enrolment->annotate_ids('user', 'userid');
578         }
580         $enrol->annotate_ids('role', 'roleid');
582         //TODO: let plugins annotate custom fields too and add more children
584         return $enrolments;
585     }
588 /**
589  * structure step that will generate the roles.xml file for the given context, observing
590  * the role_assignments setting to know if that part needs to be included
591  */
592 class backup_roles_structure_step extends backup_structure_step {
594     protected function define_structure() {
596         // To know if we are including role assignments
597         $roleassignments = $this->get_setting_value('role_assignments');
599         // Define each element separated
601         $roles = new backup_nested_element('roles');
603         $overrides = new backup_nested_element('role_overrides');
605         $override = new backup_nested_element('override', array('id'), array(
606             'roleid', 'capability', 'permission', 'timemodified',
607             'modifierid'));
609         $assignments = new backup_nested_element('role_assignments');
611         $assignment = new backup_nested_element('assignment', array('id'), array(
612             'roleid', 'userid', 'timemodified', 'modifierid', 'component', 'itemid',
613             'sortorder'));
615         // Build the tree
616         $roles->add_child($overrides);
617         $roles->add_child($assignments);
619         $overrides->add_child($override);
620         $assignments->add_child($assignment);
622         // Define sources
624         $override->set_source_table('role_capabilities', array('contextid' => backup::VAR_CONTEXTID));
626         // Assignments only added if specified
627         if ($roleassignments) {
628             $assignment->set_source_table('role_assignments', array('contextid' => backup::VAR_CONTEXTID));
629         }
631         // Define id annotations
632         $override->annotate_ids('role', 'roleid');
634         $assignment->annotate_ids('role', 'roleid');
636         $assignment->annotate_ids('user', 'userid');
638         //TODO: how do we annotate the itemid? the meaning depends on the content of component table (skodak)
640         return $roles;
641     }
644 /**
645  * structure step that will generate the roles.xml containing the
646  * list of roles used along the whole backup process. Just raw
647  * list of used roles from role table
648  */
649 class backup_final_roles_structure_step extends backup_structure_step {
651     protected function define_structure() {
653         // Define elements
655         $rolesdef = new backup_nested_element('roles_definition');
657         $role = new backup_nested_element('role', array('id'), array(
658             'name', 'shortname', 'nameincourse', 'description',
659             'sortorder', 'archetype'));
661         // Build the tree
663         $rolesdef->add_child($role);
665         // Define sources
667         $role->set_source_sql("SELECT r.*, rn.name AS nameincourse
668                                  FROM {role} r
669                                  JOIN {backup_ids_temp} bi ON r.id = bi.itemid
670                             LEFT JOIN {role_names} rn ON r.id = rn.roleid AND rn.contextid = ?
671                                 WHERE bi.backupid = ?
672                                   AND bi.itemname = 'rolefinal'", array(backup::VAR_CONTEXTID, backup::VAR_BACKUPID));
674         // Return main element (rolesdef)
675         return $rolesdef;
676     }
679 /**
680  * structure step that will generate the scales.xml containing the
681  * list of scales used along the whole backup process.
682  */
683 class backup_final_scales_structure_step extends backup_structure_step {
685     protected function define_structure() {
687         // Define elements
689         $scalesdef = new backup_nested_element('scales_definition');
691         $scale = new backup_nested_element('scale', array('id'), array(
692             'courseid', 'userid', 'name', 'scale',
693             'description', 'descriptionformat', 'timemodified'));
695         // Build the tree
697         $scalesdef->add_child($scale);
699         // Define sources
701         $scale->set_source_sql("SELECT s.*
702                                   FROM {scale} s
703                                   JOIN {backup_ids_temp} bi ON s.id = bi.itemid
704                                  WHERE bi.backupid = ?
705                                    AND bi.itemname = 'scalefinal'", array(backup::VAR_BACKUPID));
707         // Annotate scale files (they store files in system context, so pass it instead of default one)
708         $scale->annotate_files('grade', 'scale', 'id', context_system::instance()->id);
710         // Return main element (scalesdef)
711         return $scalesdef;
712     }
715 /**
716  * structure step that will generate the outcomes.xml containing the
717  * list of outcomes used along the whole backup process.
718  */
719 class backup_final_outcomes_structure_step extends backup_structure_step {
721     protected function define_structure() {
723         // Define elements
725         $outcomesdef = new backup_nested_element('outcomes_definition');
727         $outcome = new backup_nested_element('outcome', array('id'), array(
728             'courseid', 'userid', 'shortname', 'fullname',
729             'scaleid', 'description', 'descriptionformat', 'timecreated',
730             'timemodified','usermodified'));
732         // Build the tree
734         $outcomesdef->add_child($outcome);
736         // Define sources
738         $outcome->set_source_sql("SELECT o.*
739                                     FROM {grade_outcomes} o
740                                     JOIN {backup_ids_temp} bi ON o.id = bi.itemid
741                                    WHERE bi.backupid = ?
742                                      AND bi.itemname = 'outcomefinal'", array(backup::VAR_BACKUPID));
744         // Annotate outcome files (they store files in system context, so pass it instead of default one)
745         $outcome->annotate_files('grade', 'outcome', 'id', context_system::instance()->id);
747         // Return main element (outcomesdef)
748         return $outcomesdef;
749     }
752 /**
753  * structure step in charge of constructing the filters.xml file for all the filters found
754  * in activity
755  */
756 class backup_filters_structure_step extends backup_structure_step {
758     protected function define_structure() {
760         // Define each element separated
762         $filters = new backup_nested_element('filters');
764         $actives = new backup_nested_element('filter_actives');
766         $active = new backup_nested_element('filter_active', null, array('filter', 'active'));
768         $configs = new backup_nested_element('filter_configs');
770         $config = new backup_nested_element('filter_config', null, array('filter', 'name', 'value'));
772         // Build the tree
774         $filters->add_child($actives);
775         $filters->add_child($configs);
777         $actives->add_child($active);
778         $configs->add_child($config);
780         // Define sources
782         list($activearr, $configarr) = filter_get_all_local_settings($this->task->get_contextid());
784         $active->set_source_array($activearr);
785         $config->set_source_array($configarr);
787         // Return the root element (filters)
788         return $filters;
789     }
792 /**
793  * structure step in charge of constructing the comments.xml file for all the comments found
794  * in a given context
795  */
796 class backup_comments_structure_step extends backup_structure_step {
798     protected function define_structure() {
800         // Define each element separated
802         $comments = new backup_nested_element('comments');
804         $comment = new backup_nested_element('comment', array('id'), array(
805             'commentarea', 'itemid', 'content', 'format',
806             'userid', 'timecreated'));
808         // Build the tree
810         $comments->add_child($comment);
812         // Define sources
814         $comment->set_source_table('comments', array('contextid' => backup::VAR_CONTEXTID));
816         // Define id annotations
818         $comment->annotate_ids('user', 'userid');
820         // Return the root element (comments)
821         return $comments;
822     }
825 /**
826  * structure step in charge of constructing the calender.xml file for all the events found
827  * in a given context
828  */
829 class backup_calendarevents_structure_step extends backup_structure_step {
831     protected function define_structure() {
833         // Define each element separated
835         $events = new backup_nested_element('events');
837         $event = new backup_nested_element('event', array('id'), array(
838                 'name', 'description', 'format', 'courseid', 'groupid', 'userid',
839                 'repeatid', 'modulename', 'instance', 'eventtype', 'timestart',
840                 'timeduration', 'visible', 'uuid', 'sequence', 'timemodified'));
842         // Build the tree
843         $events->add_child($event);
845         // Define sources
846         if ($this->name == 'course_calendar') {
847             $calendar_items_sql ="SELECT * FROM {event}
848                         WHERE courseid = :courseid
849                         AND (eventtype = 'course' OR eventtype = 'group')";
850             $calendar_items_params = array('courseid'=>backup::VAR_COURSEID);
851             $event->set_source_sql($calendar_items_sql, $calendar_items_params);
852         } else {
853             $event->set_source_table('event', array('courseid' => backup::VAR_COURSEID, 'instance' => backup::VAR_ACTIVITYID, 'modulename' => backup::VAR_MODNAME));
854         }
856         // Define id annotations
858         $event->annotate_ids('user', 'userid');
859         $event->annotate_ids('group', 'groupid');
860         $event->annotate_files('calendar', 'event_description', 'id');
862         // Return the root element (events)
863         return $events;
864     }
867 /**
868  * structure step in charge of constructing the gradebook.xml file for all the gradebook config in the course
869  * NOTE: the backup of the grade items themselves is handled by backup_activity_grades_structure_step
870  */
871 class backup_gradebook_structure_step extends backup_structure_step {
873     /**
874      * We need to decide conditionally, based on dynamic information
875      * about the execution of this step. Only will be executed if all
876      * the module gradeitems have been already included in backup
877      */
878     protected function execute_condition() {
879         return backup_plan_dbops::require_gradebook_backup($this->get_courseid(), $this->get_backupid());
880     }
882     protected function define_structure() {
884         // are we including user info?
885         $userinfo = $this->get_setting_value('users');
887         $gradebook = new backup_nested_element('gradebook');
889         //grade_letters are done in backup_activity_grades_structure_step()
891         //calculated grade items
892         $grade_items = new backup_nested_element('grade_items');
893         $grade_item = new backup_nested_element('grade_item', array('id'), array(
894             'categoryid', 'itemname', 'itemtype', 'itemmodule',
895             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
896             'calculation', 'gradetype', 'grademax', 'grademin',
897             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
898             'plusfactor', 'aggregationcoef', 'sortorder', 'display',
899             'decimals', 'hidden', 'locked', 'locktime',
900             'needsupdate', 'timecreated', 'timemodified'));
902         $grade_grades = new backup_nested_element('grade_grades');
903         $grade_grade = new backup_nested_element('grade_grade', array('id'), array(
904             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
905             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
906             'locked', 'locktime', 'exported', 'overridden',
907             'excluded', 'feedback', 'feedbackformat', 'information',
908             'informationformat', 'timecreated', 'timemodified'));
910         //grade_categories
911         $grade_categories = new backup_nested_element('grade_categories');
912         $grade_category   = new backup_nested_element('grade_category', array('id'), array(
913                 //'courseid',
914                 'parent', 'depth', 'path', 'fullname', 'aggregation', 'keephigh',
915                 'dropload', 'aggregateonlygraded', 'aggregateoutcomes', 'aggregatesubcats',
916                 'timecreated', 'timemodified', 'hidden'));
918         $letters = new backup_nested_element('grade_letters');
919         $letter = new backup_nested_element('grade_letter', 'id', array(
920             'lowerboundary', 'letter'));
922         $grade_settings = new backup_nested_element('grade_settings');
923         $grade_setting = new backup_nested_element('grade_setting', 'id', array(
924             'name', 'value'));
927         // Build the tree
928         $gradebook->add_child($grade_categories);
929         $grade_categories->add_child($grade_category);
931         $gradebook->add_child($grade_items);
932         $grade_items->add_child($grade_item);
933         $grade_item->add_child($grade_grades);
934         $grade_grades->add_child($grade_grade);
936         $gradebook->add_child($letters);
937         $letters->add_child($letter);
939         $gradebook->add_child($grade_settings);
940         $grade_settings->add_child($grade_setting);
942         // Define sources
944         //Include manual, category and the course grade item
945         $grade_items_sql ="SELECT * FROM {grade_items}
946                            WHERE courseid = :courseid
947                            AND (itemtype='manual' OR itemtype='course' OR itemtype='category')";
948         $grade_items_params = array('courseid'=>backup::VAR_COURSEID);
949         $grade_item->set_source_sql($grade_items_sql, $grade_items_params);
951         if ($userinfo) {
952             $grade_grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
953         }
955         $grade_category_sql = "SELECT gc.*, gi.sortorder
956                                FROM {grade_categories} gc
957                                JOIN {grade_items} gi ON (gi.iteminstance = gc.id)
958                                WHERE gc.courseid = :courseid
959                                AND (gi.itemtype='course' OR gi.itemtype='category')
960                                ORDER BY gc.parent ASC";//need parent categories before their children
961         $grade_category_params = array('courseid'=>backup::VAR_COURSEID);
962         $grade_category->set_source_sql($grade_category_sql, $grade_category_params);
964         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
966         $grade_setting->set_source_table('grade_settings', array('courseid' => backup::VAR_COURSEID));
968         // Annotations (both as final as far as they are going to be exported in next steps)
969         $grade_item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
970         $grade_item->annotate_ids('outcomefinal', 'outcomeid');
972         //just in case there are any users not already annotated by the activities
973         $grade_grade->annotate_ids('userfinal', 'userid');
975         // Return the root element
976         return $gradebook;
977     }
980 /**
981  * structure step in charge if constructing the completion.xml file for all the users completion
982  * information in a given activity
983  */
984 class backup_userscompletion_structure_step extends backup_structure_step {
986     protected function define_structure() {
988         // Define each element separated
990         $completions = new backup_nested_element('completions');
992         $completion = new backup_nested_element('completion', array('id'), array(
993             'userid', 'completionstate', 'viewed', 'timemodified'));
995         // Build the tree
997         $completions->add_child($completion);
999         // Define sources
1001         $completion->set_source_table('course_modules_completion', array('coursemoduleid' => backup::VAR_MODID));
1003         // Define id annotations
1005         $completion->annotate_ids('user', 'userid');
1007         // Return the root element (completions)
1008         return $completions;
1009     }
1012 /**
1013  * structure step in charge of constructing the main groups.xml file for all the groups and
1014  * groupings information already annotated
1015  */
1016 class backup_groups_structure_step extends backup_structure_step {
1018     protected function define_structure() {
1020         // To know if we are including users
1021         $users = $this->get_setting_value('users');
1023         // Define each element separated
1025         $groups = new backup_nested_element('groups');
1027         $group = new backup_nested_element('group', array('id'), array(
1028             'name', 'idnumber', 'description', 'descriptionformat', 'enrolmentkey',
1029             'picture', 'hidepicture', 'timecreated', 'timemodified'));
1031         $members = new backup_nested_element('group_members');
1033         $member = new backup_nested_element('group_member', array('id'), array(
1034             'userid', 'timeadded', 'component', 'itemid'));
1036         $groupings = new backup_nested_element('groupings');
1038         $grouping = new backup_nested_element('grouping', 'id', array(
1039             'name', 'idnumber', 'description', 'descriptionformat', 'configdata',
1040             'timecreated', 'timemodified'));
1042         $groupinggroups = new backup_nested_element('grouping_groups');
1044         $groupinggroup = new backup_nested_element('grouping_group', array('id'), array(
1045             'groupid', 'timeadded'));
1047         // Build the tree
1049         $groups->add_child($group);
1050         $groups->add_child($groupings);
1052         $group->add_child($members);
1053         $members->add_child($member);
1055         $groupings->add_child($grouping);
1056         $grouping->add_child($groupinggroups);
1057         $groupinggroups->add_child($groupinggroup);
1059         // Define sources
1061         $group->set_source_sql("
1062             SELECT g.*
1063               FROM {groups} g
1064               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
1065              WHERE bi.backupid = ?
1066                AND bi.itemname = 'groupfinal'", array(backup::VAR_BACKUPID));
1068         // This only happens if we are including users
1069         if ($users) {
1070             $member->set_source_table('groups_members', array('groupid' => backup::VAR_PARENTID));
1071         }
1073         $grouping->set_source_sql("
1074             SELECT g.*
1075               FROM {groupings} g
1076               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
1077              WHERE bi.backupid = ?
1078                AND bi.itemname = 'groupingfinal'", array(backup::VAR_BACKUPID));
1080         $groupinggroup->set_source_table('groupings_groups', array('groupingid' => backup::VAR_PARENTID));
1082         // Define id annotations (as final)
1084         $member->annotate_ids('userfinal', 'userid');
1086         // Define file annotations
1088         $group->annotate_files('group', 'description', 'id');
1089         $group->annotate_files('group', 'icon', 'id');
1090         $grouping->annotate_files('grouping', 'description', 'id');
1092         // Return the root element (groups)
1093         return $groups;
1094     }
1097 /**
1098  * structure step in charge of constructing the main users.xml file for all the users already
1099  * annotated (final). Includes custom profile fields, preferences, tags, role assignments and
1100  * overrides.
1101  */
1102 class backup_users_structure_step extends backup_structure_step {
1104     protected function define_structure() {
1105         global $CFG;
1107         // To know if we are anonymizing users
1108         $anonymize = $this->get_setting_value('anonymize');
1109         // To know if we are including role assignments
1110         $roleassignments = $this->get_setting_value('role_assignments');
1112         // Define each element separated
1114         $users = new backup_nested_element('users');
1116         // Create the array of user fields by hand, as far as we have various bits to control
1117         // anonymize option, password backup, mnethostid...
1119         // First, the fields not needing anonymization nor special handling
1120         $normalfields = array(
1121             'confirmed', 'policyagreed', 'deleted',
1122             'lang', 'theme', 'timezone', 'firstaccess',
1123             'lastaccess', 'lastlogin', 'currentlogin',
1124             'mailformat', 'maildigest', 'maildisplay', 'htmleditor',
1125             'autosubscribe', 'trackforums', 'timecreated',
1126             'timemodified', 'trustbitmask');
1128         // Then, the fields potentially needing anonymization
1129         $anonfields = array(
1130             'username', 'idnumber', 'firstname', 'lastname',
1131             'email', 'icq', 'skype',
1132             'yahoo', 'aim', 'msn', 'phone1',
1133             'phone2', 'institution', 'department', 'address',
1134             'city', 'country', 'lastip', 'picture',
1135             'url', 'description', 'descriptionformat', 'imagealt', 'auth');
1137         // Add anonymized fields to $userfields with custom final element
1138         foreach ($anonfields as $field) {
1139             if ($anonymize) {
1140                 $userfields[] = new anonymizer_final_element($field);
1141             } else {
1142                 $userfields[] = $field; // No anonymization, normally added
1143             }
1144         }
1146         // mnethosturl requires special handling (custom final element)
1147         $userfields[] = new mnethosturl_final_element('mnethosturl');
1149         // password added conditionally
1150         if (!empty($CFG->includeuserpasswordsinbackup)) {
1151             $userfields[] = 'password';
1152         }
1154         // Merge all the fields
1155         $userfields = array_merge($userfields, $normalfields);
1157         $user = new backup_nested_element('user', array('id', 'contextid'), $userfields);
1159         $customfields = new backup_nested_element('custom_fields');
1161         $customfield = new backup_nested_element('custom_field', array('id'), array(
1162             'field_name', 'field_type', 'field_data'));
1164         $tags = new backup_nested_element('tags');
1166         $tag = new backup_nested_element('tag', array('id'), array(
1167             'name', 'rawname'));
1169         $preferences = new backup_nested_element('preferences');
1171         $preference = new backup_nested_element('preference', array('id'), array(
1172             'name', 'value'));
1174         $roles = new backup_nested_element('roles');
1176         $overrides = new backup_nested_element('role_overrides');
1178         $override = new backup_nested_element('override', array('id'), array(
1179             'roleid', 'capability', 'permission', 'timemodified',
1180             'modifierid'));
1182         $assignments = new backup_nested_element('role_assignments');
1184         $assignment = new backup_nested_element('assignment', array('id'), array(
1185             'roleid', 'userid', 'timemodified', 'modifierid', 'component', //TODO: MDL-22793 add itemid here
1186             'sortorder'));
1188         // Build the tree
1190         $users->add_child($user);
1192         $user->add_child($customfields);
1193         $customfields->add_child($customfield);
1195         $user->add_child($tags);
1196         $tags->add_child($tag);
1198         $user->add_child($preferences);
1199         $preferences->add_child($preference);
1201         $user->add_child($roles);
1203         $roles->add_child($overrides);
1204         $roles->add_child($assignments);
1206         $overrides->add_child($override);
1207         $assignments->add_child($assignment);
1209         // Define sources
1211         $user->set_source_sql('SELECT u.*, c.id AS contextid, m.wwwroot AS mnethosturl
1212                                  FROM {user} u
1213                                  JOIN {backup_ids_temp} bi ON bi.itemid = u.id
1214                             LEFT JOIN {context} c ON c.instanceid = u.id AND c.contextlevel = ' . CONTEXT_USER . '
1215                             LEFT JOIN {mnet_host} m ON m.id = u.mnethostid
1216                                 WHERE bi.backupid = ?
1217                                   AND bi.itemname = ?', array(
1218                                       backup_helper::is_sqlparam($this->get_backupid()),
1219                                       backup_helper::is_sqlparam('userfinal')));
1221         // All the rest on information is only added if we arent
1222         // in an anonymized backup
1223         if (!$anonymize) {
1224             $customfield->set_source_sql('SELECT f.id, f.shortname, f.datatype, d.data
1225                                             FROM {user_info_field} f
1226                                             JOIN {user_info_data} d ON d.fieldid = f.id
1227                                            WHERE d.userid = ?', array(backup::VAR_PARENTID));
1229             $customfield->set_source_alias('shortname', 'field_name');
1230             $customfield->set_source_alias('datatype',  'field_type');
1231             $customfield->set_source_alias('data',      'field_data');
1233             $tag->set_source_sql('SELECT t.id, t.name, t.rawname
1234                                     FROM {tag} t
1235                                     JOIN {tag_instance} ti ON ti.tagid = t.id
1236                                    WHERE ti.itemtype = ?
1237                                      AND ti.itemid = ?', array(
1238                                          backup_helper::is_sqlparam('user'),
1239                                          backup::VAR_PARENTID));
1241             $preference->set_source_table('user_preferences', array('userid' => backup::VAR_PARENTID));
1243             $override->set_source_table('role_capabilities', array('contextid' => '/users/user/contextid'));
1245             // Assignments only added if specified
1246             if ($roleassignments) {
1247                 $assignment->set_source_table('role_assignments', array('contextid' => '/users/user/contextid'));
1248             }
1250             // Define id annotations (as final)
1251             $override->annotate_ids('rolefinal', 'roleid');
1252         }
1254         // Return root element (users)
1255         return $users;
1256     }
1259 /**
1260  * structure step in charge of constructing the block.xml file for one
1261  * given block (instance and positions). If the block has custom DB structure
1262  * that will go to a separate file (different step defined in block class)
1263  */
1264 class backup_block_instance_structure_step extends backup_structure_step {
1266     protected function define_structure() {
1267         global $DB;
1269         // Define each element separated
1271         $block = new backup_nested_element('block', array('id', 'contextid', 'version'), array(
1272             'blockname', 'parentcontextid', 'showinsubcontexts', 'pagetypepattern',
1273             'subpagepattern', 'defaultregion', 'defaultweight', 'configdata'));
1275         $positions = new backup_nested_element('block_positions');
1277         $position = new backup_nested_element('block_position', array('id'), array(
1278             'contextid', 'pagetype', 'subpage', 'visible',
1279             'region', 'weight'));
1281         // Build the tree
1283         $block->add_child($positions);
1284         $positions->add_child($position);
1286         // Transform configdata information if needed (process links and friends)
1287         $blockrec = $DB->get_record('block_instances', array('id' => $this->task->get_blockid()));
1288         if ($attrstotransform = $this->task->get_configdata_encoded_attributes()) {
1289             $configdata = (array)unserialize(base64_decode($blockrec->configdata));
1290             foreach ($configdata as $attribute => $value) {
1291                 if (in_array($attribute, $attrstotransform)) {
1292                     $configdata[$attribute] = $this->contenttransformer->process($value);
1293                 }
1294             }
1295             $blockrec->configdata = base64_encode(serialize((object)$configdata));
1296         }
1297         $blockrec->contextid = $this->task->get_contextid();
1298         // Get the version of the block
1299         $blockrec->version = $DB->get_field('block', 'version', array('name' => $this->task->get_blockname()));
1301         // Define sources
1303         $block->set_source_array(array($blockrec));
1305         $position->set_source_table('block_positions', array('blockinstanceid' => backup::VAR_PARENTID));
1307         // File anotations (for fileareas specified on each block)
1308         foreach ($this->task->get_fileareas() as $filearea) {
1309             $block->annotate_files('block_' . $this->task->get_blockname(), $filearea, null);
1310         }
1312         // Return the root element (block)
1313         return $block;
1314     }
1317 /**
1318  * structure step in charge of constructing the logs.xml file for all the log records found
1319  * in course. Note that we are sending to backup ALL the log records having cmid = 0. That
1320  * includes some records that won't be restoreable (like 'upload', 'calendar'...) but we do
1321  * that just in case they become restored some day in the future
1322  */
1323 class backup_course_logs_structure_step extends backup_structure_step {
1325     protected function define_structure() {
1327         // Define each element separated
1329         $logs = new backup_nested_element('logs');
1331         $log = new backup_nested_element('log', array('id'), array(
1332             'time', 'userid', 'ip', 'module',
1333             'action', 'url', 'info'));
1335         // Build the tree
1337         $logs->add_child($log);
1339         // Define sources (all the records belonging to the course, having cmid = 0)
1341         $log->set_source_table('log', array('course' => backup::VAR_COURSEID, 'cmid' => backup_helper::is_sqlparam(0)));
1343         // Annotations
1344         // NOTE: We don't annotate users from logs as far as they MUST be
1345         //       always annotated by the course (enrol, ras... whatever)
1347         // Return the root element (logs)
1349         return $logs;
1350     }
1353 /**
1354  * structure step in charge of constructing the logs.xml file for all the log records found
1355  * in activity
1356  */
1357 class backup_activity_logs_structure_step extends backup_structure_step {
1359     protected function define_structure() {
1361         // Define each element separated
1363         $logs = new backup_nested_element('logs');
1365         $log = new backup_nested_element('log', array('id'), array(
1366             'time', 'userid', 'ip', 'module',
1367             'action', 'url', 'info'));
1369         // Build the tree
1371         $logs->add_child($log);
1373         // Define sources
1375         $log->set_source_table('log', array('cmid' => backup::VAR_MODID));
1377         // Annotations
1378         // NOTE: We don't annotate users from logs as far as they MUST be
1379         //       always annotated by the activity (true participants).
1381         // Return the root element (logs)
1383         return $logs;
1384     }
1387 /**
1388  * structure in charge of constructing the inforef.xml file for all the items we want
1389  * to have referenced there (users, roles, files...)
1390  */
1391 class backup_inforef_structure_step extends backup_structure_step {
1393     protected function define_structure() {
1395         // Items we want to include in the inforef file.
1396         $items = backup_helper::get_inforef_itemnames();
1398         // Build the tree
1400         $inforef = new backup_nested_element('inforef');
1402         // For each item, conditionally, if there are already records, build element
1403         foreach ($items as $itemname) {
1404             if (backup_structure_dbops::annotations_exist($this->get_backupid(), $itemname)) {
1405                 $elementroot = new backup_nested_element($itemname . 'ref');
1406                 $element = new backup_nested_element($itemname, array(), array('id'));
1407                 $inforef->add_child($elementroot);
1408                 $elementroot->add_child($element);
1409                 $element->set_source_sql("
1410                     SELECT itemid AS id
1411                      FROM {backup_ids_temp}
1412                     WHERE backupid = ?
1413                       AND itemname = ?",
1414                    array(backup::VAR_BACKUPID, backup_helper::is_sqlparam($itemname)));
1415             }
1416         }
1418         // We don't annotate anything there, but rely in the next step
1419         // (move_inforef_annotations_to_final) that will change all the
1420         // already saved 'inforref' entries to their 'final' annotations.
1421         return $inforef;
1422     }
1425 /**
1426  * This step will get all the annotations already processed to inforef.xml file and
1427  * transform them into 'final' annotations.
1428  */
1429 class move_inforef_annotations_to_final extends backup_execution_step {
1431     protected function define_execution() {
1433         // Items we want to include in the inforef file
1434         $items = backup_helper::get_inforef_itemnames();
1435         foreach ($items as $itemname) {
1436             // Delegate to dbops
1437             backup_structure_dbops::move_annotations_to_final($this->get_backupid(), $itemname);
1438         }
1439     }
1442 /**
1443  * structure in charge of constructing the files.xml file with all the
1444  * annotated (final) files along the process. At, the same time, and
1445  * using one specialised nested_element, will copy them form moodle storage
1446  * to backup storage
1447  */
1448 class backup_final_files_structure_step extends backup_structure_step {
1450     protected function define_structure() {
1452         // Define elements
1454         $files = new backup_nested_element('files');
1456         $file = new file_nested_element('file', array('id'), array(
1457             'contenthash', 'contextid', 'component', 'filearea', 'itemid',
1458             'filepath', 'filename', 'userid', 'filesize',
1459             'mimetype', 'status', 'timecreated', 'timemodified',
1460             'source', 'author', 'license', 'sortorder',
1461             'repositorytype', 'repositoryid', 'reference'));
1463         // Build the tree
1465         $files->add_child($file);
1467         // Define sources
1469         $file->set_source_sql("SELECT f.*, r.type AS repositorytype, fr.repositoryid, fr.reference
1470                                  FROM {files} f
1471                                       LEFT JOIN {files_reference} fr ON fr.id = f.referencefileid
1472                                       LEFT JOIN {repository_instances} ri ON ri.id = fr.repositoryid
1473                                       LEFT JOIN {repository} r ON r.id = ri.typeid
1474                                       JOIN {backup_ids_temp} bi ON f.id = bi.itemid
1475                                 WHERE bi.backupid = ?
1476                                   AND bi.itemname = 'filefinal'", array(backup::VAR_BACKUPID));
1478         return $files;
1479     }
1482 /**
1483  * Structure step in charge of creating the main moodle_backup.xml file
1484  * where all the information related to the backup, settings, license and
1485  * other information needed on restore is added*/
1486 class backup_main_structure_step extends backup_structure_step {
1488     protected function define_structure() {
1490         global $CFG;
1492         $info = array();
1494         $info['name'] = $this->get_setting_value('filename');
1495         $info['moodle_version'] = $CFG->version;
1496         $info['moodle_release'] = $CFG->release;
1497         $info['backup_version'] = $CFG->backup_version;
1498         $info['backup_release'] = $CFG->backup_release;
1499         $info['backup_date']    = time();
1500         $info['backup_uniqueid']= $this->get_backupid();
1501         $info['mnet_remoteusers']=backup_controller_dbops::backup_includes_mnet_remote_users($this->get_backupid());
1502         $info['include_file_references_to_external_content'] =
1503                 backup_controller_dbops::backup_includes_file_references($this->get_backupid());
1504         $info['original_wwwroot']=$CFG->wwwroot;
1505         $info['original_site_identifier_hash'] = md5(get_site_identifier());
1506         $info['original_course_id'] = $this->get_courseid();
1507         $originalcourseinfo = backup_controller_dbops::backup_get_original_course_info($this->get_courseid());
1508         $info['original_course_fullname']  = $originalcourseinfo->fullname;
1509         $info['original_course_shortname'] = $originalcourseinfo->shortname;
1510         $info['original_course_startdate'] = $originalcourseinfo->startdate;
1511         $info['original_course_contextid'] = context_course::instance($this->get_courseid())->id;
1512         $info['original_system_contextid'] = context_system::instance()->id;
1514         // Get more information from controller
1515         list($dinfo, $cinfo, $sinfo) = backup_controller_dbops::get_moodle_backup_information($this->get_backupid());
1517         // Define elements
1519         $moodle_backup = new backup_nested_element('moodle_backup');
1521         $information = new backup_nested_element('information', null, array(
1522             'name', 'moodle_version', 'moodle_release', 'backup_version',
1523             'backup_release', 'backup_date', 'mnet_remoteusers', 'include_file_references_to_external_content', 'original_wwwroot',
1524             'original_site_identifier_hash', 'original_course_id',
1525             'original_course_fullname', 'original_course_shortname', 'original_course_startdate',
1526             'original_course_contextid', 'original_system_contextid'));
1528         $details = new backup_nested_element('details');
1530         $detail = new backup_nested_element('detail', array('backup_id'), array(
1531             'type', 'format', 'interactive', 'mode',
1532             'execution', 'executiontime'));
1534         $contents = new backup_nested_element('contents');
1536         $activities = new backup_nested_element('activities');
1538         $activity = new backup_nested_element('activity', null, array(
1539             'moduleid', 'sectionid', 'modulename', 'title',
1540             'directory'));
1542         $sections = new backup_nested_element('sections');
1544         $section = new backup_nested_element('section', null, array(
1545             'sectionid', 'title', 'directory'));
1547         $course = new backup_nested_element('course', null, array(
1548             'courseid', 'title', 'directory'));
1550         $settings = new backup_nested_element('settings');
1552         $setting = new backup_nested_element('setting', null, array(
1553             'level', 'section', 'activity', 'name', 'value'));
1555         // Build the tree
1557         $moodle_backup->add_child($information);
1559         $information->add_child($details);
1560         $details->add_child($detail);
1562         $information->add_child($contents);
1563         if (!empty($cinfo['activities'])) {
1564             $contents->add_child($activities);
1565             $activities->add_child($activity);
1566         }
1567         if (!empty($cinfo['sections'])) {
1568             $contents->add_child($sections);
1569             $sections->add_child($section);
1570         }
1571         if (!empty($cinfo['course'])) {
1572             $contents->add_child($course);
1573         }
1575         $information->add_child($settings);
1576         $settings->add_child($setting);
1579         // Set the sources
1581         $information->set_source_array(array((object)$info));
1583         $detail->set_source_array($dinfo);
1585         $activity->set_source_array($cinfo['activities']);
1587         $section->set_source_array($cinfo['sections']);
1589         $course->set_source_array($cinfo['course']);
1591         $setting->set_source_array($sinfo);
1593         // Prepare some information to be sent to main moodle_backup.xml file
1594         return $moodle_backup;
1595     }
1599 /**
1600  * Execution step that will generate the final zip (.mbz) file with all the contents
1601  */
1602 class backup_zip_contents extends backup_execution_step {
1604     protected function define_execution() {
1606         // Get basepath
1607         $basepath = $this->get_basepath();
1609         // Get the list of files in directory
1610         $filestemp = get_directory_list($basepath, '', false, true, true);
1611         $files = array();
1612         foreach ($filestemp as $file) { // Add zip paths and fs paths to all them
1613             $files[$file] = $basepath . '/' . $file;
1614         }
1616         // Add the log file if exists
1617         $logfilepath = $basepath . '.log';
1618         if (file_exists($logfilepath)) {
1619              $files['moodle_backup.log'] = $logfilepath;
1620         }
1622         // Calculate the zip fullpath (in OS temp area it's always backup.mbz)
1623         $zipfile = $basepath . '/backup.mbz';
1625         // Get the zip packer
1626         $zippacker = get_file_packer('application/zip');
1628         // Zip files
1629         $zippacker->archive_to_pathname($files, $zipfile);
1630     }
1633 /**
1634  * This step will send the generated backup file to its final destination
1635  */
1636 class backup_store_backup_file extends backup_execution_step {
1638     protected function define_execution() {
1640         // Get basepath
1641         $basepath = $this->get_basepath();
1643         // Calculate the zip fullpath (in OS temp area it's always backup.mbz)
1644         $zipfile = $basepath . '/backup.mbz';
1646         $has_file_references = backup_controller_dbops::backup_includes_file_references($this->get_backupid());
1647         // Perform storage and return it (TODO: shouldn't be array but proper result object)
1648         return array(
1649             'backup_destination' => backup_helper::store_backup_file($this->get_backupid(), $zipfile),
1650             'include_file_references_to_external_content' => $has_file_references
1651         );
1652     }
1656 /**
1657  * This step will search for all the activity (not calculations, categories nor aggregations) grade items
1658  * and put them to the backup_ids tables, to be used later as base to backup them
1659  */
1660 class backup_activity_grade_items_to_ids extends backup_execution_step {
1662     protected function define_execution() {
1664         // Fetch all activity grade items
1665         if ($items = grade_item::fetch_all(array(
1666                          'itemtype' => 'mod', 'itemmodule' => $this->task->get_modulename(),
1667                          'iteminstance' => $this->task->get_activityid(), 'courseid' => $this->task->get_courseid()))) {
1668             // Annotate them in backup_ids
1669             foreach ($items as $item) {
1670                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grade_item', $item->id);
1671             }
1672         }
1673     }
1676 /**
1677  * This step will annotate all the groups and groupings belonging to the course
1678  */
1679 class backup_annotate_course_groups_and_groupings extends backup_execution_step {
1681     protected function define_execution() {
1682         global $DB;
1684         // Get all the course groups
1685         if ($groups = $DB->get_records('groups', array(
1686                 'courseid' => $this->task->get_courseid()))) {
1687             foreach ($groups as $group) {
1688                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->id);
1689             }
1690         }
1692         // Get all the course groupings
1693         if ($groupings = $DB->get_records('groupings', array(
1694                 'courseid' => $this->task->get_courseid()))) {
1695             foreach ($groupings as $grouping) {
1696                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grouping', $grouping->id);
1697             }
1698         }
1699     }
1702 /**
1703  * This step will annotate all the groups belonging to already annotated groupings
1704  */
1705 class backup_annotate_groups_from_groupings extends backup_execution_step {
1707     protected function define_execution() {
1708         global $DB;
1710         // Fetch all the annotated groupings
1711         if ($groupings = $DB->get_records('backup_ids_temp', array(
1712                 'backupid' => $this->get_backupid(), 'itemname' => 'grouping'))) {
1713             foreach ($groupings as $grouping) {
1714                 if ($groups = $DB->get_records('groupings_groups', array(
1715                         'groupingid' => $grouping->itemid))) {
1716                     foreach ($groups as $group) {
1717                         backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->groupid);
1718                     }
1719                 }
1720             }
1721         }
1722     }
1725 /**
1726  * This step will annotate all the scales belonging to already annotated outcomes
1727  */
1728 class backup_annotate_scales_from_outcomes extends backup_execution_step {
1730     protected function define_execution() {
1731         global $DB;
1733         // Fetch all the annotated outcomes
1734         if ($outcomes = $DB->get_records('backup_ids_temp', array(
1735                 'backupid' => $this->get_backupid(), 'itemname' => 'outcome'))) {
1736             foreach ($outcomes as $outcome) {
1737                 if ($scale = $DB->get_record('grade_outcomes', array(
1738                         'id' => $outcome->itemid))) {
1739                     // Annotate as scalefinal because it's > 0
1740                     backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'scalefinal', $scale->scaleid);
1741                 }
1742             }
1743         }
1744     }
1747 /**
1748  * This step will generate all the file annotations for the already
1749  * annotated (final) question_categories. It calculates the different
1750  * contexts that are being backup and, annotates all the files
1751  * on every context belonging to the "question" component. As far as
1752  * we are always including *complete* question banks it is safe and
1753  * optimal to do that in this (one pass) way
1754  */
1755 class backup_annotate_all_question_files extends backup_execution_step {
1757     protected function define_execution() {
1758         global $DB;
1760         // Get all the different contexts for the final question_categories
1761         // annotated along the whole backup
1762         $rs = $DB->get_recordset_sql("SELECT DISTINCT qc.contextid
1763                                         FROM {question_categories} qc
1764                                         JOIN {backup_ids_temp} bi ON bi.itemid = qc.id
1765                                        WHERE bi.backupid = ?
1766                                          AND bi.itemname = 'question_categoryfinal'", array($this->get_backupid()));
1767         // To know about qtype specific components/fileareas
1768         $components = backup_qtype_plugin::get_components_and_fileareas();
1769         // Let's loop
1770         foreach($rs as $record) {
1771             // We don't need to specify filearea nor itemid as far as by
1772             // component and context it's enough to annotate the whole bank files
1773             // This backups "questiontext", "generalfeedback" and "answerfeedback" fileareas (all them
1774             // belonging to the "question" component
1775             backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, 'question', null, null);
1776             // Again, it is enough to pick files only by context and component
1777             // Do it for qtype specific components
1778             foreach ($components as $component => $fileareas) {
1779                 backup_structure_dbops::annotate_files($this->get_backupid(), $record->contextid, $component, null, null);
1780             }
1781         }
1782         $rs->close();
1783     }
1786 /**
1787  * structure step in charge of constructing the questions.xml file for all the
1788  * question categories and questions required by the backup
1789  * and letters related to one activity
1790  */
1791 class backup_questions_structure_step extends backup_structure_step {
1793     protected function define_structure() {
1795         // Define each element separated
1797         $qcategories = new backup_nested_element('question_categories');
1799         $qcategory = new backup_nested_element('question_category', array('id'), array(
1800             'name', 'contextid', 'contextlevel', 'contextinstanceid',
1801             'info', 'infoformat', 'stamp', 'parent',
1802             'sortorder'));
1804         $questions = new backup_nested_element('questions');
1806         $question = new backup_nested_element('question', array('id'), array(
1807             'parent', 'name', 'questiontext', 'questiontextformat',
1808             'generalfeedback', 'generalfeedbackformat', 'defaultmark', 'penalty',
1809             'qtype', 'length', 'stamp', 'version',
1810             'hidden', 'timecreated', 'timemodified', 'createdby', 'modifiedby'));
1812         // attach qtype plugin structure to $question element, only one allowed
1813         $this->add_plugin_structure('qtype', $question, false);
1815         // attach local plugin stucture to $question element, multiple allowed
1816         $this->add_plugin_structure('local', $question, true);
1818         $qhints = new backup_nested_element('question_hints');
1820         $qhint = new backup_nested_element('question_hint', array('id'), array(
1821             'hint', 'hintformat', 'shownumcorrect', 'clearwrong', 'options'));
1823         // Build the tree
1825         $qcategories->add_child($qcategory);
1826         $qcategory->add_child($questions);
1827         $questions->add_child($question);
1828         $question->add_child($qhints);
1829         $qhints->add_child($qhint);
1831         // Define the sources
1833         $qcategory->set_source_sql("
1834             SELECT gc.*, contextlevel, instanceid AS contextinstanceid
1835               FROM {question_categories} gc
1836               JOIN {backup_ids_temp} bi ON bi.itemid = gc.id
1837               JOIN {context} co ON co.id = gc.contextid
1838              WHERE bi.backupid = ?
1839                AND bi.itemname = 'question_categoryfinal'", array(backup::VAR_BACKUPID));
1841         $question->set_source_table('question', array('category' => backup::VAR_PARENTID));
1843         $qhint->set_source_sql('
1844                 SELECT *
1845                 FROM {question_hints}
1846                 WHERE questionid = :questionid
1847                 ORDER BY id',
1848                 array('questionid' => backup::VAR_PARENTID));
1850         // don't need to annotate ids nor files
1851         // (already done by {@link backup_annotate_all_question_files}
1853         return $qcategories;
1854     }
1859 /**
1860  * This step will generate all the file  annotations for the already
1861  * annotated (final) users. Need to do this here because each user
1862  * has its own context and structure tasks only are able to handle
1863  * one context. Also, this step will guarantee that every user has
1864  * its context created (req for other steps)
1865  */
1866 class backup_annotate_all_user_files extends backup_execution_step {
1868     protected function define_execution() {
1869         global $DB;
1871         // List of fileareas we are going to annotate
1872         $fileareas = array('profile', 'icon');
1874         // Fetch all annotated (final) users
1875         $rs = $DB->get_recordset('backup_ids_temp', array(
1876             'backupid' => $this->get_backupid(), 'itemname' => 'userfinal'));
1877         foreach ($rs as $record) {
1878             $userid = $record->itemid;
1879             $userctx = context_user::instance($userid, IGNORE_MISSING);
1880             if (!$userctx) {
1881                 continue; // User has not context, sure it's a deleted user, so cannot have files
1882             }
1883             // Proceed with every user filearea
1884             foreach ($fileareas as $filearea) {
1885                 // We don't need to specify itemid ($userid - 5th param) as far as by
1886                 // context we can get all the associated files. See MDL-22092
1887                 backup_structure_dbops::annotate_files($this->get_backupid(), $userctx->id, 'user', $filearea, null);
1888             }
1889         }
1890         $rs->close();
1891     }
1895 /**
1896  * Defines the backup step for advanced grading methods attached to the activity module
1897  */
1898 class backup_activity_grading_structure_step extends backup_structure_step {
1900     /**
1901      * Include the grading.xml only if the module supports advanced grading
1902      */
1903     protected function execute_condition() {
1904         return plugin_supports('mod', $this->get_task()->get_modulename(), FEATURE_ADVANCED_GRADING, false);
1905     }
1907     /**
1908      * Declares the gradable areas structures and data sources
1909      */
1910     protected function define_structure() {
1912         // To know if we are including userinfo
1913         $userinfo = $this->get_setting_value('userinfo');
1915         // Define the elements
1917         $areas = new backup_nested_element('areas');
1919         $area = new backup_nested_element('area', array('id'), array(
1920             'areaname', 'activemethod'));
1922         $definitions = new backup_nested_element('definitions');
1924         $definition = new backup_nested_element('definition', array('id'), array(
1925             'method', 'name', 'description', 'descriptionformat', 'status',
1926             'timecreated', 'timemodified', 'options'));
1928         $instances = new backup_nested_element('instances');
1930         $instance = new backup_nested_element('instance', array('id'), array(
1931             'raterid', 'itemid', 'rawgrade', 'status', 'feedback',
1932             'feedbackformat', 'timemodified'));
1934         // Build the tree including the method specific structures
1935         // (beware - the order of how gradingform plugins structures are attached is important)
1936         $areas->add_child($area);
1937         // attach local plugin stucture to $area element, multiple allowed
1938         $this->add_plugin_structure('local', $area, true);
1939         $area->add_child($definitions);
1940         $definitions->add_child($definition);
1941         $this->add_plugin_structure('gradingform', $definition, true);
1942         // attach local plugin stucture to $definition element, multiple allowed
1943         $this->add_plugin_structure('local', $definition, true);
1944         $definition->add_child($instances);
1945         $instances->add_child($instance);
1946         $this->add_plugin_structure('gradingform', $instance, false);
1947         // attach local plugin stucture to $instance element, multiple allowed
1948         $this->add_plugin_structure('local', $instance, true);
1950         // Define data sources
1952         $area->set_source_table('grading_areas', array('contextid' => backup::VAR_CONTEXTID,
1953             'component' => array('sqlparam' => 'mod_'.$this->get_task()->get_modulename())));
1955         $definition->set_source_table('grading_definitions', array('areaid' => backup::VAR_PARENTID));
1957         if ($userinfo) {
1958             $instance->set_source_table('grading_instances', array('definitionid' => backup::VAR_PARENTID));
1959         }
1961         // Annotate references
1962         $definition->annotate_files('grading', 'description', 'id');
1963         $instance->annotate_ids('user', 'raterid');
1965         // Return the root element
1966         return $areas;
1967     }
1971 /**
1972  * structure step in charge of constructing the grades.xml file for all the grade items
1973  * and letters related to one activity
1974  */
1975 class backup_activity_grades_structure_step extends backup_structure_step {
1977     protected function define_structure() {
1979         // To know if we are including userinfo
1980         $userinfo = $this->get_setting_value('userinfo');
1982         // Define each element separated
1984         $book = new backup_nested_element('activity_gradebook');
1986         $items = new backup_nested_element('grade_items');
1988         $item = new backup_nested_element('grade_item', array('id'), array(
1989             'categoryid', 'itemname', 'itemtype', 'itemmodule',
1990             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
1991             'calculation', 'gradetype', 'grademax', 'grademin',
1992             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
1993             'plusfactor', 'aggregationcoef', 'sortorder', 'display',
1994             'decimals', 'hidden', 'locked', 'locktime',
1995             'needsupdate', 'timecreated', 'timemodified'));
1997         $grades = new backup_nested_element('grade_grades');
1999         $grade = new backup_nested_element('grade_grade', array('id'), array(
2000             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
2001             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
2002             'locked', 'locktime', 'exported', 'overridden',
2003             'excluded', 'feedback', 'feedbackformat', 'information',
2004             'informationformat', 'timecreated', 'timemodified'));
2006         $letters = new backup_nested_element('grade_letters');
2008         $letter = new backup_nested_element('grade_letter', 'id', array(
2009             'lowerboundary', 'letter'));
2011         // Build the tree
2013         $book->add_child($items);
2014         $items->add_child($item);
2016         $item->add_child($grades);
2017         $grades->add_child($grade);
2019         $book->add_child($letters);
2020         $letters->add_child($letter);
2022         // Define sources
2024         $item->set_source_sql("SELECT gi.*
2025                                FROM {grade_items} gi
2026                                JOIN {backup_ids_temp} bi ON gi.id = bi.itemid
2027                                WHERE bi.backupid = ?
2028                                AND bi.itemname = 'grade_item'", array(backup::VAR_BACKUPID));
2030         // This only happens if we are including user info
2031         if ($userinfo) {
2032             $grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
2033         }
2035         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
2037         // Annotations
2039         $item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
2040         $item->annotate_ids('outcome', 'outcomeid');
2042         $grade->annotate_ids('user', 'userid');
2043         $grade->annotate_ids('user', 'usermodified');
2045         // Return the root element (book)
2047         return $book;
2048     }
2051 /**
2052  * Backups up the course completion information for the course.
2053  */
2054 class backup_course_completion_structure_step extends backup_structure_step {
2056     protected function execute_condition() {
2057         // Check that all activities have been included
2058         if ($this->task->is_excluding_activities()) {
2059             return false;
2060         }
2061         return true;
2062     }
2064     /**
2065      * The structure of the course completion backup
2066      *
2067      * @return backup_nested_element
2068      */
2069     protected function define_structure() {
2071         // To know if we are including user completion info
2072         $userinfo = $this->get_setting_value('userscompletion');
2074         $cc = new backup_nested_element('course_completion');
2076         $criteria = new backup_nested_element('course_completion_criteria', array('id'), array(
2077             'course','criteriatype', 'module', 'moduleinstance', 'courseinstanceshortname', 'enrolperiod', 'timeend', 'gradepass', 'role'
2078         ));
2080         $criteriacompletions = new backup_nested_element('course_completion_crit_completions');
2082         $criteriacomplete = new backup_nested_element('course_completion_crit_compl', array('id'), array(
2083             'criteriaid', 'userid', 'gradefinal', 'unenrolled', 'timecompleted'
2084         ));
2086         $coursecompletions = new backup_nested_element('course_completions', array('id'), array(
2087             'userid', 'course', 'timeenrolled', 'timestarted', 'timecompleted', 'reaggregate'
2088         ));
2090         $aggregatemethod = new backup_nested_element('course_completion_aggr_methd', array('id'), array(
2091             'course','criteriatype','method','value'
2092         ));
2094         $cc->add_child($criteria);
2095             $criteria->add_child($criteriacompletions);
2096                 $criteriacompletions->add_child($criteriacomplete);
2097         $cc->add_child($coursecompletions);
2098         $cc->add_child($aggregatemethod);
2100         // We need to get the courseinstances shortname rather than an ID for restore
2101         $criteria->set_source_sql("SELECT ccc.*, c.shortname AS courseinstanceshortname
2102                                    FROM {course_completion_criteria} ccc
2103                                    LEFT JOIN {course} c ON c.id = ccc.courseinstance
2104                                    WHERE ccc.course = ?", array(backup::VAR_COURSEID));
2107         $aggregatemethod->set_source_table('course_completion_aggr_methd', array('course' => backup::VAR_COURSEID));
2109         if ($userinfo) {
2110             $criteriacomplete->set_source_table('course_completion_crit_compl', array('criteriaid' => backup::VAR_PARENTID));
2111             $coursecompletions->set_source_table('course_completions', array('course' => backup::VAR_COURSEID));
2112         }
2114         $criteria->annotate_ids('role', 'role');
2115         $criteriacomplete->annotate_ids('user', 'userid');
2116         $coursecompletions->annotate_ids('user', 'userid');
2118         return $cc;
2120     }