WebSVN – Moodle – Diff – /backup/moodle2/restore_stepslib.php

         // Ensure the module cache is current when recalculating grades.
         rebuild_course_cache($this->get_courseid(), true);
         // Restore marks items as needing update. Update everything now.
-        grade_regrade_final_grades($this->get_courseid());
+        grade_regrade_final_grades($this->get_courseid(), async: true);
+    }
         // Do not include group/groupings information if not requested.
         $groupinfo = $this->get_setting_value('groups');
         if ($groupinfo) {
-            $paths[] = new restore_path_element('group', '/groups/group');
-            $paths[] = new restore_path_element('groupcustomfield', '/groups/groupcustomfields/groupcustomfield');
+            $paths[] = new restore_path_element('group', '/groups/group');
-            $paths[] = new restore_path_element('grouping', '/groups/groupings/grouping');
-            $paths[] = new restore_path_element('groupingcustomfield',
-                '/groups/groupings/groupingcustomfields/groupingcustomfield');
+            $paths[] = new restore_path_element('grouping', '/groups/groupings/grouping');
+            $paths[] = new restore_path_element('grouping_group', '/groups/groupings/grouping/grouping_groups/grouping_group');
+            // Custom fields.
+            if ($this->get_setting_value('customfield')) {
+                $paths[] = new restore_path_element('groupcustomfield', '/groups/groupcustomfields/groupcustomfield');
+                $paths[] = new restore_path_element('groupingcustomfield',
+                    '/groups/groupings/groupingcustomfields/groupingcustomfield');
             $paths[] = new restore_path_element('grouping_group', '/groups/groupings/grouping/grouping_groups/grouping_group');
+        }
         return $paths;
+    }
      * @param array $data data for group custom field
      * @return void
      */
     public function process_groupcustomfield($data) {
         $newgroup = $this->get_mapping('group', $data['groupid']);
+        if ($newgroup && $newgroup->newitemid) {
-        $data['groupid'] = $newgroup->newitemid ?? $data['groupid'];
+            $data['groupid'] = $newgroup->newitemid;
-        $handler = \core_group\customfield\group_handler::create();
+            $handler = \core_group\customfield\group_handler::create();
-        $handler->restore_instance_data_from_backup($this->task, $data);
+            $handler->restore_instance_data_from_backup($this->task, $data);
+        }
+    }
     public function process_grouping($data) {
      * Restore grouping custom field values.
      * @param array $data data for grouping custom field
      * @return void
      */
     public function process_groupingcustomfield($data) {
-        $newgroup = $this->get_mapping('grouping', $data['groupingid']);
+        $newgrouping = $this->get_mapping('grouping', $data['groupingid']);
+        if ($newgrouping && $newgrouping->newitemid) {
-        $data['groupingid'] = $newgroup->newitemid ?? $data['groupingid'];
+            $data['groupingid'] = $newgrouping->newitemid;
-        $handler = \core_group\customfield\grouping_handler::create();
+            $handler = \core_group\customfield\grouping_handler::create();
-        $handler->restore_instance_data_from_backup($this->task, $data);
+            $handler->restore_instance_data_from_backup($this->task, $data);
+        }
+    }
     public function process_grouping_group($data) {
         // Look for the section
         $section = new stdclass();
         $section->course  = $this->get_courseid();
         $section->section = $data->number;
         $section->timemodified = $data->timemodified ?? 0;
+        $section->component = null;
+        $section->itemid = null;
+        $secrec = $DB->get_record(
+            'course_sections',
+            ['course' => $this->get_courseid(), 'section' => $data->number, 'component' => null]
+        );
+        $createsection = empty($secrec);
+        // Delegated sections are always restored as new sections.
+        if (!empty($data->component)) {
+            $section->itemid = $this->get_delegated_section_mapping($data->component, $data->itemid);
+            // If the delegate component does not set the mapping id, the section must be converted
+            // into a regular section. Otherwise, it won't be accessible.
+            $createsection = $createsection || $section->itemid !== null;
+            $section->component = ($section->itemid !== null) ? $data->component : null;
+            // The section number will be always the last of the course, no matter the case.
+            $section->section = $this->get_last_section_number($this->get_courseid()) + 1;
+        }
         // Section doesn't exist, create it with all the info from backup
-        if (!$secrec = $DB->get_record('course_sections', ['course' => $this->get_courseid(), 'section' => $data->number])) {
+        if ($createsection) {
             $section->name = $data->name;
             $section->summary = $data->summary;
             $section->summaryformat = $data->summaryformat;
             $section->sequence = '';
             $section->visible = $data->visible;
                 if (is_null($section->availability)) {
                     $section->availability = \core_availability\info::convert_legacy_fields(
                             $data, true);
+                }
+            }
-            // Moodle 4.4 implement basic delegated section logic but it is not able to restore
-            // them from a backup. To prevent unexpected retoration errors, all sections with
+            // Delegated sections should be always after the normal sections.
-            // a component will be restored as a normal section.
+            $this->displace_delegated_sections_after($section->section);
-            $section->component = null;
-            $section->itemid = null;
             $newitemid = $DB->insert_record('course_sections', $section);
             $section->id = $newitemid;
     protected function after_execute() {
         // Add section related files, with 'course_section' itemid to match
         $this->add_related_files('course', 'section', 'course_section');
+    }
+    /**
+     * Create a delegate section mapping.
+     *
+     * @param string $component the component name (frankenstyle)
+     * @param int $oldsectionid The old section id.
+     * @return int|null The new section id or null if not found.
+     */
+    protected function get_delegated_section_mapping($component, $oldsectionid): ?int {
+        $result = $this->get_mappingid("course_section::$component", $oldsectionid, null);
+        return $result;
+    }
+    /**
+     * Displace delegated sections after the given section number.
+     *
+     * @param int $sectionnum The section number.
+     */
+    protected function displace_delegated_sections_after(int $sectionnum): void {
+        global $DB;
+        $sectionstomove = $DB->get_records_select(
+            'course_sections',
+            'course = ? AND component IS NOT NULL',
+            [$this->get_courseid()],
+            'section DESC', 'id, section'
+        );
+        // Here we add the new section to the end of the list so we make sure that all delegated sections are really
+        // all located after the normal sections. We can have case where delegated sections are located before the
+        // normal sections, so we need to move them to the end (mostly in the restore process more than in the duplicate
+        // process in which the order sections => delegated section is mostly there).
+        $sectionnum = $sectionnum + count($sectionstomove);
+        foreach ($sectionstomove as $section) {
+            $section->section = $sectionnum--;
+            $DB->update_record('course_sections', $section);
+        }
+    }
+    /**
+     * Get the last section number in the course.
+     *
+     * @param int $courseid The course id.
+     * @param bool $includedelegated If true, include delegated sections in the count.
+     * @return int The last section number.
+     */
+    protected function get_last_section_number(int $courseid, bool $includedelegated = false): int {
+        global $DB;
+        $delegtadefilter = $includedelegated ? '' : ' AND component IS NULL';
+        return (int) $DB->get_field_sql(
+            'SELECT max(section) from {course_sections} WHERE course = ?' . $delegtadefilter,
+            [$courseid]
+        );
+    }
+}
 /**
      */
     protected $legacyallowedmodules = array();
+    protected function define_structure() {
-    protected function define_structure() {
+        $paths = [];
+        $course = new restore_path_element('course', '/course');
-        $course = new restore_path_element('course', '/course');
+        $paths[] = $course;
-        $category = new restore_path_element('category', '/course/category');
+        $paths[] = new restore_path_element('category', '/course/category');
-        $tag = new restore_path_element('tag', '/course/tags/tag');
+        $paths[] = new restore_path_element('tag', '/course/tags/tag');
+        $paths[] = new restore_path_element('course_format_option', '/course/courseformatoptions/courseformatoption');
+        $paths[] = new restore_path_element('allowed_module', '/course/allowed_modules/module');
-        $customfield = new restore_path_element('customfield', '/course/customfields/customfield');
+        // Custom fields.
+        if ($this->get_setting_value('customfield')) {
-        $courseformatoptions = new restore_path_element('course_format_option', '/course/courseformatoptions/courseformatoption');
+            $paths[] = new restore_path_element('customfield', '/course/customfields/customfield');
         $allowedmodule = new restore_path_element('allowed_module', '/course/allowed_modules/module');
         $this->add_plugin_structure('local', $course);
         // Apply for admin tool plugins optional paths at course level.
         $this->add_plugin_structure('tool', $course);
-        return array($course, $category, $tag, $customfield, $allowedmodule, $courseformatoptions);
+        return $paths;
+    }
                 'notification'   => $data->notification,
                 'status'         => BADGE_STATUS_INACTIVE,
                 'nextcron'       => $data->nextcron,
                 'version'        => $data->version,
                 'language'       => $data->language,
-                'imageauthorname' => $data->imageauthorname,
-                'imageauthoremail' => $data->imageauthoremail,
-                'imageauthorurl' => $data->imageauthorurl,
                 'imagecaption'   => $data->imagecaption
         );
         $newid = $DB->insert_record('badge', $params);
         // Do the mapping for modulename, preparing it for files by oldcontext
         $modulename = $this->task->get_modulename();
         $oldid = $this->task->get_old_activityid();
         $this->set_mapping($modulename, $oldid, $newitemid, true);
+    }
+    /**
+     * Create a delegate section mapping.
+     *
+     * @param string $component The component name (frankenstyle)
+     * @param int $olditemid The old section id.
+     * @param int $newitemid The new section id.
+     */
+    protected function set_delegated_section_mapping($component, $olditemid, $newitemid) {
+        $this->set_mapping("course_section::$component", $olditemid, $newitemid);
+    }
+}
 /**
  * Structure step in charge of creating/mapping all the qcats and qs
 class restore_create_categories_and_questions extends restore_structure_step {
     /** @var array $cachedcategory store a question category */
+    protected $cachedcategory = null;
+    /** @var stdClass the last question_bank_entry seen during the restore. Processed when we get to a question. */
+    protected $latestqbe;
+    /** @var stdClass the last question_version seen during the restore. Processed when we get to a question. */
-    protected $cachedcategory = null;
+    protected $latestversion;
     protected function define_structure() {
         if ($mapping->info->contextlevel == CONTEXT_MODULE) {
             $mapping->parentitemid = $this->get_mappingid('context', $this->task->get_old_contextid());
+        }
         $data->contextid = $mapping->parentitemid;
+        $context = \context::instance_by_id($data->contextid);
         // Before 3.5, question categories could be created at top level.
         // From 3.5 onwards, all question categories should be a child of a special category called the "top" category.
         $restoretask = $this->get_task();
+        $before35 = $restoretask->backup_release_compare('3.5', '<') || $restoretask->backup_version_compare(20180205, '<');
+        // We need a 'Top' question category for an activity module and activity modules are mapped to CONTEXT_COURSE and moved
+        // to the correct module context in restore_move_module_questions_categories.
+        // As we can't create a 'Top' category in CONTEXT_COURSE we'll make a default
-        $before35 = $restoretask->backup_release_compare('3.5', '<') || $restoretask->backup_version_compare(20180205, '<');
+        // qbank module and map it to that until they are created later.
+        if (empty($mapping->info->parent) && $before35) {
+            if ($context->contextlevel === CONTEXT_COURSE) {
+                $course = get_course($context->instanceid);
+                $defaultbank = \core_question\local\bank\question_bank_helper::get_default_open_instance_system_type($course, true);
+                $bankcontextid = $defaultbank->context->id;
+            } else {
+                $bankcontextid = $data->contextid;
-        if (empty($mapping->info->parent) && $before35) {
+            }
-            $top = question_get_top_category($data->contextid, true);
+            $top = question_get_top_category($bankcontextid, true);
             $data->parent = $top->id;
         }
-        if (empty($data->parent)) {
-            if (!$top = question_get_top_category($data->contextid)) {
-                $top = question_get_top_category($data->contextid, true);
-                $this->set_mapping('question_category_created', $oldid, $top->id, false, null, $data->contextid);
-            }
-            $this->set_mapping('question_category', $oldid, $top->id);
         } else {
         if (!empty($data->parent)) {
             // Before 3.1, the 'stamp' field could be erroneously duplicated.
             // From 3.1 onwards, there's a unique index of (contextid, stamp).
             // If we encounter a duplicate in an old restore file, just generate a new stamp.
             $this->set_mapping('question_category_created', $oldid, $newitemid, false, null, $data->contextid);
+        }
+    }
     /**
-     * Process pre 4.0 question data where in creates the record for version and entry table.
+     * Set up date to allow restore of questions from pre-4.0 backups.
      *
-     * @param array $data the data from the XML file.
+     * @param stdClass $data the data from the XML file.
      */
+    protected function process_question_legacy_data($data) {
+        $this->latestqbe = (object) [
+            'id' => $data->id,
+            'questioncategoryid' => $data->category,
+            'ownerid' => $data->createdby,
-    protected function process_question_legacy_data($data) {
+            'idnumber' => $data->idnumber ?? null,
-        global $DB;
+        ];
-        $oldid = $data->id;
-        // Process question bank entry.
-        $entrydata = new stdClass();
-        $entrydata->questioncategoryid = $data->category;
+        $this->latestversion = (object) [
-        $userid = $this->get_mappingid('user', $data->createdby);
-        if ($userid) {
-            $entrydata->ownerid = $userid;
-        } else {
-            if (!$this->task->is_samesite()) {
-                $entrydata->ownerid = $this->task->get_userid();
-            }
-        }
-        // The idnumber if it exists also needs to be unique within a category or reset it to null.
-        if (isset($data->idnumber) && !$DB->record_exists('question_bank_entries',
+            'id' => $data->id,
-                ['idnumber' => $data->idnumber, 'questioncategoryid' => $data->category])) {
-            $entrydata->idnumber = $data->idnumber;
-        }
-        $newentryid = $DB->insert_record('question_bank_entries', $entrydata);
-        // Process question versions.
-        $versiondata = new stdClass();
-        $versiondata->questionbankentryid = $newentryid;
-        $versiondata->version = 1;
-        // Question id is updated after inserting the question.
+            'version' => 1,
-        $versiondata->questionid = 0;
-        $versionstatus = \core_question\local\bank\question_version_status::QUESTION_STATUS_READY;
+            'status' => $data->hidden ?
-        if ((int)$data->hidden === 1) {
+                \core_question\local\bank\question_version_status::QUESTION_STATUS_HIDDEN :
-            $versionstatus = \core_question\local\bank\question_version_status::QUESTION_STATUS_HIDDEN;
-        }
-        $versiondata->status = $versionstatus;
-        $newversionid = $DB->insert_record('question_versions', $versiondata);
+                \core_question\local\bank\question_version_status::QUESTION_STATUS_READY,
-        $this->set_mapping('question_version_created', $oldid, $newversionid);
+        ];
+    }
     /**
      * Process question bank entry data.
+     *
-     * @param array $data the data from the XML file.
-     */
-    protected function process_question_bank_entry($data) {
-        global $DB;
-        $data = (object)$data;
-        $oldid = $data->id;
+     * @param array $data the data from the XML file.
-        $questioncreated = $this->get_mappingid('question_category_created', $data->questioncategoryid) ? true : false;
-        $recordexist = $DB->record_exists('question_bank_entries', ['id' => $data->id,
-            'questioncategoryid' => $data->questioncategoryid]);
-        // Check we have category created.
-        if (!$questioncreated && $recordexist) {
-            return self::SKIP_ALL_CHILDREN;
+     */
-        }
-        $data->questioncategoryid = $this->get_new_parentid('question_category');
+    protected function process_question_bank_entry($data) {
-        $userid = $this->get_mappingid('user', $data->ownerid);
-        if ($userid) {
-            $data->ownerid = $userid;
-        } else {
-            if (!$this->task->is_samesite()) {
-                $data->ownerid = $this->task->get_userid();
-            }
-        }
-        // The idnumber if it exists also needs to be unique within a category or reset it to null.
-        if (!empty($data->idnumber) && $DB->record_exists('question_bank_entries',
-                ['idnumber' => $data->idnumber, 'questioncategoryid' => $data->questioncategoryid])) {
-            unset($data->idnumber);
-        }
         // We can only determine the right way to process this once we get to
-        $newitemid = $DB->insert_record('question_bank_entries', $data);
+        // process_question and have more information, so for now just store.
-        $this->set_mapping('question_bank_entry', $oldid, $newitemid);
+        $this->latestqbe = (object) $data;
+    }
     /**
      * Process question versions.
-     *
-     * @param array $data the data from the XML file.
-     */
-    protected function process_question_versions($data) {
-        global $DB;
+     *
-        $data = (object)$data;
+     * @param array $data the data from the XML file.
-        $oldid = $data->id;
-        $data->questionbankentryid = $this->get_new_parentid('question_bank_entry');
+     */
-        // Question id is updated after inserting the question.
+    protected function process_question_versions($data) {
-        $data->questionid = 0;
+        // We can only determine the right way to process this once we get to
-        $newitemid = $DB->insert_record('question_versions', $data);
+        // process_question and have more information, so for now just store.
-        $this->set_mapping('question_versions', $oldid, $newitemid);
+        $this->latestversion = (object) $data;
+    }
     /**
      * Process the actual question.
      *
      * @param array $data the data from the XML file.
      */
+    protected function process_question($data) {
+        global $DB;
+        $data = (object) $data;
+        $oldid = $data->id;
+        // Check we have one mapping for this question.
-    protected function process_question($data) {
+        if (!$questionmapping = $this->get_mapping('question', $oldid)) {
-        global $DB;
+            // No mapping = this question doesn't need to be created/mapped.
-        $data = (object)$data;
-        $oldid = $data->id;
-        // Check if the backup is a pre 4.0 one.
-        $restoretask = $this->get_task();
+            return;
         if ($restoretask->backup_release_compare('4.0', '<') || $restoretask->backup_version_compare(20220202, '<')) {
             // Check we have one mapping for this question.
-            if (!$questionmapping = $this->get_mapping('question', $oldid)) {
+        // Check if this is a pre 4.0 backup, then there will not be a question bank entry
-                return; // No mapping = this question doesn't need to be created/mapped.
+        // or question version in the file. So, we need to set up that data ready to be used below.
             if (!$this->task->is_samesite()) {
                 $data->modifiedby = $this->task->get_userid();
+            }
+        }
+        // With newitemid = 0, let's create the question.
+        if (!$questionmapping->newitemid) {
+            // Now we know we are inserting a question, we may need to insert the questionbankentry.
+            if (empty($this->latestqbe->newid)) {
+                $this->latestqbe->oldid = $this->latestqbe->id;
+                $this->latestqbe->questioncategoryid = $this->get_new_parentid('question_category');
+                $userid = $this->get_mappingid('user', $this->latestqbe->ownerid);
+                if ($userid) {
+                    $this->latestqbe->ownerid = $userid;
+                } else {
+                    if (!$this->task->is_samesite()) {
+                        $this->latestqbe->ownerid = $this->task->get_userid();
+                    }
+                }
+                // The idnumber if it exists also needs to be unique within a category or reset it to null.
+                if (!empty($this->latestqbe->idnumber) && $DB->record_exists('question_bank_entries',
+                        ['idnumber' => $this->latestqbe->idnumber, 'questioncategoryid' => $this->latestqbe->questioncategoryid])) {
+                    unset($this->latestqbe->idnumber);
+                }
+                $this->latestqbe->newid = $DB->insert_record('question_bank_entries', $this->latestqbe);
+                $this->set_mapping('question_bank_entry', $this->latestqbe->oldid, $this->latestqbe->newid);
+            }
+            // Now store the question.
-        $newitemid = $DB->insert_record('question', $data);
+            $newitemid = $DB->insert_record('question', $data);
-        $this->set_mapping('question', $oldid, $newitemid);
+            $this->set_mapping('question', $oldid, $newitemid);
-        // Also annotate them as question_created, we need
+            // Also annotate them as question_created, we need
-        // that later when remapping parents (keeping the old categoryid as parentid).
+            // that later when remapping parents (keeping the old categoryid as parentid).
-        $parentcatid = $this->get_old_parentid('question_category');
+            $parentcatid = $this->get_old_parentid('question_category');
+            $this->set_mapping('question_created', $oldid, $newitemid, false, null, $parentcatid);
-        $this->set_mapping('question_created', $oldid, $newitemid, false, null, $parentcatid);
+            // Also insert this question_version.
-        // Now update the question_versions table with the new question id. we dont need to do that for random qtypes.
+            $oldqvid = $this->latestversion->id;
-        $legacyquestiondata = $this->get_mappingid('question_version_created', $oldid) ? true : false;
+            $this->latestversion->questionbankentryid = $this->latestqbe->newid;
+            $this->latestversion->questionid = $newitemid;
-        if ($legacyquestiondata) {
+            $newqvid = $DB->insert_record('question_versions', $this->latestversion);
+            $this->set_mapping('question_versions', $oldqvid, $newqvid);
             $parentitemid = $this->get_mappingid('question_version_created', $oldid);
+        } else {
+            // By performing this set_mapping() we make get_old/new_parentid() to work for all the
+            // children elements of the 'question' one (so qtype plugins will know the question they belong to).
+            $this->set_mapping('question', $oldid, $questionmapping->newitemid);
+            // Also create the question_bank_entry and version mappings, if required.
-        } else {
+            $newquestionversion = $DB->get_record('question_versions', ['questionid' => $questionmapping->newitemid]);
+            $this->set_mapping('question_versions', $this->latestversion->id, $newquestionversion->id);
+            if (empty($this->latestqbe->newid)) {
+                $this->latestqbe->oldid = $this->latestqbe->id;
+                $this->latestqbe->newid = $newquestionversion->questionbankentryid;
+                $this->set_mapping('question_bank_entry', $this->latestqbe->oldid, $this->latestqbe->newid);
             $parentitemid = $this->get_new_parentid('question_versions');
-        }
-        $version = new stdClass();
-        $version->id = $parentitemid;
-        $version->questionid = $newitemid;
         $DB->update_record('question_versions', $version);
         // Note, we don't restore any question files yet
         // as far as the CONTEXT_MODULE categories still
         // haven't their contexts to be restored to
-        // The {@link restore_create_question_files}, executed in the final step
+        // The {@see restore_create_question_files}, executed in the final
         // step will be in charge of restoring all the question files.
+    }
             // of all the question's hints in DB as slower fallback. MDL-33863.
             if (!$newitemid) {
                 $potentialhints = $DB->get_records('question_hints',
                         array('questionid' => $newquestionid), '', 'id, hint');
                 foreach ($potentialhints as $potentialhint) {
-                    // Clean in the same way than {@link xml_writer::xml_safe_utf8()}.
-                    $cleanhint = preg_replace('/[\x-\x8\xb-\xc\xe-\x1f\x7f]/is','', $potentialhint->hint); // Clean CTRL chars.
+                    $cleanhint = core_text::trim_ctrl_chars($potentialhint->hint); // Clean CTRL chars.
                     $cleanhint = preg_replace("/\r\n|\r/", "\n", $cleanhint); // Normalize line ending.
                     if ($cleanhint === $data->hint) {
                         $newitemid = $data->id;
+                    }
+                }
             return;
+        }
         if (core_tag_tag::is_enabled('core_question', 'question')) {
-            $tagname = $data->rawname;
-            if (!empty($data->contextid) && $newcontextid = $this->get_mappingid('context', $data->contextid)) {
-                    $tagcontextid = $newcontextid;
-            } else {
+            $tagname = $data->rawname;
-                // Get the category, so we can then later get the context.
+            // Get the category, so we can then later get the context.
-                $categoryid = $this->get_new_parentid('question_category');
+            $categoryid = $this->get_new_parentid('question_category');
-                if (empty($this->cachedcategory) || $this->cachedcategory->id != $categoryid) {
+            if (empty($this->cachedcategory) || $this->cachedcategory->id != $categoryid) {
-                    $this->cachedcategory = $DB->get_record('question_categories', array('id' => $categoryid));
-                }
-                $tagcontextid = $this->cachedcategory->contextid;
+                $this->cachedcategory = $DB->get_record('question_categories', ['id' => $categoryid]);
+            }
             $tagcontextid = $this->cachedcategory->contextid;
             // Add the tag to the question.
+            core_tag_tag::add_item_tag('core_question',
+                'question',
-            core_tag_tag::add_item_tag('core_question', 'question', $newquestion,
+                $newquestion,
-                    context::instance_by_id($tagcontextid),
+                context::instance_by_id($tagcontextid),
+                $tagname
-                    $tagname);
+            );
+        }
+    }
                     $DB->set_field('question_categories', 'parent', $newparent, array('id' => $dbcat->id));
                 } else {
                     $newparent = 0; // No ctx match for both cats, no parent relationship
+                }
+            }
+            $context = \core\context::instance_by_id($dbcat->contextid);
             // Here with $newparent empty, problem with contexts or remapping, set it to top cat
-            if (!$newparent && $dbcat->parent) {
+            if (!$newparent && $dbcat->parent && $context->contextlevel === CONTEXT_MODULE) {
                 $topcat = question_get_top_category($dbcat->contextid, true);
                 if ($dbcat->parent != $topcat->id) {
                     $DB->set_field('question_categories', 'parent', $topcat->id, array('id' => $dbcat->id));
+                }
+            }
         $after35 = $this->task->backup_release_compare('3.5', '>=') && $this->task->backup_version_compare(20180205, '>');
+        $contexts = restore_dbops::restore_get_question_banks($this->get_restoreid(), CONTEXT_MODULE);
+        foreach ($contexts as $contextid => $contextlevel) {
-        $contexts = restore_dbops::restore_get_question_banks($this->get_restoreid(), CONTEXT_MODULE);
+            if (!$newcontext = restore_dbops::get_backup_ids_record($this->get_restoreid(), 'context', $contextid)) {
+                // The bank for the question categories required by this module was not included in the backup,
-        foreach ($contexts as $contextid => $contextlevel) {
+                // but if that context still exists on the site and the user has access then point question references
-            // Only if context mapping exists (i.e. the module has been restored)
+                // to the originals.
-            if ($newcontext = restore_dbops::get_backup_ids_record($this->get_restoreid(), 'context', $contextid)) {
+                $originalcontext = context::instance_by_id($contextid, IGNORE_MISSING);
-                // Update all the qcats having their parentitemid set to the original contextid
+                if ($originalcontext && has_capability('mod/qbank:view', $originalcontext)) {
-                $modulecats = $DB->get_records_sql("SELECT itemid, newitemid, info
+                    $originalquestions = get_questions_category(question_get_top_category($contextid), false);
-                                                      FROM {backup_ids_temp}
+                    $targetcoursecontext = context_course::instance($this->get_courseid());
-                                                     WHERE backupid = ?
+                    foreach ($originalquestions as $originalquestion) {
+                        $backupids = restore_dbops::get_backup_ids_record(
-                                                       AND itemname = 'question_category'
+                            $this->get_restoreid(),
-                                                       AND parentitemid = ?", array($this->get_restoreid(), $contextid));
+                            'question',
-                $top = question_get_top_category($newcontext->newitemid, true);
+                            $originalquestion->id,
+                        );
-                $oldtopid = 0;
+                        if (!$backupids) {
-                $categoryids = [];
+                            continue; // This question was not included in the backup.
-                foreach ($modulecats as $modulecat) {
+                        }
+                        // Restored question references will point to the restored copy of the question. Select question references
-                    // Before 3.5, question categories could be created at top level.
+                        // that point to that restored copy, only if they are within the target course's context, so we can update
-                    // From 3.5 onwards, all question categories should be a child of a special category called the "top" category.
+                        // them to point to the original question.
-                    $info = backup_controller_dbops::decode_backup_temp_info($modulecat->info);
+                        $conpathlike = $DB->sql_like('con.path', '?');
-                    if ($after35 && empty($info->parent)) {
+                        $references = $DB->get_records_sql(
+                            "SELECT qr.id, qr.questionbankentryid
+                               FROM {question_references} qr
-                        $oldtopid = $modulecat->newitemid;
+                                    JOIN {context} con ON qr.usingcontextid = con.id
+                                    JOIN {question_versions} qv ON qv.questionbankentryid = qr.questionbankentryid
-                        $modulecat->newitemid = $top->id;
+                              WHERE qv.questionid = ?
-                    } else {
+                                    AND {$conpathlike}",
-                        $cat = new stdClass();
+                            [
+                                $backupids->newitemid,
+                                $targetcoursecontext->path . '/%',
-                        $cat->id = $modulecat->newitemid;
+                            ],
-                        $cat->contextid = $newcontext->newitemid;
+                        );
-                        if (empty($info->parent)) {
+                        if (empty($references)) {
+                            continue;
+                        }
-                            $cat->parent = $top->id;
+                        [$refin, $refparams] = $DB->get_in_or_equal(array_keys($references));
+                        $DB->set_field_select(
+                            'question_references',
-                        }
+                            'questionbankentryid',
+                            $DB->get_field('question_versions', 'questionbankentryid', ['questionid' => $backupids->itemid]),
+                            'id ' . $refin,
-                        $DB->update_record('question_categories', $cat);
+                            $refparams,
+                        );
+                    }
+                    continue;
+                }
+                // We have no target question bank so create a default bank for categories without a module to attach to.
+                // This can occur when a quiz backup contains references to a question bank module,
+                // that was not included in the backup and does not exist in the site being restored to.
+                $course = get_course($this->get_courseid());
+                $defaultqbank = core_question\local\bank\question_bank_helper::get_default_open_instance_system_type($course, true);
+                $context = context_module::instance($defaultqbank->id);
-                        $categoryids[] = (int)$cat->id;
+                $newcontext = new stdClass();
+                $newcontext->newitemid = $context->id;
+            }
+            // Only if context mapping exists (i.e. the module has been restored)
+            // Update all the qcats having their parentitemid set to the original contextid.
+            $modulecats = $DB->get_records_sql("SELECT itemid, newitemid, info
-                    }
+                                                  FROM {backup_ids_temp}
+                                                 WHERE backupid = ?
+                                                   AND itemname = 'question_category'
+                                                   AND parentitemid = ?",
+                [$this->get_restoreid(), $contextid]
+            );
+            $top = question_get_top_category($newcontext->newitemid, true);
+            $oldtopid = 0;
+            $categoryids = [];
-                    // And set new contextid (and maybe update newitemid) also in question_category mapping (will be
+            foreach ($modulecats as $modulecat) {
+                // Before 3.5, question categories could be created at top level.
+                // From 3.5 onwards, all question categories should be a child of a special category called the "top" category.
+                $info = backup_controller_dbops::decode_backup_temp_info($modulecat->info);
+                if ($after35 && empty($info->parent)) {
+                    $oldtopid = $modulecat->newitemid;
+                    $modulecat->newitemid = $top->id;
+                } else {
-                    // used by {@link restore_create_question_files} later.
+                    $cat = new stdClass();
+                    $cat->id = $modulecat->newitemid;
+                    $cat->contextid = $newcontext->newitemid;
+                    if (empty($info->parent)) {
+                        $cat->parent = $top->id;
+                    }
-                    restore_dbops::set_backup_ids_record($this->get_restoreid(), 'question_category', $modulecat->itemid,
+                    $DB->update_record('question_categories', $cat);
+                    $categoryids[] = (int) $cat->id;
+                }
+                // And set new contextid (and maybe update newitemid) also in question_category mapping (will be
+                // used by {@see restore_create_question_files} later.
+                restore_dbops::set_backup_ids_record($this->get_restoreid(),
+                    'question_category',
+                    $modulecat->itemid,
+                    $modulecat->newitemid,
+                    $newcontext->newitemid
-                            $modulecat->newitemid, $newcontext->newitemid);
+                );
-                }
+            }
-                // Update the context id of any tags applied to any questions in these categories.
+            // Update the context id of any tags applied to any questions in these categories.
-                if ($categoryids) {
+            if ($categoryids) {
-                    [$categorysql, $categoryidparams] = $DB->get_in_or_equal($categoryids, SQL_PARAMS_NAMED);
+                [$categorysql, $categoryidparams] = $DB->get_in_or_equal($categoryids, SQL_PARAMS_NAMED);
-                    $sqlupdate = "UPDATE {tag_instance}
+                $sqlupdate = "UPDATE {tag_instance}
-                                     SET contextid = :newcontext
+                                 SET contextid = :newcontext
-                                   WHERE component = :component
+                               WHERE component = :component
-                                         AND itemtype = :itemtype
+                                 AND itemtype = :itemtype
-                                         AND itemid IN (SELECT DISTINCT bi.newitemid as questionid
+                                 AND itemid IN (SELECT DISTINCT bi.newitemid as questionid
-                                                          FROM {backup_ids_temp} bi
+                                FROM {backup_ids_temp} bi
-                                                          JOIN {question} q ON q.id = bi.newitemid
+                                JOIN {question} q ON q.id = bi.newitemid
-                                                          JOIN {question_versions} qv ON qv.questionid = q.id
+                                JOIN {question_versions} qv ON qv.questionid = q.id
-                                                          JOIN {question_bank_entries} qbe ON qbe.id = qv.questionbankentryid
+                                JOIN {question_bank_entries} qbe ON qbe.id = qv.questionbankentryid
-                                                         WHERE bi.backupid = :backupid AND bi.itemname = 'question_created'
+                               WHERE bi.backupid = :backupid AND bi.itemname = 'question_created'
-                                                               AND qbe.questioncategoryid {$categorysql}) ";
+                                 AND qbe.questioncategoryid {$categorysql}) ";
-                    $params = [
+                $params = [
                         'newcontext' => $newcontext->newitemid,
                         'component' => 'core_question',
                         'itemtype' => 'question',
                         'backupid' => $this->get_restoreid(),
-                    ];
+                ];
-                    $params += $categoryidparams;
+                $params += $categoryidparams;
-                    $DB->execute($sqlupdate, $params);
+                $DB->execute($sqlupdate, $params);
-                    // As explained in {@see restore_quiz_activity_structure_step::process_quiz_question_legacy_instance()}
+                // As explained in {@see restore_quiz_activity_structure_step::process_quiz_question_legacy_instance()}
-                    // question_set_references relating to random questions restored from old backups,
+                // question_set_references relating to random questions restored from old backups,
-                    // which pick from context_module question_categores, will have been restored with the wrong questioncontextid.
+                // which pick from context_module question_categores, will have been restored with the wrong questioncontextid.
-                    // So, now, we need to find those, and updated the questioncontextid.
+                // So, now, we need to find those, and updated the questioncontextid.
-                    // We can only find them by picking apart the filter conditions, and seeign which categories they refer to.
+                // We can only find them by picking apart the filter conditions, and seeign which categories they refer to.
-                    // We need to check all the question_set_references belonging to this context_module.
+                // We need to check all the question_set_references belonging to this context_module.
-                    $references = $DB->get_records('question_set_references', ['usingcontextid' => $newcontext->newitemid]);
+                $references = $DB->get_records('question_set_references', ['usingcontextid' => $newcontext->newitemid]);
-                    foreach ($references as $reference) {
+                foreach ($references as $reference) {
-                        $filtercondition = json_decode($reference->filtercondition);
+                    $filtercondition = json_decode($reference->filtercondition);
-                        if (!empty($filtercondition->questioncategoryid) &&
+                    if (!empty($filtercondition->questioncategoryid) &&
-                                in_array($filtercondition->questioncategoryid, $categoryids)) {
+                            in_array($filtercondition->questioncategoryid, $categoryids)) {
-                            // This is one of ours, update the questionscontextid.
+                        // This is one of ours, update the questionscontextid.
-                            $DB->set_field('question_set_references',
-                                'questionscontextid', $newcontext->newitemid,
+                        $DB->set_field('question_set_references',
-                                ['id' => $reference->id]);
+                            'questionscontextid', $newcontext->newitemid,
+                            ['id' => $reference->id]);
-                        }
+                    }
-                    }
+                }
-                }
+            }
+            // Now set the parent id for the question categories that were in the top category in the course context
+            // and have been moved now.
-                // Now set the parent id for the question categories that were in the top category in the course context
+            if ($oldtopid) {
-                // and have been moved now.
+                $DB->set_field('question_categories',
-                if ($oldtopid) {
+                    'parent',
-                    $DB->set_field('question_categories', 'parent', $top->id,
+                    $top->id,
+                    ['contextid' => $newcontext->newitemid, 'parent' => $oldtopid]
+                );
+            }
+        }
+        // Remove any remaining course-level question categories from the restored course.
+        $coursecatsql = "
+            SELECT qc.id AS categoryid
+              FROM {question_categories} qc
+              JOIN {context} c ON c.id = qc.contextid
+             WHERE c.contextlevel = :courselevel AND c.instanceid = :courseid
+        ";
+        $DB->delete_records_subquery(
+            'question_categories',
+            'id',
-                            array('contextid' => $newcontext->newitemid, 'parent' => $oldtopid));
+            'categoryid',
             $coursecatsql,
             ['courselevel' => context_course::LEVEL, 'courseid' => $this->task->get_courseid()]
         );
      * @param array $data the data from the XML file.
      */
     public function process_question_set_reference($data) {
         global $DB;
         $data = (object) $data;
+        $owncontext = $data->usingcontextid == $data->questionscontextid;
         $data->usingcontextid = $this->get_mappingid('context', $data->usingcontextid);
         $data->itemid = $this->get_new_parentid('quiz_question_instance');
         $filtercondition = json_decode($data->filtercondition, true);
                     $filtercondition);
+        }
         // Map category id used for category filter condition and corresponding context id.
+        $oldcategoryid = $filtercondition['filter']['category']['values'][0];
+        // Decide if we're going to refer back to the original category, or to the new category.
+        // Are we restoring to a different site?
+        // Has the original context or category been deleted?
+        // Did the old category belong to the same context as the original set reference?
+        // Are we allowed to use its questions?
+        $questionscontext = context::instance_by_id($data->questionscontextid, IGNORE_MISSING);
+        if (
+            !$this->get_task()->is_samesite()
+            || !$questionscontext
+            || !$DB->record_exists('question_categories', ['id' => $oldcategoryid])
+            || $owncontext
+            || !has_capability('moodle/question:useall', $questionscontext)
-        $oldcategoryid = $filtercondition['filter']['category']['values'][0];
+        ) {
-        $newcategoryid = $this->get_mappingid('question_category', $oldcategoryid);
+            $newcategoryid = $this->get_mappingid('question_category', $oldcategoryid);
+            $filtercondition['filter']['category']['values'][0] = $newcategoryid;
         $filtercondition['filter']['category']['values'][0] = $newcategoryid;
         if ($context = $this->get_mappingid('context', $data->questionscontextid)) {
             $data->questionscontextid = $context;

Proyectos de Subversion Moodle

(root)/backup/moodle2/restore_stepslib.php – Rev 11 → 1441