MDL-40897 avoid extra DB queries in groups_get_activity_groupmode()
[moodle.git] / lib / grouplib.php
1 <?php
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/>.
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  */
24 defined('MOODLE_INTERNAL') || die();
26 /**
27  * Groups not used in course or activity
28  */
29 define('NOGROUPS', 0);
31 /**
32  * Groups used, users do not see other groups
33  */
34 define('SEPARATEGROUPS', 1);
36 /**
37  * Groups used, students see other groups
38  */
39 define('VISIBLEGROUPS', 2);
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 }
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 }
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 }
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 }
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;
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;
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;
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);
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);
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;
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     }
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     }
238     if (empty($userid)) {
239         $userfrom  = "";
240         $userwhere = "";
241         $params = array();
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     }
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     }
258     array_unshift($params, $courseid);
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);
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));
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;
295     if (empty($userid)) {
296         $userid = $USER->id;
297     }
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);
306     $rs = $DB->get_recordset_sql($sql, $params);
308     if (!$rs->valid()) {
309         $rs->close(); // Not going to iterate (but exit), close rs
310         return array('0' => array());
311     }
313     $result    = array();
314     $allgroups = array();
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();
328     $result['0'] = array_keys($allgroups); // all groups
330     return $result;
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;
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;
360     if (!$userid) {
361         $userid = $USER->id;
362     }
364     return $DB->record_exists('groups_members', array('groupid'=>$groupid, 'userid'=>$userid));
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;
379     static $cache = array();
381     if (empty($userid)) {
382         $userid = $USER->id;
383     }
385     $cachekey = $userid.'|'.$cm->course.'|'.$cm->groupingid;
386     if (isset($cache[$cachekey])) {
387         return($cache[$cachekey]);
388     }
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);
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     }
405     $cache[$cachekey] = $DB->record_exists_sql($sql, $params);
407     return $cache[$cachekey];
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;
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));
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;
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));
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;
462 /**
463  * Returns effective groupmode used in activity, course setting
464  * overrides activity setting if groupmodeforce enabled.
465  *
466  * @category group
467  * @param cm_info|stdClass $cm the course module object. Only the ->course and ->groupmode need to be set.
468  * @param stdClass $course object optional course object to improve perf
469  * @return int group mode
470  */
471 function groups_get_activity_groupmode($cm, $course=null) {
472     if (isset($course->id) and $course->id == $cm->course) {
473         //ok
474     } else if (isset($cm->coursegroupmode) && isset($cm->coursegroupmodeforce)) {
475         // This is an instance of cm_info (or clone) and already has the necessary course fields in it.
476         return empty($cm->coursegroupmodeforce) ? $cm->groupmode : $cm->coursegroupmode;
477     } else {
478         // Get course object (reuse $COURSE if possible).
479         $course = get_course($cm->course, false);
480     }
482     return empty($course->groupmodeforce) ? $cm->groupmode : $course->groupmode;
485 /**
486  * Print group menu selector for course level.
487  *
488  * @category group
489  * @param stdClass $course course object
490  * @param mixed $urlroot return address. Accepts either a string or a moodle_url
491  * @param bool $return return as string instead of printing
492  * @return mixed void or string depending on $return param
493  */
494 function groups_print_course_menu($course, $urlroot, $return=false) {
495     global $USER, $OUTPUT;
497     if (!$groupmode = $course->groupmode) {
498         if ($return) {
499             return '';
500         } else {
501             return;
502         }
503     }
505     $context = context_course::instance($course->id);
506     $aag = has_capability('moodle/site:accessallgroups', $context);
508     if ($groupmode == VISIBLEGROUPS or $aag) {
509         $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
510     } else {
511         $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
512     }
514     $activegroup = groups_get_course_group($course, true, $allowedgroups);
516     $groupsmenu = array();
517     if (!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) {
518         $groupsmenu[0] = get_string('allparticipants');
519     }
521     if ($allowedgroups) {
522         foreach ($allowedgroups as $group) {
523             $groupsmenu[$group->id] = format_string($group->name);
524         }
525     }
527     if ($groupmode == VISIBLEGROUPS) {
528         $grouplabel = get_string('groupsvisible');
529     } else {
530         $grouplabel = get_string('groupsseparate');
531     }
533     if ($aag and $course->defaultgroupingid) {
534         if ($grouping = groups_get_grouping($course->defaultgroupingid)) {
535             $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')';
536         }
537     }
539     if (count($groupsmenu) == 1) {
540         $groupname = reset($groupsmenu);
541         $output = $grouplabel.': '.$groupname;
542     } else {
543         $select = new single_select(new moodle_url($urlroot), 'group', $groupsmenu, $activegroup, null, 'selectgroup');
544         $select->label = $grouplabel;
545         $output = $OUTPUT->render($select);
546     }
548     $output = '<div class="groupselector">'.$output.'</div>';
550     if ($return) {
551         return $output;
552     } else {
553         echo $output;
554     }
557 /**
558  * Print group menu selector for activity.
559  *
560  * @category group
561  * @param stdClass $cm course module object
562  * @param string|moodle_url $urlroot return address that users get to if they choose an option;
563  *   should include any parameters needed, e.g. "$CFG->wwwroot/mod/forum/view.php?id=34"
564  * @param bool $return return as string instead of printing
565  * @param bool $hideallparticipants If true, this prevents the 'All participants'
566  *   option from appearing in cases where it normally would. This is intended for
567  *   use only by activities that cannot display all groups together. (Note that
568  *   selecting this option does not prevent groups_get_activity_group from
569  *   returning 0; it will still do that if the user has chosen 'all participants'
570  *   in another activity, or not chosen anything.)
571  * @return mixed void or string depending on $return param
572  */
573 function groups_print_activity_menu($cm, $urlroot, $return=false, $hideallparticipants=false) {
574     global $USER, $OUTPUT;
576     if ($urlroot instanceof moodle_url) {
577         // no changes necessary
579     } else {
580         if (strpos($urlroot, 'http') !== 0) { // Will also work for https
581             // Display error if urlroot is not absolute (this causes the non-JS version to break)
582             debugging('groups_print_activity_menu requires absolute URL for ' .
583                       '$urlroot, not <tt>' . s($urlroot) . '</tt>. Example: ' .
584                       'groups_print_activity_menu($cm, $CFG->wwwroot . \'/mod/mymodule/view.php?id=13\');',
585                       DEBUG_DEVELOPER);
586         }
587         $urlroot = new moodle_url($urlroot);
588     }
590     if (!$groupmode = groups_get_activity_groupmode($cm)) {
591         if ($return) {
592             return '';
593         } else {
594             return;
595         }
596     }
598     $context = context_module::instance($cm->id);
599     $aag = has_capability('moodle/site:accessallgroups', $context);
601     if ($groupmode == VISIBLEGROUPS or $aag) {
602         $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid); // any group in grouping
603     } else {
604         $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid); // only assigned groups
605     }
607     $activegroup = groups_get_activity_group($cm, true, $allowedgroups);
609     $groupsmenu = array();
610     if ((!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) and !$hideallparticipants) {
611         $groupsmenu[0] = get_string('allparticipants');
612     }
614     if ($allowedgroups) {
615         foreach ($allowedgroups as $group) {
616             $groupsmenu[$group->id] = format_string($group->name);
617         }
618     }
620     if ($groupmode == VISIBLEGROUPS) {
621         $grouplabel = get_string('groupsvisible');
622     } else {
623         $grouplabel = get_string('groupsseparate');
624     }
626     if ($aag and $cm->groupingid) {
627         if ($grouping = groups_get_grouping($cm->groupingid)) {
628             $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')';
629         }
630     }
632     if (count($groupsmenu) == 1) {
633         $groupname = reset($groupsmenu);
634         $output = $grouplabel.': '.$groupname;
635     } else {
636         $select = new single_select($urlroot, 'group', $groupsmenu, $activegroup, null, 'selectgroup');
637         $select->label = $grouplabel;
638         $output = $OUTPUT->render($select);
639     }
641     $output = '<div class="groupselector">'.$output.'</div>';
643     if ($return) {
644         return $output;
645     } else {
646         echo $output;
647     }
650 /**
651  * Returns group active in course, changes the group by default if 'group' page param present
652  *
653  * @category group
654  * @param stdClass $course course bject
655  * @param bool $update change active group if group param submitted
656  * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_course_menu())
657  * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
658  */
659 function groups_get_course_group($course, $update=false, $allowedgroups=null) {
660     global $USER, $SESSION;
662     if (!$groupmode = $course->groupmode) {
663         // NOGROUPS used
664         return false;
665     }
667     $context = context_course::instance($course->id);
668     if (has_capability('moodle/site:accessallgroups', $context)) {
669         $groupmode = 'aag';
670     }
672     if (!is_array($allowedgroups)) {
673         if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
674             $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
675         } else {
676             $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
677         }
678     }
680     _group_verify_activegroup($course->id, $groupmode, $course->defaultgroupingid, $allowedgroups);
682     // set new active group if requested
683     $changegroup = optional_param('group', -1, PARAM_INT);
684     if ($update and $changegroup != -1) {
686         if ($changegroup == 0) {
687             // do not allow changing to all groups without accessallgroups capability
688             if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
689                 $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = 0;
690             }
692         } else {
693             if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
694                 $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = $changegroup;
695             }
696         }
697     }
699     return $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid];
702 /**
703  * Returns group active in activity, changes the group by default if 'group' page param present
704  *
705  * @category group
706  * @param stdClass $cm course module object
707  * @param bool $update change active group if group param submitted
708  * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_activity_menu())
709  * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
710  */
711 function groups_get_activity_group($cm, $update=false, $allowedgroups=null) {
712     global $USER, $SESSION;
714     if (!$groupmode = groups_get_activity_groupmode($cm)) {
715         // NOGROUPS used
716         return false;
717     }
719     $context = context_module::instance($cm->id);
720     if (has_capability('moodle/site:accessallgroups', $context)) {
721         $groupmode = 'aag';
722     }
724     if (!is_array($allowedgroups)) {
725         if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
726             $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid);
727         } else {
728             $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid);
729         }
730     }
732     _group_verify_activegroup($cm->course, $groupmode, $cm->groupingid, $allowedgroups);
734     // set new active group if requested
735     $changegroup = optional_param('group', -1, PARAM_INT);
736     if ($update and $changegroup != -1) {
738         if ($changegroup == 0) {
739             // allgroups visible only in VISIBLEGROUPS or when accessallgroups
740             if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
741                 $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = 0;
742             }
744         } else {
745             if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
746                 $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = $changegroup;
747             }
748         }
749     }
751     return $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid];
754 /**
755  * Gets a list of groups that the user is allowed to access within the
756  * specified activity.
757  *
758  * @category group
759  * @param stdClass $cm Course-module
760  * @param int $userid User ID (defaults to current user)
761  * @return array An array of group objects, or false if none
762  */
763 function groups_get_activity_allowed_groups($cm,$userid=0) {
764     // Use current user by default
765     global $USER;
766     if(!$userid) {
767         $userid=$USER->id;
768     }
770     // Get groupmode for activity, taking into account course settings
771     $groupmode=groups_get_activity_groupmode($cm);
773     // If visible groups mode, or user has the accessallgroups capability,
774     // then they can access all groups for the activity...
775     $context = context_module::instance($cm->id);
776     if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context, $userid)) {
777         return groups_get_all_groups($cm->course, 0, $cm->groupingid);
778     } else {
779         // ...otherwise they can only access groups they belong to
780         return groups_get_all_groups($cm->course, $userid, $cm->groupingid);
781     }
784 /**
785  * Determine if a course module is currently visible to a user
786  *
787  * $USER If $userid is null, use the global object.
788  *
789  * @category group
790  * @param stdClass $cm The course module
791  * @param int $userid The user to check against the group.
792  * @return bool True if the user can view the course module, false otherwise.
793  */
794 function groups_course_module_visible($cm, $userid=null) {
795     global $CFG, $USER;
797     if (empty($userid)) {
798         $userid = $USER->id;
799     }
800     if (empty($CFG->enablegroupmembersonly)) {
801         return true;
802     }
803     if (empty($cm->groupmembersonly)) {
804         return true;
805     }
806     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id), $userid) or groups_has_membership($cm, $userid)) {
807         return true;
808     }
809     return false;
812 /**
813  * Determine if a given group is visible to user or not in a given context.
814  *
815  * @since Moodle 2.6
816  * @param int      $groupid Group id to test. 0 for all groups.
817  * @param stdClass $course  Course object.
818  * @param stdClass $cm      Course module object.
819  * @param int      $userid  user id to test against. Defaults to $USER.
820  * @return boolean true if visible, false otherwise
821  */
822 function groups_group_visible($groupid, $course, $cm = null, $userid = null) {
823     global $USER;
825     if (empty($userid)) {
826         $userid = $USER->id;
827     }
829     $groupmode = empty($cm) ? groups_get_course_groupmode($course) : groups_get_activity_groupmode($cm, $course);
830     if ($groupmode == NOGROUPS || $groupmode == VISIBLEGROUPS) {
831         // Groups are not used, or everything is visible, no need to go any further.
832         return true;
833     }
835     $context = empty($cm) ? context_course::instance($course->id) : context_module::instance($cm->id);
836     if (has_capability('moodle/site:accessallgroups', $context, $userid)) {
837         // User can see everything. Groupid = 0 is handled here as well.
838         return true;
839     } else if ($groupid != 0) {
840         // Group mode is separate, and user doesn't have access all groups capability. Check if user can see requested group.
841         $groups = empty($cm) ? groups_get_all_groups($course->id, $userid) : groups_get_activity_allowed_groups($cm, $userid);
842         if (array_key_exists($groupid, $groups)) {
843             // User can see the group.
844             return true;
845         }
846     }
847     return false;
850 /**
851  * Internal method, sets up $SESSION->activegroup and verifies previous value
852  *
853  * @param int $courseid
854  * @param int|string $groupmode SEPARATEGROUPS, VISIBLEGROUPS or 'aag' (access all groups)
855  * @param int $groupingid 0 means all groups
856  * @param array $allowedgroups list of groups user can see
857  */
858 function _group_verify_activegroup($courseid, $groupmode, $groupingid, array $allowedgroups) {
859     global $SESSION, $USER;
861     // init activegroup array if necessary
862     if (!isset($SESSION->activegroup)) {
863         $SESSION->activegroup = array();
864     }
865     if (!array_key_exists($courseid, $SESSION->activegroup)) {
866         $SESSION->activegroup[$courseid] = array(SEPARATEGROUPS=>array(), VISIBLEGROUPS=>array(), 'aag'=>array());
867     }
869     // make sure that the current group info is ok
870     if (array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode]) and !array_key_exists($SESSION->activegroup[$courseid][$groupmode][$groupingid], $allowedgroups)) {
871         // active group does not exist anymore or is 0
872         if ($SESSION->activegroup[$courseid][$groupmode][$groupingid] > 0 or $groupmode == SEPARATEGROUPS) {
873             // do not do this if all groups selected and groupmode is not separate
874             unset($SESSION->activegroup[$courseid][$groupmode][$groupingid]);
875         }
876     }
878     // set up defaults if necessary
879     if (!array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode])) {
880         if ($groupmode == 'aag') {
881             $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0; // all groups by default if user has accessallgroups
883         } else if ($allowedgroups) {
884             if ($groupmode != SEPARATEGROUPS and $mygroups = groups_get_all_groups($courseid, $USER->id, $groupingid)) {
885                 $firstgroup = reset($mygroups);
886             } else {
887                 $firstgroup = reset($allowedgroups);
888             }
889             $SESSION->activegroup[$courseid][$groupmode][$groupingid] = $firstgroup->id;
891         } else {
892             // this happen when user not assigned into group in SEPARATEGROUPS mode or groups do not exist yet
893             // mod authors must add extra checks for this when SEPARATEGROUPS mode used (such as when posting to forum)
894             $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0;
895         }
896     }
899 /**
900  * Caches group data for a particular course to speed up subsequent requests.
901  *
902  * @param int $courseid The course id to cache data for.
903  * @param cache $cache The cache if it has already been initialised. If not a new one will be created.
904  * @return stdClass A data object containing groups, groupings, and mappings.
905  */
906 function groups_cache_groupdata($courseid, cache $cache = null) {
907     global $DB;
909     if ($cache === null) {
910         // Initialise a cache if we wern't given one.
911         $cache = cache::make('core', 'groupdata');
912     }
914     // Get the groups that belong to the course.
915     $groups = $DB->get_records('groups', array('courseid' => $courseid), 'name ASC');
916     // Get the groupings that belong to the course.
917     $groupings = $DB->get_records('groupings', array('courseid' => $courseid), 'name ASC');
919     if (!is_array($groups)) {
920         $groups = array();
921     }
923     if (!is_array($groupings)) {
924         $groupings = array();
925     }
927     if (!empty($groupings)) {
928         // Finally get the mappings between the two.
929         $mappings = $DB->get_records_list('groupings_groups', 'groupingid', array_keys($groupings), '', 'id,groupingid,groupid');
930     } else {
931         $mappings = array();
932     }
934     // Prepare the data array.
935     $data = new stdClass;
936     $data->groups = $groups;
937     $data->groupings = $groupings;
938     $data->mappings = $mappings;
939     // Cache the data.
940     $cache->set($courseid, $data);
941     // Finally return it so it can be used if desired.
942     return $data;
945 /**
946  * Gets group data for a course.
947  *
948  * This returns an object with the following properties:
949  *   - groups : An array of all the groups in the course.
950  *   - groupings : An array of all the groupings within the course.
951  *   - mappings : An array of group to grouping mappings.
952  *
953  * @param int $courseid The course id to get data for.
954  * @param cache $cache The cache if it has already been initialised. If not a new one will be created.
955  * @return stdClass
956  */
957 function groups_get_course_data($courseid, cache $cache = null) {
958     if ($cache === null) {
959         // Initialise a cache if we wern't given one.
960         $cache = cache::make('core', 'groupdata');
961     }
962     // Try to retrieve it from the cache.
963     $data = $cache->get($courseid);
964     if ($data === false) {
965         $data = groups_cache_groupdata($courseid, $cache);
966     }
967     return $data;