Mark Johnson
1890a0b94d
When a question bank is restored along with a quiz that uses a random question from that bank, the set reference for the random question should now point to the category in the restored bank, rather than original. This uses the question bank context IDs recorded using the method added in MDL-86136 to decide if the set reference's question context is being restored, and update it accordingly. This required adding a new restore step in the restore_root_task, since when a restore is performed asynchronously, the temp IDs table is deleted after the prechecks are performed when the task is queued. Adding this step allows the IDs to be recorded again when the restore runs.
359 lines
18 KiB
PHP
359 lines
18 KiB
PHP
<?php
|
|
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* Defines restore_root_task class
|
|
* @package core_backup
|
|
* @subpackage moodle2
|
|
* @category backup
|
|
* @copyright 2010 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
use core\di;
|
|
use core\hook\manager;
|
|
use core_backup\hook\after_restore_root_define_settings;
|
|
|
|
/**
|
|
* Start task that provides all the settings common to all restores and other initial steps
|
|
*
|
|
* TODO: Finish phpdocs
|
|
*/
|
|
class restore_root_task extends restore_task {
|
|
|
|
/**
|
|
* Create all the steps that will be part of this task
|
|
*/
|
|
public function build() {
|
|
|
|
// Conditionally create the temp table (can exist from prechecks) and delete old stuff
|
|
$this->add_step(new restore_create_and_clean_temp_stuff('create_and_clean_temp_stuff'));
|
|
|
|
// Now make sure the user that is running the restore can actually access the course
|
|
// before executing any other step (potentially performing permission checks)
|
|
$this->add_step(new restore_fix_restorer_access_step('fix_restorer_access'));
|
|
|
|
// If we haven't preloaded information, load all the included inforef records to temp_ids table
|
|
$this->add_step(new restore_load_included_inforef_records('load_inforef_records'));
|
|
|
|
// Load all the needed files to temp_ids table
|
|
$this->add_step(new restore_load_included_files('load_file_records', 'files.xml'));
|
|
|
|
// If we haven't preloaded information, load all the needed roles to temp_ids_table
|
|
$this->add_step(new restore_load_and_map_roles('load_and_map_roles'));
|
|
|
|
// If we haven't preloaded information and are restoring user info, load all the needed users to temp_ids table
|
|
$this->add_step(new restore_load_included_users('load_user_records'));
|
|
|
|
// If we haven't preloaded information and are restoring user info, process all those needed users
|
|
// marking for create/map them as needed. Any problem here will cause exception as far as prechecks have
|
|
// performed the same process so, it's not possible to have errors here
|
|
$this->add_step(new restore_process_included_users('process_user_records'));
|
|
|
|
// Unconditionally, create all the needed users calculated in the previous step
|
|
$this->add_step(new restore_create_included_users('create_users'));
|
|
|
|
// Unconditionally, load create all the needed groups and groupings
|
|
$this->add_step(new restore_groups_structure_step('create_groups_and_groupings', 'groups.xml'));
|
|
|
|
// Unconditionally, load create all the needed scales
|
|
$this->add_step(new restore_scales_structure_step('create_scales', 'scales.xml'));
|
|
|
|
// Unconditionally, load create all the needed outcomes
|
|
$this->add_step(new restore_outcomes_structure_step('create_scales', 'outcomes.xml'));
|
|
|
|
// If we haven't preloaded information, load all the question banks to temp_ids_table.
|
|
$this->add_step(new \core\backup\restore_load_questionbanks('load_questionbanks'));
|
|
|
|
// If we haven't preloaded information, load all the needed categories and questions (reduced) to temp_ids_table
|
|
$this->add_step(new restore_load_categories_and_questions('load_categories_and_questions'));
|
|
|
|
// If we haven't preloaded information, process all the loaded categories and questions
|
|
// marking them for creation/mapping as needed. Any problem here will cause exception
|
|
// because this same process has been executed and reported by restore prechecks, so
|
|
// it is not possible to have errors here.
|
|
$this->add_step(new restore_process_categories_and_questions('process_categories_and_questions'));
|
|
|
|
// Unconditionally, create and map all the categories and questions
|
|
$this->add_step(new restore_create_categories_and_questions('create_categories_and_questions', 'questions.xml'));
|
|
|
|
// At the end, mark it as built
|
|
$this->built = true;
|
|
}
|
|
|
|
// Protected API starts here
|
|
|
|
/**
|
|
* Define the common setting that any restore type will have
|
|
*/
|
|
protected function define_settings() {
|
|
|
|
// Load all the root settings found in backup file from controller
|
|
$rootsettings = $this->get_info()->root_settings;
|
|
|
|
// Define users setting (keeping it on hand to define dependencies)
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['users']) && $rootsettings['users']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$users = new restore_users_setting('users', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$users->set_ui(new backup_setting_ui_checkbox($users, get_string('rootsettingusers', 'backup')));
|
|
$users->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($users);
|
|
|
|
// Restore enrolment methods.
|
|
if ($changeable) {
|
|
$options = [
|
|
backup::ENROL_NEVER => get_string('rootsettingenrolments_never', 'backup'),
|
|
backup::ENROL_WITHUSERS => get_string('rootsettingenrolments_withusers', 'backup'),
|
|
backup::ENROL_ALWAYS => get_string('rootsettingenrolments_always', 'backup'),
|
|
];
|
|
$enroldefault = backup::ENROL_WITHUSERS;
|
|
} else {
|
|
// Users can not be restored, simplify the dropdown.
|
|
$options = [
|
|
backup::ENROL_NEVER => get_string('no'),
|
|
backup::ENROL_ALWAYS => get_string('yes')
|
|
];
|
|
$enroldefault = backup::ENROL_NEVER;
|
|
}
|
|
$enrolments = new restore_users_setting('enrolments', base_setting::IS_INTEGER, $enroldefault);
|
|
$enrolments->set_ui(new backup_setting_ui_select($enrolments, get_string('rootsettingenrolments', 'backup'),
|
|
$options));
|
|
$this->add_setting($enrolments);
|
|
|
|
// Define role_assignments (dependent of users)
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['role_assignments']) && $rootsettings['role_assignments']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$roleassignments = new restore_role_assignments_setting('role_assignments', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$roleassignments->set_ui(new backup_setting_ui_checkbox($roleassignments,get_string('rootsettingroleassignments', 'backup')));
|
|
$roleassignments->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($roleassignments);
|
|
$users->add_dependency($roleassignments);
|
|
|
|
// Define permissions.
|
|
$defaultvalue = false; // Safer default.
|
|
$changeable = false;
|
|
// Enable when available, or key doesn't exist (backward compatibility).
|
|
if (!array_key_exists('permissions', $rootsettings) || !empty($rootsettings['permissions'])) {
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$permissions = new restore_permissions_setting('permissions', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$permissions->set_ui(new backup_setting_ui_checkbox($permissions, get_string('rootsettingpermissions', 'backup')));
|
|
$permissions->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($permissions);
|
|
|
|
// Define activitites
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['activities']) && $rootsettings['activities']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$activities = new restore_activities_setting('activities', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$activities->set_ui(new backup_setting_ui_checkbox($activities, get_string('rootsettingactivities', 'backup')));
|
|
$activities->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($activities);
|
|
|
|
// Define blocks
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['blocks']) && $rootsettings['blocks']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$blocks = new restore_generic_setting('blocks', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$blocks->set_ui(new backup_setting_ui_checkbox($blocks, get_string('rootsettingblocks', 'backup')));
|
|
$blocks->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($blocks);
|
|
|
|
// Define filters
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['filters']) && $rootsettings['filters']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$filters = new restore_generic_setting('filters', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$filters->set_ui(new backup_setting_ui_checkbox($filters, get_string('rootsettingfilters', 'backup')));
|
|
$filters->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($filters);
|
|
|
|
// Define comments (dependent of users)
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['comments']) && $rootsettings['comments']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$comments = new restore_comments_setting('comments', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$comments->set_ui(new backup_setting_ui_checkbox($comments, get_string('rootsettingcomments', 'backup')));
|
|
$comments->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($comments);
|
|
$users->add_dependency($comments);
|
|
|
|
// Define badges (dependent of activities).
|
|
$defaultvalue = false; // Safer default.
|
|
$changeable = false;
|
|
if (isset($rootsettings['badges']) && $rootsettings['badges']) { // Only enabled when available.
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$badges = new restore_badges_setting('badges', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$badges->set_ui(new backup_setting_ui_checkbox($badges, get_string('rootsettingbadges', 'backup')));
|
|
$badges->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($badges);
|
|
$activities->add_dependency($badges);
|
|
$users->add_dependency($badges);
|
|
|
|
// Define Calendar events.
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['calendarevents']) && $rootsettings['calendarevents']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$events = new restore_calendarevents_setting('calendarevents', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$events->set_ui(new backup_setting_ui_checkbox($events, get_string('rootsettingcalendarevents', 'backup')));
|
|
$events->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($events);
|
|
|
|
// Define completion (dependent of users)
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['userscompletion']) && $rootsettings['userscompletion']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$completion = new restore_userscompletion_setting('userscompletion', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$completion->set_ui(new backup_setting_ui_checkbox($completion, get_string('rootsettinguserscompletion', 'backup')));
|
|
$completion->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($completion);
|
|
$users->add_dependency($completion);
|
|
|
|
// Define logs (dependent of users)
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['logs']) && $rootsettings['logs']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$logs = new restore_logs_setting('logs', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$logs->set_ui(new backup_setting_ui_checkbox($logs, get_string('rootsettinglogs', 'backup')));
|
|
$logs->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($logs);
|
|
$users->add_dependency($logs);
|
|
|
|
// Define grade_histories (dependent of users)
|
|
$defaultvalue = false; // Safer default
|
|
$changeable = false;
|
|
if (isset($rootsettings['grade_histories']) && $rootsettings['grade_histories']) { // Only enabled when available
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$gradehistories = new restore_grade_histories_setting('grade_histories', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$gradehistories->set_ui(new backup_setting_ui_checkbox($gradehistories, get_string('rootsettinggradehistories', 'backup')));
|
|
$gradehistories->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($gradehistories);
|
|
$users->add_dependency($gradehistories);
|
|
|
|
// The restore does not process the grade histories when some activities are ignored.
|
|
// So let's define a dependency to prevent false expectations from our users.
|
|
$activities->add_dependency($gradehistories);
|
|
|
|
// Define groups and groupings.
|
|
$defaultvalue = false;
|
|
$changeable = false;
|
|
if (isset($rootsettings['groups']) && $rootsettings['groups']) { // Only enabled when available.
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
} else if (!isset($rootsettings['groups'])) {
|
|
// It is likely this is an older backup that does not contain information on the group setting,
|
|
// in which case groups should be restored and this setting can be changed.
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$groups = new restore_groups_setting('groups', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$groups->set_ui(new backup_setting_ui_checkbox($groups, get_string('rootsettinggroups', 'backup')));
|
|
$groups->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($groups);
|
|
|
|
// Competencies restore setting. Show when competencies is enabled and the setting is available.
|
|
$hascompetencies = !empty($rootsettings['competencies']);
|
|
$competencies = new restore_competencies_setting($hascompetencies);
|
|
$competencies->set_ui(new backup_setting_ui_checkbox($competencies, get_string('rootsettingcompetencies', 'backup')));
|
|
$this->add_setting($competencies);
|
|
|
|
// Custom fields.
|
|
$defaultvalue = false;
|
|
$changeable = false;
|
|
if (isset($rootsettings['customfield']) && $rootsettings['customfield']) { // Only enabled when available.
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$customfields = new restore_customfield_setting('customfield', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$customfields->set_ui(new backup_setting_ui_checkbox($customfields, get_string('rootsettingcustomfield', 'backup')));
|
|
$customfields->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($customfields);
|
|
|
|
// Define Content bank content.
|
|
$defaultvalue = false;
|
|
$changeable = false;
|
|
if (isset($rootsettings['contentbankcontent']) && $rootsettings['contentbankcontent']) { // Only enabled when available.
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$contents = new restore_contentbankcontent_setting('contentbankcontent', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$contents->set_ui(new backup_setting_ui_checkbox($contents, get_string('rootsettingcontentbankcontent', 'backup')));
|
|
$contents->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($contents);
|
|
|
|
// Define xAPI states.
|
|
$defaultvalue = false;
|
|
$changeable = false;
|
|
if (isset($rootsettings['xapistate']) && $rootsettings['xapistate']) { // Only enabled when available.
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
}
|
|
$xapistate = new restore_xapistate_setting('xapistate', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$xapistate->set_ui(new backup_setting_ui_checkbox($xapistate, get_string('rootsettingxapistate', 'backup')));
|
|
$xapistate->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($xapistate);
|
|
|
|
// Include legacy files.
|
|
$defaultvalue = true;
|
|
$changeable = true;
|
|
$legacyfiles = new restore_generic_setting('legacyfiles', base_setting::IS_BOOLEAN, $defaultvalue);
|
|
$legacyfiles->set_ui(new backup_setting_ui_checkbox($legacyfiles, get_string('rootsettinglegacyfiles', 'backup')));
|
|
$legacyfiles->get_ui()->set_changeable($changeable);
|
|
$this->add_setting($legacyfiles);
|
|
|
|
// Create and dispatch a hook to allow plugins to add other settings for the restore process.
|
|
$hook = new after_restore_root_define_settings($this);
|
|
di::get(manager::class)->dispatch($hook);
|
|
}
|
|
}
|