MDL-32787 user: rule required for custom profile fields applies to all users editing...
[moodle.git] / user / profile / lib.php
1 <?php
3 /// Some constants
5 define ('PROFILE_VISIBLE_ALL',     '2'); // only visible for users with moodle/user:update capability
6 define ('PROFILE_VISIBLE_PRIVATE', '1'); // either we are viewing our own profile or we have moodle/user:update capability
7 define ('PROFILE_VISIBLE_NONE',    '0'); // only visible for moodle/user:update capability
11 /**
12  * Base class for the customisable profile fields.
13  */
14 class profile_field_base {
16     /// These 2 variables are really what we're interested in.
17     /// Everything else can be extracted from them
18     var $fieldid;
19     var $userid;
21     var $field;
22     var $inputname;
23     var $data;
24     var $dataformat;
26     /**
27      * Constructor method.
28      * @param   integer   id of the profile from the user_info_field table
29      * @param   integer   id of the user for whom we are displaying data
30      */
31     function profile_field_base($fieldid=0, $userid=0) {
32         global $USER;
34         $this->set_fieldid($fieldid);
35         $this->set_userid($userid);
36         $this->load_data();
37     }
40 /***** The following methods must be overwritten by child classes *****/
42     /**
43      * Abstract method: Adds the profile field to the moodle form class
44      * @param  form  instance of the moodleform class
45      */
46     function edit_field_add($mform) {
47         print_error('mustbeoveride', 'debug', '', 'edit_field_add');
48     }
51 /***** The following methods may be overwritten by child classes *****/
53     /**
54      * Display the data for this field
55      */
56     function display_data() {
57         $options = new stdClass();
58         $options->para = false;
59         return format_text($this->data, FORMAT_MOODLE, $options);
60     }
62     /**
63      * Print out the form field in the edit profile page
64      * @param   object   instance of the moodleform class
65      * $return  boolean
66      */
67     function edit_field($mform) {
69         if ($this->field->visible != PROFILE_VISIBLE_NONE
70           or has_capability('moodle/user:update', get_context_instance(CONTEXT_SYSTEM))) {
72             $this->edit_field_add($mform);
73             $this->edit_field_set_default($mform);
74             $this->edit_field_set_required($mform);
75             return true;
76         }
77         return false;
78     }
80     /**
81      * Tweaks the edit form
82      * @param   object   instance of the moodleform class
83      * $return  boolean
84      */
85     function edit_after_data($mform) {
87         if ($this->field->visible != PROFILE_VISIBLE_NONE
88           or has_capability('moodle/user:update', get_context_instance(CONTEXT_SYSTEM))) {
89             $this->edit_field_set_locked($mform);
90             return true;
91         }
92         return false;
93     }
95     /**
96      * Saves the data coming from form
97      * @param   mixed   data coming from the form
98      * @return  mixed   returns data id if success of db insert/update, false on fail, 0 if not permitted
99      */
100     function edit_save_data($usernew) {
101         global $DB;
103         if (!isset($usernew->{$this->inputname})) {
104             // field not present in form, probably locked and invisible - skip it
105             return;
106         }
108         $data = new stdClass();
110         $usernew->{$this->inputname} = $this->edit_save_data_preprocess($usernew->{$this->inputname}, $data);
112         $data->userid  = $usernew->id;
113         $data->fieldid = $this->field->id;
114         $data->data    = $usernew->{$this->inputname};
116         if ($dataid = $DB->get_field('user_info_data', 'id', array('userid'=>$data->userid, 'fieldid'=>$data->fieldid))) {
117             $data->id = $dataid;
118             $DB->update_record('user_info_data', $data);
119         } else {
120             $DB->insert_record('user_info_data', $data);
121         }
122     }
124     /**
125      * Validate the form field from profile page
126      * @return  string  contains error message otherwise NULL
127      **/
128     function edit_validate_field($usernew) {
129         global $DB;
131         $errors = array();
132         /// Check for uniqueness of data if required
133         if ($this->is_unique()) {
134             $value = (is_array($usernew->{$this->inputname}) and isset($usernew->{$this->inputname}['text'])) ? $usernew->{$this->inputname}['text'] : $usernew->{$this->inputname};
135             $data = $DB->get_records_sql('
136                     SELECT id, userid
137                       FROM {user_info_data}
138                      WHERE fieldid = ?
139                        AND ' . $DB->sql_compare_text('data', 255) . ' = ' . $DB->sql_compare_text('?', 255),
140                     array($this->field->id, $value));
141             if ($data) {
142                 $existing = false;
143                 foreach ($data as $v) {
144                     if ($v->userid == $usernew->id) {
145                         $existing = true;
146                         break;
147                     }
148                 }
149                 if (!$existing) {
150                     $errors[$this->inputname] = get_string('valuealreadyused');
151                 }
152             }
153         }
154         return $errors;
155     }
157     /**
158      * Sets the default data for the field in the form object
159      * @param   object   instance of the moodleform class
160      */
161     function edit_field_set_default($mform) {
162         if (!empty($default)) {
163             $mform->setDefault($this->inputname, $this->field->defaultdata);
164         }
165     }
167     /**
168      * Sets the required flag for the field in the form object
169      * @param   object   instance of the moodleform class
170      */
171     function edit_field_set_required($mform) {
172         global $USER;
173         if ($this->is_required() && ($this->userid == $USER->id)) {
174             $mform->addRule($this->inputname, get_string('required'), 'required', null, 'client');
175         }
176     }
178     /**
179      * HardFreeze the field if locked.
180      * @param   object   instance of the moodleform class
181      */
182     function edit_field_set_locked($mform) {
183         if (!$mform->elementExists($this->inputname)) {
184             return;
185         }
186         if ($this->is_locked() and !has_capability('moodle/user:update', get_context_instance(CONTEXT_SYSTEM))) {
187             $mform->hardFreeze($this->inputname);
188             $mform->setConstant($this->inputname, $this->data);
189         }
190     }
192     /**
193      * Hook for child classess to process the data before it gets saved in database
194      * @param   mixed    $data
195      * @param   stdClass $datarecord The object that will be used to save the record
196      * @return  mixed
197      */
198     function edit_save_data_preprocess($data, $datarecord) {
199         return $data;
200     }
202     /**
203      * Loads a user object with data for this field ready for the edit profile
204      * form
205      * @param   object   a user object
206      */
207     function edit_load_user_data($user) {
208         if ($this->data !== NULL) {
209             $user->{$this->inputname} = $this->data;
210         }
211     }
213     /**
214      * Check if the field data should be loaded into the user object
215      * By default it is, but for field types where the data may be potentially
216      * large, the child class should override this and return false
217      * @return boolean
218      */
219     function is_user_object_data() {
220         return true;
221     }
224 /***** The following methods generally should not be overwritten by child classes *****/
226     /**
227      * Accessor method: set the userid for this instance
228      * @param   integer   id from the user table
229      */
230     function set_userid($userid) {
231         $this->userid = $userid;
232     }
234     /**
235      * Accessor method: set the fieldid for this instance
236      * @param   integer   id from the user_info_field table
237      */
238     function set_fieldid($fieldid) {
239         $this->fieldid = $fieldid;
240     }
242     /**
243      * Accessor method: Load the field record and user data associated with the
244      * object's fieldid and userid
245      */
246     function load_data() {
247         global $DB;
249         /// Load the field object
250         if (($this->fieldid == 0) or (!($field = $DB->get_record('user_info_field', array('id'=>$this->fieldid))))) {
251             $this->field = NULL;
252             $this->inputname = '';
253         } else {
254             $this->field = $field;
255             $this->inputname = 'profile_field_'.$field->shortname;
256         }
258         if (!empty($this->field)) {
259             if ($data = $DB->get_record('user_info_data', array('userid'=>$this->userid, 'fieldid'=>$this->fieldid), 'data, dataformat')) {
260                 $this->data = $data->data;
261                 $this->dataformat = $data->dataformat;
262             } else {
263                 $this->data = $this->field->defaultdata;
264                 $this->dataformat = FORMAT_HTML;
265             }
266         } else {
267             $this->data = NULL;
268         }
269     }
271     /**
272      * Check if the field data is visible to the current user
273      * @return  boolean
274      */
275     function is_visible() {
276         global $USER;
278         switch ($this->field->visible) {
279             case PROFILE_VISIBLE_ALL:
280                 return true;
281             case PROFILE_VISIBLE_PRIVATE:
282                 if ($this->userid == $USER->id) {
283                     return true;
284                 } else {
285                     return has_capability('moodle/user:viewalldetails',
286                             get_context_instance(CONTEXT_USER, $this->userid));
287                 }
288             default:
289                 return has_capability('moodle/user:viewalldetails',
290                         get_context_instance(CONTEXT_USER, $this->userid));
291         }
292     }
294     /**
295      * Check if the field data is considered empty
296      * return boolean
297      */
298     function is_empty() {
299         return ( ($this->data != '0') and empty($this->data));
300     }
302     /**
303      * Check if the field is required on the edit profile page
304      * @return   boolean
305      */
306     function is_required() {
307         return (boolean)$this->field->required;
308     }
310     /**
311      * Check if the field is locked on the edit profile page
312      * @return   boolean
313      */
314     function is_locked() {
315         return (boolean)$this->field->locked;
316     }
318     /**
319      * Check if the field data should be unique
320      * @return   boolean
321      */
322     function is_unique() {
323         return (boolean)$this->field->forceunique;
324     }
326     /**
327      * Check if the field should appear on the signup page
328      * @return   boolean
329      */
330     function is_signup_field() {
331         return (boolean)$this->field->signup;
332     }
335 } /// End of class definition
338 /***** General purpose functions for customisable user profiles *****/
340 function profile_load_data($user) {
341     global $CFG, $DB;
343     if ($fields = $DB->get_records('user_info_field')) {
344         foreach ($fields as $field) {
345             require_once($CFG->dirroot.'/user/profile/field/'.$field->datatype.'/field.class.php');
346             $newfield = 'profile_field_'.$field->datatype;
347             $formfield = new $newfield($field->id, $user->id);
348             $formfield->edit_load_user_data($user);
349         }
350     }
353 /**
354  * Print out the customisable categories and fields for a users profile
355  * @param  object   instance of the moodleform class
356  * @param int $userid id of user whose profile is being edited.
357  */
358 function profile_definition($mform, $userid = 0) {
359     global $CFG, $DB;
361     // if user is "admin" fields are displayed regardless
362     $update = has_capability('moodle/user:update', get_context_instance(CONTEXT_SYSTEM));
364     if ($categories = $DB->get_records('user_info_category', null, 'sortorder ASC')) {
365         foreach ($categories as $category) {
366             if ($fields = $DB->get_records('user_info_field', array('categoryid'=>$category->id), 'sortorder ASC')) {
368                 // check first if *any* fields will be displayed
369                 $display = false;
370                 foreach ($fields as $field) {
371                     if ($field->visible != PROFILE_VISIBLE_NONE) {
372                         $display = true;
373                     }
374                 }
376                 // display the header and the fields
377                 if ($display or $update) {
378                     $mform->addElement('header', 'category_'.$category->id, format_string($category->name));
379                     foreach ($fields as $field) {
380                         require_once($CFG->dirroot.'/user/profile/field/'.$field->datatype.'/field.class.php');
381                         $newfield = 'profile_field_'.$field->datatype;
382                         $formfield = new $newfield($field->id, $userid);
383                         $formfield->edit_field($mform);
384                     }
385                 }
386             }
387         }
388     }
391 function profile_definition_after_data($mform, $userid) {
392     global $CFG, $DB;
394     $userid = ($userid < 0) ? 0 : (int)$userid;
396     if ($fields = $DB->get_records('user_info_field')) {
397         foreach ($fields as $field) {
398             require_once($CFG->dirroot.'/user/profile/field/'.$field->datatype.'/field.class.php');
399             $newfield = 'profile_field_'.$field->datatype;
400             $formfield = new $newfield($field->id, $userid);
401             $formfield->edit_after_data($mform);
402         }
403     }
406 function profile_validation($usernew, $files) {
407     global $CFG, $DB;
409     $err = array();
410     if ($fields = $DB->get_records('user_info_field')) {
411         foreach ($fields as $field) {
412             require_once($CFG->dirroot.'/user/profile/field/'.$field->datatype.'/field.class.php');
413             $newfield = 'profile_field_'.$field->datatype;
414             $formfield = new $newfield($field->id, $usernew->id);
415             $err += $formfield->edit_validate_field($usernew, $files);
416         }
417     }
418     return $err;
421 function profile_save_data($usernew) {
422     global $CFG, $DB;
424     if ($fields = $DB->get_records('user_info_field')) {
425         foreach ($fields as $field) {
426             require_once($CFG->dirroot.'/user/profile/field/'.$field->datatype.'/field.class.php');
427             $newfield = 'profile_field_'.$field->datatype;
428             $formfield = new $newfield($field->id, $usernew->id);
429             $formfield->edit_save_data($usernew);
430         }
431     }
434 function profile_display_fields($userid) {
435     global $CFG, $USER, $DB;
437     if ($categories = $DB->get_records('user_info_category', null, 'sortorder ASC')) {
438         foreach ($categories as $category) {
439             if ($fields = $DB->get_records('user_info_field', array('categoryid'=>$category->id), 'sortorder ASC')) {
440                 foreach ($fields as $field) {
441                     require_once($CFG->dirroot.'/user/profile/field/'.$field->datatype.'/field.class.php');
442                     $newfield = 'profile_field_'.$field->datatype;
443                     $formfield = new $newfield($field->id, $userid);
444                     if ($formfield->is_visible() and !$formfield->is_empty()) {
445                         print_row(format_string($formfield->field->name.':'), $formfield->display_data());
446                     }
447                 }
448             }
449         }
450     }
453 /**
454  * Adds code snippet to a moodle form object for custom profile fields that
455  * should appear on the signup page
456  * @param  object  moodle form object
457  */
458 function profile_signup_fields($mform) {
459     global $CFG, $DB;
461      //only retrieve required custom fields (with category information)
462     //results are sort by categories, then by fields
463     $sql = "SELECT uf.id as fieldid, ic.id as categoryid, ic.name as categoryname, uf.datatype
464                 FROM {user_info_field} uf
465                 JOIN {user_info_category} ic
466                 ON uf.categoryid = ic.id AND uf.signup = 1 AND uf.visible<>0
467                 ORDER BY ic.sortorder ASC, uf.sortorder ASC";
469     if ( $fields = $DB->get_records_sql($sql)) {
470         foreach ($fields as $field) {
471             //check if we change the categories
472             if (!isset($currentcat) || $currentcat != $field->categoryid) {
473                  $currentcat = $field->categoryid;
474                  $mform->addElement('header', 'category_'.$field->categoryid, format_string($field->categoryname));
475             }
476             require_once($CFG->dirroot.'/user/profile/field/'.$field->datatype.'/field.class.php');
477             $newfield = 'profile_field_'.$field->datatype;
478             $formfield = new $newfield($field->fieldid);
479             $formfield->edit_field($mform);
480         }
481     }
484 /**
485  * Returns an object with the custom profile fields set for the given user
486  * @param  integer  userid
487  * @return  object
488  */
489 function profile_user_record($userid) {
490     global $CFG, $DB;
492     $usercustomfields = new stdClass();
494     if ($fields = $DB->get_records('user_info_field')) {
495         foreach ($fields as $field) {
496             require_once($CFG->dirroot.'/user/profile/field/'.$field->datatype.'/field.class.php');
497             $newfield = 'profile_field_'.$field->datatype;
498             $formfield = new $newfield($field->id, $userid);
499             if ($formfield->is_user_object_data()) {
500                 $usercustomfields->{$field->shortname} = $formfield->data;
501             }
502         }
503     }
505     return $usercustomfields;
508 /**
509  * Load custom profile fields into user object
510  *
511  * Please note originally in 1.9 we were using the custom field names directly,
512  * but it was causing unexpected collisions when adding new fields to user table,
513  * so instead we now use 'profile_' prefix.
514  *
515  * @param object $user user object
516  * @return void $user object is modified
517  */
518 function profile_load_custom_fields($user) {
519     $user->profile = (array)profile_user_record($user->id);