Proyectos de Subversion Moodle

    /** @var string XML path in the questions.xml backup file to question categories. */

    protected const CATEGORY_PATH = '/question_categories/question_category';

    /** @var string XML path in the questions.xml to question elements within question_category (Moodle 4.0+). */

    protected const QUESTION_SUBPATH =

        '/question_bank_entries/question_bank_entry/question_version/question_versions/questions/question';

    /** @var string XML path in the questions.xml to question elements within question_category (before Moodle 4.0). */

    protected const LEGACY_QUESTION_SUBPATH = '/questions/question';

    /** @var string String for concatenating data into a string for hashing.*/

    protected const HASHDATA_SEPARATOR = '|HASHDATA|';

    protected string $restoreid;

        parent::__construct();

        $this->add_path(self::CATEGORY_PATH);

        $this->add_path(self::CATEGORY_PATH . self::QUESTION_SUBPATH, true);

        $this->add_path(self::CATEGORY_PATH . self::LEGACY_QUESTION_SUBPATH, true);

        // Add all sub-elements, including those from plugins, as grouped paths with the question tag so that

        // we can create a hash of all question data for comparison with questions in the database.

        $this->add_path(self::CATEGORY_PATH . self::LEGACY_QUESTION_SUBPATH . '/question_hints');

        $this->add_path(self::CATEGORY_PATH . self::QUESTION_SUBPATH . '/question_hints/question_hint');

        $this->add_path(self::CATEGORY_PATH . self::LEGACY_QUESTION_SUBPATH . '/question_hints/question_hint');

        $connectionpoint = new restore_path_element('question', self::CATEGORY_PATH . self::QUESTION_SUBPATH);

        foreach (\core\plugin_manager::instance()->get_plugins_of_type('qtype') as $qtype) {

            $restore = $this->get_qtype_restore($qtype->name);

            if (!$restore) {

                continue;

            }

            $structure = $restore->define_plugin_structure($connectionpoint);

            foreach ($structure as $element) {

                $subpath = str_replace(self::CATEGORY_PATH . self::QUESTION_SUBPATH . '/', '', $element->get_path());

                $pathparts = explode('/', $subpath);

                $path = self::CATEGORY_PATH . self::QUESTION_SUBPATH;

                $legacypath = self::CATEGORY_PATH . self::LEGACY_QUESTION_SUBPATH;

                foreach ($pathparts as $part) {

                    $path .= '/' . $part;

                    $legacypath .= '/' . $part;

                    if (!in_array($path, $this->paths)) {

                        $this->add_path($path);

                        $this->add_path($legacypath);

                    }

                }

            $this->lastcatid = $itemid;

            $info = (object) array_filter($data['tags'], fn($tag) => !is_array($tag));

            $itemname = 'question';

            $itemid   = $info->id;

            $parentitemid = $this->lastcatid;

            $restore = $this->get_qtype_restore($data['tags']['qtype']);

            if ($restore) {

                $questiondata = $restore->convert_backup_to_questiondata($data['tags']);

            } else {

    /**

     * Load and instantiate the restore class for the given question type.

     *

     * If there is no restore class, null is returned.

     *

     * @param string $qtype The question type name (no qtype_ prefix)

     * @return ?restore_qtype_plugin

     */

    protected static function get_qtype_restore(string $qtype): ?restore_qtype_plugin {

        global $CFG;

        $step = new restore_quiz_activity_structure_step('questions', 'question.xml');

        $filepath = "{$CFG->dirroot}/question/type/{$qtype}/backup/moodle2/restore_qtype_{$qtype}_plugin.class.php";

        if (!file_exists($filepath)) {

            return null;

        }

        require_once($filepath);

        $restoreclass = "restore_qtype_{$qtype}_plugin";

        if (!class_exists($restoreclass)) {

            return null;

        }

        return new $restoreclass('qtype', $qtype, $step);

    }

    /**

     * Given a data structure containing the data for a question, reduce it to a flat array and return a sha1 hash of the data.

     *

     * @param stdClass $questiondata An array containing all the data for a question, including hints and qtype plugin data.

     * @param ?backup_xml_transformer $transformer If provided, run the backup transformer process on all text fields. This ensures

     *     that values from the database are compared like-for-like with encoded values from the backup.

     * @return string A sha1 hash of all question data, normalised and concatenated together.

     */

    public static function generate_question_identity_hash(

        stdClass $questiondata,

        ?backup_xml_transformer $transformer = null,

    ): string {

        $questiondata = clone($questiondata);

        $restore = self::get_qtype_restore($questiondata->qtype);

        if ($restore) {

            $restore->define_plugin_structure(new restore_path_element('question', self::CATEGORY_PATH . self::QUESTION_SUBPATH));

            // Combine default exclusions with those specified by the plugin.

            $questiondata = $restore->remove_excluded_question_data($questiondata, $restore->get_excluded_identity_hash_fields());

        } else {

            // The qtype has no restore class, use the default reduction method.

            $questiondata = restore_qtype_plugin::remove_excluded_question_data($questiondata);

        }

        // Convert questiondata to a flat array of values.

        $hashdata = [];

        // Convert the object to a multi-dimensional array for compatibility with array_walk_recursive.

        $questiondata = json_decode(json_encode($questiondata), true);

        array_walk_recursive($questiondata, function($value) use (&$hashdata) {

            // Normalise data types. Depending on where the data comes from, it may be a mixture of nulls, strings,

            // ints and floats. Convert everything to strings, then all numbers to floats to ensure we are doing

            // like-for-like comparisons without losing accuracy.

            $value = (string) $value;

            if (is_numeric($value)) {

                $value = (float) ($value);

            } else if (str_contains($value, "\r\n")) {

                // Normalise line breaks.

                $value = str_replace("\r\n", "\n", $value);

            }

            $hashdata[] = $value;

        });

        sort($hashdata, SORT_STRING);

        $hashstring = implode(self::HASHDATA_SEPARATOR, $hashdata);

        if ($transformer) {

            $hashstring = $transformer->process($hashstring);

            // Need to re-sort the hashdata with the transformed strings.

            $hashdata = explode(self::HASHDATA_SEPARATOR, $hashstring);

            sort($hashdata, SORT_STRING);

            $hashstring = implode(self::HASHDATA_SEPARATOR, $hashdata);

        }

        return sha1($hashstring);

    }