backup/moodle2/backup_stepslib.php

   1 <?php
   2
   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/>.
  17
  18 /**
  19  * @package moodlecore
  20  * @subpackage backup-moodle2
  21  * @copyright 2010 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
  22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 /**
  26  * Define all the backup steps that will be used by common tasks in backup
  27  */
  28
  29 /**
  30  * create the temp dir where backup/restore will happen,
  31  * delete old directories and create temp ids table
  32  */
  33 class create_and_clean_temp_stuff extends backup_execution_step {
  34
  35     protected function define_execution() {
  36         backup_helper::check_and_create_backup_dir($this->get_backupid());// Create backup temp dir
  37         backup_helper::clear_backup_dir($this->get_backupid());           // Empty temp dir, just in case
  38         backup_helper::delete_old_backup_dirs(time() - (4 * 60 * 60));    // Delete > 4 hours temp dirs
  39         backup_controller_dbops::create_backup_ids_temp_table($this->get_backupid()); // Create ids temp table
  40     }
  41 }
  42
  43 /**
  44  * delete the temp dir used by backup/restore (conditionally),
  45  * delete old directories and drop tem ids table. Note we delete
  46  * the directory but not the correspondig log file that will be
  47  * there for, at least, 4 hours - only delete_old_backup_dirs()
  48  * deletes log files (for easier access to them)
  49  */
  50 class drop_and_clean_temp_stuff extends backup_execution_step {
  51
  52     protected function define_execution() {
  53         global $CFG;
  54         backup_controller_dbops::drop_backup_ids_temp_table($this->get_backupid()); // Drop ids temp table
  55         backup_helper::delete_old_backup_dirs(time() - (4 * 60 * 60));              // Delete > 4 hours temp dirs
  56         if (empty($CFG->keeptempdirectoriesonbackup)) { // Conditionally
  57             backup_helper::delete_backup_dir($this->get_backupid()); // Empty backup dir
  58         }
  59     }
  60 }
  61
  62 /**
  63  * Create the directory where all the task (activity/block...) information will be stored
  64  */
  65 class create_taskbasepath_directory extends backup_execution_step {
  66
  67     protected function define_execution() {
  68         global $CFG;
  69         $basepath = $this->task->get_taskbasepath();
  70         if (!check_dir_exists($basepath, true, true)) {
  71             throw new backup_step_exception('cannot_create_taskbasepath_directory', $basepath);
  72         }
  73     }
  74 }
  75
  76 /**
  77  * Abtract tructure step, parent of all the activity structure steps. Used to wrap the
  78  * activity structure definition within the main <activity ...> tag. Also provides
  79  * subplugin support for activities (that must be properly declared)
  80  */
  81 abstract class backup_activity_structure_step extends backup_structure_step {
  82
  83     /**
  84      * Add subplugin structure to any element in the activity backup tree
  85      *
  86      * @param string $subplugintype type of subplugin as defined in activity db/subplugins.php
  87      * @param backup_nested_element $element element in the activity backup tree that
  88      *                                       we are going to add subplugin information to
  89      * @param bool $multiple to define if multiple subplugins can produce information
  90      *                       for each instance of $element (true) or no (false)
  91      */
  92     protected function add_subplugin_structure($subplugintype, $element, $multiple) {
  93
  94         global $CFG;
  95
  96         // Check the requested subplugintype is a valid one
  97         $subpluginsfile = $CFG->dirroot . '/mod/' . $this->task->get_modulename() . '/db/subplugins.php';
  98         if (!file_exists($subpluginsfile)) {
  99              throw new backup_step_exception('activity_missing_subplugins_php_file', $this->task->get_modulename());
 100         }
 101         include($subpluginsfile);
 102         if (!array_key_exists($subplugintype, $subplugins)) {
 103              throw new backup_step_exception('incorrect_subplugin_type', $subplugintype);
 104         }
 105
 106         // Arrived here, subplugin is correct, let's create the optigroup
 107         $optigroupname = $subplugintype . '_' . $element->get_name() . '_subplugin';
 108         $optigroup = new backup_optigroup($optigroupname, null, $multiple);
 109
 110         // Get all the optigroup_elements, looking across al the subplugin dirs
 111         $elements = array();
 112         $subpluginsdirs = get_plugin_list($subplugintype);
 113         foreach ($subpluginsdirs as $name => $subpluginsdir) {
 114             $classname = 'backup_' . $subplugintype . '_' . $name . '_subplugin';
 115             $backupfile = $subpluginsdir . '/backup/moodle2/' . $classname . '.class.php';
 116             if (file_exists($backupfile)) {
 117                 require_once($backupfile);
 118                 $backupsubplugin = new $classname($subplugintype, $name);
 119                 // Add subplugin returned structure to optigroup (must be optigroup_element instance)
 120                 if ($subpluginstructure = $backupsubplugin->define_subplugin_structure($element->get_name())) {
 121                     $optigroup->add_child($subpluginstructure);
 122                 }
 123             }
 124         }
 125         // Finished, add optigroup to element
 126         $element->add_child($optigroup);
 127     }
 128
 129     /**
 130      * Wraps any activity backup structure within the common 'activity' element
 131      * that will include common to all activities information like id, context...
 132      */
 133     protected function prepare_activity_structure($activitystructure) {
 134
 135         // Create the wrap element
 136         $activity = new backup_nested_element('activity', array('id', 'moduleid', 'modulename', 'contextid'), null);
 137
 138         // Build the tree
 139         $activity->add_child($activitystructure);
 140
 141         // Set the source
 142         $activityarr = array((object)array(
 143             'id'         => $this->task->get_activityid(),
 144             'moduleid'   => $this->task->get_moduleid(),
 145             'modulename' => $this->task->get_modulename(),
 146             'contextid'  => $this->task->get_contextid()));
 147
 148         $activity->set_source_array($activityarr);
 149
 150         // Return the root element (activity)
 151         return $activity;
 152     }
 153 }
 154
 155 /**
 156  * Abtract structure step, parent of all the block structure steps. Used to wrap the
 157  * block structure definition within the main <block ...> tag
 158  */
 159 abstract class backup_block_structure_step extends backup_structure_step {
 160
 161     protected function prepare_block_structure($blockstructure) {
 162
 163         // Create the wrap element
 164         $block = new backup_nested_element('block', array('id', 'blockname', 'contextid'), null);
 165
 166         // Build the tree
 167         $block->add_child($blockstructure);
 168
 169         // Set the source
 170         $blockarr = array((object)array(
 171             'id'         => $this->task->get_blockid(),
 172             'blockname'  => $this->task->get_blockname(),
 173             'contextid'  => $this->task->get_contextid()));
 174
 175         $block->set_source_array($blockarr);
 176
 177         // Return the root element (block)
 178         return $block;
 179     }
 180 }
 181
 182 /**
 183  * structure step that will generate the module.xml file for the activity,
 184  * acummulating various information about the activity, annotating groupings
 185  * and completion/avail conf
 186  */
 187 class backup_module_structure_step extends backup_structure_step {
 188
 189     protected function define_structure() {
 190
 191         // Define each element separated
 192
 193         $module = new backup_nested_element('module', array('id', 'version'), array(
 194             'modulename', 'sectionid', 'sectionnumber', 'idnumber',
 195             'added', 'score', 'indent', 'visible',
 196             'visibleold', 'groupmode', 'groupingid', 'groupmembersonly',
 197             'completion', 'completiongradeitemnumber', 'completionview', 'completionexpected',
 198             'availablefrom', 'availableuntil', 'showavailability'));
 199
 200         $availinfo = new backup_nested_element('availability_info');
 201         $availability = new backup_nested_element('availability', array('id'), array(
 202             'sourcecmid', 'requiredcompletion', 'gradeitemid', 'grademin', 'grademax'));
 203
 204         // Define the tree
 205         $module->add_child($availinfo);
 206         $availinfo->add_child($availability);
 207
 208         // Set the sources
 209
 210         $module->set_source_sql('
 211             SELECT cm.*, m.version, m.name AS modulename, s.id AS sectionid, s.section AS sectionnumber
 212               FROM {course_modules} cm
 213               JOIN {modules} m ON m.id = cm.module
 214               JOIN {course_sections} s ON s.id = cm.section
 215              WHERE cm.id = ?', array(backup::VAR_MODID));
 216
 217         $availability->set_source_table('course_modules_availability', array('coursemoduleid' => backup::VAR_MODID));
 218
 219         // Define annotations
 220         $module->annotate_ids('grouping', 'groupingid');
 221
 222         // Return the root element ($module)
 223         return $module;
 224     }
 225 }
 226
 227 /**
 228  * structure step that will genereate the section.xml file for the section
 229  * annotating files
 230  */
 231 class backup_section_structure_step extends backup_structure_step {
 232
 233     protected function define_structure() {
 234
 235         // Define each element separated
 236
 237         $section = new backup_nested_element('section', array('id'), array(
 238             'number', 'name', 'summary', 'summaryformat', 'sequence', 'visible'));
 239
 240         // Define sources
 241
 242         $section->set_source_table('course_sections', array('id' => backup::VAR_SECTIONID));
 243
 244         // Aliases
 245         $section->set_source_alias('section', 'number');
 246
 247         // Set annotations
 248         $section->annotate_files('course', 'section', 'id');
 249
 250         return $section;
 251     }
 252 }
 253
 254 /**
 255  * structure step that will generate the course.xml file for the course, including
 256  * course category reference, tags, modules restriction information
 257  * and some annotations (files & groupings)
 258  */
 259 class backup_course_structure_step extends backup_structure_step {
 260
 261     protected function define_structure() {
 262         global $DB;
 263
 264         // Define each element separated
 265
 266         $course = new backup_nested_element('course', array('id', 'contextid'), array(
 267             'shortname', 'fullname', 'idnumber',
 268             'summary', 'summaryformat', 'format', 'showgrades',
 269             'newsitems', 'startdate',
 270             'numsections', 'marker', 'maxbytes', 'showreports',
 271             'visible', 'hiddensections', 'groupmode', 'groupmodeforce',
 272             'defaultgroupingid', 'lang', 'theme',
 273             'timecreated', 'timemodified',
 274             'requested', 'restrictmodules',
 275             'enablecompletion'));
 276
 277         $category = new backup_nested_element('category', array('id'), array(
 278             'name', 'description'));
 279
 280         $tags = new backup_nested_element('tags');
 281
 282         $tag = new backup_nested_element('tag', array('id'), array(
 283             'name', 'rawname'));
 284
 285         $allowedmodules = new backup_nested_element('allowed_modules');
 286
 287         $module = new backup_nested_element('module', array('modulename'));
 288
 289         // Build the tree
 290
 291         $course->add_child($category);
 292
 293         $course->add_child($tags);
 294         $tags->add_child($tag);
 295
 296         $course->add_child($allowedmodules);
 297         $allowedmodules->add_child($module);
 298
 299         // Set the sources
 300
 301         $courserec = $DB->get_record('course', array('id' => $this->task->get_courseid()));
 302         $courserec->contextid = $this->task->get_contextid();
 303
 304         $course->set_source_array(array($courserec));
 305
 306         $categoryrec = $DB->get_record('course_categories', array('id' => $courserec->category));
 307
 308         $category->set_source_array(array($categoryrec));
 309
 310         $tag->set_source_sql('SELECT t.id, t.name, t.rawname
 311                                 FROM {tag} t
 312                                 JOIN {tag_instance} ti ON ti.tagid = t.id
 313                                WHERE ti.itemtype = ?
 314                                  AND ti.itemid = ?', array(
 315                                      $this->is_sqlparam('course'),
 316                                      backup::VAR_PARENTID));
 317
 318         $module->set_source_sql('SELECT m.name AS modulename
 319                                    FROM {modules} m
 320                                    JOIN {course_allowed_modules} cam ON m.id = cam.module
 321                                   WHERE course = ?', array(backup::VAR_COURSEID));
 322
 323         // Some annotations
 324
 325         $course->annotate_ids('grouping', 'defaultgroupingid');
 326
 327         $course->annotate_files('course', 'summary', null);
 328         $course->annotate_files('course', 'legacy', null);
 329
 330         // Return root element ($course)
 331
 332         return $course;
 333     }
 334 }
 335
 336 /**
 337  * structure step that will generate the roles.xml file for the given context, observing
 338  * the role_assignments setting to know if that part needs to be included
 339  */
 340 class backup_roles_structure_step extends backup_structure_step {
 341
 342     protected function define_structure() {
 343
 344         // To know if we are including role assignments
 345         $roleassignments = $this->get_setting_value('role_assignments');
 346
 347         // Define each element separated
 348
 349         $roles = new backup_nested_element('roles');
 350
 351         $overrides = new backup_nested_element('role_overrides');
 352
 353         $override = new backup_nested_element('override', array('id'), array(
 354             'roleid', 'capability', 'permission', 'timemodified',
 355             'modifierid'));
 356
 357         $assignments = new backup_nested_element('role_assignments');
 358
 359         $assignment = new backup_nested_element('assignment', array('id'), array(
 360             'roleid', 'userid', 'timemodified', 'modifierid', 'component', //TODO: MDL-22793 add itemid here
 361             'sortorder'));
 362
 363         // Build the tree
 364         $roles->add_child($overrides);
 365         $roles->add_child($assignments);
 366
 367         $overrides->add_child($override);
 368         $assignments->add_child($assignment);
 369
 370         // Define sources
 371
 372         $override->set_source_table('role_capabilities', array('contextid' => backup::VAR_CONTEXTID));
 373
 374         // Assignments only added if specified
 375         if ($roleassignments) {
 376             $assignment->set_source_table('role_assignments', array('contextid' => backup::VAR_CONTEXTID));
 377         }
 378
 379         // Define id annotations
 380         $override->annotate_ids('role', 'roleid');
 381
 382         $assignment->annotate_ids('role', 'roleid');
 383
 384         $assignment->annotate_ids('user', 'userid');
 385
 386         return $roles;
 387     }
 388 }
 389
 390 /**
 391  * structure step that will generate the roles.xml containing the
 392  * list of roles used along the whole backup process. Just raw
 393  * list of used roles from role table
 394  */
 395 class backup_final_roles_structure_step extends backup_structure_step {
 396
 397     protected function define_structure() {
 398
 399         // Define elements
 400
 401         $rolesdef = new backup_nested_element('roles_definition');
 402
 403         $role = new backup_nested_element('role', array('id'), array(
 404             'name', 'shortname', 'nameincourse', 'description',
 405             'sortorder', 'archetype'));
 406
 407         // Build the tree
 408
 409         $rolesdef->add_child($role);
 410
 411         // Define sources
 412
 413         $role->set_source_sql("SELECT r.*, rn.name AS nameincourse
 414                                  FROM {role} r
 415                                  JOIN {backup_ids_temp} bi ON r.id = bi.itemid
 416                             LEFT JOIN {role_names} rn ON r.id = rn.roleid AND rn.contextid = ?
 417                                 WHERE bi.backupid = ?
 418                                   AND bi.itemname = 'rolefinal'", array(backup::VAR_CONTEXTID, backup::VAR_BACKUPID));
 419
 420         // Return main element (rolesdef)
 421         return $rolesdef;
 422     }
 423 }
 424
 425 /**
 426  * structure step that will generate the scales.xml containing the
 427  * list of scales used along the whole backup process.
 428  */
 429 class backup_final_scales_structure_step extends backup_structure_step {
 430
 431     protected function define_structure() {
 432
 433         // Define elements
 434
 435         $scalesdef = new backup_nested_element('scales_definition');
 436
 437         $scale = new backup_nested_element('scale', array('id'), array(
 438             'courseid', 'userid', 'name', 'scale',
 439             'description', 'descriptionformat', 'timemodified'));
 440
 441         // Build the tree
 442
 443         $scalesdef->add_child($scale);
 444
 445         // Define sources
 446
 447         $scale->set_source_sql("SELECT s.*
 448                                   FROM {scale} s
 449                                   JOIN {backup_ids_temp} bi ON s.id = bi.itemid
 450                                  WHERE bi.backupid = ?
 451                                    AND bi.itemname = 'scalefinal'", array(backup::VAR_BACKUPID));
 452
 453         // Return main element (scalesdef)
 454         return $scalesdef;
 455     }
 456 }
 457
 458 /**
 459  * structure step that will generate the outcomes.xml containing the
 460  * list of outcomes used along the whole backup process.
 461  */
 462 class backup_final_outcomes_structure_step extends backup_structure_step {
 463
 464     protected function define_structure() {
 465
 466         // Define elements
 467
 468         $outcomesdef = new backup_nested_element('outcomes_definition');
 469
 470         $outcome = new backup_nested_element('outcome', array('id'), array(
 471             'courseid', 'userid', 'shortname', 'fullname',
 472             'scaleid', 'description', 'descriptionformat', 'timecreated',
 473             'timemodified','usermodified'));
 474
 475         // Build the tree
 476
 477         $outcomesdef->add_child($outcome);
 478
 479         // Define sources
 480
 481         $outcome->set_source_sql("SELECT o.*
 482                                     FROM {grade_outcomes} o
 483                                     JOIN {backup_ids_temp} bi ON o.id = bi.itemid
 484                                    WHERE bi.backupid = ?
 485                                      AND bi.itemname = 'outcomefinal'", array(backup::VAR_BACKUPID));
 486
 487         // Return main element (outcomesdef)
 488         return $outcomesdef;
 489     }
 490 }
 491
 492 /**
 493  * structure step in charge of constructing the filters.xml file for all the filters found
 494  * in activity
 495  */
 496 class backup_filters_structure_step extends backup_structure_step {
 497
 498     protected function define_structure() {
 499
 500         // Define each element separated
 501
 502         $filters = new backup_nested_element('filters');
 503
 504         $actives = new backup_nested_element('filter_actives');
 505
 506         $active = new backup_nested_element('filter_active', null, array('filter', 'active'));
 507
 508         $configs = new backup_nested_element('filter_configs');
 509
 510         $config = new backup_nested_element('filter_config', null, array('filter', 'name', 'value'));
 511
 512         // Build the tree
 513
 514         $filters->add_child($actives);
 515         $filters->add_child($configs);
 516
 517         $actives->add_child($active);
 518         $configs->add_child($config);
 519
 520         // Define sources
 521
 522         list($activearr, $configarr) = filter_get_all_local_settings($this->task->get_contextid());
 523
 524         $active->set_source_array($activearr);
 525         $config->set_source_array($configarr);
 526
 527         // Return the root element (filters)
 528         return $filters;
 529     }
 530 }
 531
 532 /**
 533  * structure step in charge of constructing the comments.xml file for all the comments found
 534  * in a given context
 535  */
 536 class backup_comments_structure_step extends backup_structure_step {
 537
 538     protected function define_structure() {
 539
 540         // Define each element separated
 541
 542         $comments = new backup_nested_element('comments');
 543
 544         $comment = new backup_nested_element('comment', array('id'), array(
 545             'commentarea', 'itemid', 'content', 'format',
 546             'userid', 'timecreated'));
 547
 548         // Build the tree
 549
 550         $comments->add_child($comment);
 551
 552         // Define sources
 553
 554         $comment->set_source_table('comments', array('contextid' => backup::VAR_CONTEXTID));
 555
 556         // Define id annotations
 557
 558         $comment->annotate_ids('user', 'userid');
 559
 560         // Return the root element (comments)
 561         return $comments;
 562     }
 563 }
 564
 565 /**
 566  * structure step in charge if constructing the completion.xml file for all the users completion
 567  * information in a given activity
 568  */
 569 class backup_userscompletion_structure_step extends backup_structure_step {
 570
 571     protected function define_structure() {
 572
 573         // Define each element separated
 574
 575         $completions = new backup_nested_element('completions');
 576
 577         $completion = new backup_nested_element('completion', array('id'), array(
 578             'userid', 'completionstate', 'viewed', 'timemodified'));
 579
 580         // Build the tree
 581
 582         $completions->add_child($completion);
 583
 584         // Define sources
 585
 586         $completion->set_source_table('course_modules_completion', array('coursemoduleid' => backup::VAR_MODID));
 587
 588         // Define id annotations
 589
 590         $completion->annotate_ids('user', 'userid');
 591
 592         // Return the root element (completions)
 593         return $completions;
 594     }
 595 }
 596
 597 /**
 598  * structure step in charge of constructing the main groups.xml file for all the groups and
 599  * groupings information already annotated
 600  */
 601 class backup_groups_structure_step extends backup_structure_step {
 602
 603     protected function define_structure() {
 604
 605         // To know if we are including users
 606         $users = $this->get_setting_value('users');
 607
 608         // Define each element separated
 609
 610         $groups = new backup_nested_element('groups');
 611
 612         $group = new backup_nested_element('group', array('id'), array(
 613             'name', 'description', 'descriptionformat', 'enrolmentkey',
 614             'picture', 'hidepicture', 'timecreated', 'timemodified'));
 615
 616         $members = new backup_nested_element('group_members');
 617
 618         $member = new backup_nested_element('group_member', array('id'), array(
 619             'userid', 'timeadded'));
 620
 621         $groupings = new backup_nested_element('groupings');
 622
 623         $grouping = new backup_nested_element('grouping', 'id', array(
 624             'name', 'description', 'descriptionformat', 'configdata',
 625             'timecreated', 'timemodified'));
 626
 627         $groupinggroups = new backup_nested_element('grouping_groups');
 628
 629         $groupinggroup = new backup_nested_element('grouping_group', array('id'), array(
 630             'groupid', 'timeadded'));
 631
 632         // Build the tree
 633
 634         $groups->add_child($group);
 635         $groups->add_child($groupings);
 636
 637         $group->add_child($members);
 638         $members->add_child($member);
 639
 640         $groupings->add_child($grouping);
 641         $grouping->add_child($groupinggroups);
 642         $groupinggroups->add_child($groupinggroup);
 643
 644         // Define sources
 645
 646         $group->set_source_sql("
 647             SELECT g.*
 648               FROM {groups} g
 649               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
 650              WHERE bi.backupid = ?
 651                AND bi.itemname = 'groupfinal'", array(backup::VAR_BACKUPID));
 652
 653         // This only happens if we are including users
 654         if ($users) {
 655             $member->set_source_table('groups_members', array('groupid' => backup::VAR_PARENTID));
 656         }
 657
 658         $grouping->set_source_sql("
 659             SELECT g.*
 660               FROM {groupings} g
 661               JOIN {backup_ids_temp} bi ON g.id = bi.itemid
 662              WHERE bi.backupid = ?
 663                AND bi.itemname = 'groupingfinal'", array(backup::VAR_BACKUPID));
 664
 665         $groupinggroup->set_source_table('groupings_groups', array('groupingid' => backup::VAR_PARENTID));
 666
 667         // Define id annotations (as final)
 668
 669         $member->annotate_ids('userfinal', 'userid');
 670
 671         // Define file annotations
 672
 673         //TODO: not implemented yet
 674         $group->annotate_files('group', 'description', 'id');
 675         $group->annotate_files('group', 'image', 'id');
 676
 677         // Return the root element (groups)
 678         return $groups;
 679     }
 680 }
 681
 682 /**
 683  * structure step in charge of constructing the main users.xml file for all the users already
 684  * annotated (final). Includes custom profile fields, preferences, tags, role assignments and
 685  * overrides.
 686  */
 687 class backup_users_structure_step extends backup_structure_step {
 688
 689     protected function define_structure() {
 690         global $CFG;
 691
 692         // To know if we are anonymizing users
 693         $anonymize = $this->get_setting_value('anonymize');
 694         // To know if we are including role assignments
 695         $roleassignments = $this->get_setting_value('role_assignments');
 696
 697         // Define each element separated
 698
 699         $users = new backup_nested_element('users');
 700
 701         // Create the array of user fields by hand, as far as we have various bits to control
 702         // anonymize option, password backup, mnethostid...
 703
 704         // First, the fields not needing anonymization nor special handling
 705         $normalfields = array(
 706             'confirmed', 'policyagreed', 'deleted',
 707             'lang', 'theme', 'timezone', 'firstaccess',
 708             'lastaccess', 'lastlogin', 'currentlogin', 'secret',
 709             'mailformat', 'maildigest', 'maildisplay', 'htmleditor',
 710             'ajax', 'autosubscribe', 'trackforums', 'timecreated',
 711             'timemodified', 'trustbitmask', 'screenreader');
 712
 713         // Then, the fields potentially needing anonymization
 714         $anonfields = array(
 715             'username', 'idnumber', 'firstname', 'lastname',
 716             'email', 'emailstop', 'lastip', 'picture',
 717             'url', 'description', 'description_format', 'imagealt', 'auth');
 718
 719         // Add anonymized fields to $userfields with custom final element
 720         foreach ($anonfields as $field) {
 721             if ($anonymize) {
 722                 $userfields[] = new anonymizer_final_element($field);
 723             } else {
 724                 $userfields[] = $field; // No anonymization, normally added
 725             }
 726         }
 727
 728         // mnethosturl requires special handling (custom final element)
 729         $userfields[] = new mnethosturl_final_element('mnethosturl');
 730
 731         // password added conditionally
 732         if (!empty($CFG->includeuserpasswordsinbackup)) {
 733             $userfields[] = 'password';
 734         }
 735
 736         // Merge all the fields
 737         $userfields = array_merge($userfields, $normalfields);
 738
 739         $user = new backup_nested_element('user', array('id', 'contextid'), $userfields);
 740
 741         $customfields = new backup_nested_element('custom_fields');
 742
 743         $customfield = new backup_nested_element('custom_field', array('id'), array(
 744             'field_name', 'field_type', 'field_data'));
 745
 746         $tags = new backup_nested_element('tags');
 747
 748         $tag = new backup_nested_element('tag', array('id'), array(
 749             'name', 'rawname'));
 750
 751         $preferences = new backup_nested_element('preferences');
 752
 753         $preference = new backup_nested_element('preference', array('id'), array(
 754             'name', 'value'));
 755
 756         $roles = new backup_nested_element('roles');
 757
 758         $overrides = new backup_nested_element('role_overrides');
 759
 760         $override = new backup_nested_element('override', array('id'), array(
 761             'roleid', 'capability', 'permission', 'timemodified',
 762             'modifierid'));
 763
 764         $assignments = new backup_nested_element('role_assignments');
 765
 766         $assignment = new backup_nested_element('assignment', array('id'), array(
 767             'roleid', 'userid', 'timemodified', 'modifierid', 'component', //TODO: MDL-22793 add itemid here
 768             'sortorder'));
 769
 770         // Build the tree
 771
 772         $users->add_child($user);
 773
 774         $user->add_child($customfields);
 775         $customfields->add_child($customfield);
 776
 777         $user->add_child($tags);
 778         $tags->add_child($tag);
 779
 780         $user->add_child($preferences);
 781         $preferences->add_child($preference);
 782
 783         $user->add_child($roles);
 784
 785         $roles->add_child($overrides);
 786         $roles->add_child($assignments);
 787
 788         $overrides->add_child($override);
 789         $assignments->add_child($assignment);
 790
 791         // Define sources
 792
 793         $user->set_source_sql('SELECT u.*, c.id AS contextid, m.wwwroot AS mnethosturl
 794                                  FROM {user} u
 795                                  JOIN {backup_ids_temp} bi ON bi.itemid = u.id
 796                                  JOIN {context} c ON c.instanceid = u.id
 797                             LEFT JOIN {mnet_host} m ON m.id = u.mnethostid
 798                                 WHERE bi.backupid = ?
 799                                   AND bi.itemname = ?
 800                                   AND c.contextlevel = ?', array(
 801                                       $this->is_sqlparam($this->get_backupid()),
 802                                       $this->is_sqlparam('userfinal'),
 803                                       $this->is_sqlparam(CONTEXT_USER)));
 804
 805         // All the rest on information is only added if we arent
 806         // in an anonymized backup
 807         if (!$anonymize) {
 808             $customfield->set_source_sql('SELECT f.id, f.shortname, f.datatype, d.data
 809                                             FROM {user_info_field} f
 810                                             JOIN {user_info_data} d ON d.fieldid = f.id
 811                                            WHERE d.userid = ?', array(backup::VAR_PARENTID));
 812
 813             $customfield->set_source_alias('shortname', 'field_name');
 814             $customfield->set_source_alias('datatype',  'field_type');
 815             $customfield->set_source_alias('data',      'field_data');
 816
 817             $tag->set_source_sql('SELECT t.id, t.name, t.rawname
 818                                     FROM {tag} t
 819                                     JOIN {tag_instance} ti ON ti.tagid = t.id
 820                                    WHERE ti.itemtype = ?
 821                                      AND ti.itemid = ?', array(
 822                                          $this->is_sqlparam('user'),
 823                                          backup::VAR_PARENTID));
 824
 825             $preference->set_source_table('user_preferences', array('userid' => backup::VAR_PARENTID));
 826
 827             $override->set_source_table('role_capabilities', array('contextid' => '/users/user/contextid'));
 828
 829             // Assignments only added if specified
 830             if ($roleassignments) {
 831                 $assignment->set_source_table('role_assignments', array('contextid' => '/users/user/contextid'));
 832             }
 833
 834             // Define id annotations (as final)
 835             $override->annotate_ids('rolefinal', 'roleid');
 836         }
 837
 838         // Return root element (users)
 839         return $users;
 840     }
 841 }
 842
 843 /**
 844  * structure step in charge of constructing the block.xml file for one
 845  * given block (intance and positions). If the block has custom DB structure
 846  * that will go to a separate file (different step defined in block class)
 847  */
 848 class backup_block_instance_structure_step extends backup_structure_step {
 849
 850     protected function define_structure() {
 851         global $DB;
 852
 853         // Define each element separated
 854
 855         $block = new backup_nested_element('block', array('id', 'version'), array(
 856             'blockname', 'showinsubcontexts', 'pagetypepattern', 'subpagepattern',
 857             'defaultregion', 'defaultweight', 'configdata'));
 858
 859         $positions = new backup_nested_element('block_positions', null, array(
 860             'contextid', 'pagetype', 'subpage', 'visible',
 861             'region', 'weight'));
 862
 863         // Build the tree
 864
 865         $block->add_child($positions);
 866
 867         // Transform configdata information if needed (process links and friends)
 868         $blockrec = $DB->get_record('block_instances', array('id' => $this->task->get_blockid()));
 869         if ($attrstotransform = $this->task->get_configdata_encoded_attributes()) {
 870             $configdata = (array)unserialize(base64_decode($blockrec->configdata));
 871             foreach ($configdata as $attribute => $value) {
 872                 if (in_array($attribute, $attrstotransform)) {
 873                     $configdata[$attribute] = $this->contenttransformer->process($value);
 874                 }
 875             }
 876             $blockrec->configdata = base64_encode(serialize((object)$configdata));
 877         }
 878         // Get the version of the block
 879         $blockrec->version = $DB->get_field('block', 'version', array('name' => $this->task->get_blockname()));
 880
 881         // Define sources
 882
 883         $block->set_source_array(array($blockrec));
 884
 885         $positions->set_source_table('block_positions', array('blockinstanceid' => backup::VAR_PARENTID));
 886
 887         // Return the root element (block)
 888         return $block;
 889     }
 890 }
 891
 892 /**
 893  * structure step in charge of constructing the logs.xml file for all the log records found
 894  * in activity
 895  */
 896 class backup_activity_logs_structure_step extends backup_structure_step {
 897
 898     protected function define_structure() {
 899
 900         // Define each element separated
 901
 902         $logs = new backup_nested_element('logs');
 903
 904         $log = new backup_nested_element('log', array('id'), array(
 905             'time', 'userid', 'ip', 'module',
 906             'action', 'url', 'info'));
 907
 908         // Build the tree
 909
 910         $logs->add_child($log);
 911
 912         // Define sources
 913
 914         $log->set_source_table('log', array('cmid' => backup::VAR_MODID));
 915
 916         // Annotations
 917         // NOTE: We don't annotate users from logs as far as they MUST be
 918         //       always annotated by the activity.
 919
 920         // Return the root element (logs)
 921
 922         return $logs;
 923     }
 924 }
 925
 926 /**
 927  * structure in charge of constructing the inforef.xml file for all the items we want
 928  * to have referenced there (users, roles, files...)
 929  */
 930 class backup_inforef_structure_step extends backup_structure_step {
 931
 932     protected function define_structure() {
 933
 934         // Items we want to include in the inforef file. NOTE: Important to keep this
 935         // list 100% sync with the one in next step! Until we get better place for it (backup:CONST)
 936         $items = array('user', 'grouping', 'group', 'role', 'file', 'scale', 'outcome', 'grade_item');
 937
 938         // Build the tree
 939
 940         $inforef = new backup_nested_element('inforef');
 941
 942         // For each item, conditionally, if there are already records, build element
 943         foreach ($items as $itemname) {
 944             if (backup_structure_dbops::annotations_exist($this->get_backupid(), $itemname)) {
 945                 $elementroot = new backup_nested_element($itemname . 'ref');
 946                 $element = new backup_nested_element($itemname, array('id'));
 947                 $inforef->add_child($elementroot);
 948                 $elementroot->add_child($element);
 949                 $element->set_source_sql("
 950                     SELECT itemid AS id
 951                      FROM {backup_ids_temp}
 952                     WHERE backupid = ?
 953                       AND itemname = ?",
 954                    array(backup::VAR_BACKUPID, $this->is_sqlparam($itemname)));
 955             }
 956         }
 957
 958         // We don't annotate anything there, but rely in the next step
 959         // (move_inforef_annotations_to_final) that will change all the
 960         // already saved 'inforref' entries to their 'final' annotations.
 961         return $inforef;
 962     }
 963 }
 964
 965 /**
 966  * This step will get all the annotations already processed to inforef.xml file and
 967  * transform them into 'final' annotations.
 968  */
 969 class move_inforef_annotations_to_final extends backup_execution_step {
 970
 971     protected function define_execution() {
 972
 973         // Items we want to include in the inforef file. NOTE: Important to keep this
 974         // list 100% sync with the one in prev step! Until we get better place for it (backup:CONST)
 975         $items = array('user', 'grouping', 'group', 'role', 'file', 'scale', 'outcome', 'grade_item');
 976         foreach ($items as $itemname) {
 977             // Delegate to dbops
 978             backup_structure_dbops::move_annotations_to_final($this->get_backupid(), $itemname);
 979         }
 980     }
 981 }
 982
 983 /**
 984  * structure in charge of constructing the files.xml file with all the
 985  * annotated (final) files along the process. At, the same time, and
 986  * using one specialised nested_element, will copy them form moodle storage
 987  * to backup storage
 988  */
 989 class backup_final_files_structure_step extends backup_structure_step {
 990
 991     protected function define_structure() {
 992
 993         // Define elements
 994
 995         $files = new backup_nested_element('files');
 996
 997         $file = new file_nested_element('file', array('id'), array(
 998             'contenthash', 'contextid', 'component', 'filearea', 'itemid',
 999             'filepath', 'filename', 'userid', 'filesize',
1000             'mimetype', 'status', 'timecreated', 'timemodified',
1001             'source', 'author', 'license', 'sortorder'));
1002
1003         // Build the tree
1004
1005         $files->add_child($file);
1006
1007         // Define sources
1008
1009         $file->set_source_sql("SELECT f.*
1010                                  FROM {files} f
1011                                  JOIN {backup_ids_temp} bi ON f.id = bi.itemid
1012                                 WHERE bi.backupid = ?
1013                                   AND bi.itemname = 'filefinal'", array(backup::VAR_BACKUPID));
1014
1015         return $files;
1016     }
1017 }
1018
1019 /**
1020  * Structure step in charge of creating the main moodle_backup.xml file
1021  * where all the information related to the backup, settings, license and
1022  * other information needed on restore is added*/
1023 class backup_main_structure_step extends backup_structure_step {
1024
1025     protected function define_structure() {
1026
1027         global $CFG;
1028
1029         $info = array();
1030
1031         $info['name'] = $this->get_setting_value('filename');
1032         $info['moodle_version'] = $CFG->version;
1033         $info['moodle_release'] = $CFG->release;
1034         $info['backup_version'] = $CFG->backup_version;
1035         $info['backup_release'] = $CFG->backup_release;
1036         $info['backup_date']    = time();
1037         $info['backup_uniqueid']= $this->get_backupid();
1038         $info['original_wwwroot']=$CFG->wwwroot;
1039         $info['original_site_identifier'] = get_site_identifier();
1040         $info['original_course_id'] = $this->get_courseid();
1041
1042         // Get more information from controller
1043         list($dinfo, $cinfo, $sinfo) = backup_controller_dbops::get_moodle_backup_information($this->get_backupid());
1044
1045         // Define elements
1046
1047         $moodle_backup = new backup_nested_element('moodle_backup');
1048
1049         $information = new backup_nested_element('information', null, array(
1050             'name', 'moodle_version', 'moodle_release', 'backup_version',
1051             'backup_release', 'backup_date', 'original_wwwroot',
1052             'original_site_identifier', 'original_course_id'));
1053
1054         $details = new backup_nested_element('details');
1055
1056         $detail = new backup_nested_element('detail', array('backup_id'), array(
1057             'type', 'format', 'interactive', 'mode',
1058             'execution', 'executiontime'));
1059
1060         $contents = new backup_nested_element('contents');
1061
1062         $activities = new backup_nested_element('activities');
1063
1064         $activity = new backup_nested_element('activity', null, array(
1065             'moduleid', 'sectionid', 'modulename', 'title',
1066             'directory'));
1067
1068         $sections = new backup_nested_element('sections');
1069
1070         $section = new backup_nested_element('section', null, array(
1071             'sectionid', 'title', 'directory'));
1072
1073         $course = new backup_nested_element('course', null, array(
1074             'courseid', 'title', 'directory'));
1075
1076         $settings = new backup_nested_element('settings');
1077
1078         $setting = new backup_nested_element('setting', null, array(
1079             'level', 'activity', 'name', 'value'));
1080
1081         // Build the tree
1082
1083         $moodle_backup->add_child($information);
1084
1085         $information->add_child($details);
1086         $details->add_child($detail);
1087
1088         $information->add_child($contents);
1089         if (!empty($cinfo['activities'])) {
1090             $contents->add_child($activities);
1091             $activities->add_child($activity);
1092         }
1093         if (!empty($cinfo['sections'])) {
1094             $contents->add_child($sections);
1095             $sections->add_child($section);
1096         }
1097         if (!empty($cinfo['course'])) {
1098             $contents->add_child($course);
1099         }
1100
1101         $information->add_child($settings);
1102         $settings->add_child($setting);
1103
1104
1105         // Set the sources
1106
1107         $information->set_source_array(array((object)$info));
1108
1109         $detail->set_source_array($dinfo);
1110
1111         $activity->set_source_array($cinfo['activities']);
1112
1113         $section->set_source_array($cinfo['sections']);
1114
1115         $course->set_source_array($cinfo['course']);
1116
1117         $setting->set_source_array($sinfo);
1118
1119         // Prepare some information to be sent to main moodle_backup.xml file
1120         return $moodle_backup;
1121     }
1122
1123 }
1124
1125 /**
1126  * Execution step that will generate the final zip file with all the contents
1127  */
1128 class backup_zip_contents extends backup_execution_step {
1129
1130     protected function define_execution() {
1131
1132         // Get basepath
1133         $basepath = $this->get_basepath();
1134
1135         // Get the list of files in directory
1136         $filestemp = get_directory_list($basepath, '', false, true, true);
1137         $files = array();
1138         foreach ($filestemp as $file) { // Add zip paths and fs paths to all them
1139             $files[$file] = $basepath . '/' . $file;
1140         }
1141
1142         // Add the log file if exists
1143         $logfilepath = $basepath . '.log';
1144         if (file_exists($logfilepath)) {
1145              $files['moodle_backup.log'] = $logfilepath;
1146         }
1147
1148         // Calculate the zip fullpath (in OS temp area it's always backup.zip)
1149         $zipfile = $basepath . '/backup.zip';
1150
1151         // Get the zip packer
1152         $zippacker = get_file_packer('application/zip');
1153
1154         // Zip files
1155         $zippacker->archive_to_pathname($files, $zipfile);
1156     }
1157 }
1158
1159 /**
1160  * This step will send the generated backup file to its final destination
1161  */
1162 class backup_store_backup_file extends backup_execution_step {
1163
1164     protected function define_execution() {
1165
1166         // Get basepath
1167         $basepath = $this->get_basepath();
1168
1169         // Calculate the zip fullpath (in OS temp area it's always backup.zip)
1170         $zipfile = $basepath . '/backup.zip';
1171
1172         // Perform storage and return it (TODO: shouldn't be array but proper result object)
1173         return array('backup_destination' => backup_helper::store_backup_file($this->get_backupid(), $zipfile));
1174     }
1175 }
1176
1177
1178 /**
1179  * This step will search for all the activity (not calculations, categories nor aggregations) grade items
1180  * and put them to the backup_ids tables, to be used later as base to backup them
1181  */
1182 class backup_activity_grade_items_to_ids extends backup_execution_step {
1183
1184     protected function define_execution() {
1185
1186         // Fetch all activity grade items
1187         if ($items = grade_item::fetch_all(array(
1188                          'itemtype' => 'mod', 'itemmodule' => $this->task->get_modulename(),
1189                          'iteminstance' => $this->task->get_activityid(), 'courseid' => $this->task->get_courseid()))) {
1190             // Annotate them in backup_ids
1191             foreach ($items as $item) {
1192                 backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'grade_item', $item->id);
1193             }
1194         }
1195     }
1196 }
1197
1198 /**
1199  * This step will annotate all the groups belonging to already annotated groupings
1200  */
1201 class backup_annotate_groups_from_groupings extends backup_execution_step {
1202
1203     protected function define_execution() {
1204         global $DB;
1205
1206         // Fetch all the annotated groupings
1207         if ($groupings = $DB->get_records('backup_ids_temp', array(
1208                 'backupid' => $this->get_backupid(), 'itemname' => 'grouping'))) {
1209             foreach ($groupings as $grouping) {
1210                 if ($groups = $DB->get_records('groupings_groups', array(
1211                         'groupingid' => $grouping->itemid))) {
1212                     foreach ($groups as $group) {
1213                         backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'group', $group->groupid);
1214                     }
1215                 }
1216             }
1217         }
1218     }
1219 }
1220
1221 /**
1222  * This step will annotate all the scales belonging to already annotated outcomes
1223  */
1224 class backup_annotate_scales_from_outcomes extends backup_execution_step {
1225
1226     protected function define_execution() {
1227         global $DB;
1228
1229         // Fetch all the annotated outcomes
1230         if ($outcomes = $DB->get_records('backup_ids_temp', array(
1231                 'backupid' => $this->get_backupid(), 'itemname' => 'outcome'))) {
1232             foreach ($outcomes as $outcome) {
1233                 if ($scale = $DB->get_record('grade_outcomes', array(
1234                         'id' => $outcome->itemid))) {
1235                     // Annotate as scalefinal because it's > 0
1236                     backup_structure_dbops::insert_backup_ids_record($this->get_backupid(), 'scalefinal', $scale->scaleid);
1237                 }
1238             }
1239         }
1240     }
1241 }
1242
1243 /**
1244  * This step will generate all the user annotations for the already
1245  * annottated (final) users. Need to do this here because each user
1246  * has its own context and structure tasks only are able to handle
1247  * one context. Also, this step will guarantee that every user has
1248  * its context created (req for other steps)
1249  */
1250 class backup_annotate_all_user_files extends backup_execution_step {
1251
1252     protected function define_execution() {
1253         global $DB;
1254
1255         // List of fileareas we are going to annotate
1256         // TODO: user image not implemented yet
1257         $fileareas = array('private', 'profile', 'image');
1258
1259         // Fetch all annotated (final) users
1260         $rs = $DB->get_recordset('backup_ids_temp', array(
1261             'backupid' => $this->get_backupid(), 'itemname' => 'userfinal'));
1262         foreach ($rs as $record) {
1263             $userid = $record->itemid;
1264             $userctxid = get_context_instance(CONTEXT_USER, $userid)->id;
1265             // Proceed with every user filearea
1266             foreach ($fileareas as $filearea) {
1267                 // We don't need to specify itemid ($userid - 4th param) as far as by
1268                 // context we can get all the associated files. See MDL-22092
1269                 backup_structure_dbops::annotate_files($this->get_backupid(), $userctxid, 'user', $filearea, null);
1270             }
1271         }
1272         $rs->close();
1273     }
1274 }
1275
1276 /**
1277  * structure step in charge of constructing the grades.xml file for all the grade items
1278  * and letters related to one activity
1279  */
1280 class backup_activity_grades_structure_step extends backup_structure_step {
1281
1282     protected function define_structure() {
1283
1284         // To know if we are including userinfo
1285         $userinfo = $this->get_setting_value('userinfo');
1286
1287         // Define each element separated
1288
1289         $book = new backup_nested_element('activity_gradebook');
1290
1291         $items = new backup_nested_element('grade_items');
1292
1293         $item = new backup_nested_element('grade_item', array('id'), array(
1294             'categoryid', 'itemname', 'itemtype', 'itemmodule',
1295             'iteminstance', 'itemnumber', 'iteminfo', 'idnumber',
1296             'calculation', 'gradetype', 'grademax', 'grademin',
1297             'scaleid', 'outcomeid', 'gradepass', 'multfactor',
1298             'plusfactor', 'aggregationcoef', 'sortorder', 'display',
1299             'decimals', 'hidden', 'locked', 'locktime',
1300             'needsupdate', 'timecreated', 'timemodified'));
1301
1302         $grades = new backup_nested_element('grade_grades');
1303
1304         $grade = new backup_nested_element('grade_grade', array('id'), array(
1305             'userid', 'rawgrade', 'rawgrademax', 'rawgrademin',
1306             'rawscaleid', 'usermodified', 'finalgrade', 'hidden',
1307             'locked', 'locktime', 'exported', 'overridden',
1308             'excluded', 'feedback', 'feedbackformat', 'information',
1309             'informationformat', 'timecreated', 'timemodified'));
1310
1311         $letters = new backup_nested_element('grade_letters');
1312
1313         $letter = new backup_nested_element('grade_letter', 'id', array(
1314             'lowerboundary', 'letter'));
1315
1316         // Build the tree
1317
1318         $book->add_child($items);
1319         $items->add_child($item);
1320
1321         $item->add_child($grades);
1322         $grades->add_child($grade);
1323
1324         $book->add_child($letters);
1325         $letters->add_child($letter);
1326
1327         // Define sources
1328
1329         $item->set_source_sql("
1330             SELECT gi.*
1331               FROM {grade_items} gi
1332               JOIN {backup_ids_temp} bi ON gi.id = bi.itemid
1333              WHERE bi.backupid = ?
1334                AND bi.itemname = 'grade_item'", array(backup::VAR_BACKUPID));
1335
1336         // This only happens if we are including user info
1337         if ($userinfo) {
1338             $grade->set_source_table('grade_grades', array('itemid' => backup::VAR_PARENTID));
1339         }
1340
1341         $letter->set_source_table('grade_letters', array('contextid' => backup::VAR_CONTEXTID));
1342
1343         // Annotations
1344
1345         $item->annotate_ids('scalefinal', 'scaleid'); // Straight as scalefinal because it's > 0
1346         $item->annotate_ids('outcome', 'outcomeid');
1347
1348         $grade->annotate_ids('user', 'userid');
1349         $grade->annotate_ids('user', 'usermodified');
1350
1351         // Return the root element (book)
1352
1353         return $book;
1354     }
1355 }