WebSVN – Moodle – Diff – /lib/moodlelib.php

 /** 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);
+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_USER_LEVEL', 1);
-define ('BLOG_GROUP_LEVEL', 2);
+define('BLOG_GROUP_LEVEL', 2);
-define ('BLOG_COURSE_LEVEL', 3);
+define('BLOG_COURSE_LEVEL', 3);
-define ('BLOG_SITE_LEVEL', 4);
+define('BLOG_SITE_LEVEL', 4);
-define ('BLOG_GLOBAL_LEVEL', 5);
+define('BLOG_GLOBAL_LEVEL', 5);
  * @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_LOWER', 'abcdefghijklmnopqrstuvwxyz');
-define ('PASSWORD_UPPER', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
+define('PASSWORD_UPPER', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
-define ('PASSWORD_DIGITS', '0123456789');
+define('PASSWORD_DIGITS', '0123456789');
-define ('PASSWORD_NONALPHANUM', '.,;:!?_-+/*@#&$');
+define('PASSWORD_NONALPHANUM', '.,;:!?_-+/*@#&$');
 /**
  * Required password pepper entropy.
  */
-define ('PEPPER_ENTROPY', 112);
+define('PEPPER_ENTROPY', 112);
 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
  * @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) {
+function required_param($parname, $type)
+{
     return \core\param::from_type($type)->required_param($parname);
+}
 /**
  * @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) {
+function required_param_array($parname, $type)
+{
     return \core\param::from_type($type)->required_param_array($parname);
+}
 /**
  * @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) {
+function optional_param($parname, $default, $type)
+{
     return \core\param::from_type($type)->optional_param(
         paramname: $parname,
         default: $default,
     );
+}
  * @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) {
+function optional_param_array($parname, $default, $type)
+{
     return \core\param::from_type($type)->optional_param_array(
         paramname: $parname,
         default: $default,
     );
+}
  * @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 = '') {
+function validate_param($param, $type, $allownull = NULL_NOT_ALLOWED, $debuginfo = '')
+{
     return \core\param::from_type($type)->validate_param(
         param: $param,
         allownull: $allownull,
         debuginfo: $debuginfo,
     );
  * @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) {
+function clean_param_array(?array $param, $type, $recursive = false)
+{
     return \core\param::from_type($type)->clean_param_array(
         param: $param,
         recursive: $recursive,
     );
+}
  * @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) {
+function clean_param($param, $type)
+{
     return \core\param::from_type($type)->clean($param);
+}
 /**
  * This function tries to best guess which parameters can contain localised strings.
+ *
  * @param string $paramtype Constant PARAM_*.
  * @return bool
  */
-function is_rtl_compatible($paramtype) {
+function is_rtl_compatible($paramtype)
+{
     return $paramtype == PARAM_TEXT || $paramtype == PARAM_NOTAGS;
+}
 /**
  * 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) {
+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;
+        }
         $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€');
+            $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);
+                $result = mb_convert_encoding($value, 'utf-8', 'utf-8');
                 mb_substitute_character($subst);
             } else {
                 // Warn admins on admin/index.php page.
-                $result = $value;
                 $result = $value;
+            }
         } else {
             $result = @iconv('UTF-8', 'UTF-8//IGNORE', $value);
-        }
+        }
         return $result;
         return $result;
     } else if (is_array($value)) {
         foreach ($value as $k => $v) {
-            $value[$k] = fix_utf8($v);
             $value[$k] = fix_utf8($v);
         return $value;
+        return $value;
     } else if (is_object($value)) {
         // Do not modify original.
-        $value = clone($value);
+        $value = clone ($value);
         foreach ($value as $k => $v) {
-            $value->$k = fix_utf8($v);
             $value->$k = fix_utf8($v);
         return $value;
         return $value;
     } else {
         // This is some other type, no utf-8 here.
  * 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) {
+function is_number($value)
+{
     if (is_int($value)) {
         return true;
     } else if (is_string($value)) {
         return ((string)(int)$value) === $value;
     } else {
  * Returns host part from url.
+ *
  * @param string $url full url
  * @return string host, null if not found
  */
-function get_host_from_url($url) {
+function get_host_from_url($url)
+{
     preg_match('|^[a-z]+://([a-zA-Z0-9-.]+)|i', $url, $matches);
     if ($matches) {
         return $matches[1];
+    }
     return null;
+ *
  * @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) {
+function html_is_blank($string)
+{
     return trim(strip_tags((string)$string, '<img><object><applet><input><select><textarea><hr>')) == '';
+}
 /**
  * @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) {
+function set_config($name, $value, $plugin = null)
+{
     global $CFG, $DB;
     // Redirect to appropriate handler when value is null.
     if ($value === null) {
  * @param string $plugin full component name
  * @param string $name default null
  * @return mixed hash-like object or single value, return false no config found
  * @throws dml_exception
  */
-function get_config($plugin, $name = null) {
+function get_config($plugin, $name = null)
+{
     global $CFG, $DB;
     if ($plugin === 'moodle' || $plugin === 'core' || empty($plugin)) {
-        $forced =& $CFG->config_php_settings;
+        $forced = &$CFG->config_php_settings;
         $iscore = true;
         $plugin = 'core';
     } else {
         if (array_key_exists($plugin, $CFG->forced_plugin_settings)) {
-            $forced =& $CFG->forced_plugin_settings[$plugin];
+            $forced = &$CFG->forced_plugin_settings[$plugin];
         } else {
             $forced = array();
+        }
         $iscore = false;
+ *
  * @param string $name the key to set
  * @param string $plugin (optional) the plugin scope
  * @return boolean whether the operation succeeded.
  */
-function unset_config($name, $plugin=null) {
+function unset_config($name, $plugin = null)
+{
     global $CFG, $DB;
     if (empty($plugin)) {
         unset($CFG->$name);
  * NOTE: this function is called from lib/db/upgrade.php
+ *
  * @param string $plugin a plugin, for example 'quiz' or 'qtype_multichoice';
  * @return boolean whether the operation succeeded.
  */
-function unset_all_config_for_plugin($plugin) {
+function unset_all_config_for_plugin($plugin)
+{
     global $DB;
     // Delete from the obvious config_plugins first.
     $DB->delete_records('config_plugins', array('plugin' => $plugin));
     // Next delete any suspect settings from config.
     $like = $DB->sql_like('name', '?', true, true, false, '|');
-    $params = array($DB->sql_like_escape($plugin.'_', '|') . '%');
+    $params = array($DB->sql_like_escape($plugin . '_', '|') . '%');
     $DB->delete_records_select('config', $like, $params);
     // Finally clear both the plugin cache and the core cache (suspect settings now removed from core).
     cache_helper::invalidate_by_definition('core', 'config', array(), array('core', $plugin));
  * @param string $value the value of the config setting.
  * @param string $capability the capability - must match the one passed to the admin_setting_users_with_capability constructor.
  * @param bool $includeadmins include administrators.
  * @return array of user objects.
  */
-function get_users_from_config($value, $capability, $includeadmins = true) {
+function get_users_from_config($value, $capability, $includeadmins = true)
+{
     if (empty($value) or $value === '$@NONE@$') {
         return array();
+    }
 /**
  * Invalidates browser caches and cached data in temp.
+ *
  * @return void
  */
-function purge_all_caches() {
+function purge_all_caches()
+{
     purge_caches();
+}
 /**
  *        'lang'   Purge language string cache?
  *        'js'     Purge javascript cache?
  *        'filter' Purge text filter cache?
  *        'other'  Purge all other caches?
  */
-function purge_caches($options = []) {
+function purge_caches($options = [])
+{
     $defaults = array_fill_keys(['muc', 'courses', 'theme', 'lang', 'js', 'template', 'filter', 'other'], false);
     if (empty(array_filter($options))) {
         $options = array_fill_keys(array_keys($defaults), true); // Set all options to true.
     } else {
         $options = array_merge($defaults, array_intersect_key($options, $defaults)); // Override defaults with specified options.
  * Purge all non-MUC caches not otherwise purged in purge_caches.
+ *
  * IMPORTANT - If you are adding anything here to do with the cache directory you should also have a look at
  * {@link phpunit_util::reset_dataroot()}
  */
-function purge_other_caches() {
+function purge_other_caches()
+{
     global $DB, $CFG;
     if (class_exists('core_plugin_manager')) {
         core_plugin_manager::reset_caches();
+    }
     $DB->reset_caches();
     // Purge all other caches: rss, simplepie, etc.
     clearstatcache();
-    remove_dir($CFG->cachedir.'', true);
+    remove_dir($CFG->cachedir . '', true);
+ *
  * @param string $type
  * @param int $changedsince default null
  * @return array records array
  */
-function get_cache_flags($type, $changedsince = null) {
+function get_cache_flags($type, $changedsince = null)
+{
     global $DB;
     $params = array('type' => $type, 'expiry' => time());
     $sqlwhere = "flagtype = :type AND expiry >= :expiry";
  * @param string $type
  * @param string $name
  * @param int $changedsince default null
  * @return string|false The cache flag value or false
  */
-function get_cache_flag($type, $name, $changedsince=null) {
+function get_cache_flag($type, $name, $changedsince = null)
+{
     global $DB;
     $params = array('type' => $type, 'name' => $name, 'expiry' => time());
  * @param string $name the key to set
  * @param string $value the value to set (without magic quotes) - null will remove the flag
  * @param int $expiry (optional) epoch indicating expiry - defaults to now()+ 24hs
  * @return bool Always returns true
  */
-function set_cache_flag($type, $name, $value, $expiry = null) {
+function set_cache_flag($type, $name, $value, $expiry = null)
+{
     global $DB;
     $timemodified = time();
     if ($expiry === null || $expiry < $timemodified) {
+ *
  * @param string $type the "type" namespace for the key
  * @param string $name the key to set
  * @return bool
  */
-function unset_cache_flag($type, $name) {
+function unset_cache_flag($type, $name)
+{
     global $DB;
     $DB->delete_records('cache_flags', array('name' => $name, 'flagtype' => $type));
     return true;
+}
 /**
  * Garbage-collect volatile flags
+ *
  * @return bool Always returns true
  */
+function gc_cache_flags()
 function gc_cache_flags() {
     global $DB;
     $DB->delete_records_select('cache_flags', 'expiry < ?', array(time()));
     return true;
  * @param    stdClass         $user          User object. Preferences are preloaded into 'preference' property
  * @param    int              $cachelifetime Cache life time on the current page (in seconds)
  * @throws   coding_exception
  * @return   null
  */
-function check_user_preferences_loaded(stdClass $user, $cachelifetime = 120) {
+function check_user_preferences_loaded(stdClass $user, $cachelifetime = 120)
+{
     global $DB;
     // Static cache, we need to check on each page load, not only every 2 minutes.
     static $loadedusers = array();
     if (isset($loadedusers[$user->id]) and isset($user->preference) and isset($user->preference['_lastloaded'])) {
         // Already loaded at least once on this page. Are we up to date?
         if ($user->preference['_lastloaded'] + $cachelifetime > $timenow) {
             // No need to reload - we are on the same page and we loaded prefs just a moment ago.
             return;
         } else if (!get_cache_flag('userpreferenceschanged', $user->id, $user->preference['_lastloaded'])) {
             // No change since the lastcheck on this page.
             $user->preference['_lastloaded'] = $timenow;
             return;
+        }
+ *
  * @package core
  * @access private
  * @param integer $userid the user whose prefs were changed.
  */
-function mark_user_preferences_changed($userid) {
+function mark_user_preferences_changed($userid)
+{
     global $CFG;
     if (empty($userid) or isguestuser($userid)) {
         // No cache flags for guest and not-logged-in users.
  *                                    record, null means delete current value.
  * @param    stdClass|int|null $user  A moodle user object or id, null means current user
  * @throws   coding_exception
  * @return   bool                     Always true or exception
  */
-function set_user_preference($name, $value, $user = null) {
+function set_user_preference($name, $value, $user = null)
+{
     global $USER, $DB;
     if (empty($name) or is_numeric($name) or $name === '_lastloaded') {
         throw new coding_exception('Invalid preference name in set_user_preference() call');
         if ($preference->value === $value and isset($user->preference[$name]) and $user->preference[$name] === $value) {
             // Preference already set to this value.
             return true;
+        }
         $DB->set_field('user_preferences', 'value', $value, array('id' => $preference->id));
     } else {
         $preference = new stdClass();
         $preference->userid = $user->id;
         $preference->name   = $name;
         $preference->value  = $value;
  * @access   public
  * @param    array             $prefarray An array of key/value pairs to be set
  * @param    stdClass|int|null $user      A moodle user object or id, null means current user
  * @return   bool                         Always true or exception
  */
-function set_user_preferences(array $prefarray, $user = null) {
+function set_user_preferences(array $prefarray, $user = null)
+{
     foreach ($prefarray as $name => $value) {
         set_user_preference($name, $value, $user);
+    }
     return true;
+}
  * @param    string            $name The key to unset as preference for the specified user
  * @param    stdClass|int|null $user A moodle user object or id, null means current user
  * @throws   coding_exception
  * @return   bool                    Always true or exception
  */
-function unset_user_preference($name, $user = null) {
+function unset_user_preference($name, $user = null)
+{
     global $USER, $DB;
     if (empty($name) or is_numeric($name) or $name === '_lastloaded') {
         throw new coding_exception('Invalid preference name in unset_user_preference() call');
  * @param    stdClass|int|null $user    A moodle user object or id, null means current user
  * @throws   coding_exception
  * @return   string|mixed|null          A string containing the value of a single preference. An
  *                                      array with all of the preferences or null
  */
-function get_user_preferences($name = null, $default = null, $user = null) {
+function get_user_preferences($name = null, $default = null, $user = null)
+{
     global $USER;
     if (is_null($name)) {
         // All prefs.
  *             if 99 then default user's timezone is used {@link https://moodledev.io/docs/apis/subsystems/time#timezone}
  * @param bool $applydst Toggle Daylight Saving Time, default true, will be
  *             applied only if timezone is 99 or string.
  * @return int GMT timestamp
  */
-function make_timestamp($year, $month=1, $day=1, $hour=0, $minute=0, $second=0, $timezone=99, $applydst=true) {
+function make_timestamp($year, $month = 1, $day = 1, $hour = 0, $minute = 0, $second = 0, $timezone = 99, $applydst = true)
+{
     $date = new DateTime('now', core_date::get_user_timezone_object($timezone));
     $date->setDate((int)$year, (int)$month, (int)$day);
     $date->setTime((int)$hour, (int)$minute, (int)$second);
     $time = $date->getTimestamp();
     if ($time === false) {
-        throw new coding_exception('getTimestamp() returned false, please ensure you have passed correct values.'.
+        throw new coding_exception('getTimestamp() returned false, please ensure you have passed correct values.' .
             ' This can fail if year is more than 2038 and OS is 32 bit windows');
+    }
     // Moodle BC DST stuff.
     if (!$applydst) {
-        $time += dst_offset_on($time, $timezone);
         $time += dst_offset_on($time, $timezone);
+    }
     return $time;
     return $time;
  * @uses YEARSECS
  * @param int $totalsecs Time in seconds
  * @param stdClass $str Should be a time object
  * @return string A nicely formatted date/time string
  */
-function format_time($totalsecs, $str = null) {
+function format_time($totalsecs, $str = null)
+{
     $totalsecs = abs($totalsecs);
         $str->secs  = get_string('secs');
         $str->year  = get_string('year');
         $str->years = get_string('years');
+    }
-    $years     = floor($totalsecs/YEARSECS);
+    $years     = floor($totalsecs / YEARSECS);
-    $remainder = $totalsecs - ($years*YEARSECS);
+    $remainder = $totalsecs - ($years * YEARSECS);
-    $days      = floor($remainder/DAYSECS);
+    $days      = floor($remainder / DAYSECS);
-    $remainder = $totalsecs - ($days*DAYSECS);
+    $remainder = $totalsecs - ($days * DAYSECS);
-    $hours     = floor($remainder/HOURSECS);
+    $hours     = floor($remainder / HOURSECS);
-    $remainder = $remainder - ($hours*HOURSECS);
+    $remainder = $remainder - ($hours * HOURSECS);
-    $mins      = floor($remainder/MINSECS);
+    $mins      = floor($remainder / MINSECS);
-    $secs      = $remainder - ($mins*MINSECS);
+    $secs      = $remainder - ($mins * MINSECS);
     $ss = ($secs == 1)  ? $str->sec  : $str->secs;
     $sm = ($mins == 1)  ? $str->min  : $str->mins;
     $ohours = '';
     $omins = '';
     $osecs = '';
     if ($years) {
-        $oyears  = $years .' '. $sy;
+        $oyears  = $years . ' ' . $sy;
+    }
     if ($days) {
-        $odays  = $days .' '. $sd;
+        $odays  = $days . ' ' . $sd;
+    }
     if ($hours) {
-        $ohours = $hours .' '. $sh;
+        $ohours = $hours . ' ' . $sh;
+    }
     if ($mins) {
-        $omins  = $mins .' '. $sm;
+        $omins  = $mins . ' ' . $sm;
+    }
     if ($secs) {
-        $osecs  = $secs .' '. $ss;
+        $osecs  = $secs . ' ' . $ss;
+    }
     if ($years) {
-        return trim($oyears .' '. $odays);
+        return trim($oyears . ' ' . $odays);
     }
     if ($days) {
-        return trim($odays .' '. $ohours);
+        return trim($odays . ' ' . $ohours);
     }
     if ($hours) {
-        return trim($ohours .' '. $omins);
+        return trim($ohours . ' ' . $omins);
     }
     if ($mins) {
-        return trim($omins .' '. $osecs);
+        return trim($omins . ' ' . $osecs);
+    }
     if ($secs) {
         return $osecs;
  * @param bool $fixday If true (default) then the leading zero from %d is removed.
  *        If false then the leading zero is maintained.
  * @param bool $fixhour If true (default) then the leading zero from %I is removed.
  * @return string the formatted date/time.
  */
-function userdate($date, $format = '', $timezone = 99, $fixday = true, $fixhour = true) {
+function userdate($date, $format = '', $timezone = 99, $fixday = true, $fixhour = true)
+{
     $calendartype = \core_calendar\type_factory::get_calendar_instance();
     return $calendartype->timestamp_to_date_string($date, $format, $timezone, $fixday, $fixhour);
+}
  * @param bool $fixday If true (default) then the leading zero from %d is removed.
  *        If false then the leading zero is maintained.
  * @param bool $fixhour If true (default) then the leading zero from %I is removed.
  * @return string the formatted date/time.
  */
-function userdate_htmltime($date, $format = '', $timezone = 99, $fixday = true, $fixhour = true) {
+function userdate_htmltime($date, $format = '', $timezone = 99, $fixday = true, $fixhour = true)
+{
     $userdatestr = userdate($date, $format, $timezone, $fixday, $fixhour);
     if (CLI_SCRIPT && !PHPUNIT_TEST) {
         return $userdatestr;
+    }
     $machinedate = new DateTime();
  * @param string $format strftime format.
  * @param int|float|string $tz the user timezone
  * @return string the formatted date/time.
  * @since Moodle 2.3.3
  */
-function date_format_string($date, $format, $tz = 99) {
+function date_format_string($date, $format, $tz = 99)
+{
     date_default_timezone_set(core_date::get_user_timezone($tz));
  * @category time
  * @param int $time Timestamp in GMT
  * @param float|int|string $timezone user timezone
  * @return array An array that represents the date in user time
  */
-function usergetdate($time, $timezone=99) {
+function usergetdate($time, $timezone = 99)
+{
     if ($time === null) {
         // PHP8 and PHP7 return different results when getdate(null) is called.
         // Display warning and cast to 0 to make sure the usergetdate() behaves consistently on all versions of PHP.
         // In the future versions of Moodle we may consider adding a strict typehint.
         debugging('usergetdate() expects parameter $time to be int, null given', DEBUG_DEVELOPER);
  * @category time
  * @param int $date Timestamp in GMT
  * @param float|int|string $timezone user timezone
  * @return int
  */
-function usertime($date, $timezone=99) {
+function usertime($date, $timezone = 99)
+{
     $userdate = new DateTime('@' . $date);
     $userdate->setTimezone(core_date::get_user_timezone_object($timezone));
     $dst = dst_offset_on($date, $timezone);
  *                         e.g. a duration of 3 days and 2 hours will be displayed as '3d 2h' instead of '3d 2h 0s'
  * @param bool $fullformat If format is not provided and this is set to true, display time units in full format.
  *                         e.g. instead of showing "3d", "3 days" will be returned.
  * @return string the formatted string describing the time difference, e.g. '10d 11h 45m'.
  */
-function get_time_interval_string(int $time1, int $time2, string $format = '',
+function get_time_interval_string(
+    int $time1,
+    int $time2,
+    string $format = '',
-        bool $dropzeroes = false, bool $fullformat = false): string {
+    bool $dropzeroes = false,
+    bool $fullformat = false
+): string {
     $dtdate = new DateTime();
     $dtdate->setTimeStamp($time1);
     $dtdate2 = new DateTime();
     $dtdate2->setTimeStamp($time2);
     $interval = $dtdate2->diff($dtdate);
  * @category time
  * @param int $date Timestamp in GMT
  * @param float|int|string $timezone user timezone
  * @return int Returns a GMT timestamp
  */
-function usergetmidnight($date, $timezone=99) {
+function usergetmidnight($date, $timezone = 99)
+{
     $userdate = usergetdate($date, $timezone);
-    // Time of midnight of this user's day, in GMT.
-    return make_timestamp($userdate['year'], $userdate['mon'], $userdate['mday'], 0, 0, 0, $timezone);
+    // Time of midnight of this user's day, in GMT.
     return make_timestamp($userdate['year'], $userdate['mon'], $userdate['mday'], 0, 0, 0, $timezone);
+}
 /**
  * Returns a string that prints the user's timezone
+ *
  * @package core
  * @category time
  * @param float|int|string $timezone user timezone
+ * @return string
- * @return string
+ */
- */
+function usertimezone($timezone = 99)
 function usertimezone($timezone=99) {
     $tz = core_date::get_user_timezone($timezone);
  * @param float|int|string $tz timezone to calculate GMT time offset before
  *        calculating user timezone, 99 is default user timezone
  *        {@link https://moodledev.io/docs/apis/subsystems/time#timezone}
  * @return float|string
  */
-function get_user_timezone($tz = 99) {
+function get_user_timezone($tz = 99)
+{
     global $USER, $CFG;
     $timezones = array(
         $tz,
         isset($CFG->forcetimezone) ? $CFG->forcetimezone : 99,
         isset($USER->timezone) ? $USER->timezone : 99,
         isset($CFG->timezone) ? $CFG->timezone : 99,
-        );
+    );
     $tz = 99;
  * @category time
  * @param int $time must NOT be compensated at all, it has to be a pure timestamp
  * @param int|float|string $strtimezone user timezone
  * @return int
  */
-function dst_offset_on($time, $strtimezone = null) {
+function dst_offset_on($time, $strtimezone = null)
+{
     $tz = core_date::get_user_timezone($strtimezone);
     $date = new DateTime('@' . $time);
     $date->setTimezone(new DateTimeZone($tz));
     if ($date->format('I') == '1') {
         if ($tz === 'Australia/Lord_Howe') {
  * @param int $weekday The day when week starts (normally taken from user preferences)
  * @param int $month The month whose day is sought
  * @param int $year The year of the month whose day is sought
  * @return int
  */
-function find_day_in_month($startday, $weekday, $month, $year) {
+function find_day_in_month($startday, $weekday, $month, $year)
+{
     $calendartype = \core_calendar\type_factory::get_calendar_instance();
     $daysinmonth = days_in_month($month, $year);
  * @category time
  * @param int $month The month whose day count is sought
  * @param int $year The year of the month whose day count is sought
  * @return int
  */
-function days_in_month($month, $year) {
+function days_in_month($month, $year)
+{
     $calendartype = \core_calendar\type_factory::get_calendar_instance();
     return $calendartype->get_num_days_in_month($year, $month);
+}
  * @param int $day The day of the date whose position in the week is sought
  * @param int $month The month of the date whose position in the week is sought
  * @param int $year The year of the date whose position in the week is sought
  * @return int
  */
-function dayofweek($day, $month, $year) {
+function dayofweek($day, $month, $year)
+{
     $calendartype = \core_calendar\type_factory::get_calendar_instance();
     return $calendartype->get_weekday($year, $month, $day);
+}
  * Any form submissions for authentication to this URL must include username,
  * password as well as a logintoken generated by \core\session\manager::get_login_token().
+ *
  * @return string login url
  */
-function get_login_url() {
+function get_login_url()
+{
     global $CFG;
     return "$CFG->wwwroot/login/index.php";
  * @return mixed Void, exit, and die depending on path
  * @throws coding_exception
  * @throws require_login_exception
  * @throws moodle_exception
  */
-function require_login($courseorid = null, $autologinguest = true, $cm = null, $setwantsurltome = true, $preventredirect = false) {
+function require_login($courseorid = null, $autologinguest = true, $cm = null, $setwantsurltome = true, $preventredirect = false)
+{
     global $CFG, $SESSION, $USER, $PAGE, $SITE, $DB, $OUTPUT;
     // Must not redirect when byteserving already started.
     if (!empty($_SERVER['HTTP_RANGE'])) {
     // Setup global $COURSE, themes, language and locale.
     if (!empty($courseorid)) {
         if (is_object($courseorid)) {
             $course = $courseorid;
         } else if ($courseorid == SITEID) {
-            $course = clone($SITE);
+            $course = clone ($SITE);
         } else {
             $course = $DB->get_record('course', array('id' => $courseorid), '*', MUST_EXIST);
+        }
         if ($cm) {
             if ($cm->course != $course->id) {
                 $SESSION->wantsurl = qualified_me();
+            }
             // Give auth plugins an opportunity to authenticate or redirect to an external login page
             $authsequence = get_enabled_auth_plugins(); // Auths, in sequence.
-            foreach($authsequence as $authname) {
+            foreach ($authsequence as $authname) {
                 $authplugin = get_auth_plugin($authname);
                 $authplugin->pre_loginpage_hook();
                 if (isloggedin()) {
                     if ($cm) {
     // Loginas as redirection if needed.
     if ($course->id != SITEID and \core\session\manager::is_loggedinas()) {
         if ($USER->loginascontext->contextlevel == CONTEXT_COURSE) {
             if ($USER->loginascontext->instanceid != $course->id) {
+                throw new \moodle_exception(
+                    'loginasonecourse',
-                throw new \moodle_exception('loginasonecourse', '',
+                    '',
+                    $CFG->wwwroot . '/course/view.php?id=' . $USER->loginascontext->instanceid
-                    $CFG->wwwroot.'/course/view.php?id='.$USER->loginascontext->instanceid);
+                );
+            }
+        }
+    }
             if ($changeurl = $userauth->change_password_url()) {
                 // Use plugin custom url.
                 redirect($changeurl);
             } else {
                 // Use moodle internal method.
-                redirect($CFG->wwwroot .'/login/change_password.php');
+                redirect($CFG->wwwroot . '/login/change_password.php');
+            }
         } else if ($userauth->can_change_password()) {
             throw new moodle_exception('forcepasswordchangenotice');
         } else {
             throw new moodle_exception('nopasswordchangeforced', 'auth');
             throw new moodle_exception('usernotfullysetup');
+        }
         if ($setwantsurltome) {
             $SESSION->wantsurl = qualified_me();
+        }
-        redirect($CFG->wwwroot .'/user/edit.php?id='. $USER->id .'&amp;course='. SITEID);
+        redirect($CFG->wwwroot . '/user/edit.php?id=' . $USER->id . '&amp;course=' . SITEID);
+    }
     // Make sure the USER has a sesskey set up. Used for CSRF protection.
+                }
                 $PAGE->set_context(null);
                 // We need to override the navigation URL as the course won't have been added to the navigation and thus
                 // the navigation will mess up when trying to find it.
                 navigation_node::override_active_url(new moodle_url('/'));
-                notice(get_string('coursehidden'), $CFG->wwwroot .'/');
+                notice(get_string('coursehidden'), $CFG->wwwroot . '/');
+            }
+        }
+    }
         // Everybody is enrolled on the frontpage.
     } else {
         if (\core\session\manager::is_loggedinas()) {
             // Make sure the REAL person can access this course first.
             $realuser = \core\session\manager::get_realuser();
+            if (
-            if (!is_enrolled($coursecontext, $realuser->id, '', true) and
+                !is_enrolled($coursecontext, $realuser->id, '', true) and
-                !is_viewing($coursecontext, $realuser->id) and !is_siteadmin($realuser->id)) {
+                !is_viewing($coursecontext, $realuser->id) and !is_siteadmin($realuser->id)
+            ) {
                 if ($preventredirect) {
                     throw new require_login_exception('Invalid course login-as access');
+                }
                 $PAGE->set_context(null);
                 echo $OUTPUT->header();
-                notice(get_string('studentnotallowed', '', fullname($USER, true)), $CFG->wwwroot .'/');
+                notice(get_string('studentnotallowed', '', fullname($USER, true)), $CFG->wwwroot . '/');
+            }
+        }
         $access = false;
         if (is_role_switched($course->id)) {
-            // Ok, user had to be inside this course before the switch.
-            $access = true;
+            // Ok, user had to be inside this course before the switch.
             $access = true;
         } else if (is_viewing($coursecontext, $USER)) {
-            // Ok, no need to mess with enrol.
-            $access = true;
+            // Ok, no need to mess with enrol.
             $access = true;
         } else {
             if (isset($USER->enrol['enrolled'][$course->id])) {
                 if ($USER->enrol['enrolled'][$course->id] > time()) {
                     if ($until == 0) {
                         $until = ENROL_MAX_TIMESTAMP;
+                    }
                     $USER->enrol['enrolled'][$course->id] = $until;
                     $access = true;
                 } else if (core_course_category::can_view_course_info($course)) {
                     $params = array('courseid' => $course->id, 'status' => ENROL_INSTANCE_ENABLED);
                     $instances = $DB->get_records('enrol', $params, 'sortorder, id ASC');
                     $enrols = enrol_get_plugins(true);
                     // First ask all enabled enrol instances in course if they want to auto enrol user.
+                    }
                     $PAGE->set_context(null);
                     // We need to override the navigation URL as the course won't have been added to the navigation and thus
                     // the navigation will mess up when trying to find it.
                     navigation_node::override_active_url(new moodle_url('/'));
-                    notice(get_string('coursehidden'), $CFG->wwwroot .'/');
+                    notice(get_string('coursehidden'), $CFG->wwwroot . '/');
+                }
+            }
+        }
                 throw new require_login_exception('Not enrolled');
+            }
             if ($setwantsurltome) {
                 $SESSION->wantsurl = qualified_me();
+            }
-            redirect($CFG->wwwroot .'/enrol/index.php?id='. $course->id);
+            redirect($CFG->wwwroot . '/enrol/index.php?id=' . $course->id);
+        }
+    }
     // Check whether the activity has been scheduled for deletion. If so, then deny access, even for admins.
 /**
  * A convenience function for where we must be logged in as admin
  * @return void
  */
+function require_admin()
 function require_admin() {
     require_login(null, false);
     require_capability('moodle/site:config', context_system::instance());
+}
 /**
  * This function just makes sure a user is logged out.
+ *
  * @package    core_access
  * @category   access
+ */
- */
+function require_logout()
 function require_logout() {
     global $USER, $DB;
             'userid' => $USER->id,
             'objectid' => $USER->id,
             'other' => array('sessionid' => $sid),
+        )
     );
-    if ($session = $DB->get_record('sessions', array('sid'=>$sid))) {
+    if ($session = $DB->get_record('sessions', array('sid' => $sid))) {
         $event->add_record_snapshot('sessions', $session);
+    }
     // Clone of $USER object to be used by auth plugins.
  *             in order to keep redirects working properly. MDL-14495
  * @param bool $preventredirect set to true in scripts that can not redirect (CLI, rss feeds, etc.), throws exceptions
  * @return void
  * @throws coding_exception
  */
-function require_course_login($courseorid, $autologinguest = true, $cm = null, $setwantsurltome = true, $preventredirect = false) {
+function require_course_login($courseorid, $autologinguest = true, $cm = null, $setwantsurltome = true, $preventredirect = false)
+{
     global $CFG, $PAGE, $SITE;
     $issite = ((is_object($courseorid) and $courseorid->id == SITEID)
-          or (!is_object($courseorid) and $courseorid == SITEID));
+        or (!is_object($courseorid) and $courseorid == SITEID));
     if ($issite && !empty($cm) && !($cm instanceof cm_info)) {
         // Note: nearly all pages call get_fast_modinfo anyway and it does not make any
         // db queries so this is not really a performance concern, however it is obviously
         // better if you use get_fast_modinfo to get the cm before calling this.
         if (is_object($courseorid)) {
             $course = $courseorid;
         } else {
-            $course = clone($SITE);
+            $course = clone ($SITE);
+        }
         $modinfo = get_fast_modinfo($course);
         $cm = $modinfo->get_cm($cm->id);
+    }
     if (!empty($CFG->forcelogin)) {
         // Login required for both SITE and courses.
         require_login($courseorid, $autologinguest, $cm, $setwantsurltome, $preventredirect);
     } else if ($issite && !empty($cm) and !$cm->uservisible) {
         // Always login for hidden activities.
         require_login($courseorid, $autologinguest, $cm, $setwantsurltome, $preventredirect);
     } else if (isloggedin() && !isguestuser()) {
         // User is already logged in. Make sure the login is complete (user is fully setup, policies agreed).
         require_login($courseorid, $autologinguest, $cm, $setwantsurltome, $preventredirect);
     } else if ($issite) {
         // Login for SITE not required.
         // We still need to instatiate PAGE vars properly so that things that rely on it like navigation function correctly.
         if (!empty($courseorid)) {
             if (is_object($courseorid)) {
         // Do not update access time for webservice or ajax requests.
         if (!WS_SERVER && !AJAX_SCRIPT) {
             user_accesstime_log(SITEID);
+        }
         return;
     } else {
         // Course login always required.
         require_login($courseorid, $autologinguest, $cm, $setwantsurltome, $preventredirect);
+    }
+}
  * @param  int $instance    instance id
  * @return stdClass the key entry in the user_private_key table
  * @since Moodle 3.2
  * @throws moodle_exception
  */
-function validate_user_key($keyvalue, $script, $instance) {
+function validate_user_key($keyvalue, $script, $instance)
+{
     global $DB;
     if (!$key = $DB->get_record('user_private_key', array('script' => $script, 'value' => $keyvalue, 'instance' => $instance))) {
         throw new \moodle_exception('invalidkey');
  * @param string $script unique script identifier
  * @param int $instance optional instance id
  * @param string $keyvalue The key. If not supplied, this will be fetched from the current session.
  * @return int Instance ID
  */
-function require_user_key_login($script, $instance = null, $keyvalue = null) {
+function require_user_key_login($script, $instance = null, $keyvalue = null)
+{
     global $DB;
     if (!NO_MOODLE_COOKIES) {
         throw new \moodle_exception('sessioncookiesdisable');
  * @param int $instance optional instance id
  * @param string $iprestriction optional ip restricted access
  * @param int $validuntil key valid only until given data
  * @return string access key value
  */
-function create_user_key($script, $userid, $instance=null, $iprestriction=null, $validuntil=null) {
+function create_user_key($script, $userid, $instance = null, $iprestriction = null, $validuntil = null)
+{
     global $DB;
     $key = new stdClass();
     $key->script        = $script;
     $key->iprestriction = $iprestriction;
     $key->validuntil    = $validuntil;
     $key->timecreated   = time();
     // Something long and unique.
-    $key->value         = md5($userid.'_'.time().random_string(40));
+    $key->value         = md5($userid . '_' . time() . random_string(40));
     while ($DB->record_exists('user_private_key', array('value' => $key->value))) {
         // Must be unique.
-        $key->value     = md5($userid.'_'.time().random_string(40));
+        $key->value     = md5($userid . '_' . time() . random_string(40));
+    }
     $DB->insert_record('user_private_key', $key);
     return $key->value;
+ *
  * @param string $script unique target identifier
  * @param int $userid
  * @return void
  */
-function delete_user_key($script, $userid) {
+function delete_user_key($script, $userid)
+{
     global $DB;
     $DB->delete_records('user_private_key', array('script' => $script, 'userid' => $userid));
+}
  * @param int $instance optional instance id
  * @param string $iprestriction optional ip restricted access
  * @param int $validuntil key valid only until given date
  * @return string access key value
  */
-function get_user_key($script, $userid, $instance=null, $iprestriction=null, $validuntil=null) {
+function get_user_key($script, $userid, $instance = null, $iprestriction = null, $validuntil = null)
+{
     global $DB;
+    if ($key = $DB->get_record('user_private_key', array(
+        'script' => $script,
+        'userid' => $userid,
-    if ($key = $DB->get_record('user_private_key', array('script' => $script, 'userid' => $userid,
+        'instance' => $instance,
-                                                         'instance' => $instance, 'iprestriction' => $iprestriction,
+        'iprestriction' => $iprestriction,
+        'validuntil' => $validuntil
-                                                         'validuntil' => $validuntil))) {
+    ))) {
         return $key->value;
     } else {
         return create_user_key($script, $userid, $instance, $iprestriction, $validuntil);
+    }
 /**
  * Modify the user table by setting the currently logged in user's last login to now.
+ *
  * @return bool Always returns true
  */
-function update_user_login_times() {
+function update_user_login_times()
+{
     global $USER, $DB, $SESSION;
     if (isguestuser()) {
         // Do not update guest access times/ips for performance.
+ *
  * @param stdClass $user A {@link $USER} object to test for the existence of a valid name and email
  * @param bool $strict Be more strict and assert id and custom profile fields set, too
  * @return bool
  */
-function user_not_fully_set_up($user, $strict = true) {
+function user_not_fully_set_up($user, $strict = true)
+{
     global $CFG, $SESSION, $USER;
-    require_once($CFG->dirroot.'/user/profile/lib.php');
+    require_once($CFG->dirroot . '/user/profile/lib.php');
     // If the user is setup then store this in the session to avoid re-checking.
     // Some edge cases are when the users email starts to bounce or the
     // configuration for custom fields has changed while they are logged in so
+    // we re-check this fully every hour for the rare cases it has changed.
-    // we re-check this fully every hour for the rare cases it has changed.
+    if (
-    if (isset($USER->id) && isset($user->id) && $USER->id === $user->id &&
+        isset($USER->id) && isset($user->id) && $USER->id === $user->id &&
+        isset($SESSION->fullysetupstrict) && (time() - $SESSION->fullysetupstrict) < HOURSECS
-         isset($SESSION->fullysetupstrict) && (time() - $SESSION->fullysetupstrict) < HOURSECS) {
+    ) {
         return false;
+    }
  * Check whether the user has exceeded the bounce threshold
+ *
  * @param stdClass $user A {@link $USER} object
  * @return bool true => User has exceeded bounce threshold
  */
-function over_bounce_threshold($user) {
+function over_bounce_threshold($user)
+{
     global $CFG, $DB;
     if (empty($CFG->handlebounces)) {
         return false;
     if (empty($CFG->bounceratio)) {
         $CFG->bounceratio = .20;
+    }
     $bouncecount = 0;
     $sendcount = 0;
-    if ($bounce = $DB->get_record('user_preferences', array ('userid' => $user->id, 'name' => 'email_bounce_count'))) {
+    if ($bounce = $DB->get_record('user_preferences', array('userid' => $user->id, 'name' => 'email_bounce_count'))) {
         $bouncecount = $bounce->value;
+    }
     if ($send = $DB->get_record('user_preferences', array('userid' => $user->id, 'name' => 'email_send_count'))) {
         $sendcount = $send->value;
+    }
-    return ($bouncecount >= $CFG->minbounces && $bouncecount/$sendcount >= $CFG->bounceratio);
+    return ($bouncecount >= $CFG->minbounces && $bouncecount / $sendcount >= $CFG->bounceratio);
+}
 /**
  * Used to increment or reset email sent count
+ *
  * @param stdClass $user object containing an id
  * @param bool $reset will reset the count to 0
  * @return void
  */
+function set_send_count($user, $reset = false)
 function set_send_count($user, $reset=false) {
     global $DB;
     if (empty($user->id)) {
         // No real (DB) user, nothing to do here.
         return;
     }
     if ($pref = $DB->get_record('user_preferences', array('userid' => $user->id, 'name' => 'email_send_count'))) {
-        $pref->value = (!empty($reset)) ? 0 : $pref->value+1;
+        $pref->value = (!empty($reset)) ? 0 : $pref->value + 1;
         $DB->update_record('user_preferences', $pref);
     } else if (!empty($reset)) {
  * Increment or reset user's email bounce count
+ *
  * @param stdClass $user object containing an id
  * @param bool $reset will reset the count to 0
  */
-function set_bounce_count($user, $reset=false) {
+function set_bounce_count($user, $reset = false)
+{
     global $DB;
     if ($pref = $DB->get_record('user_preferences', array('userid' => $user->id, 'name' => 'email_bounce_count'))) {
-        $pref->value = (!empty($reset)) ? 0 : $pref->value+1;
+        $pref->value = (!empty($reset)) ? 0 : $pref->value + 1;
         $DB->update_record('user_preferences', $pref);
     } else if (!empty($reset)) {
         // If it's not there and we're resetting, don't bother. Make a new one.
         $pref = new stdClass();
  * Determines if the logged in user is currently moving an activity
+ *
  * @param int $courseid The id of the course being tested
  * @return bool
  */
-function ismoving($courseid) {
+function ismoving($courseid)
+{
     global $USER;
     if (!empty($USER->activitycopy)) {
         return ($USER->activitycopycourse == $courseid);
+ *
  * @param stdClass $user A {@link $USER} object to get full name of.
  * @param bool $override If true then the alternativefullnameformat format rather than fullnamedisplay format will be used.
  * @return string
  */
-function fullname($user, $override=false) {
+function fullname($user, $override = false)
+{
     // Note: We do not intend to deprecate this function any time soon as it is too widely used at this time.
     // Uses of it should be updated to use the new API and pass updated arguments.
     // Return an empty string if there is no user.
  * @param string $prefix prefix to be added to all fields (including $additionalfields) e.g. authorfirstname.
  * @param array $additionalfields Additional fields to be matched with data in the second object.
  * The key can be set to the user table field name.
  * @return object User name fields.
  */
-function username_load_fields_from_object($addtoobject, $secondobject, $prefix = null, $additionalfields = null) {
+function username_load_fields_from_object($addtoobject, $secondobject, $prefix = null, $additionalfields = null)
+{
     $fields = [];
     foreach (\core_user\fields::get_name_fields() as $field) {
         $fields[$field] = $prefix . $field;
+    }
     if ($additionalfields) {
+ *
  * @param array $values Values to be found in the string format
  * @param string $stringformat The string which may contain values being searched for.
  * @return array An array of values in order according to placement in the string format.
  */
-function order_in_string($values, $stringformat) {
+function order_in_string($values, $stringformat)
+{
     $valuearray = array();
     foreach ($values as $value) {
         $pattern = "/$value\b/";
         // Using preg_match as strpos() may match values that are similar e.g. firstname and firstnamephonetic.
         if (preg_match($pattern, $stringformat)) {
  * Returns whether a given authentication plugin exists.
+ *
  * @param string $auth Form of authentication to check for. Defaults to the global setting in {@link $CFG}.
  * @return boolean Whether the plugin is available.
  */
-function exists_auth_plugin($auth) {
+function exists_auth_plugin($auth)
+{
     global $CFG;
     if (file_exists("{$CFG->dirroot}/auth/$auth/auth.php")) {
         return is_readable("{$CFG->dirroot}/auth/$auth/auth.php");
  * Checks if a given plugin is in the list of enabled authentication plugins.
+ *
  * @param string $auth Authentication plugin.
  * @return boolean Whether the plugin is enabled.
  */
-function is_enabled_auth($auth) {
+function is_enabled_auth($auth)
+{
     if (empty($auth)) {
         return false;
+    }
  * Returns an authentication plugin instance.
+ *
  * @param string $auth name of authentication plugin
  * @return auth_plugin_base An instance of the required authentication plugin.
  */
-function get_auth_plugin($auth) {
+function get_auth_plugin($auth)
+{
     global $CFG;
     // Check the plugin exists first.
     if (! exists_auth_plugin($auth)) {
  * Returns array of active auth plugins.
+ *
  * @param bool $fix fix $CFG->auth if needed. Only set if logged in as admin.
  * @return array
  */
-function get_enabled_auth_plugins($fix=false) {
+function get_enabled_auth_plugins($fix = false)
+{
     global $CFG;
     $default = array('manual', 'nologin');
  * if method not specified then, global default is assumed
+ *
  * @param string $auth Form of authentication required
  * @return bool
  */
-function is_internal_auth($auth) {
+function is_internal_auth($auth)
+{
     // Throws error if bad $auth.
     $authplugin = get_auth_plugin($auth);
     return $authplugin->is_internal();
+}
  * Used in the login process to inform the user and allow him/her to reset the password
+ *
  * @param string $username username to be checked
  * @return bool
  */
-function is_restored_user($username) {
+function is_restored_user($username)
+{
     global $CFG, $DB;
     return $DB->record_exists('user', array('username' => $username, 'mnethostid' => $CFG->mnet_localhost_id, 'password' => 'restored'));
+}
 /**
  * Returns an array of user fields
+ *
  * @return array User field/column names
+ */
- */
+function get_user_fieldnames()
 function get_user_fieldnames() {
     global $DB;
 /**
  * Returns the string of the language for the new user.
+ *
  * @return string language for the new user
  */
-function get_newuser_language() {
+function get_newuser_language()
+{
     global $CFG, $SESSION;
     return (!empty($CFG->autolangusercreation) && !empty($SESSION->lang)) ? $SESSION->lang : $CFG->lang;
+}
  * @param string $username New user's username to add to record
  * @param string $password New user's password to add to record
  * @param string $auth Form of authentication required
  * @return stdClass A complete user object
  */
-function create_user_record($username, $password, $auth = 'manual') {
+function create_user_record($username, $password, $auth = 'manual')
+{
     global $CFG, $DB, $SESSION;
-    require_once($CFG->dirroot.'/user/profile/lib.php');
+    require_once($CFG->dirroot . '/user/profile/lib.php');
-    require_once($CFG->dirroot.'/user/lib.php');
+    require_once($CFG->dirroot . '/user/lib.php');
     // Just in case check text case.
     $username = trim(core_text::strtolower($username));
     // Save user profile data.
     profile_save_data($newuser);
     $user = get_complete_user_data('id', $newuser->id);
-    if (!empty($CFG->{'auth_'.$newuser->auth.'_forcechangepassword'})) {
+    if (!empty($CFG->{'auth_' . $newuser->auth . '_forcechangepassword'})) {
         set_user_preference('auth_forcepasswordchange', 1, $user);
+    }
  * Will update a local user record from an external source (MNET users can not be updated using this method!).
+ *
  * @param string $username user's username to update the record
  * @return stdClass A complete user object
  */
-function update_user_record($username) {
+function update_user_record($username)
+{
     global $DB, $CFG;
     // Just in case check text case.
     $username = trim(core_text::strtolower($username));
  * Will update a local user record from an external source (MNET users can not be updated using this method!).
+ *
  * @param int $id user id
  * @return stdClass A complete user object
  */
-function update_user_record_by_id($id) {
+function update_user_record_by_id($id)
+{
     global $DB, $CFG;
-    require_once($CFG->dirroot."/user/profile/lib.php");
+    require_once($CFG->dirroot . "/user/profile/lib.php");
-    require_once($CFG->dirroot.'/user/lib.php');
+    require_once($CFG->dirroot . '/user/lib.php');
     $params = array('mnethostid' => $CFG->mnet_localhost_id, 'id' => $id, 'deleted' => 0);
     $oldinfo = $DB->get_record('user', $params, '*', MUST_EXIST);
             $iscustom = in_array($key, $customfields);
             if (!$iscustom) {
                 $key = strtolower($key);
+            }
             if ((!property_exists($oldinfo, $key) && !$iscustom) or $key === 'username' or $key === 'id'
-                    or $key === 'auth' or $key === 'mnethostid' or $key === 'deleted') {
+                or $key === 'auth' or $key === 'mnethostid' or $key === 'deleted'
+            ) {
                 // Unknown or must not be changed.
                 continue;
+            }
             if (empty($userauth->config->{'field_updatelocal_' . $key}) || empty($userauth->config->{'field_lock_' . $key})) {
                 continue;
                 // in a value for the selected field _if LDAP is giving
                 // nothing_ for this field. Thus it makes sense to let this value
                 // stand in until LDAP is giving a value for this field.
                 if (!(empty($value) && $lockval === 'unlockedifempty')) {
                     if ($iscustom || (in_array($key, $userauth->userfields) &&
-                            ((string)$oldinfo->$key !== (string)$value))) {
+                        ((string)$oldinfo->$key !== (string)$value))) {
                         $newuser[$key] = (string)$value;
+                    }
+                }
+            }
+        }
  * Will truncate userinfo as it comes from auth_get_userinfo (from external auth) which may have large fields.
+ *
  * @param array $info Array of user properties to truncate if needed
  * @return array The now truncated information that was passed in
  */
-function truncate_userinfo(array $info) {
+function truncate_userinfo(array $info)
+{
     // Define the limits.
     $limit = array(
         'username'    => 100,
         'idnumber'    => 255,
         'firstname'   => 100,
+ *
  * @param stdClass $user full user object before delete
  * @return boolean success
  * @throws coding_exception if invalid $user parameter detected
  */
-function delete_user(stdClass $user) {
+function delete_user(stdClass $user)
+{
     global $CFG, $DB, $SESSION;
-    require_once($CFG->libdir.'/grouplib.php');
+    require_once($CFG->libdir . '/grouplib.php');
-    require_once($CFG->libdir.'/gradelib.php');
+    require_once($CFG->libdir . '/gradelib.php');
-    require_once($CFG->dirroot.'/message/lib.php');
+    require_once($CFG->dirroot . '/message/lib.php');
-    require_once($CFG->dirroot.'/user/lib.php');
+    require_once($CFG->dirroot . '/user/lib.php');
     // Make sure nobody sends bogus record type as parameter.
     if (!property_exists($user, 'id') or !property_exists($user, 'username')) {
         throw new coding_exception('Invalid $user parameter in delete_user() detected');
     // Mark internal user record as "deleted".
     $updateuser = new stdClass();
     $updateuser->id           = $user->id;
     $updateuser->deleted      = 1;
     $updateuser->username     = $delname;            // Remember it just in case.
-    $updateuser->email        = md5($user->username);// Store hash of username, useful importing/restoring users.
+    $updateuser->email        = md5($user->username); // Store hash of username, useful importing/restoring users.
     $updateuser->idnumber     = '';                  // Clear this field to free it up.
     $updateuser->picture      = 0;
     $updateuser->timemodified = $deltime;
     \core_search\manager::context_deleted($usercontext);
     // Any plugin that needs to cleanup should register this event.
     // Trigger event.
     $event = \core\event\user_deleted::create(
-            array(
+        array(
-                'objectid' => $user->id,
+            'objectid' => $user->id,
-                'relateduserid' => $user->id,
+            'relateduserid' => $user->id,
-                'context' => $usercontext,
+            'context' => $usercontext,
-                'other' => array(
+            'other' => array(
-                    'username' => $user->username,
+                'username' => $user->username,
-                    'email' => $user->email,
+                'email' => $user->email,
-                    'idnumber' => $user->idnumber,
+                'idnumber' => $user->idnumber,
-                    'picture' => $user->picture,
+                'picture' => $user->picture,
-                    'mnethostid' => $user->mnethostid
+                'mnethostid' => $user->mnethostid
-                    )
+            )
-                )
+        )
-            );
+    );
     $event->add_record_snapshot('user', $olduser);
     $event->trigger();
 /**
  * Retrieve the guest user object.
+ *
  * @return stdClass A {@link $USER} object
  */
-function guest_user() {
+function guest_user()
+{
     global $CFG, $DB;
     if ($newuser = $DB->get_record('user', array('id' => $CFG->siteguest))) {
         $newuser->confirmed = 1;
                 'username' => $username,
                 'reason' => $failurereason,
             ],
         ])->trigger();
-        error_log('[client '.getremoteaddr()."]  $CFG->wwwroot  Invalid Login Token:  $username  ".$_SERVER['HTTP_USER_AGENT']);
+        error_log('[client ' . getremoteaddr() . "]  $CFG->wwwroot  Invalid Login Token:  $username  " . $_SERVER['HTTP_USER_AGENT']);
         return false;
+    }
         if (!empty($user->suspended)) {
             $failurereason = AUTH_LOGIN_SUSPENDED;
+            // Trigger login failed event.
-            // Trigger login failed event.
+            $event = \core\event\user_login_failed::create(array(
+                'userid' => $user->id,
-            $event = \core\event\user_login_failed::create(array('userid' => $user->id,
+                'other' => array('username' => $username, 'reason' => $failurereason)
-                    'other' => array('username' => $username, 'reason' => $failurereason)));
+            ));
             $event->trigger();
-            error_log('[client '.getremoteaddr()."]  $CFG->wwwroot  Suspended Login:  $username  ".$_SERVER['HTTP_USER_AGENT']);
+            error_log('[client ' . getremoteaddr() . "]  $CFG->wwwroot  Suspended Login:  $username  " . $_SERVER['HTTP_USER_AGENT']);
             return false;
+        }
-        if ($auth=='nologin' or !is_enabled_auth($auth)) {
+        if ($auth == 'nologin' or !is_enabled_auth($auth)) {
             // Legacy way to suspend user.
             $failurereason = AUTH_LOGIN_SUSPENDED;
+            // Trigger login failed event.
+            $event = \core\event\user_login_failed::create(array(
-            // Trigger login failed event.
+                'userid' => $user->id,
-            $event = \core\event\user_login_failed::create(array('userid' => $user->id,
+                'other' => array('username' => $username, 'reason' => $failurereason)
-                    'other' => array('username' => $username, 'reason' => $failurereason)));
+            ));
             $event->trigger();
-            error_log('[client '.getremoteaddr()."]  $CFG->wwwroot  Disabled Login:  $username  ".$_SERVER['HTTP_USER_AGENT']);
+            error_log('[client ' . getremoteaddr() . "]  $CFG->wwwroot  Disabled Login:  $username  " . $_SERVER['HTTP_USER_AGENT']);
-            return false;
             return false;
         $auths = array($auth);
         $auths = array($auth);
     } else {
         // Check if there's a deleted record (cheaply), this should not happen because we mangle usernames in delete_user().
         if ($DB->get_field('user', 'id', array('username' => $username, 'mnethostid' => $CFG->mnet_localhost_id,  'deleted' => 1))) {
+            $failurereason = AUTH_LOGIN_NOUSER;
-            $failurereason = AUTH_LOGIN_NOUSER;
+            // Trigger login failed event.
             $event = \core\event\user_login_failed::create(array('other' => array(
-            // Trigger login failed event.
+                'username' => $username,
-            $event = \core\event\user_login_failed::create(array('other' => array('username' => $username,
+                'reason' => $failurereason
-                    'reason' => $failurereason)));
+            )));
             $event->trigger();
-            error_log('[client '.getremoteaddr()."]  $CFG->wwwroot  Deleted Login:  $username  ".$_SERVER['HTTP_USER_AGENT']);
+            error_log('[client ' . getremoteaddr() . "]  $CFG->wwwroot  Deleted Login:  $username  " . $_SERVER['HTTP_USER_AGENT']);
         // Verify login lockout after other ways that may prevent user login.
         if (login_is_lockedout($user)) {
             $failurereason = AUTH_LOGIN_LOCKOUT;
             // Trigger login failed event.
+            $event = \core\event\user_login_failed::create(array(
-            $event = \core\event\user_login_failed::create(array('userid' => $user->id,
+                'userid' => $user->id,
+                'other' => array('username' => $username, 'reason' => $failurereason)
-                    'other' => array('username' => $username, 'reason' => $failurereason)));
+            ));
             $event->trigger();
-            error_log('[client '.getremoteaddr()."]  $CFG->wwwroot  Login lockout:  $username  ".$_SERVER['HTTP_USER_AGENT']);
+            error_log('[client ' . getremoteaddr() . "]  $CFG->wwwroot  Login lockout:  $username  " . $_SERVER['HTTP_USER_AGENT']);
             $SESSION->loginerrormsg = get_string('accountlocked', 'admin');
             // The user is authenticated but user creation may be disabled.
             if (!empty($CFG->authpreventaccountcreation)) {
                 $failurereason = AUTH_LOGIN_UNAUTHORISED;
                 // Trigger login failed event.
+                $event = \core\event\user_login_failed::create(array('other' => array(
-                $event = \core\event\user_login_failed::create(array('other' => array('username' => $username,
+                    'username' => $username,
+                    'reason' => $failurereason
-                        'reason' => $failurereason)));
+                )));
                 $event->trigger();
-                error_log('[client '.getremoteaddr()."]  $CFG->wwwroot  Unknown user, can not create new accounts:  $username  ".
+                error_log('[client ' . getremoteaddr() . "]  $CFG->wwwroot  Unknown user, can not create new accounts:  $username  " .
-                        $_SERVER['HTTP_USER_AGENT']);
+                    $_SERVER['HTTP_USER_AGENT']);
                 return false;
             } else {
                 $user = create_user_record($username, $password, $auth);
+        }
         if (empty($user->id)) {
             $failurereason = AUTH_LOGIN_NOUSER;
             // Trigger login failed event.
+            $event = \core\event\user_login_failed::create(array('other' => array(
-            $event = \core\event\user_login_failed::create(array('other' => array('username' => $username,
+                'username' => $username,
+                'reason' => $failurereason
-                    'reason' => $failurereason)));
+            )));
             $event->trigger();
             return false;
+        }
         if (!empty($user->suspended)) {
             // Just in case some auth plugin suspended account.
             $failurereason = AUTH_LOGIN_SUSPENDED;
+            // Trigger login failed event.
-            // Trigger login failed event.
+            $event = \core\event\user_login_failed::create(array(
+                'userid' => $user->id,
-            $event = \core\event\user_login_failed::create(array('userid' => $user->id,
+                'other' => array('username' => $username, 'reason' => $failurereason)
-                    'other' => array('username' => $username, 'reason' => $failurereason)));
+            ));
             $event->trigger();
-            error_log('[client '.getremoteaddr()."]  $CFG->wwwroot  Suspended Login:  $username  ".$_SERVER['HTTP_USER_AGENT']);
+            error_log('[client ' . getremoteaddr() . "]  $CFG->wwwroot  Suspended Login:  $username  " . $_SERVER['HTTP_USER_AGENT']);
             return false;
+        }
         login_attempt_valid($user);
         $failurereason = AUTH_LOGIN_OK;
         return $user;
     }
     // Failed if all the plugins have failed.
     if (debugging('', DEBUG_ALL)) {
-        error_log('[client '.getremoteaddr()."]  $CFG->wwwroot  Failed Login:  $username  ".$_SERVER['HTTP_USER_AGENT']);
+        error_log('[client ' . getremoteaddr() . "]  $CFG->wwwroot  Failed Login:  $username  " . $_SERVER['HTTP_USER_AGENT']);
+    }
+    if ($user->id) {
-    if ($user->id) {
+        login_attempt_failed($user);
+        $failurereason = AUTH_LOGIN_FAILED;
-        login_attempt_failed($user);
+        // Trigger login failed event.
-        $failurereason = AUTH_LOGIN_FAILED;
+        $event = \core\event\user_login_failed::create(array(
-        // Trigger login failed event.
+            'userid' => $user->id,
-        $event = \core\event\user_login_failed::create(array('userid' => $user->id,
+            'other' => array('username' => $username, 'reason' => $failurereason)
-                'other' => array('username' => $username, 'reason' => $failurereason)));
+        ));
+        $event->trigger();
-        $event->trigger();
+    } else {
+        $failurereason = AUTH_LOGIN_NOUSER;
-    } else {
+        // Trigger login failed event.
-        $failurereason = AUTH_LOGIN_NOUSER;
+        $event = \core\event\user_login_failed::create(array('other' => array(
-        // Trigger login failed event.
+            'username' => $username,
-        $event = \core\event\user_login_failed::create(array('other' => array('username' => $username,
+            'reason' => $failurereason
+ *
  * @param stdClass $user
  * @param array $extrauserinfo
  * @return stdClass A {@link $USER} object - BC only, do not use
  */
-function complete_user_login($user, array $extrauserinfo = []) {
+function complete_user_login($user, array $extrauserinfo = [])
+{
     global $CFG, $DB, $USER, $SESSION;
     \core\session\manager::login_user($user);
             if ($changeurl = $userauth->change_password_url()) {
                 redirect($changeurl);
             } else {
                 require_once($CFG->dirroot . '/login/lib.php');
                 $SESSION->wantsurl = core_login_get_return_url();
-                redirect($CFG->wwwroot.'/login/change_password.php');
+                redirect($CFG->wwwroot . '/login/change_password.php');
+            }
         } else {
             throw new \moodle_exception('nopasswordchangeforced', 'auth');
+        }
+    }
  * Check a password hash to see if it was hashed using the legacy hash algorithm (bcrypt).
+ *
  * @param string $password String to check.
  * @return bool True if the $password matches the format of a bcrypt hash.
  */
-function password_is_legacy_hash(#[\SensitiveParameter] string $password): bool {
+function password_is_legacy_hash(#[\SensitiveParameter] string $password): bool
+{
     return (bool) preg_match('/^\$2y\$[\d]{2}\$[A-Za-z0-9\.\/]{53}$/', $password);
+}
 /**
  * Calculate the Shannon entropy of a string.
+ *
  * @param string $pepper The pepper to calculate the entropy of.
  * @return float The Shannon entropy of the string.
  */
+function calculate_entropy(#[\SensitiveParameter] string $pepper): float
 function calculate_entropy(#[\SensitiveParameter] string $pepper): float {
     // Initialize entropy.
     $h = 0;
  * Also, we allow the latest pepper to be empty, to allow admins to migrate off peppers.
+ *
  * @return array The password peppers.
  * @throws coding_exception If the entropy of the password pepper is less than the recommended minimum.
  */
-function get_password_peppers(): array {
+function get_password_peppers(): array
+{
     global $CFG;
     // Get all available peppers.
     if (isset($CFG->passwordpeppers) && is_array($CFG->passwordpeppers)) {
     // Check if the entropy of the most recent pepper is less than the minimum.
     // Also, we allow the most recent pepper to be empty, to allow admins to migrate off peppers.
     $lastpepper = reset($peppers);
     if (!empty($peppers) && $lastpepper !== '' && calculate_entropy($lastpepper) < PEPPER_ENTROPY) {
         throw new coding_exception(
-                'password pepper below minimum',
+            'password pepper below minimum',
-                'The entropy of the password pepper is less than the recommended minimum.');
+            'The entropy of the password pepper is less than the recommended minimum.'
+        );
+    }
     return $peppers;
+}
+ *
  * @param stdClass $user (Password property may be updated).
  * @param string $password Plain text password.
  * @return bool True if password is valid.
  */
-function validate_internal_user_password(stdClass $user, #[\SensitiveParameter] string $password): bool {
+function validate_internal_user_password(stdClass $user, #[\SensitiveParameter] string $password): bool
+{
     if (exceeds_password_length($password)) {
         // Password cannot be more than MAX_PASSWORD_CHARACTERS characters.
         return false;
  * @param int $pepperlength Lenght of the peppers
  * @return string The hashed password.
+ *
  * @throws moodle_exception If a problem occurs while generating the hash.
  */
-function hash_internal_user_password(#[\SensitiveParameter] string $password, $fasthash = false, $pepperlength = 0): string {
+function hash_internal_user_password(#[\SensitiveParameter] string $password, $fasthash = false, $pepperlength = 0): string
+{
     if (exceeds_password_length($password, $pepperlength)) {
         // Password cannot be more than MAX_PASSWORD_CHARACTERS.
         throw new \moodle_exception(get_string("passwordexceeded", 'error', MAX_PASSWORD_CHARACTERS));
+    }
  *                       less secure. It is used when lots of hashes need to
  *                       be generated quickly.
  * @return bool Always returns true.
  */
 function update_internal_user_password(
-        stdClass $user,
+    stdClass $user,
-        #[\SensitiveParameter] ?string $password,
+    #[\SensitiveParameter] ?string $password,
-        bool $fasthash = false
+    bool $fasthash = false
 ): bool {
     global $CFG, $DB;
     // Add the latest password pepper to the password before further processing.
         $password = $password . reset($peppers);
+    }
     // Figure out what the hashed password should be.
+    if (!isset($user->auth)) {
-    if (!isset($user->auth)) {
+        debugging(
-        debugging('User record in update_internal_user_password() must include field auth',
+            'User record in update_internal_user_password() must include field auth',
+            DEBUG_DEVELOPER
-                DEBUG_DEVELOPER);
+        );
         $user->auth = $DB->get_field('user', 'auth', array('id' => $user->id));
+    }
     $authplugin = get_auth_plugin($user->auth);
     if ($authplugin->prevent_local_passwords()) {
     $algorithmchanged = false;
     if ($hashedpassword === AUTH_PASSWORD_NOT_CACHED) {
         // Password is not cached, update it if not set to AUTH_PASSWORD_NOT_CACHED.
-        $passwordchanged = ($user->password !== $hashedpassword);
         $passwordchanged = ($user->password !== $hashedpassword);
     } else if (isset($user->password)) {
         // If verification fails then it means the password has changed.
         $passwordchanged = !password_verify($password, $user->password);
         $algorithmchanged = password_is_legacy_hash($user->password);
         $user = $DB->get_record('user', array('id' => $user->id));
         \core\event\user_password_updated::create_from_user($user)->trigger();
         // Remove WS user tokens.
         if (!empty($CFG->passwordchangetokendeletion)) {
-            require_once($CFG->dirroot.'/webservice/lib.php');
+            require_once($CFG->dirroot . '/webservice/lib.php');
             webservice::delete_user_ws_tokens($user->id);
+        }
+    }
  * @param int $mnethostid
  * @param bool $throwexception If true, it will throw an exception when there's no record found or when there are multiple records
  *                              found. Otherwise, it will just return false.
  * @return mixed False, or A {@link $USER} object.
  */
-function get_complete_user_data($field, $value, $mnethostid = null, $throwexception = false) {
+function get_complete_user_data($field, $value, $mnethostid = null, $throwexception = false)
+{
     global $CFG, $DB;
     if (!$field || !$value) {
         return false;
+    }
     // Add the custom profile fields to the user record.
     $user->profile = array();
     if (!isguestuser($user)) {
-        require_once($CFG->dirroot.'/user/profile/lib.php');
+        require_once($CFG->dirroot . '/user/profile/lib.php');
         profile_load_custom_fields($user);
+    }
  * @param string|null $errmsg the error message to display when the password doesn't comply with the policy.
  * @param stdClass|null $user the user object to perform password validation against. Defaults to null if not provided.
+ *
  * @return bool true if the password is valid according to the policy. false otherwise.
  */
-function check_password_policy(string $password, ?string &$errmsg, ?stdClass $user = null) {
+function check_password_policy(string $password, ?string &$errmsg, ?stdClass $user = null)
+{
     global $CFG;
     if (!empty($CFG->passwordpolicy) && !isguestuser($user)) {
         $errors = get_password_policy_errors($password, $user);
  * @param string $password the password to be checked against the password policy
  * @param stdClass|null $user the user object to perform password validation against. Defaults to null if not provided.
+ *
  * @return string[] Array of error messages.
  */
-function get_password_policy_errors(string $password, ?stdClass $user = null) : array {
+function get_password_policy_errors(string $password, ?stdClass $user = null): array
+{
     global $CFG;
     $errors = [];
+}
 /**
  * When logging in, this function is run to set certain preferences for the current SESSION.
  */
+function set_login_session_preferences()
 function set_login_session_preferences() {
     global $SESSION;
  * @param bool $showfeedback Whether to display notifications of each action the function performs.
  * @return bool true if all the removals succeeded. false if there were any failures. If this
  *             method returns false, some of the removals will probably have succeeded, and others
  *             failed, but you have no way of knowing which.
  */
-function delete_course($courseorid, $showfeedback = true) {
+function delete_course($courseorid, $showfeedback = true)
+{
     global $DB, $CFG;
     if (is_object($courseorid)) {
         $courseid = $courseorid->id;
         'context' => $context,
         'other' => array(
             'shortname' => $course->shortname,
             'fullname' => $course->fullname,
             'idnumber' => $course->idnumber
-            )
+        )
     ));
     $event->add_record_snapshot('course', $course);
     $event->trigger();
  * @param array $options extra options
  * @return bool true if all the removals succeeded. false if there were any failures. If this
  *             method returns false, some of the removals will probably have succeeded, and others
  *             failed, but you have no way of knowing which.
  */
-function remove_course_contents($courseid, $showfeedback = true, array $options = null) {
+function remove_course_contents($courseid, $showfeedback = true, array $options = null)
+{
     global $CFG, $DB, $OUTPUT;
-    require_once($CFG->libdir.'/badgeslib.php');
+    require_once($CFG->libdir . '/badgeslib.php');
-    require_once($CFG->libdir.'/completionlib.php');
+    require_once($CFG->libdir . '/completionlib.php');
-    require_once($CFG->libdir.'/questionlib.php');
+    require_once($CFG->libdir . '/questionlib.php');
-    require_once($CFG->libdir.'/gradelib.php');
+    require_once($CFG->libdir . '/gradelib.php');
-    require_once($CFG->dirroot.'/group/lib.php');
+    require_once($CFG->dirroot . '/group/lib.php');
-    require_once($CFG->dirroot.'/comment/lib.php');
+    require_once($CFG->dirroot . '/comment/lib.php');
-    require_once($CFG->dirroot.'/rating/lib.php');
+    require_once($CFG->dirroot . '/rating/lib.php');
-    require_once($CFG->dirroot.'/notes/lib.php');
+    require_once($CFG->dirroot . '/notes/lib.php');
     // Handle course badges.
     badges_handle_course_deletion($courseid);
     // NOTE: these concatenated strings are suboptimal, but it is just extra info...
-    $strdeleted = get_string('deleted').' - ';
+    $strdeleted = get_string('deleted') . ' - ';
     // Delete course completion information, this has to be done before grades and enrols.
     $cc = new completion_info($course);
     $cc->clear_criteria();
     if ($showfeedback) {
-        echo $OUTPUT->notification($strdeleted.get_string('completion', 'completion'), 'notifysuccess');
+        echo $OUTPUT->notification($strdeleted . get_string('completion', 'completion'), 'notifysuccess');
+    }
     // Remove all data from gradebook - this needs to be done before course modules
         blocks_delete_all_for_context($childcontext->id);
+    }
     unset($childcontexts);
     blocks_delete_all_for_context($coursecontext->id);
     if ($showfeedback) {
-        echo $OUTPUT->notification($strdeleted.get_string('type_block_plural', 'plugin'), 'notifysuccess');
+        echo $OUTPUT->notification($strdeleted . get_string('type_block_plural', 'plugin'), 'notifysuccess');
+    }
     $DB->set_field('course_modules', 'deletioninprogress', '1', ['course' => $courseid]);
         if ($modname === 'NEWMODULE') {
             continue;
+        }
         if (array_key_exists($modname, $allmodules)) {
             $sql = "SELECT cm.*, m.id AS modinstance, m.name, '$modname' AS modname
-              FROM {".$modname."} m
+              FROM {" . $modname . "} m
                    LEFT JOIN {course_modules} cm ON cm.instance = m.id AND cm.module = :moduleid
              WHERE m.course = :courseid";
-            $instances = $DB->get_records_sql($sql, array('courseid' => $course->id,
+            $instances = $DB->get_records_sql($sql, array(
+                'courseid' => $course->id,
+                'modulename' => $modname,
-                'modulename' => $modname, 'moduleid' => $allmodules[$modname]));
+                'moduleid' => $allmodules[$modname]
+            ));
             include_once("$moddir/lib.php");                 // Shows php warning only if plugin defective.
-            $moddelete = $modname .'_delete_instance';       // Delete everything connected to an instance.
+            $moddelete = $modname . '_delete_instance';       // Delete everything connected to an instance.
             if ($instances) {
                 foreach ($instances as $cm) {
                         rebuild_course_cache($cm->course, true);
+                    }
+                }
+            }
             if ($instances and $showfeedback) {
-                echo $OUTPUT->notification($strdeleted.get_string('pluginname', $modname), 'notifysuccess');
+                echo $OUTPUT->notification($strdeleted . get_string('pluginname', $modname), 'notifysuccess');
+            }
         } else {
             // Ooops, this module is not properly installed, force-delete it in the next block.
+        }
+    }
     $DB->delete_records("course_completion_defaults", array("course" => $courseid));
     // Remove all data from availability and completion tables that is associated
     // with course-modules belonging to this course. Note this is done even if the
+    // features are not enabled now, in case they were enabled previously.
-    // features are not enabled now, in case they were enabled previously.
+    $DB->delete_records_subquery(
+        'course_modules_completion',
+        'coursemoduleid',
-    $DB->delete_records_subquery('course_modules_completion', 'coursemoduleid', 'id',
+        'id',
+        'SELECT id from {course_modules} WHERE course = ?',
+        [$courseid]
-            'SELECT id from {course_modules} WHERE course = ?', [$courseid]);
+    );
+    $DB->delete_records_subquery(
+        'course_modules_viewed',
+        'coursemoduleid',
-    $DB->delete_records_subquery('course_modules_viewed', 'coursemoduleid', 'id',
+        'id',
+        'SELECT id from {course_modules} WHERE course = ?',
+        [$courseid]
-        'SELECT id from {course_modules} WHERE course = ?', [$courseid]);
+    );
     // Remove course-module data that has not been removed in modules' _delete_instance callbacks.
     $cms = $DB->get_records('course_modules', array('course' => $course->id));
         $DB->delete_records('course_modules', array('id' => $cm->id));
         rebuild_course_cache($cm->course, true);
+    }
     if ($showfeedback) {
-        echo $OUTPUT->notification($strdeleted.get_string('type_mod_plural', 'plugin'), 'notifysuccess');
+        echo $OUTPUT->notification($strdeleted . get_string('type_mod_plural', 'plugin'), 'notifysuccess');
+    }
     // Delete questions and question categories.
     question_delete_course($course);
     if ($showfeedback) {
-        echo $OUTPUT->notification($strdeleted.get_string('questions', 'question'), 'notifysuccess');
+        echo $OUTPUT->notification($strdeleted . get_string('questions', 'question'), 'notifysuccess');
+    }
     // Delete content bank contents.
     $cb = new \core_contentbank\contentbank();
     $cbdeleted = $cb->delete_contents($coursecontext);
     if ($showfeedback && $cbdeleted) {
-        echo $OUTPUT->notification($strdeleted.get_string('contentbank', 'contentbank'), 'notifysuccess');
+        echo $OUTPUT->notification($strdeleted . get_string('contentbank', 'contentbank'), 'notifysuccess');
+    }
         // permission to remove.
         $userid = $options['userid'] ?? null;
         enrol_course_delete($course, $userid);
         role_unassign_all(array('contextid' => $coursecontext->id, 'component' => ''), true);
         if ($showfeedback) {
-            echo $OUTPUT->notification($strdeleted.get_string('type_enrol_plural', 'plugin'), 'notifysuccess');
+            echo $OUTPUT->notification($strdeleted . get_string('type_enrol_plural', 'plugin'), 'notifysuccess');
+        }
+    }
     // Delete any groups, removing members and grouping/course links first.
         // there might be also files used by enrol plugins...
+    }
     // Delete legacy files - just in case some files are still left there after conversion to new file api,
     // also some non-standard unsupported plugins may try to store something there.
-    fulldelete($CFG->dataroot.'/'.$course->id);
+    fulldelete($CFG->dataroot . '/' . $course->id);
     // Delete from cache to reduce the cache size especially makes sense in case of bulk course deletion.
     course_modinfo::purge_course_cache($courseid);
     // Trigger a course content deleted event.
+    $event = \core\event\course_content_deleted::create(array(
-    $event = \core\event\course_content_deleted::create(array(
+        'objectid' => $course->id,
-        'objectid' => $course->id,
+        'context' => $coursecontext,
+        'other' => array(
-        'context' => $coursecontext,
+            'shortname' => $course->shortname,
-        'other' => array('shortname' => $course->shortname,
+            'fullname' => $course->fullname,
-                         'fullname' => $course->fullname,
+            'options' => $options
-                         'options' => $options) // Passing this for legacy reasons.
+        ) // Passing this for legacy reasons.
     ));
  * @param int $timeshift time difference
  * @param int $courseid
  * @param int $modid (Optional) passed if specific mod instance in course needs to be updated.
  * @return bool success
  */
-function shift_course_mod_dates($modname, $fields, $timeshift, $courseid, $modid = 0) {
+function shift_course_mod_dates($modname, $fields, $timeshift, $courseid, $modid = 0)
+{
     global $CFG, $DB;
-    include_once($CFG->dirroot.'/mod/'.$modname.'/lib.php');
+    include_once($CFG->dirroot . '/mod/' . $modname . '/lib.php');
     $return = true;
     $params = array($timeshift, $courseid);
     foreach ($fields as $field) {
-        $updatesql = "UPDATE {".$modname."}
+        $updatesql = "UPDATE {" . $modname . "}
                           SET $field = $field + ?
                         WHERE course=? AND $field<>0";
         if ($modid) {
             $updatesql .= ' AND id=?';
  * It will retain the activities and the structure of the course.
+ *
  * @param object $data an object containing all the settings including courseid (without magic quotes)
  * @return array status array of array component, item, error
  */
-function reset_course_userdata($data) {
+function reset_course_userdata($data)
+{
     global $CFG, $DB;
-    require_once($CFG->libdir.'/gradelib.php');
+    require_once($CFG->libdir . '/gradelib.php');
-    require_once($CFG->libdir.'/completionlib.php');
+    require_once($CFG->libdir . '/completionlib.php');
-    require_once($CFG->dirroot.'/completion/criteria/completion_criteria_date.php');
+    require_once($CFG->dirroot . '/completion/criteria/completion_criteria_date.php');
-    require_once($CFG->dirroot.'/group/lib.php');
+    require_once($CFG->dirroot . '/group/lib.php');
     $data->courseid = $data->id;
     $context = context_course::instance($data->courseid);
         if ($CFG->enablecompletion) {
             $modinfo = get_fast_modinfo($data->courseid);
             $changed = false;
             foreach ($modinfo->get_cms() as $cm) {
                 if ($cm->completion && !empty($cm->completionexpected)) {
+                    $DB->set_field(
+                        'course_modules',
+                        'completionexpected',
-                    $DB->set_field('course_modules', 'completionexpected', $cm->completionexpected + $data->timeshift,
+                        $cm->completionexpected + $data->timeshift,
-                        array('id' => $cm->id));
+                        array('id' => $cm->id)
+                    );
                     $changed = true;
+                }
+            }
         $DB->delete_records('event', array('courseid' => $data->courseid));
         $status[] = array('component' => $componentstr, 'item' => get_string('deleteevents', 'calendar'), 'error' => false);
+    }
     if (!empty($data->reset_notes)) {
-        require_once($CFG->dirroot.'/notes/lib.php');
+        require_once($CFG->dirroot . '/notes/lib.php');
         note_delete_all($data->courseid);
         $status[] = array('component' => $componentstr, 'item' => get_string('deletenotes', 'notes'), 'error' => false);
+    }
     if (!empty($data->delete_blog_associations)) {
-        require_once($CFG->dirroot.'/blog/lib.php');
+        require_once($CFG->dirroot . '/blog/lib.php');
         blog_remove_associations_for_course($data->courseid);
         $status[] = array('component' => $componentstr, 'item' => get_string('deleteblogassociations', 'blog'), 'error' => false);
+    }
     if (!empty($data->reset_completion)) {
         // Delete course and activity completion information.
+        $course = $DB->get_record('course', array('id' => $data->courseid));
-        $course = $DB->get_record('course', array('id' => $data->courseid));
+        $cc = new completion_info($course);
-        $cc = new completion_info($course);
+        $cc->delete_all_completion_data();
+        $status[] = array(
+            'component' => $componentstr,
-        $cc->delete_all_completion_data();
+            'item' => get_string('deletecompletiondata', 'completion'),
-        $status[] = array('component' => $componentstr,
+            'error' => false
-                'item' => get_string('deletecompletiondata', 'completion'), 'error' => false);
+        );
+    }
-    }
+    if (!empty($data->reset_competency_ratings)) {
+        \core_competency\api::hook_course_reset_competency_ratings($data->courseid);
+        $status[] = array(
-    if (!empty($data->reset_competency_ratings)) {
+            'component' => $componentstr,
-        \core_competency\api::hook_course_reset_competency_ratings($data->courseid);
+            'item' => get_string('deletecompetencyratings', 'core_competency'),
-        $status[] = array('component' => $componentstr,
+            'error' => false
                           FROM {user_enrolments} ue
                           JOIN {enrol} e ON (e.id = ue.enrolid AND e.courseid = :courseid)
                           JOIN {context} c ON (c.contextlevel = :courselevel AND c.instanceid = e.courseid)
                           JOIN {role_assignments} ra ON (ra.contextid = c.id AND ra.roleid = :roleid AND ra.userid = ue.userid)";
                 $params = array('courseid' => $data->courseid, 'roleid' => $withroleid, 'courselevel' => CONTEXT_COURSE);
             } else {
                 // Without any role assigned at course context.
                 $sql = "SELECT ue.*
                           FROM {user_enrolments} ue
                           JOIN {enrol} e ON (e.id = ue.enrolid AND e.courseid = :courseid)
+        }
+    }
     if (!empty($data->unenrolled)) {
         $status[] = array(
             'component' => $componentstr,
-            'item' => get_string('unenrol', 'enrol').' ('.count($data->unenrolled).')',
+            'item' => get_string('unenrol', 'enrol') . ' (' . count($data->unenrolled) . ')',
             'error' => false
         );
+    }
         $status[] = array('component' => $componentstr, 'item' => get_string('deleteallgroupings', 'group'), 'error' => false);
+    }
     // Look in every instance of every module for data to delete.
     $unsupportedmods = array();
-    if ($allmods = $DB->get_records('modules') ) {
+    if ($allmods = $DB->get_records('modules')) {
         foreach ($allmods as $mod) {
             $modname = $mod->name;
-            $modfile = $CFG->dirroot.'/mod/'. $modname.'/lib.php';
+            $modfile = $CFG->dirroot . '/mod/' . $modname . '/lib.php';
-            $moddeleteuserdata = $modname.'_reset_userdata';   // Function to delete user data.
+            $moddeleteuserdata = $modname . '_reset_userdata';   // Function to delete user data.
             if (file_exists($modfile)) {
                 if (!$DB->count_records($modname, array('course' => $data->courseid))) {
                     continue; // Skip mods with no instances.
+                }
                 include_once($modfile);
                 if (function_exists($moddeleteuserdata)) {
                     $modstatus = $moddeleteuserdata($data);
                     if (is_array($modstatus)) {
                         $status = array_merge($status, $modstatus);
                     } else {
-                        debugging('Module '.$modname.' returned incorrect staus - must be an array!');
+                        debugging('Module ' . $modname . ' returned incorrect staus - must be an array!');
+                    }
                 } else {
                     $unsupportedmods[] = $mod;
+                }
             } else {
-                debugging('Missing lib.php in '.$modname.' module!');
+                debugging('Missing lib.php in ' . $modname . ' module!');
+            }
             // Update calendar events for all modules.
             course_module_bulk_update_calendar_events($modname, $data->courseid);
+        }
     if (!empty($data->reset_gradebook_items)) {
         remove_course_grades($data->courseid, false);
         grade_grab_course_grades($data->courseid);
         grade_regrade_final_grades($data->courseid);
         $status[] = array('component' => $componentstr, 'item' => get_string('removeallcourseitems', 'grades'), 'error' => false);
     } else if (!empty($data->reset_gradebook_grades)) {
         grade_course_reset($data->courseid);
         $status[] = array('component' => $componentstr, 'item' => get_string('removeallcoursegrades', 'grades'), 'error' => false);
+    }
     // Reset comments.
     if (!empty($data->reset_comments)) {
-        require_once($CFG->dirroot.'/comment/lib.php');
+        require_once($CFG->dirroot . '/comment/lib.php');
         comment::reset_course_page_comments($context);
+    }
     $event = \core\event\course_reset_ended::create($eventparams);
+ *
  * @param int $modid
  * @param string $modargs
  * @return string Returns email processing address
  */
-function generate_email_processing_address($modid, $modargs) {
+function generate_email_processing_address($modid, $modargs)
+{
     global $CFG;
-    $header = $CFG->mailprefix . substr(base64_encode(pack('C', $modid)), 0, 2).$modargs;
+    $header = $CFG->mailprefix . substr(base64_encode(pack('C', $modid)), 0, 2) . $modargs;
-    return $header . substr(md5($header.get_site_identifier()), 0, 16).'@'.$CFG->maildomain;
+    return $header . substr(md5($header . get_site_identifier()), 0, 16) . '@' . $CFG->maildomain;
+}
 /**
  * ?
+ *
  * @todo Finish documenting this function
+ *
  * @param string $modargs
  * @param string $body Currently unused
+ */
- */
+function moodle_process_email($modargs, $body)
 function moodle_process_email($modargs, $body) {
     global $DB;
     // The first char should be an unencoded letter. We'll take this as an action.
     switch ($modargs[0]) {
         case 'B': { // Bounce.
-            list(, $userid) = unpack('V', base64_decode(substr($modargs, 1, 8)));
+                list(, $userid) = unpack('V', base64_decode(substr($modargs, 1, 8)));
-            if ($user = $DB->get_record("user", array('id' => $userid), "id,email")) {
+                if ($user = $DB->get_record("user", array('id' => $userid), "id,email")) {
-                // Check the half md5 of their email.
+                    // Check the half md5 of their email.
+                    $md5check = substr(md5($user->email), 0, 16);
+                    if ($md5check == substr($modargs, -16)) {
-                $md5check = substr(md5($user->email), 0, 16);
+                        set_bounce_count($user);
-                if ($md5check == substr($modargs, -16)) {
                     set_bounce_count($user);
-                }
-                // Else maybe they've already changed it?
+                    // Else maybe they've already changed it?
-            }
+                }
+            }
-        break;
+            break;
-        // Maybe more later?
+            // Maybe more later?
  * Get mailer instance, enable buffering, flush buffer or disable buffering.
+ *
  * @param string $action 'get', 'buffer', 'close' or 'flush'
  * @return moodle_phpmailer|null mailer instance if 'get' used or nothing
  */
-function get_mailer($action='get') {
+function get_mailer($action = 'get')
+{
     global $CFG;
     /** @var moodle_phpmailer $mailer */
     static $mailer  = null;
             $prevkeepalive = $mailer->SMTPKeepAlive;
             get_mailer('flush');
         }
-        require_once($CFG->libdir.'/phpmailer/moodle_phpmailer.php');
+        require_once($CFG->libdir . '/phpmailer/moodle_phpmailer.php');
         $mailer = new moodle_phpmailer();
         $counter = 1;
         if ($CFG->smtphosts == 'qmail') {
-            // Use Qmail system.
+        if ($CFG->smtphosts == 'qmail') {
-            $mailer->isQmail();
+            // Use Qmail system.
-        } else if (empty($CFG->smtphosts)) {
+            $mailer->isQmail();
-            // Use PHP mail() = sendmail.
+        } else if (empty($CFG->smtphosts)) {
-            $mailer->isMail();
+            // Use PHP mail() = sendmail.
             $mailer->isMail();
         } else {
     // Close smtp session, but continue buffering.
     if ($action == 'flush') {
         if (isset($mailer) and $mailer->Mailer == 'smtp') {
             if (!empty($mailer->SMTPDebug)) {
-                echo '<pre>'."\n";
+                echo '<pre>' . "\n";
+            }
             $mailer->SmtpClose();
             if (!empty($mailer->SMTPDebug)) {
                 echo '</pre>';
  * A helper function to test for email diversion
+ *
  * @param string $email
  * @return bool Returns true if the email should be diverted
  */
-function email_should_be_diverted($email) {
+function email_should_be_diverted($email)
+{
     global $CFG;
     if (empty($CFG->divertallemailsto)) {
         return false;
  * Generate a unique email Message-ID using the moodle domain and install path
+ *
  * @param string $localpart An optional unique message id prefix.
  * @return string The formatted ID ready for appending to the email headers.
  */
-function generate_email_messageid($localpart = null) {
+function generate_email_messageid($localpart = null)
+{
     global $CFG;
     $urlinfo = parse_url($CFG->wwwroot);
  * @param string $replyto Email address to reply to
  * @param string $replytoname Name of reply to recipient
  * @param int $wordwrapwidth custom word wrap width, default 79
  * @return bool Returns true if mail was sent OK and false if there was an error.
  */
-function email_to_user($user, $from, $subject, $messagetext, $messagehtml = '', $attachment = '', $attachname = '',
+function email_to_user(
+    $user,
+    $from,
+    $subject,
+    $messagetext,
+    $messagehtml = '',
+    $attachment = '',
+    $attachname = '',
-                       $usetrueaddress = true, $replyto = '', $replytoname = '', $wordwrapwidth = 79) {
+    $usetrueaddress = true,
+    $replyto = '',
+    $replytoname = '',
+    $wordwrapwidth = 79
+) {
     global $CFG, $PAGE, $SITE;
     if (empty($user) or empty($user->id)) {
         debugging('Can not send email to null user', DEBUG_DEVELOPER);
         return false;
     }
     if (empty($user->email)) {
-        debugging('Can not send email to user without email: '.$user->id, DEBUG_DEVELOPER);
+        debugging('Can not send email to user without email: ' . $user->id, DEBUG_DEVELOPER);
         return false;
+    }
     if (!empty($user->deleted)) {
-        debugging('Can not send email to deleted user: '.$user->id, DEBUG_DEVELOPER);
+        debugging('Can not send email to deleted user: ' . $user->id, DEBUG_DEVELOPER);
         return true;
+    }
     if (email_should_be_diverted($user->email)) {
         $subject = "[DIVERTED {$user->email}] $subject";
-        $user = clone($user);
+        $user = clone ($user);
         $user->email = $CFG->divertallemailsto;
+    }
     // Skip mail to suspended users.
-    if ((isset($user->auth) && $user->auth=='nologin') or (isset($user->suspended) && $user->suspended)) {
+    if ((isset($user->auth) && $user->auth == 'nologin') or (isset($user->suspended) && $user->suspended)) {
         return true;
+    }
     if (!validate_email($user->email)) {
         // We can not send emails to invalid addresses - it might create security issue or confuse the mailer.
-        debugging("email_to_user: User $user->id (".fullname($user).") email ($user->email) is invalid! Not sending.");
+        debugging("email_to_user: User $user->id (" . fullname($user) . ") email ($user->email) is invalid! Not sending.");
         return false;
+    }
     if (over_bounce_threshold($user)) {
-        debugging("email_to_user: User $user->id (".fullname($user).") is over bounce threshold! Not sending.");
+        debugging("email_to_user: User $user->id (" . fullname($user) . ") is over bounce threshold! Not sending.");
         return false;
     }
     // TLD .invalid  is specifically reserved for invalid domain names.
     // For More information, see {@link http://tools.ietf.org/html/rfc2606#section-2}.
     if (substr($user->email, -8) == '.invalid') {
-        debugging("email_to_user: User $user->id (".fullname($user).") email domain ($user->email) is invalid! Not sending.");
+        debugging("email_to_user: User $user->id (" . fullname($user) . ") email domain ($user->email) is invalid! Not sending.");
         return true; // This is not an error.
     }
     // If the user is a remote mnet user, parse the email text for URL to the
     // wwwroot and modify the url to direct the user's browser to login at their
+    // home site (identity provider - idp) before hitting the link itself.
-    // home site (identity provider - idp) before hitting the link itself.
+    if (is_mnet_remote_user($user)) {
-    if (is_mnet_remote_user($user)) {
+        require_once($CFG->dirroot . '/mnet/lib.php');
+        $jumpurl = mnet_get_idp_jump_url($user);
-        require_once($CFG->dirroot.'/mnet/lib.php');
+        $callback = partial('mnet_sso_apply_indirection', $jumpurl);
-        $jumpurl = mnet_get_idp_jump_url($user);
+        $messagetext = preg_replace_callback(
+            "%($CFG->wwwroot[^[:space:]]*)%",
-        $callback = partial('mnet_sso_apply_indirection', $jumpurl);
+            $callback,
             $messagetext
-        $messagetext = preg_replace_callback("%($CFG->wwwroot[^[:space:]]*)%",
+        );
-                $callback,
+        $messagehtml = preg_replace_callback(
     // Make sure that we fall back onto some reasonable no-reply address.
     $noreplyaddressdefault = 'noreply@' . get_host_from_url($CFG->wwwroot);
     $noreplyaddress = empty($CFG->noreplyaddress) ? $noreplyaddressdefault : $CFG->noreplyaddress;
     if (!validate_email($noreplyaddress)) {
-        debugging('email_to_user: Invalid noreply-email '.s($noreplyaddress));
+        debugging('email_to_user: Invalid noreply-email ' . s($noreplyaddress));
         $noreplyaddress = $noreplyaddressdefault;
+    }
     // Make up an email address for handling bounces.
     if (!empty($CFG->handlebounces)) {
-        $modargs = 'B'.base64_encode(pack('V', $user->id)).substr(md5($user->email), 0, 16);
+        $modargs = 'B' . base64_encode(pack('V', $user->id)) . substr(md5($user->email), 0, 16);
         $mail->Sender = generate_email_processing_address(0, $modargs);
     } else {
         $mail->Sender = $noreplyaddress;
+    }
     // Make sure that the explicit replyto is valid, fall back to the implicit one.
     if (!empty($replyto) && !validate_email($replyto)) {
-        debugging('email_to_user: Invalid replyto-email '.s($replyto));
+        debugging('email_to_user: Invalid replyto-email ' . s($replyto));
         $replyto = $noreplyaddress;
+    }
     if (is_string($from)) { // So we can pass whatever we want if there is need.
         $mail->From     = $noreplyaddress;
         $mail->FromName = $from;
-    // Check if using the true address is true, and the email is in the list of allowed domains for sending email,
+        // Check if using the true address is true, and the email is in the list of allowed domains for sending email,
-    // and that the senders email setting is either displayed to everyone, or display to only other users that are enrolled
+        // and that the senders email setting is either displayed to everyone, or display to only other users that are enrolled
-    // in a course with the sender.
+        // in a course with the sender.
     } else if ($usetrueaddress && can_send_from_real_email_address($from, $user)) {
         if (!validate_email($from->email)) {
-            debugging('email_to_user: Invalid from-email '.s($from->email).' - not sending');
+            debugging('email_to_user: Invalid from-email ' . s($from->email) . ' - not sending');
             // Better not to use $noreplyaddress in this case.
                 $origin = $call;
+            }
+        }
         $originheader = $CFG->wwwroot . ' => ' . gethostname() . ':'
-             . str_replace($CFG->dirroot . '/', '', $origin['file']) . ':' . $origin['line'];
+            . str_replace($CFG->dirroot . '/', '', $origin['file']) . ':' . $origin['line'];
         $mail->addCustomHeader('X-Moodle-Originating-Script: ' . $originheader);
+    }
         $mail->MessageID = generate_email_messageid();
+    }
     if ($messagehtml && !empty($user->mailformat) && $user->mailformat == 1) {
+        // Don't ever send HTML to users who don't want it.
+        // Agregar HEADER y FOOTER con imágenes al messagehtml
+        // Rutas de las imágenes
+        $header_image_url = $CFG->wwwroot . '/theme/universe/pix/logo-horizontal-cesa.png'; // 👉 Imagen del Header
+        $footer_image_url = $CFG->wwwroot . '/theme/universe/pix/email-footer.jpg'; // 👉 Imagen del Footer
-        // Don't ever send HTML to users who don't want it.
+        // HTML del Header
+        $header_html = '<div style="text-align:center; margin-bottom:20px;">'
+            . '<img src="' . $header_image_url . '" alt="Header Image" style="max-width:100%; height:auto;">'
+            . '</div>';
-        $mail->isHTML(true);
+        // HTML del Footer
+        $footer_html = '<div style="text-align:center; margin-top:40px;">'
-        $mail->Encoding = 'quoted-printable';
+            . '<img src="' . $footer_image_url . '" alt="Footer Image" style="max-width:100%; height:auto;">'
+            . '</div>';
-        $mail->Body    =  $messagehtml;
+        // Unir: Header + Contenido original + Footer
-        $mail->AltBody =  "\n$messagetext\n";
+        $messagehtml = $header_html . $messagehtml . $footer_html;
     } else {
         $mail->IsHTML(false);
         $mail->Body =  "\n$messagetext\n";
+    }
     if ($attachment && $attachname) {
-        if (preg_match( "~\\.\\.~" , $attachment )) {
+        if (preg_match("~\\.\\.~", $attachment)) {
             // Security check for ".." in dir path.
             $supportuser = core_user::get_support_user();
             $temprecipients[] = array($supportuser->email, fullname($supportuser, true));
             $mail->addStringAttachment('Error in attachment.  User attempted to attach a filename with a unsafe name.', 'error.txt', '8bit', 'text/plain');
         } else {
-            require_once($CFG->libdir.'/filelib.php');
+            require_once($CFG->libdir . '/filelib.php');
             $mimetype = mimeinfo('type', $attachname);
             // Before doing the comparison, make sure that the paths are correct (Windows uses slashes in the other direction).
             // The absolute (real) path is also fetched to ensure that comparisons to allowed paths are compared equally.
             $attachpath = str_replace('\\', '/', realpath($attachment));
             // Build an array of all filepaths from which attachments can be added (normalised slashes, absolute/real path).
-            $allowedpaths = array_map(function(string $path): string {
+            $allowedpaths = array_map(function (string $path): string {
                 return str_replace('\\', '/', realpath($path));
                 'errorinfo' => $mail->ErrorInfo
+            )
         ));
         $event->trigger();
         if (CLI_SCRIPT) {
-            mtrace('Error: lib/moodlelib.php email_to_user(): '.$mail->ErrorInfo);
+            mtrace('Error: lib/moodlelib.php email_to_user(): ' . $mail->ErrorInfo);
+        }
         if (!empty($mail->SMTPDebug)) {
             echo '</pre>';
+        }
         return false;
  * @param  object $from The user object for the user we are sending the email from.
  * @param  object $user The user object that we are sending the email to.
  * @param  array $unused No longer used.
  * @return bool Returns true if we can use the from user's email adress in the "From" field.
  */
-function can_send_from_real_email_address($from, $user, $unused = null) {
+function can_send_from_real_email_address($from, $user, $unused = null)
+{
     global $CFG;
     if (!isset($CFG->allowedemaildomains) || empty(trim($CFG->allowedemaildomains))) {
         return false;
+    }
     $alloweddomains = array_map('trim', explode("\n", $CFG->allowedemaildomains));
     // Email is in the list of allowed domains for sending email,
     // and the senders email setting is either displayed to everyone, or display to only other users that are enrolled
     // in a course with the sender.
+    if (
-    if (\core\ip_utils::is_domain_in_allowed_list(substr($from->email, strpos($from->email, '@') + 1), $alloweddomains)
+        \core\ip_utils::is_domain_in_allowed_list(substr($from->email, strpos($from->email, '@') + 1), $alloweddomains)
-                && ($from->maildisplay == core_user::MAILDISPLAY_EVERYONE
+        && ($from->maildisplay == core_user::MAILDISPLAY_EVERYONE
-                || ($from->maildisplay == core_user::MAILDISPLAY_COURSE_MEMBERS_ONLY
+            || ($from->maildisplay == core_user::MAILDISPLAY_COURSE_MEMBERS_ONLY
-                && enrol_get_shared_courses($user, $from, false, true)))) {
+                && enrol_get_shared_courses($user, $from, false, true)))
+    ) {
         return true;
+    }
     return false;
+}
 /**
  * Generate a signoff for emails based on support settings
+ *
  * @return string
  */
+function generate_email_signoff()
 function generate_email_signoff() {
     global $CFG, $OUTPUT;
     $signoff = "\n";
     if (!empty($CFG->supportname)) {
-        $signoff .= $CFG->supportname."\n";
+        $signoff .= $CFG->supportname . "\n";
+    }
+ *
  * @param stdClass $user A {@link $USER} object
  * @param bool $fasthash If true, use a low cost factor when generating the hash for speed.
  * @return bool|string Returns "true" if mail was sent OK and "false" if there was an error
  */
-function setnew_password_and_mail($user, $fasthash = false) {
+function setnew_password_and_mail($user, $fasthash = false)
+{
     global $CFG, $DB;
     // We try to send the mail in language the user understands,
     // unfortunately the filter_string() does not support alternative langs yet
     $a = new stdClass();
     $a->firstname   = fullname($user, true);
     $a->sitename    = format_string($site->fullname);
     $a->username    = $user->username;
     $a->newpassword = $newpassword;
-    $a->link        = $CFG->wwwroot .'/login/?lang='.$lang;
+    $a->link        = $CFG->wwwroot . '/login/?lang=' . $lang;
     $a->signoff     = generate_email_signoff();
     $message = (string)new lang_string('newusernewpasswordtext', '', $a, $lang);
-    $subject = format_string($site->fullname) .': '. (string)new lang_string('newusernewpasswordsubj', '', $a, $lang);
+    $subject = format_string($site->fullname) . ': ' . (string)new lang_string('newusernewpasswordsubj', '', $a, $lang);
     // Directly email rather than using the messaging system to ensure its not routed to a popup or jabber.
-    return email_to_user($user, $supportuser, $subject, $message);
+    // Directly email rather than using the messaging system to ensure its not routed to a popup or jabber.
     return email_to_user($user, $supportuser, $subject, $message);
+}
 /**
  * Resets specified user's password and send the new password to the user via email.
  *
+ * @param stdClass $user A {@link $USER} object
- * @param stdClass $user A {@link $USER} object
+ * @return bool Returns true if mail was sent OK and false if there was an error.
- * @return bool Returns true if mail was sent OK and false if there was an error.
+ */
- */
+function reset_password_and_mail($user)
     $a->firstname   = $user->firstname;
     $a->lastname    = $user->lastname;
     $a->sitename    = format_string($site->fullname);
     $a->username    = $user->username;
     $a->newpassword = $newpassword;
-    $a->link        = $CFG->wwwroot .'/login/change_password.php';
+    $a->link        = $CFG->wwwroot . '/login/change_password.php';
     $a->signoff     = generate_email_signoff();
     $message = get_string('newpasswordtext', '', $a);
-    $subject  = format_string($site->fullname) .': '. get_string('changedpassword');
+    $subject  = format_string($site->fullname) . ': ' . get_string('changedpassword');
+ *
  * @param stdClass $user A {@link $USER} object
  * @param string $confirmationurl user confirmation URL
  * @return bool Returns true if mail was sent OK and false if there was an error.
  */
-function send_confirmation_email($user, $confirmationurl = null) {
+function send_confirmation_email($user, $confirmationurl = null)
+{
     global $CFG;
     $site = get_site();
     // Perform normal url encoding of the username first.
     $username = urlencode($user->username);
     // Prevent problems with trailing dots not being included as part of link in some mail clients.
     $username = str_replace('.', '%2E', $username);
-    $data->link = $confirmationpath . ( $hasquerystring ? '&' : '?') . 'data='. $user->secret .'/'. $username;
+    $data->link = $confirmationpath . ($hasquerystring ? '&' : '?') . 'data=' . $user->secret . '/' . $username;
     $message     = get_string('emailconfirmation', '', $data);
+ *
  * @param stdClass $user A {@link $USER} object
  * @param stdClass $resetrecord An object tracking metadata regarding password reset request
  * @return bool Returns true if mail was sent OK and false if there was an error.
  */
-function send_password_change_confirmation_email($user, $resetrecord) {
+function send_password_change_confirmation_email($user, $resetrecord)
+{
     global $CFG;
     $site = get_site();
     $supportuser = core_user::get_support_user();
     $data = new stdClass();
     $data->firstname = $user->firstname;
     $data->lastname  = $user->lastname;
     $data->username  = $user->username;
     $data->sitename  = format_string($site->fullname);
-    $data->link      = $CFG->wwwroot .'/login/forgot_password.php?token='. $resetrecord->token;
+    $data->link      = $CFG->wwwroot . '/login/forgot_password.php?token=' . $resetrecord->token;
     $data->admin     = generate_email_signoff();
     $data->resetminutes = $pwresetmins;
     $message = get_string('emailresetconfirmation', '', $data);
     $subject = get_string('emailresetconfirmationsubject', '', format_string($site->fullname));
-    // Directly email rather than using the messaging system to ensure its not routed to a popup or jabber.
-    return email_to_user($user, $supportuser, $subject, $message);
+    // Directly email rather than using the messaging system to ensure its not routed to a popup or jabber.
     return email_to_user($user, $supportuser, $subject, $message);
+}
 /**
  * Sends an email containing information on how to change your password.
+ *
  * @param stdClass $user A {@link $USER} object
+ * @return bool Returns true if mail was sent OK and false if there was an error.
- * @return bool Returns true if mail was sent OK and false if there was an error.
+ */
- */
+function send_password_change_info($user)
 function send_password_change_info($user) {
     $site = get_site();
  * Check that an email is allowed.  It returns an error message if there was a problem.
+ *
  * @param string $email Content of email
  * @return string|false
  */
-function email_is_not_allowed($email) {
+function email_is_not_allowed($email)
+{
     global $CFG;
     // Comparing lowercase domains.
     $email = strtolower($email);
             if (strpos($allowedpattern, '.') === 0) {
                 if (strpos(strrev($email), strrev($allowedpattern)) === 0) {
                     // Subdomains are in a form ".example.com" - matches "xxx@anything.example.com".
                     return false;
+                }
-            } else if (strpos(strrev($email), strrev('@'.$allowedpattern)) === 0) {
+            } else if (strpos(strrev($email), strrev('@' . $allowedpattern)) === 0) {
                 return false;
+            }
+        }
         return get_string('emailonlyallowed', '', $CFG->allowemailaddresses);
     } else if (!empty($CFG->denyemailaddresses)) {
         $denied = explode(' ', strtolower($CFG->denyemailaddresses));
         foreach ($denied as $deniedpattern) {
             $deniedpattern = trim($deniedpattern);
             if (!$deniedpattern) {
             if (strpos($deniedpattern, '.') === 0) {
                 if (strpos(strrev($email), strrev($deniedpattern)) === 0) {
                     // Subdomains are in a form ".example.com" - matches "xxx@anything.example.com".
                     return get_string('emailnotallowed', '', $CFG->denyemailaddresses);
+                }
-            } else if (strpos(strrev($email), strrev('@'.$deniedpattern)) === 0) {
+            } else if (strpos(strrev($email), strrev('@' . $deniedpattern)) === 0) {
                 return get_string('emailnotallowed', '', $CFG->denyemailaddresses);
+            }
+        }
+    }
 /**
  * Returns local file storage instance
+ *
  * @return ?file_storage
  */
-function get_file_storage($reset = false) {
+function get_file_storage($reset = false)
+{
     global $CFG;
     static $fs = null;
 /**
  * Returns local file storage instance
+ *
  * @return file_browser
  */
-function get_file_browser() {
+function get_file_browser()
+{
     global $CFG;
     static $fb = null;
  * Returns file packer
+ *
  * @param string $mimetype default application/zip
  * @return file_packer|false
  */
-function get_file_packer($mimetype='application/zip') {
+function get_file_packer($mimetype = 'application/zip')
+{
     global $CFG;
     static $fp = array();
         case 'application/zip':
         case 'application/vnd.moodle.profiling':
             $classname = 'zip_packer';
             break;
-        case 'application/x-gzip' :
+        case 'application/x-gzip':
             $classname = 'tgz_packer';
             break;
  * Returns current name of file on disk if it exists.
+ *
  * @param string $newfile File to be verified
  * @return string Current name of file on disk if true
  */
-function valid_uploaded_file($newfile) {
+function valid_uploaded_file($newfile)
+{
     if (empty($newfile)) {
         return '';
+    }
     if (is_uploaded_file($newfile['tmp_name']) and $newfile['size'] > 0) {
         return $newfile['tmp_name'];
  * @param int $coursebytes Current course $course->maxbytes (in bytes)
  * @param int $modulebytes Current module ->maxbytes (in bytes)
  * @param bool $unused This parameter has been deprecated and is not used any more.
  * @return int The maximum size for uploading files.
  */
-function get_max_upload_file_size($sitebytes=0, $coursebytes=0, $modulebytes=0, $unused = false) {
+function get_max_upload_file_size($sitebytes = 0, $coursebytes = 0, $modulebytes = 0, $unused = false)
+{
     if (! $filesize = ini_get('upload_max_filesize')) {
         $filesize = '5M';
+    }
  * @param int $modulebytes Current module ->maxbytes (in bytes)
  * @param stdClass|int|null $user The user
  * @param bool $unused This parameter has been deprecated and is not used any more.
  * @return int The maximum size for uploading files.
  */
-function get_user_max_upload_file_size($context, $sitebytes = 0, $coursebytes = 0, $modulebytes = 0, $user = null,
+function get_user_max_upload_file_size(
+    $context,
+    $sitebytes = 0,
+    $coursebytes = 0,
+    $modulebytes = 0,
+    $user = null,
-        $unused = false) {
+    $unused = false
+) {
     global $USER;
     if (empty($user)) {
         $user = $USER;
  * @param int $modulebytes Current module ->maxbytes (in bytes)
  * @param int|array $custombytes custom upload size/s which will be added to list,
  *        Only value/s smaller then maxsize will be added to list.
  * @return array
  */
-function get_max_upload_sizes($sitebytes = 0, $coursebytes = 0, $modulebytes = 0, $custombytes = null) {
+function get_max_upload_sizes($sitebytes = 0, $coursebytes = 0, $modulebytes = 0, $custombytes = null)
+{
     global $CFG;
     if (!$maxsize = get_max_upload_file_size($sitebytes, $coursebytes, $modulebytes)) {
         return array();
         // Will get the minimum of upload_max_filesize or post_max_size.
         $sitebytes = get_max_upload_file_size();
+    }
     $filesize = array();
+    $sizelist = array(
+,
+,
+,
+,
+        1048576,
+        2097152,
+        5242880,
+        10485760,
+        20971520,
+        52428800,
+        104857600,
-    $sizelist = array(10240, 51200, 102400, 512000, 1048576, 2097152,
+        262144000,
+        524288000,
-                      5242880, 10485760, 20971520, 52428800, 104857600,
+        786432000,
+        1073741824,
-                      262144000, 524288000, 786432000, 1073741824,
+        2147483648,
+        4294967296,
+        8589934592
-                      2147483648, 4294967296, 8589934592);
+    );
     // If custombytes is given and is valid then add it to the list.
     if (is_number($custombytes) and $custombytes > 0) {
+        }
+    }
     $limitlevel = '';
+    $displaysize = '';
-    $displaysize = '';
+    if (
-    if ($modulebytes &&
+        $modulebytes &&
         (($modulebytes < $coursebytes || $coursebytes == 0) &&
+            ($modulebytes < $sitebytes || $sitebytes == 0))
-         ($modulebytes < $sitebytes || $sitebytes == 0))) {
+    ) {
         $limitlevel = get_string('activity', 'core');
         $displaysize = display_size($modulebytes, 0);
         $filesize[$modulebytes] = $displaysize; // Make sure the limit is also included in the list.
  * @param bool $descend If true then subdirectories are recursed as well
  * @param bool $getdirs If true then (sub)directories are included in the output
  * @param bool $getfiles  If true then files are included in the output
  * @return array An array with all the filenames in all subdirectories, relative to the given rootdir
  */
-function get_directory_list($rootdir, $excludefiles='', $descend=true, $getdirs=false, $getfiles=true) {
+function get_directory_list($rootdir, $excludefiles = '', $descend = true, $getdirs = false, $getfiles = true)
+{
     $dirs = array();
     while (false !== ($file = readdir($dir))) {
         $firstchar = substr($file, 0, 1);
         if ($firstchar == '.' or $file == 'CVS' or in_array($file, $excludefiles)) {
             continue;
+        }
-        $fullfile = $rootdir .'/'. $file;
+        $fullfile = $rootdir . '/' . $file;
         if (filetype($fullfile) == 'dir') {
             if ($getdirs) {
                 $dirs[] = $file;
+            }
             if ($descend) {
                 $subdirs = get_directory_list($fullfile, $excludefiles, $descend, $getdirs, $getfiles);
                 foreach ($subdirs as $subdir) {
-                    $dirs[] = $file .'/'. $subdir;
+                    $dirs[] = $file . '/' . $subdir;
+                }
+            }
         } else if ($getfiles) {
             $dirs[] = $file;
+        }
+ *
  * @param string $rootdir  The directory to start from
  * @param string $excludefile A file to exclude when summing directory size
  * @return int The summed size of all files and subfiles within the root directory
  */
-function get_directory_size($rootdir, $excludefile='') {
+function get_directory_size($rootdir, $excludefile = '')
+{
     global $CFG;
     // Do it this way if we can, it's much faster.
     if (!empty($CFG->pathtodu) && is_executable(trim($CFG->pathtodu))) {
-        $command = trim($CFG->pathtodu).' -sk '.escapeshellarg($rootdir);
+        $command = trim($CFG->pathtodu) . ' -sk ' . escapeshellarg($rootdir);
         $output = null;
         $return = null;
         exec($command, $output, $return);
         if (is_array($output)) {
             // We told it to return k.
-            return get_real_size(intval($output[0]).'k');
+            return get_real_size(intval($output[0]) . 'k');
+        }
+    }
     while (false !== ($file = readdir($dir))) {
         $firstchar = substr($file, 0, 1);
         if ($firstchar == '.' or $file == 'CVS' or $file == $excludefile) {
             continue;
+        }
-        $fullfile = $rootdir .'/'. $file;
+        $fullfile = $rootdir . '/' . $file;
         if (filetype($fullfile) == 'dir') {
             $size += get_directory_size($fullfile, $excludefile);
         } else {
             $size += filesize($fullfile);
+        }
  * @param int $size  The size to convert to human readable form
  * @param int $decimalplaces If specified, uses fixed number of decimal places
  * @param string $fixedunits If specified, uses fixed units (e.g. 'KB')
  * @return string Display version of size
  */
-function display_size($size, int $decimalplaces = 1, string $fixedunits = ''): string {
+function display_size($size, int $decimalplaces = 1, string $fixedunits = ''): string
+{
     static $units;
         $units[] = get_string('sizetb');
         $units[] = get_string('sizepb');
+    }
     switch ($fixedunits) {
-        case 'PB' :
+        case 'PB':
             $magnitude = 5;
             break;
-        case 'TB' :
+        case 'TB':
             $magnitude = 4;
             break;
-        case 'GB' :
+        case 'GB':
             $magnitude = 3;
             break;
-        case 'MB' :
+        case 'MB':
             $magnitude = 2;
             break;
-        case 'KB' :
+        case 'KB':
             $magnitude = 1;
             break;
-        case 'B' :
+        case 'B':
             $magnitude = 0;
             break;
         case '':
             $magnitude = floor(log($size, 1024));
+ *
  * @see clean_param()
  * @param string $string file name
  * @return string cleaned file name
  */
-function clean_filename($string) {
+function clean_filename($string)
+{
     return clean_param($string, PARAM_FILE);
+}
  * Returns the code for the current language
+ *
  * @category string
  * @return string
  */
-function current_language() {
+function current_language()
+{
     global $CFG, $PAGE, $SESSION, $USER;
     if (!empty($SESSION->forcelang)) {
         // Allows overriding course-forced language (useful for admins to check
         // issues in courses whose language they don't understand).
         // Also used by some code to temporarily get language-related information in a
         // specific language (see force_current_language()).
-        $return = $SESSION->forcelang;
         $return = $SESSION->forcelang;
     } else if (!empty($PAGE->cm->lang)) {
         // Activity language, if set.
-        $return = $PAGE->cm->lang;
         $return = $PAGE->cm->lang;
     } else if (!empty($PAGE->course->id) && $PAGE->course->id != SITEID && !empty($PAGE->course->lang)) {
         // Course language can override all other settings for this page.
-        $return = $PAGE->course->lang;
         $return = $PAGE->course->lang;
     } else if (!empty($SESSION->lang)) {
         // Session language can override other settings.
-        $return = $SESSION->lang;
         $return = $SESSION->lang;
     } else if (!empty($USER->lang)) {
-        $return = $USER->lang;
         $return = $USER->lang;
     } else if (isset($CFG->lang)) {
-        $return = $CFG->lang;
         $return = $CFG->lang;
     } else {
         $return = 'en';
+    }
  * Fix the current language to the given language code.
+ *
  * @param string $lang The language code to use.
  * @return void
  */
-function fix_current_language(string $lang): void {
+function fix_current_language(string $lang): void
+{
     global $CFG, $COURSE, $SESSION, $USER;
     if (!get_string_manager()->translation_exists($lang)) {
         throw new coding_exception("The language pack for $lang is not available");
+ *
  * @category string
  * @param string $lang null means current language
  * @return string
  */
-function get_parent_language($lang=null) {
+function get_parent_language($lang = null)
+{
     $parentlang = get_string_manager()->get_string('parentlanguage', 'langconfig', null, $lang);
  * until this function is called again, or equivalent code is run.
+ *
  * @param string $language
  * @return string previous $SESSION->forcelang value
  */
-function force_current_language($language) {
+function force_current_language($language)
+{
     global $SESSION;
     $sessionforcelang = isset($SESSION->forcelang) ? $SESSION->forcelang : '';
     if ($language !== $sessionforcelang) {
         // Setting forcelang to null or an empty string disables its effect.
         if (empty($language) || get_string_manager()->translation_exists($language, false)) {
+ *
  * @category string
  * @param bool $forcereload shall the singleton be released and new instance created instead?
  * @return core_string_manager
  */
-function get_string_manager($forcereload=false) {
+function get_string_manager($forcereload = false)
+{
     global $CFG;
     static $singleton = null;
     if ($singleton === null) {
         if (empty($CFG->early_install_lang)) {
             $transaliases = array();
             if (empty($CFG->langlist)) {
-                 $translist = array();
+                $translist = array();
             } else {
                 $translist = explode(',', $CFG->langlist);
                 $translist = array_map('trim', $translist);
                 // Each language in the $CFG->langlist can has an "alias" that would substitute the default language name.
                     $implements = class_implements($classname);
                     if (isset($implements['core_string_manager'])) {
                         $singleton = new $classname($CFG->langotherroot, $CFG->langlocalroot, $translist, $transaliases);
-                        return $singleton;
                         return $singleton;
                     } else {
-                        debugging('Unable to instantiate custom string manager: class '.$classname.
+                        debugging('Unable to instantiate custom string manager: class ' . $classname .
                             ' does not implement the core_string_manager interface.');
-                    }
+                    }
                 } else {
-                    debugging('Unable to instantiate custom string manager: class '.$classname.' can not be found.');
+                    debugging('Unable to instantiate custom string manager: class ' . $classname . ' can not be found.');
+                }
+            }
             $singleton = new core_string_manager_standard($CFG->langotherroot, $CFG->langlocalroot, $translist, $transaliases);
             $singleton = new core_string_manager_standard($CFG->langotherroot, $CFG->langlocalroot, $translist, $transaliases);
         } else {
             $singleton = new core_string_manager_install();
  * @param bool $lazyload If set to true a string object is returned instead of
  *      the string itself. The string then isn't calculated until it is first used.
  * @return string The localized string.
  * @throws coding_exception
  */
-function get_string($identifier, $component = '', $a = null, $lazyload = false) {
+function get_string($identifier, $component = '', $a = null, $lazyload = false)
+{
     global $CFG;
     // If the lazy load argument has been supplied return a lang_string object
     // instead.
         debugging('extralocations parameter in get_string() is not supported any more, please use standard lang locations only.');
+    }
     if (strpos((string)$component, '/') !== false) {
         debugging('The module name you passed to get_string is the deprecated format ' .
-                'like mod/mymod or block/myblock. The correct form looks like mymod, or block_myblock.' , DEBUG_DEVELOPER);
+            'like mod/mymod or block/myblock. The correct form looks like mymod, or block_myblock.', DEBUG_DEVELOPER);
         $componentpath = explode('/', $component);
         switch ($componentpath[0]) {
             case 'mod':
                 $component = $componentpath[1];
                 break;
             case 'blocks':
             case 'block':
-                $component = 'block_'.$componentpath[1];
+                $component = 'block_' . $componentpath[1];
                 break;
             case 'enrol':
-                $component = 'enrol_'.$componentpath[1];
+                $component = 'enrol_' . $componentpath[1];
                 break;
             case 'format':
-                $component = 'format_'.$componentpath[1];
+                $component = 'format_' . $componentpath[1];
                 break;
             case 'grade':
-                $component = 'grade'.$componentpath[1].'_'.$componentpath[2];
+                $component = 'grade' . $componentpath[1] . '_' . $componentpath[2];
                 break;
+        }
+ *
  * @param array $array An array of strings
  * @param string $component The language module that these strings can be found in.
  * @return stdClass translated strings.
  */
-function get_strings($array, $component = '') {
+function get_strings($array, $component = '')
+{
     $string = new stdClass;
     foreach ($array as $item) {
         $string->$item = get_string($item, $component);
+    }
     return $string;
  * @category string
  * @param string $identifier The key identifier for the localized string
  * @param string $component The module where the key identifier is stored. If none is specified then moodle.php is used.
  * @param string|object|array $a An object, string or number that can be used within translation strings
  */
-function print_string($identifier, $component = '', $a = null) {
+function print_string($identifier, $component = '', $a = null)
+{
     echo get_string($identifier, $component, $a);
+}
 /**
  * Returns a list of charset codes. It's hardcoded, so they should be added manually
  * (checking that such charset is supported by the texlib library!)
+ *
  * @return array And associative array with contents in the form of charset => charset
  */
-function get_list_of_charsets() {
+function get_list_of_charsets()
+{
     $charsets = array(
         'EUC-JP'     => 'EUC-JP',
-        'ISO-2022-JP'=> 'ISO-2022-JP',
+        'ISO-2022-JP' => 'ISO-2022-JP',
         'ISO-8859-1' => 'ISO-8859-1',
         'SHIFT-JIS'  => 'SHIFT-JIS',
         'GB2312'     => 'GB2312',
         'GB18030'    => 'GB18030', // GB18030 not supported by typo and mbstring.
+        'UTF-8'      => 'UTF-8'
-        'UTF-8'      => 'UTF-8');
+    );
     asort($charsets);
 /**
  * Returns a list of valid and compatible themes
+ *
  * @return array
  */
-function get_list_of_themes() {
+function get_list_of_themes()
+{
     global $CFG;
     $themes = array();
 /**
  * Factory function for emoticon_manager
+ *
  * @return emoticon_manager singleton
  */
-function get_emoticon_manager() {
+function get_emoticon_manager()
+{
     static $singleton = null;
     if (is_null($singleton)) {
         $singleton = new emoticon_manager();
  * @see admin_setting_emoticons
+ *
  * @copyright 2010 David Mudrak
  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class emoticon_manager {
+class emoticon_manager
+{
     /**
      * Returns the currently enabled emoticons
+     *
      * @param boolean $selectable - If true, only return emoticons that should be selectable from a list.
      * @return array of emoticon objects
      */
+    public function get_emoticons($selectable = false)
     public function get_emoticons($selectable = false) {
         global $CFG;
         $notselectable = ['martin', 'egg'];
+     *
      * @param stdClass $emoticon emoticon object
      * @param array $attributes explicit HTML attributes to set
      * @return pix_emoticon
      */
-    public function prepare_renderable_emoticon(stdClass $emoticon, array $attributes = array()) {
+    public function prepare_renderable_emoticon(stdClass $emoticon, array $attributes = array())
+    {
         $stringmanager = get_string_manager();
         if ($stringmanager->string_exists($emoticon->altidentifier, $emoticon->altcomponent)) {
             $alt = get_string($emoticon->altidentifier, $emoticon->altcomponent);
         } else {
             $alt = s($emoticon->text);
+     *
      * @see self::decode_stored_config()
      * @param array $emoticons array of emtocion objects
      * @return string
      */
-    public function encode_stored_config(array $emoticons) {
+    public function encode_stored_config(array $emoticons)
+    {
         return json_encode($emoticons);
+    }
     /**
      * Decodes the string into an array of emoticon objects
+     *
      * @see self::encode_stored_config()
      * @param string $encoded
      * @return array|null
      */
+    public function decode_stored_config($encoded)
     public function decode_stored_config($encoded) {
         $decoded = json_decode($encoded);
         if (!is_array($decoded)) {
             return null;
+        }
     /**
      * Returns default set of emoticons supported by Moodle
+     *
      * @return array of sdtClasses
      */
-    public function default_emoticons() {
+    public function default_emoticons()
+    {
         return array(
             $this->prepare_emoticon_object(":-)", 's/smiley', 'smiley'),
             $this->prepare_emoticon_object(":)", 's/smiley', 'smiley'),
             $this->prepare_emoticon_object(":-D", 's/biggrin', 'biggrin'),
             $this->prepare_emoticon_object(";-)", 's/wink', 'wink'),
      * @param string $altidentifier alternative string identifier, null for no alt
      * @param string $altcomponent where the alternative string is defined
      * @param string $imagecomponent to be used by {@link pix_emoticon}
      * @return stdClass
      */
-    protected function prepare_emoticon_object($text, $imagename, $altidentifier = null,
+    protected function prepare_emoticon_object(
+        $text,
+        $imagename,
+        $altidentifier = null,
-                                               $altcomponent = 'core_pix', $imagecomponent = 'core') {
+        $altcomponent = 'core_pix',
+        $imagecomponent = 'core'
+    ) {
         return (object)array(
             'text'           => $text,
             'imagename'      => $imagename,
             'imagecomponent' => $imagecomponent,
             'altidentifier'  => $altidentifier,
  * rc4encrypt
+ *
  * @param string $data        Data to encrypt.
  * @return string             The now encrypted data.
  */
-function rc4encrypt($data) {
+function rc4encrypt($data)
+{
     return endecrypt(get_site_identifier(), $data, '');
+}
 /**
  * rc4decrypt
+ *
  * @param string $data        Data to decrypt.
  * @return string             The now decrypted data.
  */
+function rc4decrypt($data)
 function rc4decrypt($data) {
     return endecrypt(get_site_identifier(), $data, 'de');
+}
  * @param string $pwd The password to use when encrypting or decrypting
  * @param string $data The data to be decrypted/encrypted
  * @param string $case Either 'de' for decrypt or '' for encrypt
  * @return string
  */
-function endecrypt ($pwd, $data, $case) {
+function endecrypt($pwd, $data, $case)
+{
     if ($case == 'de') {
         $data = urldecode($data);
  * This method validates a plug name. It is much faster than calling clean_param.
+ *
  * @param string $name a string that might be a plugin name.
  * @return bool if this string is a valid plugin name.
  */
-function is_valid_plugin_name($name) {
+function is_valid_plugin_name($name)
+{
     // This does not work for 'mod', bad luck, use any other type.
     return core_component::is_valid_plugin_name('tool', $name);
+}
  * @param string $file the name of file within the plugin that defines the
  *      function. Defaults to lib.php.
  * @return array with frankenstyle plugin names as keys (e.g. 'report_courselist', 'mod_forum')
  *      and the function names as values (e.g. 'report_courselist_hook', 'forum_hook').
  */
-function get_plugin_list_with_function($plugintype, $function, $file = 'lib.php') {
+function get_plugin_list_with_function($plugintype, $function, $file = 'lib.php')
+{
     global $CFG;
     // We don't include here as all plugin types files would be included.
  *      function. Defaults to lib.php.
  * @param bool $include Whether to include the files that contain the functions or not.
  * @param bool $migratedtohook if true this is a deprecated lib.php callback, if hook callback is present then do nothing
  * @return array with [plugintype][plugin] = functionname
  */
-function get_plugins_with_function($function, $file = 'lib.php', $include = true, bool $migratedtohook = false) {
+function get_plugins_with_function($function, $file = 'lib.php', $include = true, bool $migratedtohook = false)
+{
     global $CFG;
     if (during_initial_install() || isset($CFG->upgraderunning)) {
         // API functions _must not_ be called during an installation or upgrade.
         return [];
+    }
     $plugincallback = $function;
-    $filtermigrated = function($plugincallback, $pluginfunctions): array {
+    $filtermigrated = function ($plugincallback, $pluginfunctions): array {
         foreach ($pluginfunctions as $plugintype => $plugins) {
             foreach ($plugins as $plugin => $unusedfunction) {
                 $component = $plugintype . '_' . $plugin;
             $pluginfunction = false;
             if (function_exists($fullfunction)) {
                 // Function exists with standard name. Store, indexed by frankenstyle name of plugin.
-                $pluginfunction = $fullfunction;
                 $pluginfunction = $fullfunction;
             } else if ($plugintype === 'mod') {
                 // For modules, we also allow plugin without full frankenstyle but just starting with the module name.
                 $shortfunction = $plugin . '_' . $function;
                 if (function_exists($shortfunction)) {
                 if (empty($pluginfunctions[$plugintype])) {
                     $pluginfunctions[$plugintype] = array();
+                }
                 $pluginfunctions[$plugintype][$plugin] = $pluginfunction;
+            }
+        }
+    }
     if (!empty($CFG->allversionshash)) {
         $cache->set($key, $pluginfunctions);
+    }
     if ($migratedtohook && $file === 'lib.php') {
         $pluginfunctions = $filtermigrated($plugincallback, $pluginfunctions);
+    }
-    return $pluginfunctions;
     return $pluginfunctions;
+}
 /**
  * @param string $directory relative directory from root
  * @param string $exclude dir name to exclude from the list (defaults to none)
  * @param string $basedir full path to the base dir where $plugin resides (defaults to $CFG->dirroot)
  * @return array Sorted array of directory names found under the requested parameters
  */
-function get_list_of_plugins($directory='mod', $exclude='', $basedir='') {
+function get_list_of_plugins($directory = 'mod', $exclude = '', $basedir = '')
+{
     global $CFG;
     $plugins = array();
-    if (empty($basedir)) {
-        $basedir = $CFG->dirroot .'/'. $directory;
+    if (empty($basedir)) {
+        $basedir = $CFG->dirroot . '/' . $directory;
     } else {
-        $basedir = $basedir .'/'. $directory;
+        $basedir = $basedir . '/' . $directory;
+    }
+            }
             if (array_key_exists($dir, $ignorelist)) {
                 // This directory features on the ignore list.
                 continue;
+            }
-            if (filetype($basedir .'/'. $dir) != 'dir') {
+            if (filetype($basedir . '/' . $dir) != 'dir') {
                 continue;
+            }
             $plugins[] = $dir;
+        }
         closedir($dirhandle);
  * @param bool $migratedtohook if true this is a deprecated callback, if hook callback is present then do nothing
  * @return mixed
+ *
  * @todo Decide about to deprecate and drop plugin_callback() - MDL-30743
  */
-function plugin_callback($type, $name, $feature, $action, $params = null, $default = null, bool $migratedtohook = false) {
+function plugin_callback($type, $name, $feature, $action, $params = null, $default = null, bool $migratedtohook = false)
+{
     return component_callback($type . '_' . $name, $feature . '_' . $action, (array) $params, $default, $migratedtohook);
+}
 /**
  * @param array $params parameters of callback function
  * @param mixed $default default value if callback function hasn't been defined, or if it retursn null.
  * @param bool $migratedtohook if true this is a deprecated callback, if hook callback is present then do nothing
  * @return mixed
  */
-function component_callback($component, $function, array $params = array(), $default = null, bool $migratedtohook = false) {
+function component_callback($component, $function, array $params = array(), $default = null, bool $migratedtohook = false)
+{
     $functionname = component_callback_exists($component, $function);
     if ($functionname) {
         if ($migratedtohook) {
                     return null;
                 } else {
                     $hookmessage = count($hooks) == 1 ? reset($hooks) : 'one of  ' . implode(', ', $hooks);
                     debugging(
                         "Callback $function in $component component should be migrated to new hook callback for $hookmessage",
-                        DEBUG_DEVELOPER);
+                        DEBUG_DEVELOPER
+                    );
+                }
+            }
+        }
  * @param string $component frankenstyle component name, e.g. 'mod_quiz'
  * @param string $function the rest of the function name, e.g. 'cron' will end up calling 'mod_quiz_cron'
  * @return mixed Complete function name to call if the callback exists or false if it doesn't.
  * @throws coding_exception if invalid component specfied
  */
-function component_callback_exists($component, $function) {
+function component_callback_exists($component, $function)
+{
     global $CFG; // This is needed for the inclusions.
     $cleancomponent = clean_param($component, PARAM_COMPONENT);
     if (empty($cleancomponent)) {
     $component = $cleancomponent;
     list($type, $name) = core_component::normalize_component($component);
     $component = $type . '_' . $name;
-    $oldfunction = $name.'_'.$function;
+    $oldfunction = $name . '_' . $function;
-    $function = $component.'_'.$function;
+    $function = $component . '_' . $function;
     $dir = core_component::get_component_directory($component);
     if (empty($dir)) {
         throw new coding_exception('Invalid component used in plugin/component_callback():' . $component);
     }
     // Load library and look for function.
-    if (file_exists($dir.'/lib.php')) {
+    if (file_exists($dir . '/lib.php')) {
-        require_once($dir.'/lib.php');
+        require_once($dir . '/lib.php');
  * @param   array       $params The arguments to pass into the method.
  * @param   mixed       $default The default value.
  * @param   bool        $migratedtohook True if the callback has been migrated to a hook.
  * @return  mixed       The return value.
  */
-function component_class_callback($classname, $methodname, array $params, $default = null, bool $migratedtohook = false) {
+function component_class_callback($classname, $methodname, array $params, $default = null, bool $migratedtohook = false)
+{
     if (!class_exists($classname)) {
         return $default;
+    }
                 // Do not call the old class callback,
                 // it is there for compatibility with older Moodle versions only.
                 return null;
             } else {
                 $hookmessage = count($hooks) == 1 ? reset($hooks) : 'one of  ' . implode(', ', $hooks);
+                debugging(
-                debugging("Callback $callback in $component component should be migrated to new hook callback for $hookmessage",
+                    "Callback $callback in $component component should be migrated to new hook callback for $hookmessage",
-                        DEBUG_DEVELOPER);
+                    DEBUG_DEVELOPER
+                );
+            }
+        }
+    }
  * @param mixed $default default value if feature support unknown
  * @return mixed Feature result (false if not supported, null if feature is unknown,
  *         otherwise usually true but may have other feature-specific value such as array)
  * @throws coding_exception
  */
-function plugin_supports($type, $name, $feature, $default = null) {
+function plugin_supports($type, $name, $feature, $default = null)
+{
     global $CFG;
     if ($type === 'mod' and $name === 'NEWMODULE') {
         // Somebody forgot to rename the module template.
     if ($type === 'mod') {
         // We need this special case because we support subplugins in modules,
         // otherwise it would end up in infinite loop.
         if (file_exists("$CFG->dirroot/mod/$name/lib.php")) {
             include_once("$CFG->dirroot/mod/$name/lib.php");
-            $function = $component.'_supports';
+            $function = $component . '_supports';
             if (!function_exists($function)) {
                 // Legacy non-frankenstyle function name.
-                $function = $name.'_supports';
+                $function = $name . '_supports';
+            }
+        }
     } else {
         if (!$path = core_component::get_plugin_directory($type, $name)) {
             // Non existent plugin type.
             return false;
+        }
         if (file_exists("$path/lib.php")) {
             include_once("$path/lib.php");
-            $function = $component.'_supports';
+            $function = $component . '_supports';
+        }
+    }
     if ($function and function_exists($function)) {
  * @todo Check PHP version being required here is it too low?
+ *
  * @param string $version The version of php being tested.
  * @return bool
  */
-function check_php_version($version='5.2.4') {
+function check_php_version($version = '5.2.4')
+{
     return (version_compare(phpversion(), $version) >= 0);
+}
 /**
  * if there are any mismatches.
+ *
  * @param bool $checkupgradeflag check the outagelessupgrade flag to see if an upgrade is running.
  * @return bool
  */
-function moodle_needs_upgrading($checkupgradeflag = true) {
+function moodle_needs_upgrading($checkupgradeflag = true)
+{
     global $CFG, $DB;
     // Say no if there is already an upgrade running.
     if ($checkupgradeflag) {
  * the main version.php.
+ *
  * @param bool $fromdisk should the version if source code files be used
  * @return string|false the major version like '2.3', false if could not be determined
  */
-function moodle_major_version($fromdisk = false) {
+function moodle_major_version($fromdisk = false)
+{
     global $CFG;
     if ($fromdisk) {
         $release = null;
-        require($CFG->dirroot.'/version.php');
+        require($CFG->dirroot . '/version.php');
         if (empty($release)) {
             return false;
-        }
+        }
     } else {
         if (empty($CFG->release)) {
             return false;
+        }
 /**
  * Gets the system locale
+ *
  * @return string Retuns the current locale.
  */
-function moodle_getlocale() {
+function moodle_getlocale()
+{
     global $CFG;
     // Fetch the correct locale based on ostype.
     if ($CFG->ostype == 'WINDOWS') {
  * Sets the system locale
+ *
  * @category string
  * @param string $locale Can be used to force a locale
  */
-function moodle_setlocale($locale='') {
+function moodle_setlocale($locale = '')
+{
     global $CFG;
     static $currentlocale = ''; // Last locale caching.
     // Due to some strange BUG we cannot set the LC_TIME directly, so we fetch current values,
     // set LC_ALL and then set values again. Just wondering why we cannot set LC_ALL only??? - stronk7
     // Some day, numeric, monetary and other categories should be set too, I think. :-/.
     // Get current values.
-    $monetary= setlocale (LC_MONETARY, 0);
+    $monetary = setlocale(LC_MONETARY, 0);
-    $numeric = setlocale (LC_NUMERIC, 0);
+    $numeric = setlocale(LC_NUMERIC, 0);
-    $ctype   = setlocale (LC_CTYPE, 0);
+    $ctype   = setlocale(LC_CTYPE, 0);
     if ($CFG->ostype != 'WINDOWS') {
-        $messages= setlocale (LC_MESSAGES, 0);
+        $messages = setlocale(LC_MESSAGES, 0);
+    }
     // Set locale to all.
-    $result = setlocale (LC_ALL, $currentlocale);
+    $result = setlocale(LC_ALL, $currentlocale);
     // If setting of locale fails try the other utf8 or utf-8 variant,
     // some operating systems support both (Debian), others just one (OSX).
     if ($result === false) {
         if (stripos($currentlocale, '.UTF-8') !== false) {
             $newlocale = str_ireplace('.UTF-8', '.UTF8', $currentlocale);
-            setlocale (LC_ALL, $newlocale);
+            setlocale(LC_ALL, $newlocale);
         } else if (stripos($currentlocale, '.UTF8') !== false) {
             $newlocale = str_ireplace('.UTF8', '.UTF-8', $currentlocale);
-            setlocale (LC_ALL, $newlocale);
+            setlocale(LC_ALL, $newlocale);
+        }
+    }
     // Set old values.
-    setlocale (LC_MONETARY, $monetary);
+    setlocale(LC_MONETARY, $monetary);
-    setlocale (LC_NUMERIC, $numeric);
+    setlocale(LC_NUMERIC, $numeric);
     if ($CFG->ostype != 'WINDOWS') {
-        setlocale (LC_MESSAGES, $messages);
+        setlocale(LC_MESSAGES, $messages);
+    }
     if ($currentlocale == 'tr_TR' or $currentlocale == 'tr_TR.UTF-8') {
         // To workaround a well-known PHP problem with Turkish letter Ii.
-        setlocale (LC_CTYPE, $ctype);
+        setlocale(LC_CTYPE, $ctype);
+    }
+}
  * @category string
  * @param string $string The text to be searched for words. May be HTML.
  * @param int|null $format
  * @return int The count of words in the specified string
  */
-function count_words($string, $format = null) {
+function count_words($string, $format = null)
+{
     // Before stripping tags, add a space after the close tag of anything that is not obviously inline.
     // Also, br is a special case because it definitely delimits a word, but has no close tag.
     $string = preg_replace('~
             (                                   # Capture the tag we match.
                 </                              # Start of close tag.
  * @category string
  * @param string $string The text to be searched for letters. May be HTML.
  * @param int|null $format
  * @return int The count of letters in the specified text.
  */
-function count_letters($string, $format = null) {
+function count_letters($string, $format = null)
+{
     if ($format !== null && $format != FORMAT_PLAIN) {
         // Match the usual text cleaning before display.
         // Ideally we should apply multilang filter only here, other filters might add extra text.
         $string = format_text($string, $format, ['filter' => false, 'noclean' => false, 'para' => false]);
+    }
  * Generate and return a random string of the specified length.
+ *
  * @param int $length The length of the string to be created.
  * @return string
  */
-function random_string($length=15) {
+function random_string($length = 15)
+{
     $randombytes = random_bytes($length);
     $pool  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
     $pool .= 'abcdefghijklmnopqrstuvwxyz';
     $pool .= '0123456789';
     $poollen = strlen($pool);
     $string = '';
     for ($i = 0; $i < $length; $i++) {
         $rand = ord($randombytes[$i]);
-        $string .= substr($pool, ($rand%($poollen)), 1);
+        $string .= substr($pool, ($rand % ($poollen)), 1);
+    }
     return $string;
+}
  * larger pool of characters and generates a string between 24 and 32 characters
+ *
  * @param int $length Optional if set generates a string to exactly this length
  * @return string
  */
-function complex_random_string($length=null) {
+function complex_random_string($length = null)
+{
     $pool  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     $pool .= '`~!@#%^&*()_+-=[];,./<>?:{} ';
     $poollen = strlen($pool);
-    if ($length===null) {
+    if ($length === null) {
         $length = floor(rand(24, 32));
+    }
     $randombytes = random_bytes($length);
     $string = '';
     for ($i = 0; $i < $length; $i++) {
         $rand = ord($randombytes[$i]);
-        $string .= $pool[($rand%$poollen)];
+        $string .= $pool[($rand % $poollen)];
+    }
     return $string;
+}
  * @param int $ideal ideal string length
  * @param boolean $exact if false, $text will not be cut mid-word
  * @param string $ending The string to append if the passed string is truncated
  * @return string $truncate shortened string
  */
-function shorten_text($text, $ideal=30, $exact = false, $ending='...') {
+function shorten_text($text, $ideal = 30, $exact = false, $ending = '...')
+{
     // If the plain text is shorter than the maximum length, return the whole text.
     if (core_text::strlen(preg_replace('/<.*?>/', '', $text)) <= $ideal) {
         return $text;
+    }
             // If it's an "empty element" with or without xhtml-conform closing slash (f.e. <br/>).
             if (!preg_match('/^<(\s*.+?\/\s*|\s*(img|br|input|hr|area|base|basefont|col|frame|isindex|link|meta|param)(\s.+?)?)>$/is', $linematchings[1])) {
                 if (preg_match('/^<\s*\/([^\s]+?)\s*>$/s', $linematchings[1], $tagmatchings)) {
                     // Record closing tag.
                     $tagdetails[] = (object) array(
-                            'open' => false,
+                        'open' => false,
-                            'tag'  => core_text::strtolower($tagmatchings[1]),
+                        'tag'  => core_text::strtolower($tagmatchings[1]),
-                            'pos'  => core_text::strlen($truncate),
+                        'pos'  => core_text::strlen($truncate),
-                        );
+                    );
                 } else if (preg_match('/^<\s*([^\s>!]+).*?>$/s', $linematchings[1], $tagmatchings)) {
                     // Record opening tag.
                     $tagdetails[] = (object) array(
-                            'open' => true,
+                        'open' => true,
-                            'tag'  => core_text::strtolower($tagmatchings[1]),
+                        'tag'  => core_text::strtolower($tagmatchings[1]),
-                            'pos'  => core_text::strlen($truncate),
+                        'pos'  => core_text::strlen($truncate),
-                        );
+                    );
                 } else if (preg_match('/^<!--\[if\s.*?\]>$/s', $linematchings[1], $tagmatchings)) {
                     $tagdetails[] = (object) array(
-                            'open' => true,
+                        'open' => true,
-                            'tag'  => core_text::strtolower('if'),
+                        'tag'  => core_text::strtolower('if'),
-                            'pos'  => core_text::strlen($truncate),
+                        'pos'  => core_text::strlen($truncate),
                     );
                 } else if (preg_match('/^<!--<!\[endif\]-->$/s', $linematchings[1], $tagmatchings)) {
                     $tagdetails[] = (object) array(
-                            'open' => false,
+                        'open' => false,
-                            'tag'  => core_text::strtolower('if'),
+                        'tag'  => core_text::strtolower('if'),
-                            'pos'  => core_text::strlen($truncate),
+                        'pos'  => core_text::strlen($truncate),
                     );
+                }
+            }
             // Add html-tag to $truncate'd text.
             $truncate .= $linematchings[1];
             $entitieslength = 0;
             // Search for html entities.
             if (preg_match_all('/&[0-9a-z]{2,8};|&#[0-9]{1,7};|&#x[0-9a-f]{1,6};/i', $linematchings[2], $entities, PREG_OFFSET_CAPTURE)) {
                 // Calculate the real length of all entities in the legal range.
                 foreach ($entities[0] as $entity) {
-                    if ($entity[1]+1-$entitieslength <= $left) {
+                    if ($entity[1] + 1 - $entitieslength <= $left) {
                         $left--;
                         $entitieslength += core_text::strlen($entity[0]);
                     } else {
                         // No more characters left.
                         break;
  * @param string $filename file name
  * @param int $length ideal string length
  * @param bool $includehash Whether to include a file hash in the shortened version. This ensures uniqueness.
  * @return string $shortened shortened file name
  */
-function shorten_filename($filename, $length = MAX_FILENAME_SIZE, $includehash = false) {
+function shorten_filename($filename, $length = MAX_FILENAME_SIZE, $includehash = false)
+{
     $shortened = $filename;
     // Extract a part of the filename if it's char size exceeds the ideal string length.
     if (core_text::strlen($filename) > $length) {
         // Exclude extension if present in filename.
         $mimetypes = get_mimetypes_array();
  * @param array $path The paths to reduce the length.
  * @param int $length Ideal string length
  * @param bool $includehash Whether to include a file hash in the shortened version. This ensures uniqueness.
  * @return array $result Shortened paths in array.
  */
-function shorten_filenames(array $path, $length = MAX_FILENAME_SIZE, $includehash = false) {
+function shorten_filenames(array $path, $length = MAX_FILENAME_SIZE, $includehash = false)
+{
     $result = null;
-    $result = array_reduce($path, function($carry, $singlepath) use ($length, $includehash) {
+    $result = array_reduce($path, function ($carry, $singlepath) use ($length, $includehash) {
         $carry[] = shorten_filename($singlepath, $length, $includehash);
         return $carry;
     }, []);
+ *
  * @param int $startdate Timestamp for the start date
  * @param int $thedate Timestamp for the end date
  * @return string
  */
-function getweek ($startdate, $thedate) {
+function getweek($startdate, $thedate)
+{
     if ($thedate < $startdate) {
         return 0;
+    }
  * {@link http://es2.php.net/manual/en/function.str-shuffle.php#73254}
+ *
  * @param int $maxlen  The maximum size of the password being generated.
  * @return string
  */
-function generate_password($maxlen=10) {
+function generate_password($maxlen = 10)
+{
     global $CFG;
     if (empty($CFG->passwordpolicy)) {
         $fillers = PASSWORD_DIGITS;
         while ($nonalphanum > strlen($passwordnonalphanum)) {
             $passwordnonalphanum .= PASSWORD_NONALPHANUM;
+        }
         // Now mix and shuffle it all.
-        $password = str_shuffle (substr(str_shuffle ($passwordlower), 0, $lower) .
+        $password = str_shuffle(substr(str_shuffle($passwordlower), 0, $lower) .
-                                 substr(str_shuffle ($passwordupper), 0, $upper) .
+            substr(str_shuffle($passwordupper), 0, $upper) .
-                                 substr(str_shuffle ($passworddigits), 0, $digits) .
+            substr(str_shuffle($passworddigits), 0, $digits) .
-                                 substr(str_shuffle ($passwordnonalphanum), 0 , $nonalphanum) .
+            substr(str_shuffle($passwordnonalphanum), 0, $nonalphanum) .
-                                 substr(str_shuffle ($passwordlower .
+            substr(str_shuffle($passwordlower .
-                                                     $passwordupper .
+                $passwordupper .
-                                                     $passworddigits .
+                $passworddigits .
-                                                     $passwordnonalphanum), 0 , $additional));
+                $passwordnonalphanum), 0, $additional));
     }
-    return substr ($password, 0, $maxlen);
+    return substr($password, 0, $maxlen);
+}
  * @param bool $localized use localized decimal separator
  * @param bool $stripzeros If true, removes final zeros after decimal point. It will be ignored and the trailing zeros after
  *                         the decimal point are always striped if $decimalpoints is -1.
  * @return string locale float
  */
-function format_float($float, $decimalpoints=1, $localized=true, $stripzeros=false) {
+function format_float($float, $decimalpoints = 1, $localized = true, $stripzeros = false)
+{
     if (is_null($float)) {
         return '';
+    }
     if ($localized) {
         $separator = get_string('decsep', 'langconfig');
+ *
  * @param string $localefloat locale aware float representation
  * @param bool $strict If true, then check the input and return false if it is not a valid number.
  * @return mixed float|bool - false or the parsed float.
  */
-function unformat_float($localefloat, $strict = false) {
+function unformat_float($localefloat, $strict = false)
+{
     $localefloat = trim((string)$localefloat);
     if ($localefloat == '') {
         return null;
  * Unlike PHP's shuffle() this function works on any machine.
+ *
  * @param array $array The array to be rearranged
  * @return array
  */
-function swapshuffle($array) {
+function swapshuffle($array)
+{
     $last = count($array) - 1;
     for ($i = 0; $i <= $last; $i++) {
         $from = rand(0, $last);
  * Like {@link swapshuffle()}, but works on associative arrays
+ *
  * @param array $array The associative array to be rearranged
  * @return array
  */
-function swapshuffle_assoc($array) {
+function swapshuffle_assoc($array)
+{
     $newarray = array();
     $newkeys = swapshuffle(array_keys($array));
+ *
  * @param array $array
  * @param int $draws
  * @return array
  */
-function draw_rand_array($array, $draws) {
+function draw_rand_array($array, $draws)
+{
     $return = array();
+ *
  * @param string $a The first Microtime
  * @param string $b The second Microtime
  * @return string
  */
-function microtime_diff($a, $b) {
+function microtime_diff($a, $b)
+{
     list($adec, $asec) = explode(' ', $a);
     list($bdec, $bsec) = explode(' ', $b);
     return $bsec - $asec + $bdec - $adec;
+}
+ *
  * @param string $list The string to explode into array bits
  * @param string $separator The separator used within the list string
  * @return array The now assembled array
  */
-function make_menu_from_list($list, $separator=',') {
+function make_menu_from_list($list, $separator = ',')
+{
     $array = array_reverse(explode($separator, $list), true);
     foreach ($array as $key => $item) {
-        $outarray[$key+1] = trim($item);
+        $outarray[$key + 1] = trim($item);
+    }
     return $outarray;
+}
  * @todo Finish documenting this function or better deprecated this completely!
+ *
  * @param int $gradingtype
  * @return array
  */
-function make_grades_menu($gradingtype) {
+function make_grades_menu($gradingtype)
+{
     global $DB;
     $grades = array();
     if ($gradingtype < 0) {
-        if ($scale = $DB->get_record('scale', array('id'=> (-$gradingtype)))) {
+        if ($scale = $DB->get_record('scale', array('id' => (-$gradingtype)))) {
             return make_menu_from_list($scale->scale);
+        }
     } else if ($gradingtype > 0) {
-        for ($i=$gradingtype; $i>=0; $i--) {
+        for ($i = $gradingtype; $i >= 0; $i--) {
-            $grades[$i] = $i .' / '. $gradingtype;
+            $grades[$i] = $i . ' / ' . $gradingtype;
+        }
         return $grades;
+    }
     return $grades;
+ *
  * @uses $_SERVER
  * @param string $extra Extra string to append to the end of the code
  * @return string
  */
-function make_unique_id_code($extra = '') {
+function make_unique_id_code($extra = '')
+{
     $hostname = 'unknownhost';
     if (!empty($_SERVER['HTTP_HOST'])) {
         $hostname = $_SERVER['HTTP_HOST'];
     $date = gmdate("ymdHis");
     $random =  random_string(6);
     if ($extra) {
-        return $hostname .'+'. $date .'+'. $random .'+'. $extra;
+        return $hostname . '+' . $date . '+' . $random . '+' . $extra;
     } else {
-        return $hostname .'+'. $date .'+'. $random;
+        return $hostname . '+' . $date . '+' . $random;
+    }
  * @param string $addr    The address you are checking
  * @param string $subnetstr    The string of subnet addresses
  * @param bool $checkallzeros    The state to whether check for 0.0.0.0
  * @return bool
  */
-function address_in_subnet($addr, $subnetstr, $checkallzeros = false) {
+function address_in_subnet($addr, $subnetstr, $checkallzeros = false)
+{
     if ($addr == '0.0.0.0' && !$checkallzeros) {
         return false;
+    }
+                    }
                     continue;
+                }
                 $ipparts = explode(':', $ip);
                 $modulo  = $mask % 16;
-                $ipnet   = array_slice($ipparts, 0, ($mask-$modulo)/16);
+                $ipnet   = array_slice($ipparts, 0, ($mask - $modulo) / 16);
-                $addrnet = array_slice($addrparts, 0, ($mask-$modulo)/16);
+                $addrnet = array_slice($addrparts, 0, ($mask - $modulo) / 16);
                 if (implode(':', $ipnet) === implode(':', $addrnet)) {
                     if ($modulo == 0) {
                         return true;
+                    }
-                    $pos     = ($mask-$modulo)/16;
+                    $pos     = ($mask - $modulo) / 16;
                     $ipnet   = hexdec($ipparts[$pos]);
                     $addrnet = hexdec($addrparts[$pos]);
                     $mask    = 0xffff << (16 - $modulo);
                     if (($addrnet & $mask) == ($ipnet & $mask)) {
                         return true;
+                    }
+                }
             } else {
                 // IPv4.
                 if ($ipv6) {
                     continue;
+                }
                 $mask = 0xffffffff << (32 - $mask);
                 if (((ip2long($addr) & $mask) == (ip2long($ip) & $mask))) {
                     return true;
+                }
+            }
         } else if (strpos($subnet, '-') !== false) {
             // 2: xxx.xxx.xxx.xxx-yyy or  xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx::xxxx-yyyy. A range of IP addresses in the last group.
             $parts = explode('-', $subnet);
             if (count($parts) != 2) {
                 continue;
                 $addrend = hexdec($addrparts[7]);
                 if (($addrend >= $start) and ($addrend <= $end)) {
                     return true;
-                }
+                }
             } else {
                 // IPv4.
                 if ($ipv6) {
                     continue;
                 if ((ip2long($addr) >= ip2long($ipstart)) and (ip2long($addr) <= ip2long($ipend))) {
                     return true;
+                }
-            }
+            }
         } else {
             // 3: xxx.xxx or xxx.xxx. or xxx:xxx:xxxx or xxx:xxx:xxxx.
             if (strpos($subnet, ':') !== false) {
                 // IPv6.
                 if (!$ipv6) {
                     continue;
+                }
                 $parts = explode(':', $subnet);
                 $count = count($parts);
-                if ($parts[$count-1] === '') {
+                if ($parts[$count - 1] === '') {
-                    unset($parts[$count-1]); // Trim trailing :'s.
+                    unset($parts[$count - 1]); // Trim trailing :'s.
                     $count--;
                     $subnet = implode('.', $parts);
+                }
                 $isip = cleanremoteaddr($subnet, false); // Normalise.
+                    }
                     continue;
                 } else if ($count > 8) {
                     continue;
+                }
-                $zeros = array_fill(0, 8-$count, '0');
+                $zeros = array_fill(0, 8 - $count, '0');
-                $subnet = $subnet.':'.implode(':', $zeros).'/'.($count*16);
+                $subnet = $subnet . ':' . implode(':', $zeros) . '/' . ($count * 16);
                 if (address_in_subnet($addr, $subnet)) {
                     return true;
+                }
             } else {
                 // IPv4.
                 if ($ipv6) {
                     continue;
+                }
                 $parts = explode('.', $subnet);
                 $count = count($parts);
-                if ($parts[$count-1] === '') {
+                if ($parts[$count - 1] === '') {
-                    unset($parts[$count-1]); // Trim trailing .
+                    unset($parts[$count - 1]); // Trim trailing .
                     $count--;
                     $subnet = implode('.', $parts);
+                }
                 if ($count == 4) {
                     $subnet = cleanremoteaddr($subnet, false); // Normalise.
+                    }
                     continue;
                 } else if ($count > 4) {
                     continue;
+                }
-                $zeros = array_fill(0, 4-$count, '0');
+                $zeros = array_fill(0, 4 - $count, '0');
-                $subnet = $subnet.'.'.implode('.', $zeros).'/'.($count*8);
+                $subnet = $subnet . '.' . implode('.', $zeros) . '/' . ($count * 8);
                 if (address_in_subnet($addr, $subnet)) {
                     return true;
+                }
+            }
+        }
  * @param string $string The string to write
  * @param string $eol The end of line char(s) to use
  * @param string $sleep Period to make the application sleep
  *                      This ensures any messages have time to display before redirect
  */
-function mtrace($string, $eol="\n", $sleep=0) {
+function mtrace($string, $eol = "\n", $sleep = 0)
+{
     global $CFG;
     if (isset($CFG->mtrace_wrapper) && function_exists($CFG->mtrace_wrapper)) {
         $fn = $CFG->mtrace_wrapper;
 /**
  * Helper to {@see mtrace()} an exception or throwable, including all relevant information.
+ *
  * @param Throwable $e the error to ouptput.
  */
-function mtrace_exception(Throwable $e): void {
+function mtrace_exception(Throwable $e): void
+{
     $info = get_exception_info($e);
     $message = $info->message;
     if ($info->debuginfo) {
  * Replace 1 or more slashes or backslashes to 1 slash
+ *
  * @param string $path The path to strip
  * @return string the path with double slashes removed
  */
-function cleardoubleslashes ($path) {
+function cleardoubleslashes($path)
+{
     return preg_replace('/(\/|\\\){1,}/', '/', $path);
+}
 /**
  * Is the current ip in a given list?
+ *
  * @param string $list
  * @return bool
  */
+function remoteip_in_list($list)
 function remoteip_in_list($list) {
     $clientip = getremoteaddr(null);
     if (!$clientip) {
  * Returns most reliable client address
+ *
  * @param string $default If an address can't be determined, then return this
  * @return string The remote IP address
  */
-function getremoteaddr($default='0.0.0.0') {
+function getremoteaddr($default = '0.0.0.0')
+{
     global $CFG;
     if (!isset($CFG->getremoteaddrconf)) {
         // This will happen, for example, before just after the upgrade, as the
+    }
     if (!($variablestoskip & GETREMOTEADDR_SKIP_HTTP_X_FORWARDED_FOR)) {
         if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
             $forwardedaddresses = explode(",", $_SERVER['HTTP_X_FORWARDED_FOR']);
-            $forwardedaddresses = array_filter($forwardedaddresses, function($ip) {
+            $forwardedaddresses = array_filter($forwardedaddresses, function ($ip) {
                 global $CFG;
                 return !\core\ip_utils::is_ip_in_subnet_list($ip, $CFG->reverseproxyignore ?? '', ',');
             });
+ *
  * @param string $addr IPv4 or IPv6 address
  * @param bool $compress use IPv6 address compression
  * @return string normalised ip address string, null if error
  */
-function cleanremoteaddr($addr, $compress=false) {
+function cleanremoteaddr($addr, $compress = false)
+{
     $addr = trim($addr);
     if (strpos($addr, ':') !== false) {
         // Can be only IPv6.
         $parts = explode(':', $addr);
         $count = count($parts);
-        if (strpos($parts[$count-1], '.') !== false) {
+        if (strpos($parts[$count - 1], '.') !== false) {
             // Legacy ipv4 notation.
             $last = array_pop($parts);
             $ipv4 = cleanremoteaddr($last, true);
             if ($ipv4 === null) {
                 return null;
             }
             $bits = explode('.', $ipv4);
-            $parts[] = dechex($bits[0]).dechex($bits[1]);
+            $parts[] = dechex($bits[0]) . dechex($bits[1]);
-            $parts[] = dechex($bits[2]).dechex($bits[3]);
+            $parts[] = dechex($bits[2]) . dechex($bits[3]);
             $count = count($parts);
             $addr = implode(':', $parts);
  * Is IP address a public address?
+ *
  * @param string $ip The ip to check
  * @return bool true if the ip is public
  */
-function ip_is_public($ip) {
+function ip_is_public($ip)
+{
     return (bool) filter_var($ip, FILTER_VALIDATE_IP, (FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE));
+}
 /**
  * This function will make a complete copy of anything it's given,
  * regardless of whether it's an object or not.
+ *
  * @param mixed $thing Something you want cloned
  * @return mixed What ever it is you passed it
  */
+function fullclone($thing)
 function fullclone($thing) {
     return unserialize(serialize($thing));
+}
  * @param int $min The minimum value
  * @param int $value The value to check
  * @param int $max The maximum value
  * @return int
  */
-function bounded_number($min, $value, $max) {
+function bounded_number($min, $value, $max)
+{
     if ($value < $min) {
         return $min;
+    }
     if ($value > $max) {
         return $max;
  * Check if there is a nested array within the passed array
+ *
  * @param array $array
  * @return bool true if there is a nested array false otherwise
  */
-function array_is_nested($array) {
+function array_is_nested($array)
+{
     foreach ($array as $value) {
         if (is_array($value)) {
             return true;
+        }
+    }
  * values ready for use, and each of the individual stats provided
  * separately as well.
+ *
  * @return array
  */
-function get_performance_info() {
+function get_performance_info()
+{
     global $CFG, $PERF, $DB, $PAGE;
     $info = array();
+    }
     $info['html'] .= '<ul class="list-unstyled row mx-md-0">';         // Holds userfriendly HTML representation.
     $info['realtime'] = microtime_diff($PERF->starttime, microtime());
-    $info['html'] .= '<li class="timeused col-sm-4">'.$info['realtime'].' secs</li> ';
+    $info['html'] .= '<li class="timeused col-sm-4">' . $info['realtime'] . ' secs</li> ';
-    $info['txt'] .= 'time: '.$info['realtime'].'s ';
+    $info['txt'] .= 'time: ' . $info['realtime'] . 's ';
     // GET/POST (or NULL if $_SERVER['REQUEST_METHOD'] is undefined) is useful for txt logged information.
     $info['txt'] .= 'method: ' . ($_SERVER['REQUEST_METHOD'] ?? "NULL") . ' ';
     if (function_exists('memory_get_usage')) {
         $info['memory_total'] = memory_get_usage();
         $info['memory_growth'] = memory_get_usage() - $PERF->startmemory;
-        $info['html'] .= '<li class="memoryused col-sm-4">RAM: '.display_size($info['memory_total']).'</li> ';
+        $info['html'] .= '<li class="memoryused col-sm-4">RAM: ' . display_size($info['memory_total']) . '</li> ';
-        $info['txt']  .= 'memory_total: '.$info['memory_total'].'B (' . display_size($info['memory_total']).') memory_growth: '.
+        $info['txt']  .= 'memory_total: ' . $info['memory_total'] . 'B (' . display_size($info['memory_total']) . ') memory_growth: ' .
-            $info['memory_growth'].'B ('.display_size($info['memory_growth']).') ';
+            $info['memory_growth'] . 'B (' . display_size($info['memory_growth']) . ') ';
     }
     if (function_exists('memory_get_peak_usage')) {
         $info['memory_peak'] = memory_get_peak_usage();
-        $info['html'] .= '<li class="memoryused col-sm-4">RAM peak: '.display_size($info['memory_peak']).'</li> ';
+        $info['html'] .= '<li class="memoryused col-sm-4">RAM peak: ' . display_size($info['memory_peak']) . '</li> ';
-        $info['txt']  .= 'memory_peak: '.$info['memory_peak'].'B (' . display_size($info['memory_peak']).') ';
+        $info['txt']  .= 'memory_peak: ' . $info['memory_peak'] . 'B (' . display_size($info['memory_peak']) . ') ';
     }
     $info['html'] .= '</ul><ul class="list-unstyled row mx-md-0">';
     $inc = get_included_files();
     $info['includecount'] = count($inc);
             $info['html'] .= "<li class='$key col-sm-4'>$nicenames[$key]: $value </li> ";
             $info['txt'] .= "$key: $value ";
+        }
+    }
-    $info['dbqueries'] = $DB->perf_get_reads().'/'.$DB->perf_get_writes();
+    $info['dbqueries'] = $DB->perf_get_reads() . '/' . $DB->perf_get_writes();
-    $info['html'] .= '<li class="dbqueries col-sm-4">DB reads/writes: '.$info['dbqueries'].'</li> ';
+    $info['html'] .= '<li class="dbqueries col-sm-4">DB reads/writes: ' . $info['dbqueries'] . '</li> ';
-    $info['txt'] .= 'db reads/writes: '.$info['dbqueries'].' ';
+    $info['txt'] .= 'db reads/writes: ' . $info['dbqueries'] . ' ';
     if ($DB->want_read_slave()) {
         $info['dbreads_slave'] = $DB->perf_get_reads_slave();
-        $info['html'] .= '<li class="dbqueries col-sm-4">DB reads from slave: '.$info['dbreads_slave'].'</li> ';
+        $info['html'] .= '<li class="dbqueries col-sm-4">DB reads from slave: ' . $info['dbreads_slave'] . '</li> ';
-        $info['txt'] .= 'db reads from slave: '.$info['dbreads_slave'].' ';
+        $info['txt'] .= 'db reads from slave: ' . $info['dbreads_slave'] . ' ';
     }
     $info['dbtime'] = round($DB->perf_get_queries_time(), 5);
-    $info['html'] .= '<li class="dbtime col-sm-4">DB queries time: '.$info['dbtime'].' secs</li> ';
+    $info['html'] .= '<li class="dbtime col-sm-4">DB queries time: ' . $info['dbtime'] . ' secs</li> ';
     $info['txt'] .= 'db queries time: ' . $info['dbtime'] . 's ';
     // /proc will only work under some linux configurations
     // while uptime is there under MacOSX/Darwin and other unices.
     if (is_readable('/proc/loadavg') && $loadavg = @file('/proc/loadavg')) {
         list($serverload) = explode(' ', $loadavg[0]);
         unset($loadavg);
-    } else if ( function_exists('is_executable') && is_executable('/usr/bin/uptime') && $loadavg = `/usr/bin/uptime` ) {
+    } else if (function_exists('is_executable') && is_executable('/usr/bin/uptime') && $loadavg = `/usr/bin/uptime`) {
         if (preg_match('/load averages?: (\d+[\.,:]\d+)/', $loadavg, $matches)) {
             $serverload = $matches[1];
         } else {
             trigger_error('Could not parse uptime output!');
+        }
+    }
     if (!empty($serverload)) {
         $info['serverload'] = $serverload;
-        $info['html'] .= '<li class="serverload col-sm-4">Load average: '.$info['serverload'].'</li> ';
+        $info['html'] .= '<li class="serverload col-sm-4">Load average: ' . $info['serverload'] . '</li> ';
         $info['txt'] .= "serverload: {$info['serverload']} ";
+    }
     // Display size of session if session started.
         $html .= html_writer::table($table);
         $info['cachesused'] = "$hits / $misses / $sets";
         $info['html'] .= $html;
-        $info['txt'] .= $text.'. ';
+        $info['txt'] .= $text . '. ';
     } else {
         $info['cachesused'] = '0 / 0 / 0';
         $info['html'] .= '<div class="cachesused">Caches used (hits/misses/sets): 0/0/0</div>';
+        }
         $info['html'] .= html_writer::table($table);
         $info['txt'] .= $text . '. ';
+    }
-    $info['html'] = '<div class="performanceinfo siteinfo container-fluid px-md-0 overflow-auto pt-3">'.$info['html'].'</div>';
+    $info['html'] = '<div class="performanceinfo siteinfo container-fluid px-md-0 overflow-auto pt-3">' . $info['html'] . '</div>';
     return $info;
+}
  * @param string $filepath Original filepath
  * @param string $prefix Prefix to use for the temporary name
  * @return string|bool New file path or false if failed
  * @since Moodle 3.10
  */
-function rename_to_unused_name(string $filepath, string $prefix = '_temp_') {
+function rename_to_unused_name(string $filepath, string $prefix = '_temp_')
+{
     $dir = dirname($filepath);
     $basename = $dir . '/' . $prefix;
     $limit = 0;
     while ($limit < 100) {
         // Select a new name based on a random number.
+ *
  * @param string $dir directory path
  * @param bool $contentonly
  * @return bool success, true also if dir does not exist
  */
-function remove_dir($dir, $contentonly=false) {
+function remove_dir($dir, $contentonly = false)
+{
     if (!is_dir($dir)) {
         // Nothing to do.
         return true;
+    }
     if (!$handle = opendir($dir)) {
         return false;
+    }
     $result = true;
-    while (false!==($item = readdir($handle))) {
+    while (false !== ($item = readdir($handle))) {
         if ($item != '.' && $item != '..') {
-            if (is_dir($dir.'/'.$item)) {
+            if (is_dir($dir . '/' . $item)) {
-                $result = remove_dir($dir.'/'.$item) && $result;
+                $result = remove_dir($dir . '/' . $item) && $result;
             } else {
-                $result = unlink($dir.'/'.$item) && $result;
+                $result = unlink($dir . '/' . $item) && $result;
+            }
+        }
+    }
     closedir($handle);
+ *
  * @param mixed $obj Name of class or real object to test
  * @param string $property name of property to find
  * @return bool true if property exists
  */
-function object_property_exists( $obj, $property ) {
+function object_property_exists($obj, $property)
+{
-    if (is_string( $obj )) {
+    if (is_string($obj)) {
-        $properties = get_class_vars( $obj );
+        $properties = get_class_vars($obj);
     } else {
-        $properties = get_object_vars( $obj );
+        $properties = get_object_vars($obj);
+    }
-    return array_key_exists( $property, $properties );
+    return array_key_exists($property, $properties);
+}
 /**
  * Converts an object into an associative array
  * and return all available properties in getIterator()
+ *
  * @param mixed $var
  * @return array
  */
-function convert_to_array($var) {
+function convert_to_array($var)
+{
     $result = array();
     // Loop over elements/properties.
     foreach ($var as $key => $value) {
  * Detect a custom script replacement in the data directory that will
  * replace an existing moodle script
+ *
  * @return string|bool full path name if a custom script exists, false if no custom script exists
  */
-function custom_script_path() {
+function custom_script_path()
+{
     global $CFG, $SCRIPT;
     if ($SCRIPT === null) {
         // Probably some weird external script.
  * is in moodlelib because it does not rely on loading any of the MNET code.
+ *
  * @param object $user A valid user object
  * @return bool        True if the user is from a remote Moodle.
  */
-function is_mnet_remote_user($user) {
+function is_mnet_remote_user($user)
+{
     global $CFG;
     if (!isset($CFG->mnet_localhost_id)) {
         include_once($CFG->dirroot . '/mnet/lib.php');
 /**
  * This function will search for browser prefereed languages, setting Moodle
  * to use the best one available if $SESSION->lang is undefined
  */
+function setup_lang_from_browser()
 function setup_lang_from_browser() {
     global $CFG, $SESSION, $USER;
     if (!empty($SESSION->lang) or !empty($USER->lang) or empty($CFG->autolang)) {
     $order = 1.0;
     foreach ($rawlangs as $lang) {
         if (strpos($lang, ';') === false) {
             $langs[(string)$order] = $lang;
-            $order = $order-0.01;
+            $order = $order - 0.01;
         } else {
             $parts = explode(';', $lang);
             $pos = strpos($parts[1], '=');
-            $langs[substr($parts[1], $pos+1)] = $parts[0];
+            $langs[substr($parts[1], $pos + 1)] = $parts[0];
+        }
+    }
     krsort($langs, SORT_NUMERIC);
  * Any errors just result in the proxy being used (least bad)
+ *
  * @param string $url url to check
  * @return boolean true if we should bypass the proxy
  */
-function is_proxybypass( $url ) {
+function is_proxybypass($url)
+{
     global $CFG;
     // Sanity check.
     if (empty($CFG->proxyhost) or empty($CFG->proxybypass)) {
         return false;
+    }
     // Get the host part out of the url.
-    if (!$host = parse_url( $url, PHP_URL_HOST )) {
+    if (!$host = parse_url($url, PHP_URL_HOST)) {
         return false;
     }
     // Get the possible bypass hosts into an array.
-    $matches = explode( ',', $CFG->proxybypass );
+    $matches = explode(',', $CFG->proxybypass);
  * Check if the passed navigation is of the new style
+ *
  * @param mixed $navigation
  * @return bool true for yes false for no
  */
-function is_newnav($navigation) {
+function is_newnav($navigation)
+{
     if (is_array($navigation) && !empty($navigation['newnav'])) {
         return true;
     } else {
         return false;
+    }
+ *
  * @param string $var The variable name
  * @param object $object The object to check
  * @return boolean
  */
-function in_object_vars($var, $object) {
+function in_object_vars($var, $object)
+{
     $classvars = get_class_vars(get_class($object));
     $classvars = array_keys($classvars);
     return in_array($var, $classvars);
+}
+ *
  * @param array $array
  * @param bool $keepkeyassoc
  * @return array
  */
-function object_array_unique($array, $keepkeyassoc = true) {
+function object_array_unique($array, $keepkeyassoc = true)
+{
     $duplicatekeys = array();
     $tmp         = array();
     foreach ($array as $key => $val) {
  * Is a userid the primary administrator?
+ *
  * @param int $userid int id of user to check
  * @return boolean
  */
-function is_primary_admin($userid) {
+function is_primary_admin($userid)
+{
     $primaryadmin =  get_admin();
     if ($userid == $primaryadmin->id) {
         return true;
 /**
  * Returns the site identifier
+ *
  * @return string $CFG->siteidentifier, first making sure it is properly initialised.
  */
-function get_site_identifier() {
+function get_site_identifier()
+{
     global $CFG;
     // Check to see if it is missing. If so, initialise it.
     if (empty($CFG->siteidentifier)) {
         set_config('siteidentifier', random_string(32) . $_SERVER['HTTP_HOST']);
+    }
+ *
  * @param string $password   password to be checked against the password policy
  * @param integer $maxchars  maximum number of consecutive identical characters
  * @return bool
  */
-function check_consecutive_identical_characters($password, $maxchars) {
+function check_consecutive_identical_characters($password, $maxchars)
+{
     if ($maxchars < 1) {
         return true; // Zero 0 is to disable this check.
+    }
+ *
  * @param mixed $function a php callback
  * @param mixed $arg1,... $argv arguments to partially bind with
  * @return array Array callback
  */
-function partial() {
+function partial()
+{
     if (!class_exists('partial')) {
         /**
          * Used to manage function binding.
          * @copyright  2009 Penny Leach
          * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
          */
-        class partial{
+        class partial
+        {
             /** @var array */
             public $values = array();
             /** @var string The function to call as a callback. */
             public $func;
             /**
              * Constructor
              * @param string $func
              * @param array $args
              */
-            public function __construct($func, $args) {
+            public function __construct($func, $args)
+            {
                 $this->values = $args;
                 $this->func = $func;
+            }
             /**
              * Calls the callback function.
              * @return mixed
              */
-            public function method() {
+            public function method()
+            {
                 $args = func_get_args();
                 return call_user_func_array($this->func, array_merge($this->values, $args));
+            }
+        }
+    }
  * helper function to load up and initialise the mnet environment
  * this must be called before you use mnet functions.
+ *
  * @return mnet_environment the equivalent of old $MNET global
  */
-function get_mnet_environment() {
+function get_mnet_environment()
+{
     global $CFG;
     require_once($CFG->dirroot . '/mnet/lib.php');
     static $instance = null;
     if (empty($instance)) {
         $instance = new mnet_environment();
  * during xmlrpc server code execution, any code wishing to access
  * information about the remote peer must use this to get it.
+ *
  * @return mnet_remote_client|false the equivalent of old $MNETREMOTE_CLIENT global
  */
-function get_mnet_remote_client() {
+function get_mnet_remote_client()
+{
     if (!defined('MNET_SERVER')) {
         debugging(get_string('notinxmlrpcserver', 'mnet'));
         return false;
+    }
     global $MNET_REMOTE_CLIENT;
  * to setup the object returned by {@link get_mnet_remote_client}
+ *
  * @param mnet_remote_client $client the client to set up
  * @throws moodle_exception
  */
-function set_mnet_remote_client($client) {
+function set_mnet_remote_client($client)
+{
     if (!defined('MNET_SERVER')) {
         throw new moodle_exception('notinxmlrpcserver', 'mnet');
+    }
     global $MNET_REMOTE_CLIENT;
     $MNET_REMOTE_CLIENT = $client;
  * return the jump url for a given remote user
  * this is used for rewriting forum post links in emails, etc
+ *
  * @param stdclass $user the user to get the idp url for
  */
-function mnet_get_idp_jump_url($user) {
+function mnet_get_idp_jump_url($user)
+{
     global $CFG;
     static $mnetjumps = array();
     if (!array_key_exists($user->mnethostid, $mnetjumps)) {
 /**
  * Gets the homepage to use for the current user
+ *
  * @return int One of HOMEPAGE_*
  */
-function get_home_page() {
+function get_home_page()
+{
     global $CFG;
     if (isloggedin() && !isguestuser() && !empty($CFG->defaulthomepage)) {
         // If dashboard is disabled, home will be set to default page.
  * Returns the default home page to display if current one is not defined or can't be applied.
  * The default behaviour is to return Dashboard if it's enabled or My courses page if it isn't.
+ *
  * @return int The default home page.
  */
-function get_default_home_page(): int {
+function get_default_home_page(): int
+{
     global $CFG;
     return (!isset($CFG->enabledashboard) || $CFG->enabledashboard) ? HOMEPAGE_MY : HOMEPAGE_MYCOURSES;
  * By default this is just $course->fullname but user can configure it. The
  * result of this function should be passed through print_string.
  * @param stdClass|core_course_list_element $course Moodle course object
  * @return string Display name of course (either fullname or short + fullname)
  */
-function get_course_display_name_for_list($course) {
+function get_course_display_name_for_list($course)
+{
     global $CFG;
     if (!empty($CFG->courselistshortnames)) {
         if (!($course instanceof stdClass)) {
             $course = (object)convert_to_array($course);
+        }
  * Arrays may contain only integers or strings as both keys and values. Nested arrays are allowed.
+ *
  * @param string $expression
  * @return array|bool either parsed array or false if parsing was impossible.
  */
-function unserialize_array($expression) {
+function unserialize_array($expression)
+{
     // Check the expression is an array.
     if (!preg_match('/^a:(\d+):/', $expression)) {
         return false;
+    }
     $values = (array) unserialize_object($expression);
     // Callback that returns true if the given value is an unserialized object, executes recursively.
-    $invalidvaluecallback = static function($value) use (&$invalidvaluecallback): bool {
+    $invalidvaluecallback = static function ($value) use (&$invalidvaluecallback): bool {
         if (is_array($value)) {
             return (bool) array_filter($value, $invalidvaluecallback);
  * otherwise we would return an instances of {@see __PHP_Incomplete_class} for malformed strings
+ *
  * @param string $input
  * @return stdClass
  */
-function unserialize_object(string $input): stdClass {
+function unserialize_object(string $input): stdClass
+{
     $instance = (array) unserialize($input, ['allowed_classes' => [stdClass::class]]);
     return (object) $instance;
+}
  * @package    core
  * @category   string
  * @copyright  2011 Sam Hemelryk
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class lang_string {
+class lang_string
+{
     /** @var string The strings identifier */
     protected $identifier;
     /** @var string The strings component. Default '' */
      * @param string $component The strings component
      * @param stdClass|array|mixed $a Any arguments the string requires
      * @param string $lang The language to use when processing the string.
      * @throws coding_exception
      */
-    public function __construct($identifier, $component = '', $a = null, $lang = null) {
+    public function __construct($identifier, $component = '', $a = null, $lang = null)
+    {
         if (empty($component)) {
             $component = 'moodle';
+        }
+            }
             if (!empty($this->component) && clean_param($this->component, PARAM_COMPONENT) == '') {
                 throw new coding_exception('Invalid string compontent. Please check your string definition');
+            }
             if (!get_string_manager()->string_exists($this->identifier, $this->component)) {
-                debugging('String does not exist. Please check your string definition for '.$this->identifier.'/'.$this->component, DEBUG_DEVELOPER);
+                debugging('String does not exist. Please check your string definition for ' . $this->identifier . '/' . $this->component, DEBUG_DEVELOPER);
+            }
+        }
+    }
      * compatibility.
+     *
      * @return string
      * @throws coding_exception
      */
-    protected function get_string() {
+    protected function get_string()
+    {
         global $CFG;
         // Check if we need to process the string.
         if ($this->string === null) {
      * Returns the string
+     *
      * @param string $lang The langauge to use when processing the string
      * @return string
      */
-    public function out($lang = null) {
+    public function out($lang = null)
+    {
         if ($lang !== null && $lang != $this->lang && ($this->lang == null && $lang != current_language())) {
             if ($this->forcedstring) {
-                debugging('lang_string objects that have been used cannot be printed in another language. ('.$this->lang.' used)', DEBUG_DEVELOPER);
+                debugging('lang_string objects that have been used cannot be printed in another language. (' . $this->lang . ' used)', DEBUG_DEVELOPER);
                 return $this->get_string();
+            }
             $translatedstring = new lang_string($this->identifier, $this->component, $this->a, $lang);
             return $translatedstring->out();
+        }
     /**
      * Magic __toString method for printing a string
+     *
      * @return string
      */
-    public function __toString() {
+    public function __toString()
+    {
         return $this->get_string();
+    }
     /**
      * Magic __set_state method used for var_export
+     *
      * @param array $array
      * @return self
      */
+    public static function __set_state(array $array): self
     public static function __set_state(array $array): self {
         $tmp = new lang_string($array['identifier'], $array['component'], $array['a'], $array['lang']);
         $tmp->string = $array['string'];
         $tmp->forcedstring = $array['forcedstring'];
         return $tmp;
      * string properties... the string cannot be regenerated so we need to ensure
      * it is generated for this.
+     *
      * @return array
      */
-    public function __sleep() {
+    public function __sleep()
+    {
         $this->get_string();
         $this->forcedstring = true;
         return array('forcedstring', 'string', 'lang');
+    }
     /**
      * Returns the identifier.
+     *
      * @return string
      */
+    public function get_identifier()
     public function get_identifier() {
         return $this->identifier;
+    }
     /**
      * Returns the component.
+     *
      * @return string
+     */
-     */
+    public function get_component()
     public function get_component() {
         return $this->component;
+    }
  * It does not check if the callable actually exists.
+ *
  * @param callable|string|array $callable
  * @return string|bool Human readable name of callable, or false if not a valid callable.
  */
-function get_callable_name($callable) {
+function get_callable_name($callable)
+{
     if (!is_callable($callable, true, $name)) {
-        return false;
         return false;
     } else {
         return $name;
+    }
  * Good thing is there is no false negative.
  * Note that it's possible to force the result of this check by specifying $CFG->site_is_public in config.php
+ *
  * @return bool
  */
-function site_is_public() {
+function site_is_public()
+{
     global $CFG;
     // Return early if site admin has forced this setting.
     if (isset($CFG->site_is_public)) {
+ *
  * @param string $password
  * @param int $pepperlength The length of the used peppers
  * @return bool
  */
-function exceeds_password_length(string $password, int $pepperlength = 0): bool {
+function exceeds_password_length(string $password, int $pepperlength = 0): bool
+{
     return (strlen($password) > (MAX_PASSWORD_CHARACTERS + $pepperlength));
+}
 /**
  * @param array $array
  * @param mixed $filter The value to filter on
  * @param bool $strict Whether to apply a strit test with the filter
  * @return array
  */
-function moodle_array_keys_filter(array $array, mixed $filter, bool $strict = false): array {
+function moodle_array_keys_filter(array $array, mixed $filter, bool $strict = false): array
+{
     return array_keys(array_filter(
         $array,
-        function($value, $key) use ($filter, $strict): bool {
+        function ($value, $key) use ($filter, $strict): bool {
             if ($strict) {
                 return $value === $filter;
+            }
             return $value == $filter;
         },

Proyectos de Subversion Moodle

(root)/lib/moodlelib.php – Rev 11 → 1326