Search moodle.org's
Developer Documentation

See Release Notes
Long Term Support Release

  • Bug fixes for general core bugs in 4.1.x will end 13 November 2023 (12 months).
  • Bug fixes for security issues in 4.1.x will end 10 November 2025 (36 months).
  • PHP version: minimum PHP 7.4.0 Note: minimum PHP version has increased since Moodle 4.0. PHP 8.0.x is supported too.
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * Profile field API library file.
 *
 * @package core_user
 * @copyright  2007 onwards Shane Elliot {@link http://pukunui.com}
 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

/**
> * Visible to anyone who has the moodle/site:viewuseridentity permission. * Visible to anyone who can view the user. > * Editable by the profile owner if they have the moodle/user:editownprofile capability * Editable by the profile owner if they have the moodle/user:editownprofile capability > * or any user with the moodle/user:update capability. * or any user with the moodle/user:update capability. > */ */ > define('PROFILE_VISIBLE_TEACHERS', '3'); define('PROFILE_VISIBLE_ALL', '2'); > /** > /**
* Visible to the profile owner or anyone with the moodle/user:viewalldetails capability. * Editable by the profile owner if they have the moodle/user:editownprofile capability * or any user with moodle/user:viewalldetails and moodle/user:update capabilities. */ define('PROFILE_VISIBLE_PRIVATE', '1'); /** * Only visible to users with the moodle/user:viewalldetails capability. * Only editable by users with the moodle/user:viewalldetails and moodle/user:update capabilities. */ define('PROFILE_VISIBLE_NONE', '0'); /** * Base class for the customisable profile fields. * * @package core_user * @copyright 2007 onwards Shane Elliot {@link http://pukunui.com} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */ class profile_field_base { // These 2 variables are really what we're interested in. // Everything else can be extracted from them. /** @var int */ public $fieldid; /** @var int */ public $userid; /** @var stdClass */ public $field; /** @var string */ public $inputname; /** @var mixed */ public $data; /** @var string */ public $dataformat; /** @var string name of the user profile category */ protected $categoryname; /** * Constructor method. * @param int $fieldid id of the profile from the user_info_field table * @param int $userid id of the user for whom we are displaying data
< * @param object $fielddata optional data for the field object plus additional fields 'hasuserdata', 'data' and 'dataformat'
> * @param stdClass $fielddata optional data for the field object plus additional fields 'hasuserdata', 'data' and 'dataformat'
* with user data. (If $fielddata->hasuserdata is empty, user data is not available and we should use default data). * If this parameter is passed, constructor will not call load_data() at all. */ public function __construct($fieldid=0, $userid=0, $fielddata=null) { global $CFG; if ($CFG->debugdeveloper) { // In Moodle 3.4 the new argument $fielddata was added to the constructor. Make sure that // plugin constructor properly passes this argument. $backtrace = debug_backtrace(); if (isset($backtrace[1]['class']) && $backtrace[1]['function'] === '__construct' && in_array(self::class, class_parents($backtrace[1]['class']))) { // If this constructor is called from the constructor of the plugin make sure that the third argument was passed through. if (count($backtrace[1]['args']) >= 3 && count($backtrace[0]['args']) < 3) { debugging($backtrace[1]['class'].'::__construct() must support $fielddata as the third argument ' . 'and pass it to the parent constructor', DEBUG_DEVELOPER); } } } $this->set_fieldid($fieldid); $this->set_userid($userid); if ($fielddata) { $this->set_field($fielddata); if ($userid > 0 && !empty($fielddata->hasuserdata)) { $this->set_user_data($fielddata->data, $fielddata->dataformat); } } else { $this->load_data(); } } /** * Old syntax of class constructor. Deprecated in PHP7. * * @deprecated since Moodle 3.1 */ public function profile_field_base($fieldid=0, $userid=0) { debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER); self::__construct($fieldid, $userid); } /** * Abstract method: Adds the profile field to the moodle form class * @abstract The following methods must be overwritten by child classes
< * @param moodleform $mform instance of the moodleform class
> * @param MoodleQuickForm $mform instance of the moodleform class
*/ public function edit_field_add($mform) {
< print_error('mustbeoveride', 'debug', '', 'edit_field_add');
> throw new \moodle_exception('mustbeoveride', 'debug', '', 'edit_field_add');
} /** * Display the data for this field * @return string */ public function display_data() { $options = new stdClass(); $options->para = false; return format_text($this->data, FORMAT_MOODLE, $options); } /** * Print out the form field in the edit profile page
< * @param moodleform $mform instance of the moodleform class
> * @param MoodleQuickForm $mform instance of the moodleform class
* @return bool */ public function edit_field($mform) { if (!$this->is_editable()) { return false; } $this->edit_field_add($mform); $this->edit_field_set_default($mform); $this->edit_field_set_required($mform); return true; } /** * Tweaks the edit form
< * @param moodleform $mform instance of the moodleform class
> * @param MoodleQuickForm $mform instance of the moodleform class
* @return bool */ public function edit_after_data($mform) { if (!$this->is_editable()) { return false; } $this->edit_field_set_locked($mform); return true; } /** * Saves the data coming from form * @param stdClass $usernew data coming from the form
< * @return mixed returns data id if success of db insert/update, false on fail, 0 if not permitted
*/ public function edit_save_data($usernew) { global $DB; if (!isset($usernew->{$this->inputname})) { // Field not present in form, probably locked and invisible - skip it. return; } $data = new stdClass(); $usernew->{$this->inputname} = $this->edit_save_data_preprocess($usernew->{$this->inputname}, $data); if (!isset($usernew->{$this->inputname})) { // Field cannot be set to null, set the default value. $usernew->{$this->inputname} = $this->field->defaultdata; } $data->userid = $usernew->id; $data->fieldid = $this->field->id; $data->data = $usernew->{$this->inputname}; if ($dataid = $DB->get_field('user_info_data', 'id', array('userid' => $data->userid, 'fieldid' => $data->fieldid))) { $data->id = $dataid; $DB->update_record('user_info_data', $data); } else { $DB->insert_record('user_info_data', $data); } } /** * Validate the form field from profile page * * @param stdClass $usernew
< * @return string contains error message otherwise null
> * @return array error messages for the form validation
*/ public function edit_validate_field($usernew) { global $DB; $errors = array(); // Get input value. if (isset($usernew->{$this->inputname})) { if (is_array($usernew->{$this->inputname}) && isset($usernew->{$this->inputname}['text'])) { $value = $usernew->{$this->inputname}['text']; } else { $value = $usernew->{$this->inputname}; } } else { $value = ''; } // Check for uniqueness of data if required. if ($this->is_unique() && (($value !== '') || $this->is_required())) { $data = $DB->get_records_sql(' SELECT id, userid FROM {user_info_data} WHERE fieldid = ? AND ' . $DB->sql_compare_text('data', 255) . ' = ' . $DB->sql_compare_text('?', 255), array($this->field->id, $value)); if ($data) { $existing = false; foreach ($data as $v) { if ($v->userid == $usernew->id) { $existing = true; break; } } if (!$existing) { $errors[$this->inputname] = get_string('valuealreadyused'); } } } return $errors; } /** * Sets the default data for the field in the form object
< * @param moodleform $mform instance of the moodleform class
> * @param MoodleQuickForm $mform instance of the moodleform class
*/ public function edit_field_set_default($mform) {
< if (!empty($this->field->defaultdata)) {
> if (isset($this->field->defaultdata)) {
$mform->setDefault($this->inputname, $this->field->defaultdata); } } /** * Sets the required flag for the field in the form object *
< * @param moodleform $mform instance of the moodleform class
> * @param MoodleQuickForm $mform instance of the moodleform class
*/ public function edit_field_set_required($mform) { global $USER; if ($this->is_required() && ($this->userid == $USER->id || isguestuser())) { $mform->addRule($this->inputname, get_string('required'), 'required', null, 'client'); } } /** * HardFreeze the field if locked.
< * @param moodleform $mform instance of the moodleform class
> * @param MoodleQuickForm $mform instance of the moodleform class
*/ public function edit_field_set_locked($mform) { if (!$mform->elementExists($this->inputname)) { return; } if ($this->is_locked() and !has_capability('moodle/user:update', context_system::instance())) { $mform->hardFreeze($this->inputname); $mform->setConstant($this->inputname, $this->data); } } /** * Hook for child classess to process the data before it gets saved in database * @param stdClass $data * @param stdClass $datarecord The object that will be used to save the record * @return mixed */ public function edit_save_data_preprocess($data, $datarecord) { return $data; } /** * Loads a user object with data for this field ready for the edit profile * form * @param stdClass $user a user object */ public function edit_load_user_data($user) { if ($this->data !== null) { $user->{$this->inputname} = $this->data; } } /** * Check if the field data should be loaded into the user object * By default it is, but for field types where the data may be potentially * large, the child class should override this and return false * @return bool */ public function is_user_object_data() { return true; } /** * Accessor method: set the userid for this instance * @internal This method should not generally be overwritten by child classes. * @param integer $userid id from the user table */ public function set_userid($userid) { $this->userid = $userid; } /** * Accessor method: set the fieldid for this instance * @internal This method should not generally be overwritten by child classes. * @param integer $fieldid id from the user_info_field table */ public function set_fieldid($fieldid) { $this->fieldid = $fieldid; } /** * Sets the field object and default data and format into $this->data and $this->dataformat * * This method should be called before {@link self::set_user_data} * * @param stdClass $field * @throws coding_exception */ public function set_field($field) { global $CFG; if ($CFG->debugdeveloper) { $properties = ['id', 'shortname', 'name', 'datatype', 'description', 'descriptionformat', 'categoryid', 'sortorder', 'required', 'locked', 'visible', 'forceunique', 'signup', 'defaultdata', 'defaultdataformat', 'param1', 'param2', 'param3', 'param4', 'param5']; foreach ($properties as $property) { if (!property_exists($field, $property)) { debugging('The \'' . $property . '\' property must be set.', DEBUG_DEVELOPER); } } } if ($this->fieldid && $this->fieldid != $field->id) { throw new coding_exception('Can not set field object after a different field id was set'); } $this->fieldid = $field->id; $this->field = $field; $this->inputname = 'profile_field_' . $this->field->shortname; $this->data = $this->field->defaultdata; $this->dataformat = FORMAT_HTML; } /** * Sets user id and user data for the field * * @param mixed $data * @param int $dataformat */ public function set_user_data($data, $dataformat) { $this->data = $data; $this->dataformat = $dataformat; } /** * Set the name for the profile category where this field is * * @param string $categoryname */ public function set_category_name($categoryname) { $this->categoryname = $categoryname; } /**
> * Return field short name * Returns the name of the profile category where this field is > * * > * @return string * @return string > */ */ > public function get_shortname(): string { public function get_category_name() { > return $this->field->shortname; global $DB; > } if ($this->categoryname === null) { > $this->categoryname = $DB->get_field('user_info_category', 'name', ['id' => $this->field->categoryid]); > /**
} return $this->categoryname; } /** * Accessor method: Load the field record and user data associated with the * object's fieldid and userid * * @internal This method should not generally be overwritten by child classes. */ public function load_data() { global $DB; // Load the field object. if (($this->fieldid == 0) or (!($field = $DB->get_record('user_info_field', array('id' => $this->fieldid))))) { $this->field = null; $this->inputname = ''; } else { $this->set_field($field); } if (!empty($this->field) && $this->userid > 0) { $params = array('userid' => $this->userid, 'fieldid' => $this->fieldid); if ($data = $DB->get_record('user_info_data', $params, 'data, dataformat')) { $this->set_user_data($data->data, $data->dataformat); } } else { $this->data = null; } } /** * Check if the field data is visible to the current user * @internal This method should not generally be overwritten by child classes.
> * * @return bool > * @param context|null $context
*/
< public function is_visible() { < global $USER;
> public function is_visible(?context $context = null): bool { > global $USER, $COURSE;
> if ($context === null) {
$context = ($this->userid > 0) ? context_user::instance($this->userid) : context_system::instance();
> }
switch ($this->field->visible) {
> case PROFILE_VISIBLE_TEACHERS: case PROFILE_VISIBLE_ALL: > if ($this->is_signup_field() && (empty($this->userid) || isguestuser($this->userid))) { return true; > return true; case PROFILE_VISIBLE_PRIVATE: > } else if ($this->userid == $USER->id) { if ($this->is_signup_field() && (empty($this->userid) || isguestuser($this->userid))) { > return true; return true; > } else if ($this->userid > 0) { } else if ($this->userid == $USER->id) { > return has_capability('moodle/user:viewalldetails', $context); return true; > } else { } else { > $coursecontext = context_course::instance($COURSE->id); return has_capability('moodle/user:viewalldetails', $context); > return has_capability('moodle/site:viewuseridentity', $coursecontext); } > }
default:
> // PROFILE_VISIBLE_NONE, so let's check capabilities at system level. return has_capability('moodle/user:viewalldetails', $context); > if ($this->userid > 0) { } > $context = context_system::instance(); } > }
/** * Check if the field data is editable for the current user * This method should not generally be overwritten by child classes. * @return bool */ public function is_editable() { global $USER; if (!$this->is_visible()) { return false; } if ($this->is_signup_field() && (empty($this->userid) || isguestuser($this->userid))) { // Allow editing the field on the signup page. return true; } $systemcontext = context_system::instance(); if ($this->userid == $USER->id && has_capability('moodle/user:editownprofile', $systemcontext)) { return true; } if (has_capability('moodle/user:update', $systemcontext)) { return true; }
> // Checking for mentors have capability to edit user's profile. return false; > if ($this->userid > 0) { } > $usercontext = context_user::instance($this->userid); > if ($this->userid != $USER->id && has_capability('moodle/user:editprofile', $usercontext, $USER->id)) { /** > return true; * Check if the field data is considered empty > } * @internal This method should not generally be overwritten by child classes. > } * @return boolean >
*/ public function is_empty() { return ( ($this->data != '0') and empty($this->data)); } /** * Check if the field is required on the edit profile page * @internal This method should not generally be overwritten by child classes. * @return bool */ public function is_required() { return (boolean)$this->field->required; } /** * Check if the field is locked on the edit profile page * @internal This method should not generally be overwritten by child classes. * @return bool */ public function is_locked() { return (boolean)$this->field->locked; } /** * Check if the field data should be unique * @internal This method should not generally be overwritten by child classes. * @return bool */ public function is_unique() { return (boolean)$this->field->forceunique; } /** * Check if the field should appear on the signup page * @internal This method should not generally be overwritten by child classes. * @return bool */ public function is_signup_field() { return (boolean)$this->field->signup; } /** * Return the field settings suitable to be exported via an external function. * By default it return all the field settings. * * @return array all the settings * @since Moodle 3.2 */ public function get_field_config_for_external() { return (array) $this->field; } /** * Return the field type and null properties. * This will be used for validating the data submitted by a user. * * @return array the param type and null property * @since Moodle 3.2 */ public function get_field_properties() { return array(PARAM_RAW, NULL_NOT_ALLOWED); }
> } > /** > * Check if the field should convert the raw data into user-friendly data when exporting /** > * * Returns an array of all custom field records with any defined data (or empty data), for the specified user id. > * @return bool * @param int $userid > */ * @return profile_field_base[] > public function is_transform_supported(): bool { */ > return false; function profile_get_user_fields_with_data($userid) { > } global $DB, $CFG; > } > // Join any user info data present with each user info field for the user object. > /** $sql = 'SELECT uif.*, uic.name AS categoryname '; > * Return profile field instance for given type if ($userid > 0) { > * $sql .= ', uind.id AS hasuserdata, uind.data, uind.dataformat '; > * @param string $type } > * @param int $fieldid $sql .= 'FROM {user_info_field} uif '; > * @param int $userid $sql .= 'LEFT JOIN {user_info_category} uic ON uif.categoryid = uic.id '; > * @param stdClass|null $fielddata if ($userid > 0) { > * @return profile_field_base $sql .= 'LEFT JOIN {user_info_data} uind ON uif.id = uind.fieldid AND uind.userid = :userid '; > */ } > function profile_get_user_field(string $type, int $fieldid = 0, int $userid = 0, ?stdClass $fielddata = null): profile_field_base { $sql .= 'ORDER BY uic.sortorder ASC, uif.sortorder ASC '; > global $CFG; $fields = $DB->get_records_sql($sql, ['userid' => $userid]); > $data = []; > require_once("{$CFG->dirroot}/user/profile/field/{$type}/field.class.php"); foreach ($fields as $field) { > require_once($CFG->dirroot . '/user/profile/field/' . $field->datatype . '/field.class.php'); > // Return instance of profile field type. $classname = 'profile_field_' . $field->datatype; > $profilefieldtype = "profile_field_{$type}"; $field->hasuserdata = !empty($field->hasuserdata); > return new $profilefieldtype($fieldid, $userid, $fielddata);
< function profile_get_user_fields_with_data($userid) { < global $DB, $CFG;
> function profile_get_user_fields_with_data(int $userid): array { > global $DB;
< require_once($CFG->dirroot . '/user/profile/field/' . $field->datatype . '/field.class.php'); < $classname = 'profile_field_' . $field->datatype;
< /** @var profile_field_base $fieldobject */ < $fieldobject = new $classname($field->id, $userid, $field);
> $fieldobject = profile_get_user_field($field->datatype, $field->id, $userid, $field);
return $data; } /** * Returns an array of all custom field records with any defined data (or empty data), for the specified user id, by category. * @param int $userid * @return profile_field_base[][] */
< function profile_get_user_fields_with_data_by_category($userid) {
> function profile_get_user_fields_with_data_by_category(int $userid): array {
$fields = profile_get_user_fields_with_data($userid); $data = []; foreach ($fields as $field) { $data[$field->field->categoryid][] = $field; } return $data; } /** * Loads user profile field data into the user object. * @param stdClass $user */
< function profile_load_data($user) { < global $CFG; <
> function profile_load_data(stdClass $user): void {
$fields = profile_get_user_fields_with_data($user->id); foreach ($fields as $formfield) { $formfield->edit_load_user_data($user); } } /** * Print out the customisable categories and fields for a users profile *
< * @param moodleform $mform instance of the moodleform class < * @param int $userid id of user whose profile is being edited.
> * @param MoodleQuickForm $mform instance of the moodleform class > * @param int $userid id of user whose profile is being edited or 0 for the new user
*/
< function profile_definition($mform, $userid = 0) {
> function profile_definition(MoodleQuickForm $mform, int $userid = 0): void {
$categories = profile_get_user_fields_with_data_by_category($userid); foreach ($categories as $categoryid => $fields) { // Check first if *any* fields will be displayed. $fieldstodisplay = []; foreach ($fields as $formfield) { if ($formfield->is_editable()) { $fieldstodisplay[] = $formfield; } } if (empty($fieldstodisplay)) { continue; } // Display the header and the fields. $mform->addElement('header', 'category_'.$categoryid, format_string($fields[0]->get_category_name())); foreach ($fieldstodisplay as $formfield) { $formfield->edit_field($mform); } } } /** * Adds profile fields to user edit forms.
< * @param moodleform $mform
> * @param MoodleQuickForm $mform
* @param int $userid */
< function profile_definition_after_data($mform, $userid) { < global $CFG; <
> function profile_definition_after_data(MoodleQuickForm $mform, int $userid): void {
$userid = ($userid < 0) ? 0 : (int)$userid; $fields = profile_get_user_fields_with_data($userid); foreach ($fields as $formfield) { $formfield->edit_after_data($mform); } } /** * Validates profile data. * @param stdClass $usernew * @param array $files
< * @return array
> * @return array array of errors, same as in {@see moodleform::validation()}
*/
< function profile_validation($usernew, $files) { < global $CFG; <
> function profile_validation(stdClass $usernew, array $files): array {
$err = array(); $fields = profile_get_user_fields_with_data($usernew->id); foreach ($fields as $formfield) { $err += $formfield->edit_validate_field($usernew, $files); } return $err; } /** * Saves profile data for a user. * @param stdClass $usernew */
< function profile_save_data($usernew) {
> function profile_save_data(stdClass $usernew): void {
global $CFG; $fields = profile_get_user_fields_with_data($usernew->id); foreach ($fields as $formfield) { $formfield->edit_save_data($usernew); } } /** * Display profile fields.
> * * @param int $userid > * @deprecated since Moodle 3.11 MDL-71051 - please do not use this function any more. */ > * @todo MDL-71413 This will be deleted in Moodle 4.3. function profile_display_fields($userid) { > *
< global $CFG, $USER, $DB;
> debugging('Function profile_display_fields() is deprecated because it is no longer used and will be '. > 'removed in future versions of Moodle', DEBUG_DEVELOPER);
$categories = profile_get_user_fields_with_data_by_category($userid); foreach ($categories as $categoryid => $fields) { foreach ($fields as $formfield) { if ($formfield->is_visible() and !$formfield->is_empty()) { echo html_writer::tag('dt', format_string($formfield->field->name)); echo html_writer::tag('dd', $formfield->display_data()); } } } } /** * Retrieves a list of profile fields that must be displayed in the sign-up form. * * @return array list of profile fields info * @since Moodle 3.2 */
< function profile_get_signup_fields() { < global $CFG, $DB; <
> function profile_get_signup_fields(): array {
$profilefields = array();
< // Only retrieve required custom fields (with category information) < // results are sort by categories, then by fields. < $sql = "SELECT uf.id as fieldid, ic.id as categoryid, ic.name as categoryname, uf.datatype < FROM {user_info_field} uf < JOIN {user_info_category} ic < ON uf.categoryid = ic.id AND uf.signup = 1 AND uf.visible<>0 < ORDER BY ic.sortorder ASC, uf.sortorder ASC"; < < if ($fields = $DB->get_records_sql($sql)) { < foreach ($fields as $field) { < require_once($CFG->dirroot.'/user/profile/field/'.$field->datatype.'/field.class.php'); < $newfield = 'profile_field_'.$field->datatype; < $fieldobject = new $newfield($field->fieldid); <
> $fieldobjects = profile_get_user_fields_with_data(0); > foreach ($fieldobjects as $fieldobject) { > $field = (object)$fieldobject->get_field_config_for_external(); > if ($fieldobject->get_category_name() !== null && $fieldobject->is_signup_field() && $field->visible <> 0) {
$profilefields[] = (object) array( 'categoryid' => $field->categoryid,
< 'categoryname' => $field->categoryname, < 'fieldid' => $field->fieldid,
> 'categoryname' => $fieldobject->get_category_name(), > 'fieldid' => $field->id,
'datatype' => $field->datatype, 'object' => $fieldobject ); } } return $profilefields; } /** * Adds code snippet to a moodle form object for custom profile fields that * should appear on the signup page
< * @param moodleform $mform moodle form object
> * @param MoodleQuickForm $mform moodle form object
*/
< function profile_signup_fields($mform) {
> function profile_signup_fields(MoodleQuickForm $mform): void {
if ($fields = profile_get_signup_fields()) { foreach ($fields as $field) { // Check if we change the categories. if (!isset($currentcat) || $currentcat != $field->categoryid) { $currentcat = $field->categoryid; $mform->addElement('header', 'category_'.$field->categoryid, format_string($field->categoryname)); }; $field->object->edit_field($mform); } } } /** * Returns an object with the custom profile fields set for the given user
< * @param integer $userid
> * @param int $userid
* @param bool $onlyinuserobject True if you only want the ones in $USER.
< * @return stdClass
> * @return stdClass object where properties names are shortnames of custom profile fields
*/
< function profile_user_record($userid, $onlyinuserobject = true) { < global $CFG; <
> function profile_user_record(int $userid, bool $onlyinuserobject = true): stdClass {
$usercustomfields = new stdClass(); $fields = profile_get_user_fields_with_data($userid); foreach ($fields as $formfield) { if (!$onlyinuserobject || $formfield->is_user_object_data()) { $usercustomfields->{$formfield->field->shortname} = $formfield->data; } } return $usercustomfields; } /** * Obtains a list of all available custom profile fields, indexed by id. * * Some profile fields are not included in the user object data (see * profile_user_record function above). Optionally, you can obtain only those * fields that are included in the user object. * * To be clear, this function returns the available fields, and does not * return the field values for a particular user. * * @param bool $onlyinuserobject True if you only want the ones in $USER * @return array Array of field objects from database (indexed by id) * @since Moodle 2.7.1 */
< function profile_get_custom_fields($onlyinuserobject = false) { < global $DB, $CFG; < < // Get all the fields. < $fields = $DB->get_records('user_info_field', null, 'id ASC'); < < // If only doing the user object ones, unset the rest. < if ($onlyinuserobject) { < foreach ($fields as $id => $field) { < require_once($CFG->dirroot . '/user/profile/field/' . < $field->datatype . '/field.class.php'); < $newfield = 'profile_field_' . $field->datatype; < $formfield = new $newfield(); < if (!$formfield->is_user_object_data()) { < unset($fields[$id]);
> function profile_get_custom_fields(bool $onlyinuserobject = false): array { > $fieldobjects = profile_get_user_fields_with_data(0); > $fields = []; > foreach ($fieldobjects as $fieldobject) { > if (!$onlyinuserobject || $fieldobject->is_user_object_data()) { > $fields[$fieldobject->fieldid] = (object)$fieldobject->get_field_config_for_external();
} }
< } <
> ksort($fields);
return $fields; } /** * Load custom profile fields into user object * * @param stdClass $user user object */ function profile_load_custom_fields($user) { $user->profile = (array)profile_user_record($user->id); } /** * Save custom profile fields for a user. * * @param int $userid The user id * @param array $profilefields The fields to save */ function profile_save_custom_fields($userid, $profilefields) { global $DB;
< if ($fields = $DB->get_records('user_info_field')) { < foreach ($fields as $field) {
> $fields = profile_get_user_fields_with_data(0); > if ($fields) { > foreach ($fields as $fieldobject) { > $field = (object)$fieldobject->get_field_config_for_external();
if (isset($profilefields[$field->shortname])) { $conditions = array('fieldid' => $field->id, 'userid' => $userid); $id = $DB->get_field('user_info_data', 'id', $conditions); $data = $profilefields[$field->shortname]; if ($id) { $DB->set_field('user_info_data', 'data', $data, array('id' => $id)); } else { $record = array('fieldid' => $field->id, 'userid' => $userid, 'data' => $data); $DB->insert_record('user_info_data', $record); } } } } } /**
> * Gets basic data about custom profile fields. This is minimal data that is cached within the * Trigger a user profile viewed event. > * current request for all fields so that it can be used quickly. * > * * @param stdClass $user user object > * @param string $shortname Shortname of custom profile field * @param stdClass $context context object (course or user) > * @param bool $casesensitive Whether to perform case-sensitive matching of shortname. Note current limitations of custom profile * @param stdClass $course course object > * fields allow the same shortname to exist differing only by it's case * @since Moodle 2.9 > * @return stdClass|null Object with properties id, shortname, name, visible, datatype, categoryid, etc */ > */ function profile_view($user, $context, $course = null) { > function profile_get_custom_field_data_by_shortname(string $shortname, bool $casesensitive = true): ?stdClass { > $cache = \cache::make_from_params(cache_store::MODE_REQUEST, 'core_profile', 'customfields', $eventdata = array( > [], ['simplekeys' => true, 'simpledata' => true]); 'objectid' => $user->id, > $data = $cache->get($shortname); 'relateduserid' => $user->id, > if ($data === false) { 'context' => $context > // If we don't have data, we get and cache it for all fields to avoid multiple DB requests. ); > $fields = profile_get_custom_fields(); > $data = null; if (!empty($course)) { > foreach ($fields as $field) { $eventdata['courseid'] = $course->id; > $cache->set($field->shortname, $field); $eventdata['other'] = array( > 'courseid' => $course->id, > // Perform comparison according to case sensitivity parameter. 'courseshortname' => $course->shortname, > $shortnamematch = $casesensitive 'coursefullname' => $course->fullname > ? strcmp($field->shortname, $shortname) === 0 ); > : strcasecmp($field->shortname, $shortname) === 0; } > > if ($shortnamematch) { $event = \core\event\user_profile_viewed::create($eventdata); > $data = $field; $event->add_record_snapshot('user', $user); > } $event->trigger(); > } } > } > /** > return $data; * Does the user have all required custom fields set? > } * > * Internal, to be exclusively used by {@link user_not_fully_set_up()} only. > /**
* * Note that if users have no way to fill a required field via editing their * profiles (e.g. the field is not visible or it is locked), we still return true. * So this is actually checking if we should redirect the user to edit their * profile, rather than whether there is a value in the database. * * @param int $userid * @return bool */ function profile_has_required_custom_fields_set($userid) {
< global $DB; < < $sql = "SELECT f.id < FROM {user_info_field} f < LEFT JOIN {user_info_data} d ON (d.fieldid = f.id AND d.userid = ?) < WHERE f.required = 1 AND f.visible > 0 AND f.locked = 0 AND d.id IS NULL"; < < if ($DB->record_exists_sql($sql, [$userid])) {
> $profilefields = profile_get_user_fields_with_data($userid); > foreach ($profilefields as $profilefield) { > if ($profilefield->is_required() && !$profilefield->is_locked() && > $profilefield->is_empty() && $profilefield->get_field_config_for_external()['visible']) {
return false; }
> }
return true;
> } } > > /** > * Return the list of valid custom profile user fields. > * > * @return array array of profile field names > */ > function get_profile_field_names(): array { > $profilefields = profile_get_user_fields_with_data(0); > $profilefieldnames = []; > foreach ($profilefields as $field) { > $profilefieldnames[] = $field->inputname; > } > return $profilefieldnames; > } > > /** > * Return the list of profile fields > * in a format they can be used for choices in a group select menu. > * > * @return array array of category name with its profile fields > */ > function get_profile_field_list(): array { > $customfields = profile_get_user_fields_with_data_by_category(0); > $data = []; > foreach ($customfields as $category) { > foreach ($category as $field) { > $categoryname = $field->get_category_name(); > if (!isset($data[$categoryname])) { > $data[$categoryname] = []; > } > $data[$categoryname][$field->inputname] = $field->field->name; > } > } > return $data;