Proyectos de Subversion Moodle

use core\output\inplace_editable;

use mod_quiz\event\slot_mark_updated;

    /**

     * Placeholder string used when a question category is missing.

     */

    const MISSING_QUESTION_CATEGORY_PLACEHOLDER = 'missing_question_category';

    protected $canaddrandom = null;

    /** @var array the slotids => question categories array for all slots containing a random question. */

    protected $randomslotcategories = null;

    /** @var array the slotids => question tags array for all slots containing a random question. */

    protected $randomslottags = null;

    /** @var array an array of question banks course_modules records indexed by their associated contextid */

    /**

     * Update the question version for a given slot, if necessary.

     *

     * @param int $id ID of row from the quiz_slots table.

     * @param int|null $newversion The new question version for the slot.

     *                             A null value means 'Always latest'.

     * @return bool True if the version was updated, false if no update was required.

     * @throws coding_exception If the specified version does not exist.

     */

    public function update_slot_version(int $id, ?int $newversion): bool {

        global $DB;

        $slot = $this->get_slot_by_id($id);

        $context = $this->quizobj->get_context();

        $refparams = ['usingcontextid' => $context->id, 'component' => 'mod_quiz', 'questionarea' => 'slot', 'itemid' => $slot->id];

        $reference = $DB->get_record('question_references', $refparams, '*', MUST_EXIST);

        $oldversion = is_null($reference->version) ? null : (int) $reference->version;

        $reference->version = $newversion === 0 ? null : $newversion;

        $existsparams = ['questionbankentryid' => $reference->questionbankentryid, 'version' => $newversion];

        $versionexists = $DB->record_exists('question_versions', $existsparams);

        // We are attempting to switch to an existing version.

        // Verify that the version we want to switch to exists.

        if (!is_null($newversion) && !$versionexists) {

            throw new coding_exception(

                'Version: ' . $newversion . ' ' .

                'does not exist for question bank entry: ' . $reference->questionbankentryid

            );

        }

        if ($newversion === $oldversion) {

            return false;

        }

        $transaction = $DB->start_delegated_transaction();

        $DB->update_record('question_references', $reference);

        slot_version_updated::create([

            'context' => $this->quizobj->get_context(),

            'objectid' => $slot->id,

            'other' => [

                'quizid' => $this->get_quizid(),

                'previousversion' => $oldversion,

                'newversion' => $reference->version,

            ],

        ])->trigger();

        $transaction->allow_commit();

        return true;

    }

    /**

     * Get a human-readable description of a random slot.

     *

     * @param int $slotid id of slot.

     * @return string that can be used to display the random slot.

     */

    public function describe_random_slot(int $slotid): string {

        $this->ensure_random_slot_info_loaded();

        if (!isset($this->randomslotcategories[$slotid])) {

            throw new coding_exception('Called describe_random_slot on slot id ' .

                $slotid . ' which is not a random slot.');

        }

        // Build the random question name with categories and tags information and return.

        $a = new stdClass();

        $a->category = $this->randomslotcategories[$slotid];

        $stringid = 'randomqnamecat';

        if (!empty($this->randomslottags[$slotid])) {

            $a->tags = $this->randomslottags[$slotid];

            $stringid = 'randomqnamecattags';

        }

        return shorten_text(get_string($stringid, 'quiz', $a), 255);

    }

    /**

     * Ensure that {@see load_random_slot_info()} has been called, so the data is available.

     */

    protected function ensure_random_slot_info_loaded(): void {

        if ($this->randomslotcategories == null) {

            $this->load_random_slot_info();

        }

    }

    /**

     * Load information about the question categories and tags for all random slots,

     */

    protected function load_random_slot_info(): void {

        global $DB;

        // Find the random slots.

        $allslots = $this->get_slots();

        foreach ($allslots as $key => $slot) {

            if ($slot->qtype != 'random') {

                unset($allslots[$key]);

            }

        }

        if (empty($allslots)) {

            // No random slots. Nothing to do.

            $this->randomslotcategories = [];

            $this->randomslottags = [];

            return;

        }

        // Loop over all random slots to build arrays of the data we will need.

        $tagids = [];

        $questioncategoriesids = [];

        // An associative array of slotid. Example structure:

        // ['cat' => [values => catid, 'includesubcategories' => true, 'tag' => [tagid, tagid, ...]].

        $randomcategoriesandtags = [];

        foreach ($allslots as $slotid => $slot) {

            foreach ($slot->filtercondition as $name => $value) {

                if ($name !== 'filter') {

                    continue;

                }

                // Parse the filter condition.

                foreach ($value as $filteroption => $filtervalue) {

                    if ($filteroption === 'category') {

                        $randomcategoriesandtags[$slotid]['cat']['values'] = $questioncategoriesids[] = $filtervalue['values'][0];

                        $randomcategoriesandtags[$slotid]['cat']['includesubcategories'] =

                            $filtervalue['filteroptions']['includesubcategories'] ?? false;

                    }

                    if ($filteroption === 'qtagids') {

                        foreach ($filtervalue as $qtagidsoption => $qtagidsvalue) {

                            if ($qtagidsoption !== 'values') {

                                continue;

                            }

                            foreach ($qtagidsvalue as $qtagidsvaluevalue) {

                                $randomcategoriesandtags[$slotid]['tag'][] = $qtagidsvaluevalue;

                                $tagids[] = $qtagidsvaluevalue;

                            }

                        }

                    }

                }

            }

        }

        // Get names for all tags into a tagid => name array.

        $tags = \core_tag_tag::get_bulk($tagids, 'id, rawname');

        $tagnames = array_map(fn($tag) => $tag->get_display_name(), $tags);

        // Get names for all question categories.

        $categories = $DB->get_records_list('question_categories', 'id', $questioncategoriesids,

            'id', 'id, name, contextid, parent');

        // Now, put the data required for each slot into $this->randomslotcategories and $this->randomslottags.

        foreach ($randomcategoriesandtags as $slotid => $catandtags) {

            $qcategoryid = $catandtags['cat']['values'];

            if (!array_key_exists($qcategoryid, $categories)) {

                $this->randomslotcategories[$slotid] = self::MISSING_QUESTION_CATEGORY_PLACEHOLDER;

                continue;

            }

            $qcategory = $categories[$qcategoryid];

            $includesubcategories = $catandtags['cat']['includesubcategories'];

            $this->randomslotcategories[$slotid] = $this->get_used_category_description($qcategory, $includesubcategories);

            if (isset($catandtags['tag'])) {

                $slottagnames = [];

                foreach ($catandtags['tag'] as $tagid) {

                    $slottagnames[] = $tagnames[$tagid];

                }

                $this->randomslottags[$slotid] = implode(', ', $slottagnames);

            }

        }

    }

    /**

     * Returns a description of the used question category, taking into account the context and whether subcategories are

     * included.

     *

     * @param stdClass $qcategory The question category object containing category details.

     * @param bool $includesubcategories Whether subcategories are included.

     * @return string The generated description based on the used category.

     * @throws coding_exception If the context level is unsupported.

     */

    private function get_used_category_description(stdClass $qcategory, bool $includesubcategories): string {

        $context = \context::instance_by_id($qcategory->contextid);

        if ($context->contextlevel != CONTEXT_MODULE) {

            throw new coding_exception('Unsupported context.');

        }

        if ($qcategory->name === 'top') { // This is a "top" question category.

            if (!$includesubcategories) {

                // Question categories labeled as "top" cannot directly contain questions. If the subcategories that may

                // hold questions are excluded, the generated random questions will be invalid. Thus, return a description

                // that informs the user about the issues associated with these types of generated random questions.

                return get_string('randomfaultynosubcat', 'mod_quiz');

            }

            return get_string('randommodulewithsubcat', 'mod_quiz');

        }

        // Otherwise, return the description of the used standard question category, also indicating whether subcategories

        // are included.

        return $includesubcategories ? get_string('randomcatwithsubcat', 'mod_quiz', $qcategory->name) :

            $qcategory->name;

    }

    /**

     * Populate question_sources with cm records for later reference.

     *

     * @return void

     */

    private function populate_question_sources(): void {

        global $DB;

        $contextids = array_map(fn($question) => $question->contextid, $this->questions);

        [$insql, $inparams] = $DB->get_in_or_equal(array_unique($contextids));

        $sql = "

            SELECT c.id as contextid, cm.id, cm.course

              FROM {context} c

              JOIN {course_modules} cm ON cm.id = c.instanceid AND c.contextlevel = ?

             WHERE c.id {$insql}

        ";

        $params = array_merge([context_module::LEVEL], $inparams);

        $this->questionsources = $DB->get_records_sql($sql, $params);

    }

    /**

     * Get data on the question bank being used by the question in the slot.

     *

     * @param int $slot slot number

     * @return stdClass|null

     */

    public function get_source_bank(int $slot): ?stdClass {

        $questionid = $this->slotsinorder[$slot]->questionid;

            $this->questionsources[$this->questions[$questionid]->contextid] ?? $this->populate_question_sources();

        // This shouldn't happen as all categories belong to a module context level but let's account for it.

        if (empty($this->questionsources[$this->questions[$questionid]->contextid])) {

            return null;

        }

        $cminfo = \cm_info::create($this->questionsources[$this->questions[$questionid]->contextid]);

        return (object) [

            'cminfo' => $cminfo,

            'issharedbank' => plugin_supports('mod', $cminfo->modname, FEATURE_PUBLISHES_QUESTIONS, false),

        ];

    }