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 core_question\local\bank;

use cm_info;

use context;

use context_course;

use core\task\manager;

use moodle_url;

use stdClass;

defined('MOODLE_INTERNAL') || die();

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

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

/**

 * Helper class for qbank sharing.

 *

 * @package    core_question

 * @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 question_bank_helper {

    /** @var string the type of qbank module that users create */

    public const TYPE_STANDARD = 'standard';

    /**

     * The type of shared bank module that the system creates.

     * These are created in course restores when no target context can be found,

     * and also for when a question category cannot be deleted safely due to questions being in use.

     *

     * @var string

     */

    public const TYPE_SYSTEM = 'system';

    /** @var string The type of shared bank module that the system creates for previews. Not used for any other purpose. */

    public const TYPE_PREVIEW = 'preview';

    /** @var array Shared bank types */

    public const SHARED_TYPES = [self::TYPE_STANDARD, self::TYPE_SYSTEM, self::TYPE_PREVIEW];

    /**

     * User preferences record key to store recently viewed question banks.

     */

    protected const RECENTLY_VIEWED = 'recently_viewed_open_banks';

    /**

     * Category delimiter used by the SQL to group concatenate question category data i.e.

     * category_id<->category_name<->context_id.

     */

    private const CATEGORY_DELIMITER = '<->';

    /**

     * Category separator used by the SQL for group concatenation of those category triplets

     * from above.

     */

    private const CATEGORY_SEPARATOR = '<,>';

    /**

     * Maximum length for the question bank name database field.

     */

    public const BANK_NAME_MAX_LENGTH = 255;

    /**

     * Modules that share questions via FEATURE_PUBLISHES_QUESTIONS.

     *

     * @return array

     */

    public static function get_activity_types_with_shareable_questions(): array {

        static $sharedmods;

        if (!empty($sharedmods)) {

            return $sharedmods;

        }

        $manager = \core_plugin_manager::instance();

        $plugins = $manager->get_enabled_plugins('mod');

        $sharedmods = array_filter(

            array_keys($plugins),

            static fn ($plugin) => plugin_supports('mod', $plugin, FEATURE_PUBLISHES_QUESTIONS) &&

                question_module_uses_questions($plugin)

        );

        return array_values($sharedmods);

    }

    /**

     * Get module types that do not share questions. They will have FEATURE_USES_QUESTIONS set to false or won't have it defined.

     *

     * @return array

     */

    public static function get_activity_types_with_private_questions(): array {

        static $privatemods;

        if (!empty($privatemods)) {

            return $privatemods;

        }

        $manager = \core_plugin_manager::instance();

        $plugins = $manager->get_enabled_plugins('mod');

        $privatemods = array_filter(

            array_keys($plugins),

            static fn ($plugin) => !plugin_supports('mod', $plugin, FEATURE_PUBLISHES_QUESTIONS) &&

                question_module_uses_questions($plugin)

        );

        return array_values($privatemods);

    }

    /**

     * Get records for activity modules that do publish questions, and optionally get their question categories too.

     *

     * @param array $incourseids array of course ids where you want instances included. Leave empty if you want from all courses.

     * @param array $notincourseids array of course ids where you do not want instances included.

     * @param array $havingcap current user must have at least one of these capabilities on each bank context.

     * @param bool $getcategories optionally return the categories belonging to these banks.

     * @param int $currentbankid optionally include the bank id you want included as the first result from the method return.

     * it will only be included if the other parameters allow it.

     * @param ?context $filtercontext Optional context to use for all string filtering, useful for performance when calling with

     *      parameters that will get banks across multiple contexts.

     * @param string $search Optional term to search question bank instances by name

     * @param int $limit The number of results to return (default 0 = no limit)

     * @return stdClass[]

     */

    public static function get_activity_instances_with_shareable_questions(

        array $incourseids = [],

        array $notincourseids = [],

        array $havingcap = [],

        bool $getcategories = false,

        int $currentbankid = 0,

        ?context $filtercontext = null,

        string $search = '',

        int $limit = 0,

    ): array {

        return self::get_bank_instances(true,

            $incourseids,

            $notincourseids,

            $getcategories,

            $currentbankid,

            $havingcap,

            $filtercontext,

            $search,

            $limit,

        );

    }

    /**

     * Get records for activity modules that don't publish questions, and optionally get their question categories too.

     *

     * @param array $incourseids array of course ids where you want instances included. Leave empty if you want from all courses.

     * @param array $notincourseids array of course ids where you do not want instances included.

     * @param array $havingcap current user must have at least one of these capabilities on each bank context.

     * @param bool $getcategories optionally return the categories belonging to these banks.

     * @param int $currentbankid optionally include the bank id you want included as the first result from the method return.

     * it will only be included if the other parameters allow it.

     * @param ?context $filtercontext Optional context to use for all string filtering, useful for performance when calling with

     *       parameters that will get banks across multiple contexts.

     * @return stdClass[]

     */

    public static function get_activity_instances_with_private_questions(

        array $incourseids = [],

        array $notincourseids = [],

        array $havingcap = [],

        bool $getcategories = false,

        int $currentbankid = 0,

        ?context $filtercontext = null,

    ): array {

        return self::get_bank_instances(false,

            $incourseids,

            $notincourseids,

            $getcategories,

            $currentbankid,

            $havingcap,

            $filtercontext,

        );

    }

    /**

     * Private method to build the SQL and get records from the DB. Called from public API methods

     * {@see self::get_activity_instances_with_shareable_questions()}

     * {@see self::get_activity_instances_with_private_questions()}

     *

     * @param bool $isshared true if you want instances that publish questions false if you want instances that don't

     * @param array $incourseids array of course ids where you want instances included. Leave empty if you want from all courses.

     * @param array $notincourseids array of course ids where you do not want instances included.

     * @param bool $getcategories optionally return the categories belonging to these banks.

     * @param int $currentbankid optionally include the bank id you want included as the first result from the method return.

     *  it will only be included if the other parameters allow it.

     * @param array $havingcap current user must have at least one of these capabilities on each bank context.

     * @param ?context $filtercontext Optional context to use for all string filtering, useful for performance when calling with

     *     parameters that will get banks across multiple contexts.

     * @param string $search Optional term to search question bank instances by name

     * @param int $limit The number of results to return (default 0 = no limit)

     * @return stdClass[]

     */

    private static function get_bank_instances(

        bool $isshared,

        array $incourseids = [],

        array $notincourseids = [],

        bool $getcategories = false,

        int $currentbankid = 0,

        array $havingcap = [],

        ?context $filtercontext = null,

        string $search = '',

        int $limit = 0,

    ): array {

        global $DB;

        $pluginssql = [];

        $params = [];

        // Build the SELECT portion of the SQL and include question category joins as required.

        if ($getcategories) {

            $concat = $DB->sql_concat('qc.id',

                "'" . self::CATEGORY_DELIMITER . "'",

                'qc.name',

                "'" . self::CATEGORY_DELIMITER . "'",

                'qc.contextid'

            );

            $groupconcat = $DB->sql_group_concat($concat, self::CATEGORY_SEPARATOR);

            $select = "SELECT cm.id, cm.course, {$groupconcat} AS cats";

            $catsql = ' JOIN {context} c ON c.instanceid = cm.id AND c.contextlevel = ' . CONTEXT_MODULE .

                ' JOIN {question_categories} qc ON qc.contextid = c.id AND qc.parent <> 0';

        } else {

            $select = 'SELECT cm.id, cm.course';

            $catsql = '';

        }

        if ($isshared) {

            $plugins = self::get_activity_types_with_shareable_questions();

        } else {

            $plugins = self::get_activity_types_with_private_questions();

        }

        if (empty($plugins)) {

            return [];

        }

        // Build the joins for all modules of the type requested i.e. those that do or do not share questions.

        foreach ($plugins as $key => $plugin) {

            $moduleid = $DB->get_field('modules', 'id', ['name' => $plugin]);

            $sql = "JOIN {{$plugin}} p{$key} ON p{$key}.id = cm.instance

                    AND cm.module = {$moduleid} AND cm.deletioninprogress = 0";

            if ($plugin === self::get_default_question_bank_activity_name()) {

                $sql .= " AND p{$key}.type <> '" . self::TYPE_PREVIEW . "'";

            }

            if (!empty($search)) {

                $sql .= " AND " . $DB->sql_like("p{$key}.name", ":search{$key}", false);

                $params["search{$key}"] = "%{$search}%";

            }

            $pluginssql[] = $sql;

        }

        $pluginssql = implode(' ', $pluginssql);

        // Build the SQL to filter out any requested course ids.

        if (!empty($notincourseids)) {

            [$notincoursesql, $notincourseparams] = $DB->get_in_or_equal($notincourseids, SQL_PARAMS_NAMED, 'param', false);

            $notincoursesql = "AND cm.course {$notincoursesql}";

            $params = array_merge($params, $notincourseparams);

        } else {

            $notincoursesql = '';

        }

        // Build the SQL to include ONLY records belonging to the requested courses.

        if (!empty($incourseids)) {

            [$incoursesql, $incourseparams] = $DB->get_in_or_equal($incourseids, SQL_PARAMS_NAMED);

            $incoursesql = " AND cm.course {$incoursesql}";

            $params = array_merge($params, $incourseparams);

        } else {

            $incoursesql = '';

        }

        // Optionally order the results by the requested bank id.

        if (!empty($currentbankid)) {

            $orderbysql = " ORDER BY CASE WHEN cm.id = :currentbankid THEN 0 ELSE 1 END ASC, cm.id DESC ";

            $params['currentbankid'] = $currentbankid;

        } else {

            $orderbysql = '';

        }

        $sql = "{$select}

                FROM {course_modules} cm

                JOIN {modules} m ON m.id = cm.module

                {$pluginssql}

                {$catsql}

                WHERE 1=1 {$notincoursesql} {$incoursesql}

                GROUP BY cm.id, cm.course

                {$orderbysql}";

        $rs = $DB->get_recordset_sql($sql, $params, limitnum: $limit);

        $banks = [];

        foreach ($rs as $cm) {

            // If capabilities have been supplied as a method argument then ensure the viewing user has at least one of those

            // capabilities on the module itself.

            if (!empty($havingcap)) {

                $context = \context_module::instance($cm->id);

                if (!(new question_edit_contexts($context))->have_one_cap($havingcap)) {

                    continue;

                }

            }

            // Populate the raw record.

            $banks[] = self::get_formatted_bank($cm, $currentbankid, filtercontext: $filtercontext);

        }

        $rs->close();

        return $banks;

    }

    /**

     * Get a list of recently viewed question banks that implement FEATURE_PUBLISHES_QUESTIONS.

     * If any of the stored contexts don't exist anymore then update the user preference record accordingly.

     *

     * @param int $userid of the user to get recently viewed banks for.

     * @param int $notincourseid if supplied don't return any in this course id

     * @param ?context $filtercontext Optional context to use for all string filtering, useful for performance when calling with

     *       parameters that will get banks across multiple contexts.

     * @return cm_info[]

     */

    public static function get_recently_used_open_banks(

        int $userid,

        int $notincourseid = 0,

        ?context $filtercontext = null,

        array $havingcap = [],

    ): array {

        $prefs = get_user_preferences(self::RECENTLY_VIEWED, null, $userid);

        $contextids = !empty($prefs) ? explode(',', $prefs) : [];

        if (empty($contextids)) {

            return $contextids;

        }

        $invalidcontexts = [];

        $banks = [];

        foreach ($contextids as $contextid) {

            if (!$context = context::instance_by_id($contextid, IGNORE_MISSING)) {

                $invalidcontexts[] = $context;

                continue;

            }

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

                throw new \moodle_exception('Invalid question bank contextlevel: ' . $context->contextlevel);

            }

            [, $cm] = get_module_from_cmid($context->instanceid);

            if (!empty($notincourseid) && $notincourseid == $cm->course) {

                continue;

            }

            if (!empty($havingcap) && !(new question_edit_contexts($context))->have_one_cap($havingcap)) {

                continue;

            }

            $record = self::get_formatted_bank($cm, filtercontext: $filtercontext);

            $banks[] = $record;

        }

        if (!empty($invalidcontexts)) {

            $tostore = array_diff($contextids, $invalidcontexts);

            $tostore = implode(',', $tostore);

            set_user_preference(self::RECENTLY_VIEWED, $tostore, $userid);

        }

        return $banks;

    }

    /**

     * Mark a user as having viewed a question bank in the user_preferences table with key {@see self::RECENTLY_VIEWED}

     *

     * @param context $bankcontext add this bank context to the viewing user's list of recently viewed.

     * @return void

     */

    public static function add_bank_context_to_recently_viewed(context $bankcontext): void {

        [, $cm] = get_module_from_cmid($bankcontext->instanceid);

        if (!plugin_supports('mod', $cm->modname, FEATURE_PUBLISHES_QUESTIONS)) {

            return;

        }

        $userprefs = get_user_preferences(self::RECENTLY_VIEWED);

        $recentlyviewed = !empty($userprefs) ? explode(',', $userprefs) : [];

        $recentlyviewed = array_combine($recentlyviewed, $recentlyviewed);

        $tostore = [];

        $tostore[] = $bankcontext->id;

        if (!empty($recentlyviewed[$bankcontext->id])) {

            unset($recentlyviewed[$bankcontext->id]);

        }

        $tostore = array_merge($tostore, array_values($recentlyviewed));

        $tostore = array_slice($tostore, 0, 5);

        set_user_preference(self::RECENTLY_VIEWED, implode(',', $tostore));

    }

    /**

     * Populate the raw record with data for use in rendering.

     *

     * @param stdClass $cm raw course_modules record to populate data from.

     * @param int $currentbankid set an 'enabled' flag on the instance that matched this id.

     *     Used in qbank_bulkmove/bulk_move.mustache

     * @param ?context $filtercontext Optional context in which to apply filters.

     *

     * @return stdClass

     */

    private static function get_formatted_bank(stdClass $cm, int $currentbankid = 0, ?context $filtercontext = null): stdClass {

        $cminfo = cm_info::create($cm);

        $concatedcats = !empty($cm->cats) ? explode(self::CATEGORY_SEPARATOR, $cm->cats) : [];

        $categories = array_map(static function($concatedcategory) use ($cminfo, $currentbankid) {

            $values = explode(self::CATEGORY_DELIMITER, $concatedcategory);

            $cat = new stdClass();

            $cat->id = $values[0];

            $cat->name = $values[1];

            $cat->contextid = $values[2];

            $cat->enabled = $cminfo->id == $currentbankid ? 'enabled' : 'disabled';

            return $cat;

        }, $concatedcats);

        $bank = new stdClass();

        $filteroptions = ['escape' => false];

        if (!is_null($filtercontext)) {

            $filteroptions['context'] = $filtercontext;

        }

        $bank->name = $cminfo->get_formatted_name($filteroptions);

        $bank->modid = $cminfo->id;

        $bank->contextid = $cminfo->context->id;

        if (!isset($filteroptions['context'])) {

            $filteroptions['context'] = context_course::instance($cminfo->get_course()->id);

        }

        $bank->coursenamebankname = format_string($cminfo->get_course()->shortname, true, $filteroptions) . " - {$bank->name}";

        $bank->cminfo = $cminfo;

        $bank->questioncategories = $categories;

        return $bank;

    }

    /**

     * Get the system type qbank instance for this course, optionally create it if it does not yet exist.

     * {@see self::TYPE_SYSTEM}

     *

     * @param stdClass $course the course to get the default system type bank for.

     * @param bool $createifnotexists create a default bank if it does not exist.

     * @return cm_info|null

     */

    public static function get_default_open_instance_system_type(stdClass $course, bool $createifnotexists = false): ?cm_info {

        $modinfo = get_fast_modinfo($course);

        $qbanks = $modinfo->get_instances_of(self::get_default_question_bank_activity_name());

        $systembank = null;

        if ($systembankids = self::get_qbank_ids_of_type_in_course($course, self::TYPE_SYSTEM)) {

            // We should only ever have 1 of these.

            $systembankid = reset($systembankids);

            // Filter the course modinfo qbanks by the systembankid.

            $systembanks = array_filter($qbanks, static fn($bank) => $bank->id === $systembankid);

            $systembank = !empty($systembanks) ? reset($systembanks) : null;

        }

        if (!$systembank && $createifnotexists) {

            $systembank = self::create_default_open_instance(

                $course,

                self::get_bank_name_string('systembank', 'question'),

                self::TYPE_SYSTEM,

            );

        }

        return $systembank;

    }

    /**

     * Get the bank that is used for preview purposes only, optionally create it if it does not yet exist.

     * {@see \qbank_columnsortorder\column_manager::get_questionbank()}

     *

     * @param bool $createifnotexists create a default bank if it does not exist.

     * @return cm_info|null

     */

    public static function get_preview_open_instance_type(bool $createifnotexists = false): ?cm_info {

        $site = get_site();

        $modinfo = get_fast_modinfo($site);

        $qbanks = $modinfo->get_instances_of(self::get_default_question_bank_activity_name());

        $previewbank = null;

        if ($previewbankids = self::get_qbank_ids_of_type_in_course($site, self::TYPE_PREVIEW)) {

            // We should only ever have 1 of these.

            $previewbankid = reset($previewbankids);

            // Filter the course modinfo qbanks by the previewbankid.

            $previewbanks = array_filter($qbanks, static fn($bank) => $bank->id === $previewbankid);

            $previewbank = !empty($previewbanks) ? reset($previewbanks) : null;

        }

        if (!$previewbank && $createifnotexists) {

            $previewbank = self::create_default_open_instance(

                $site,

                self::get_bank_name_string('previewbank', 'question'),

                self::TYPE_PREVIEW

            );

        }

        return $previewbank;

    }

    /**

     * Get course module ids from qbank instances on a course that are of the sub-type provided.

     *

     * @param stdClass $course the course to search

     * @param string $subtype the subtype of the qbank module {@see self::SHARED_TYPES}

     * @return int[]

     */

    private static function get_qbank_ids_of_type_in_course(stdClass $course, string $subtype): array {

        global $DB;

        if (!in_array($subtype, self::SHARED_TYPES)) {

            throw new \moodle_exception('Invalid question bank type: ' . $subtype);

        }

        $modinfo = get_fast_modinfo($course);

        $defaultyactivityname = self::get_default_question_bank_activity_name();

        $qbanks = $modinfo->get_instances_of($defaultyactivityname);

        $whereclause = "AND m.name = '" . $defaultyactivityname . "'";

        if (!empty($qbanks)) {

            $sql = "SELECT cm.id

                      FROM {course_modules} cm

                      JOIN {modules} m ON m.id = cm.module

                      JOIN {{$defaultyactivityname}} q ON q.id = cm.instance

                     WHERE cm.course = :course

                       AND q.type = :type " .

            $whereclause;

            return $DB->get_fieldset_sql($sql, ['type' => $subtype, 'course' => $course->id]);

        }

        return [];

    }

    /**

     * Create a bank on the course from default options.

     *

     * @param stdClass $course the course that the new module is being created in

     * @param string $bankname name of the new module

     * @param string $type {@see self::TYPES}

     * @return cm_info

     */

    public static function create_default_open_instance(

        stdClass $course,

        string $bankname,

        string $type = self::TYPE_STANDARD

    ): cm_info {

        global $DB;

        if (!in_array($type, self::SHARED_TYPES)) {

            throw new \RuntimeException('invalid type');

        }

        // Preview bank must be created at site course.

        if ($type === self::TYPE_PREVIEW) {

            if ($qbank = self::get_preview_open_instance_type()) {

                return $qbank;

            }

            $course = get_site();

        }

        // We can only have one of these types per course.

        if ($type === self::TYPE_SYSTEM && $qbank = self::get_default_open_instance_system_type($course)) {

            return $qbank;

        }

        $module = $DB->get_record('modules', ['name' => self::get_default_question_bank_activity_name()], '*', MUST_EXIST);

        $context = context_course::instance($course->id);

        // STANDARD type needs capability checks.

        if ($type === self::TYPE_STANDARD) {

            require_capability('moodle/course:manageactivities', $context);

            if (!course_allowed_module($course, $module->name)) {

                throw new \moodle_exception('moduledisable');

            }

        }

        if (\core_text::strlen($bankname) > self::BANK_NAME_MAX_LENGTH) {

            throw new \coding_exception(

                'The provided bankname is too long for the database field.',

                'Use question_bank_helper::get_bank_name_string to get a suitably truncated name.',

            );

        }

        $data = new stdClass();

        $data->section = 0;

        $data->visible = 0;

        $data->course = $course->id;

        $data->module = $module->id;

        $data->modulename = $module->name;

        $data->groupmode = $course->groupmode;

        $data->groupingid = $course->defaultgroupingid;

        $data->id = '';

        $data->instance = '';

        $data->coursemodule = '';

        $data->downloadcontent = DOWNLOAD_COURSE_CONTENT_ENABLED;

        $data->visibleoncoursepage = 0;

        $data->name = $bankname;

        $data->type = in_array($type, self::SHARED_TYPES) ? $type : self::TYPE_STANDARD;

        $data->showdescription = $type === self::TYPE_STANDARD ? 0 : 1;

        // Don't create the default category if this is being created by the system as part of a migration or restore,

        // existing categories will be migrated to the new context.

        $data->skipdefaultcategory = $type === self::TYPE_SYSTEM;

        $mod = add_moduleinfo($data, $course);

        // Have to set this manually as the system because this bank type is not intended to be created directly by a user.

        if ($type === self::TYPE_SYSTEM) {

            $DB->set_field($module->name, 'intro', get_string('systembankdescription', 'question'), ['id' => $mod->instance]);

            $DB->set_field($module->name, 'introformat', FORMAT_HTML, ['id' => $mod->instance]);

        }

        return get_fast_modinfo($course)->get_cm($mod->coursemodule);

    }

    /**

     * Get the url that shows the banks list of a course.

     *

     * @param int $courseid of the course to get the url for.

     * @param bool $createdefault Pass true if you want the URL to create a default qbank instance when referred.

     * @return moodle_url

     */

    public static function get_url_for_qbank_list(int $courseid, bool $createdefault = false): moodle_url {

        $url = new moodle_url('/question/banks.php', ['courseid' => $courseid]);

        if ($createdefault) {

            $url->param('createdefault', true);

        }

        return $url;

    }

    /**

     * This task should only ever be called once, on install/upgrade. But we may need to warn the user on some pages

     * that some banks may not have been transferred yet if it failed or hasn't yet completed.

     *

     * @return bool

     */

    public static function has_bank_migration_task_completed_successfully(): bool {

        $defaultbank = self::get_default_question_bank_activity_name();

        $task = manager::get_adhoc_tasks("\\mod_{$defaultbank}\\task\\transfer_question_categories");

        $subtasks = manager::get_adhoc_tasks("\\mod_{$defaultbank}\\task\\transfer_questions");

        return empty($task) && empty($subtasks);

    }

    /**

     * Get the activity plugin name that will be the type used for default bank creation and management.

     *

     * @return string

     */

    public static function get_default_question_bank_activity_name(): string {

        global $CFG;

        return $CFG->corequestion_defaultqbankmod ?? 'qbank';

    }

    /**

     * Get the requested language string, with parameters truncated to ensure the result fits in the database.

     *

     * Since we may be generating a question bank name based on an existing course or category name, we need to ensure

     * that the resulting string isn't longer than the maximum module name.

     *

     * @param string $identifier The string identifier

     * @param string $component The string component

     * @param mixed|null $params The string parameters (a single string, array or object as accepted by get_string)

     * @return string The string truncated to a length that will fit in the database.

     */

    public static function get_bank_name_string(string $identifier, string $component, mixed $params = null): string {

        if (is_object($params)) {

            $shortparams = (array) $params;

        } else {

            $shortparams = $params;

        }

        $bankname = get_string($identifier, $component, $shortparams);

        if (!is_null($shortparams)) {

            $trimlength = self::BANK_NAME_MAX_LENGTH - 4;

            while (\core_text::strlen($bankname) > self::BANK_NAME_MAX_LENGTH && $trimlength > 0) {

                // Gradually shorten the string parameters until the resulting string is short enough.

                if (is_array($shortparams)) {

                    $shortparams = array_map(fn($param) => shorten_text(trim($param), $trimlength), $shortparams);

                } else {

                    $shortparams = shorten_text(trim($shortparams), $trimlength);

                }

                $bankname = get_string($identifier, $component, $shortparams);

                $trimlength -= 10;

            }

        }

        // As a failsafe, limit the length of the final string in case the lang string is too long.

        return shorten_text($bankname, self::BANK_NAME_MAX_LENGTH);

    }

}