MDL-24419 (2): Moved groupings cache to get_all_groupings function
[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     global $DB;
90     if ($groups = $DB->get_records('groups', array('courseid'=>$courseid, 'name'=>$name))) {
91         return key($groups);
92     }
93     return false;
94 }
96 /**
97  * Returns the groupingid of a grouping with the name specified for the course.
98  * Grouping names should be unique in course
99  *
100  * @category group
101  * @param int $courseid The id of the course
102  * @param string $name name of group (without magic quotes)
103  * @return int $groupid
104  */
105 function groups_get_grouping_by_name($courseid, $name) {
106     global $DB;
107     if ($groupings = $DB->get_records('groupings', array('courseid'=>$courseid, 'name'=>$name))) {
108         return key($groupings);
109     }
110     return false;
113 /**
114  * Get the group object
115  *
116  * @category group
117  * @param int $groupid ID of the group.
118  * @param string $fields (default is all fields)
119  * @param int $strictness (IGNORE_MISSING - default)
120  * @return stdGlass group object
121  */
122 function groups_get_group($groupid, $fields='*', $strictness=IGNORE_MISSING) {
123     global $DB;
124     return $DB->get_record('groups', array('id'=>$groupid), $fields, $strictness);
127 /**
128  * Get the grouping object
129  *
130  * @category group
131  * @param int $groupingid ID of the group.
132  * @param string $fields
133  * @param int $strictness (IGNORE_MISSING - default)
134  * @return stdClass group object
135  */
136 function groups_get_grouping($groupingid, $fields='*', $strictness=IGNORE_MISSING) {
137     global $DB;
138     return $DB->get_record('groupings', array('id'=>$groupingid), $fields, $strictness);
141 /**
142  * Gets array of all groups in a specified course.
143  *
144  * @category group
145  * @param int $courseid The id of the course.
146  * @param mixed $userid optional user id or array of ids, returns only groups of the user.
147  * @param int $groupingid optional returns only groups in the specified grouping.
148  * @param string $fields
149  * @return array Returns an array of the group objects (userid field returned if array in $userid)
150  */
151 function groups_get_all_groups($courseid, $userid=0, $groupingid=0, $fields='g.*') {
152     global $DB;
154     if (empty($userid)) {
155         $userfrom  = "";
156         $userwhere = "";
157         $params = array();
159     } else {
160         list($usql, $params) = $DB->get_in_or_equal($userid);
161         $userfrom  = ", {groups_members} gm";
162         $userwhere = "AND g.id = gm.groupid AND gm.userid $usql";
163     }
165     if (!empty($groupingid)) {
166         $groupingfrom  = ", {groupings_groups} gg";
167         $groupingwhere = "AND g.id = gg.groupid AND gg.groupingid = ?";
168         $params[] = $groupingid;
169     } else {
170         $groupingfrom  = "";
171         $groupingwhere = "";
172     }
174     array_unshift($params, $courseid);
176     return $DB->get_records_sql("SELECT $fields
177                                    FROM {groups} g $userfrom $groupingfrom
178                                   WHERE g.courseid = ? $userwhere $groupingwhere
179                                ORDER BY name ASC", $params);
182 /**
183  * Returns info about user's groups in course.
184  *
185  * @category group
186  * @param int $courseid
187  * @param int $userid $USER if not specified
188  * @return array Array[groupingid][groupid] including grouping id 0 which means all groups
189  */
190 function groups_get_user_groups($courseid, $userid=0) {
191     global $USER, $DB;
193     if (empty($userid)) {
194         $userid = $USER->id;
195     }
197     $sql = "SELECT g.id, gg.groupingid
198               FROM {groups} g
199                    JOIN {groups_members} gm   ON gm.groupid = g.id
200               LEFT JOIN {groupings_groups} gg ON gg.groupid = g.id
201              WHERE gm.userid = ? AND g.courseid = ?";
202     $params = array($userid, $courseid);
204     $rs = $DB->get_recordset_sql($sql, $params);
206     if (!$rs->valid()) {
207         $rs->close(); // Not going to iterate (but exit), close rs
208         return array('0' => array());
209     }
211     $result    = array();
212     $allgroups = array();
214     foreach ($rs as $group) {
215         $allgroups[$group->id] = $group->id;
216         if (is_null($group->groupingid)) {
217             continue;
218         }
219         if (!array_key_exists($group->groupingid, $result)) {
220             $result[$group->groupingid] = array();
221         }
222         $result[$group->groupingid][$group->id] = $group->id;
223     }
224     $rs->close();
226     $result['0'] = array_keys($allgroups); // all groups
228     return $result;
231 /**
232  * Gets an array of all groupings in a specified course. This value is cached
233  * for a single course (so you can call it repeatedly for the same course
234  * without a performance penalty).
235  *
236  * @category group
237  * @param int $courseid return all groupings from course with this courseid
238  * @return array Returns an array of the grouping objects (empty if none)
239  */
240 function groups_get_all_groupings($courseid) {
241     global $CFG, $DB, $GROUPLIB_CACHE;
243     // Use cached data if available. (Note: We only cache a single request, so
244     // as not to waste memory if processing is happening for multiple courses.)
245     if (!empty($GROUPLIB_CACHE->groupings) &&
246             $GROUPLIB_CACHE->groupings->courseid == $courseid) {
247         return $GROUPLIB_CACHE->groupings->result;
248     }
249     if (empty($GROUPLIB_CACHE)) {
250         $GROUPLIB_CACHE = new stdClass();
251     }
252     $GROUPLIB_CACHE->groupings = new stdClass();
253     $GROUPLIB_CACHE->groupings->courseid = $courseid;
254     $GROUPLIB_CACHE->groupings->result =
255             $DB->get_records('groupings', array('courseid' => $courseid), 'name ASC');
256     return $GROUPLIB_CACHE->groupings->result;
259 /**
260  * Determines if the user is a member of the given group.
261  *
262  * If $userid is null, use the global object.
263  *
264  * @category group
265  * @param int $groupid The group to check for membership.
266  * @param int $userid The user to check against the group.
267  * @return bool True if the user is a member, false otherwise.
268  */
269 function groups_is_member($groupid, $userid=null) {
270     global $USER, $DB;
272     if (!$userid) {
273         $userid = $USER->id;
274     }
276     return $DB->record_exists('groups_members', array('groupid'=>$groupid, 'userid'=>$userid));
279 /**
280  * Determines if current or specified is member of any active group in activity
281  *
282  * @category group
283  * @staticvar array $cache
284  * @param cm_info $cm course module object
285  * @param int $userid id of user, null means $USER->id
286  * @return bool true if user member of at least one group used in activity
287  */
288 function groups_has_membership($cm, $userid=null) {
289     global $CFG, $USER, $DB;
291     static $cache = array();
293     if (empty($userid)) {
294         $userid = $USER->id;
295     }
297     $cachekey = $userid.'|'.$cm->course.'|'.$cm->groupingid;
298     if (isset($cache[$cachekey])) {
299         return($cache[$cachekey]);
300     }
302     if ($cm->groupingid) {
303         // find out if member of any group in selected activity grouping
304         $sql = "SELECT 'x'
305                   FROM {groups_members} gm, {groupings_groups} gg
306                  WHERE gm.userid = ? AND gm.groupid = gg.groupid AND gg.groupingid = ?";
307         $params = array($userid, $cm->groupingid);
309     } else {
310         // no grouping used - check all groups in course
311         $sql = "SELECT 'x'
312                   FROM {groups_members} gm, {groups} g
313                  WHERE gm.userid = ? AND gm.groupid = g.id AND g.courseid = ?";
314         $params = array($userid, $cm->course);
315     }
317     $cache[$cachekey] = $DB->record_exists_sql($sql, $params);
319     return $cache[$cachekey];
322 /**
323  * Returns the users in the specified group.
324  *
325  * @category group
326  * @param int $groupid The groupid to get the users for
327  * @param int $fields The fields to return
328  * @param int $sort optional sorting of returned users
329  * @return array|bool Returns an array of the users for the specified
330  * group or false if no users or an error returned.
331  */
332 function groups_get_members($groupid, $fields='u.*', $sort='lastname ASC') {
333     global $DB;
335     return $DB->get_records_sql("SELECT $fields
336                                    FROM {user} u, {groups_members} gm
337                                   WHERE u.id = gm.userid AND gm.groupid = ?
338                                ORDER BY $sort", array($groupid));
342 /**
343  * Returns the users in the specified grouping.
344  *
345  * @category group
346  * @param int $groupingid The groupingid to get the users for
347  * @param string $fields The fields to return
348  * @param string $sort optional sorting of returned users
349  * @return array|bool Returns an array of the users for the specified
350  * group or false if no users or an error returned.
351  */
352 function groups_get_grouping_members($groupingid, $fields='u.*', $sort='lastname ASC') {
353     global $DB;
355     return $DB->get_records_sql("SELECT $fields
356                                    FROM {user} u
357                                      INNER JOIN {groups_members} gm ON u.id = gm.userid
358                                      INNER JOIN {groupings_groups} gg ON gm.groupid = gg.groupid
359                                   WHERE  gg.groupingid = ?
360                                ORDER BY $sort", array($groupingid));
363 /**
364  * Returns effective groupmode used in course
365  *
366  * @category group
367  * @param stdClass $course course object.
368  * @return int group mode
369  */
370 function groups_get_course_groupmode($course) {
371     return $course->groupmode;
374 /**
375  * Returns effective groupmode used in activity, course setting
376  * overrides activity setting if groupmodeforce enabled.
377  *
378  * @category group
379  * @param cm_info $cm the course module object. Only the ->course and ->groupmode need to be set.
380  * @param stdClass $course object optional course object to improve perf
381  * @return int group mode
382  */
383 function groups_get_activity_groupmode($cm, $course=null) {
384     global $COURSE, $DB;
386     // get course object (reuse COURSE if possible)
387     if (isset($course->id) and $course->id == $cm->course) {
388         //ok
389     } else if ($cm->course == $COURSE->id) {
390         $course = $COURSE;
391     } else {
392         if (!$course = $DB->get_record('course', array('id'=>$cm->course))) {
393             print_error('invalidcourseid');
394         }
395     }
397     return empty($course->groupmodeforce) ? $cm->groupmode : $course->groupmode;
400 /**
401  * Print group menu selector for course level.
402  *
403  * @category group
404  * @param stdClass $course course object
405  * @param mixed $urlroot return address. Accepts either a string or a moodle_url
406  * @param bool $return return as string instead of printing
407  * @return mixed void or string depending on $return param
408  */
409 function groups_print_course_menu($course, $urlroot, $return=false) {
410     global $USER, $OUTPUT;
412     if (!$groupmode = $course->groupmode) {
413         if ($return) {
414             return '';
415         } else {
416             return;
417         }
418     }
420     $context = get_context_instance(CONTEXT_COURSE, $course->id);
421     $aag = has_capability('moodle/site:accessallgroups', $context);
423     if ($groupmode == VISIBLEGROUPS or $aag) {
424         $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
425     } else {
426         $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
427     }
429     $activegroup = groups_get_course_group($course, true, $allowedgroups);
431     $groupsmenu = array();
432     if (!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) {
433         $groupsmenu[0] = get_string('allparticipants');
434     }
436     if ($allowedgroups) {
437         foreach ($allowedgroups as $group) {
438             $groupsmenu[$group->id] = format_string($group->name);
439         }
440     }
442     if ($groupmode == VISIBLEGROUPS) {
443         $grouplabel = get_string('groupsvisible');
444     } else {
445         $grouplabel = get_string('groupsseparate');
446     }
448     if ($aag and $course->defaultgroupingid) {
449         if ($grouping = groups_get_grouping($course->defaultgroupingid)) {
450             $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')';
451         }
452     }
454     if (count($groupsmenu) == 1) {
455         $groupname = reset($groupsmenu);
456         $output = $grouplabel.': '.$groupname;
457     } else {
458         $select = new single_select(new moodle_url($urlroot), 'group', $groupsmenu, $activegroup, null, 'selectgroup');
459         $select->label = $grouplabel;
460         $output = $OUTPUT->render($select);
461     }
463     $output = '<div class="groupselector">'.$output.'</div>';
465     if ($return) {
466         return $output;
467     } else {
468         echo $output;
469     }
472 /**
473  * Print group menu selector for activity.
474  *
475  * @category group
476  * @param stdClass $cm course module object
477  * @param string|moodle_url $urlroot return address that users get to if they choose an option;
478  *   should include any parameters needed, e.g. "$CFG->wwwroot/mod/forum/view.php?id=34"
479  * @param bool $return return as string instead of printing
480  * @param bool $hideallparticipants If true, this prevents the 'All participants'
481  *   option from appearing in cases where it normally would. This is intended for
482  *   use only by activities that cannot display all groups together. (Note that
483  *   selecting this option does not prevent groups_get_activity_group from
484  *   returning 0; it will still do that if the user has chosen 'all participants'
485  *   in another activity, or not chosen anything.)
486  * @return mixed void or string depending on $return param
487  */
488 function groups_print_activity_menu($cm, $urlroot, $return=false, $hideallparticipants=false) {
489     global $USER, $OUTPUT;
491     if ($urlroot instanceof moodle_url) {
492         // no changes necessary
494     } else {
495         if (strpos($urlroot, 'http') !== 0) { // Will also work for https
496             // Display error if urlroot is not absolute (this causes the non-JS version to break)
497             debugging('groups_print_activity_menu requires absolute URL for ' .
498                       '$urlroot, not <tt>' . s($urlroot) . '</tt>. Example: ' .
499                       'groups_print_activity_menu($cm, $CFG->wwwroot . \'/mod/mymodule/view.php?id=13\');',
500                       DEBUG_DEVELOPER);
501         }
502         $urlroot = new moodle_url($urlroot);
503     }
505     if (!$groupmode = groups_get_activity_groupmode($cm)) {
506         if ($return) {
507             return '';
508         } else {
509             return;
510         }
511     }
513     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
514     $aag = has_capability('moodle/site:accessallgroups', $context);
516     if ($groupmode == VISIBLEGROUPS or $aag) {
517         $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid); // any group in grouping
518     } else {
519         $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid); // only assigned groups
520     }
522     $activegroup = groups_get_activity_group($cm, true, $allowedgroups);
524     $groupsmenu = array();
525     if ((!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) and !$hideallparticipants) {
526         $groupsmenu[0] = get_string('allparticipants');
527     }
529     if ($allowedgroups) {
530         foreach ($allowedgroups as $group) {
531             $groupsmenu[$group->id] = format_string($group->name);
532         }
533     }
535     if ($groupmode == VISIBLEGROUPS) {
536         $grouplabel = get_string('groupsvisible');
537     } else {
538         $grouplabel = get_string('groupsseparate');
539     }
541     if ($aag and $cm->groupingid) {
542         if ($grouping = groups_get_grouping($cm->groupingid)) {
543             $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')';
544         }
545     }
547     if (count($groupsmenu) == 1) {
548         $groupname = reset($groupsmenu);
549         $output = $grouplabel.': '.$groupname;
550     } else {
551         $select = new single_select($urlroot, 'group', $groupsmenu, $activegroup, null, 'selectgroup');
552         $select->label = $grouplabel;
553         $output = $OUTPUT->render($select);
554     }
556     $output = '<div class="groupselector">'.$output.'</div>';
558     if ($return) {
559         return $output;
560     } else {
561         echo $output;
562     }
565 /**
566  * Returns group active in course, changes the group by default if 'group' page param present
567  *
568  * @category group
569  * @param stdClass $course course bject
570  * @param bool $update change active group if group param submitted
571  * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_course_menu())
572  * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
573  */
574 function groups_get_course_group($course, $update=false, $allowedgroups=null) {
575     global $USER, $SESSION;
577     if (!$groupmode = $course->groupmode) {
578         // NOGROUPS used
579         return false;
580     }
582     $context = get_context_instance(CONTEXT_COURSE, $course->id);
583     if (has_capability('moodle/site:accessallgroups', $context)) {
584         $groupmode = 'aag';
585     }
587     if (!is_array($allowedgroups)) {
588         if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
589             $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid);
590         } else {
591             $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid);
592         }
593     }
595     _group_verify_activegroup($course->id, $groupmode, $course->defaultgroupingid, $allowedgroups);
597     // set new active group if requested
598     $changegroup = optional_param('group', -1, PARAM_INT);
599     if ($update and $changegroup != -1) {
601         if ($changegroup == 0) {
602             // do not allow changing to all groups without accessallgroups capability
603             if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
604                 $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = 0;
605             }
607         } else {
608             if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
609                 $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = $changegroup;
610             }
611         }
612     }
614     return $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid];
617 /**
618  * Returns group active in activity, changes the group by default if 'group' page param present
619  *
620  * @category group
621  * @param stdClass $cm course module object
622  * @param bool $update change active group if group param submitted
623  * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_activity_menu())
624  * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
625  */
626 function groups_get_activity_group($cm, $update=false, $allowedgroups=null) {
627     global $USER, $SESSION;
629     if (!$groupmode = groups_get_activity_groupmode($cm)) {
630         // NOGROUPS used
631         return false;
632     }
634     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
635     if (has_capability('moodle/site:accessallgroups', $context)) {
636         $groupmode = 'aag';
637     }
639     if (!is_array($allowedgroups)) {
640         if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
641             $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid);
642         } else {
643             $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid);
644         }
645     }
647     _group_verify_activegroup($cm->course, $groupmode, $cm->groupingid, $allowedgroups);
649     // set new active group if requested
650     $changegroup = optional_param('group', -1, PARAM_INT);
651     if ($update and $changegroup != -1) {
653         if ($changegroup == 0) {
654             // allgroups visible only in VISIBLEGROUPS or when accessallgroups
655             if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
656                 $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = 0;
657             }
659         } else {
660             if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
661                 $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = $changegroup;
662             }
663         }
664     }
666     return $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid];
669 /**
670  * Gets a list of groups that the user is allowed to access within the
671  * specified activity.
672  *
673  * @category group
674  * @param stdClass $cm Course-module
675  * @param int $userid User ID (defaults to current user)
676  * @return array An array of group objects, or false if none
677  */
678 function groups_get_activity_allowed_groups($cm,$userid=0) {
679     // Use current user by default
680     global $USER;
681     if(!$userid) {
682         $userid=$USER->id;
683     }
685     // Get groupmode for activity, taking into account course settings
686     $groupmode=groups_get_activity_groupmode($cm);
688     // If visible groups mode, or user has the accessallgroups capability,
689     // then they can access all groups for the activity...
690     $context = get_context_instance(CONTEXT_MODULE, $cm->id);
691     if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context)) {
692         return groups_get_all_groups($cm->course, 0, $cm->groupingid);
693     } else {
694         // ...otherwise they can only access groups they belong to
695         return groups_get_all_groups($cm->course, $userid, $cm->groupingid);
696     }
699 /**
700  * Determine if a course module is currently visible to a user
701  *
702  * $USER If $userid is null, use the global object.
703  *
704  * @category group
705  * @param stdClass $cm The course module
706  * @param int $userid The user to check against the group.
707  * @return bool True if the user can view the course module, false otherwise.
708  */
709 function groups_course_module_visible($cm, $userid=null) {
710     global $CFG, $USER;
712     if (empty($userid)) {
713         $userid = $USER->id;
714     }
715     if (empty($CFG->enablegroupmembersonly)) {
716         return true;
717     }
718     if (empty($cm->groupmembersonly)) {
719         return true;
720     }
721     if (has_capability('moodle/site:accessallgroups', get_context_instance(CONTEXT_MODULE, $cm->id), $userid) or groups_has_membership($cm, $userid)) {
722         return true;
723     }
724     return false;
727 /**
728  * Internal method, sets up $SESSION->activegroup and verifies previous value
729  *
730  * @param int $courseid
731  * @param int|string $groupmode SEPARATEGROUPS, VISIBLEGROUPS or 'aag' (access all groups)
732  * @param int $groupingid 0 means all groups
733  * @param array $allowedgroups list of groups user can see
734  */
735 function _group_verify_activegroup($courseid, $groupmode, $groupingid, array $allowedgroups) {
736     global $SESSION, $USER;
738     // init activegroup array if necessary
739     if (!isset($SESSION->activegroup)) {
740         $SESSION->activegroup = array();
741     }
742     if (!array_key_exists($courseid, $SESSION->activegroup)) {
743         $SESSION->activegroup[$courseid] = array(SEPARATEGROUPS=>array(), VISIBLEGROUPS=>array(), 'aag'=>array());
744     }
746     // make sure that the current group info is ok
747     if (array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode]) and !array_key_exists($SESSION->activegroup[$courseid][$groupmode][$groupingid], $allowedgroups)) {
748         // active group does not exist anymore or is 0
749         if ($SESSION->activegroup[$courseid][$groupmode][$groupingid] > 0 or $groupmode == SEPARATEGROUPS) {
750             // do not do this if all groups selected and groupmode is not separate
751             unset($SESSION->activegroup[$courseid][$groupmode][$groupingid]);
752         }
753     }
755     // set up defaults if necessary
756     if (!array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode])) {
757         if ($groupmode == 'aag') {
758             $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0; // all groups by default if user has accessallgroups
760         } else if ($allowedgroups) {
761             if ($groupmode != SEPARATEGROUPS and $mygroups = groups_get_all_groups($courseid, $USER->id, $groupingid)) {
762                 $firstgroup = reset($mygroups);
763             } else {
764                 $firstgroup = reset($allowedgroups);
765             }
766             $SESSION->activegroup[$courseid][$groupmode][$groupingid] = $firstgroup->id;
768         } else {
769             // this happen when user not assigned into group in SEPARATEGROUPS mode or groups do not exist yet
770             // mod authors must add extra checks for this when SEPARATEGROUPS mode used (such as when posting to forum)
771             $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0;
772         }
773     }