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/>.

/**

 * moodlelib.php - Moodle main library

 *

 * Main library file of miscellaneous general-purpose Moodle functions.

 * Other main libraries:

 *  - weblib.php      - functions that produce web output

 *  - datalib.php     - functions that access the database

 *

 * @package    core

 * @subpackage lib

 * @copyright  1999 onwards Martin Dougiamas  http://dougiamas.com

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

 */

use core\di;

use core\hook;

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

// CONSTANTS (Encased in phpdoc proper comments).

// Date and time constants.

/**

 * Time constant - the number of seconds in a year

 */

define('YEARSECS', 31536000);

/**

 * Time constant - the number of seconds in a week

 */

define('WEEKSECS', 604800);

/**

 * Time constant - the number of seconds in a day

 */

define('DAYSECS', 86400);

/**

 * Time constant - the number of seconds in an hour

 */

define('HOURSECS', 3600);

/**

 * Time constant - the number of seconds in a minute

 */

define('MINSECS', 60);

/**

 * Time constant - the number of minutes in a day

 */

define('DAYMINS', 1440);

/**

 * Time constant - the number of minutes in an hour

 */

define('HOURMINS', 60);

// Parameter constants - every call to optional_param(), required_param()

// or clean_param() should have a specified type of parameter.

// We currently include \core\param manually here to avoid broken upgrades.

// This may change after the next LTS release as LTS releases require the previous LTS release.

require_once(__DIR__ . '/classes/deprecation.php');

require_once(__DIR__ . '/classes/param.php');

/**

 * PARAM_ALPHA - contains only English ascii letters [a-zA-Z].

 */

define('PARAM_ALPHA', \core\param::ALPHA->value);

/**

 * PARAM_ALPHAEXT the same contents as PARAM_ALPHA (English ascii letters [a-zA-Z]) plus the chars in quotes: "_-" allowed

 * NOTE: originally this allowed "/" too, please use PARAM_SAFEPATH if "/" needed

 */

define('PARAM_ALPHAEXT', \core\param::ALPHAEXT->value);

/**

 * PARAM_ALPHANUM - expected numbers 0-9 and English ascii letters [a-zA-Z] only.

 */

define('PARAM_ALPHANUM', \core\param::ALPHANUM->value);

/**

 * PARAM_ALPHANUMEXT - expected numbers 0-9, letters (English ascii letters [a-zA-Z]) and _- only.

 */

define('PARAM_ALPHANUMEXT', \core\param::ALPHANUMEXT->value);

/**

 * PARAM_AUTH - actually checks to make sure the string is a valid auth plugin

 */

define('PARAM_AUTH', \core\param::AUTH->value);

/**

 * PARAM_BASE64 - Base 64 encoded format

 */

define('PARAM_BASE64', \core\param::BASE64->value);

/**

 * PARAM_BOOL - converts input into 0 or 1, use for switches in forms and urls.

 */

define('PARAM_BOOL', \core\param::BOOL->value);

/**

 * PARAM_CAPABILITY - A capability name, like 'moodle/role:manage'. Actually

 * checked against the list of capabilities in the database.

 */

define('PARAM_CAPABILITY', \core\param::CAPABILITY->value);

/**

 * PARAM_CLEANHTML - cleans submitted HTML code. Note that you almost never want

 * to use this. The normal mode of operation is to use PARAM_RAW when receiving

 * the input (required/optional_param or formslib) and then sanitise the HTML

 * using format_text on output. This is for the rare cases when you want to

 * sanitise the HTML on input. This cleaning may also fix xhtml strictness.

 */

define('PARAM_CLEANHTML', \core\param::CLEANHTML->value);

/**

 * PARAM_EMAIL - an email address following the RFC

 */

define('PARAM_EMAIL', \core\param::EMAIL->value);

/**

 * PARAM_FILE - safe file name, all dangerous chars are stripped, protects against XSS, SQL injections and directory traversals

 */

define('PARAM_FILE', \core\param::FILE->value);

/**

 * PARAM_FLOAT - a real/floating point number.

 *

 * Note that you should not use PARAM_FLOAT for numbers typed in by the user.

 * It does not work for languages that use , as a decimal separator.

 * Use PARAM_LOCALISEDFLOAT instead.

 */

define('PARAM_FLOAT', \core\param::FLOAT->value);

/**

 * PARAM_LOCALISEDFLOAT - a localised real/floating point number.

 * This is preferred over PARAM_FLOAT for numbers typed in by the user.

 * Cleans localised numbers to computer readable numbers; false for invalid numbers.

 */

define('PARAM_LOCALISEDFLOAT', \core\param::LOCALISEDFLOAT->value);

/**

 * PARAM_HOST - expected fully qualified domain name (FQDN) or an IPv4 dotted quad (IP address)

 */

define('PARAM_HOST', \core\param::HOST->value);

/**

 * PARAM_INT - integers only, use when expecting only numbers.

 */

define('PARAM_INT', \core\param::INT->value);

/**

 * PARAM_LANG - checks to see if the string is a valid installed language in the current site.

 */

define('PARAM_LANG', \core\param::LANG->value);

/**

 * PARAM_LOCALURL - expected properly formatted URL as well as one that refers to the local server itself. (NOT orthogonal to the

 * others! Implies PARAM_URL!)

 */

define('PARAM_LOCALURL', \core\param::LOCALURL->value);

/**

 * PARAM_NOTAGS - all html tags are stripped from the text. Do not abuse this type.

 */

define('PARAM_NOTAGS', \core\param::NOTAGS->value);

/**

 * PARAM_PATH - safe relative path name, all dangerous chars are stripped, protects against XSS, SQL injections and directory

 * traversals note: the leading slash is not removed, window drive letter is not allowed

 */

define('PARAM_PATH', \core\param::PATH->value);

/**

 * PARAM_PEM - Privacy Enhanced Mail format

 */

define('PARAM_PEM', \core\param::PEM->value);

/**

 * PARAM_PERMISSION - A permission, one of CAP_INHERIT, CAP_ALLOW, CAP_PREVENT or CAP_PROHIBIT.

 */

define('PARAM_PERMISSION', \core\param::PERMISSION->value);

/**

 * PARAM_RAW specifies a parameter that is not cleaned/processed in any way except the discarding of the invalid utf-8 characters

 */

define('PARAM_RAW', \core\param::RAW->value);

/**

 * PARAM_RAW_TRIMMED like PARAM_RAW but leading and trailing whitespace is stripped.

 */

define('PARAM_RAW_TRIMMED', \core\param::RAW_TRIMMED->value);

/**

 * PARAM_SAFEDIR - safe directory name, suitable for include() and require()

 */

define('PARAM_SAFEDIR', \core\param::SAFEDIR->value);

/**

 * PARAM_SAFEPATH - several PARAM_SAFEDIR joined by "/", suitable for include() and require(), plugin paths

 * and other references to Moodle code files.

 *

 * This is NOT intended to be used for absolute paths or any user uploaded files.

 */

define('PARAM_SAFEPATH', \core\param::SAFEPATH->value);

/**

 * PARAM_SEQUENCE - expects a sequence of numbers like 8 to 1,5,6,4,6,8,9.  Numbers and comma only.

 */

define('PARAM_SEQUENCE', \core\param::SEQUENCE->value);

/**

 * PARAM_TAG - one tag (interests, blogs, etc.) - mostly international characters and space, <> not supported

 */

define('PARAM_TAG', \core\param::TAG->value);

/**

 * PARAM_TAGLIST - list of tags separated by commas (interests, blogs, etc.)

 */

define('PARAM_TAGLIST', \core\param::TAGLIST->value);

/**

 * PARAM_TEXT - general plain text compatible with multilang filter, no other html tags. Please note '<', or '>' are allowed here.

 */

define('PARAM_TEXT', \core\param::TEXT->value);

/**

 * PARAM_THEME - Checks to see if the string is a valid theme name in the current site

 */

define('PARAM_THEME', \core\param::THEME->value);

/**

 * PARAM_URL - expected properly formatted URL. Please note that domain part is required, http://localhost/ is not accepted but

 * http://localhost.localdomain/ is ok.

 */

define('PARAM_URL', \core\param::URL->value);

/**

 * PARAM_USERNAME - Clean username to only contains allowed characters. This is to be used ONLY when manually creating user

 * accounts, do NOT use when syncing with external systems!!

 */

define('PARAM_USERNAME', \core\param::USERNAME->value);

/**

 * PARAM_STRINGID - used to check if the given string is valid string identifier for get_string()

 */

define('PARAM_STRINGID', \core\param::STRINGID->value);

// DEPRECATED PARAM TYPES OR ALIASES - DO NOT USE FOR NEW CODE.

/**

 * PARAM_CLEAN - obsoleted, please use a more specific type of parameter.

 * It was one of the first types, that is why it is abused so much ;-)

 * @deprecated since 2.0

 */

define('PARAM_CLEAN', \core\param::CLEAN->value);

/**

 * PARAM_INTEGER - deprecated alias for PARAM_INT

 * @deprecated since 2.0

 */

define('PARAM_INTEGER', \core\param::INT->value);

/**

 * PARAM_NUMBER - deprecated alias of PARAM_FLOAT

 * @deprecated since 2.0

 */

define('PARAM_NUMBER', \core\param::FLOAT->value);

/**

 * PARAM_ACTION - deprecated alias for PARAM_ALPHANUMEXT, use for various actions in forms and urls

 * NOTE: originally alias for PARAM_APLHA

 * @deprecated since 2.0

 */

define('PARAM_ACTION', \core\param::ALPHANUMEXT->value);

/**

 * PARAM_FORMAT - deprecated alias for PARAM_ALPHANUMEXT, use for names of plugins, formats, etc.

 * NOTE: originally alias for PARAM_APLHA

 * @deprecated since 2.0

 */

define('PARAM_FORMAT', \core\param::ALPHANUMEXT->value);

/**

 * PARAM_MULTILANG - deprecated alias of PARAM_TEXT.

 * @deprecated since 2.0

 */

define('PARAM_MULTILANG', \core\param::TEXT->value);

/**

 * PARAM_TIMEZONE - expected timezone. Timezone can be int +-(0-13) or float +-(0.5-12.5) or

 * string separated by '/' and can have '-' &/ '_' (eg. America/North_Dakota/New_Salem

 * America/Port-au-Prince)

 */

define('PARAM_TIMEZONE', \core\param::TIMEZONE->value);

/**

 * PARAM_CLEANFILE - deprecated alias of PARAM_FILE; originally was removing regional chars too

 * @deprecated since 2.0

 */

define('PARAM_CLEANFILE', \core\param::CLEANFILE->value);

/**

 * PARAM_COMPONENT is used for full component names (aka frankenstyle) such as 'mod_forum', 'core_rating', 'auth_ldap'.

 * Short legacy subsystem names and module names are accepted too ex: 'forum', 'rating', 'user'.

 * Only lowercase ascii letters, numbers and underscores are allowed, it has to start with a letter.

 * NOTE: numbers and underscores are strongly discouraged in plugin names!

 */

define('PARAM_COMPONENT', \core\param::COMPONENT->value);

/**

 * PARAM_AREA is a name of area used when addressing files, comments, ratings, etc.

 * It is usually used together with context id and component.

 * Only lowercase ascii letters, numbers and underscores are allowed, it has to start with a letter.

 */

define('PARAM_AREA', \core\param::AREA->value);

/**

 * PARAM_PLUGIN is used for plugin names such as 'forum', 'glossary', 'ldap', 'paypal', 'completionstatus'.

 * Only lowercase ascii letters, numbers and underscores are allowed, it has to start with a letter.

 * NOTE: numbers and underscores are strongly discouraged in plugin names! Underscores are forbidden in module names.

 */

define('PARAM_PLUGIN', \core\param::PLUGIN->value);

// Web Services.

/**

 * VALUE_REQUIRED - if the parameter is not supplied, there is an error

 */

define('VALUE_REQUIRED', 1);

/**

 * VALUE_OPTIONAL - if the parameter is not supplied, then the param has no value

 */

define('VALUE_OPTIONAL', 2);

/**

 * VALUE_DEFAULT - if the parameter is not supplied, then the default value is used

 */

define('VALUE_DEFAULT', 0);

/**

 * NULL_NOT_ALLOWED - the parameter can not be set to null in the database

 */

define('NULL_NOT_ALLOWED', false);

/**

 * NULL_ALLOWED - the parameter can be set to null in the database

 */

define('NULL_ALLOWED', true);

// Page types.

/**

 * PAGE_COURSE_VIEW is a definition of a page type. For more information on the page class see moodle/lib/pagelib.php.

 */

define('PAGE_COURSE_VIEW', 'course-view');

/** Get remote addr constant */

define('GETREMOTEADDR_SKIP_HTTP_CLIENT_IP', '1');

/** Get remote addr constant */

define('GETREMOTEADDR_SKIP_HTTP_X_FORWARDED_FOR', '2');

/**

 * GETREMOTEADDR_SKIP_DEFAULT defines the default behavior remote IP address validation.

 */

define('GETREMOTEADDR_SKIP_DEFAULT', GETREMOTEADDR_SKIP_HTTP_X_FORWARDED_FOR | GETREMOTEADDR_SKIP_HTTP_CLIENT_IP);

// Blog access level constant declaration.

define('BLOG_USER_LEVEL', 1);

define('BLOG_GROUP_LEVEL', 2);

define('BLOG_COURSE_LEVEL', 3);

define('BLOG_SITE_LEVEL', 4);

define('BLOG_GLOBAL_LEVEL', 5);

// Tag constants.

/**

 * To prevent problems with multibytes strings,Flag updating in nav not working on the review page. this should not exceed the

 * length of "varchar(255) / 3 (bytes / utf-8 character) = 85".

 * TODO: this is not correct, varchar(255) are 255 unicode chars ;-)

 *

 * @todo define(TAG_MAX_LENGTH) this is not correct, varchar(255) are 255 unicode chars ;-)

 */

define('TAG_MAX_LENGTH', 50);

// Password policy constants.

define('PASSWORD_LOWER', 'abcdefghijklmnopqrstuvwxyz');

define('PASSWORD_UPPER', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');

define('PASSWORD_DIGITS', '0123456789');

define('PASSWORD_NONALPHANUM', '.,;:!?_-+/*@#&$');

/**

 * Required password pepper entropy.

 */

define('PEPPER_ENTROPY', 112);

// Feature constants.

// Used for plugin_supports() to report features that are, or are not, supported by a module.

/** True if module can provide a grade */

define('FEATURE_GRADE_HAS_GRADE', 'grade_has_grade');

/** True if module supports outcomes */

define('FEATURE_GRADE_OUTCOMES', 'outcomes');

/** True if module supports advanced grading methods */

define('FEATURE_ADVANCED_GRADING', 'grade_advanced_grading');

/** True if module controls the grade visibility over the gradebook */

define('FEATURE_CONTROLS_GRADE_VISIBILITY', 'controlsgradevisbility');

/** True if module supports plagiarism plugins */

define('FEATURE_PLAGIARISM', 'plagiarism');

/** True if module has code to track whether somebody viewed it */

define('FEATURE_COMPLETION_TRACKS_VIEWS', 'completion_tracks_views');

/** True if module has custom completion rules */

define('FEATURE_COMPLETION_HAS_RULES', 'completion_has_rules');

/** True if module has no 'view' page (like label) */

define('FEATURE_NO_VIEW_LINK', 'viewlink');

/** True (which is default) if the module wants support for setting the ID number for grade calculation purposes. */

define('FEATURE_IDNUMBER', 'idnumber');

/** True if module supports groups */

define('FEATURE_GROUPS', 'groups');

/** True if module supports groupings */

define('FEATURE_GROUPINGS', 'groupings');

/**

 * True if module supports groupmembersonly (which no longer exists)

 * @deprecated Since Moodle 2.8

 */

define('FEATURE_GROUPMEMBERSONLY', 'groupmembersonly');

/** Type of module */

define('FEATURE_MOD_ARCHETYPE', 'mod_archetype');

/** True if module supports intro editor */

define('FEATURE_MOD_INTRO', 'mod_intro');

/** True if module has default completion */

define('FEATURE_MODEDIT_DEFAULT_COMPLETION', 'modedit_default_completion');

define('FEATURE_COMMENT', 'comment');

define('FEATURE_RATE', 'rate');

/** True if module supports backup/restore of moodle2 format */

define('FEATURE_BACKUP_MOODLE2', 'backup_moodle2');

/** True if module can show description on course main page */

define('FEATURE_SHOW_DESCRIPTION', 'showdescription');

/** True if module uses the question bank */

define('FEATURE_USES_QUESTIONS', 'usesquestions');

/**

 * Maximum filename char size

 */

define('MAX_FILENAME_SIZE', 100);

/** Unspecified module archetype */

define('MOD_ARCHETYPE_OTHER', 0);

/** Resource-like type module */

define('MOD_ARCHETYPE_RESOURCE', 1);

/** Assignment module archetype */

define('MOD_ARCHETYPE_ASSIGNMENT', 2);

/** System (not user-addable) module archetype */

define('MOD_ARCHETYPE_SYSTEM', 3);

/** Type of module */

define('FEATURE_MOD_PURPOSE', 'mod_purpose');

/** Module purpose administration */

define('MOD_PURPOSE_ADMINISTRATION', 'administration');

/** Module purpose assessment */

define('MOD_PURPOSE_ASSESSMENT', 'assessment');

/** Module purpose communication */

define('MOD_PURPOSE_COLLABORATION', 'collaboration');

/** Module purpose communication */

define('MOD_PURPOSE_COMMUNICATION', 'communication');

/** Module purpose content */

define('MOD_PURPOSE_CONTENT', 'content');

/** Module purpose interactive content */

define('MOD_PURPOSE_INTERACTIVECONTENT', 'interactivecontent');

/** Module purpose other */

define('MOD_PURPOSE_OTHER', 'other');

/**

 * Module purpose interface

 * @deprecated since Moodle 4.4

 * @todo MDL-80701 Remove in Moodle 4.8

 */

define('MOD_PURPOSE_INTERFACE', 'interface');

/**

 * Security token used for allowing access

 * from external application such as web services.

 * Scripts do not use any session, performance is relatively

 * low because we need to load access info in each request.

 * Scripts are executed in parallel.

 */

define('EXTERNAL_TOKEN_PERMANENT', 0);

/**

 * Security token used for allowing access

 * of embedded applications, the code is executed in the

 * active user session. Token is invalidated after user logs out.

 * Scripts are executed serially - normal session locking is used.

 */

define('EXTERNAL_TOKEN_EMBEDDED', 1);

/**

 * The home page should be the site home

 */

define('HOMEPAGE_SITE', 0);

/**

 * The home page should be the users my page

 */

define('HOMEPAGE_MY', 1);

/**

 * The home page can be chosen by the user

 */

define('HOMEPAGE_USER', 2);

/**

 * The home page should be the users my courses page

 */

define('HOMEPAGE_MYCOURSES', 3);

/**

 * URL of the Moodle sites registration portal.

 */

defined('HUB_MOODLEORGHUBURL') || define('HUB_MOODLEORGHUBURL', 'https://stats.moodle.org');

/**

 * URL of main Moodle site for marketing, products and services.

 */

defined('MOODLE_PRODUCTURL') || define('MOODLE_PRODUCTURL', 'https://moodle.com');

/**

 * URL of the statistic server public key.

 */

defined('HUB_STATSPUBLICKEY') || define('HUB_STATSPUBLICKEY', 'https://moodle.org/static/statspubkey.pem');

/**

 * Moodle mobile app service name

 */

define('MOODLE_OFFICIAL_MOBILE_SERVICE', 'moodle_mobile_app');

/**

 * Indicates the user has the capabilities required to ignore activity and course file size restrictions

 */

define('USER_CAN_IGNORE_FILE_SIZE_LIMITS', -1);

/**

 * Course display settings: display all sections on one page.

 */

define('COURSE_DISPLAY_SINGLEPAGE', 0);

/**

 * Course display settings: split pages into a page per section.

 */

define('COURSE_DISPLAY_MULTIPAGE', 1);

/**

 * Authentication constant: String used in password field when password is not stored.

 */

define('AUTH_PASSWORD_NOT_CACHED', 'not cached');

/**

 * Email from header to never include via information.

 */

define('EMAIL_VIA_NEVER', 0);

/**

 * Email from header to always include via information.

 */

define('EMAIL_VIA_ALWAYS', 1);

/**

 * Email from header to only include via information if the address is no-reply.

 */

define('EMAIL_VIA_NO_REPLY_ONLY', 2);

/**

 * Contact site support form/link disabled.

 */

define('CONTACT_SUPPORT_DISABLED', 0);

/**

 * Contact site support form/link only available to authenticated users.

 */

define('CONTACT_SUPPORT_AUTHENTICATED', 1);

/**

 * Contact site support form/link available to anyone visiting the site.

 */

define('CONTACT_SUPPORT_ANYONE', 2);

/**

 * Maximum number of characters for password.

 */

define('MAX_PASSWORD_CHARACTERS', 128);

/**

 * Toggle sensitive feature is disabled. Used for sensitive inputs (passwords, tokens, keys).

 */

define('TOGGLE_SENSITIVE_DISABLED', 0);

/**

 * Toggle sensitive feature is enabled. Used for sensitive inputs (passwords, tokens, keys).

 */

define('TOGGLE_SENSITIVE_ENABLED', 1);

/**

 * Toggle sensitive feature is enabled for small screens only. Used for sensitive inputs (passwords, tokens, keys).

 */

define('TOGGLE_SENSITIVE_SMALL_SCREENS_ONLY', 2);

// PARAMETER HANDLING.

/**

 * Returns a particular value for the named variable, taken from

 * POST or GET.  If the parameter doesn't exist then an error is

 * thrown because we require this variable.

 *

 * This function should be used to initialise all required values

 * in a script that are based on parameters.  Usually it will be

 * used like this:

 *    $id = required_param('id', PARAM_INT);

 *

 * Please note the $type parameter is now required and the value can not be array.

 *

 * @param string $parname the name of the page parameter we want

 * @param string $type expected type of parameter

 * @return mixed

 * @throws coding_exception

 */

function required_param($parname, $type)

{

    return \core\param::from_type($type)->required_param($parname);

}

/**

 * Returns a particular array value for the named variable, taken from

 * POST or GET.  If the parameter doesn't exist then an error is

 * thrown because we require this variable.

 *

 * This function should be used to initialise all required values

 * in a script that are based on parameters.  Usually it will be

 * used like this:

 *    $ids = required_param_array('ids', PARAM_INT);

 *

 *  Note: arrays of arrays are not supported, only alphanumeric keys with _ and - are supported

 *

 * @param string $parname the name of the page parameter we want

 * @param string $type expected type of parameter

 * @return array

 * @throws coding_exception

 */

function required_param_array($parname, $type)

{

    return \core\param::from_type($type)->required_param_array($parname);

}

/**

 * Returns a particular value for the named variable, taken from

 * POST or GET, otherwise returning a given default.

 *

 * This function should be used to initialise all optional values

 * in a script that are based on parameters.  Usually it will be

 * used like this:

 *    $name = optional_param('name', 'Fred', PARAM_TEXT);

 *

 * Please note the $type parameter is now required and the value can not be array.

 *

 * @param string $parname the name of the page parameter we want

 * @param mixed  $default the default value to return if nothing is found

 * @param string $type expected type of parameter

 * @return mixed

 * @throws coding_exception

 */

function optional_param($parname, $default, $type)

{

    return \core\param::from_type($type)->optional_param(

        paramname: $parname,

        default: $default,

    );

}

/**

 * Returns a particular array value for the named variable, taken from

 * POST or GET, otherwise returning a given default.

 *

 * This function should be used to initialise all optional values

 * in a script that are based on parameters.  Usually it will be

 * used like this:

 *    $ids = optional_param('id', array(), PARAM_INT);

 *

 * Note: arrays of arrays are not supported, only alphanumeric keys with _ and - are supported

 *

 * @param string $parname the name of the page parameter we want

 * @param mixed $default the default value to return if nothing is found

 * @param string $type expected type of parameter

 * @return array

 * @throws coding_exception

 */

function optional_param_array($parname, $default, $type)

{

    return \core\param::from_type($type)->optional_param_array(

        paramname: $parname,

        default: $default,

    );

}

/**

 * Strict validation of parameter values, the values are only converted

 * to requested PHP type. Internally it is using clean_param, the values

 * before and after cleaning must be equal - otherwise

 * an invalid_parameter_exception is thrown.

 * Objects and classes are not accepted.

 *

 * @param mixed $param

 * @param string $type PARAM_ constant

 * @param bool $allownull are nulls valid value?

 * @param string $debuginfo optional debug information

 * @return mixed the $param value converted to PHP type

 * @throws invalid_parameter_exception if $param is not of given type

 */

function validate_param($param, $type, $allownull = NULL_NOT_ALLOWED, $debuginfo = '')

{

    return \core\param::from_type($type)->validate_param(

        param: $param,

        allownull: $allownull,

        debuginfo: $debuginfo,

    );

}

/**

 * Makes sure array contains only the allowed types, this function does not validate array key names!

 *

 * <code>

 * $options = clean_param($options, PARAM_INT);

 * </code>

 *

 * @param array|null $param the variable array we are cleaning

 * @param string $type expected format of param after cleaning.

 * @param bool $recursive clean recursive arrays

 * @return array

 * @throws coding_exception

 */

function clean_param_array(?array $param, $type, $recursive = false)

{

    return \core\param::from_type($type)->clean_param_array(

        param: $param,

        recursive: $recursive,

    );

}

/**

 * Used by {@link optional_param()} and {@link required_param()} to

 * clean the variables and/or cast to specific types, based on

 * an options field.

 * <code>

 * $course->format = clean_param($course->format, PARAM_ALPHA);

 * $selectedgradeitem = clean_param($selectedgradeitem, PARAM_INT);

 * </code>

 *

 * @param mixed $param the variable we are cleaning

 * @param string $type expected format of param after cleaning.

 * @return mixed

 * @throws coding_exception

 */

function clean_param($param, $type)

{

    return \core\param::from_type($type)->clean($param);

}

/**

 * Whether the PARAM_* type is compatible in RTL.

 *

 * Being compatible with RTL means that the data they contain can flow

 * from right-to-left or left-to-right without compromising the user experience.

 *

 * Take URLs for example, they are not RTL compatible as they should always

 * flow from the left to the right. This also applies to numbers, email addresses,

 * configuration snippets, base64 strings, etc...

 *

 * This function tries to best guess which parameters can contain localised strings.

 *

 * @param string $paramtype Constant PARAM_*.

 * @return bool

 */

function is_rtl_compatible($paramtype)

{

    return $paramtype == PARAM_TEXT || $paramtype == PARAM_NOTAGS;

}

/**

 * Makes sure the data is using valid utf8, invalid characters are discarded.

 *

 * Note: this function is not intended for full objects with methods and private properties.

 *

 * @param mixed $value

 * @return mixed with proper utf-8 encoding

 */

function fix_utf8($value)

{

    if (is_null($value) or $value === '') {

        return $value;

    } else if (is_string($value)) {

        if ((string)(int)$value === $value) {

            // Shortcut.

            return $value;

        }

        // Remove null bytes or invalid Unicode sequences from value.

        $value = str_replace(["\0", "\xef\xbf\xbe", "\xef\xbf\xbf"], '', $value);

        // Note: this duplicates min_fix_utf8() intentionally.

        static $buggyiconv = null;

        if ($buggyiconv === null) {

            $buggyiconv = (!function_exists('iconv') or @iconv('UTF-8', 'UTF-8//IGNORE', '100' . chr(130) . '€') !== '100€');

        }

        if ($buggyiconv) {

            if (function_exists('mb_convert_encoding')) {

                $subst = mb_substitute_character();

                mb_substitute_character('none');

                $result = mb_convert_encoding($value, 'utf-8', 'utf-8');

                mb_substitute_character($subst);

            } else {

                // Warn admins on admin/index.php page.

                $result = $value;

            }

        } else {

            $result = @iconv('UTF-8', 'UTF-8//IGNORE', $value);

        }

        return $result;

    } else if (is_array($value)) {

        foreach ($value as $k => $v) {

            $value[$k] = fix_utf8($v);

        }

        return $value;

    } else if (is_object($value)) {

        // Do not modify original.

        $value = clone ($value);

        foreach ($value as $k => $v) {

            $value->$k = fix_utf8($v);

        }

        return $value;

    } else {

        // This is some other type, no utf-8 here.

        return $value;

    }

}

/**

 * Return true if given value is integer or string with integer value

 *

 * @param mixed $value String or Int

 * @return bool true if number, false if not

 */

function is_number($value)

{

    if (is_int($value)) {

        return true;

    } else if (is_string($value)) {

        return ((string)(int)$value) === $value;

    } else {

        return false;

    }

}

/**

 * Returns host part from url.

 *

 * @param string $url full url

 * @return string host, null if not found

 */

function get_host_from_url($url)

{

    preg_match('|^[a-z]+://([a-zA-Z0-9-.]+)|i', $url, $matches);

    if ($matches) {

        return $matches[1];

    }

    return null;

}

/**

 * Tests whether anything was returned by text editor

 *

 * This function is useful for testing whether something you got back from

 * the HTML editor actually contains anything. Sometimes the HTML editor

 * appear to be empty, but actually you get back a <br> tag or something.

 *

 * @param string $string a string containing HTML.

 * @return boolean does the string contain any actual content - that is text,

 * images, objects, etc.

 */

function html_is_blank($string)

{

    return trim(strip_tags((string)$string, '<img><object><applet><input><select><textarea><hr>')) == '';

}

/**

 * Set a key in global configuration

 *

 * Set a key/value pair in both this session's {@link $CFG} global variable

 * and in the 'config' database table for future sessions.

 *

 * Can also be used to update keys for plugin-scoped configs in config_plugin table.

 * In that case it doesn't affect $CFG.

 *

 * A NULL value will delete the entry.

 *

 * NOTE: this function is called from lib/db/upgrade.php

 *

 * @param string $name the key to set

 * @param string|int|bool|null $value the value to set (without magic quotes),

 *               null to unset the value

 * @param string $plugin (optional) the plugin scope, default null

 * @return bool true or exception

 */

function set_config($name, $value, $plugin = null)

{

    global $CFG, $DB;

    // Redirect to appropriate handler when value is null.

    if ($value === null) {

        return unset_config($name, $plugin);

    }

    // Set variables determining conditions and where to store the new config.

    // Plugin config goes to {config_plugins}, core config goes to {config}.

    $iscore = empty($plugin);

    if ($iscore) {

        // If it's for core config.

        $table = 'config';

        $conditions = ['name' => $name];

        $invalidatecachekey = 'core';

    } else {

        // If it's a plugin.

        $table = 'config_plugins';

        $conditions = ['name' => $name, 'plugin' => $plugin];

        $invalidatecachekey = $plugin;

    }

    // DB handling - checks for existing config, updating or inserting only if necessary.

    $invalidatecache = true;

    $inserted = false;

    $record = $DB->get_record($table, $conditions, 'id, value');

    if ($record === false) {

        // Inserts a new config record.

        $config = new stdClass();

        $config->name  = $name;

        $config->value = $value;

        if (!$iscore) {

            $config->plugin = $plugin;

        }

        $inserted = $DB->insert_record($table, $config, false);

    } else if ($invalidatecache = ($record->value !== $value)) {

        // Record exists - Check and only set new value if it has changed.

        $DB->set_field($table, 'value', $value, ['id' => $record->id]);

    }

    if ($iscore && !isset($CFG->config_php_settings[$name])) {

        // So it's defined for this invocation at least.

        // Settings from db are always strings.

        $CFG->$name = (string) $value;

    }

    // When setting config during a Behat test (in the CLI script, not in the web browser

    // requests), remember which ones are set so that we can clear them later.

    if ($iscore && $inserted && defined('BEHAT_TEST')) {

        $CFG->behat_cli_added_config[$name] = true;

    }

    // Update siteidentifier cache, if required.

    if ($iscore && $name === 'siteidentifier') {

        cache_helper::update_site_identifier($value);

    }

    // Invalidate cache, if required.

    if ($invalidatecache) {

        cache_helper::invalidate_by_definition('core', 'config', [], $invalidatecachekey);

    }

    return true;

}

/**