[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Extra library for groups and groupings.
   4   *
   5   * @copyright &copy; 2006 The Open University
   6   * @author J.White AT open.ac.uk, Petr Skoda (skodak)
   7   * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
   8   * @package groups
   9   */
  10  
  11  /*
  12   * INTERNAL FUNCTIONS - to be used by moodle core only
  13   * require_once $CFG->dirroot.'/group/lib.php' must be used
  14   */
  15  
  16  /**
  17   * Adds a specified user to a group
  18   * @param int $userid   The user id
  19   * @param int $groupid  The group id
  20   * @return boolean True if user added successfully or the user is already a
  21   * member of the group, false otherwise.
  22   */
  23  function groups_add_member($groupid, $userid) {
  24      if (!groups_group_exists($groupid)) {
  25          return false;
  26      }
  27  
  28      if (groups_is_member($groupid, $userid)) {
  29          return true;
  30      }
  31  
  32      $member = new object();
  33      $member->groupid   = $groupid;
  34      $member->userid    = $userid;
  35      $member->timeadded = time();
  36  
  37      if (!insert_record('groups_members', $member)) {
  38          return false;
  39      }
  40  
  41      //update group info
  42      set_field('groups', 'timemodified', $member->timeadded, 'id', $groupid);
  43  
  44      //trigger groups events
  45      $eventdata = new object();
  46      $eventdata->groupid = $groupid;
  47      $eventdata->userid  = $userid;
  48      events_trigger('groups_member_added', $eventdata);
  49  
  50      return true;
  51  }
  52  
  53  /**
  54   * Deletes the link between the specified user and group.
  55   * @param int $groupid The group to delete the user from
  56   * @param int $userid The user to delete
  57   * @return boolean True if deletion was successful, false otherwise
  58   */
  59  function groups_remove_member($groupid, $userid) {
  60      if (!groups_group_exists($groupid)) {
  61          return false;
  62      }
  63  
  64      if (!groups_is_member($groupid, $userid)) {
  65          return true;
  66      }
  67  
  68      if (!delete_records('groups_members', 'groupid', $groupid, 'userid', $userid)) {
  69          return false;
  70      }
  71      //update group info
  72      set_field('groups', 'timemodified', time(), 'id', $groupid);
  73  
  74      //trigger groups events
  75      $eventdata = new object();
  76      $eventdata->groupid = $groupid;
  77      $eventdata->userid  = $userid;
  78      events_trigger('groups_member_removed', $eventdata);
  79  
  80      return true;
  81  }
  82  
  83  /**
  84   * Add a new group
  85   * @param object $data group properties (with magic quotes)
  86   * @param object $um upload manager with group picture
  87   * @return id of group or false if error
  88   */
  89  function groups_create_group($data, $um=false) {
  90      global $CFG;
  91      require_once("$CFG->libdir/gdlib.php");
  92  
  93      $data->timecreated = time();
  94      $data->timemodified = $data->timecreated;
  95      $data->name = trim($data->name);
  96      $id = insert_record('groups', $data);
  97  
  98      if ($id) {
  99          $data->id = $id;
 100          if ($um) {
 101              //update image
 102              if (save_profile_image($id, $um, 'groups')) {
 103                  set_field('groups', 'picture', 1, 'id', $id);
 104              }
 105              $data->picture = 1;
 106          }
 107  
 108          //trigger groups events
 109          events_trigger('groups_group_created', stripslashes_recursive($data));
 110      }
 111  
 112      return $id;
 113  }
 114  
 115  /**
 116   * Add a new grouping
 117   * @param object $data grouping properties (with magic quotes)
 118   * @return id of grouping or false if error
 119   */
 120  function groups_create_grouping($data) {
 121      global $CFG;
 122  
 123      $data->timecreated = time();
 124      $data->timemodified = $data->timecreated;
 125      $data->name = trim($data->name);
 126  
 127      $id = insert_record('groupings', $data);
 128      
 129      if ($id) {
 130          //trigger groups events
 131          $data->id = $id;
 132          events_trigger('groups_grouping_created', stripslashes_recursive($data));
 133      }
 134  
 135      return $id;
 136  }
 137  
 138  /**
 139   * Update group
 140   * @param object $data group properties (with magic quotes)
 141   * @param object $um upload manager with group picture
 142   * @return boolean success
 143   */
 144  function groups_update_group($data, $um=false) {
 145      global $CFG;
 146      require_once("$CFG->libdir/gdlib.php");
 147  
 148      $data->timemodified = time();
 149      $data->name = trim($data->name);
 150      $result = update_record('groups', $data);
 151  
 152      if ($result) {
 153          if ($um) {
 154              //update image
 155              if (save_profile_image($data->id, $um, 'groups')) {
 156                  set_field('groups', 'picture', 1, 'id', $data->id);
 157                  $data->picture = 1;
 158              }
 159          }
 160  
 161          //trigger groups events
 162          events_trigger('groups_group_updated', stripslashes_recursive($data));
 163      }
 164  
 165      return $result;
 166  }
 167  
 168  /**
 169   * Update grouping
 170   * @param object $data grouping properties (with magic quotes)
 171   * @return boolean success
 172   */
 173  function groups_update_grouping($data) {
 174      global $CFG;
 175      $data->timemodified = time();
 176      $data->name = trim($data->name);
 177      $result = update_record('groupings', $data);
 178      if ($result) {
 179          //trigger groups events
 180          events_trigger('groups_grouping_updated', stripslashes_recursive($data));
 181      }
 182      return $result;
 183  }
 184  
 185  /**
 186   * Delete a group best effort, first removing members and links with courses and groupings.
 187   * Removes group avatar too.
 188   * @param mixed $grouporid The id of group to delete or full group object
 189   * @return boolean True if deletion was successful, false otherwise
 190   */
 191  function groups_delete_group($grouporid) {
 192      global $CFG;
 193      require_once($CFG->libdir.'/gdlib.php');
 194  
 195      if (is_object($grouporid)) {
 196          $groupid = $grouporid->id;
 197          $group   = $grouporid;
 198      } else {
 199          $groupid = $grouporid;
 200          if (!$group = get_record('groups', 'id', $groupid)) {
 201              return false;
 202          }
 203      }
 204  
 205      // delete group calendar events
 206      delete_records('event', 'groupid', $groupid);
 207      //first delete usage in groupings_groups
 208      delete_records('groupings_groups', 'groupid', $groupid);
 209      //delete members
 210      delete_records('groups_members', 'groupid', $groupid);
 211      //then imge
 212      delete_profile_image($groupid, 'groups');
 213      //group itself last
 214      $result = delete_records('groups', 'id', $groupid);
 215  
 216      if ($result) {
 217          //trigger groups events
 218          events_trigger('groups_group_deleted', $group);
 219      }
 220  
 221      return $result;
 222  }
 223  
 224  /**
 225   * Delete grouping
 226   * @param int $groupingid
 227   * @return bool success
 228   */
 229  function groups_delete_grouping($groupingorid) {
 230      if (is_object($groupingorid)) {
 231          $groupingid = $groupingorid->id;
 232          $grouping   = $groupingorid;
 233      } else {
 234          $groupingid = $groupingorid;
 235          if (!$grouping = get_record('groupings', 'id', $groupingorid)) {
 236              return false;
 237          }
 238      }
 239  
 240      //first delete usage in groupings_groups
 241      delete_records('groupings_groups', 'groupingid', $groupingid);
 242      // remove the default groupingid from course
 243      set_field('course', 'defaultgroupingid', 0, 'defaultgroupingid', $groupingid);
 244      // remove the groupingid from all course modules
 245      set_field('course_modules', 'groupingid', 0, 'groupingid', $groupingid);
 246      //group itself last
 247      $result = delete_records('groupings', 'id', $groupingid);
 248  
 249      if ($result) {
 250          //trigger groups events
 251          events_trigger('groups_grouping_deleted', $grouping);
 252      }
 253  
 254      return $result;
 255  }
 256  
 257  /**
 258   * Remove all users (or one user) from all groups in course
 259   * @param int $courseid
 260   * @param int $userid 0 means all users
 261   * @param bool $showfeedback
 262   * @return bool success
 263   */
 264  function groups_delete_group_members($courseid, $userid=0, $showfeedback=false) {
 265      global $CFG;
 266  
 267      if (is_bool($userid)) {
 268          debugging('Incorrect userid function parameter');
 269          return false;
 270      }
 271  
 272      if ($userid) {
 273          $usersql = "AND userid = $userid";
 274      } else {
 275          $usersql = "";
 276      }
 277  
 278      $groupssql = "SELECT id FROM {$CFG->prefix}groups g WHERE g.courseid = $courseid";
 279      delete_records_select('groups_members', "groupid IN ($groupssql) $usersql");
 280  
 281      //trigger groups events
 282      $eventdata = new object();
 283      $eventdata->courseid = $courseid;
 284      $eventdata->userid   = $userid;
 285      events_trigger('groups_members_removed', $eventdata);
 286  
 287      if ($showfeedback) {
 288          notify(get_string('deleted').' groups_members');
 289      }
 290  
 291      return true;
 292  }
 293  
 294  /**
 295   * Remove all groups from all groupings in course
 296   * @param int $courseid
 297   * @param bool $showfeedback
 298   * @return bool success
 299   */
 300  function groups_delete_groupings_groups($courseid, $showfeedback=false) {
 301      global $CFG;
 302  
 303      $groupssql = "SELECT id FROM {$CFG->prefix}groups g WHERE g.courseid = $courseid";
 304      delete_records_select('groupings_groups', "groupid IN ($groupssql)");
 305  
 306      //trigger groups events
 307      events_trigger('groups_groupings_groups_removed', $courseid);
 308  
 309      if ($showfeedback) {
 310          notify(get_string('deleted').' groupings_groups');
 311      }
 312  
 313      return true;
 314  }
 315  
 316  /**
 317   * Delete all groups from course
 318   * @param int $courseid
 319   * @param bool $showfeedback
 320   * @return bool success
 321   */
 322  function groups_delete_groups($courseid, $showfeedback=false) {
 323      global $CFG;
 324      require_once($CFG->libdir.'/gdlib.php');
 325  
 326      $groupssql = "SELECT id FROM {$CFG->prefix}groups g WHERE g.courseid = $courseid";
 327  
 328      // delete any uses of groups
 329      groups_delete_groupings_groups($courseid, $showfeedback);
 330      groups_delete_group_members($courseid, 0, $showfeedback);
 331  
 332      // delete group pictures
 333      if ($groups = get_records('groups', 'courseid', $courseid)) {
 334          foreach($groups as $group) {
 335              delete_profile_image($group->id, 'groups');
 336          }
 337      }
 338  
 339      // delete group calendar events
 340      delete_records_select('event', "groupid IN ($groupssql)");
 341  
 342      delete_records('groups', 'courseid', $courseid);
 343  
 344      //trigger groups events
 345      events_trigger('groups_groups_deleted', $courseid);
 346  
 347      if ($showfeedback) {
 348          notify(get_string('deleted').' groups');
 349      }
 350  
 351      return true;
 352  }
 353  
 354  /**
 355   * Delete all groupings from course
 356   * @param int $courseid
 357   * @param bool $showfeedback
 358   * @return bool success
 359   */
 360  function groups_delete_groupings($courseid, $showfeedback=false) {
 361      global $CFG;
 362  
 363      // delete any uses of groupings
 364      $sql = "DELETE FROM {$CFG->prefix}groupings_groups
 365               WHERE groupingid in (SELECT id FROM {$CFG->prefix}groupings g WHERE g.courseid = $courseid)";
 366      execute_sql($sql, false);
 367  
 368      // remove the default groupingid from course
 369      set_field('course', 'defaultgroupingid', 0, 'id', $courseid);
 370      // remove the groupingid from all course modules
 371      set_field('course_modules', 'groupingid', 0, 'course', $courseid);
 372  
 373      delete_records('groupings', 'courseid', $courseid);
 374  
 375      //trigger groups events
 376      events_trigger('groups_groupings_deleted', $courseid);
 377  
 378      if ($showfeedback) {
 379          notify(get_string('deleted').' groupings');
 380      }
 381  
 382      return true;
 383  }
 384  
 385  /* =================================== */
 386  /* various functions used by groups UI */
 387  /* =================================== */
 388  
 389  /**
 390   * Gets the users for a course who are not in a specified group, and returns
 391   * them in an array organised by role. For the array format, see 
 392   * groups_get_members_by_role.
 393   * @param int $groupid The id of the group
 394   * @param string searchtext similar to searchtext in role assign, search
 395   * @return array An array of role id or '*' => information about that role 
 396   *   including a list of users
 397   */
 398  function groups_get_users_not_in_group_by_role($courseid, $groupid, $searchtext='', $sort = 'u.lastname ASC') {
 399  
 400      global $CFG;
 401      $context = get_context_instance(CONTEXT_COURSE, $courseid);
 402      
 403      if ($searchtext !== '') {   // Search for a subset of remaining users
 404          $LIKE      = sql_ilike();
 405          $FULLNAME  = sql_fullname();
 406          $wheresearch = " AND u.id IN (SELECT id FROM {$CFG->prefix}user WHERE $FULLNAME $LIKE '%$searchtext%' OR email $LIKE '%$searchtext%' )";
 407      } else {
 408          $wheresearch = '';
 409      }
 410  
 411  /// Get list of allowed roles     
 412      if(!($validroleids=groups_get_possible_roles($context))) {
 413          return;
 414      }
 415      $roleids = '('.implode(',', $validroleids).')';
 416  
 417  /// Construct the main SQL
 418      $select = " SELECT r.id AS roleid,r.shortname AS roleshortname,r.name AS rolename,
 419                         u.id AS userid, u.firstname, u.lastname";
 420      $from   = " FROM {$CFG->prefix}user u
 421                  INNER JOIN {$CFG->prefix}role_assignments ra ON ra.userid = u.id
 422                  INNER JOIN {$CFG->prefix}role r ON r.id = ra.roleid";
 423  
 424      $where  = " WHERE ra.contextid ".get_related_contexts_string($context)."
 425                    AND u.deleted = 0
 426                    AND ra.roleid in $roleids
 427                    AND u.id NOT IN (SELECT userid
 428                                     FROM {$CFG->prefix}groups_members
 429                                     WHERE groupid = $groupid)
 430                    $wheresearch";
 431      $orderby = " ORDER BY $sort";
 432  
 433      return groups_calculate_role_people(get_recordset_sql(
 434          $select.$from.$where.$orderby),$context);
 435  }
 436  
 437  
 438  /**
 439   * Obtains a list of the possible roles that group members might come from,
 440   * on a course. Generally this includes all the roles who would have 
 441   * course:view on that course, except the doanything roles.
 442   * @param object $context Context of course
 443   * @return Array of role ID integers, or false if error/none.
 444   */
 445  function groups_get_possible_roles($context) {
 446      $capability = 'moodle/course:view';
 447      $doanything = false;
 448  
 449      // find all possible "student" roles
 450      if ($possibleroles = get_roles_with_capability($capability, CAP_ALLOW, $context)) {
 451          if (!$doanything) {
 452              if (!$sitecontext = get_context_instance(CONTEXT_SYSTEM)) {
 453                  return false;    // Something is seriously wrong
 454              }
 455              $doanythingroles = get_roles_with_capability('moodle/site:doanything', CAP_ALLOW, $sitecontext);
 456          }
 457  
 458          $validroleids = array();
 459          foreach ($possibleroles as $possiblerole) {
 460              if (!$doanything) {
 461                  if (isset($doanythingroles[$possiblerole->id])) {  // We don't want these included
 462                      continue;
 463                  }
 464              }
 465              if ($caps = role_context_capabilities($possiblerole->id, $context, $capability)) { // resolved list
 466                  if (isset($caps[$capability]) && $caps[$capability] > 0) { // resolved capability > 0
 467                      $validroleids[] = $possiblerole->id;
 468                  }
 469              }
 470          }
 471          if (empty($validroleids)) {
 472              return false;
 473          }
 474          return $validroleids;
 475      } else {
 476          return false;  // No need to continue, since no roles have this capability set
 477      }    
 478  }
 479  
 480  
 481  /**
 482   * Gets potential group members for grouping
 483   * @param int $courseid The id of the course
 484   * @param int $roleid The role to select users from
 485   * @param string $orderby The colum to sort users by
 486   * @return array An array of the users
 487   */
 488  function groups_get_potential_members($courseid, $roleid = null, $orderby = 'lastname,firstname') {
 489      global $CFG;
 490  
 491      $context = get_context_instance(CONTEXT_COURSE, $courseid);
 492      $sitecontext = get_context_instance(CONTEXT_SYSTEM);
 493      $rolenames = array();
 494      $avoidroles = array();
 495  
 496      if ($roles = get_roles_used_in_context($context, true)) {
 497  
 498          $canviewroles    = get_roles_with_capability('moodle/course:view', CAP_ALLOW, $context);
 499          $doanythingroles = get_roles_with_capability('moodle/site:doanything', CAP_ALLOW, $sitecontext);
 500  
 501          foreach ($roles as $role) {
 502              if (!isset($canviewroles[$role->id])) {   // Avoid this role (eg course creator)
 503                  $avoidroles[] = $role->id;
 504                  unset($roles[$role->id]);
 505                  continue;
 506              }
 507              if (isset($doanythingroles[$role->id])) {   // Avoid this role (ie admin)
 508                  $avoidroles[] = $role->id;
 509                  unset($roles[$role->id]);
 510                  continue;
 511              }
 512              $rolenames[$role->id] = strip_tags(role_get_name($role, $context));   // Used in menus etc later on
 513          }
 514      }
 515  
 516      $select = 'SELECT u.id, u.username, u.firstname, u.lastname, u.idnumber ';
 517      $from   = "FROM {$CFG->prefix}user u INNER JOIN
 518                 {$CFG->prefix}role_assignments r on u.id=r.userid ";
 519  
 520      if ($avoidroles) {
 521          $adminroles = 'AND r.roleid NOT IN (';
 522          $adminroles .= implode(',', $avoidroles);
 523          $adminroles .= ')';
 524      } else {
 525          $adminroles = '';
 526      }
 527  
 528      // we are looking for all users with this role assigned in this context or higher
 529      if ($usercontexts = get_parent_contexts($context)) {
 530          $listofcontexts = '('.implode(',', $usercontexts).')';
 531      } else {
 532          $listofcontexts = '('.$sitecontext->id.')'; // must be site
 533      }
 534  
 535      if ($roleid) {
 536          $selectrole = " AND r.roleid = $roleid ";
 537      } else {
 538          $selectrole = " ";
 539      }
 540  
 541      $where  = "WHERE (r.contextid = $context->id OR r.contextid in $listofcontexts)
 542                       AND u.deleted = 0 $selectrole
 543                       AND u.username != 'guest'
 544                       $adminroles ";
 545      $order = "ORDER BY $orderby ";
 546  
 547      return(get_records_sql($select.$from.$where.$order));
 548  
 549  }
 550  
 551  /**
 552   * Parse a group name for characters to replace
 553   * @param string $format The format a group name will follow
 554   * @param int $groupnumber The number of the group to be used in the parsed format string
 555   * @return string the parsed format string
 556   */
 557  function groups_parse_name($format, $groupnumber) {
 558      if (strstr($format, '@') !== false) { // Convert $groupnumber to a character series
 559          $letter = 'A';
 560          for($i=0; $i<$groupnumber; $i++) {
 561              $letter++;
 562          }
 563          $str = str_replace('@', $letter, $format);
 564      } else {
 565          $str = str_replace('#', $groupnumber+1, $format);
 566      }
 567      return($str);
 568  }
 569  
 570  /**
 571   * Assigns group into grouping
 572   * @param int groupingid
 573   * @param int groupid
 574   * @return bool success
 575   */
 576  function groups_assign_grouping($groupingid, $groupid) {
 577      if (record_exists('groupings_groups', 'groupingid', $groupingid, 'groupid', $groupid)) {
 578          return true;
 579      }
 580      $assign = new object();
 581      $assign->groupingid = $groupingid;
 582      $assign->groupid = $groupid;
 583      $assign->timeadded = time();
 584      return (bool)insert_record('groupings_groups', $assign);
 585  }
 586  
 587  /**
 588   * Unassigns group grom grouping
 589   * @param int groupingid
 590   * @param int groupid
 591   * @return bool success
 592   */
 593  function groups_unassign_grouping($groupingid, $groupid) {
 594      return delete_records('groupings_groups', 'groupingid', $groupingid, 'groupid', $groupid);
 595  }
 596  
 597  /**
 598   * Lists users in a group based on their role on the course.
 599   * Returns false if there's an error or there are no users in the group. 
 600   * Otherwise returns an array of role ID => role data, where role data includes:
 601   * (role) $id, $shortname, $name
 602   * $users: array of objects for each user which include the specified fields
 603   * Users who do not have a role are stored in the returned array with key '-'
 604   * and pseudo-role details (including a name, 'No role'). Users with multiple
 605   * roles, same deal with key '*' and name 'Multiple roles'. You can find out
 606   * which roles each has by looking in the $roles array of the user object.
 607   * @param int $groupid
 608   * @param int $courseid Course ID (should match the group's course)
 609   * @param string $fields List of fields from user table prefixed with u, default 'u.*'
 610   * @param string $sort SQL ORDER BY clause, default 'u.lastname ASC'
 611   * @return array Complex array as described above
 612   */
 613  function groups_get_members_by_role($groupid, $courseid, $fields='u.*', $sort='u.lastname ASC') {
 614      global $CFG;
 615  
 616      // Retrieve information about all users and their roles on the course or
 617      // parent ('related') contexts 
 618      $context=get_context_instance(CONTEXT_COURSE,$courseid);
 619      $rs=get_recordset_sql($crap="SELECT r.id AS roleid,r.shortname AS roleshortname,r.name AS rolename,
 620                                          u.id AS userid,$fields
 621                                    FROM {$CFG->prefix}groups_members gm
 622                              INNER JOIN {$CFG->prefix}user u ON u.id = gm.userid
 623                              INNER JOIN {$CFG->prefix}role_assignments ra 
 624                                         ON ra.userid = u.id 
 625                              INNER JOIN {$CFG->prefix}role r ON r.id = ra.roleid
 626                                   WHERE gm.groupid='$groupid'
 627                                     AND ra.contextid ".get_related_contexts_string($context)."
 628                                ORDER BY r.sortorder,$sort");
 629  
 630      return groups_calculate_role_people($rs,$context);
 631  }
 632  
 633  /**
 634   * Internal function used by groups_get_members_by_role to handle the
 635   * results of a database query that includes a list of users and possible
 636   * roles on a course.
 637   *
 638   * @param object $rs The record set (may be false)
 639   * @param object $context of course
 640   * @return array As described in groups_get_members_by_role 
 641   */
 642  function groups_calculate_role_people($rs,$context) {
 643      global $CFG;
 644      if(!$rs) {
 645          return false;
 646      }
 647      
 648      $roles = get_records_menu('role', null, 'name', 'id, name');
 649      $aliasnames = role_fix_names($roles, $context);
 650  
 651      // Array of all involved roles
 652      $roles=array();
 653      // Array of all retrieved users
 654      $users=array();
 655      // Fill arrays
 656      while($rec=rs_fetch_next_record($rs)) {
 657          // Create information about user if this is a new one
 658          if(!array_key_exists($rec->userid,$users)) {
 659              // User data includes all the optional fields, but not any of the
 660              // stuff we added to get the role details
 661              $userdata=clone($rec);
 662              unset($userdata->roleid);
 663              unset($userdata->roleshortname);
 664              unset($userdata->rolename);
 665              unset($userdata->userid);
 666              $userdata->id=$rec->userid;
 667  
 668              // Make an array to hold the list of roles for this user
 669              $userdata->roles=array();
 670              $users[$rec->userid]=$userdata;
 671          }
 672          // If user has a role...
 673          if(!is_null($rec->roleid)) {
 674              // Create information about role if this is a new one
 675              if(!array_key_exists($rec->roleid,$roles)) {
 676                  $roledata=new StdClass;
 677                  $roledata->id=$rec->roleid;
 678                  $roledata->shortname=$rec->roleshortname;
 679                  if(array_key_exists($rec->roleid,$aliasnames)) {
 680                      $roledata->name=$aliasnames[$rec->roleid];
 681                  } else {
 682                      $roledata->name=$rec->rolename;
 683                  }
 684                  $roledata->users=array();
 685                  $roles[$roledata->id]=$roledata;
 686              }
 687              // Record that user has role
 688              $users[$rec->userid]->roles[] = $roles[$rec->roleid];
 689          }
 690      }
 691      rs_close($rs);
 692  
 693      // Return false if there weren't any users
 694      if(count($users)==0) {
 695          return false;
 696      }
 697  
 698      // Add pseudo-role for multiple roles
 699      $roledata=new StdClass;
 700      $roledata->name=get_string('multipleroles','role');
 701      $roledata->users=array();
 702      $roles['*']=$roledata;
 703  
 704      // Now we rearrange the data to store users by role
 705      foreach($users as $userid=>$userdata) {
 706          $rolecount=count($userdata->roles);
 707          if($rolecount==0) {
 708              debugging("Unexpected: user $userid is missing roles");
 709          } else if($rolecount>1) {
 710              $roleid='*';
 711          } else {
 712              $roleid=$userdata->roles[0]->id;
 713          }
 714          $roles[$roleid]->users[$userid]=$userdata;
 715      }
 716  
 717      // Delete roles not used
 718      foreach($roles as $key=>$roledata) {
 719          if(count($roledata->users)===0) {
 720              unset($roles[$key]);
 721          }
 722      }
 723  
 724      // Return list of roles containing their users
 725      return $roles;
 726  }
 727  
 728  ?>