Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 4.2.x will end 22 April 2024 (12 months).
  • Bug fixes for security issues in 4.2.x will end 7 October 2024 (18 months).
  • PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.1.x is supported too.
/lib/ -> grouplib.php (source)
<?php

// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 * @package    core_group
 */

defined('MOODLE_INTERNAL') || die();

/**
 * Groups not used in course or activity
 */
define('NOGROUPS', 0);

/**
 * Groups used, users do not see other groups
 */
define('SEPARATEGROUPS', 1);

/**
 * Groups used, students see other groups
 */
define('VISIBLEGROUPS', 2);

/**
 * This is for filtering users without any group.
 */
define('USERSWITHOUTGROUP', -1);

/**
 * 'None' join type, used when filtering by groups (logical NOT)
 */
define('GROUPS_JOIN_NONE', 0);

/**
 * 'Any' join type, used when filtering by groups (logical OR)
 */
define('GROUPS_JOIN_ANY', 1);

/**
 * 'All' join type, used when filtering by groups (logical AND)
 */
define('GROUPS_JOIN_ALL', 2);

/**
> * All users can see this group and its members. * Determines if a group with a given groupid exists. > */ * > define('GROUPS_VISIBILITY_ALL', 0); * @category group > * @param int $groupid The groupid to check for > /** * @return bool True if the group exists, false otherwise or if an error > * Members of this group can see this group and other members. * occurred. > */ */ > define('GROUPS_VISIBILITY_MEMBERS', 1); function groups_group_exists($groupid) { > global $DB; > /** return $DB->record_exists('groups', array('id'=>$groupid)); > * Members of this group can see the group and their own membership, but not each other's membership } > */ > define('GROUPS_VISIBILITY_OWN', 2); /** > * Gets the name of a group with a specified id > /** * > * No-one can see this group or its members. Members of the group will not know they are in the group. * @category group > */ * @param int $groupid The id of the group > define('GROUPS_VISIBILITY_NONE', 3); * @return string The name of the group > */ > /**
function groups_get_group_name($groupid) {
> * Before output, you should call {@see format_string} on the result global $DB; > *
return $DB->get_field('groups', 'name', array('id'=>$groupid)); } /** * Gets the name of a grouping with a specified id *
> * Before output, you should call {@see format_string} on the result * @category group > *
* @param int $groupingid The id of the grouping * @return string The name of the grouping */ function groups_get_grouping_name($groupingid) { global $DB; return $DB->get_field('groupings', 'name', array('id'=>$groupingid)); } /** * Returns the groupid of a group with the name specified for the course. * Group names should be unique in course * * @category group * @param int $courseid The id of the course * @param string $name name of group (without magic quotes) * @return int $groupid */ function groups_get_group_by_name($courseid, $name) { $data = groups_get_course_data($courseid); foreach ($data->groups as $group) { if ($group->name == $name) { return $group->id; } } return false; } /** * Returns the groupid of a group with the idnumber specified for the course. * Group idnumbers should be unique within course * * @category group * @param int $courseid The id of the course * @param string $idnumber idnumber of group * @return group object */ function groups_get_group_by_idnumber($courseid, $idnumber) { if (empty($idnumber)) { return false; } $data = groups_get_course_data($courseid); foreach ($data->groups as $group) { if ($group->idnumber == $idnumber) { return $group; } } return false; } /** * Returns the groupingid of a grouping with the name specified for the course. * Grouping names should be unique in course * * @category group * @param int $courseid The id of the course * @param string $name name of group (without magic quotes) * @return int $groupid */ function groups_get_grouping_by_name($courseid, $name) { $data = groups_get_course_data($courseid); foreach ($data->groupings as $grouping) { if ($grouping->name == $name) { return $grouping->id; } } return false; } /** * Returns the groupingid of a grouping with the idnumber specified for the course. * Grouping names should be unique within course * * @category group * @param int $courseid The id of the course * @param string $idnumber idnumber of the group * @return grouping object */ function groups_get_grouping_by_idnumber($courseid, $idnumber) { if (empty($idnumber)) { return false; } $data = groups_get_course_data($courseid); foreach ($data->groupings as $grouping) { if ($grouping->idnumber == $idnumber) { return $grouping; } } return false; } /** * Get the group object * * @category group * @param int $groupid ID of the group. * @param string $fields (default is all fields) * @param int $strictness (IGNORE_MISSING - default) * @return bool|stdClass group object or false if not found * @throws dml_exception */ function groups_get_group($groupid, $fields='*', $strictness=IGNORE_MISSING) { global $DB; return $DB->get_record('groups', array('id'=>$groupid), $fields, $strictness); } /** * Get the grouping object * * @category group * @param int $groupingid ID of the group. * @param string $fields * @param int $strictness (IGNORE_MISSING - default) * @return stdClass group object */ function groups_get_grouping($groupingid, $fields='*', $strictness=IGNORE_MISSING) { global $DB; return $DB->get_record('groupings', array('id'=>$groupingid), $fields, $strictness); } /** * Gets array of all groups in a specified course (subject to the conditions imposed by the other arguments). *
> * If a user does not have moodle/course:viewhiddengroups, the list of groups and members will be restricted based on the * @category group > * visibility setting of each group. * @param int $courseid The id of the course. > *
* @param int|int[] $userid optional user id or array of ids, returns only groups continaing one or more of those users. * @param int $groupingid optional returns only groups in the specified grouping. * @param string $fields defaults to g.*. This allows you to vary which fields are returned. * If $groupingid is specified, the groupings_groups table will be available with alias gg. * If $userid is specified, the groups_members table will be available as gm. * @param bool $withmembers if true return an extra field members (int[]) which is the list of userids that * are members of each group. For this to work, g.id (or g.*) must be included in $fields. * In this case, the final results will always be an array indexed by group id.
> * @param bool $participationonly Only return groups where the participation field is true.
* @return array returns an array of the group objects (unless you have done something very weird * with the $fields option). */
< function groups_get_all_groups($courseid, $userid=0, $groupingid=0, $fields='g.*', $withmembers=false) { < global $DB;
> function groups_get_all_groups($courseid, $userid=0, $groupingid=0, $fields='g.*', $withmembers=false, $participationonly = false) { > global $DB, $USER;
// We need to check that we each field in the fields list belongs to the group table and that it has not being // aliased. If its something else we need to avoid the cache and run the query as who knows whats going on. $knownfields = true; if ($fields !== 'g.*') { // Quickly check if the first field is no longer g.id as using the // cache will return an array indexed differently than when expect if (strpos($fields, 'g.*') !== 0 && strpos($fields, 'g.id') !== 0) { $knownfields = false; } else { $fieldbits = explode(',', $fields); foreach ($fieldbits as $bit) { $bit = trim($bit); if (strpos($bit, 'g.') !== 0 or stripos($bit, ' AS ') !== false) { $knownfields = false; break; } } } }
< if (empty($userid) && $knownfields && !$withmembers) {
> if (empty($userid) && $knownfields && !$withmembers && \core_group\visibility::can_view_all_groups($courseid)) {
// We can use the cache. $data = groups_get_course_data($courseid); if (empty($groupingid)) { // All groups.. Easy! $groups = $data->groups; } else { $groups = array(); foreach ($data->mappings as $mapping) { if ($mapping->groupingid != $groupingid) { continue; } if (isset($data->groups[$mapping->groupid])) { $groups[$mapping->groupid] = $data->groups[$mapping->groupid]; } } }
> if ($participationonly) { // Yay! We could use the cache. One more query saved. > $groups = array_filter($groups, fn($group) => $group->participation); return $groups; > }
} $params = []; $userfrom = ''; $userwhere = ''; if (!empty($userid)) { list($usql, $params) = $DB->get_in_or_equal($userid); $userfrom = "JOIN {groups_members} gm ON gm.groupid = g.id"; $userwhere = "AND gm.userid $usql"; } $groupingfrom = ''; $groupingwhere = ''; if (!empty($groupingid)) { $groupingfrom = "JOIN {groupings_groups} gg ON gg.groupid = g.id"; $groupingwhere = "AND gg.groupingid = ?"; $params[] = $groupingid; } array_unshift($params, $courseid);
> $visibilityfrom = ''; $results = $DB->get_records_sql(" > $visibilitywhere = ''; SELECT $fields > $viewhidden = has_capability('moodle/course:viewhiddengroups', context_course::instance($courseid)); FROM {groups} g > if (!$viewhidden) { $userfrom > // Apply group visibility restrictions. Only return groups where visibility is ALL, or the current user is a member and the $groupingfrom > // visibility is MEMBERS or OWN. WHERE g.courseid = ? > $userids = []; $userwhere > if (empty($userid)) { $groupingwhere > $userids = [$USER->id]; ORDER BY g.name ASC", $params); > $visibilityfrom = "LEFT JOIN {groups_members} gm ON gm.groupid = g.id AND gm.userid = ?"; > } if (!$withmembers) { > [$insql, $inparams] = $DB->get_in_or_equal([GROUPS_VISIBILITY_MEMBERS, GROUPS_VISIBILITY_OWN]); return $results; > $visibilitywhere = " AND (g.visibility = ? OR (g.visibility $insql AND gm.id IS NOT NULL))"; } > $params = array_merge( > $userids, // We also want group members. We do this in a separate query, becuse the above > $params, // query will return a lot of data (e.g. g.description) for each group, and > [GROUPS_VISIBILITY_ALL], // some groups may contain hundreds of members. We don't want the results > $inparams // to contain hundreds of copies of long descriptions. > ); $groups = []; > } foreach ($results as $row) { > $groups[$row->id] = $row; > $participationwhere = ''; $groups[$row->id]->members = []; > if ($participationonly) { } > $participationwhere = "AND g.participation = ?"; $groupmembers = $DB->get_records_list('groups_members', 'groupid', array_keys($groups)); > $params = array_merge($params, [1]); foreach ($groupmembers as $gm) { > } $groups[$gm->groupid]->members[$gm->userid] = $gm->userid; >
}
> $visibilityfrom
return $groups;
> $visibilitywhere } > $participationwhere
< $groupmembers = $DB->get_records_list('groups_members', 'groupid', array_keys($groups));
> > $gmvisibilityfrom = ''; > $gmvisibilitywhere = ''; > $gmvisibilityparams = []; > if (!$viewhidden) { > // Only return membership records where visibility is ALL, visibility is MEMBERS and the current user is a member, > // or visibility is OWN and the record is for the current user. > $gmvisibilityfrom = " > JOIN {groups} g ON gm.groupid = g.id > "; > $gmvisibilitywhere = " > AND (g.visibility = ? > OR (g.visibility = ? > AND g.id IN (SELECT gm2.groupid FROM {groups_members} gm2 WHERE gm2.groupid = g.id AND gm2.userid = ?)) > OR (g.visibility = ? > AND gm.userid = ?))"; > $gmvisibilityparams = [ > GROUPS_VISIBILITY_ALL, > GROUPS_VISIBILITY_MEMBERS, > $USER->id, > GROUPS_VISIBILITY_OWN, > $USER->id > ]; > } > > $groupmembers = []; > if (!empty($groups)) { > [$gmin, $gmparams] = $DB->get_in_or_equal(array_keys($groups)); > $params = array_merge($gmparams, $gmvisibilityparams); > $gmsql = " > SELECT gm.* > FROM {groups_members} gm > $gmvisibilityfrom > WHERE gm.groupid $gmin > $gmvisibilitywhere"; > $groupmembers = $DB->get_records_sql($gmsql, $params); > } >
/** * Gets array of all groups in current user. * * @since Moodle 2.5 * @category group * @return array Returns an array of the group objects. */ function groups_get_my_groups() { global $DB, $USER;
> return $DB->get_records_sql("SELECT * > $params = ['userid' => $USER->id]; FROM {groups_members} gm > JOIN {groups} g > $viewhidden = has_capability('moodle/course:viewhiddengroups', context_system::instance()); ON g.id = gm.groupid > $visibilitywhere = ''; WHERE gm.userid = ? > if (!$viewhidden) { ORDER BY name ASC", array($USER->id)); > $params['novisibility'] = GROUPS_VISIBILITY_NONE; } > $visibilitywhere = ' AND g.visibility != :novisibility'; > } /** >
< WHERE gm.userid = ? < ORDER BY name ASC", array($USER->id));
> WHERE gm.userid = :userid > $visibilitywhere > ORDER BY name ASC", $params);
* @category group * @param int $courseid * @param int $userid $USER if not specified * @return array Array[groupingid][groupid] including grouping id 0 which means all groups */ function groups_get_user_groups($courseid, $userid=0) { global $USER, $DB;
> if (empty($courseid)) { if (empty($userid)) { > return ['0' => []]; $userid = $USER->id; > } } >
> $usergroups = false; $cache = cache::make('core', 'user_group_groupings'); > $viewhidden = has_capability('moodle/course:viewhiddengroups', context_course::instance($courseid)); > $viewall = \core_group\visibility::can_view_all_groups($courseid); // Try to retrieve group ids from the cache. >
$usergroups = $cache->get($userid);
> if ($viewall) {
> }
if ($usergroups === false) {
>
$sql = "SELECT g.id, g.courseid, gg.groupingid FROM {groups} g JOIN {groups_members} gm ON gm.groupid = g.id LEFT JOIN {groupings_groups} gg ON gg.groupid = g.id
< WHERE gm.userid = ?";
> WHERE gm.userid = :userid"; > > $params = ['userid' => $userid]; > > if (!$viewhidden) { > // Apply visibility restrictions. > // Everyone can see who is in groups with ALL visibility. > list($visibilitywhere, $visibilityparams) = \core_group\visibility::sql_group_visibility_where($userid); > $sql .= " AND " . $visibilitywhere; > $params = array_merge($params, $visibilityparams); > } > > $sql .= ' ORDER BY g.id'; // To make results deterministic.
< $rs = $DB->get_recordset_sql($sql, array($userid));
> $rs = $DB->get_recordset_sql($sql, $params);
$usergroups = array(); $allgroups = array(); foreach ($rs as $group) { if (!array_key_exists($group->courseid, $allgroups)) { $allgroups[$group->courseid] = array(); } $allgroups[$group->courseid][$group->id] = $group->id; if (!array_key_exists($group->courseid, $usergroups)) { $usergroups[$group->courseid] = array(); } if (is_null($group->groupingid)) { continue; } if (!array_key_exists($group->groupingid, $usergroups[$group->courseid])) { $usergroups[$group->courseid][$group->groupingid] = array(); } $usergroups[$group->courseid][$group->groupingid][$group->id] = $group->id; } $rs->close(); foreach (array_keys($allgroups) as $cid) { $usergroups[$cid]['0'] = array_keys($allgroups[$cid]); // All user groups in the course. }
< // Cache the data.
> if ($viewall) { > // Cache the data, if we got the full list of groups.
$cache->set($userid, $usergroups); }
> }
if (array_key_exists($courseid, $usergroups)) { return $usergroups[$courseid]; } else { return array('0' => array()); } } /** * Gets an array of all groupings in a specified course. This value is cached * for a single course (so you can call it repeatedly for the same course * without a performance penalty). * * @category group * @param int $courseid return all groupings from course with this courseid * @return array Returns an array of the grouping objects (empty if none) */ function groups_get_all_groupings($courseid) { $data = groups_get_course_data($courseid); return $data->groupings; } /** * Determines if the user is a member of the given group. * * If $userid is null, use the global object. * * @category group * @param int $groupid The group to check for membership. * @param int $userid The user to check against the group. * @return bool True if the user is a member, false otherwise. */ function groups_is_member($groupid, $userid=null) { global $USER, $DB; if (!$userid) { $userid = $USER->id; }
< return $DB->record_exists('groups_members', array('groupid'=>$groupid, 'userid'=>$userid));
> $courseid = $DB->get_field('groups', 'courseid', ['id' => $groupid]); > if (!$courseid) { > return false; > } > > if (\core_group\visibility::can_view_all_groups($courseid)) { > return $DB->record_exists('groups_members', ['groupid' => $groupid, 'userid' => $userid]); > } > > $sql = "SELECT * > FROM {groups_members} gm > JOIN {groups} g ON gm.groupid = g.id > WHERE g.id = :groupid > AND gm.userid = :userid"; > $params = ['groupid' => $groupid, 'userid' => $userid]; > > list($visibilitywhere, $visibilityparams) = \core_group\visibility::sql_group_visibility_where($userid); > > $sql .= " AND " . $visibilitywhere; > $params = array_merge($params, $visibilityparams); > > return $DB->record_exists_sql($sql, $params);
} /** * Determines if current or specified is member of any active group in activity * * @category group * @staticvar array $cache * @param stdClass|cm_info $cm course module object * @param int $userid id of user, null means $USER->id * @return bool true if user member of at least one group used in activity */ function groups_has_membership($cm, $userid=null) { global $CFG, $USER, $DB; static $cache = array(); if (empty($userid)) { $userid = $USER->id; } $cachekey = $userid.'|'.$cm->course.'|'.$cm->groupingid; if (isset($cache[$cachekey])) { return($cache[$cachekey]); } if ($cm->groupingid) { // find out if member of any group in selected activity grouping $sql = "SELECT 'x' FROM {groups_members} gm, {groupings_groups} gg WHERE gm.userid = ? AND gm.groupid = gg.groupid AND gg.groupingid = ?"; $params = array($userid, $cm->groupingid); } else { // no grouping used - check all groups in course $sql = "SELECT 'x' FROM {groups_members} gm, {groups} g WHERE gm.userid = ? AND gm.groupid = g.id AND g.courseid = ?"; $params = array($userid, $cm->course); } $cache[$cachekey] = $DB->record_exists_sql($sql, $params); return $cache[$cachekey]; } /** * Returns the users in the specified group. * * @category group * @param int $groupid The groupid to get the users for * @param int $fields The fields to return * @param int $sort optional sorting of returned users
< * @return array|bool Returns an array of the users for the specified < * group or false if no users or an error returned.
> * @return array Returns an array of the users for the specified group
*/ function groups_get_members($groupid, $fields='u.*', $sort='lastname ASC') { global $DB;
< return $DB->get_records_sql("SELECT $fields < FROM {user} u, {groups_members} gm < WHERE u.id = gm.userid AND gm.groupid = ? < ORDER BY $sort", array($groupid));
> if (empty($groupid)) { > return []; > } > > $courseid = $DB->get_field('groups', 'courseid', ['id' => $groupid]); > if ($courseid === false) { > return []; > } > > $select = "SELECT $fields"; > $from = "FROM {user} u > JOIN {groups_members} gm ON gm.userid = u.id"; > $where = "WHERE gm.groupid = :groupid"; > $order = "ORDER BY $sort"; > > $params = ['groupid' => $groupid]; > > if (!\core_group\visibility::can_view_all_groups($courseid)) { > $from .= " JOIN {groups} g ON g.id = gm.groupid"; > // Can view memberships of visibility is ALL, visibility is MEMBERS and current user is a member, > // or visibility is OWN and this is their membership. > list($visibilitywhere, $visibilityparams) = \core_group\visibility::sql_member_visibility_where(); > $params = array_merge($params, $visibilityparams); > $where .= ' AND ' . $visibilitywhere; > } > > $sql = implode(PHP_EOL, [$select, $from, $where, $order]); > > return $DB->get_records_sql($sql, $params);
} /** * Returns the users in the specified grouping. * * @category group * @param int $groupingid The groupingid to get the users for * @param string $fields The fields to return * @param string $sort optional sorting of returned users * @return array|bool Returns an array of the users for the specified * group or false if no users or an error returned. */ function groups_get_grouping_members($groupingid, $fields='u.*', $sort='lastname ASC') { global $DB; return $DB->get_records_sql("SELECT $fields FROM {user} u INNER JOIN {groups_members} gm ON u.id = gm.userid INNER JOIN {groupings_groups} gg ON gm.groupid = gg.groupid WHERE gg.groupingid = ? ORDER BY $sort", array($groupingid)); } /** * Returns effective groupmode used in course * * @category group * @param stdClass $course course object. * @return int group mode */ function groups_get_course_groupmode($course) { return $course->groupmode; } /** * Returns effective groupmode used in activity, course setting * overrides activity setting if groupmodeforce enabled. * * If $cm is an instance of cm_info it is easier to use $cm->effectivegroupmode * * @category group * @param cm_info|stdClass $cm the course module object. Only the ->course and ->groupmode need to be set. * @param stdClass $course object optional course object to improve perf * @return int group mode */ function groups_get_activity_groupmode($cm, $course=null) { if ($cm instanceof cm_info) { return $cm->effectivegroupmode; } if (isset($course->id) and $course->id == $cm->course) { //ok } else { // Get course object (reuse $COURSE if possible). $course = get_course($cm->course, false); } return empty($course->groupmodeforce) ? $cm->groupmode : $course->groupmode; } /** * Print group menu selector for course level. * * @category group * @param stdClass $course course object * @param mixed $urlroot return address. Accepts either a string or a moodle_url * @param bool $return return as string instead of printing * @return mixed void or string depending on $return param */ function groups_print_course_menu($course, $urlroot, $return=false) { global $USER, $OUTPUT; if (!$groupmode = $course->groupmode) { if ($return) { return ''; } else { return; } } $context = context_course::instance($course->id); $aag = has_capability('moodle/site:accessallgroups', $context); $usergroups = array(); if ($groupmode == VISIBLEGROUPS or $aag) { $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid); // Get user's own groups and put to the top. $usergroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid); } else { $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid); } $activegroup = groups_get_course_group($course, true, $allowedgroups); $groupsmenu = array(); if (!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) { $groupsmenu[0] = get_string('allparticipants'); } $groupsmenu += groups_sort_menu_options($allowedgroups, $usergroups); if ($groupmode == VISIBLEGROUPS) { $grouplabel = get_string('groupsvisible'); } else { $grouplabel = get_string('groupsseparate'); } if ($aag and $course->defaultgroupingid) { if ($grouping = groups_get_grouping($course->defaultgroupingid)) { $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')'; } } if (count($groupsmenu) == 1) { $groupname = reset($groupsmenu); $output = $grouplabel.': '.$groupname; } else { $select = new single_select(new moodle_url($urlroot), 'group', $groupsmenu, $activegroup, null, 'selectgroup'); $select->label = $grouplabel; $output = $OUTPUT->render($select); } $output = '<div class="groupselector">'.$output.'</div>'; if ($return) { return $output; } else { echo $output; } } /** * Turn an array of groups into an array of menu options. * @param array $groups of group objects. * @return array groupid => formatted group name. */ function groups_list_to_menu($groups) { $groupsmenu = array(); foreach ($groups as $group) { $groupsmenu[$group->id] = format_string($group->name); } return $groupsmenu; } /** * Takes user's allowed groups and own groups and formats for use in group selector menu * If user has allowed groups + own groups will add to an optgroup * Own groups are removed from allowed groups * @param array $allowedgroups All groups user is allowed to see * @param array $usergroups Groups user belongs to * @return array */ function groups_sort_menu_options($allowedgroups, $usergroups) { $useroptions = array(); if ($usergroups) { $useroptions = groups_list_to_menu($usergroups); // Remove user groups from other groups list. foreach ($usergroups as $group) { unset($allowedgroups[$group->id]); } } $allowedoptions = array(); if ($allowedgroups) { $allowedoptions = groups_list_to_menu($allowedgroups); } if ($useroptions && $allowedoptions) { return array( 1 => array(get_string('mygroups', 'group') => $useroptions), 2 => array(get_string('othergroups', 'group') => $allowedoptions) ); } else if ($useroptions) { return $useroptions; } else { return $allowedoptions; } } /** * Generates html to print menu selector for course level, listing all groups. * Note: This api does not do any group mode check use groups_print_course_menu() instead if you want proper checks. * * @param stdclass $course course object. * @param string|moodle_url $urlroot return address. Accepts either a string or a moodle_url. * @param bool $update set this to true to update current active group based on the group param. * @param int $activegroup Change group active to this group if $update set to true. * * @return string html or void */ function groups_allgroups_course_menu($course, $urlroot, $update = false, $activegroup = 0) { global $SESSION, $OUTPUT, $USER; $groupmode = groups_get_course_groupmode($course); $context = context_course::instance($course->id); $groupsmenu = array(); if (has_capability('moodle/site:accessallgroups', $context)) { $groupsmenu[0] = get_string('allparticipants'); $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid); } else { $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid); } $groupsmenu += groups_list_to_menu($allowedgroups); if ($update) { // Init activegroup array if necessary. if (!isset($SESSION->activegroup)) { $SESSION->activegroup = array(); } if (!isset($SESSION->activegroup[$course->id])) { $SESSION->activegroup[$course->id] = array(SEPARATEGROUPS => array(), VISIBLEGROUPS => array(), 'aag' => array()); } if (empty($groupsmenu[$activegroup])) { $activegroup = key($groupsmenu); // Force set to one of accessible groups. } $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = $activegroup; } $grouplabel = get_string('groups'); if (count($groupsmenu) == 0) { return ''; } else if (count($groupsmenu) == 1) { $groupname = reset($groupsmenu); $output = $grouplabel.': '.$groupname; } else { $select = new single_select(new moodle_url($urlroot), 'group', $groupsmenu, $activegroup, null, 'selectgroup'); $select->label = $grouplabel; $output = $OUTPUT->render($select); } return $output; } /** * Print group menu selector for activity. * * @category group * @param stdClass|cm_info $cm course module object * @param string|moodle_url $urlroot return address that users get to if they choose an option; * should include any parameters needed, e.g. "$CFG->wwwroot/mod/forum/view.php?id=34" * @param bool $return return as string instead of printing * @param bool $hideallparticipants If true, this prevents the 'All participants' * option from appearing in cases where it normally would. This is intended for * use only by activities that cannot display all groups together. (Note that * selecting this option does not prevent groups_get_activity_group from * returning 0; it will still do that if the user has chosen 'all participants' * in another activity, or not chosen anything.) * @return mixed void or string depending on $return param */ function groups_print_activity_menu($cm, $urlroot, $return=false, $hideallparticipants=false) { global $USER, $OUTPUT; if ($urlroot instanceof moodle_url) { // no changes necessary } else { if (strpos($urlroot, 'http') !== 0) { // Will also work for https // Display error if urlroot is not absolute (this causes the non-JS version to break) debugging('groups_print_activity_menu requires absolute URL for ' . '$urlroot, not <tt>' . s($urlroot) . '</tt>. Example: ' . 'groups_print_activity_menu($cm, $CFG->wwwroot . \'/mod/mymodule/view.php?id=13\');', DEBUG_DEVELOPER); } $urlroot = new moodle_url($urlroot); } if (!$groupmode = groups_get_activity_groupmode($cm)) { if ($return) { return ''; } else { return; } } $context = context_module::instance($cm->id); $aag = has_capability('moodle/site:accessallgroups', $context); $usergroups = array(); if ($groupmode == VISIBLEGROUPS or $aag) {
< $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid); // any group in grouping
> $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid, 'g.*', false, true); // Any group in grouping.
// Get user's own groups and put to the top.
< $usergroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid);
> $usergroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.*', false, true);
} else {
< $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid); // only assigned groups
> // Only assigned groups. > $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.*', false, true);
} $activegroup = groups_get_activity_group($cm, true, $allowedgroups); $groupsmenu = array(); if ((!$allowedgroups or $groupmode == VISIBLEGROUPS or $aag) and !$hideallparticipants) { $groupsmenu[0] = get_string('allparticipants'); } $groupsmenu += groups_sort_menu_options($allowedgroups, $usergroups); if ($groupmode == VISIBLEGROUPS) { $grouplabel = get_string('groupsvisible'); } else { $grouplabel = get_string('groupsseparate'); } if ($aag and $cm->groupingid) { if ($grouping = groups_get_grouping($cm->groupingid)) { $grouplabel = $grouplabel . ' (' . format_string($grouping->name) . ')'; } } if (count($groupsmenu) == 1) { $groupname = reset($groupsmenu); $output = $grouplabel.': '.$groupname; } else { $select = new single_select($urlroot, 'group', $groupsmenu, $activegroup, null, 'selectgroup'); $select->label = $grouplabel; $output = $OUTPUT->render($select); } $output = '<div class="groupselector">'.$output.'</div>'; if ($return) { return $output; } else { echo $output; } } /** * Returns group active in course, changes the group by default if 'group' page param present * * @category group * @param stdClass $course course bject * @param bool $update change active group if group param submitted * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_course_menu()) * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode) */ function groups_get_course_group($course, $update=false, $allowedgroups=null) { global $USER, $SESSION; if (!$groupmode = $course->groupmode) { // NOGROUPS used return false; } $context = context_course::instance($course->id); if (has_capability('moodle/site:accessallgroups', $context)) { $groupmode = 'aag'; } if (!is_array($allowedgroups)) { if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') { $allowedgroups = groups_get_all_groups($course->id, 0, $course->defaultgroupingid); } else { $allowedgroups = groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid); } } _group_verify_activegroup($course->id, $groupmode, $course->defaultgroupingid, $allowedgroups); // set new active group if requested $changegroup = optional_param('group', -1, PARAM_INT); if ($update and $changegroup != -1) { if ($changegroup == 0) { // do not allow changing to all groups without accessallgroups capability if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') { $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = 0; } } else { if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) { $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid] = $changegroup; } } } return $SESSION->activegroup[$course->id][$groupmode][$course->defaultgroupingid]; } /** * Returns group active in activity, changes the group by default if 'group' page param present * * @category group * @param stdClass|cm_info $cm course module object * @param bool $update change active group if group param submitted * @param array $allowedgroups list of groups user may access (INTERNAL, to be used only from groups_print_activity_menu()) * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode) */ function groups_get_activity_group($cm, $update=false, $allowedgroups=null) { global $USER, $SESSION; if (!$groupmode = groups_get_activity_groupmode($cm)) { // NOGROUPS used return false; } $context = context_module::instance($cm->id); if (has_capability('moodle/site:accessallgroups', $context)) { $groupmode = 'aag'; } if (!is_array($allowedgroups)) { if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') {
< $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid);
> $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid, 'g.*', false, true);
} else {
< $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid);
> $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.*', false, true);
} } _group_verify_activegroup($cm->course, $groupmode, $cm->groupingid, $allowedgroups); // set new active group if requested $changegroup = optional_param('group', -1, PARAM_INT); if ($update and $changegroup != -1) { if ($changegroup == 0) { // allgroups visible only in VISIBLEGROUPS or when accessallgroups if ($groupmode == VISIBLEGROUPS or $groupmode === 'aag') { $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = 0; } } else { if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) { $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = $changegroup; } } } return $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid]; } /** * Gets a list of groups that the user is allowed to access within the * specified activity. * * @category group * @param stdClass|cm_info $cm Course-module * @param int $userid User ID (defaults to current user) * @return array An array of group objects, or false if none */ function groups_get_activity_allowed_groups($cm,$userid=0) { // Use current user by default global $USER; if(!$userid) { $userid=$USER->id; } // Get groupmode for activity, taking into account course settings $groupmode=groups_get_activity_groupmode($cm); // If visible groups mode, or user has the accessallgroups capability, // then they can access all groups for the activity... $context = context_module::instance($cm->id); if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context, $userid)) {
< return groups_get_all_groups($cm->course, 0, $cm->groupingid);
> return groups_get_all_groups($cm->course, 0, $cm->groupingid, 'g.*', false, true);
} else { // ...otherwise they can only access groups they belong to
< return groups_get_all_groups($cm->course, $userid, $cm->groupingid);
> return groups_get_all_groups($cm->course, $userid, $cm->groupingid, 'g.*', false, true);
} } /** * Determine if a given group is visible to user or not in a given context. * * @since Moodle 2.6 * @param int $groupid Group id to test. 0 for all groups. * @param stdClass $course Course object. * @param stdClass $cm Course module object. * @param int $userid user id to test against. Defaults to $USER. * @return boolean true if visible, false otherwise */ function groups_group_visible($groupid, $course, $cm = null, $userid = null) { global $USER; if (empty($userid)) { $userid = $USER->id; } $groupmode = empty($cm) ? groups_get_course_groupmode($course) : groups_get_activity_groupmode($cm, $course); if ($groupmode == NOGROUPS || $groupmode == VISIBLEGROUPS) { // Groups are not used, or everything is visible, no need to go any further. return true; } $context = empty($cm) ? context_course::instance($course->id) : context_module::instance($cm->id); if (has_capability('moodle/site:accessallgroups', $context, $userid)) { // User can see everything. Groupid = 0 is handled here as well. return true; } else if ($groupid != 0) { // Group mode is separate, and user doesn't have access all groups capability. Check if user can see requested group. $groups = empty($cm) ? groups_get_all_groups($course->id, $userid) : groups_get_activity_allowed_groups($cm, $userid); if (array_key_exists($groupid, $groups)) { // User can see the group. return true; } } return false; } /** * Get sql and parameters that will return user ids for a group or groups * * @param int|array $groupids Where this is an array of multiple groups, it will match on members of any of the groups * @param context $context Course context or a context within a course. Mandatory when $groupid = USERSWITHOUTGROUP * @param int $groupsjointype Join type logic used. Defaults to 'Any' (logical OR). * @return array($sql, $params) * @throws coding_exception if empty or invalid context submitted when $groupid = USERSWITHOUTGROUP */ function groups_get_members_ids_sql($groupids, context $context = null, $groupsjointype = GROUPS_JOIN_ANY) { if (!is_array($groupids)) { $groupids = [$groupids]; } $groupjoin = groups_get_members_join($groupids, 'u.id', $context, $groupsjointype); $sql = "SELECT DISTINCT u.id FROM {user} u $groupjoin->joins WHERE u.deleted = 0"; if (!empty($groupjoin->wheres)) { $sql .= ' AND '. $groupjoin->wheres; } return array($sql, $groupjoin->params); } /**
> * Returns array with SQL and parameters returning userids and concatenated group names for given course * Get sql join to return users in a group > * * > * This function uses 'gn[0-9]+_' prefix for table names and parameters * @param int|array $groupids The groupids, 0 or [] means all groups and USERSWITHOUTGROUP no group > * * @param string $useridcolumn The column of the user id from the calling SQL, e.g. u.id > * @param int $courseid * @param context $context Course context or a context within a course. Mandatory when $groupids includes USERSWITHOUTGROUP > * @param string $separator * @param int $jointype Join type logic used. Defaults to 'Any' (logical OR). > * @return array [$sql, $params] * @return \core\dml\sql_join Contains joins, wheres, params > */ * @throws coding_exception if empty or invalid context submitted when $groupid = USERSWITHOUTGROUP > function groups_get_names_concat_sql(int $courseid, string $separator = ', '): array { */ > global $DB; function groups_get_members_join($groupids, $useridcolumn, context $context = null, int $jointype = GROUPS_JOIN_ANY) { > global $DB; > // Use unique prefix just in case somebody makes some SQL magic with the result. > static $i = 0; // Use unique prefix just in case somebody makes some SQL magic with the result. > $i++; static $i = 0; > $prefix = "gn{$i}_"; $i++; > $prefix = 'gm' . $i . '_'; > $groupalias = $prefix . 'g'; > $groupmemberalias = $prefix . 'gm'; if (!is_array($groupids)) { > $groupcourseparam = $prefix . 'courseid'; $groupids = $groupids ? [$groupids] : []; > } > $sqlgroupconcat = $DB->sql_group_concat("{$groupalias}.name", $separator, "{$groupalias}.name"); > $join = ''; > $sql = "SELECT {$groupmemberalias}.userid, {$sqlgroupconcat} AS groupnames $where = ''; > FROM {groups} {$groupalias} $param = []; > JOIN {groups_members} {$groupmemberalias} ON {$groupmemberalias}.groupid = {$groupalias}.id > WHERE {$groupalias}.courseid = :{$groupcourseparam} $coursecontext = (!empty($context)) ? $context->get_course_context() : null; > GROUP BY {$groupmemberalias}.userid"; if (in_array(USERSWITHOUTGROUP, $groupids) && empty($coursecontext)) { > // Throw an exception if $context is empty or invalid because it's needed to get the users without any group. > return [$sql, [$groupcourseparam => $courseid]]; throw new coding_exception('Missing or wrong $context parameter in an attempt to get members without any group'); > }; } > > /**
< $join = '';
> $joins = [];
if (($nogroupskey = array_search(USERSWITHOUTGROUP, $groupids)) !== false) {
> // Can we view hidden groups within a course? // Get members without any group. > [$ualias] = explode('.', $useridcolumn); $join .= "LEFT JOIN ( > $viewhidden = false; SELECT g.courseid, m.groupid, m.userid > if (!empty($coursecontext)) { FROM {groups_members} m > $viewhidden = \core_group\visibility::can_view_all_groups($coursecontext->instanceid); JOIN {groups} g ON g.id = m.groupid > }
< // Get members without any group. < $join .= "LEFT JOIN (
> $visibilityjoin = ''; > $visibilitywhere = ''; > > if (!$viewhidden) { > $visibilityjoin = 'JOIN {user} u ON u.id = m.userid'; > [$visibilitywhere, $visibilityparams] = \core_group\visibility::sql_member_visibility_where('g', 'm'); > $param = array_merge($param, $visibilityparams); > $visibilitywhere = 'WHERE ' . $visibilitywhere; > } > // Get members without any group, or only in groups we cannot see membership of. > $joins[] = "LEFT JOIN (
// Join type 'None' when filtering by 'no groups' means match users in at least one group.
> {$visibilityjoin} if ($jointype == GROUPS_JOIN_NONE) { > {$visibilitywhere}
$where = "{$prefix}gm.userid IS NOT NULL"; } else { // All other cases need to match users not in any group. $where = "{$prefix}gm.userid IS NULL"; }
< $param = ["{$prefix}gcourseid" => $coursecontext->instanceid];
> $param["{$prefix}gcourseid"] = $coursecontext->instanceid;
unset($groupids[$nogroupskey]); } // Handle any specified groups that need to be included. if (!empty($groupids)) { switch ($jointype) { case GROUPS_JOIN_ALL: // Handle matching all of the provided groups (logical AND). $joinallwheres = []; $aliaskey = 0; foreach ($groupids as $groupid) { $gmalias = "{$prefix}gm{$aliaskey}"; $aliaskey++;
< $join .= "LEFT JOIN {groups_members} {$gmalias}
> $joins[] = "LEFT JOIN {groups_members} {$gmalias}
ON ({$gmalias}.userid = {$useridcolumn} AND {$gmalias}.groupid = :{$gmalias}param)"; $joinallwheres[] = "{$gmalias}.userid IS NOT NULL"; $param["{$gmalias}param"] = $groupid;
> if (!$viewhidden) { } > $galias = "{$prefix}g{$aliaskey}"; > $joins[] = "LEFT JOIN {groups} {$galias} ON {$gmalias}.groupid = {$galias}.id"; // Members of all of the specified groups only. > [$visibilitywhere, $visibilityparams] = \core_group\visibility::sql_member_visibility_where( if (empty($where)) { > $galias, $where = '(' . implode(' AND ', $joinallwheres) . ')'; > $gmalias, } else { > $ualias, // Members of the specified groups and also no groups. > $prefix . $aliaskey . '_' // NOTE: This will always return no results, because you cannot be in specified groups and also be in no groups. > ); $where = '(' . $where . ' AND ' . implode(' AND ', $joinallwheres) . ')'; > $joinallwheres[] = $visibilitywhere; } > $param = array_merge($param, $visibilityparams); > }
break; case GROUPS_JOIN_ANY: // Handle matching any of the provided groups (logical OR). list($groupssql, $groupsparams) = $DB->get_in_or_equal($groupids, SQL_PARAMS_NAMED, $prefix);
< $join .= "LEFT JOIN {groups_members} {$prefix}gm2
> $joins[] = "LEFT JOIN {groups_members} {$prefix}gm2
ON ({$prefix}gm2.userid = {$useridcolumn} AND {$prefix}gm2.groupid {$groupssql})"; $param = array_merge($param, $groupsparams); // Members of any of the specified groups only. if (empty($where)) { $where = "{$prefix}gm2.userid IS NOT NULL"; } else { // Members of any of the specified groups or no groups. $where = "({$where} OR {$prefix}gm2.userid IS NOT NULL)"; }
> if (!$viewhidden) { break; > $joins[] = "LEFT JOIN {groups} {$prefix}g2 ON {$prefix}gm2.groupid = {$prefix}g2.id"; > [$visibilitywhere, $visibilityparams] = \core_group\visibility::sql_member_visibility_where( case GROUPS_JOIN_NONE: > $prefix . 'g2', // Handle matching none of the provided groups (logical NOT). > $prefix . 'gm2', list($groupssql, $groupsparams) = $DB->get_in_or_equal($groupids, SQL_PARAMS_NAMED, $prefix); > $ualias, > $prefix . 'param_' $join .= "LEFT JOIN {groups_members} {$prefix}gm2 > ); ON ({$prefix}gm2.userid = {$useridcolumn} AND {$prefix}gm2.groupid {$groupssql})"; > $where .= ' AND ' . $visibilitywhere; $param = array_merge($param, $groupsparams); > $param = array_merge($param, $visibilityparams); > } // Members of none of the specified groups only. >
< $join .= "LEFT JOIN {groups_members} {$prefix}gm2
> $joins[] = "LEFT JOIN {groups_members} {$prefix}gm2
$where = "{$prefix}gm2.userid IS NULL"; } else { // Members of any unspecified groups (not a member of the specified groups, and not a member of no groups). $where = "({$where} AND {$prefix}gm2.userid IS NULL)"; }
> if (!$viewhidden) { break; > $joins[] = "LEFT JOIN {groups} {$prefix}g2 ON {$prefix}gm2.groupid = {$prefix}g2.id"; } > [$visibilitywhere, $visibilityparams] = \core_group\visibility::sql_member_visibility_where( } > $prefix . 'g2', > $prefix . 'gm2', return new \core\dml\sql_join($join, $where, $param); > $ualias } > ); > $where .= ' OR NOT ' . $visibilitywhere; /** > $param = array_merge($param, $visibilityparams); * Internal method, sets up $SESSION->activegroup and verifies previous value > } * >
< return new \core\dml\sql_join($join, $where, $param);
> return new \core\dml\sql_join(implode("\n", $joins), $where, $param);
* @param int|string $groupmode SEPARATEGROUPS, VISIBLEGROUPS or 'aag' (access all groups) * @param int $groupingid 0 means all groups * @param array $allowedgroups list of groups user can see */ function _group_verify_activegroup($courseid, $groupmode, $groupingid, array $allowedgroups) { global $SESSION, $USER; // init activegroup array if necessary if (!isset($SESSION->activegroup)) { $SESSION->activegroup = array(); } if (!array_key_exists($courseid, $SESSION->activegroup)) { $SESSION->activegroup[$courseid] = array(SEPARATEGROUPS=>array(), VISIBLEGROUPS=>array(), 'aag'=>array()); } // make sure that the current group info is ok if (array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode]) and !array_key_exists($SESSION->activegroup[$courseid][$groupmode][$groupingid], $allowedgroups)) { // active group does not exist anymore or is 0 if ($SESSION->activegroup[$courseid][$groupmode][$groupingid] > 0 or $groupmode == SEPARATEGROUPS) { // do not do this if all groups selected and groupmode is not separate unset($SESSION->activegroup[$courseid][$groupmode][$groupingid]); } } // set up defaults if necessary if (!array_key_exists($groupingid, $SESSION->activegroup[$courseid][$groupmode])) { if ($groupmode == 'aag') { $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0; // all groups by default if user has accessallgroups } else if ($allowedgroups) {
< if ($groupmode != SEPARATEGROUPS and $mygroups = groups_get_all_groups($courseid, $USER->id, $groupingid)) {
> if ($groupmode != SEPARATEGROUPS > && $mygroups = groups_get_all_groups($courseid, $USER->id, $groupingid, 'g.*', false, true)) {
$firstgroup = reset($mygroups); } else { $firstgroup = reset($allowedgroups); } $SESSION->activegroup[$courseid][$groupmode][$groupingid] = $firstgroup->id; } else { // this happen when user not assigned into group in SEPARATEGROUPS mode or groups do not exist yet // mod authors must add extra checks for this when SEPARATEGROUPS mode used (such as when posting to forum) $SESSION->activegroup[$courseid][$groupmode][$groupingid] = 0; } } } /** * Caches group data for a particular course to speed up subsequent requests. * * @param int $courseid The course id to cache data for. * @param cache $cache The cache if it has already been initialised. If not a new one will be created. * @return stdClass A data object containing groups, groupings, and mappings. */ function groups_cache_groupdata($courseid, cache $cache = null) { global $DB; if ($cache === null) { // Initialise a cache if we wern't given one. $cache = cache::make('core', 'groupdata'); } // Get the groups that belong to the course. $groups = $DB->get_records('groups', array('courseid' => $courseid), 'name ASC'); // Get the groupings that belong to the course. $groupings = $DB->get_records('groupings', array('courseid' => $courseid), 'name ASC'); if (!is_array($groups)) { $groups = array(); } if (!is_array($groupings)) { $groupings = array(); } if (!empty($groupings)) { // Finally get the mappings between the two. list($insql, $params) = $DB->get_in_or_equal(array_keys($groupings)); $mappings = $DB->get_records_sql(" SELECT gg.id, gg.groupingid, gg.groupid FROM {groupings_groups} gg JOIN {groups} g ON g.id = gg.groupid WHERE gg.groupingid $insql ORDER BY g.name ASC", $params); } else { $mappings = array(); } // Prepare the data array. $data = new stdClass; $data->groups = $groups; $data->groupings = $groupings; $data->mappings = $mappings; // Cache the data. $cache->set($courseid, $data); // Finally return it so it can be used if desired. return $data; } /** * Gets group data for a course. * * This returns an object with the following properties: * - groups : An array of all the groups in the course. * - groupings : An array of all the groupings within the course. * - mappings : An array of group to grouping mappings. * * @param int $courseid The course id to get data for. * @param cache $cache The cache if it has already been initialised. If not a new one will be created. * @return stdClass */ function groups_get_course_data($courseid, cache $cache = null) { if ($cache === null) { // Initialise a cache if we wern't given one. $cache = cache::make('core', 'groupdata'); } // Try to retrieve it from the cache. $data = $cache->get($courseid); if ($data === false) { $data = groups_cache_groupdata($courseid, $cache); } return $data; } /** * Determine if the current user can see at least one of the groups of the specified user. * * @param stdClass $course Course object. * @param int $userid user id to check against. * @param stdClass $cm Course module object. Optional, just for checking at activity level instead course one. * @return boolean true if visible, false otherwise * @since Moodle 2.9 */ function groups_user_groups_visible($course, $userid, $cm = null) { global $USER; $groupmode = empty($cm) ? groups_get_course_groupmode($course) : groups_get_activity_groupmode($cm, $course); if ($groupmode == NOGROUPS || $groupmode == VISIBLEGROUPS) { // Groups are not used, or everything is visible, no need to go any further. return true; } $context = empty($cm) ? context_course::instance($course->id) : context_module::instance($cm->id); if (has_capability('moodle/site:accessallgroups', $context)) { // User can see everything. return true; } else { // Group mode is separate, and user doesn't have access all groups capability. if (empty($cm)) { $usergroups = groups_get_all_groups($course->id, $userid); $currentusergroups = groups_get_all_groups($course->id, $USER->id); } else { $usergroups = groups_get_activity_allowed_groups($cm, $userid); $currentusergroups = groups_get_activity_allowed_groups($cm, $USER->id); } $samegroups = array_intersect_key($currentusergroups, $usergroups); if (!empty($samegroups)) { // We share groups! return true; } } return false; } /** * Returns the users in the specified groups. * * This function does not return complete user objects by default. It returns the user_picture basic fields. * * @param array $groupsids The list of groups ids to check * @param array $extrafields extra fields to be included in result * @param int $sort optional sorting of returned users * @return array|bool Returns an array of the users for the specified group or false if no users or an error returned. * @since Moodle 3.3 */ function groups_get_groups_members($groupsids, $extrafields=null, $sort='lastname ASC') { global $DB;
> $wheres = [];
$userfieldsapi = \core_user\fields::for_userpic()->including(...($extrafields ?? [])); $userfields = $userfieldsapi->get_sql('u', false, '', '', false)->selects;
< list($insql, $params) = $DB->get_in_or_equal($groupsids);
> list($insql, $params) = $DB->get_in_or_equal($groupsids, SQL_PARAMS_NAMED); > $wheres[] = "gm.groupid $insql"; > > $courseids = $DB->get_fieldset_sql("SELECT DISTINCT courseid FROM {groups} WHERE id $insql", $params); > > if (count($courseids) > 1) { > // Groups from multiple courses. Have to check permission in system context. > $context = context_system::instance(); > } else { > $courseid = reset($courseids); > $context = context_course::instance($courseid); > } > > if (!has_capability('moodle/course:viewhiddengroups', $context)) { > list($visibilitywhere, $visibilityparams) = \core_group\visibility::sql_member_visibility_where(); > $params = array_merge($params, $visibilityparams); > $wheres[] = $visibilitywhere; > }
> $where = implode(' AND ', $wheres);
return $DB->get_records_sql("SELECT $userfields
< FROM {user} u, {groups_members} gm < WHERE u.id = gm.userid AND gm.groupid $insql
> FROM {user} u > JOIN {groups_members} gm ON u.id = gm.userid > JOIN {groups} g ON g.id = gm.groupid > WHERE {$where}
GROUP BY $userfields ORDER BY $sort", $params); } /** * Returns users who share group membership with the specified user in the given actiivty. * * @param stdClass|cm_info $cm course module * @param int $userid user id (empty for current user) * @return array a list of user * @since Moodle 3.3 */ function groups_get_activity_shared_group_members($cm, $userid = null) { global $USER; if (empty($userid)) {
< $userid = $USER;
> $userid = $USER->id;
} $groupsids = array_keys(groups_get_activity_allowed_groups($cm, $userid)); // No groups no users. if (empty($groupsids)) { return []; } return groups_get_groups_members($groupsids); }