Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
  • Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
  • PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.
/lib/ -> grouplib.php (source)

Differences Between: [Versions 310 and 311] [Versions 311 and 400] [Versions 311 and 401] [Versions 311 and 402] [Versions 311 and 403] [Versions 39 and 311]

   1  <?php
   2  
   3  // This file is part of Moodle - http://moodle.org/
   4  //
   5  // Moodle is free software: you can redistribute it and/or modify
   6  // it under the terms of the GNU General Public License as published by
   7  // the Free Software Foundation, either version 3 of the License, or
   8  // (at your option) any later version.
   9  //
  10  // Moodle is distributed in the hope that it will be useful,
  11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  // GNU General Public License for more details.
  14  //
  15  // You should have received a copy of the GNU General Public License
  16  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17  
  18  /**
  19   * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
  20   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  21   * @package    core_group
  22   */
  23  
  24  defined('MOODLE_INTERNAL') || die();
  25  
  26  /**
  27   * Groups not used in course or activity
  28   */
  29  define('NOGROUPS', 0);
  30  
  31  /**
  32   * Groups used, users do not see other groups
  33   */
  34  define('SEPARATEGROUPS', 1);
  35  
  36  /**
  37   * Groups used, students see other groups
  38   */
  39  define('VISIBLEGROUPS', 2);
  40  
  41  /**
  42   * This is for filtering users without any group.
  43   */
  44  define('USERSWITHOUTGROUP', -1);
  45  
  46  /**
  47   * 'None' join type, used when filtering by groups (logical NOT)
  48   */
  49  define('GROUPS_JOIN_NONE', 0);
  50  
  51  /**
  52   * 'Any' join type, used when filtering by groups (logical OR)
  53   */
  54  define('GROUPS_JOIN_ANY', 1);
  55  
  56  /**
  57   * 'All' join type, used when filtering by groups (logical AND)
  58   */
  59  define('GROUPS_JOIN_ALL', 2);
  60  
  61  /**
  62   * Determines if a group with a given groupid exists.
  63   *
  64   * @category group
  65   * @param int $groupid The groupid to check for
  66   * @return bool True if the group exists, false otherwise or if an error
  67   * occurred.
  68   */
  69  function groups_group_exists($groupid) {
  70      global $DB;
  71      return $DB->record_exists('groups', array('id'=>$groupid));
  72  }
  73  
  74  /**
  75   * Gets the name of a group with a specified id
  76   *
  77   * @category group
  78   * @param int $groupid The id of the group
  79   * @return string The name of the group
  80   */
  81  function groups_get_group_name($groupid) {
  82      global $DB;
  83      return $DB->get_field('groups', 'name', array('id'=>$groupid));
  84  }
  85  
  86  /**
  87   * Gets the name of a grouping with a specified id
  88   *
  89   * @category group
  90   * @param int $groupingid The id of the grouping
  91   * @return string The name of the grouping
  92   */
  93  function groups_get_grouping_name($groupingid) {
  94      global $DB;
  95      return $DB->get_field('groupings', 'name', array('id'=>$groupingid));
  96  }
  97  
  98  /**
  99   * Returns the groupid of a group with the name specified for the course.
 100   * Group names should be unique in course
 101   *
 102   * @category group
 103   * @param int $courseid The id of the course
 104   * @param string $name name of group (without magic quotes)
 105   * @return int $groupid
 106   */
 107  function groups_get_group_by_name($courseid, $name) {
 108      $data = groups_get_course_data($courseid);
 109      foreach ($data->groups as $group) {
 110          if ($group->name == $name) {
 111              return $group->id;
 112          }
 113      }
 114      return false;
 115  }
 116  
 117  /**
 118   * Returns the groupid of a group with the idnumber specified for the course.
 119   * Group idnumbers should be unique within course
 120   *
 121   * @category group
 122   * @param int $courseid The id of the course
 123   * @param string $idnumber idnumber of group
 124   * @return group object
 125   */
 126  function groups_get_group_by_idnumber($courseid, $idnumber) {
 127      if (empty($idnumber)) {
 128          return false;
 129      }
 130      $data = groups_get_course_data($courseid);
 131      foreach ($data->groups as $group) {
 132          if ($group->idnumber == $idnumber) {
 133              return $group;
 134          }
 135      }
 136      return false;
 137  }
 138  
 139  /**
 140   * Returns the groupingid of a grouping with the name specified for the course.
 141   * Grouping names should be unique in course
 142   *
 143   * @category group
 144   * @param int $courseid The id of the course
 145   * @param string $name name of group (without magic quotes)
 146   * @return int $groupid
 147   */
 148  function groups_get_grouping_by_name($courseid, $name) {
 149      $data = groups_get_course_data($courseid);
 150      foreach ($data->groupings as $grouping) {
 151          if ($grouping->name == $name) {
 152              return $grouping->id;
 153          }
 154      }
 155      return false;
 156  }
 157  
 158  /**
 159   * Returns the groupingid of a grouping with the idnumber specified for the course.
 160   * Grouping names should be unique within course
 161   *
 162   * @category group
 163   * @param int $courseid The id of the course
 164   * @param string $idnumber idnumber of the group
 165   * @return grouping object
 166   */
 167  function groups_get_grouping_by_idnumber($courseid, $idnumber) {
 168      if (empty($idnumber)) {
 169          return false;
 170      }
 171      $data = groups_get_course_data($courseid);
 172      foreach ($data->groupings as $grouping) {
 173          if ($grouping->idnumber == $idnumber) {
 174              return $grouping;
 175          }
 176      }
 177      return false;
 178  }
 179  
 180  /**
 181   * Get the group object
 182   *
 183   * @category group
 184   * @param int $groupid ID of the group.
 185   * @param string $fields (default is all fields)
 186   * @param int $strictness (IGNORE_MISSING - default)
 187   * @return bool|stdClass group object or false if not found
 188   * @throws dml_exception
 189   */
 190  function groups_get_group($groupid, $fields='*', $strictness=IGNORE_MISSING) {
 191      global $DB;
 192      return $DB->get_record('groups', array('id'=>$groupid), $fields, $strictness);
 193  }
 194  
 195  /**
 196   * Get the grouping object
 197   *
 198   * @category group
 199   * @param int $groupingid ID of the group.
 200   * @param string $fields
 201   * @param int $strictness (IGNORE_MISSING - default)
 202   * @return stdClass group object
 203   */
 204  function groups_get_grouping($groupingid, $fields='*', $strictness=IGNORE_MISSING) {
 205      global $DB;
 206      return $DB->get_record('groupings', array('id'=>$groupingid), $fields, $strictness);
 207  }
 208  
 209  /**
 210   * Gets array of all groups in a specified course (subject to the conditions imposed by the other arguments).
 211   *
 212   * @category group
 213   * @param int $courseid The id of the course.
 214   * @param int|int[] $userid optional user id or array of ids, returns only groups continaing one or more of those users.
 215   * @param int $groupingid optional returns only groups in the specified grouping.
 216   * @param string $fields defaults to g.*. This allows you to vary which fields are returned.
 217   *      If $groupingid is specified, the groupings_groups table will be available with alias gg.
 218   *      If $userid is specified, the groups_members table will be available as gm.
 219   * @param bool $withmembers if true return an extra field members (int[]) which is the list of userids that
 220   *      are members of each group. For this to work, g.id (or g.*) must be included in $fields.
 221   *      In this case, the final results will always be an array indexed by group id.
 222   * @return array returns an array of the group objects (unless you have done something very weird
 223   *      with the $fields option).
 224   */
 225  function groups_get_all_groups($courseid, $userid=0, $groupingid=0, $fields='g.*', $withmembers=false) {
 226      global $DB;
 227  
 228      // We need to check that we each field in the fields list belongs to the group table and that it has not being
 229      // aliased. If its something else we need to avoid the cache and run the query as who knows whats going on.
 230      $knownfields = true;
 231      if ($fields !== 'g.*') {
 232          // Quickly check if the first field is no longer g.id as using the
 233          // cache will return an array indexed differently than when expect
 234          if (strpos($fields, 'g.*') !== 0 && strpos($fields, 'g.id') !== 0) {
 235              $knownfields = false;
 236          } else {
 237              $fieldbits = explode(',', $fields);
 238              foreach ($fieldbits as $bit) {
 239                  $bit = trim($bit);
 240                  if (strpos($bit, 'g.') !== 0 or stripos($bit, ' AS ') !== false) {
 241                      $knownfields = false;
 242                      break;
 243                  }
 244              }
 245          }
 246      }
 247  
 248      if (empty($userid) && $knownfields && !$withmembers) {
 249          // We can use the cache.
 250          $data = groups_get_course_data($courseid);
 251          if (empty($groupingid)) {
 252              // All groups.. Easy!
 253              $groups = $data->groups;
 254          } else {
 255              $groups = array();
 256              foreach ($data->mappings as $mapping) {
 257                  if ($mapping->groupingid != $groupingid) {
 258                      continue;
 259                  }
 260                  if (isset($data->groups[$mapping->groupid])) {
 261                      $groups[$mapping->groupid] = $data->groups[$mapping->groupid];
 262                  }
 263              }
 264          }
 265          // Yay! We could use the cache. One more query saved.
 266          return $groups;
 267      }
 268  
 269      $params = [];
 270      $userfrom  = '';
 271      $userwhere = '';
 272      if (!empty($userid)) {
 273          list($usql, $params) = $DB->get_in_or_equal($userid);
 274          $userfrom  = "JOIN {groups_members} gm ON gm.groupid = g.id";
 275          $userwhere = "AND gm.userid $usql";
 276      }
 277  
 278      $groupingfrom  = '';
 279      $groupingwhere = '';
 280      if (!empty($groupingid)) {
 281          $groupingfrom  = "JOIN {groupings_groups} gg ON gg.groupid = g.id";
 282          $groupingwhere = "AND gg.groupingid = ?";
 283          $params[] = $groupingid;
 284      }
 285  
 286      array_unshift($params, $courseid);
 287  
 288      $results = $DB->get_records_sql("
 289              SELECT $fields
 290                FROM {groups} g
 291                $userfrom
 292                $groupingfrom
 293               WHERE g.courseid = ?
 294                 $userwhere
 295                 $groupingwhere
 296            ORDER BY g.name ASC", $params);
 297  
 298      if (!$withmembers) {
 299          return $results;
 300      }
 301  
 302      // We also want group members. We do this in a separate query, becuse the above
 303      // query will return a lot of data (e.g. g.description) for each group, and
 304      // some groups may contain hundreds of members. We don't want the results
 305      // to contain hundreds of copies of long descriptions.
 306      $groups = [];
 307      foreach ($results as $row) {
 308          $groups[$row->id] = $row;
 309          $groups[$row->id]->members = [];
 310      }
 311      $groupmembers = $DB->get_records_list('groups_members', 'groupid', array_keys($groups));
 312      foreach ($groupmembers as $gm) {
 313          $groups[$gm->groupid]->members[$gm->userid] = $gm->userid;
 314      }
 315      return $groups;
 316  }
 317  
 318  /**
 319   * Gets array of all groups in current user.
 320   *
 321   * @since Moodle 2.5
 322   * @category group
 323   * @return array Returns an array of the group objects.
 324   */
 325  function groups_get_my_groups() {
 326      global $DB, $USER;
 327      return $DB->get_records_sql("SELECT *
 328                                     FROM {groups_members} gm
 329                                     JOIN {groups} g
 330                                      ON g.id = gm.groupid
 331                                    WHERE gm.userid = ?
 332                                     ORDER BY name ASC", array($USER->id));
 333  }
 334  
 335  /**
 336   * Returns info about user's groups in course.
 337   *
 338   * @category group
 339   * @param int $courseid
 340   * @param int $userid $USER if not specified
 341   * @return array Array[groupingid][groupid] including grouping id 0 which means all groups
 342   */
 343  function groups_get_user_groups($courseid, $userid=0) {
 344      global $USER, $DB;
 345  
 346      if (empty($userid)) {
 347          $userid = $USER->id;
 348      }
 349  
 350      $cache = cache::make('core', 'user_group_groupings');
 351  
 352      // Try to retrieve group ids from the cache.
 353      $usergroups = $cache->get($userid);
 354  
 355      if ($usergroups === false) {
 356          $sql = "SELECT g.id, g.courseid, gg.groupingid
 357                    FROM {groups} g
 358                    JOIN {groups_members} gm ON gm.groupid = g.id
 359               LEFT JOIN {groupings_groups} gg ON gg.groupid = g.id
 360                   WHERE gm.userid = ?";
 361  
 362          $rs = $DB->get_recordset_sql($sql, array($userid));
 363  
 364          $usergroups = array();
 365          $allgroups  = array();
 366  
 367          foreach ($rs as $group) {
 368              if (!array_key_exists($group->courseid, $allgroups)) {
 369                  $allgroups[$group->courseid] = array();
 370              }
 371              $allgroups[$group->courseid][$group->id] = $group->id;
 372              if (!array_key_exists($group->courseid, $usergroups)) {
 373                  $usergroups[$group->courseid] = array();
 374              }
 375              if (is_null($group->groupingid)) {
 376                  continue;
 377              }
 378              if (!array_key_exists($group->groupingid, $usergroups[$group->courseid])) {
 379                  $usergroups[$group->courseid][$group->groupingid] = array();
 380              }
 381              $usergroups[$group->courseid][$group->groupingid][$group->id] = $group->id;
 382          }
 383          $rs->close();
 384  
 385          foreach (array_keys($allgroups) as $cid) {
 386              $usergroups[$cid]['0'] = array_keys($allgroups[$cid]); // All user groups in the course.
 387          }
 388  
 389          // Cache the data.
 390          $cache->set($userid, $usergroups);
 391      }
 392  
 393      if (array_key_exists($courseid, $usergroups)) {
 394          return $usergroups[$courseid];
 395      } else {
 396          return array('0' => array());
 397      }
 398  }
 399  
 400  /**
 401   * Gets an array of all groupings in a specified course. This value is cached
 402   * for a single course (so you can call it repeatedly for the same course
 403   * without a performance penalty).
 404   *
 405   * @category group
 406   * @param int $courseid return all groupings from course with this courseid
 407   * @return array Returns an array of the grouping objects (empty if none)
 408   */
 409  function groups_get_all_groupings($courseid) {
 410      $data = groups_get_course_data($courseid);
 411      return $data->groupings;
 412  }
 413  
 414  /**
 415   * Determines if the user is a member of the given group.
 416   *
 417   * If $userid is null, use the global object.
 418   *
 419   * @category group
 420   * @param int $groupid The group to check for membership.
 421   * @param int $userid The user to check against the group.
 422   * @return bool True if the user is a member, false otherwise.
 423   */
 424  function groups_is_member($groupid, $userid=null) {
 425      global $USER, $DB;
 426  
 427      if (!$userid) {
 428          $userid = $USER->id;
 429      }
 430  
 431      return $DB->record_exists('groups_members', array('groupid'=>$groupid, 'userid'=>$userid));
 432  }
 433  
 434  /**
 435   * Determines if current or specified is member of any active group in activity
 436   *
 437   * @category group
 438   * @staticvar array $cache
 439   * @param stdClass|cm_info $cm course module object
 440   * @param int $userid id of user, null means $USER->id
 441   * @return bool true if user member of at least one group used in activity
 442   */
 443  function groups_has_membership($cm, $userid=null) {
 444      global $CFG, $USER, $DB;
 445  
 446      static $cache = array();
 447  
 448      if (empty($userid)) {
 449          $userid = $USER->id;
 450      }
 451  
 452      $cachekey = $userid.'|'.$cm->course.'|'.$cm->groupingid;
 453      if (isset($cache[$cachekey])) {
 454          return($cache[$cachekey]);
 455      }
 456  
 457      if ($cm->groupingid) {
 458          // find out if member of any group in selected activity grouping
 459          $sql = "SELECT 'x'
 460                    FROM {groups_members} gm, {groupings_groups} gg
 461                   WHERE gm.userid = ? AND gm.groupid = gg.groupid AND gg.groupingid = ?";
 462          $params = array($userid, $cm->groupingid);
 463  
 464      } else {
 465          // no grouping used - check all groups in course
 466          $sql = "SELECT 'x'
 467                    FROM {groups_members} gm, {groups} g
 468                   WHERE gm.userid = ? AND gm.groupid = g.id AND g.courseid = ?";
 469          $params = array($userid, $cm->course);
 470      }
 471  
 472      $cache[$cachekey] = $DB->record_exists_sql($sql, $params);
 473  
 474      return $cache[$cachekey];
 475  }
 476  
 477  /**
 478   * Returns the users in the specified group.
 479   *
 480   * @category group
 481   * @param int $groupid The groupid to get the users for
 482   * @param int $fields The fields to return
 483   * @param int $sort optional sorting of returned users
 484   * @return array|bool Returns an array of the users for the specified
 485   * group or false if no users or an error returned.
 486   */
 487  function groups_get_members($groupid, $fields='u.*', $sort='lastname ASC') {
 488      global $DB;
 489  
 490      return $DB->get_records_sql("SELECT $fields
 491                                     FROM {user} u, {groups_members} gm
 492                                    WHERE u.id = gm.userid AND gm.groupid = ?
 493                                 ORDER BY $sort", array($groupid));
 494  }
 495  
 496  
 497  /**
 498   * Returns the users in the specified grouping.
 499   *
 500   * @category group
 501   * @param int $groupingid The groupingid to get the users for
 502   * @param string $fields The fields to return
 503   * @param string $sort optional sorting of returned users
 504   * @return array|bool Returns an array of the users for the specified
 505   * group or false if no users or an error returned.
 506   */
 507  function groups_get_grouping_members($groupingid, $fields='u.*', $sort='lastname ASC') {
 508      global $DB;
 509  
 510      return $DB->get_records_sql("SELECT $fields
 511                                     FROM {user} u
 512                                       INNER JOIN {groups_members} gm ON u.id = gm.userid
 513                                       INNER JOIN {groupings_groups} gg ON gm.groupid = gg.groupid
 514                                    WHERE  gg.groupingid = ?
 515                                 ORDER BY $sort", array($groupingid));
 516  }
 517  
 518  /**
 519   * Returns effective groupmode used in course
 520   *
 521   * @category group
 522   * @param stdClass $course course object.
 523   * @return int group mode
 524   */
 525  function groups_get_course_groupmode($course) {
 526      return $course->groupmode;
 527  }
 528  
 529  /**
 530   * Returns effective groupmode used in activity, course setting
 531   * overrides activity setting if groupmodeforce enabled.
 532   *
 533   * If $cm is an instance of cm_info it is easier to use $cm->effectivegroupmode
 534   *
 535   * @category group
 536   * @param cm_info|stdClass $cm the course module object. Only the ->course and ->groupmode need to be set.
 537   * @param stdClass $course object optional course object to improve perf
 538   * @return int group mode
 539   */
 540  function groups_get_activity_groupmode($cm, $course=null) {
 541      if ($cm instanceof cm_info) {
 542          return $cm->effectivegroupmode;
 543      }
 544      if (isset($course->id) and $course->id == $cm->course) {
 545          //ok
 546      } else {
 547          // Get course object (reuse $COURSE if possible).
 548          $course = get_course($cm->course, false);
 549      }
 550  
 551      return empty($course->groupmodeforce) ? $cm->groupmode : $course->groupmode;
 552  }
 553  
 554  /**
 555   * Print group menu selector for course level.
 556   *
 557   * @category group
 558   * @param stdClass $course course object
 559   * @param mixed $urlroot return address. Accepts either a string or a moodle_url
 560   * @param bool $return return as string instead of printing
 561   * @return mixed void or string depending on $return param
 562   */
 563  function groups_print_course_menu($course, $urlroot, $return=false) {
 564      global $USER, $OUTPUT;
 565  
 566      if (!$groupmode = $course->groupmode) {
 567          if ($return) {
 568              return '';
 569          } else {
 570              return;
 571          }
 572      }
 573  
 574      $context = context_course::instance($course->id);
 575      $aag = has_capability('moodle/site:accessallgroups', $context);
 576  
 577      $usergroups = array();
 578      if ($groupmode == VISIBLEGROUPS or $aag) {
 579          $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
 580          // Get user's own groups and put to the top.
 581          $usergroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
 582      } else {
 583          $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
 584      }
 585  
 586      $activegroup = groups_get_course_group($course, true, $allowedgroups);
 587  
 588      $groupsmenu = array();
 589      if (!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) {
 590          $groupsmenu[0] = get_string('allparticipants');
 591      }
 592  
 593      $groupsmenu += groups_sort_menu_options($allowedgroups, $usergroups);
 594  
 595      if ($groupmode == VISIBLEGROUPS) {
 596          $grouplabel = get_string('groupsvisible');
 597      } else {
 598          $grouplabel = get_string('groupsseparate');
 599      }
 600  
 601      if ($aag and $course->defaultgroupingid) {
 602          if ($grouping = groups_get_grouping($course->defaultgroupingid)) {
 603              $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')';
 604          }
 605      }
 606  
 607      if (count($groupsmenu) == 1) {
 608          $groupname = reset($groupsmenu);
 609          $output = $grouplabel.': '.$groupname;
 610      } else {
 611          $select = new single_select(new moodle_url($urlroot), 'group', $groupsmenu, $activegroup, null, 'selectgroup');
 612          $select->label = $grouplabel;
 613          $output = $OUTPUT->render($select);
 614      }
 615  
 616      $output = '<div class="groupselector">'.$output.'</div>';
 617  
 618      if ($return) {
 619          return $output;
 620      } else {
 621          echo $output;
 622      }
 623  }
 624  
 625  /**
 626   * Turn an array of groups into an array of menu options.
 627   * @param array $groups of group objects.
 628   * @return array groupid => formatted group name.
 629   */
 630  function groups_list_to_menu($groups) {
 631      $groupsmenu = array();
 632      foreach ($groups as $group) {
 633          $groupsmenu[$group->id] = format_string($group->name);
 634      }
 635      return $groupsmenu;
 636  }
 637  
 638  /**
 639   * Takes user's allowed groups and own groups and formats for use in group selector menu
 640   * If user has allowed groups + own groups will add to an optgroup
 641   * Own groups are removed from allowed groups
 642   * @param array $allowedgroups All groups user is allowed to see
 643   * @param array $usergroups Groups user belongs to
 644   * @return array
 645   */
 646  function groups_sort_menu_options($allowedgroups, $usergroups) {
 647      $useroptions = array();
 648      if ($usergroups) {
 649          $useroptions = groups_list_to_menu($usergroups);
 650  
 651          // Remove user groups from other groups list.
 652          foreach ($usergroups as $group) {
 653              unset($allowedgroups[$group->id]);
 654          }
 655      }
 656  
 657      $allowedoptions = array();
 658      if ($allowedgroups) {
 659          $allowedoptions = groups_list_to_menu($allowedgroups);
 660      }
 661  
 662      if ($useroptions && $allowedoptions) {
 663          return array(
 664              1 => array(get_string('mygroups', 'group') => $useroptions),
 665              2 => array(get_string('othergroups', 'group') => $allowedoptions)
 666          );
 667      } else if ($useroptions) {
 668          return $useroptions;
 669      } else {
 670          return $allowedoptions;
 671      }
 672  }
 673  
 674  /**
 675   * Generates html to print menu selector for course level, listing all groups.
 676   * Note: This api does not do any group mode check use groups_print_course_menu() instead if you want proper checks.
 677   *
 678   * @param stdclass          $course  course object.
 679   * @param string|moodle_url $urlroot return address. Accepts either a string or a moodle_url.
 680   * @param bool              $update  set this to true to update current active group based on the group param.
 681   * @param int               $activegroup Change group active to this group if $update set to true.
 682   *
 683   * @return string html or void
 684   */
 685  function groups_allgroups_course_menu($course, $urlroot, $update = false, $activegroup = 0) {
 686      global $SESSION, $OUTPUT, $USER;
 687  
 688      $groupmode = groups_get_course_groupmode($course);
 689      $context = context_course::instance($course->id);
 690      $groupsmenu = array();
 691  
 692      if (has_capability('moodle/site:accessallgroups', $context)) {
 693          $groupsmenu[0] = get_string('allparticipants');
 694          $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
 695      } else {
 696          $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
 697      }
 698  
 699      $groupsmenu += groups_list_to_menu($allowedgroups);
 700  
 701      if ($update) {
 702          // Init activegroup array if necessary.
 703          if (!isset($SESSION->activegroup)) {
 704              $SESSION->activegroup = array();
 705          }
 706          if (!isset($SESSION->activegroup[$course->id])) {
 707              $SESSION->activegroup[$course->id] = array(SEPARATEGROUPS => array(), VISIBLEGROUPS => array(), 'aag' => array());
 708          }
 709          if (empty($groupsmenu[$activegroup])) {
 710              $activegroup = key($groupsmenu); // Force set to one of accessible groups.
 711          }
 712          $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = $activegroup;
 713      }
 714  
 715      $grouplabel = get_string('groups');
 716      if (count($groupsmenu) == 0) {
 717          return '';
 718      } else if (count($groupsmenu) == 1) {
 719          $groupname = reset($groupsmenu);
 720          $output = $grouplabel.': '.$groupname;
 721      } else {
 722          $select = new single_select(new moodle_url($urlroot), 'group', $groupsmenu, $activegroup, null, 'selectgroup');
 723          $select->label = $grouplabel;
 724          $output = $OUTPUT->render($select);
 725      }
 726  
 727      return $output;
 728  
 729  }
 730  
 731  /**
 732   * Print group menu selector for activity.
 733   *
 734   * @category group
 735   * @param stdClass|cm_info $cm course module object
 736   * @param string|moodle_url $urlroot return address that users get to if they choose an option;
 737   *   should include any parameters needed, e.g. "$CFG->wwwroot/mod/forum/view.php?id=34"
 738   * @param bool $return return as string instead of printing
 739   * @param bool $hideallparticipants If true, this prevents the 'All participants'
 740   *   option from appearing in cases where it normally would. This is intended for
 741   *   use only by activities that cannot display all groups together. (Note that
 742   *   selecting this option does not prevent groups_get_activity_group from
 743   *   returning 0; it will still do that if the user has chosen 'all participants'
 744   *   in another activity, or not chosen anything.)
 745   * @return mixed void or string depending on $return param
 746   */
 747  function groups_print_activity_menu($cm, $urlroot, $return=false, $hideallparticipants=false) {
 748      global $USER, $OUTPUT;
 749  
 750      if ($urlroot instanceof moodle_url) {
 751          // no changes necessary
 752  
 753      } else {
 754          if (strpos($urlroot, 'http') !== 0) { // Will also work for https
 755              // Display error if urlroot is not absolute (this causes the non-JS version to break)
 756              debugging('groups_print_activity_menu requires absolute URL for ' .
 757                        '$urlroot, not <tt>' . s($urlroot) . '</tt>. Example: ' .
 758                        'groups_print_activity_menu($cm, $CFG->wwwroot . \'/mod/mymodule/view.php?id=13\');',
 759                        DEBUG_DEVELOPER);
 760          }
 761          $urlroot = new moodle_url($urlroot);
 762      }
 763  
 764      if (!$groupmode = groups_get_activity_groupmode($cm)) {
 765          if ($return) {
 766              return '';
 767          } else {
 768              return;
 769          }
 770      }
 771  
 772      $context = context_module::instance($cm->id);
 773      $aag = has_capability('moodle/site:accessallgroups', $context);
 774  
 775      $usergroups = array();
 776      if ($groupmode == VISIBLEGROUPS or $aag) {
 777          $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid); // any group in grouping
 778          // Get user's own groups and put to the top.
 779          $usergroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid);
 780      } else {
 781          $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid); // only assigned groups
 782      }
 783  
 784      $activegroup = groups_get_activity_group($cm, true, $allowedgroups);
 785  
 786      $groupsmenu = array();
 787      if ((!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) and !$hideallparticipants) {
 788          $groupsmenu[0] = get_string('allparticipants');
 789      }
 790  
 791      $groupsmenu += groups_sort_menu_options($allowedgroups, $usergroups);
 792  
 793      if ($groupmode == VISIBLEGROUPS) {
 794          $grouplabel = get_string('groupsvisible');
 795      } else {
 796          $grouplabel = get_string('groupsseparate');
 797      }
 798  
 799      if ($aag and $cm->groupingid) {
 800          if ($grouping = groups_get_grouping($cm->groupingid)) {
 801              $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')';
 802          }
 803      }
 804  
 805      if (count($groupsmenu) == 1) {
 806          $groupname = reset($groupsmenu);
 807          $output = $grouplabel.': '.$groupname;
 808      } else {
 809          $select = new single_select($urlroot, 'group', $groupsmenu, $activegroup, null, 'selectgroup');
 810          $select->label = $grouplabel;
 811          $output = $OUTPUT->render($select);
 812      }
 813  
 814      $output = '<div class="groupselector">'.$output.'</div>';
 815  
 816      if ($return) {
 817          return $output;
 818      } else {
 819          echo $output;
 820      }
 821  }
 822  
 823  /**
 824   * Returns group active in course, changes the group by default if 'group' page param present
 825   *
 826   * @category group
 827   * @param stdClass $course course bject
 828   * @param bool $update change active group if group param submitted
 829   * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_course_menu())
 830   * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
 831   */
 832  function groups_get_course_group($course, $update=false, $allowedgroups=null) {
 833      global $USER, $SESSION;
 834  
 835      if (!$groupmode = $course->groupmode) {
 836          // NOGROUPS used
 837          return false;
 838      }
 839  
 840      $context = context_course::instance($course->id);
 841      if (has_capability('moodle/site:accessallgroups', $context)) {
 842          $groupmode = 'aag';
 843      }
 844  
 845      if (!is_array($allowedgroups)) {
 846          if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
 847              $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
 848          } else {
 849              $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
 850          }
 851      }
 852  
 853      _group_verify_activegroup($course->id, $groupmode, $course->defaultgroupingid, $allowedgroups);
 854  
 855      // set new active group if requested
 856      $changegroup = optional_param('group', -1, PARAM_INT);
 857      if ($update and $changegroup != -1) {
 858  
 859          if ($changegroup == 0) {
 860              // do not allow changing to all groups without accessallgroups capability
 861              if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
 862                  $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = 0;
 863              }
 864  
 865          } else {
 866              if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
 867                  $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = $changegroup;
 868              }
 869          }
 870      }
 871  
 872      return $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid];
 873  }
 874  
 875  /**
 876   * Returns group active in activity, changes the group by default if 'group' page param present
 877   *
 878   * @category group
 879   * @param stdClass|cm_info $cm course module object
 880   * @param bool $update change active group if group param submitted
 881   * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_activity_menu())
 882   * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
 883   */
 884  function groups_get_activity_group($cm, $update=false, $allowedgroups=null) {
 885      global $USER, $SESSION;
 886  
 887      if (!$groupmode = groups_get_activity_groupmode($cm)) {
 888          // NOGROUPS used
 889          return false;
 890      }
 891  
 892      $context = context_module::instance($cm->id);
 893      if (has_capability('moodle/site:accessallgroups', $context)) {
 894          $groupmode = 'aag';
 895      }
 896  
 897      if (!is_array($allowedgroups)) {
 898          if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
 899              $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid);
 900          } else {
 901              $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid);
 902          }
 903      }
 904  
 905      _group_verify_activegroup($cm->course, $groupmode, $cm->groupingid, $allowedgroups);
 906  
 907      // set new active group if requested
 908      $changegroup = optional_param('group', -1, PARAM_INT);
 909      if ($update and $changegroup != -1) {
 910  
 911          if ($changegroup == 0) {
 912              // allgroups visible only in VISIBLEGROUPS or when accessallgroups
 913              if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
 914                  $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = 0;
 915              }
 916  
 917          } else {
 918              if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
 919                  $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = $changegroup;
 920              }
 921          }
 922      }
 923  
 924      return $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid];
 925  }
 926  
 927  /**
 928   * Gets a list of groups that the user is allowed to access within the
 929   * specified activity.
 930   *
 931   * @category group
 932   * @param stdClass|cm_info $cm Course-module
 933   * @param int $userid User ID (defaults to current user)
 934   * @return array An array of group objects, or false if none
 935   */
 936  function groups_get_activity_allowed_groups($cm,$userid=0) {
 937      // Use current user by default
 938      global $USER;
 939      if(!$userid) {
 940          $userid=$USER->id;
 941      }
 942  
 943      // Get groupmode for activity, taking into account course settings
 944      $groupmode=groups_get_activity_groupmode($cm);
 945  
 946      // If visible groups mode, or user has the accessallgroups capability,
 947      // then they can access all groups for the activity...
 948      $context = context_module::instance($cm->id);
 949      if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context, $userid)) {
 950          return groups_get_all_groups($cm->course, 0, $cm->groupingid);
 951      } else {
 952          // ...otherwise they can only access groups they belong to
 953          return groups_get_all_groups($cm->course, $userid, $cm->groupingid);
 954      }
 955  }
 956  
 957  /**
 958   * Determine if a given group is visible to user or not in a given context.
 959   *
 960   * @since Moodle 2.6
 961   * @param int      $groupid Group id to test. 0 for all groups.
 962   * @param stdClass $course  Course object.
 963   * @param stdClass $cm      Course module object.
 964   * @param int      $userid  user id to test against. Defaults to $USER.
 965   * @return boolean true if visible, false otherwise
 966   */
 967  function groups_group_visible($groupid, $course, $cm = null, $userid = null) {
 968      global $USER;
 969  
 970      if (empty($userid)) {
 971          $userid = $USER->id;
 972      }
 973  
 974      $groupmode = empty($cm) ? groups_get_course_groupmode($course) : groups_get_activity_groupmode($cm, $course);
 975      if ($groupmode == NOGROUPS || $groupmode == VISIBLEGROUPS) {
 976          // Groups are not used, or everything is visible, no need to go any further.
 977          return true;
 978      }
 979  
 980      $context = empty($cm) ? context_course::instance($course->id) : context_module::instance($cm->id);
 981      if (has_capability('moodle/site:accessallgroups', $context, $userid)) {
 982          // User can see everything. Groupid = 0 is handled here as well.
 983          return true;
 984      } else if ($groupid != 0) {
 985          // Group mode is separate, and user doesn't have access all groups capability. Check if user can see requested group.
 986          $groups = empty($cm) ? groups_get_all_groups($course->id, $userid) : groups_get_activity_allowed_groups($cm, $userid);
 987          if (array_key_exists($groupid, $groups)) {
 988              // User can see the group.
 989              return true;
 990          }
 991      }
 992      return false;
 993  }
 994  
 995  /**
 996   * Get sql and parameters that will return user ids for a group or groups
 997   *
 998   * @param int|array $groupids Where this is an array of multiple groups, it will match on members of any of the groups
 999   * @param context $context Course context or a context within a course. Mandatory when $groupid = USERSWITHOUTGROUP
1000   * @param int $groupsjointype Join type logic used. Defaults to 'Any' (logical OR).
1001   * @return array($sql, $params)
1002   * @throws coding_exception if empty or invalid context submitted when $groupid = USERSWITHOUTGROUP
1003   */
1004  function groups_get_members_ids_sql($groupids, context $context = null, $groupsjointype = GROUPS_JOIN_ANY) {
1005      if (!is_array($groupids)) {
1006          $groupids = [$groupids];
1007      }
1008  
1009      $groupjoin = groups_get_members_join($groupids, 'u.id', $context, $groupsjointype);
1010  
1011      $sql = "SELECT DISTINCT u.id
1012                FROM {user} u
1013              $groupjoin->joins
1014               WHERE u.deleted = 0";
1015      if (!empty($groupjoin->wheres)) {
1016          $sql .= ' AND '. $groupjoin->wheres;
1017      }
1018  
1019      return array($sql, $groupjoin->params);
1020  }
1021  
1022  /**
1023   * Get sql join to return users in a group
1024   *
1025   * @param int|array $groupids The groupids, 0 or [] means all groups and USERSWITHOUTGROUP no group
1026   * @param string $useridcolumn The column of the user id from the calling SQL, e.g. u.id
1027   * @param context $context Course context or a context within a course. Mandatory when $groupids includes USERSWITHOUTGROUP
1028   * @param int $jointype Join type logic used. Defaults to 'Any' (logical OR).
1029   * @return \core\dml\sql_join Contains joins, wheres, params
1030   * @throws coding_exception if empty or invalid context submitted when $groupid = USERSWITHOUTGROUP
1031   */
1032  function groups_get_members_join($groupids, $useridcolumn, context $context = null, int $jointype = GROUPS_JOIN_ANY) {
1033      global $DB;
1034  
1035      // Use unique prefix just in case somebody makes some SQL magic with the result.
1036      static $i = 0;
1037      $i++;
1038      $prefix = 'gm' . $i . '_';
1039  
1040      if (!is_array($groupids)) {
1041          $groupids = $groupids ? [$groupids] : [];
1042      }
1043  
1044      $join = '';
1045      $where = '';
1046      $param = [];
1047  
1048      $coursecontext = (!empty($context)) ? $context->get_course_context() : null;
1049      if (in_array(USERSWITHOUTGROUP, $groupids) && empty($coursecontext)) {
1050          // Throw an exception if $context is empty or invalid because it's needed to get the users without any group.
1051          throw new coding_exception('Missing or wrong $context parameter in an attempt to get members without any group');
1052      }
1053  
1054      // Handle cases where we need to include/exclude users not in any groups.
1055      if (($nogroupskey = array_search(USERSWITHOUTGROUP, $groupids)) !== false) {
1056          // Get members without any group.
1057          $join .= "LEFT JOIN (
1058                       SELECT g.courseid, m.groupid, m.userid
1059                         FROM {groups_members} m
1060                         JOIN {groups} g ON g.id = m.groupid
1061                    ) {$prefix}gm ON ({$prefix}gm.userid = {$useridcolumn} AND {$prefix}gm.courseid = :{$prefix}gcourseid)";
1062  
1063          // Join type 'None' when filtering by 'no groups' means match users in at least one group.
1064          if ($jointype == GROUPS_JOIN_NONE) {
1065              $where = "{$prefix}gm.userid IS NOT NULL";
1066          } else {
1067              // All other cases need to match users not in any group.
1068              $where = "{$prefix}gm.userid IS NULL";
1069          }
1070  
1071          $param = ["{$prefix}gcourseid" => $coursecontext->instanceid];
1072          unset($groupids[$nogroupskey]);
1073      }
1074  
1075      // Handle any specified groups that need to be included.
1076      if (!empty($groupids)) {
1077          switch ($jointype) {
1078              case GROUPS_JOIN_ALL:
1079                  // Handle matching all of the provided groups (logical AND).
1080                  $joinallwheres = [];
1081                  $aliaskey = 0;
1082                  foreach ($groupids as $groupid) {
1083                      $gmalias = "{$prefix}gm{$aliaskey}";
1084                      $aliaskey++;
1085                      $join .= "LEFT JOIN {groups_members} {$gmalias}
1086                                       ON ({$gmalias}.userid = {$useridcolumn} AND {$gmalias}.groupid = :{$gmalias}param)";
1087                      $joinallwheres[] = "{$gmalias}.userid IS NOT NULL";
1088                      $param["{$gmalias}param"] = $groupid;
1089                  }
1090  
1091                  // Members of all of the specified groups only.
1092                  if (empty($where)) {
1093                      $where = '(' . implode(' AND ', $joinallwheres) . ')';
1094                  } else {
1095                      // Members of the specified groups and also no groups.
1096                      // NOTE: This will always return no results, because you cannot be in specified groups and also be in no groups.
1097                      $where = '(' . $where . ' AND ' . implode(' AND ', $joinallwheres) . ')';
1098                  }
1099  
1100                  break;
1101  
1102              case GROUPS_JOIN_ANY:
1103                  // Handle matching any of the provided groups (logical OR).
1104                  list($groupssql, $groupsparams) = $DB->get_in_or_equal($groupids, SQL_PARAMS_NAMED, $prefix);
1105  
1106                  $join .= "LEFT JOIN {groups_members} {$prefix}gm2
1107                                   ON ({$prefix}gm2.userid = {$useridcolumn} AND {$prefix}gm2.groupid {$groupssql})";
1108                  $param = array_merge($param, $groupsparams);
1109  
1110                  // Members of any of the specified groups only.
1111                  if (empty($where)) {
1112                      $where = "{$prefix}gm2.userid IS NOT NULL";
1113                  } else {
1114                      // Members of any of the specified groups or no groups.
1115                      $where = "({$where} OR {$prefix}gm2.userid IS NOT NULL)";
1116                  }
1117  
1118                  break;
1119  
1120              case GROUPS_JOIN_NONE:
1121                  // Handle matching none of the provided groups (logical NOT).
1122                  list($groupssql, $groupsparams) = $DB->get_in_or_equal($groupids, SQL_PARAMS_NAMED, $prefix);
1123  
1124                  $join .= "LEFT JOIN {groups_members} {$prefix}gm2
1125                                   ON ({$prefix}gm2.userid = {$useridcolumn} AND {$prefix}gm2.groupid {$groupssql})";
1126                  $param = array_merge($param, $groupsparams);
1127  
1128                  // Members of none of the specified groups only.
1129                  if (empty($where)) {
1130                      $where = "{$prefix}gm2.userid IS NULL";
1131                  } else {
1132                      // Members of any unspecified groups (not a member of the specified groups, and not a member of no groups).
1133                      $where = "({$where} AND {$prefix}gm2.userid IS NULL)";
1134                  }
1135  
1136                  break;
1137          }
1138      }
1139  
1140      return new \core\dml\sql_join($join, $where, $param);
1141  }
1142  
1143  /**
1144   * Internal method, sets up $SESSION->activegroup and verifies previous value
1145   *
1146   * @param int $courseid
1147   * @param int|string $groupmode SEPARATEGROUPS, VISIBLEGROUPS or 'aag' (access all groups)
1148   * @param int $groupingid 0 means all groups
1149   * @param array $allowedgroups list of groups user can see
1150   */
1151  function _group_verify_activegroup($courseid, $groupmode, $groupingid, array $allowedgroups) {
1152      global $SESSION, $USER;
1153  
1154      // init activegroup array if necessary
1155      if (!isset($SESSION->activegroup)) {
1156          $SESSION->activegroup = array();
1157      }
1158      if (!array_key_exists($courseid, $SESSION->activegroup)) {
1159          $SESSION->activegroup[$courseid] = array(SEPARATEGROUPS=>array(), VISIBLEGROUPS=>array(), 'aag'=>array());
1160      }
1161  
1162      // make sure that the current group info is ok
1163      if (array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode]) and !array_key_exists($SESSION->activegroup[$courseid][$groupmode][$groupingid], $allowedgroups)) {
1164          // active group does not exist anymore or is 0
1165          if ($SESSION->activegroup[$courseid][$groupmode][$groupingid] > 0 or $groupmode == SEPARATEGROUPS) {
1166              // do not do this if all groups selected and groupmode is not separate
1167              unset($SESSION->activegroup[$courseid][$groupmode][$groupingid]);
1168          }
1169      }
1170  
1171      // set up defaults if necessary
1172      if (!array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode])) {
1173          if ($groupmode == 'aag') {
1174              $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0; // all groups by default if user has accessallgroups
1175  
1176          } else if ($allowedgroups) {
1177              if ($groupmode != SEPARATEGROUPS and $mygroups = groups_get_all_groups($courseid, $USER->id, $groupingid)) {
1178                  $firstgroup = reset($mygroups);
1179              } else {
1180                  $firstgroup = reset($allowedgroups);
1181              }
1182              $SESSION->activegroup[$courseid][$groupmode][$groupingid] = $firstgroup->id;
1183  
1184          } else {
1185              // this happen when user not assigned into group in SEPARATEGROUPS mode or groups do not exist yet
1186              // mod authors must add extra checks for this when SEPARATEGROUPS mode used (such as when posting to forum)
1187              $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0;
1188          }
1189      }
1190  }
1191  
1192  /**
1193   * Caches group data for a particular course to speed up subsequent requests.
1194   *
1195   * @param int $courseid The course id to cache data for.
1196   * @param cache $cache The cache if it has already been initialised. If not a new one will be created.
1197   * @return stdClass A data object containing groups, groupings, and mappings.
1198   */
1199  function groups_cache_groupdata($courseid, cache $cache = null) {
1200      global $DB;
1201  
1202      if ($cache === null) {
1203          // Initialise a cache if we wern't given one.
1204          $cache = cache::make('core', 'groupdata');
1205      }
1206  
1207      // Get the groups that belong to the course.
1208      $groups = $DB->get_records('groups', array('courseid' => $courseid), 'name ASC');
1209      // Get the groupings that belong to the course.
1210      $groupings = $DB->get_records('groupings', array('courseid' => $courseid), 'name ASC');
1211  
1212      if (!is_array($groups)) {
1213          $groups = array();
1214      }
1215  
1216      if (!is_array($groupings)) {
1217          $groupings = array();
1218      }
1219  
1220      if (!empty($groupings)) {
1221          // Finally get the mappings between the two.
1222          list($insql, $params) = $DB->get_in_or_equal(array_keys($groupings));
1223          $mappings = $DB->get_records_sql("
1224                  SELECT gg.id, gg.groupingid, gg.groupid
1225                    FROM {groupings_groups} gg
1226                    JOIN {groups} g ON g.id = gg.groupid
1227                   WHERE gg.groupingid $insql
1228                ORDER BY g.name ASC", $params);
1229      } else {
1230          $mappings = array();
1231      }
1232  
1233      // Prepare the data array.
1234      $data = new stdClass;
1235      $data->groups = $groups;
1236      $data->groupings = $groupings;
1237      $data->mappings = $mappings;
1238      // Cache the data.
1239      $cache->set($courseid, $data);
1240      // Finally return it so it can be used if desired.
1241      return $data;
1242  }
1243  
1244  /**
1245   * Gets group data for a course.
1246   *
1247   * This returns an object with the following properties:
1248   *   - groups : An array of all the groups in the course.
1249   *   - groupings : An array of all the groupings within the course.
1250   *   - mappings : An array of group to grouping mappings.
1251   *
1252   * @param int $courseid The course id to get data for.
1253   * @param cache $cache The cache if it has already been initialised. If not a new one will be created.
1254   * @return stdClass
1255   */
1256  function groups_get_course_data($courseid, cache $cache = null) {
1257      if ($cache === null) {
1258          // Initialise a cache if we wern't given one.
1259          $cache = cache::make('core', 'groupdata');
1260      }
1261      // Try to retrieve it from the cache.
1262      $data = $cache->get($courseid);
1263      if ($data === false) {
1264          $data = groups_cache_groupdata($courseid, $cache);
1265      }
1266      return $data;
1267  }
1268  
1269  /**
1270   * Determine if the current user can see at least one of the groups of the specified user.
1271   *
1272   * @param stdClass $course  Course object.
1273   * @param int $userid  user id to check against.
1274   * @param stdClass $cm Course module object. Optional, just for checking at activity level instead course one.
1275   * @return boolean true if visible, false otherwise
1276   * @since Moodle 2.9
1277   */
1278  function groups_user_groups_visible($course, $userid, $cm = null) {
1279      global $USER;
1280  
1281      $groupmode = empty($cm) ? groups_get_course_groupmode($course) : groups_get_activity_groupmode($cm, $course);
1282      if ($groupmode == NOGROUPS || $groupmode == VISIBLEGROUPS) {
1283          // Groups are not used, or everything is visible, no need to go any further.
1284          return true;
1285      }
1286  
1287      $context = empty($cm) ? context_course::instance($course->id) : context_module::instance($cm->id);
1288      if (has_capability('moodle/site:accessallgroups', $context)) {
1289          // User can see everything.
1290          return true;
1291      } else {
1292          // Group mode is separate, and user doesn't have access all groups capability.
1293          if (empty($cm)) {
1294              $usergroups = groups_get_all_groups($course->id, $userid);
1295              $currentusergroups = groups_get_all_groups($course->id, $USER->id);
1296          } else {
1297              $usergroups = groups_get_activity_allowed_groups($cm, $userid);
1298              $currentusergroups = groups_get_activity_allowed_groups($cm, $USER->id);
1299          }
1300  
1301          $samegroups = array_intersect_key($currentusergroups, $usergroups);
1302          if (!empty($samegroups)) {
1303              // We share groups!
1304              return true;
1305          }
1306      }
1307      return false;
1308  }
1309  
1310  /**
1311   * Returns the users in the specified groups.
1312   *
1313   * This function does not return complete user objects by default. It returns the user_picture basic fields.
1314   *
1315   * @param array $groupsids The list of groups ids to check
1316   * @param array $extrafields extra fields to be included in result
1317   * @param int $sort optional sorting of returned users
1318   * @return array|bool Returns an array of the users for the specified group or false if no users or an error returned.
1319   * @since  Moodle 3.3
1320   */
1321  function groups_get_groups_members($groupsids, $extrafields=null, $sort='lastname ASC') {
1322      global $DB;
1323  
1324      $userfieldsapi = \core_user\fields::for_userpic()->including(...($extrafields ?? []));
1325      $userfields = $userfieldsapi->get_sql('u', false, '', '', false)->selects;
1326      list($insql, $params) = $DB->get_in_or_equal($groupsids);
1327  
1328      return $DB->get_records_sql("SELECT $userfields
1329                                     FROM {user} u, {groups_members} gm
1330                                    WHERE u.id = gm.userid AND gm.groupid $insql
1331                                 GROUP BY $userfields
1332                                 ORDER BY $sort", $params);
1333  }
1334  
1335  /**
1336   * Returns users who share group membership with the specified user in the given actiivty.
1337   *
1338   * @param stdClass|cm_info $cm course module
1339   * @param int $userid user id (empty for current user)
1340   * @return array a list of user
1341   * @since  Moodle 3.3
1342   */
1343  function groups_get_activity_shared_group_members($cm, $userid = null) {
1344      global $USER;
1345  
1346      if (empty($userid)) {
1347          $userid = $USER;
1348      }
1349  
1350      $groupsids = array_keys(groups_get_activity_allowed_groups($cm, $userid));
1351      // No groups no users.
1352      if (empty($groupsids)) {
1353          return [];
1354      }
1355      return groups_get_groups_members($groupsids);
1356  }