Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

namespace mod_qbank\task;

use context_system;

use core\context;

use core\task\adhoc_task;

use core\task\manager;

use core_course_category;

use core_question\local\bank\question_bank_helper;

use stdClass;

/**

 * This script transfers question categories at CONTEXT_SITE, CONTEXT_COURSE, & CONTEXT_COURSECAT to a new qbank instance

 * context.

 *

 * Firstly, it finds any question categories where questions are not being used and deletes them, including questions.

 *

 * Then for any remaining, if it is at course level context, it creates a mod_qbank instance taking the course name

 * and moves the category there including subcategories, files and tags.

 *

 * If the original question category context was at system context, then it creates a mod_qbank instance on the site course i.e.

 * front page and moves the category & sub categories there, along with its files and tags.

 *

 * If the original question category context was a course category context, then it creates a course in that category,

 * taking the category name. Then it creates a mod_qbank instance in that course and moves the category & sub categories

 * there, along with files and tags belonging to those categories.

 *

 * @package    mod_qbank

 * @copyright  2024 onwards Catalyst IT EU {@link https://catalyst-eu.net}

 * @author     Simon Adams <simon.adams@catalyst-eu.net>

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class transfer_question_categories extends adhoc_task {

    /**

     * @var array a cache [ context id => question category ] of the top category in each context.

     * Used by get_top_category_id_for_context() to avoid repeated DB queries.

     * 0 is cached if this context id has no corresponding top category.

     */

    private array $topcategorycache = [];

    #[\Override]

    public function execute(): void {

        global $DB, $CFG;

        require_once($CFG->dirroot . '/course/modlib.php');

        require_once($CFG->libdir . '/questionlib.php');

        $this->fix_wrong_parents();

        $recordset = $DB->get_recordset('question_categories', ['parent' => 0]);

        $movedcategorycontexts = [];

        foreach ($recordset as $oldtopcategory) {

            if (!$oldcontext = context::instance_by_id($oldtopcategory->contextid, IGNORE_MISSING)) {

                // That context does not exist anymore, we will treat these as if they were at site context level.

                $oldcontext = context_system::instance();

            }

            $trans = $DB->start_delegated_transaction();

            // Remove any unused questions if they are marked as deleted.

            // Also, if a category contained questions which were all unusable then delete it as well.

            $subcategories = $DB->get_records_select('question_categories',

                'parent <> 0 AND contextid = :contextid',

                ['contextid' => $oldtopcategory->contextid]

            );

            // This gives us categories in parent -> child order so array_reverse it,

            // because we should process stale categories from the bottom up.

            $subcategories = array_reverse(sort_categories_by_tree($subcategories, $oldtopcategory->id));

            foreach ($subcategories as $subcategory) {

                \qbank_managecategories\helper::question_remove_stale_questions_from_category($subcategory->id);

                if ($this->question_category_is_empty($subcategory->id)) {

                    question_category_delete_safe($subcategory);

                }

            }

            // If the top category no longer has any subcategories, because they only contained stale questions,

            // delete the top category and stop here without creating a new qbank.

            if (!$DB->record_exists('question_categories', ['parent' => $oldtopcategory->id])) {

                $DB->delete_records('question_categories', ['id' => $oldtopcategory->id]);

                $trans->allow_commit();

                continue;

            }

            // We don't want to transfer any categories at valid contexts i.e. quiz modules.

            if ($oldcontext->contextlevel === CONTEXT_MODULE) {

                $trans->allow_commit();

                continue;

            }

            // Category is in use so let's process it. Firstly, a course and mod instance is needed.

            switch ($oldcontext->contextlevel) {

                case CONTEXT_SYSTEM:

                    $course = get_site();

                    $bankname = question_bank_helper::get_bank_name_string('systembank', 'question');

                    break;

                case CONTEXT_COURSECAT:

                    $coursecategory = core_course_category::get($oldcontext->instanceid);

                    $courseshortname = "$coursecategory->name-$coursecategory->id";

                    $course = $this->create_course($coursecategory, $courseshortname);

                    $bankname = question_bank_helper::get_bank_name_string('sharedbank', 'mod_qbank', $coursecategory->name);

                    break;

                case CONTEXT_COURSE:

                    $course = get_course($oldcontext->instanceid);

                    $bankname = question_bank_helper::get_bank_name_string('sharedbank', 'mod_qbank', $course->shortname);

                    break;

                default:

                    // This shouldn't be possible, so we can't really transfer it.

                    // We should commit any pre-transfer category cleanup though.

                    $trans->allow_commit();

                    continue 2;

            }

            if (!$newmod = question_bank_helper::get_default_open_instance_system_type($course)) {

                $newmod = question_bank_helper::create_default_open_instance($course, $bankname, question_bank_helper::TYPE_SYSTEM);

            }

            // We have our new mod instance, now move all the subcategories of the old 'top' category to this new context.

            $movedcategories = $this->move_question_category($oldtopcategory, $newmod->context);

            $movedcategorycontexts += array_fill_keys($movedcategories, $oldtopcategory->contextid);

            // Job done, lets delete the old 'top' category.

            $DB->delete_records('question_categories', ['id' => $oldtopcategory->id]);

            $trans->allow_commit();

        }

        $recordset->close();

        // Create a set of new tasks to update the questions in each category to the new contexts.

        // The category itself is already in the new context. We record the old context so we know where to move

        // files and tags from.

        foreach ($movedcategorycontexts as $categoryid => $oldcontextid) {

            $task = new transfer_questions();

            $task->set_custom_data(['categoryid' => $categoryid, 'contextid' => $oldcontextid]);

            manager::queue_adhoc_task($task);

        }

    }

    /**

     * Wrapper for \create_course.

     *

     * @param core_course_category $coursecategory

     * @param string $shortname

     * @return stdClass

     */

    protected function create_course(core_course_category $coursecategory, string $shortname): stdClass {

        $data = (object) [

            'enablecompletion' => 0,

            'fullname' => get_string('coursecategory', 'mod_qbank', $coursecategory->name),

            'shortname' => $shortname,

            'category' => $coursecategory->id,

        ];

        return create_course($data);

    }

    /**

     * Create a new 'Top' category in our new context and move the old categories descendents beneath it.

     *

     * @param stdClass $oldtopcategory The old 'Top' category that we are moving.

     * @param context\module $newcontext The context we are moving our category to.

     * @return int[] The IDs of all categories moved to the new context.

     */

    protected function move_question_category(stdClass $oldtopcategory, context\module $newcontext): array {

        global $DB;

        $newtopcategory = question_get_top_category($newcontext->id, true);

        move_question_set_references($oldtopcategory->id, $newtopcategory->id, $oldtopcategory->contextid, $newcontext->id, true);

        // This function moves subcategories, so we have to start at the top.

        $movedcategories = $this->move_subcategories_to_context($oldtopcategory->id, $newcontext);

        // Move the parent from the old top category to the new one.

        $DB->set_field('question_categories', 'parent', $newtopcategory->id, ['parent' => $oldtopcategory->id]);

        return $movedcategories;

    }

    /**

     * Recursively update the contextid for all subcategories of the given category.

     *

     * @param int $categoryid The ID of the category to update subcategories for. When calling directly,

     *                        this should be a top category.

     * @param context\module $newcontext The new context for the subcategories.

     * @return int[] The IDs of all categories moved to the new context.

     */

    protected function move_subcategories_to_context(int $categoryid, context\module $newcontext): array {

        global $DB;

        $movedcategories = [];

        $subcatids = $DB->get_records('question_categories', ['parent' => $categoryid]);

        foreach ($subcatids as $subcatid => $data) {

            // Because of the fallback above, where categories pointing to a

            // missing contextid are all moved to the new shared system-level

            // question bank, some categories are moved from previously

            // separate contextids to the same context. This can violate

            // unique indexes, so we fix this by ensuring uniqueness.

            // For the stamp, we just generate a new stamp if required.

            if ($DB->record_exists('question_categories', ['stamp' => $data->stamp, 'contextid' => $newcontext->id])) {

                $data->stamp = make_unique_id_code();

            }

            // The idnumber we just reset duplicates to null, as is done in other places.

            if (

                $data->idnumber !== null &&

                $DB->record_exists('question_categories', ['idnumber' => $data->idnumber, 'contextid' => $newcontext->id])

            ) {

                $data->idnumber = null;

            }

            // Update the contextid and save the category.

            $data->contextid = $newcontext->id;

            $DB->update_record('question_categories', $data);

            $movedcategories[] = $subcatid;

            $movedcategories = array_merge(

                $this->move_subcategories_to_context($subcatid, $newcontext),

                $movedcategories,

            );

        }

        return $movedcategories;

    }

    /**

     * Find the Top category for a context, if there is one.

     *

     * @param int $contextid the id of a context (which might not exist).

     * @return int a Top category id, or 0 if none is found.

     */

    protected function get_top_category_id_for_context(int $contextid): int {

        global $DB;

        // Use the cache if we have already loaded this.

        if (array_key_exists($contextid, $this->topcategorycache)) {

            return $this->topcategorycache[$contextid];

        }

        $topcategoryid = (int) $DB->get_field('question_categories', 'id',

            ['contextid' => $contextid, 'parent' => 0]);

        $this->topcategorycache[$contextid] = $topcategoryid;

        return $topcategoryid;

    }

    /**

     * Fix the context of child categories whose contextid does not match that of their parents.

     *

     * Fix here means:

     *

     * - if the child category's context exists, and has a 'Top' category, we move the child

     *   category to be just under that Top category. That is where they would have appeared

     *   before, e.g. in the return from question_categorylist().

     *

     * - if the child category points to a context that does not exist at all, then we

     *   instead change its context to be the same as it's parent's context. This may

     *   break things like images in the question text of questions there, but there is

     *   no real alternative.

     *

     * This is necessary because, due to old bugs, for example in backup and restoree code,

     * we know there can be question categories in the databases of old Moodle sites with

     * the wrong context id.

     */

    public function fix_wrong_parents(): void {

        global $DB;

        $categoriestofix = $this->get_categories_in_a_different_context_to_their_parent();

        foreach ($categoriestofix as $childcategoryid => $childcontextid) {

            $topcategoryid = $this->get_top_category_id_for_context($childcontextid);

            if ($topcategoryid) {

                // Suitable Top category in the child's current context, so move to be a parent of that.

                $DB->set_field('question_categories', 'parent', $topcategoryid, ['id' => $childcategoryid]);

            } else {

                // Top not found. Change the child to have the same context as its parent.

                // This is not efficient in DB queries, but we expect this to be a rare case, and this is simple and right.

                $childcategory = $DB->get_record('question_categories', ['id' => $childcategoryid]);

                $parentcontextid = $DB->get_field('question_categories', 'contextid', ['id' => $childcategory->parent]);

                $this->move_category_and_its_children($childcategoryid, $parentcontextid);

            }

        }

    }

    /**

     * Get question categories that are in a different context to their parent.

     *

     * @return int[] child category id => context id of the child category.

     */

    public function get_categories_in_a_different_context_to_their_parent(): array {

        global $DB;

        return $DB->get_records_sql_menu('

            SELECT c.id, c.contextid

              FROM {question_categories} c

              JOIN {question_categories} p ON p.id = c.parent

             WHERE p.contextid <> c.contextid

          ORDER BY c.id

        ');

    }

    /**

     * Set the contextid of category $categoryid and all its children to $newcontextid.

     *

     * @param int $categoryid a question_category id.

     * @param int $newcontextid the place to move to.

     */

    public function move_category_and_its_children(int $categoryid, int $newcontextid): void {

        global $DB;

        $DB->set_field('question_categories', 'contextid', $newcontextid, ['id' => $categoryid]);

        $children = $DB->get_records('question_categories', ['parent' => $categoryid], '', 'id, contextid');

        foreach ($children as $child) {

            if ($child->contextid != $newcontextid) {

                $this->move_category_and_its_children($child->id, $newcontextid);

            }

        }

    }

    /**

     * Recursively check if a question category or its children contain any questions.

     *

     * @param int $categoryid The parent category to check from.

     * @return bool True if neither the category nor its children contain any questions.

     */

    protected function question_category_is_empty(int $categoryid): bool {

        global $DB;

        if ($DB->record_exists('question_bank_entries', ['questioncategoryid' => $categoryid])) {

            return false;

        }

        // If this category is empty, recursively check child categories.

        $childcategoryids = $DB->get_fieldset('question_categories', 'id', ['parent' => $categoryid]);

        foreach ($childcategoryids as $childcategoryid) {

            if (!$this->question_category_is_empty($childcategoryid)) {

                // If we found questions in a child, we don't want to check any other children.

                return false;

            }

        }

        return true;

    }

}