MDL-35637 group: Fix form submission error that occurs when GD version is not set.
[moodle.git] / group / lib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * Extra library for groups and groupings.
20  *
21  * @copyright 2006 The Open University, J.White AT open.ac.uk, Petr Skoda (skodak)
22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  * @package   core_group
24  */
26 /*
27  * INTERNAL FUNCTIONS - to be used by moodle core only
28  * require_once $CFG->dirroot.'/group/lib.php' must be used
29  */
31 /**
32  * Adds a specified user to a group
33  *
34  * @param mixed $grouporid  The group id or group object
35  * @param mixed $userorid   The user id or user object
36  * @return bool True if user added successfully or the user is already a
37  * member of the group, false otherwise.
38  */
39 function groups_add_member($grouporid, $userorid) {
40     global $DB;
42     if (is_object($userorid)) {
43         $userid = $userorid->id;
44         $user   = $userorid;
45     } else {
46         $userid = $userorid;
47         $user = $DB->get_record('user', array('id'=>$userid), '*', MUST_EXIST);
48     }
50     if (is_object($grouporid)) {
51         $groupid = $grouporid->id;
52         $group   = $grouporid;
53     } else {
54         $groupid = $grouporid;
55         $group = $DB->get_record('groups', array('id'=>$groupid), '*', MUST_EXIST);
56     }
58     //check if the user a participant of the group course
59     if (!is_enrolled(get_context_instance(CONTEXT_COURSE, $group->courseid), $userid)) {
60         return false;
61     }
63     if (groups_is_member($groupid, $userid)) {
64         return true;
65     }
67     $member = new stdClass();
68     $member->groupid   = $groupid;
69     $member->userid    = $userid;
70     $member->timeadded = time();
72     $DB->insert_record('groups_members', $member);
74     //update group info
75     $DB->set_field('groups', 'timemodified', $member->timeadded, array('id'=>$groupid));
77     //trigger groups events
78     $eventdata = new stdClass();
79     $eventdata->groupid = $groupid;
80     $eventdata->userid  = $userid;
81     events_trigger('groups_member_added', $eventdata);
83     return true;
84 }
86 /**
87  * Deletes the link between the specified user and group.
88  *
89  * @param mixed $grouporid  The group id or group object
90  * @param mixed $userorid   The user id or user object
91  * @return bool True if deletion was successful, false otherwise
92  */
93 function groups_remove_member($grouporid, $userorid) {
94     global $DB;
96     if (is_object($userorid)) {
97         $userid = $userorid->id;
98         $user   = $userorid;
99     } else {
100         $userid = $userorid;
101         $user = $DB->get_record('user', array('id'=>$userid), '*', MUST_EXIST);
102     }
104     if (is_object($grouporid)) {
105         $groupid = $grouporid->id;
106         $group   = $grouporid;
107     } else {
108         $groupid = $grouporid;
109         $group = $DB->get_record('groups', array('id'=>$groupid), '*', MUST_EXIST);
110     }
112     if (!groups_is_member($groupid, $userid)) {
113         return true;
114     }
116     $DB->delete_records('groups_members', array('groupid'=>$groupid, 'userid'=>$userid));
118     //update group info
119     $DB->set_field('groups', 'timemodified', time(), array('id'=>$groupid));
121     //trigger groups events
122     $eventdata = new stdClass();
123     $eventdata->groupid = $groupid;
124     $eventdata->userid  = $userid;
125     events_trigger('groups_member_removed', $eventdata);
127     return true;
130 /**
131  * Add a new group
132  *
133  * @param stdClass $data group properties
134  * @param stdClass $editform
135  * @param array $editoroptions
136  * @return id of group or false if error
137  */
138 function groups_create_group($data, $editform = false, $editoroptions = false) {
139     global $CFG, $DB;
141     //check that courseid exists
142     $course = $DB->get_record('course', array('id' => $data->courseid), '*', MUST_EXIST);
143     $context = get_context_instance(CONTEXT_COURSE, $course->id);
145     $data->timecreated  = time();
146     $data->timemodified = $data->timecreated;
147     $data->name         = trim($data->name);
148     if (isset($data->idnumber)) {
149         $data->idnumber = trim($data->idnumber);
150         if (groups_get_group_by_idnumber($course->id, $data->idnumber)) {
151             throw new moodle_exception('idnumbertaken');
152         }
153     }
155     if ($editform and $editoroptions) {
156         $data->description = $data->description_editor['text'];
157         $data->descriptionformat = $data->description_editor['format'];
158     }
160     $data->id = $DB->insert_record('groups', $data);
162     if ($editform and $editoroptions) {
163         // Update description from editor with fixed files
164         $data = file_postupdate_standard_editor($data, 'description', $editoroptions, $context, 'group', 'description', $data->id);
165         $upd = new stdClass();
166         $upd->id                = $data->id;
167         $upd->description       = $data->description;
168         $upd->descriptionformat = $data->descriptionformat;
169         $DB->update_record('groups', $upd);
170     }
172     $group = $DB->get_record('groups', array('id'=>$data->id));
174     if ($editform) {
175         groups_update_group_icon($group, $data, $editform);
176     }
178     //trigger groups events
179     events_trigger('groups_group_created', $group);
181     return $group->id;
184 /**
185  * Add a new grouping
186  *
187  * @param stdClass $data grouping properties
188  * @param array $editoroptions
189  * @return id of grouping or false if error
190  */
191 function groups_create_grouping($data, $editoroptions=null) {
192     global $DB;
194     $data->timecreated  = time();
195     $data->timemodified = $data->timecreated;
196     $data->name         = trim($data->name);
197     if (isset($data->idnumber)) {
198         $data->idnumber = trim($data->idnumber);
199         if (groups_get_grouping_by_idnumber($data->courseid, $data->idnumber)) {
200             throw new moodle_exception('idnumbertaken');
201         }
202     }
204     if ($editoroptions !== null) {
205         $data->description = $data->description_editor['text'];
206         $data->descriptionformat = $data->description_editor['format'];
207     }
209     $id = $DB->insert_record('groupings', $data);
211     //trigger groups events
212     $data->id = $id;
214     if ($editoroptions !== null) {
215         $description = new stdClass;
216         $description->id = $data->id;
217         $description->description_editor = $data->description_editor;
218         $description = file_postupdate_standard_editor($description, 'description', $editoroptions, $editoroptions['context'], 'grouping', 'description', $description->id);
219         $DB->update_record('groupings', $description);
220     }
222     events_trigger('groups_grouping_created', $data);
224     return $id;
227 /**
228  * Update the group icon from form data
229  *
230  * @param stdClass $group group information
231  * @param stdClass $data
232  * @param stdClass $editform
233  */
234 function groups_update_group_icon($group, $data, $editform) {
235     global $CFG, $DB;
236     require_once("$CFG->libdir/gdlib.php");
238     $fs = get_file_storage();
239     $context = get_context_instance(CONTEXT_COURSE, $group->courseid, MUST_EXIST);
241     //TODO: it would make sense to allow picture deleting too (skodak)
242     if (!empty($CFG->gdversion)) {
243         if ($iconfile = $editform->save_temp_file('imagefile')) {
244             if (process_new_icon($context, 'group', 'icon', $group->id, $iconfile)) {
245                 $DB->set_field('groups', 'picture', 1, array('id'=>$group->id));
246                 $group->picture = 1;
247             } else {
248                 $fs->delete_area_files($context->id, 'group', 'icon', $group->id);
249                 $DB->set_field('groups', 'picture', 0, array('id'=>$group->id));
250                 $group->picture = 0;
251             }
252             @unlink($iconfile);
253         }
254     }
257 /**
258  * Update group
259  *
260  * @param stdClass $data group properties (with magic quotes)
261  * @param stdClass $editform
262  * @param array $editoroptions
263  * @return bool true or exception
264  */
265 function groups_update_group($data, $editform = false, $editoroptions = false) {
266     global $CFG, $DB;
268     $context = get_context_instance(CONTEXT_COURSE, $data->courseid);
270     $data->timemodified = time();
271     $data->name         = trim($data->name);
272     if (isset($data->idnumber)) {
273         $data->idnumber = trim($data->idnumber);
274         if (($existing = groups_get_group_by_idnumber($data->courseid, $data->idnumber)) && $existing->id != $data->id) {
275             throw new moodle_exception('idnumbertaken');
276         }
277     }
279     if ($editform and $editoroptions) {
280         $data = file_postupdate_standard_editor($data, 'description', $editoroptions, $context, 'group', 'description', $data->id);
281     }
283     $DB->update_record('groups', $data);
285     $group = $DB->get_record('groups', array('id'=>$data->id));
287     if ($editform) {
288         groups_update_group_icon($group, $data, $editform);
289     }
291     //trigger groups events
292     events_trigger('groups_group_updated', $group);
295     return true;
298 /**
299  * Update grouping
300  *
301  * @param stdClass $data grouping properties (with magic quotes)
302  * @param array $editoroptions
303  * @return bool true or exception
304  */
305 function groups_update_grouping($data, $editoroptions=null) {
306     global $DB;
307     $data->timemodified = time();
308     $data->name         = trim($data->name);
309     if (isset($data->idnumber)) {
310         $data->idnumber = trim($data->idnumber);
311         if (($existing = groups_get_grouping_by_idnumber($data->courseid, $data->idnumber)) && $existing->id != $data->id) {
312             throw new moodle_exception('idnumbertaken');
313         }
314     }
315     if ($editoroptions !== null) {
316         $data = file_postupdate_standard_editor($data, 'description', $editoroptions, $editoroptions['context'], 'grouping', 'description', $data->id);
317     }
318     $DB->update_record('groupings', $data);
319     //trigger groups events
320     events_trigger('groups_grouping_updated', $data);
322     return true;
325 /**
326  * Delete a group best effort, first removing members and links with courses and groupings.
327  * Removes group avatar too.
328  *
329  * @param mixed $grouporid The id of group to delete or full group object
330  * @return bool True if deletion was successful, false otherwise
331  */
332 function groups_delete_group($grouporid) {
333     global $CFG, $DB;
334     require_once("$CFG->libdir/gdlib.php");
336     if (is_object($grouporid)) {
337         $groupid = $grouporid->id;
338         $group   = $grouporid;
339     } else {
340         $groupid = $grouporid;
341         if (!$group = $DB->get_record('groups', array('id'=>$groupid))) {
342             //silently ignore attempts to delete missing already deleted groups ;-)
343             return true;
344         }
345     }
347     // delete group calendar events
348     $DB->delete_records('event', array('groupid'=>$groupid));
349     //first delete usage in groupings_groups
350     $DB->delete_records('groupings_groups', array('groupid'=>$groupid));
351     //delete members
352     $DB->delete_records('groups_members', array('groupid'=>$groupid));
353     //group itself last
354     $DB->delete_records('groups', array('id'=>$groupid));
356     // Delete all files associated with this group
357     $context = get_context_instance(CONTEXT_COURSE, $group->courseid);
358     $fs = get_file_storage();
359     $fs->delete_area_files($context->id, 'group', 'description', $groupid);
360     $fs->delete_area_files($context->id, 'group', 'icon', $groupid);
362     //trigger groups events
363     events_trigger('groups_group_deleted', $group);
365     return true;
368 /**
369  * Delete grouping
370  *
371  * @param int $groupingorid
372  * @return bool success
373  */
374 function groups_delete_grouping($groupingorid) {
375     global $DB;
377     if (is_object($groupingorid)) {
378         $groupingid = $groupingorid->id;
379         $grouping   = $groupingorid;
380     } else {
381         $groupingid = $groupingorid;
382         if (!$grouping = $DB->get_record('groupings', array('id'=>$groupingorid))) {
383             //silently ignore attempts to delete missing already deleted groupings ;-)
384             return true;
385         }
386     }
388     //first delete usage in groupings_groups
389     $DB->delete_records('groupings_groups', array('groupingid'=>$groupingid));
390     // remove the default groupingid from course
391     $DB->set_field('course', 'defaultgroupingid', 0, array('defaultgroupingid'=>$groupingid));
392     // remove the groupingid from all course modules
393     $DB->set_field('course_modules', 'groupingid', 0, array('groupingid'=>$groupingid));
394     //group itself last
395     $DB->delete_records('groupings', array('id'=>$groupingid));
397     $context = get_context_instance(CONTEXT_COURSE, $grouping->courseid);
398     $fs = get_file_storage();
399     $files = $fs->get_area_files($context->id, 'grouping', 'description', $groupingid);
400     foreach ($files as $file) {
401         $file->delete();
402     }
404     //trigger groups events
405     events_trigger('groups_grouping_deleted', $grouping);
407     return true;
410 /**
411  * Remove all users (or one user) from all groups in course
412  *
413  * @param int $courseid
414  * @param int $userid 0 means all users
415  * @param bool $showfeedback
416  * @return bool success
417  */
418 function groups_delete_group_members($courseid, $userid=0, $showfeedback=false) {
419     global $DB, $OUTPUT;
421     if (is_bool($userid)) {
422         debugging('Incorrect userid function parameter');
423         return false;
424     }
426     $params = array('courseid'=>$courseid);
428     if ($userid) {
429         $usersql = "AND userid = :userid";
430         $params['userid'] = $userid;
431     } else {
432         $usersql = "";
433     }
435     $groupssql = "SELECT id FROM {groups} g WHERE g.courseid = :courseid";
436     $DB->delete_records_select('groups_members', "groupid IN ($groupssql) $usersql", $params);
438     //trigger groups events
439     $eventdata = new stdClass();
440     $eventdata->courseid = $courseid;
441     $eventdata->userid   = $userid;
442     events_trigger('groups_members_removed', $eventdata);
444     if ($showfeedback) {
445         echo $OUTPUT->notification(get_string('deleted').' - '.get_string('groupmembers', 'group'), 'notifysuccess');
446     }
448     return true;
451 /**
452  * Remove all groups from all groupings in course
453  *
454  * @param int $courseid
455  * @param bool $showfeedback
456  * @return bool success
457  */
458 function groups_delete_groupings_groups($courseid, $showfeedback=false) {
459     global $DB, $OUTPUT;
461     $groupssql = "SELECT id FROM {groups} g WHERE g.courseid = ?";
462     $DB->delete_records_select('groupings_groups', "groupid IN ($groupssql)", array($courseid));
464     //trigger groups events
465     events_trigger('groups_groupings_groups_removed', $courseid);
467     // no need to show any feedback here - we delete usually first groupings and then groups
469     return true;
472 /**
473  * Delete all groups from course
474  *
475  * @param int $courseid
476  * @param bool $showfeedback
477  * @return bool success
478  */
479 function groups_delete_groups($courseid, $showfeedback=false) {
480     global $CFG, $DB, $OUTPUT;
482     // delete any uses of groups
483     // Any associated files are deleted as part of groups_delete_groupings_groups
484     groups_delete_groupings_groups($courseid, $showfeedback);
485     groups_delete_group_members($courseid, 0, $showfeedback);
487     // delete group pictures and descriptions
488     $context = get_context_instance(CONTEXT_COURSE, $courseid);
489     $fs = get_file_storage();
490     $fs->delete_area_files($context->id, 'group');
492     // delete group calendar events
493     $groupssql = "SELECT id FROM {groups} g WHERE g.courseid = ?";
494     $DB->delete_records_select('event', "groupid IN ($groupssql)", array($courseid));
496     $context = get_context_instance(CONTEXT_COURSE, $courseid);
497     $fs = get_file_storage();
498     $fs->delete_area_files($context->id, 'group');
500     $DB->delete_records('groups', array('courseid'=>$courseid));
502     // trigger groups events
503     events_trigger('groups_groups_deleted', $courseid);
505     if ($showfeedback) {
506         echo $OUTPUT->notification(get_string('deleted').' - '.get_string('groups', 'group'), 'notifysuccess');
507     }
509     return true;
512 /**
513  * Delete all groupings from course
514  *
515  * @param int $courseid
516  * @param bool $showfeedback
517  * @return bool success
518  */
519 function groups_delete_groupings($courseid, $showfeedback=false) {
520     global $DB, $OUTPUT;
522     // delete any uses of groupings
523     $sql = "DELETE FROM {groupings_groups}
524              WHERE groupingid in (SELECT id FROM {groupings} g WHERE g.courseid = ?)";
525     $DB->execute($sql, array($courseid));
527     // remove the default groupingid from course
528     $DB->set_field('course', 'defaultgroupingid', 0, array('id'=>$courseid));
529     // remove the groupingid from all course modules
530     $DB->set_field('course_modules', 'groupingid', 0, array('course'=>$courseid));
532     // Delete all files associated with groupings for this course
533     $context = get_context_instance(CONTEXT_COURSE, $courseid);
534     $fs = get_file_storage();
535     $fs->delete_area_files($context->id, 'grouping');
537     $DB->delete_records('groupings', array('courseid'=>$courseid));
539     // trigger groups events
540     events_trigger('groups_groupings_deleted', $courseid);
542     if ($showfeedback) {
543         echo $OUTPUT->notification(get_string('deleted').' - '.get_string('groupings', 'group'), 'notifysuccess');
544     }
546     return true;
549 /* =================================== */
550 /* various functions used by groups UI */
551 /* =================================== */
553 /**
554  * Obtains a list of the possible roles that group members might come from,
555  * on a course. Generally this includes only profile roles.
556  *
557  * @param context $context Context of course
558  * @return Array of role ID integers, or false if error/none.
559  */
560 function groups_get_possible_roles($context) {
561     $roles = get_profile_roles($context);
562     return array_keys($roles);
566 /**
567  * Gets potential group members for grouping
568  *
569  * @param int $courseid The id of the course
570  * @param int $roleid The role to select users from
571  * @param int $cohortid restrict to cohort id
572  * @param string $orderby The column to sort users by
573  * @return array An array of the users
574  */
575 function groups_get_potential_members($courseid, $roleid = null, $cohortid = null, $orderby = 'lastname ASC, firstname ASC') {
576     global $DB;
578     $context = get_context_instance(CONTEXT_COURSE, $courseid);
580     // we are looking for all users with this role assigned in this context or higher
581     $listofcontexts = get_related_contexts_string($context);
583     list($esql, $params) = get_enrolled_sql($context);
585     if ($roleid) {
586         $params['roleid'] = $roleid;
587         $where = "WHERE u.id IN (SELECT userid
588                                    FROM {role_assignments}
589                                   WHERE roleid = :roleid AND contextid $listofcontexts)";
590     } else {
591         $where = "";
592     }
594     if ($cohortid) {
595         $cohortjoin = "JOIN {cohort_members} cm ON (cm.userid = u.id AND cm.cohortid = :cohortid)";
596         $params['cohortid'] = $cohortid;
597     } else {
598         $cohortjoin = "";
599     }
601     $sql = "SELECT u.id, u.username, u.firstname, u.lastname, u.idnumber
602               FROM {user} u
603               JOIN ($esql) e ON e.id = u.id
604        $cohortjoin
605             $where
606           ORDER BY $orderby";
608     return $DB->get_records_sql($sql, $params);
612 /**
613  * Parse a group name for characters to replace
614  *
615  * @param string $format The format a group name will follow
616  * @param int $groupnumber The number of the group to be used in the parsed format string
617  * @return string the parsed format string
618  */
619 function groups_parse_name($format, $groupnumber) {
620     if (strstr($format, '@') !== false) { // Convert $groupnumber to a character series
621         $letter = 'A';
622         for($i=0; $i<$groupnumber; $i++) {
623             $letter++;
624         }
625         $str = str_replace('@', $letter, $format);
626     } else {
627         $str = str_replace('#', $groupnumber+1, $format);
628     }
629     return($str);
632 /**
633  * Assigns group into grouping
634  *
635  * @param int groupingid
636  * @param int groupid
637  * @return bool true or exception
638  */
639 function groups_assign_grouping($groupingid, $groupid) {
640     global $DB;
642     if ($DB->record_exists('groupings_groups', array('groupingid'=>$groupingid, 'groupid'=>$groupid))) {
643         return true;
644     }
645     $assign = new stdClass();
646     $assign->groupingid = $groupingid;
647     $assign->groupid    = $groupid;
648     $assign->timeadded  = time();
649     $DB->insert_record('groupings_groups', $assign);
651     return true;
654 /**
655  * Unassigns group grom grouping
656  *
657  * @param int groupingid
658  * @param int groupid
659  * @return bool success
660  */
661 function groups_unassign_grouping($groupingid, $groupid) {
662     global $DB;
663     $DB->delete_records('groupings_groups', array('groupingid'=>$groupingid, 'groupid'=>$groupid));
665     return true;
668 /**
669  * Lists users in a group based on their role on the course.
670  * Returns false if there's an error or there are no users in the group.
671  * Otherwise returns an array of role ID => role data, where role data includes:
672  * (role) $id, $shortname, $name
673  * $users: array of objects for each user which include the specified fields
674  * Users who do not have a role are stored in the returned array with key '-'
675  * and pseudo-role details (including a name, 'No role'). Users with multiple
676  * roles, same deal with key '*' and name 'Multiple roles'. You can find out
677  * which roles each has by looking in the $roles array of the user object.
678  *
679  * @param int $groupid
680  * @param int $courseid Course ID (should match the group's course)
681  * @param string $fields List of fields from user table prefixed with u, default 'u.*'
682  * @param string $sort SQL ORDER BY clause, default 'u.lastname ASC'
683  * @param string $extrawheretest extra SQL conditions ANDed with the existing where clause.
684  * @param array $whereparams any parameters required by $extrawheretest (named parameters).
685  * @return array Complex array as described above
686  */
687 function groups_get_members_by_role($groupid, $courseid, $fields='u.*',
688         $sort='u.lastname ASC', $extrawheretest='', $whereparams=array()) {
689     global $CFG, $DB;
691     // Retrieve information about all users and their roles on the course or
692     // parent ('related') contexts
693     $context = get_context_instance(CONTEXT_COURSE, $courseid);
695     if ($extrawheretest) {
696         $extrawheretest = ' AND ' . $extrawheretest;
697     }
699     $sql = "SELECT r.id AS roleid, r.shortname AS roleshortname, r.name AS rolename,
700                    u.id AS userid, $fields
701               FROM {groups_members} gm
702               JOIN {user} u ON u.id = gm.userid
703          LEFT JOIN {role_assignments} ra ON (ra.userid = u.id AND ra.contextid ".get_related_contexts_string($context).")
704          LEFT JOIN {role} r ON r.id = ra.roleid
705              WHERE gm.groupid=:mgroupid
706                    ".$extrawheretest."
707           ORDER BY r.sortorder, $sort";
708     $whereparams['mgroupid'] = $groupid;
709     $rs = $DB->get_recordset_sql($sql, $whereparams);
711     return groups_calculate_role_people($rs, $context);
714 /**
715  * Internal function used by groups_get_members_by_role to handle the
716  * results of a database query that includes a list of users and possible
717  * roles on a course.
718  *
719  * @param moodle_recordset $rs The record set (may be false)
720  * @param int $context ID of course context
721  * @return array As described in groups_get_members_by_role
722  */
723 function groups_calculate_role_people($rs, $context) {
724     global $CFG, $DB;
726     if (!$rs) {
727         return array();
728     }
730     $roles = $DB->get_records_menu('role', null, 'name', 'id, name');
731     $aliasnames = role_fix_names($roles, $context);
733     // Array of all involved roles
734     $roles = array();
735     // Array of all retrieved users
736     $users = array();
737     // Fill arrays
738     foreach ($rs as $rec) {
739         // Create information about user if this is a new one
740         if (!array_key_exists($rec->userid, $users)) {
741             // User data includes all the optional fields, but not any of the
742             // stuff we added to get the role details
743             $userdata = clone($rec);
744             unset($userdata->roleid);
745             unset($userdata->roleshortname);
746             unset($userdata->rolename);
747             unset($userdata->userid);
748             $userdata->id = $rec->userid;
750             // Make an array to hold the list of roles for this user
751             $userdata->roles = array();
752             $users[$rec->userid] = $userdata;
753         }
754         // If user has a role...
755         if (!is_null($rec->roleid)) {
756             // Create information about role if this is a new one
757             if (!array_key_exists($rec->roleid,$roles)) {
758                 $roledata = new stdClass();
759                 $roledata->id        = $rec->roleid;
760                 $roledata->shortname = $rec->roleshortname;
761                 if (array_key_exists($rec->roleid, $aliasnames)) {
762                     $roledata->name = $aliasnames[$rec->roleid];
763                 } else {
764                     $roledata->name = $rec->rolename;
765                 }
766                 $roledata->users = array();
767                 $roles[$roledata->id] = $roledata;
768             }
769             // Record that user has role
770             $users[$rec->userid]->roles[] = $roles[$rec->roleid];
771         }
772     }
773     $rs->close();
775     // Return false if there weren't any users
776     if (count($users) == 0) {
777         return false;
778     }
780     // Add pseudo-role for multiple roles
781     $roledata = new stdClass();
782     $roledata->name = get_string('multipleroles','role');
783     $roledata->users = array();
784     $roles['*'] = $roledata;
786     $roledata = new stdClass();
787     $roledata->name = get_string('noroles','role');
788     $roledata->users = array();
789     $roles[0] = $roledata;
791     // Now we rearrange the data to store users by role
792     foreach ($users as $userid=>$userdata) {
793         $rolecount = count($userdata->roles);
794         if ($rolecount == 0) {
795             // does not have any roles
796             $roleid = 0;
797         } else if($rolecount > 1) {
798             $roleid = '*';
799         } else {
800             $roleid = $userdata->roles[0]->id;
801         }
802         $roles[$roleid]->users[$userid] = $userdata;
803     }
805     // Delete roles not used
806     foreach ($roles as $key=>$roledata) {
807         if (count($roledata->users)===0) {
808             unset($roles[$key]);
809         }
810     }
812     // Return list of roles containing their users
813     return $roles;