MDL-21432 backup - complete standard/course outcomes backup & restore
[moodle.git] / backup / moodle2 / restore_stepslib.php
index 6b93918..2494a64 100644 (file)
 class restore_create_and_clean_temp_stuff extends restore_execution_step {
 
     protected function define_execution() {
-        backup_helper::delete_old_backup_dirs(time() - (4 * 60 * 60));    // Delete > 4 hours temp dirs
-        $exists = restore_controller_dbops::create_backup_ids_temp_table($this->get_restoreid()); // Create temp table conditionally
+        $exists = restore_controller_dbops::create_restore_temp_tables($this->get_restoreid()); // temp tables conditionally
         // If the table already exists, it's because restore_prechecks have been executed in the same
         // request (without problems) and it already contains a bunch of preloaded information (users...)
         // that we aren't going to execute again
         if ($exists) { // Inform plan about preloaded information
             $this->task->set_preloaded_information();
         }
+        // Create the old-course-ctxid to new-course-ctxid mapping, we need that available since the beginning
+        $itemid = $this->task->get_old_contextid();
+        $newitemid = get_context_instance(CONTEXT_COURSE, $this->get_courseid())->id;
+        restore_dbops::set_backup_ids_record($this->get_restoreid(), 'context', $itemid, $newitemid);
+        // Create the old-system-ctxid to new-system-ctxid mapping, we need that available since the beginning
+        $itemid = $this->task->get_old_system_contextid();
+        $newitemid = get_context_instance(CONTEXT_SYSTEM)->id;
+        restore_dbops::set_backup_ids_record($this->get_restoreid(), 'context', $itemid, $newitemid);
     }
 }
 
@@ -51,7 +58,7 @@ class restore_drop_and_clean_temp_stuff extends restore_execution_step {
 
     protected function define_execution() {
         global $CFG;
-        backup_controller_dbops::drop_backup_ids_temp_table($this->get_restoreid()); // Drop ids temp table
+        restore_controller_dbops::drop_restore_temp_tables($this->get_restoreid()); // Drop ids temp table
         backup_helper::delete_old_backup_dirs(time() - (4 * 60 * 60));               // Delete > 4 hours temp dirs
         if (empty($CFG->keeptempdirectoriesonbackup)) { // Conditionally
             backup_helper::delete_backup_dir($this->get_restoreid()); // Empty backup dir
@@ -80,11 +87,67 @@ class restore_load_included_inforef_records extends restore_execution_step {
     }
 }
 
+/*
+ * Execution step that will load all the needed files into backup_files_temp
+ *   - info: contains the whole original object (times, names...)
+ * (all them being original ids as loaded from xml)
+ */
+class restore_load_included_files extends restore_structure_step {
+
+    protected function define_structure() {
+
+        $file = new restore_path_element('file', '/files/file');
+
+        return array($file);
+    }
+
+    // Processing functions go here
+    public function process_file($data) {
+
+        $data = (object)$data; // handy
+
+        // load it if needed:
+        //   - it it is one of the annotated inforef files (course/section/activity/block)
+        //   - it is one "user", "group", "grouping" or "grade" component file (that aren't sent to inforef ever)
+        $isfileref   = restore_dbops::get_backup_ids_record($this->get_restoreid(), 'fileref', $data->id);
+        $iscomponent = ($data->component == 'user' || $data->component == 'group' ||
+                        $data->component == 'grouping' || $data->component == 'grade');
+        if ($isfileref || $iscomponent) {
+            restore_dbops::set_backup_files_record($this->get_restoreid(), $data);
+        }
+    }
+}
+
+/**
+ * Execution step that, *conditionally* (if there isn't preloaded information),
+ * will load all the needed roles to backup_temp_ids. They will be stored with
+ * "role" itemname. Also it will perform one automatic mapping to roles existing
+ * in the target site, based in permissions of the user performing the restore,
+ * archetypes and other bits. At the end, each original role will have its associated
+ * target role or 0 if it's going to be skipped. Note we wrap everything over one
+ * restore_dbops method, as far as the same stuff is going to be also executed
+ * by restore prechecks
+ */
+class restore_load_and_map_roles extends restore_execution_step {
+
+    protected function define_execution() {
+        if ($this->task->get_preloaded_information()) { // if info is already preloaded, nothing to do
+            return;
+        }
+
+        $file = $this->get_basepath() . '/roles.xml';
+        // Load needed toles to temp_ids
+        restore_dbops::load_roles_to_tempids($this->get_restoreid(), $file);
+        // Process roles, mapping/skipping. Any error throws exception
+        restore_dbops::process_included_roles($this->get_restoreid(), $this->task->get_courseid(), $this->task->get_userid(), $this->task->is_samesite());
+    }
+}
+
 /**
  * Execution step that, *conditionally* (if there isn't preloaded information
  * and users have been selected in settings, will load all the needed users
  * to backup_temp_ids. They will be stored with "user" itemname and with
- * their original contextid as paremitemid.
+ * their original contextid as paremitemid
  */
 class restore_load_included_users extends restore_execution_step {
 
@@ -108,7 +171,7 @@ class restore_load_included_users extends restore_execution_step {
  * Note: Any error will cause exception, as far as this is the same processing
  * than the one into restore prechecks (that should have stopped process earlier)
  */
- class restore_process_included_users extends restore_execution_step {
+class restore_process_included_users extends restore_execution_step {
 
     protected function define_execution() {
 
@@ -122,6 +185,270 @@ class restore_load_included_users extends restore_execution_step {
     }
 }
 
+/**
+ * Execution step that will create all the needed users as calculated
+ * by @restore_process_included_users (those having newiteind = 0)
+ */
+class restore_create_included_users extends restore_execution_step {
+
+    protected function define_execution() {
+
+        restore_dbops::create_included_users($this->get_basepath(), $this->get_restoreid(), $this->get_setting_value('user_files'));
+    }
+}
+
+/**
+ * Structure step that will create all the needed groups and groupings
+ * by loading them from the groups.xml file performing the required matches.
+ * Note group members only will be added if restoring user info
+ */
+class restore_groups_structure_step extends restore_structure_step {
+
+    protected function define_structure() {
+
+        $paths = array(); // Add paths here
+
+        $paths[] = new restore_path_element('group', '/groups/group');
+        if ($this->get_setting_value('users')) {
+            $paths[] = new restore_path_element('member', '/groups/group/group_members/group_member');
+        }
+        $paths[] = new restore_path_element('grouping', '/groups/groupings/grouping');
+        $paths[] = new restore_path_element('grouping_group', '/groups/groupings/grouping/grouping_groups/grouping_group');
+
+        return $paths;
+    }
+
+    // Processing functions go here
+    public function process_group($data) {
+        global $DB;
+
+        $data = (object)$data; // handy
+        $data->courseid = $this->get_courseid();
+
+        $oldid = $data->id;    // need this saved for later
+
+        $restorefiles = false; // Only if we end creating the group
+
+        // Search if the group already exists (by name & description) in the target course
+        $description_clause = '';
+        $params = array('courseid' => $this->get_courseid(), 'grname' => $data->name);
+        if (!empty($data->description)) {
+            $description_clause = ' AND ' .
+                                  $DB->sql_compare_text('description') . ' = ' . $DB->sql_compare_text(':desc');
+           $params['desc'] = $data->description;
+        }
+        if (!$groupdb = $DB->get_record_sql("SELECT *
+                                               FROM {groups}
+                                              WHERE courseid = :courseid
+                                                AND name = :grname $description_clause", $params)) {
+            // group doesn't exist, create
+            $newitemid = $DB->insert_record('groups', $data);
+            $restorefiles = true; // We'll restore the files
+        } else {
+            // group exists, use it
+            $newitemid = $groupdb->id;
+        }
+        // Save the id mapping
+        $this->set_mapping('group', $oldid, $newitemid, $restorefiles);
+    }
+
+    public function process_member($data) {
+        global $DB;
+
+        $data = (object)$data; // handy
+
+        // get parent group->id
+        $data->groupid = $this->get_new_parentid('group');
+
+        // map user newitemid and insert if not member already
+        if ($data->userid = $this->get_mappingid('user', $data->userid)) {
+            if (!$DB->record_exists('groups_members', array('groupid' => $data->groupid, 'userid' => $data->userid))) {
+                $DB->insert_record('groups_members', $data);
+            }
+        }
+    }
+
+    public function process_grouping($data) {
+        global $DB;
+
+        $data = (object)$data; // handy
+        $data->courseid = $this->get_courseid();
+
+        $oldid = $data->id;    // need this saved for later
+        $restorefiles = false; // Only if we end creating the grouping
+
+        // Search if the grouping already exists (by name & description) in the target course
+        $description_clause = '';
+        $params = array('courseid' => $this->get_courseid(), 'grname' => $data->name);
+        if (!empty($data->description)) {
+            $description_clause = ' AND ' .
+                                  $DB->sql_compare_text('description') . ' = ' . $DB->sql_compare_text(':desc');
+           $params['desc'] = $data->description;
+        }
+        if (!$groupingdb = $DB->get_record_sql("SELECT *
+                                                  FROM {groupings}
+                                                 WHERE courseid = :courseid
+                                                   AND name = :grname $description_clause", $params)) {
+            // grouping doesn't exist, create
+            $newitemid = $DB->insert_record('groupings', $data);
+            $restorefiles = true; // We'll restore the files
+        } else {
+            // grouping exists, use it
+            $newitemid = $groupingdb->id;
+        }
+        // Save the id mapping
+        $this->set_mapping('grouping', $oldid, $newitemid, $restorefiles);
+    }
+
+    public function process_grouping_group($data) {
+        global $DB;
+
+        $data = (object)$data;
+
+        $data->groupingid = $this->get_new_parentid('grouping'); // Use new parentid
+        $data->groupid    = $this->get_mappingid('group', $data->groupid); // Get from mappings
+        $DB->insert_record('groupings_groups', $data);  // No need to set this mapping (no child info nor files)
+    }
+
+    protected function after_execute() {
+        // Add group related files, matching with "group" mappings
+        $this->add_related_files('group', 'icon', 'group');
+        $this->add_related_files('group', 'description', 'group');
+        // Add grouping related files, matching with "grouping" mappings
+        $this->add_related_files('grouping', 'description', 'grouping');
+    }
+
+}
+
+/**
+ * Structure step that will create all the needed scales
+ * by loading them from the scales.xml
+ */
+class restore_scales_structure_step extends restore_structure_step {
+
+    protected function define_structure() {
+
+        $paths = array(); // Add paths here
+        $paths[] = new restore_path_element('scale', '/scales_definition/scale');
+        return $paths;
+    }
+
+    protected function process_scale($data) {
+        global $DB;
+
+        $data = (object)$data;
+
+        $restorefiles = false; // Only if we end creating the group
+
+        $oldid = $data->id;    // need this saved for later
+
+        // Look for scale (by 'scale' both in standard (course=0) and current course
+        // with priority to standard scales (ORDER clause)
+        // scale is not course unique, use get_record_sql to suppress warning
+        // Going to compare LOB columns so, use the cross-db sql_compare_text() in both sides
+        $compare_scale_clause = $DB->sql_compare_text('scale')  . ' = ' . $DB->sql_compare_text(':scaledesc');
+        $params = array('courseid' => $this->get_courseid(), 'scaledesc' => $data->scale);
+        if (!$scadb = $DB->get_record_sql("SELECT *
+                                            FROM {scale}
+                                           WHERE courseid IN (0, :courseid)
+                                             AND $compare_scale_clause
+                                        ORDER BY courseid", $params, IGNORE_MULTIPLE)) {
+            // Remap the user if possible, defaut to user performing the restore if not
+            $userid = $this->get_mappingid('user', $data->userid);
+            $data->userid = $userid ? $userid : $this->get_userid();
+            // Remap the course if course scale
+            $data->courseid = $data->courseid ? $this->get_courseid() : 0;
+            // If global scale (course=0), check the user has perms to create it
+            // falling to course scale if not
+            $systemctx = get_context_instance(CONTEXT_SYSTEM);
+            if ($data->courseid == 0 && !has_capability('moodle/course:managescales', $systemctx , $data->userid)) {
+                $data->courseid = $this->get_courseid();
+            }
+            // scale doesn't exist, create
+            $newitemid = $DB->insert_record('scale', $data);
+            $restorefiles = true; // We'll restore the files
+        } else {
+            // scale exists, use it
+            $newitemid = $scadb->id;
+        }
+        // Save the id mapping (with files support at system context)
+        $this->set_mapping('scale', $oldid, $newitemid, $restorefiles, $this->task->get_old_system_contextid());
+    }
+
+    protected function after_execute() {
+        // Add scales related files, matching with "scale" mappings
+        $this->add_related_files('grade', 'scale', 'scale', $this->task->get_old_system_contextid());
+    }
+}
+
+
+/**
+ * Structure step that will create all the needed outocomes
+ * by loading them from the outcomes.xml
+ */
+class restore_outcomes_structure_step extends restore_structure_step {
+
+    protected function define_structure() {
+
+        $paths = array(); // Add paths here
+        $paths[] = new restore_path_element('outcome', '/outcomes_definition/outcome');
+        return $paths;
+    }
+
+    protected function process_outcome($data) {
+        global $DB;
+
+        $data = (object)$data;
+
+        $restorefiles = false; // Only if we end creating the group
+
+        $oldid = $data->id;    // need this saved for later
+
+        // Look for outcome (by shortname both in standard (courseid=null) and current course
+        // with priority to standard outcomes (ORDER clause)
+        // outcome is not course unique, use get_record_sql to suppress warning
+        $params = array('courseid' => $this->get_courseid(), 'shortname' => $data->shortname);
+        if (!$outdb = $DB->get_record_sql('SELECT *
+                                             FROM {grade_outcomes}
+                                            WHERE shortname = :shortname
+                                              AND (courseid = :courseid OR courseid IS NULL)
+                                         ORDER BY COALESCE(courseid, 0)', $params, IGNORE_MULTIPLE)) {
+            // Remap the user
+            $userid = $this->get_mappingid('user', $data->usermodified);
+            $data->usermodified = $userid ? $userid : $this->get_userid();
+            // Remap the course if course outcome
+            $data->courseid = $data->courseid ? $this->get_courseid() : null;
+            // If global outcome (course=null), check the user has perms to create it
+            // falling to course outcome if not
+            $systemctx = get_context_instance(CONTEXT_SYSTEM);
+            if (is_null($data->courseid) && !has_capability('moodle/grade:manageoutcomes', $systemctx , $data->userid)) {
+                $data->courseid = $this->get_courseid();
+            }
+            // outcome doesn't exist, create
+            $newitemid = $DB->insert_record('grade_outcomes', $data);
+            $restorefiles = true; // We'll restore the files
+        } else {
+            // scale exists, use it
+            $newitemid = $outdb->id;
+        }
+        // Set the corresponding grade_outcomes_courses record
+        $outcourserec = new stdclass();
+        $outcourserec->courseid  = $this->get_courseid();
+        $outcourserec->outcomeid = $newitemid;
+        if (!$DB->record_exists('grade_outcomes_courses', (array)$outcourserec)) {
+            $DB->insert_record('grade_outcomes_courses', $outcourserec);
+        }
+        // Save the id mapping (with files support at system context)
+        $this->set_mapping('outcome', $oldid, $newitemid, $restorefiles, $this->task->get_old_system_contextid());
+    }
+
+    protected function after_execute() {
+        // Add outcomes related files, matching with "outcome" mappings
+        $this->add_related_files('grade', 'outcome', 'outcome', $this->task->get_old_system_contextid());
+    }
+}
+
+
 /*
  * Structure step that will read the course.xml file, loading it and performing
  * various actions depending of the site/restore settings
@@ -140,6 +467,7 @@ class restore_course_structure_step extends restore_structure_step {
 
     // Processing functions go here
     public function process_course($data) {
+        // TODO: don't forget to remap defaultgroupingid
         print_object('stopped before processing course. Continue here');
     }