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 /**
  43  * Determines if a group with a given groupid exists.
  44  *
  45  * @category group
  46  * @param int $groupid The groupid to check for
  47  * @return bool True if the group exists, false otherwise or if an error
  48  * occurred.
  49  */
  50 function groups_group_exists($groupid) {
  51     global $DB;
  52     return $DB->record_exists('groups', array('id'=>$groupid));
  53 }
  54
  55 /**
  56  * Gets the name of a group with a specified id
  57  *
  58  * @category group
  59  * @param int $groupid The id of the group
  60  * @return string The name of the group
  61  */
  62 function groups_get_group_name($groupid) {
  63     global $DB;
  64     return $DB->get_field('groups', 'name', array('id'=>$groupid));
  65 }
  66
  67 /**
  68  * Gets the name of a grouping with a specified id
  69  *
  70  * @category group
  71  * @param int $groupingid The id of the grouping
  72  * @return string The name of the grouping
  73  */
  74 function groups_get_grouping_name($groupingid) {
  75     global $DB;
  76     return $DB->get_field('groupings', 'name', array('id'=>$groupingid));
  77 }
  78
  79 /**
  80  * Returns the groupid of a group with the name specified for the course.
  81  * Group names should be unique in course
  82  *
  83  * @category group
  84  * @param int $courseid The id of the course
  85  * @param string $name name of group (without magic quotes)
  86  * @return int $groupid
  87  */
  88 function groups_get_group_by_name($courseid, $name) {
  89     $data = groups_get_course_data($courseid);
  90     foreach ($data->groups as $group) {
  91         if ($group->name == $name) {
  92             return $group->id;
  93         }
  94     }
  95     return false;
  96 }
  97
  98 /**
  99  * Returns the groupid of a group with the idnumber specified for the course.
 100  * Group idnumbers should be unique within course
 101  *
 102  * @category group
 103  * @param int $courseid The id of the course
 104  * @param string $idnumber idnumber of group
 105  * @return group object
 106  */
 107 function groups_get_group_by_idnumber($courseid, $idnumber) {
 108     if (empty($idnumber)) {
 109         return false;
 110     }
 111     $data = groups_get_course_data($courseid);
 112     foreach ($data->groups as $group) {
 113         if ($group->idnumber == $idnumber) {
 114             return $group;
 115         }
 116     }
 117     return false;
 118 }
 119
 120 /**
 121  * Returns the groupingid of a grouping with the name specified for the course.
 122  * Grouping names should be unique in course
 123  *
 124  * @category group
 125  * @param int $courseid The id of the course
 126  * @param string $name name of group (without magic quotes)
 127  * @return int $groupid
 128  */
 129 function groups_get_grouping_by_name($courseid, $name) {
 130     $data = groups_get_course_data($courseid);
 131     foreach ($data->groupings as $grouping) {
 132         if ($grouping->name == $name) {
 133             return $grouping->id;
 134         }
 135     }
 136     return false;
 137 }
 138
 139 /**
 140  * Returns the groupingid of a grouping with the idnumber specified for the course.
 141  * Grouping names should be unique within course
 142  *
 143  * @category group
 144  * @param int $courseid The id of the course
 145  * @param string $idnumber idnumber of the group
 146  * @return grouping object
 147  */
 148 function groups_get_grouping_by_idnumber($courseid, $idnumber) {
 149     if (empty($idnumber)) {
 150         return false;
 151     }
 152     $data = groups_get_course_data($courseid);
 153     foreach ($data->groupings as $grouping) {
 154         if ($grouping->idnumber == $idnumber) {
 155             return $grouping;
 156         }
 157     }
 158     return false;
 159 }
 160
 161 /**
 162  * Get the group object
 163  *
 164  * @category group
 165  * @param int $groupid ID of the group.
 166  * @param string $fields (default is all fields)
 167  * @param int $strictness (IGNORE_MISSING - default)
 168  * @return stdGlass group object
 169  */
 170 function groups_get_group($groupid, $fields='*', $strictness=IGNORE_MISSING) {
 171     global $DB;
 172     return $DB->get_record('groups', array('id'=>$groupid), $fields, $strictness);
 173 }
 174
 175 /**
 176  * Get the grouping object
 177  *
 178  * @category group
 179  * @param int $groupingid ID of the group.
 180  * @param string $fields
 181  * @param int $strictness (IGNORE_MISSING - default)
 182  * @return stdClass group object
 183  */
 184 function groups_get_grouping($groupingid, $fields='*', $strictness=IGNORE_MISSING) {
 185     global $DB;
 186     return $DB->get_record('groupings', array('id'=>$groupingid), $fields, $strictness);
 187 }
 188
 189 /**
 190  * Gets array of all groups in a specified course.
 191  *
 192  * @category group
 193  * @param int $courseid The id of the course.
 194  * @param mixed $userid optional user id or array of ids, returns only groups of the user.
 195  * @param int $groupingid optional returns only groups in the specified grouping.
 196  * @param string $fields
 197  * @return array Returns an array of the group objects (userid field returned if array in $userid)
 198  */
 199 function groups_get_all_groups($courseid, $userid=0, $groupingid=0, $fields='g.*') {
 200     global $DB;
 201
 202     // We need to check that we each field in the fields list belongs to the group table and that it has not being
 203     // aliased. If its something else we need to avoid the cache and run the query as who knows whats going on.
 204     $knownfields = true;
 205     if ($fields !== 'g.*') {
 206         $fieldbits = explode(',', $fields);
 207         foreach ($fieldbits as $bit) {
 208             $bit = trim($bit);
 209             if (strpos($bit, 'g.') !== 0 or stripos($bit, ' AS ') !== false) {
 210                 $knownfields = false;
 211                 break;
 212             }
 213         }
 214     }
 215
 216     if (empty($userid) && $knownfields) {
 217         // We can use the cache.
 218         $data = groups_get_course_data($courseid);
 219         if (empty($groupingid)) {
 220             // All groups.. Easy!
 221             $groups = $data->groups;
 222         } else {
 223             $groups = array();
 224             foreach ($data->mappings as $mapping) {
 225                 if ($mapping->groupingid != $groupingid) {
 226                     continue;
 227                 }
 228                 if (isset($data->groups[$mapping->groupid])) {
 229                     $groups[$mapping->groupid] = $data->groups[$mapping->groupid];
 230                 }
 231             }
 232         }
 233         // Yay! We could use the cache. One more query saved.
 234         return $groups;
 235     }
 236
 237
 238     if (empty($userid)) {
 239         $userfrom  = "";
 240         $userwhere = "";
 241         $params = array();
 242
 243     } else {
 244         list($usql, $params) = $DB->get_in_or_equal($userid);
 245         $userfrom  = ", {groups_members} gm";
 246         $userwhere = "AND g.id = gm.groupid AND gm.userid $usql";
 247     }
 248
 249     if (!empty($groupingid)) {
 250         $groupingfrom  = ", {groupings_groups} gg";
 251         $groupingwhere = "AND g.id = gg.groupid AND gg.groupingid = ?";
 252         $params[] = $groupingid;
 253     } else {
 254         $groupingfrom  = "";
 255         $groupingwhere = "";
 256     }
 257
 258     array_unshift($params, $courseid);
 259
 260     return $DB->get_records_sql("SELECT $fields
 261                                    FROM {groups} g $userfrom $groupingfrom
 262                                   WHERE g.courseid = ? $userwhere $groupingwhere
 263                                ORDER BY name ASC", $params);
 264 }
 265
 266
 267 /**
 268  * Gets array of all groups in current user.
 269  *
 270  * @since Moodle 2.5
 271  * @category group
 272  * @return array Returns an array of the group objects.
 273  */
 274 function groups_get_my_groups() {
 275     global $DB, $USER;
 276     return $DB->get_records_sql("SELECT *
 277                                    FROM {groups_members} gm
 278                                    JOIN {groups} g
 279                                     ON g.id = gm.groupid
 280                                   WHERE gm.userid = ?
 281                                    ORDER BY name ASC", array($USER->id));
 282 }
 283
 284 /**
 285  * Returns info about user's groups in course.
 286  *
 287  * @category group
 288  * @param int $courseid
 289  * @param int $userid $USER if not specified
 290  * @return array Array[groupingid][groupid] including grouping id 0 which means all groups
 291  */
 292 function groups_get_user_groups($courseid, $userid=0) {
 293     global $USER, $DB;
 294
 295     if (empty($userid)) {
 296         $userid = $USER->id;
 297     }
 298
 299     $sql = "SELECT g.id, gg.groupingid
 300               FROM {groups} g
 301                    JOIN {groups_members} gm   ON gm.groupid = g.id
 302               LEFT JOIN {groupings_groups} gg ON gg.groupid = g.id
 303              WHERE gm.userid = ? AND g.courseid = ?";
 304     $params = array($userid, $courseid);
 305
 306     $rs = $DB->get_recordset_sql($sql, $params);
 307
 308     if (!$rs->valid()) {
 309         $rs->close(); // Not going to iterate (but exit), close rs
 310         return array('0' => array());
 311     }
 312
 313     $result    = array();
 314     $allgroups = array();
 315
 316     foreach ($rs as $group) {
 317         $allgroups[$group->id] = $group->id;
 318         if (is_null($group->groupingid)) {
 319             continue;
 320         }
 321         if (!array_key_exists($group->groupingid, $result)) {
 322             $result[$group->groupingid] = array();
 323         }
 324         $result[$group->groupingid][$group->id] = $group->id;
 325     }
 326     $rs->close();
 327
 328     $result['0'] = array_keys($allgroups); // all groups
 329
 330     return $result;
 331 }
 332
 333 /**
 334  * Gets an array of all groupings in a specified course. This value is cached
 335  * for a single course (so you can call it repeatedly for the same course
 336  * without a performance penalty).
 337  *
 338  * @category group
 339  * @param int $courseid return all groupings from course with this courseid
 340  * @return array Returns an array of the grouping objects (empty if none)
 341  */
 342 function groups_get_all_groupings($courseid) {
 343     $data = groups_get_course_data($courseid);
 344     return $data->groupings;
 345 }
 346
 347 /**
 348  * Determines if the user is a member of the given group.
 349  *
 350  * If $userid is null, use the global object.
 351  *
 352  * @category group
 353  * @param int $groupid The group to check for membership.
 354  * @param int $userid The user to check against the group.
 355  * @return bool True if the user is a member, false otherwise.
 356  */
 357 function groups_is_member($groupid, $userid=null) {
 358     global $USER, $DB;
 359
 360     if (!$userid) {
 361         $userid = $USER->id;
 362     }
 363
 364     return $DB->record_exists('groups_members', array('groupid'=>$groupid, 'userid'=>$userid));
 365 }
 366
 367 /**
 368  * Determines if current or specified is member of any active group in activity
 369  *
 370  * @category group
 371  * @staticvar array $cache
 372  * @param cm_info $cm course module object
 373  * @param int $userid id of user, null means $USER->id
 374  * @return bool true if user member of at least one group used in activity
 375  */
 376 function groups_has_membership($cm, $userid=null) {
 377     global $CFG, $USER, $DB;
 378
 379     static $cache = array();
 380
 381     if (empty($userid)) {
 382         $userid = $USER->id;
 383     }
 384
 385     $cachekey = $userid.'|'.$cm->course.'|'.$cm->groupingid;
 386     if (isset($cache[$cachekey])) {
 387         return($cache[$cachekey]);
 388     }
 389
 390     if ($cm->groupingid) {
 391         // find out if member of any group in selected activity grouping
 392         $sql = "SELECT 'x'
 393                   FROM {groups_members} gm, {groupings_groups} gg
 394                  WHERE gm.userid = ? AND gm.groupid = gg.groupid AND gg.groupingid = ?";
 395         $params = array($userid, $cm->groupingid);
 396
 397     } else {
 398         // no grouping used - check all groups in course
 399         $sql = "SELECT 'x'
 400                   FROM {groups_members} gm, {groups} g
 401                  WHERE gm.userid = ? AND gm.groupid = g.id AND g.courseid = ?";
 402         $params = array($userid, $cm->course);
 403     }
 404
 405     $cache[$cachekey] = $DB->record_exists_sql($sql, $params);
 406
 407     return $cache[$cachekey];
 408 }
 409
 410 /**
 411  * Returns the users in the specified group.
 412  *
 413  * @category group
 414  * @param int $groupid The groupid to get the users for
 415  * @param int $fields The fields to return
 416  * @param int $sort optional sorting of returned users
 417  * @return array|bool Returns an array of the users for the specified
 418  * group or false if no users or an error returned.
 419  */
 420 function groups_get_members($groupid, $fields='u.*', $sort='lastname ASC') {
 421     global $DB;
 422
 423     return $DB->get_records_sql("SELECT $fields
 424                                    FROM {user} u, {groups_members} gm
 425                                   WHERE u.id = gm.userid AND gm.groupid = ?
 426                                ORDER BY $sort", array($groupid));
 427 }
 428
 429
 430 /**
 431  * Returns the users in the specified grouping.
 432  *
 433  * @category group
 434  * @param int $groupingid The groupingid to get the users for
 435  * @param string $fields The fields to return
 436  * @param string $sort optional sorting of returned users
 437  * @return array|bool Returns an array of the users for the specified
 438  * group or false if no users or an error returned.
 439  */
 440 function groups_get_grouping_members($groupingid, $fields='u.*', $sort='lastname ASC') {
 441     global $DB;
 442
 443     return $DB->get_records_sql("SELECT $fields
 444                                    FROM {user} u
 445                                      INNER JOIN {groups_members} gm ON u.id = gm.userid
 446                                      INNER JOIN {groupings_groups} gg ON gm.groupid = gg.groupid
 447                                   WHERE  gg.groupingid = ?
 448                                ORDER BY $sort", array($groupingid));
 449 }
 450
 451 /**
 452  * Returns effective groupmode used in course
 453  *
 454  * @category group
 455  * @param stdClass $course course object.
 456  * @return int group mode
 457  */
 458 function groups_get_course_groupmode($course) {
 459     return $course->groupmode;
 460 }
 461
 462 /**
 463  * Returns effective groupmode used in activity, course setting
 464  * overrides activity setting if groupmodeforce enabled.
 465  *
 466  * If $cm is an instance of cm_info it is easier to use $cm->effectivegroupmode
 467  *
 468  * @category group
 469  * @param cm_info|stdClass $cm the course module object. Only the ->course and ->groupmode need to be set.
 470  * @param stdClass $course object optional course object to improve perf
 471  * @return int group mode
 472  */
 473 function groups_get_activity_groupmode($cm, $course=null) {
 474     if ($cm instanceof cm_info) {
 475         return $cm->effectivegroupmode;
 476     }
 477     if (isset($course->id) and $course->id == $cm->course) {
 478         //ok
 479     } else {
 480         // Get course object (reuse $COURSE if possible).
 481         $course = get_course($cm->course, false);
 482     }
 483
 484     return empty($course->groupmodeforce) ? $cm->groupmode : $course->groupmode;
 485 }
 486
 487 /**
 488  * Print group menu selector for course level.
 489  *
 490  * @category group
 491  * @param stdClass $course course object
 492  * @param mixed $urlroot return address. Accepts either a string or a moodle_url
 493  * @param bool $return return as string instead of printing
 494  * @return mixed void or string depending on $return param
 495  */
 496 function groups_print_course_menu($course, $urlroot, $return=false) {
 497     global $USER, $OUTPUT;
 498
 499     if (!$groupmode = $course->groupmode) {
 500         if ($return) {
 501             return '';
 502         } else {
 503             return;
 504         }
 505     }
 506
 507     $context = context_course::instance($course->id);
 508     $aag = has_capability('moodle/site:accessallgroups', $context);
 509
 510     if ($groupmode == VISIBLEGROUPS or $aag) {
 511         $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
 512     } else {
 513         $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
 514     }
 515
 516     $activegroup = groups_get_course_group($course, true, $allowedgroups);
 517
 518     $groupsmenu = array();
 519     if (!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) {
 520         $groupsmenu[0] = get_string('allparticipants');
 521     }
 522
 523     if ($allowedgroups) {
 524         foreach ($allowedgroups as $group) {
 525             $groupsmenu[$group->id] = format_string($group->name);
 526         }
 527     }
 528
 529     if ($groupmode == VISIBLEGROUPS) {
 530         $grouplabel = get_string('groupsvisible');
 531     } else {
 532         $grouplabel = get_string('groupsseparate');
 533     }
 534
 535     if ($aag and $course->defaultgroupingid) {
 536         if ($grouping = groups_get_grouping($course->defaultgroupingid)) {
 537             $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')';
 538         }
 539     }
 540
 541     if (count($groupsmenu) == 1) {
 542         $groupname = reset($groupsmenu);
 543         $output = $grouplabel.': '.$groupname;
 544     } else {
 545         $select = new single_select(new moodle_url($urlroot), 'group', $groupsmenu, $activegroup, null, 'selectgroup');
 546         $select->label = $grouplabel;
 547         $output = $OUTPUT->render($select);
 548     }
 549
 550     $output = '<div class="groupselector">'.$output.'</div>';
 551
 552     if ($return) {
 553         return $output;
 554     } else {
 555         echo $output;
 556     }
 557 }
 558
 559 /**
 560  * Generates html to print menu selector for course level, listing all groups.
 561  * Note: This api does not do any group mode check use groups_print_course_menu() instead if you want proper checks.
 562  *
 563  * @param stdclass          $course  course object.
 564  * @param string|moodle_url $urlroot return address. Accepts either a string or a moodle_url.
 565  * @param bool              $update  set this to true to update current active group based on the group param.
 566  * @param int               $activegroup Change group active to this group if $update set to true.
 567  *
 568  * @return string html or void
 569  */
 570 function groups_allgroups_course_menu($course, $urlroot, $update = false, $activegroup = 0) {
 571     global $SESSION, $OUTPUT, $USER;
 572
 573     $groupmode = groups_get_course_groupmode($course);
 574     $context = context_course::instance($course->id);
 575     $groupsmenu = array();
 576
 577     if (has_capability('moodle/site:accessallgroups', $context)) {
 578         $groupsmenu[0] = get_string('allparticipants');
 579         $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
 580     } else {
 581         $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
 582     }
 583
 584     foreach ($allowedgroups as $group) {
 585         $groupsmenu[$group->id] = format_string($group->name);
 586     }
 587
 588     if ($update) {
 589         // Init activegroup array if necessary.
 590         if (!isset($SESSION->activegroup)) {
 591             $SESSION->activegroup = array();
 592         }
 593         if (!isset($SESSION->activegroup[$course->id])) {
 594             $SESSION->activegroup[$course->id] = array(SEPARATEGROUPS => array(), VISIBLEGROUPS => array(), 'aag' => array());
 595         }
 596         if (empty($groupsmenu[$activegroup])) {
 597             $activegroup = key($groupsmenu); // Force set to one of accessible groups.
 598         }
 599         $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = $activegroup;
 600     }
 601
 602     $grouplabel = get_string('groups');
 603     if (count($groupsmenu) == 0) {
 604         return '';
 605     } else if (count($groupsmenu) == 1) {
 606         $groupname = reset($groupsmenu);
 607         $output = $grouplabel.': '.$groupname;
 608     } else {
 609         $select = new single_select(new moodle_url($urlroot), 'group', $groupsmenu, $activegroup, null, 'selectgroup');
 610         $select->label = $grouplabel;
 611         $output = $OUTPUT->render($select);
 612     }
 613
 614     return $output;
 615
 616 }
 617
 618 /**
 619  * Print group menu selector for activity.
 620  *
 621  * @category group
 622  * @param stdClass $cm course module object
 623  * @param string|moodle_url $urlroot return address that users get to if they choose an option;
 624  *   should include any parameters needed, e.g. "$CFG->wwwroot/mod/forum/view.php?id=34"
 625  * @param bool $return return as string instead of printing
 626  * @param bool $hideallparticipants If true, this prevents the 'All participants'
 627  *   option from appearing in cases where it normally would. This is intended for
 628  *   use only by activities that cannot display all groups together. (Note that
 629  *   selecting this option does not prevent groups_get_activity_group from
 630  *   returning 0; it will still do that if the user has chosen 'all participants'
 631  *   in another activity, or not chosen anything.)
 632  * @return mixed void or string depending on $return param
 633  */
 634 function groups_print_activity_menu($cm, $urlroot, $return=false, $hideallparticipants=false) {
 635     global $USER, $OUTPUT;
 636
 637     if ($urlroot instanceof moodle_url) {
 638         // no changes necessary
 639
 640     } else {
 641         if (strpos($urlroot, 'http') !== 0) { // Will also work for https
 642             // Display error if urlroot is not absolute (this causes the non-JS version to break)
 643             debugging('groups_print_activity_menu requires absolute URL for ' .
 644                       '$urlroot, not <tt>' . s($urlroot) . '</tt>. Example: ' .
 645                       'groups_print_activity_menu($cm, $CFG->wwwroot . \'/mod/mymodule/view.php?id=13\');',
 646                       DEBUG_DEVELOPER);
 647         }
 648         $urlroot = new moodle_url($urlroot);
 649     }
 650
 651     if (!$groupmode = groups_get_activity_groupmode($cm)) {
 652         if ($return) {
 653             return '';
 654         } else {
 655             return;
 656         }
 657     }
 658
 659     $context = context_module::instance($cm->id);
 660     $aag = has_capability('moodle/site:accessallgroups', $context);
 661
 662     if ($groupmode == VISIBLEGROUPS or $aag) {
 663         $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid); // any group in grouping
 664     } else {
 665         $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid); // only assigned groups
 666     }
 667
 668     $activegroup = groups_get_activity_group($cm, true, $allowedgroups);
 669
 670     $groupsmenu = array();
 671     if ((!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) and !$hideallparticipants) {
 672         $groupsmenu[0] = get_string('allparticipants');
 673     }
 674
 675     if ($allowedgroups) {
 676         foreach ($allowedgroups as $group) {
 677             $groupsmenu[$group->id] = format_string($group->name);
 678         }
 679     }
 680
 681     if ($groupmode == VISIBLEGROUPS) {
 682         $grouplabel = get_string('groupsvisible');
 683     } else {
 684         $grouplabel = get_string('groupsseparate');
 685     }
 686
 687     if ($aag and $cm->groupingid) {
 688         if ($grouping = groups_get_grouping($cm->groupingid)) {
 689             $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')';
 690         }
 691     }
 692
 693     if (count($groupsmenu) == 1) {
 694         $groupname = reset($groupsmenu);
 695         $output = $grouplabel.': '.$groupname;
 696     } else {
 697         $select = new single_select($urlroot, 'group', $groupsmenu, $activegroup, null, 'selectgroup');
 698         $select->label = $grouplabel;
 699         $output = $OUTPUT->render($select);
 700     }
 701
 702     $output = '<div class="groupselector">'.$output.'</div>';
 703
 704     if ($return) {
 705         return $output;
 706     } else {
 707         echo $output;
 708     }
 709 }
 710
 711 /**
 712  * Returns group active in course, changes the group by default if 'group' page param present
 713  *
 714  * @category group
 715  * @param stdClass $course course bject
 716  * @param bool $update change active group if group param submitted
 717  * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_course_menu())
 718  * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
 719  */
 720 function groups_get_course_group($course, $update=false, $allowedgroups=null) {
 721     global $USER, $SESSION;
 722
 723     if (!$groupmode = $course->groupmode) {
 724         // NOGROUPS used
 725         return false;
 726     }
 727
 728     $context = context_course::instance($course->id);
 729     if (has_capability('moodle/site:accessallgroups', $context)) {
 730         $groupmode = 'aag';
 731     }
 732
 733     if (!is_array($allowedgroups)) {
 734         if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
 735             $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
 736         } else {
 737             $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
 738         }
 739     }
 740
 741     _group_verify_activegroup($course->id, $groupmode, $course->defaultgroupingid, $allowedgroups);
 742
 743     // set new active group if requested
 744     $changegroup = optional_param('group', -1, PARAM_INT);
 745     if ($update and $changegroup != -1) {
 746
 747         if ($changegroup == 0) {
 748             // do not allow changing to all groups without accessallgroups capability
 749             if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
 750                 $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = 0;
 751             }
 752
 753         } else {
 754             if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
 755                 $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = $changegroup;
 756             }
 757         }
 758     }
 759
 760     return $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid];
 761 }
 762
 763 /**
 764  * Returns group active in activity, changes the group by default if 'group' page param present
 765  *
 766  * @category group
 767  * @param stdClass $cm course module object
 768  * @param bool $update change active group if group param submitted
 769  * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_activity_menu())
 770  * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
 771  */
 772 function groups_get_activity_group($cm, $update=false, $allowedgroups=null) {
 773     global $USER, $SESSION;
 774
 775     if (!$groupmode = groups_get_activity_groupmode($cm)) {
 776         // NOGROUPS used
 777         return false;
 778     }
 779
 780     $context = context_module::instance($cm->id);
 781     if (has_capability('moodle/site:accessallgroups', $context)) {
 782         $groupmode = 'aag';
 783     }
 784
 785     if (!is_array($allowedgroups)) {
 786         if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
 787             $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid);
 788         } else {
 789             $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid);
 790         }
 791     }
 792
 793     _group_verify_activegroup($cm->course, $groupmode, $cm->groupingid, $allowedgroups);
 794
 795     // set new active group if requested
 796     $changegroup = optional_param('group', -1, PARAM_INT);
 797     if ($update and $changegroup != -1) {
 798
 799         if ($changegroup == 0) {
 800             // allgroups visible only in VISIBLEGROUPS or when accessallgroups
 801             if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
 802                 $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = 0;
 803             }
 804
 805         } else {
 806             if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
 807                 $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = $changegroup;
 808             }
 809         }
 810     }
 811
 812     return $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid];
 813 }
 814
 815 /**
 816  * Gets a list of groups that the user is allowed to access within the
 817  * specified activity.
 818  *
 819  * @category group
 820  * @param stdClass $cm Course-module
 821  * @param int $userid User ID (defaults to current user)
 822  * @return array An array of group objects, or false if none
 823  */
 824 function groups_get_activity_allowed_groups($cm,$userid=0) {
 825     // Use current user by default
 826     global $USER;
 827     if(!$userid) {
 828         $userid=$USER->id;
 829     }
 830
 831     // Get groupmode for activity, taking into account course settings
 832     $groupmode=groups_get_activity_groupmode($cm);
 833
 834     // If visible groups mode, or user has the accessallgroups capability,
 835     // then they can access all groups for the activity...
 836     $context = context_module::instance($cm->id);
 837     if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context, $userid)) {
 838         return groups_get_all_groups($cm->course, 0, $cm->groupingid);
 839     } else {
 840         // ...otherwise they can only access groups they belong to
 841         return groups_get_all_groups($cm->course, $userid, $cm->groupingid);
 842     }
 843 }
 844
 845 /**
 846  * Determine if a course module is currently visible to a user
 847  *
 848  * $USER If $userid is null, use the global object.
 849  *
 850  * @category group
 851  * @param stdClass $cm The course module
 852  * @param int $userid The user to check against the group.
 853  * @return bool True if the user can view the course module, false otherwise.
 854  */
 855 function groups_course_module_visible($cm, $userid=null) {
 856     global $CFG, $USER;
 857
 858     if (empty($userid)) {
 859         $userid = $USER->id;
 860     }
 861     if (empty($CFG->enablegroupmembersonly)) {
 862         return true;
 863     }
 864     if (empty($cm->groupmembersonly)) {
 865         return true;
 866     }
 867     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id), $userid) or groups_has_membership($cm, $userid)) {
 868         return true;
 869     }
 870     return false;
 871 }
 872
 873 /**
 874  * Determine if a given group is visible to user or not in a given context.
 875  *
 876  * @since Moodle 2.6
 877  * @param int      $groupid Group id to test. 0 for all groups.
 878  * @param stdClass $course  Course object.
 879  * @param stdClass $cm      Course module object.
 880  * @param int      $userid  user id to test against. Defaults to $USER.
 881  * @return boolean true if visible, false otherwise
 882  */
 883 function groups_group_visible($groupid, $course, $cm = null, $userid = null) {
 884     global $USER;
 885
 886     if (empty($userid)) {
 887         $userid = $USER->id;
 888     }
 889
 890     $groupmode = empty($cm) ? groups_get_course_groupmode($course) : groups_get_activity_groupmode($cm, $course);
 891     if ($groupmode == NOGROUPS || $groupmode == VISIBLEGROUPS) {
 892         // Groups are not used, or everything is visible, no need to go any further.
 893         return true;
 894     }
 895
 896     $context = empty($cm) ? context_course::instance($course->id) : context_module::instance($cm->id);
 897     if (has_capability('moodle/site:accessallgroups', $context, $userid)) {
 898         // User can see everything. Groupid = 0 is handled here as well.
 899         return true;
 900     } else if ($groupid != 0) {
 901         // Group mode is separate, and user doesn't have access all groups capability. Check if user can see requested group.
 902         $groups = empty($cm) ? groups_get_all_groups($course->id, $userid) : groups_get_activity_allowed_groups($cm, $userid);
 903         if (array_key_exists($groupid, $groups)) {
 904             // User can see the group.
 905             return true;
 906         }
 907     }
 908     return false;
 909 }
 910
 911 /**
 912  * Internal method, sets up $SESSION->activegroup and verifies previous value
 913  *
 914  * @param int $courseid
 915  * @param int|string $groupmode SEPARATEGROUPS, VISIBLEGROUPS or 'aag' (access all groups)
 916  * @param int $groupingid 0 means all groups
 917  * @param array $allowedgroups list of groups user can see
 918  */
 919 function _group_verify_activegroup($courseid, $groupmode, $groupingid, array $allowedgroups) {
 920     global $SESSION, $USER;
 921
 922     // init activegroup array if necessary
 923     if (!isset($SESSION->activegroup)) {
 924         $SESSION->activegroup = array();
 925     }
 926     if (!array_key_exists($courseid, $SESSION->activegroup)) {
 927         $SESSION->activegroup[$courseid] = array(SEPARATEGROUPS=>array(), VISIBLEGROUPS=>array(), 'aag'=>array());
 928     }
 929
 930     // make sure that the current group info is ok
 931     if (array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode]) and !array_key_exists($SESSION->activegroup[$courseid][$groupmode][$groupingid], $allowedgroups)) {
 932         // active group does not exist anymore or is 0
 933         if ($SESSION->activegroup[$courseid][$groupmode][$groupingid] > 0 or $groupmode == SEPARATEGROUPS) {
 934             // do not do this if all groups selected and groupmode is not separate
 935             unset($SESSION->activegroup[$courseid][$groupmode][$groupingid]);
 936         }
 937     }
 938
 939     // set up defaults if necessary
 940     if (!array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode])) {
 941         if ($groupmode == 'aag') {
 942             $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0; // all groups by default if user has accessallgroups
 943
 944         } else if ($allowedgroups) {
 945             if ($groupmode != SEPARATEGROUPS and $mygroups = groups_get_all_groups($courseid, $USER->id, $groupingid)) {
 946                 $firstgroup = reset($mygroups);
 947             } else {
 948                 $firstgroup = reset($allowedgroups);
 949             }
 950             $SESSION->activegroup[$courseid][$groupmode][$groupingid] = $firstgroup->id;
 951
 952         } else {
 953             // this happen when user not assigned into group in SEPARATEGROUPS mode or groups do not exist yet
 954             // mod authors must add extra checks for this when SEPARATEGROUPS mode used (such as when posting to forum)
 955             $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0;
 956         }
 957     }
 958 }
 959
 960 /**
 961  * Caches group data for a particular course to speed up subsequent requests.
 962  *
 963  * @param int $courseid The course id to cache data for.
 964  * @param cache $cache The cache if it has already been initialised. If not a new one will be created.
 965  * @return stdClass A data object containing groups, groupings, and mappings.
 966  */
 967 function groups_cache_groupdata($courseid, cache $cache = null) {
 968     global $DB;
 969
 970     if ($cache === null) {
 971         // Initialise a cache if we wern't given one.
 972         $cache = cache::make('core', 'groupdata');
 973     }
 974
 975     // Get the groups that belong to the course.
 976     $groups = $DB->get_records('groups', array('courseid' => $courseid), 'name ASC');
 977     // Get the groupings that belong to the course.
 978     $groupings = $DB->get_records('groupings', array('courseid' => $courseid), 'name ASC');
 979
 980     if (!is_array($groups)) {
 981         $groups = array();
 982     }
 983
 984     if (!is_array($groupings)) {
 985         $groupings = array();
 986     }
 987
 988     if (!empty($groupings)) {
 989         // Finally get the mappings between the two.
 990         $mappings = $DB->get_records_list('groupings_groups', 'groupingid', array_keys($groupings), '', 'id,groupingid,groupid');
 991     } else {
 992         $mappings = array();
 993     }
 994
 995     // Prepare the data array.
 996     $data = new stdClass;
 997     $data->groups = $groups;
 998     $data->groupings = $groupings;
 999     $data->mappings = $mappings;
1000     // Cache the data.
1001     $cache->set($courseid, $data);
1002     // Finally return it so it can be used if desired.
1003     return $data;
1004 }
1005
1006 /**
1007  * Gets group data for a course.
1008  *
1009  * This returns an object with the following properties:
1010  *   - groups : An array of all the groups in the course.
1011  *   - groupings : An array of all the groupings within the course.
1012  *   - mappings : An array of group to grouping mappings.
1013  *
1014  * @param int $courseid The course id to get data for.
1015  * @param cache $cache The cache if it has already been initialised. If not a new one will be created.
1016  * @return stdClass
1017  */
1018 function groups_get_course_data($courseid, cache $cache = null) {
1019     if ($cache === null) {
1020         // Initialise a cache if we wern't given one.
1021         $cache = cache::make('core', 'groupdata');
1022     }
1023     // Try to retrieve it from the cache.
1024     $data = $cache->get($courseid);
1025     if ($data === false) {
1026         $data = groups_cache_groupdata($courseid, $cache);
1027     }
1028     return $data;
1029 }