WebSVN – Moodle – Diff – /lib/classes/user.php

 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
-/**
- * User class
- *
- * @package    core
- * @copyright  2013 Rajesh Taneja <rajesh@moodle.com>
- * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+namespace core;
+use core\context\user as context_user;
+use core\context\course as context_course;
+use core\context\system as context_system;
+use core_user\fields;
- */
+use core\exception\invalid_parameter_exception;
+use core\exception\moodle_exception;
+use core\exception\coding_exception;
+use core\output\theme_config;
+use core\output\user_picture;
+use core_date;
 use dml_exception;
-defined('MOODLE_INTERNAL') || die();
+use stdClass;
 /**
  * User class to access user details.
+ *
- * @todo       move api's from user/lib.php and deprecate old ones.
+ * @todo       MDL-82650 Move api's from user/lib.php and deprecate old ones.
  * @package    core
  * @copyright  2013 Rajesh Taneja <rajesh@moodle.com>
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class core_user {
+class user {
     /**
         'phone2',
         'address',
         'firstnamephonetic',
         'lastnamephonetic',
         'middlename',
-        'alternatename'
+        'alternatename',
     ];
     /** @var int Indicates that user profile view should be prevented */
     const VIEWPROFILE_PREVENT = -1;
     /** @var array store user preferences cache. */
     protected static $preferencescache = null;
     /**
      * Return user object from db or create noreply or support user,
-     * if userid matches corse_user::NOREPLY_USER or corse_user::SUPPORT_USER
+     * if userid matches \core\user::NOREPLY_USER or \core\user::SUPPORT_USER
      * respectively. If userid is not found, then return false.
+     *
      * @param int $userid user id
      * @param string $fields A comma separated list of user fields to be returned, support and noreply user
                 break;
             case self::SUPPORT_USER:
                 return self::get_support_user();
                 break;
             default:
-                return $DB->get_record('user', array('id' => $userid), $fields, $strictness);
+                return $DB->get_record('user', ['id' => $userid], $fields, $strictness);
+        }
+    }
     /**
         if (empty($mnethostid)) {
             // If empty, we restrict to local users.
             $mnethostid = $CFG->mnet_localhost_id;
+        }
-        return $DB->get_record('user', array('email' => $email, 'mnethostid' => $mnethostid), $fields, $strictness);
+        return $DB->get_record('user', ['email' => $email, 'mnethostid' => $mnethostid], $fields, $strictness);
+    }
     /**
         if (empty($mnethostid)) {
             // If empty, we restrict to local users.
             $mnethostid = $CFG->mnet_localhost_id;
+        }
+        return $DB->get_record('user', ['username' => $username, 'mnethostid' => $mnethostid], $fields, $strictness);
+    }
+    /**
+     * Return User object based on their idnumber.
+     *
+     * @param string $idnumber The idnumber of the user searched.
+     * @param string $fields A comma separated list of user fields to be returned, support and noreply user.
+     * @param null|int $mnethostid The id of the remote host.
+     * @param int $strictness IGNORE_MISSING means compatible mode, false returned if user not found, debug message if more found;
+     *                        IGNORE_MULTIPLE means return first user, ignore multiple user records found(not recommended);
+     *                        MUST_EXIST means throw an exception if no user record or multiple records found.
+     * @return stdClass|bool user record if found, else false.
+     */
+    public static function get_user_by_idnumber(
+        string $idnumber,
+        string $fields = '*',
+        ?int $mnethostid = null,
+        int $strictness = IGNORE_MISSING,
+    ): stdClass|bool {
+        global $DB, $CFG;
+        // Because we use the username as the search criteria, we must also restrict our search based on mnet host.
+        if (empty($mnethostid)) {
+            // If empty, we restrict to local users.
+            $mnethostid = $CFG->mnet_localhost_id;
+        }
+        return $DB->get_record('user', [
+            'idnumber' => $idnumber,
+            'mnethostid' => $mnethostid,
-        return $DB->get_record('user', array('username' => $username, 'mnethostid' => $mnethostid), $fields, $strictness);
+        ], $fields, $strictness);
+    }
     /**
+     *
      * The returned user objects include id, username, all fields required for user pictures, and
      * user identity fields.
+     *
      * @param string $query Search query text
-     * @param \context_course|null $coursecontext Course context or null if system-wide
+     * @param context_course|null $coursecontext Course context or null if system-wide
      * @param int $max Max number of users to return, default 30 (zero = no limit)
      * @param int $querylimit Max number of database queries, default 5 (zero = no limit)
      * @return array Array of user objects with limited fields
      */
+    public static function search(
+        $query,
-    public static function search($query, \context_course $coursecontext = null,
+        ?context_course $coursecontext = null,
+        $max = 30,
-            $max = 30, $querylimit = 5) {
+        $querylimit = 5
+    ) {
         global $CFG, $DB;
         require_once($CFG->dirroot . '/user/lib.php');
         // Allow limits to be turned off.
         if (!$querylimit) {
             $querylimit = PHP_INT_MAX;
+        }
         // Check permission to view profiles at each context.
-        $systemcontext = \context_system::instance();
+        $systemcontext = context_system::instance();
         $viewsystem = has_capability('moodle/user:viewdetails', $systemcontext);
         if ($viewsystem) {
             $userquery = 'SELECT id FROM {user}';
             $userparams = [];
+        }
         if (!$viewsystem) {
-            list($userquery, $userparams) = self::get_enrolled_sql_on_courses_with_capability(
+            [$userquery, $userparams] = self::get_enrolled_sql_on_courses_with_capability(
+                'moodle/user:viewdetails'
-                    'moodle/user:viewdetails');
+            );
             if (!$userquery) {
                 // No permissions anywhere, return nothing.
                 return [];
+            }
+        }
         // Start building the WHERE clause based on name.
-        list ($where, $whereparams) = users_search_sql($query, 'u');
+         [$where, $whereparams] = users_search_sql($query, 'u');
         // We allow users to search with extra identity fields (as well as name) but only if they
                 // They have permission everywhere so just add the extra query to the normal query.
                 $where .= ' OR ' . $extrasql;
                 $whereparams = array_merge($whereparams, $extraparams);
             } else {
                 // Get all courses where user can view full user identity.
-                list($sql, $params) = self::get_enrolled_sql_on_courses_with_capability(
+                [$sql, $params] = self::get_enrolled_sql_on_courses_with_capability(
-                    'moodle/site:viewuseridentity');
+                    'moodle/site:viewuseridentity'
+                );
                 if ($sql) {
                     // Join that with the user query to get an extra field indicating if we can.
                     $userquery = "
                         SELECT innerusers.id, COUNT(identityusers.id) AS showidentity
                           FROM ($userquery) innerusers
+            }
+        }
         // Default order is just name order. But if searching within a course then we show users
         // within the course first.
-        list ($order, $orderparams) = users_order_by_sql('u', $query, $systemcontext);
+         [$order, $orderparams] = users_order_by_sql('u', $query, $systemcontext);
         if ($coursecontext) {
-            list ($sql, $params) = get_enrolled_sql($coursecontext);
+             [$sql, $params] = get_enrolled_sql($coursecontext);
             $mainfield = 'innerusers2.id';
             if ($usingshowidentity) {
                 $mainfield .= ', innerusers2.showidentity';
+            }
         $result = [];
         $got = 0;
         $pos = 0;
         $readcount = $max + 2;
         for ($i = 0; $i < $querylimit; $i++) {
-            $rawresult = $DB->get_records_sql("
+            $rawresult = $DB->get_records_sql(
+                "
                     SELECT $selectfields
                       FROM ($userquery) users
                       JOIN {user} u ON u.id = users.id
                      WHERE $where
+                  ORDER BY $order",
-                  ORDER BY $order", array_merge($userparams, $whereparams, $orderparams),
+                array_merge($userparams, $whereparams, $orderparams),
+                $pos,
-                    $pos, $readcount);
+                $readcount
+            );
             foreach ($rawresult as $user) {
                 // Skip guest.
                 if ($user->username === 'guest') {
                     continue;
+                }
      * @param string $capability Required capability
      * @return array Array containing SQL and params, or two nulls if there are no courses
      */
     protected static function get_enrolled_sql_on_courses_with_capability($capability) {
         // Get all courses where user have the capability.
-        $courses = get_user_capability_course($capability, null, true,
+        $courses = get_user_capability_course(
+            $capability,
+            null,
+            true,
-                implode(',', array_values(context_helper::get_preload_record_columns('ctx'))));
+            implode(',', array_values(context_helper::get_preload_record_columns('ctx')))
+        );
         if (!$courses) {
             return [null, null];
+        }
         // pass an array of courseids, but it doesn't.
         $unionsql = '';
         $unionparams = [];
         foreach ($courses as $course) {
             // Get SQL to list user ids enrolled in this course.
-            \context_helper::preload_from_record($course);
+            context_helper::preload_from_record($course);
-            list ($sql, $params) = get_enrolled_sql(\context_course::instance($course->id));
+             [$sql, $params] = get_enrolled_sql(context_course::instance($course->id));
             // Combine to a big union query.
             if ($unionsql) {
                 $unionsql .= ' UNION ';
         if ($userid <= 0) {
             return false;
+        }
         if ($checkdb) {
-            return $DB->record_exists('user', array('id' => $userid));
+            return $DB->record_exists('user', ['id' => $userid]);
         } else {
             return true;
+        }
         if (isguestuser($user)) {
             throw new moodle_exception('guestsarenotallowed', 'error');
         }
-        if ($checksuspended and $user->suspended) {
+        if ($checksuspended && $user->suspended) {
             throw new moodle_exception('suspended', 'auth');
+        }
-        if ($checknologin and $user->auth == 'nologin') {
+        if ($checknologin && $user->auth == 'nologin') {
             throw new moodle_exception('suspended', 'auth');
+     *
      * @param stdClass $usernew An object that contains some information about the user being updated
      * @param array $filemanageroptions
      * @return bool True if the user was updated, false if it stayed the same.
      */
-    public static function update_picture(stdClass $usernew, $filemanageroptions = array()) {
+    public static function update_picture(stdClass $usernew, $filemanageroptions = []) {
         global $CFG, $DB;
         require_once("$CFG->libdir/gdlib.php");
         $context = context_user::instance($usernew->id, MUST_EXIST);
-        $user = core_user::get_user($usernew->id, 'id, picture', MUST_EXIST);
+        $user = self::get_user($usernew->id, 'id, picture', MUST_EXIST);
         $newpicture = $user->picture;
         // Get file_storage to process files.
                 return false;
+            }
+        }
         if ($newpicture != $user->picture) {
-            $DB->set_field('user', 'picture', $newpicture, array('id' => $user->id));
+            $DB->set_field('user', 'picture', $newpicture, ['id' => $user->id]);
             return true;
         } else {
             return false;
+        }
             return;
+        }
         // Array of user fields properties and expected parameters.
         // Every new field on the user table should be added here otherwise it won't be validated.
-        $fields = array();
+        $fields = [];
-        $fields['id'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['id'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['auth'] = array('type' => PARAM_AUTH, 'null' => NULL_NOT_ALLOWED);
+        $fields['auth'] = ['type' => PARAM_AUTH, 'null' => NULL_NOT_ALLOWED];
-        $fields['confirmed'] = array('type' => PARAM_BOOL, 'null' => NULL_NOT_ALLOWED);
+        $fields['confirmed'] = ['type' => PARAM_BOOL, 'null' => NULL_NOT_ALLOWED];
-        $fields['policyagreed'] = array('type' => PARAM_BOOL, 'null' => NULL_NOT_ALLOWED);
+        $fields['policyagreed'] = ['type' => PARAM_BOOL, 'null' => NULL_NOT_ALLOWED];
-        $fields['deleted'] = array('type' => PARAM_BOOL, 'null' => NULL_NOT_ALLOWED);
+        $fields['deleted'] = ['type' => PARAM_BOOL, 'null' => NULL_NOT_ALLOWED];
-        $fields['suspended'] = array('type' => PARAM_BOOL, 'null' => NULL_NOT_ALLOWED);
+        $fields['suspended'] = ['type' => PARAM_BOOL, 'null' => NULL_NOT_ALLOWED];
-        $fields['mnethostid'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['mnethostid'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['username'] = array('type' => PARAM_USERNAME, 'null' => NULL_NOT_ALLOWED);
+        $fields['username'] = ['type' => PARAM_USERNAME, 'null' => NULL_NOT_ALLOWED];
-        $fields['password'] = array('type' => PARAM_RAW, 'null' => NULL_NOT_ALLOWED);
+        $fields['password'] = ['type' => PARAM_RAW, 'null' => NULL_NOT_ALLOWED];
-        $fields['idnumber'] = array('type' => PARAM_RAW, 'null' => NULL_NOT_ALLOWED);
+        $fields['idnumber'] = ['type' => PARAM_RAW, 'null' => NULL_NOT_ALLOWED];
-        $fields['firstname'] = array('type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED);
+        $fields['firstname'] = ['type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED];
-        $fields['lastname'] = array('type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED);
+        $fields['lastname'] = ['type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED];
-        $fields['surname'] = array('type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED);
+        $fields['surname'] = ['type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED];
-        $fields['email'] = array('type' => PARAM_RAW_TRIMMED, 'null' => NULL_NOT_ALLOWED);
+        $fields['email'] = ['type' => PARAM_RAW_TRIMMED, 'null' => NULL_NOT_ALLOWED];
-        $fields['emailstop'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED, 'default' => 0);
+        $fields['emailstop'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED, 'default' => 0];
-        $fields['phone1'] = array('type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED);
+        $fields['phone1'] = ['type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED];
-        $fields['phone2'] = array('type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED);
+        $fields['phone2'] = ['type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED];
-        $fields['institution'] = array('type' => PARAM_TEXT, 'null' => NULL_NOT_ALLOWED);
+        $fields['institution'] = ['type' => PARAM_TEXT, 'null' => NULL_NOT_ALLOWED];
-        $fields['department'] = array('type' => PARAM_TEXT, 'null' => NULL_NOT_ALLOWED);
+        $fields['department'] = ['type' => PARAM_TEXT, 'null' => NULL_NOT_ALLOWED];
-        $fields['address'] = array('type' => PARAM_TEXT, 'null' => NULL_NOT_ALLOWED);
+        $fields['address'] = ['type' => PARAM_TEXT, 'null' => NULL_NOT_ALLOWED];
+        $fields['city'] = ['type' => PARAM_TEXT, 'null' => NULL_NOT_ALLOWED, 'default' => $CFG->defaultcity];
+        $fields['country'] = [
+            'type' => PARAM_ALPHA,
-        $fields['city'] = array('type' => PARAM_TEXT, 'null' => NULL_NOT_ALLOWED, 'default' => $CFG->defaultcity);
+            'null' => NULL_NOT_ALLOWED,
+            'default' => $CFG->country,
+            'choices' => array_merge(
-        $fields['country'] = array('type' => PARAM_ALPHA, 'null' => NULL_NOT_ALLOWED, 'default' => $CFG->country,
+                ['' => ''],
+                get_string_manager()->get_list_of_countries(true, true)
+            ),
+        ];
+        $fields['lang'] = [
-                'choices' => array_merge(array('' => ''), get_string_manager()->get_list_of_countries(true, true)));
+            'type' => PARAM_LANG,
-        $fields['lang'] = array('type' => PARAM_LANG, 'null' => NULL_NOT_ALLOWED,
+            'null' => NULL_NOT_ALLOWED,
+            'default' => (!empty($CFG->autolangusercreation) && !empty($SESSION->lang)) ? $SESSION->lang : $CFG->lang,
+            'choices' => array_merge(
-                'default' => (!empty($CFG->autolangusercreation) && !empty($SESSION->lang)) ? $SESSION->lang : $CFG->lang,
+                ['' => ''],
+                get_string_manager()->get_list_of_translations(false)
+            ),
+        ];
+        $fields['calendartype'] = [
+            'type' => PARAM_PLUGIN,
-                'choices' => array_merge(array('' => ''), get_string_manager()->get_list_of_translations(false)));
+            'null' => NULL_NOT_ALLOWED,
+            'default' => $CFG->calendartype,
+            'choices' => array_merge(
-        $fields['calendartype'] = array('type' => PARAM_PLUGIN, 'null' => NULL_NOT_ALLOWED, 'default' => $CFG->calendartype,
+                ['' => ''],
+                \core_calendar\type_factory::get_list_of_calendar_types()
+            ),
+        ];
+        $fields['theme'] = [
-                'choices' => array_merge(array('' => ''), \core_calendar\type_factory::get_list_of_calendar_types()));
+            'type' => PARAM_THEME,
-        $fields['theme'] = array('type' => PARAM_THEME, 'null' => NULL_NOT_ALLOWED,
+            'null' => NULL_NOT_ALLOWED,
+            'default' => theme_config::DEFAULT_THEME,
+            'choices' => array_merge(
+                ['' => ''],
+                get_list_of_themes()
+            ),
+        ];
+        $fields['timezone'] = [
+            // Must not use choices here: timezones can come and go.
-                'default' => theme_config::DEFAULT_THEME, 'choices' => array_merge(array('' => ''), get_list_of_themes()));
+            'type' => PARAM_TIMEZONE,
-        $fields['timezone'] = array('type' => PARAM_TIMEZONE, 'null' => NULL_NOT_ALLOWED,
+            'null' => NULL_NOT_ALLOWED,
+            'default' => core_date::get_server_timezone(),
-                'default' => core_date::get_server_timezone()); // Must not use choices here: timezones can come and go.
+        ];
-        $fields['firstaccess'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['firstaccess'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['lastaccess'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['lastaccess'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['lastlogin'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['lastlogin'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['currentlogin'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['currentlogin'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['lastip'] = array('type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED);
+        $fields['lastip'] = ['type' => PARAM_NOTAGS, 'null' => NULL_NOT_ALLOWED];
-        $fields['secret'] = array('type' => PARAM_ALPHANUM, 'null' => NULL_NOT_ALLOWED);
+        $fields['secret'] = ['type' => PARAM_ALPHANUM, 'null' => NULL_NOT_ALLOWED];
-        $fields['picture'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['picture'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['description'] = array('type' => PARAM_RAW, 'null' => NULL_ALLOWED);
+        $fields['description'] = ['type' => PARAM_RAW, 'null' => NULL_ALLOWED];
+        $fields['descriptionformat'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
+        $fields['mailformat'] = [
-        $fields['descriptionformat'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+            'type' => PARAM_INT,
-        $fields['mailformat'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED,
+            'null' => NULL_NOT_ALLOWED,
+            'default' => $CFG->defaultpreference_mailformat,
+        ];
+        $fields['maildigest'] = [
-                'default' => $CFG->defaultpreference_mailformat);
+            'type' => PARAM_INT,
-        $fields['maildigest'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED,
+            'null' => NULL_NOT_ALLOWED,
+            'default' => $CFG->defaultpreference_maildigest,
+        ];
+        $fields['maildisplay'] = [
-                'default' => $CFG->defaultpreference_maildigest);
+            'type' => PARAM_INT,
-        $fields['maildisplay'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED,
+            'null' => NULL_NOT_ALLOWED,
+            'default' => $CFG->defaultpreference_maildisplay,
+        ];
+        $fields['autosubscribe'] = [
-                'default' => $CFG->defaultpreference_maildisplay);
+            'type' => PARAM_INT,
-        $fields['autosubscribe'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED,
+            'null' => NULL_NOT_ALLOWED,
+            'default' => $CFG->defaultpreference_autosubscribe,
+        ];
+        $fields['trackforums'] = [
-                'default' => $CFG->defaultpreference_autosubscribe);
+            'type' => PARAM_INT,
-        $fields['trackforums'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED,
+            'null' => NULL_NOT_ALLOWED,
+            'default' => $CFG->defaultpreference_trackforums,
-                'default' => $CFG->defaultpreference_trackforums);
+        ];
-        $fields['timecreated'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['timecreated'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['timemodified'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['timemodified'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['trustbitmask'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED);
+        $fields['trustbitmask'] = ['type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED];
-        $fields['imagealt'] = array('type' => PARAM_TEXT, 'null' => NULL_ALLOWED);
+        $fields['imagealt'] = ['type' => PARAM_TEXT, 'null' => NULL_ALLOWED];
-        $fields['lastnamephonetic'] = array('type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED);
+        $fields['lastnamephonetic'] = ['type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED];
-        $fields['firstnamephonetic'] = array('type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED);
+        $fields['firstnamephonetic'] = ['type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED];
-        $fields['middlename'] = array('type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED);
+        $fields['middlename'] = ['type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED];
-        $fields['alternatename'] = array('type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED);
+        $fields['alternatename'] = ['type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED];
         self::$propertiescache = $fields;
             try {
                 if (isset(self::$propertiescache[$property])) {
                     validate_param($value, self::$propertiescache[$property]['type'], self::$propertiescache[$property]['null']);
+                }
                 // Check that the value is part of a list of allowed values.
+                if (
-                if (!empty(self::$propertiescache[$property]['choices']) &&
+                    !empty(self::$propertiescache[$property]['choices']) &&
-                        !isset(self::$propertiescache[$property]['choices'][$value])) {
+                    !isset(self::$propertiescache[$property]['choices'][$value])
+                ) {
                     throw new invalid_parameter_exception($value);
+                }
             } catch (invalid_parameter_exception $e) {
                 $errors[$property] = $e->getMessage();
+            }
      * During unit tests we need to be able to reset all caches so that each new test starts in a known state.
      * Intended for use only for testing, phpunit calls this before every test.
      */
     public static function reset_caches() {
         self::$propertiescache = null;
+        self::$preferencescache = null;
+    }
     /**
      * Clean the user data.
+        }
         foreach ($user as $field => $value) {
             // Get the property parameter type and do the cleaning.
             try {
-                $user->$field = core_user::clean_field($value, $field);
+                $user->$field = self::clean_field($value, $field);
             } catch (coding_exception $e) {
                 debugging("The property '$field' could not be cleaned.", DEBUG_DEVELOPER);
+            }
         if (empty($data) || empty($field)) {
             return $data;
+        }
         try {
-            $type = core_user::get_property_type($field);
+            $type = self::get_property_type($field);
             if (isset(self::$propertiescache[$field]['choices'])) {
                 if (!array_key_exists($data, self::$propertiescache[$field]['choices'])) {
      */
     public static function get_property_choices($property) {
+        self::fill_properties_cache();
-        self::fill_properties_cache();
+        if (
-        if (!array_key_exists($property, self::$propertiescache) && !array_key_exists('choices',
+            !array_key_exists($property, self::$propertiescache) &&
-                self::$propertiescache[$property])) {
+            !array_key_exists('choices', self::$propertiescache[$property])
         ) {
             throw new coding_exception('Invalid property requested, or the property does not has a list of choices.');
+        }
      *          'null' => NULL_ALLOWED,    // Defaults to NULL_NOT_ALLOWED. Takes NULL_NOT_ALLOWED or NULL_ALLOWED.
      *          'type' => PARAM_TYPE,      // Expected parameter type of the user field - mandatory
      *          'choices' => array(1, 2..) // An array of accepted values of the user field - optional
      *          'default' => $CFG->setting // An default value for the field - optional
      *          'isregex' => false/true    // Whether the name of the preference is a regular expression (default false).
-     *          'permissioncallback' => callable // Function accepting arguments ($user, $preferencename) that checks if current user
+     *          'permissioncallback' => callable // Function accepting arguments ($user, $preferencename) that checks if current
+     *                                     // user
      *                                     // is allowed to modify this preference for given user.
-     *                                     // If not specified core_user::default_preference_permission_check() will be assumed.
+     *                                     // If not specified \core\user::default_preference_permission_check() will be assumed.
-     *          'cleancallback' => callable // Custom callback for cleaning value if something more difficult than just type/choices is needed
+     *          'cleancallback' => callable // Custom callback for cleaning value if something more difficult than just type/choices
-     *                                     // accepts arguments ($value, $preferencename)
+     *                                      // is needed accepts arguments ($value, $preferencename)
      *     )
      * )
+     *
      * @return void
      */
             return;
+        }
         // Array of user preferences and expected types/values.
         // Every preference that can be updated directly by user should be added here.
-        $preferences = array();
+        $preferences = [];
+        $preferences['auth_forcepasswordchange'] = [
+            'type' => PARAM_INT,
+            'null' => NULL_NOT_ALLOWED,
-        $preferences['auth_forcepasswordchange'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED, 'choices' => array(0, 1),
+            'choices' => [0, 1],
-            'permissioncallback' => function($user, $preferencename) {
+            'permissioncallback' => function ($user, $preferencename) {
                 global $USER;
                 $systemcontext = context_system::instance();
                 return ($USER->id != $user->id && (has_capability('moodle/user:update', $systemcontext) ||
                         ($user->timecreated > time() - 10 && has_capability('moodle/user:create', $systemcontext))));
+            },
+        ];
-            });
+        $preferences['forum_markasreadonnotification'] = [
-        $preferences['forum_markasreadonnotification'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED, 'default' => 1,
+            'type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED, 'default' => 1,
+            'choices' => [0, 1],
+        ];
-            'choices' => array(0, 1));
+        $preferences['htmleditor'] = [
-        $preferences['htmleditor'] = array('type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED,
+            'type' => PARAM_NOTAGS, 'null' => NULL_ALLOWED,
-            'cleancallback' => function($value, $preferencename) {
+            'cleancallback' => function ($value, $preferencename) {
-                if (empty($value) || !array_key_exists($value, core_component::get_plugin_list('editor'))) {
+                if (empty($value) || !array_key_exists($value, component::get_plugin_list('editor'))) {
                     return null;
+                }
                 return $value;
+            },
+        ];
-            });
+        $preferences['badgeprivacysetting'] = [
-        $preferences['badgeprivacysetting'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED, 'default' => 1,
+            'type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED, 'default' => 1,
-            'choices' => array(0, 1), 'permissioncallback' => function($user, $preferencename) {
+            'choices' => [0, 1], 'permissioncallback' => function ($user, $preferencename) {
                 global $CFG;
                 return !empty($CFG->enablebadges) && self::is_current_user($user);
+            },
+        ];
-            });
+        $preferences['blogpagesize'] = [
-        $preferences['blogpagesize'] = array('type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED, 'default' => 10,
+            'type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED, 'default' => 10,
-            'permissioncallback' => function($user, $preferencename) {
+            'permissioncallback' => function ($user, $preferencename) {
                 return self::is_current_user($user) && has_capability('moodle/blog:view', context_system::instance());
+            },
-            });
+        ];
         $preferences['filemanager_recentviewmode'] = [
             'type' => PARAM_INT,
             'null' => NULL_NOT_ALLOWED,
             'default' => 1,
         $choices = [HOMEPAGE_SITE];
         if (!empty($CFG->enabledashboard)) {
             $choices[] = HOMEPAGE_MY;
+        }
         $choices[] = HOMEPAGE_MYCOURSES;
+        // Allow hook callbacks to extend options.
+        $hook = new \core_user\hook\extend_default_homepage(true);
+        \core\di::get(\core\hook\manager::class)->dispatch($hook);
+        $choices = array_merge($choices, array_keys($hook->get_options()));
         $preferences['user_home_page_preference'] = [
-            'type' => PARAM_INT,
             'null' => NULL_ALLOWED,
             'default' => get_default_home_page(),
             'choices' => $choices,
             'permissioncallback' => function ($user, $preferencename) {
                 global $CFG;
                 return self::is_current_user($user) &&
                     (!empty($CFG->defaulthomepage) && ($CFG->defaulthomepage == HOMEPAGE_USER));
-            }
+            },
         ];
         // Core components that may want to define their preferences.
         // List of core components implementing callback is hardcoded here for performance reasons.
      * Retrieves the preference definition
+     *
      * @param string $preferencename
      * @return array
      */
-    protected static function get_preference_definition($preferencename) {
+    public static function get_preference_definition($preferencename) {
         self::fill_preferences_cache();
         foreach (self::$preferencescache as $key => $preference) {
             if (empty($preference['isregex'])) {
         if (self::is_current_user($user)) {
             // Editing own profile.
             $systemcontext = context_system::instance();
             return has_capability('moodle/user:editownprofile', $systemcontext);
-        } else  {
+        } else {
             // Teachers, parents, etc.
             $personalcontext = context_user::instance($user->id);
             if (!has_capability('moodle/user:editprofile', $personalcontext)) {
                 return false;
             }
-            if (is_siteadmin($user->id) and !is_siteadmin($USER)) {
+            if (is_siteadmin($user->id) && !is_siteadmin($USER)) {
                 // Only admins may edit other admins.
                 return false;
+            }
             return true;
      * This covers cases such as filling the profile, changing password or agreeing to the site policy.
+     *
      * @param stdClass $user User object, defaults to the current user.
      * @return bool
      */
-    public static function awaiting_action(stdClass $user = null): bool {
+    public static function awaiting_action(?stdClass $user = null): bool {
         global $USER;
         if ($user === null) {
             $user = $USER;
      * @param stdClass $user the person to get details of.
      * @param context|null $context The context will be used to determine the visibility of the user's full name.
      * @param array $options can include: override - if true, will not use forced firstname/lastname settings
      * @return string Full name of the user
      */
-    public static function get_fullname(stdClass $user, context $context = null, array $options = []): string {
+    public static function get_fullname(stdClass $user, ?context $context = null, array $options = []): string {
         global $CFG, $SESSION;
         // Clone the user so that it does not mess up the original object.
                 // If the override is true, then change the template to use the complete name.
                 $template = $CFG->alternativefullnameformat;
+            }
+        }
-        $requirednames = array();
+        $requirednames = [];
         // With each name, see if it is in the display name template, and add it to the required names array if it is.
         foreach ($allnames as $allname) {
             if (strpos($template, $allname) !== false) {
                 $requirednames[] = $allname;
+            }
+        }
         // Tidy up any misc. characters (Not perfect, but gets most characters).
         // Don't remove the "u" at the end of the first expression unless you want garbled characters when combining hiragana or
         // katakana and parenthesis.
-        $patterns = array();
+        $patterns = [];
         // This regular expression replacement is to fix problems such as 'James () Kirk' Where 'Tiberius' (middlename) has not been
         // filled in by a user.
         // The special characters are Japanese brackets that are common enough to make allowances for them (not covered by :punct:).
         $patterns[] = '/[[:punct:]「」]*EMPTY[[:punct:]「」]*/u';
         // This regular expression is to remove any double spaces in the display name.
+        }
         return $displayname;
+    }
+    /**
+     * Return fullname of a dummy user comprised of configured name fields only
+     *
+     * @param context|null $context
+     * @param array $options
+     * @return string
+     */
+    public static function get_dummy_fullname(?context $context = null, array $options = []): string {
+        // Create a dummy user object containing all name fields.
+        $namefields = \core_user\fields::get_name_fields();
+        $user = (object) array_combine($namefields, $namefields);
+        return static::get_fullname($user, $context, $options);
+    }
     /**
      * Return profile url depending on context.
+     *
      * @param stdClass $user the person to get details of.
      * @param context|null $context The context will be used to determine the visibility of the user's profile url.
-     * @return moodle_url Profile url of the user
+     * @return url Profile url of the user
      */
-    public static function get_profile_url(stdClass $user, context $context = null): moodle_url {
+    public static function get_profile_url(stdClass $user, ?context $context = null): url {
         if (empty($user->id)) {
             throw new coding_exception('User id is required when displaying profile url.');
+        }
             $params['course'] = $coursecontext->instanceid;
+        }
         // If courseid is not set or is set to site id, then return profile page, otherwise return view page.
         if (!isset($params['course']) || $params['course'] == SITEID) {
-            return new moodle_url('/user/profile.php', $params);
+            return new url('/user/profile.php', $params);
         } else {
-            return new moodle_url('/user/view.php', $params);
+            return new url('/user/view.php', $params);
+        }
+    }
      *     - visibletoscreenreaders = true (whether to be visible to screen readers)
      *     - includefullname = false (whether to include the user's full name together with the user picture)
      *     - includetoken = false (whether to use a token for authentication. True for current user, int value for other user id)
      * @return user_picture User picture object
      */
-    public static function get_profile_picture(stdClass $user, context $context = null, array $options = []): user_picture {
+    public static function get_profile_picture(stdClass $user, ?context $context = null, array $options = []): user_picture {
         // Create a new user picture object.
         $userpicture = new user_picture($user);
         // Override the user picture object with the options provided.
      * @return string
      */
     public static function get_initials(stdClass $user): string {
         // Get the available name fields.
         $namefields = \core_user\fields::get_name_fields();
-        // Build a dummy user to determine the name format.
-        $dummyuser = array_combine($namefields, $namefields);
         // Determine the name format by using fullname() and passing the dummy user.
-        $nameformat = fullname((object) $dummyuser);
+        $nameformat = static::get_dummy_fullname();
         // Fetch all the available username fields.
         $availablefields = order_in_string($namefields, $nameformat);
         // We only want the first and last name fields.
         if (!empty($availablefields) && count($availablefields) >= 2) {
             $availablefields = [reset($availablefields), end($availablefields)];
+            }
+        }
         return $initials;
+    }
+    /**
+     * Prepare SQL where clause and associated parameters for any user searching being performed.
+     * This mostly came from core_user\table\participants_search with some slight modifications four our use case.
+     *
+     * @param context $context Context we are in.
+     * @param string $usersearch Array of field mappings (fieldname => SQL code for the value)
+     * @return array SQL query data in the format ['where' => '', 'params' => []].
+     */
+    public static function get_users_search_sql(context $context, string $usersearch = ''): array {
+        global $DB, $USER;
+        $userfields = fields::for_identity($context, false)->with_userpic();
+        ['mappings' => $mappings]  = (array)$userfields->get_sql('u', true);
+        $userfields = $userfields->get_required_fields();
+        $canviewfullnames = has_capability('moodle/site:viewfullnames', $context);
+        $params = [];
+        $searchkey1 = 'search01';
+        $searchkey2 = 'search02';
+        $searchkey3 = 'search03';
+        $conditions = [];
+        // Search by fullname.
+        [$fullname, $fullnameparams] = fields::get_sql_fullname('u', $canviewfullnames);
+        $conditions[] = $DB->sql_like($fullname, ':' . $searchkey1, false, false);
+        $params = array_merge($params, $fullnameparams);
+        // Search by email.
+        $email = $DB->sql_like('email', ':' . $searchkey2, false, false);
+        if (!in_array('email', $userfields)) {
+            $maildisplay = 'maildisplay0';
+            $userid1 = 'userid01';
+            // Prevent users who hide their email address from being found by others
+            // who aren't allowed to see hidden email addresses.
+            $email = "(". $email ." AND (" .
+                "u.maildisplay <> :$maildisplay " .
+                "OR u.id = :$userid1". // Users can always find themselves.
+                "))";
+            $params[$maildisplay] = self::MAILDISPLAY_HIDE;
+            $params[$userid1] = $USER->id;
+        }
+        $conditions[] = $email;
+        // Search by idnumber.
+        $idnumber = $DB->sql_like('idnumber', ':' . $searchkey3, false, false);
+        if (!in_array('idnumber', $userfields)) {
+            $userid2 = 'userid02';
+            // Users who aren't allowed to see idnumbers should at most find themselves
+            // when searching for an idnumber.
+            $idnumber = "(". $idnumber . " AND u.id = :$userid2)";
+            $params[$userid2] = $USER->id;
+        }
+        $conditions[] = $idnumber;
+        // Search all user identify fields.
+        $extrasearchfields = fields::get_identity_fields(null, false);
+        foreach ($extrasearchfields as $fieldindex => $extrasearchfield) {
+            if (in_array($extrasearchfield, ['email', 'idnumber', 'country'])) {
+                // Already covered above.
+                continue;
+            }
+            // The param must be short (max 32 characters) so don't include field name.
+            $param = $searchkey3 . '_ident' . $fieldindex;
+            $fieldsql = $mappings[$extrasearchfield];
+            $condition = $DB->sql_like($fieldsql, ':' . $param, false, false);
+            $params[$param] = "%$usersearch%";
+            if (!in_array($extrasearchfield, $userfields)) {
+                // User cannot see this field, but allow match if their own account.
+                $userid3 = 'userid03_ident' . $fieldindex;
+                $condition = "(". $condition . " AND u.id = :$userid3)";
+                $params[$userid3] = $USER->id;
+            }
+            $conditions[] = $condition;
+        }
+        $where = "(". implode(" OR ", $conditions) .") ";
+        $params[$searchkey1] = "%$usersearch%";
+        $params[$searchkey2] = "%$usersearch%";
+        $params[$searchkey3] = "%$usersearch%";
+        return [
+            'where' => $where,
+            'params' => $params,
+        ];
+    }
+    /**
+     * Generates an array of name placeholders for a given user.
+     *
+     * @param stdClass $user The user object containing name fields.
+     * @return array An associative array of name placeholders.
+     */
+    public static function get_name_placeholders(stdClass $user): array {
+        $namefields = [
+            'fullname' => fullname($user),
+            'alternativefullname' => fullname($user, true),
+        ];
+        foreach (fields::get_name_fields() as $namefield) {
+            $namefields[$namefield] = $user->{$namefield};
+        }
+        return $namefields;
+    }
+}
+// Alias this class to the old name.
+// This file will be autoloaded by the legacyclasses autoload system.
+// In future all uses of this class will be corrected and the legacy references will be removed.

Proyectos de Subversion Moodle

(root)/lib/classes/user.php – Rev 11 → 1441