WebSVN – Moodle – Diff – /backup/util/dbops/restore_dbops.class.php

      * @param string $restoreid Restore id
      * @param string $inforeffile File path
      * @param \core\progress\base $progress Progress tracker
      */
     public static function load_inforef_to_tempids($restoreid, $inforeffile,
-            \core\progress\base $progress = null) {
+            ?\core\progress\base $progress = null) {
         if (!file_exists($inforeffile)) { // Shouldn't happen ever, but...
             throw new backup_helper_exception('missing_inforef_xml_file', $inforeffile);
      * @param string $restoreid Restore id
      * @param string $usersfile File path
      * @param \core\progress\base $progress Progress tracker
      */
     public static function load_users_to_tempids($restoreid, $usersfile,
-            \core\progress\base $progress = null) {
+            ?\core\progress\base $progress = null) {
         if (!file_exists($usersfile)) { // Shouldn't happen ever, but...
             throw new backup_helper_exception('missing_users_xml_file', $usersfile);
      * This function will process all the question banks present in restore
      * at some contextlevel (from CONTEXT_SYSTEM to CONTEXT_MODULE), finding
      * the target contexts where each bank will be restored and returning
      * warnings/errors as needed.
+     *
+     * Question categories at CONTEXT_SYSTEM, CONTEXT_COURSE, and CONTEXT_COURSECAT
-     * Some contextlevels (system, coursecat), will delegate process to
+     * are now deprecated, but we still have to account for them in backup files
-     * course level if any problem is found (lack of permissions, non-matching
+     * made with pre-deprecated code. As such, any categories in backup files that used
-     * target context...). Other contextlevels (course, module) will
+     * to target these contexts will now be attached to a 'fallback' qbank
-     * cause return error if some problem is found.
+     * instance on the course being restored.
+     *
      * At the end, if no errors were found, all the categories in backup_temp_ids
      * will be pointing (parentitemid) to the target context where they must be
      * created later in the restore process.
+     *
      * @param bool $samesite True if restore is to same site
      * @param int $contextlevel (CONTEXT_SYSTEM, etc.)
      * @return array A separate list of all error and warnings detected
      */
     public static function prechek_precheck_qbanks_by_level($restoreid, $courseid, $userid, $samesite, $contextlevel) {
-        global $DB;
+        global $DB, $CFG;
         // To return any errors and warnings found
-        $errors   = array();
+        $errors = [];
-        $warnings = array();
-        // Specify which fallbacks must be performed
-        $fallbacks = array(
-            CONTEXT_SYSTEM => CONTEXT_COURSE,
-            CONTEXT_COURSECAT => CONTEXT_COURSE);
+        $warnings = [];
         /** @var restore_controller $rc */
         $rc = restore_controller_dbops::load_controller($restoreid);
         $plan = $rc->get_plan();
+        $after35 = $plan->backup_release_compare('3.5', '>=') && $plan->backup_version_compare(20180205, '>');
-        $after35 = $plan->backup_release_compare('3.5', '>=') && $plan->backup_version_compare(20180205, '>');
+        $rc->destroy(); // Always need to destroy.
-        $rc->destroy(); // Always need to destroy.
+        /*
-        // For any contextlevel, follow this process logic:
+          For any contextlevel, follow this process logic:
-        //
-        // 0) Iterate over each context (qbank)
+) Iterate over each context (qbank)
-        // 1) Iterate over each qcat in the context, matching by stamp for the found target context
-        //     2a) No match, check if user can create qcat and q
+) Iterate over each qcat in the context, matching by stamp for the found target context
-        //         3a) User can, mark the qcat and all dependent qs to be created in that target context
-        //         3b) User cannot, check if we are in some contextlevel with fallback
+a) No match, check if user can create qcat and q
-        //             4a) There is fallback, move ALL the qcats to fallback, warn. End qcat loop
+a) User can, mark the qcat and all dependent qs to be created in that target context
-        //             4b) No fallback, error. End qcat loop.
+b) User cannot. Move ALL the qcats to a default qbank instance, warn. End qcat loop
-        //     2b) Match, mark qcat to be mapped and iterate over each q, matching by stamp and version
-        //         5a) No match, check if user can add q
+b) Match, mark qcat to be mapped and iterate over each q, matching by stamp and version
-        //             6a) User can, mark the q to be created
-        //             6b) User cannot, check if we are in some contextlevel with fallback
+a) No match, check if user can add q
-        //                 7a) There is fallback, move ALL the qcats to fallback, warn. End qcat loop
+a) User can, mark the q to be created
-        //                 7b) No fallback, error. End qcat loop
+b) User cannot. Move ALL the qcats to a default qbank instance, warn. End qcat loop
+b) Random question, must always create new.
-        //         5b) Random question, must always create new.
+c) Match, mark q to be mapped
-        //         5c) Match, mark q to be mapped
+) Check if backup is from Moodle >= 3.5 and error if more than one top-level category in the context.
-        // 8) Check if backup is from Moodle >= 3.5 and error if more than one top-level category in the context.
+         */
         // Get all the contexts (question banks) in restore for the given contextlevel
         $contexts = self::restore_get_question_banks($restoreid, $contextlevel);
         // 0) Iterate over each context (qbank)
         foreach ($contexts as $contextid => $contextlevel) {
             // Init some perms
             $canmanagecategory = false;
-            $canadd            = false;
+            $canadd = false;
             // Top-level category counter.
             $topcats = 0;
             // get categories in context (bank)
             $categories = self::restore_get_question_categories($restoreid, $contextid, $contextlevel);
             // cache permissions if $targetcontext is found
             if ($targetcontext = self::restore_find_best_target_context($categories, $courseid, $contextlevel)) {
                 $canmanagecategory = has_capability('moodle/question:managecategory', $targetcontext, $userid);
-                $canadd            = has_capability('moodle/question:add', $targetcontext, $userid);
+                $canadd = has_capability('moodle/question:add', $targetcontext, $userid);
+            }
             // 1) Iterate over each qcat in the context, matching by stamp for the found target context
             foreach ($categories as $category) {
                 if ($category->parent == 0) {
                     $topcats++;
+                }
                 $matchcat = false;
-                $matchcat = false;
+                if ($targetcontext) {
-                if ($targetcontext) {
+                    $matchcat = $DB->get_record('question_categories', [
-                    $matchcat = $DB->get_record('question_categories', array(
+                            'contextid' => $targetcontext->id,
                         if ($contextlevel == CONTEXT_MODULE) {
                             $parentitemid = null; // null means "not modify" a.k.a. leave original contextid
+                        }
                         self::set_backup_ids_record($restoreid, 'question_category', $category->id, 0, $parentitemid);
                         // Nothing else to mark, newitemid = 0 means create
-                    // 3b) User cannot, check if we are in some contextlevel with fallback
                     } else {
-                        // 4a) There is fallback, move ALL the qcats to fallback, warn. End qcat loop
+                        // 3b) User cannot. Move ALL the qcats to the fallback i.e. a default qbank instance, warn. End qcat loop.
+                        $course = get_course($courseid);
+                        $course->fullname = get_string('courserestore', 'question');
+                        $module =
+                            core_question\local\bank\question_bank_helper::get_default_open_instance_system_type($course, true);
-                        if (array_key_exists($contextlevel, $fallbacks)) {
+                        $fallbackcontext = $module->context;
-                            foreach ($categories as $movedcat) {
+                        foreach ($categories as $movedcat) {
-                                $movedcat->contextlevel = $fallbacks[$contextlevel];
+                            $movedcat->contextlevel = $contextlevel;
-                                self::set_backup_ids_record($restoreid, 'question_category', $movedcat->id, 0, $contextid, $movedcat);
+                            self::set_backup_ids_record($restoreid,
-                                // Warn about the performed fallback
+                                'question_category',
-                                $warnings[] = get_string('qcategory2coursefallback', 'backup', $movedcat);
+                                $movedcat->id,
-                            }
+,
-                        // 4b) No fallback, error. End qcat loop.
+                                $fallbackcontext->id,
+                                $movedcat
-                        } else {
+                            );
+                            // Warn about the performed fallback.
-                            $errors[] = get_string('qcategorycannotberestored', 'backup', $category);
+                            $warnings[] = get_string('qcategory2coursefallback', 'backup', $movedcat);
+                        }
-                        break; // out from qcat loop (both 4a and 4b), we have decided about ALL categories in context (bank)
+                        break; // Out from qcat loop (both 3a and 3b), we have decided about ALL categories in context (bank).
+                    }
-                // 2b) Match, mark qcat to be mapped and iterate over each q, matching by stamp and version
+                    // 2b) Match, mark qcat to be mapped and iterate over each q, matching by stamp and version
                 } else {
                     self::set_backup_ids_record($restoreid, 'question_category', $category->id, $matchcat->id, $targetcontext->id);
+                    $questions = self::restore_get_questions($restoreid, $category->id);
-                    $questions = self::restore_get_questions($restoreid, $category->id);
+                    $transformer = self::get_backup_xml_transformer($courseid);
                     // Collect all the questions for this category into memory so we only talk to the DB once.
-                    $questioncache = $DB->get_records_sql_menu('SELECT q.id,
+                    $recordset = $DB->get_recordset_sql(
-                                                                       q.stamp
+                        "SELECT q.*
-                                                                  FROM {question} q
+                           FROM {question} q
-                                                                  JOIN {question_versions} qv
+                           JOIN {question_versions} qv ON qv.questionid = q.id
+                           JOIN {question_bank_entries} qbe ON qbe.id = qv.questionbankentryid
+                           JOIN {question_categories} qc ON qc.id = qbe.questioncategoryid
+                          WHERE qc.id = ?",
+                        [$matchcat->id],
+                    );
+                    // Compute a hash of question and answer fields to differentiate between identical stamp-version questions.
-                                                                    ON qv.questionid = q.id
+                    $questioncache = [];
+                    foreach ($recordset as $question) {
+                        $question->export_process = true; // Include all question options required for export.
-                                                                  JOIN {question_bank_entries} qbe
+                        get_question_options($question);
+                        unset($question->export_process);
+                        // Remove some additional properties from get_question_options() that isn't included in backups
-                                                                    ON qbe.id = qv.questionbankentryid
+                        // before we produce the identity hash.
-                                                                  JOIN {question_categories} qc
+                        unset($question->categoryobject);
+                        unset($question->questioncategoryid);
+                        $cachekey = restore_questions_parser_processor::generate_question_identity_hash($question, $transformer);
+                        $questioncache[$cachekey] = $question->id;
                                                                     ON qc.id = qbe.questioncategoryid
-                                                                 WHERE qc.id = ?', array($matchcat->id));
+                    $recordset->close();
                     foreach ($questions as $question) {
-                        if (isset($questioncache[$question->stamp." ".$question->version])) {
+                        if (isset($questioncache[$question->questionhash])) {
-                            $matchqid = $questioncache[$question->stamp." ".$question->version];
+                            $matchqid = $questioncache[$question->questionhash];
                         } else {
                             $matchqid = false;
                         }
-                        // 5a) No match, check if user can add q
+                        // 4a) No match, check if user can add q
                         if (!$matchqid) {
-                            // 6a) User can, mark the q to be created
-                            if ($canadd) {
-                                // Nothing to mark, newitemid means create
+                            // 5a) User can, mark the q to be created
+                            if ($canadd) {
+                                // Nothing to mark, newitemid means create
+                            } else {
+                                // 5b) User cannot.
+                                // Move ALL the qcats to the fallback i.e. a default qbank instance, warn. End qcat loop.
+                                $course = get_course($courseid);
+                                $course->fullname = get_string('courserestore', 'question');
+                                $module = core_question\local\bank\question_bank_helper::get_default_open_instance_system_type(
-                             // 6b) User cannot, check if we are in some contextlevel with fallback
+                                    $course,
-                            } else {
+                                    true
-                                // 7a) There is fallback, move ALL the qcats to fallback, warn. End qcat loo
+                                );
-                                if (array_key_exists($contextlevel, $fallbacks)) {
+                                $fallbackcontext = $module->context;
-                                    foreach ($categories as $movedcat) {
+                                foreach ($categories as $movedcat) {
-                                        $movedcat->contextlevel = $fallbacks[$contextlevel];
+                                    $movedcat->contextlevel = $contextlevel;
-                                        self::set_backup_ids_record($restoreid, 'question_category', $movedcat->id, 0, $contextid, $movedcat);
+                                    self::set_backup_ids_record($restoreid,
-                                        // Warn about the performed fallback
-                                        $warnings[] = get_string('question2coursefallback', 'backup', $movedcat);
+                                        'question_category',
+                                        $movedcat->id,
-                                    }
+,
+                                        $fallbackcontext->id,
+                                        $movedcat
-                                // 7b) No fallback, error. End qcat loop
+                                    );
-                                } else {
+                                    // Warn about the performed fallback.
+                                    $warnings[] = get_string('question2coursefallback', 'backup', $movedcat);
                                     $errors[] = get_string('questioncannotberestored', 'backup', $question);
-                                }
+                                // Out from qcat loop (both 5a and 5b), we have decided about ALL categories in context (bank).
-                                break 2; // out from qcat loop (both 7a and 7b), we have decided about ALL categories in context (bank)
+                                break 2;
+                            }
-                        // 5b) Random questions must always be newly created.
+                            // 4b) Random questions must always be newly created.
                         } else if ($question->qtype == 'random') {
                             // Nothing to mark, newitemid means create
-                        // 5c) Match, mark q to be mapped.
+                            // 4c) Match, mark q to be mapped.
                         } else {
                             self::set_backup_ids_record($restoreid, 'question', $question->id, $matchqid);
+                        }
+                    }
+                }
+            }
-            // 8) Check if backup is made on Moodle >= 3.5 and there are more than one top-level category in the context.
+            // 6) Check if backup is made on Moodle >= 3.5 and there are more than one top-level category in the context.
             if ($after35 && $topcats > 1) {
                 $errors[] = get_string('restoremultipletopcats', 'question', $contextid);
+            }
         return $results;
+    }
+    /**
-    /**
+     * Calculates the best existing context to restore one collection of qcats.
+     * Uses the backup category stamp to match the target category stamp
+     * and categories must all belong to the same context (question bank).
-     * Calculates the best context found to restore one collection of qcats,
+     *
+     * @param array $categories categories to find target context for
+     * @param int $courseid course to restore to
-     * al them belonging to the same context (question bank), returning the
+     * @param int $contextlevel contextlevel to search for the target context
-     * target context found (object) or false
+     * @return bool|\core\context target context or false if no target context found
      */
     public static function restore_find_best_target_context($categories, $courseid, $contextlevel) {
-        global $DB;
-        $targetcontext = false;
-        // Depending of $contextlevel, we perform different actions
-        switch ($contextlevel) {
-             // For system is easy, the best context is the system context
-             case CONTEXT_SYSTEM:
-                 $targetcontext = context_system::instance();
-                 break;
+        global $DB;
-             // For coursecat, we are going to look for stamps in all the
-             // course categories between CONTEXT_SYSTEM and CONTEXT_COURSE
-             // (i.e. in all the course categories in the path)
-             //
+        $targetcontext = false;
-             // And only will return one "best" target context if all the
-             // matches belong to ONE and ONLY ONE context. If multiple
+        // If context module we need to find any existing module instances with categories matching the category stamps
-             // matches are found, that means that there is some annoying
-             // qbank "fragmentation" in the categories, so we'll fallback
+        // from the backup. If multiple matches are found, that means that there is some annoying
-             // to create the qbank at course level
+        // qbank "fragmentation" in the categories, so we'll fall back
-             case CONTEXT_COURSECAT:
+        // to creating a qbank instance at course level and putting the categories there.
-                 // Build the array of stamps we are going to match
+        if ($contextlevel == CONTEXT_MODULE) {
-                 $stamps = array();
+            $stamps = [];
+            foreach ($categories as $category) {
-                 foreach ($categories as $category) {
+                $stamps[] = $category->stamp;
-                     $stamps[] = $category->stamp;
+            }
-                 }
-                 $contexts = array();
-                 // Build the array of contexts we are going to look
+            $modinfo = get_fast_modinfo($courseid);
-                 $systemctx = context_system::instance();
-                 $coursectx = context_course::instance($courseid);
+            // Get contextids of modules from the course that support publishing questions.
-                 $parentctxs = $coursectx->get_parent_context_ids();
-                 foreach ($parentctxs as $parentctx) {
+            $supportedcontextids = [];
-                     // Exclude system context
-                     if ($parentctx == $systemctx->id) {
+            foreach ($modinfo->get_cms() as $cm) {
+                if (plugin_supports('mod', $cm->modname, FEATURE_PUBLISHES_QUESTIONS, false)) {
-                         continue;
+                    $supportedcontextids[] = $cm->context->id;
-                     }
-                     $contexts[] = $parentctx;
+                }
-                 }
+            }
-                 if (!empty($stamps) && !empty($contexts)) {
-                     // Prepare the query
+            if (!empty($stamps) && !empty($supportedcontextids)) {
-                     list($stamp_sql, $stamp_params) = $DB->get_in_or_equal($stamps);
+                [$stampsql, $stampparams] = $DB->get_in_or_equal($stamps);
-                     list($context_sql, $context_params) = $DB->get_in_or_equal($contexts);
+                [$contextsql, $contextparams] = $DB->get_in_or_equal($supportedcontextids);
-                     $sql = "SELECT DISTINCT contextid
+                $sql = "SELECT DISTINCT contextid
-                               FROM {question_categories}
+                          FROM {question_categories}
-                              WHERE stamp $stamp_sql
+                         WHERE stamp {$stampsql}
-                                AND contextid $context_sql";
+                           AND contextid {$contextsql}";
-                     $params = array_merge($stamp_params, $context_params);
+                $params = array_merge($stampparams, $contextparams);
-                     $matchingcontexts = $DB->get_records_sql($sql, $params);
+                $matchingcontexts = $DB->get_records_sql($sql, $params);
-                     // Only if ONE and ONLY ONE context is found, use it as valid target
+                // Only if ONE and ONLY ONE context is found, use it as valid target.
-                     if (count($matchingcontexts) == 1) {
-                         $targetcontext = context::instance_by_id(reset($matchingcontexts)->contextid);
-                     }
+                if (count($matchingcontexts) === 1) {
-                 }
-                 break;
-             // For course is easy, the best context is the course context
-             case CONTEXT_COURSE:
-                 $targetcontext = context_course::instance($courseid);
-                 break;
-             // For module is easy, there is not best context, as far as the
-             // activity hasn't been created yet. So we return context course
-             // for them, so permission checks and friends will work. Note this
+                    $targetcontext = context::instance_by_id(reset($matchingcontexts)->contextid);
-             // case is handled by {@link prechek_precheck_qbanks_by_level}
              // in an special way
+            }
-             case CONTEXT_MODULE:
+            // We don't have a target so set as course context until the module is created and then assign to the module context.
-                 $targetcontext = context_course::instance($courseid);
+            $targetcontext = $targetcontext ?: context_course::instance($courseid);
                  break;
      * @return array of result object
      */
     public static function send_files_to_pool($basepath, $restoreid, $component, $filearea,
             $oldcontextid, $dfltuserid, $itemname = null, $olditemid = null,
             $forcenewcontextid = null, $skipparentitemidctxmatch = false,
-            \core\progress\base $progress = null) {
+            ?\core\progress\base $progress = null) {
         global $DB, $CFG;
         $backupinfo = backup_general_helper::get_backup_information(basename($basepath));
      * @param int $userid User id
      * @param bool $samesite True if restore is to same site
      * @param \core\progress\base $progress Optional progress tracker
      */
     public static function process_included_users($restoreid, $courseid, $userid, $samesite,
-            \core\progress\base $progress = null) {
+            ?\core\progress\base $progress = null) {
         global $DB;
         // Just let precheck_included_users() to do all the hard work
                 $suffixfull  = '';
                 $suffixshort = '';
+            }
+            // Ensure we don't overflow maximum length of name fields, in multi-byte safe manner.
-            // Ensure we don't overflow maximum length of name fields, in multi-byte safe manner.
+            $currentfullname = core_text::substr($fullname, 0,
+                    \core_course\constants::FULLNAME_MAXIMUM_LENGTH - strlen($suffixfull)) . $suffixfull;
-            $currentfullname = core_text::substr($fullname, 0, 254 - strlen($suffixfull)) . $suffixfull;
+            $currentshortname = core_text::substr($shortname, 0,
-            $currentshortname = core_text::substr($shortname, 0, 100 - strlen($suffixshort)) . $suffixshort;
+                    \core_course\constants::SHORTNAME_MAXIMUM_LENGTH - strlen($suffixshort)) . $suffixshort;
             $coursefull  = $DB->get_record_select('course', 'fullname = ? AND id != ?',
                     array($currentfullname, $courseid), '*', IGNORE_MULTIPLE);
      * Deletes all of the content associated with the given course (courseid)
      * @param int $courseid
      * @param array $options
      * @return bool True for success
      */
-    public static function delete_course_content($courseid, array $options = null) {
+    public static function delete_course_content($courseid, ?array $options = null) {
         return remove_course_contents($courseid, false, $options);
+    }
     /**
      * @return bool
      */
     private static function password_should_be_discarded(#[\SensitiveParameter] string $password): bool {
         return (bool) preg_match('/^[0-9a-f]{32}$/', $password);
+    }
+    /**
+     * Load required classes and return a backup XML transformer for the specified course.
+     *
+     * These classes may not have been loaded if we're only doing a restore in the current process,
+     * so make sure we have them here.
+     *
+     * @param int $courseid
+     * @return backup_xml_transformer
+     */
+    protected static function get_backup_xml_transformer(int $courseid): backup_xml_transformer {
+        global $CFG;
+        require_once($CFG->dirroot . '/backup/util/includes/backup_includes.php');
+        require_once($CFG->dirroot . '/backup/moodle2/backup_plan_builder.class.php');
+        return new backup_xml_transformer($courseid);
+    }
+}
 /*
  * Exception class used by all the @dbops stuff

Proyectos de Subversion Moodle

(root)/backup/util/dbops/restore_dbops.class.php – Rev 1 → 1441