lib/grouplib.php

   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     $userfields = user_picture::fields('u', $extrafields);
1325     list($insql, $params) = $DB->get_in_or_equal($groupsids);
1326
1327     return $DB->get_records_sql("SELECT $userfields
1328                                    FROM {user} u, {groups_members} gm
1329                                   WHERE u.id = gm.userid AND gm.groupid $insql
1330                                GROUP BY $userfields
1331                                ORDER BY $sort", $params);
1332 }
1333
1334 /**
1335  * Returns users who share group membership with the specified user in the given actiivty.
1336  *
1337  * @param stdClass|cm_info $cm course module
1338  * @param int $userid user id (empty for current user)
1339  * @return array a list of user
1340  * @since  Moodle 3.3
1341  */
1342 function groups_get_activity_shared_group_members($cm, $userid = null) {
1343     global $USER;
1344
1345     if (empty($userid)) {
1346         $userid = $USER;
1347     }
1348
1349     $groupsids = array_keys(groups_get_activity_allowed_groups($cm, $userid));
1350     // No groups no users.
1351     if (empty($groupsids)) {
1352         return [];
1353     }
1354     return groups_get_groups_members($groupsids);
1355 }