[Summary view] [Print] [Text view]

   1  <?php  //$Id: grouplib.php,v 1.22.2.7 2008/04/13 21:58:31 skodak Exp $
   2  
   3  /**
   4   * Groups not used in course or activity
   5   */
   6  define('NOGROUPS', 0);
   7  
   8  /**
   9   * Groups used, users do not see other groups
  10   */
  11  define('SEPARATEGROUPS', 1);
  12  
  13  /**
  14   * Groups used, students see other groups
  15   */
  16  define('VISIBLEGROUPS', 2);
  17  
  18  
  19  /**
  20   * Determines if a group with a given groupid exists.
  21   * @param int $groupid The groupid to check for
  22   * @return boolean True if the group exists, false otherwise or if an error
  23   * occurred.
  24   */
  25  function groups_group_exists($groupid) {
  26      return record_exists('groups', 'id', $groupid);
  27  }
  28  
  29  /**
  30   * Gets the name of a group with a specified id
  31   * @param int $groupid The id of the group
  32   * @return string The name of the group
  33   */
  34  function groups_get_group_name($groupid) {
  35      return get_field('groups', 'name', 'id', $groupid);
  36  }
  37  
  38  /**
  39   * Gets the name of a grouping with a specified id
  40   * @param int $groupingid The id of the grouping
  41   * @return string The name of the grouping
  42   */
  43  function groups_get_grouping_name($groupingid) {
  44      return get_field('groupings', 'name', 'id', $groupingid);
  45  }
  46  
  47  /**
  48   * Returns the groupid of a group with the name specified for the course.
  49   * Group names should be unique in course
  50   * @param int $courseid The id of the course
  51   * @param string $name name of group (without magic quotes)
  52   * @return int $groupid
  53   */
  54  function groups_get_group_by_name($courseid, $name) {
  55      if ($groups = get_records_select('groups', "courseid=$courseid AND name='".addslashes($name)."'")) {
  56          return key($groups);
  57      }
  58      return false;
  59  }
  60  
  61  /**
  62   * Returns the groupingid of a grouping with the name specified for the course.
  63   * Grouping names should be unique in course
  64   * @param int $courseid The id of the course
  65   * @param string $name name of group (without magic quotes)
  66   * @return int $groupid
  67   */
  68  function groups_get_grouping_by_name($courseid, $name) {
  69      if ($groupings = get_records_select('groupings', "courseid=$courseid AND name='".addslashes($name)."'")) {
  70          return key($groupings);
  71      }
  72      return false;
  73  }
  74  
  75  /**
  76   * Get the group object
  77   * @param groupid ID of the group.
  78   * @return group object
  79   */
  80  function groups_get_group($groupid) {
  81      return get_record('groups', 'id', $groupid);
  82  }
  83  
  84  /**
  85   * Get the grouping object
  86   * @param groupingid ID of the group.
  87   * @return group object
  88   */
  89  function groups_get_grouping($groupingid) {
  90      return get_record('groupings', 'id', $groupingid);
  91  }
  92  
  93  /**
  94   * Gets array of all groups in a specified course.
  95   * @param int $courseid The id of the course.
  96   * @param mixed $userid optional user id or array of ids, returns only groups of the user.
  97   * @param int $groupingid optional returns only groups in the specified grouping.
  98   * @return array | false Returns an array of the group objects or false if no records
  99   * or an error occurred. (userid field returned if array in $userid)
 100   */
 101  function groups_get_all_groups($courseid, $userid=0, $groupingid=0, $fields='g.*') {
 102      global $CFG;
 103  
 104      // groupings are ignored when not enabled
 105      if (empty($CFG->enablegroupings)) {
 106          $groupingid = 0;
 107      }
 108  
 109      if (empty($userid)) {
 110          $userfrom  = "";
 111          $userwhere = "";
 112  
 113      } else if (is_array($userid)) {
 114          $userids = implode(',', $userid);
 115          $userfrom  = ", {$CFG->prefix}groups_members gm";
 116          $userwhere = "AND g.id = gm.groupid AND gm.userid IN ($userids)";
 117  
 118      } else {
 119          $userfrom  = ", {$CFG->prefix}groups_members gm";
 120          $userwhere = "AND g.id = gm.groupid AND gm.userid = '$userid'";
 121      }
 122  
 123      if (!empty($groupingid)) {
 124          $groupingfrom  = ", {$CFG->prefix}groupings_groups gg";
 125          $groupingwhere = "AND g.id = gg.groupid AND gg.groupingid = '$groupingid'";
 126      } else {
 127          $groupingfrom  = "";
 128          $groupingwhere = "";
 129      }
 130  
 131      return get_records_sql("SELECT $fields
 132                                FROM {$CFG->prefix}groups g $userfrom $groupingfrom
 133                               WHERE g.courseid = $courseid $userwhere $groupingwhere
 134                            ORDER BY name ASC");
 135  }
 136  
 137  /**
 138   * Returns info about user's groups in course.
 139   * @param int $courseid
 140   * @param int $userid $USER if not specified
 141   * @return array[groupingid][groupid] including grouping id 0 which means all groups
 142   */
 143  function groups_get_user_groups($courseid, $userid=0) {
 144      global $CFG, $USER;
 145  
 146      if (empty($userid)) {
 147          $userid = $USER->id;
 148      }
 149  
 150      if (!$rs = get_recordset_sql("SELECT g.id, gg.groupingid
 151                                      FROM {$CFG->prefix}groups g
 152                                           JOIN {$CFG->prefix}groups_members gm        ON gm.groupid = g.id
 153                                           LEFT JOIN {$CFG->prefix}groupings_groups gg ON gg.groupid = g.id
 154                                     WHERE gm.userid = $userid AND g.courseid = $courseid")) {
 155          return array('0' => array());
 156      }
 157  
 158      $result    = array();
 159      $allgroups = array();
 160      
 161      while ($group = rs_fetch_next_record($rs)) {
 162          $allgroups[$group->id] = $group->id;
 163          if (is_null($group->groupingid)) {
 164              continue;
 165          }
 166          if (!array_key_exists($group->groupingid, $result)) {
 167              $result[$group->groupingid] = array();
 168          }
 169          $result[$group->groupingid][$group->id] = $group->id;
 170      }
 171      rs_close($rs);
 172  
 173      $result['0'] = array_keys($allgroups); // all groups
 174  
 175      return $result;
 176  }
 177  
 178  /**
 179   * Gets array of all groupings in a specified course.
 180   * @param int $courseid return only groupings in this with this courseid
 181   * @return array | false Returns an array of the grouping objects or false if no records
 182   * or an error occurred.
 183   */
 184  function groups_get_all_groupings($courseid) {
 185      global $CFG;
 186  
 187      // groupings are ignored when not enabled
 188      if (empty($CFG->enablegroupings)) {
 189          return(false);
 190      }
 191      return get_records_sql("SELECT *
 192                                FROM {$CFG->prefix}groupings
 193                               WHERE courseid = $courseid
 194                            ORDER BY name ASC");
 195  }
 196  
 197  
 198  
 199  /**
 200   * Determines if the user is a member of the given group.
 201   *
 202   * @uses $USER If $userid is null, use the global object.
 203   * @param int $groupid The group to check for membership.
 204   * @param int $userid The user to check against the group.
 205   * @return boolean True if the user is a member, false otherwise.
 206   */
 207  function groups_is_member($groupid, $userid=null) {
 208      global $USER;
 209  
 210      if (!$userid) {
 211          $userid = $USER->id;
 212      }
 213  
 214      return record_exists('groups_members', 'groupid', $groupid, 'userid', $userid);
 215  }
 216  
 217  /**
 218   * Determines if current or specified is member of any active group in activity
 219   * @param object $cm coruse module object
 220   * @param int $userid id of user, null menas $USER->id
 221   * @return booelan true if user member of at least one group used in activity
 222   */
 223  function groups_has_membership($cm, $userid=null) {
 224      global $CFG, $USER;
 225  
 226      static $cache = array();
 227  
 228      // groupings are ignored when not enabled
 229      if (empty($CFG->enablegroupings)) {
 230          $cm->groupingid = 0;
 231      }
 232  
 233      if (empty($userid)) {
 234          $userid = $USER->id;
 235      }
 236  
 237      $cachekey = $userid.'|'.$cm->course.'|'.$cm->groupingid;
 238      if (isset($cache[$cachekey])) {
 239          return($cache[$cachekey]);
 240      }
 241  
 242      if ($cm->groupingid) {
 243          // find out if member of any group in selected activity grouping
 244          $sql = "SELECT 'x'
 245                    FROM {$CFG->prefix}groups_members gm, {$CFG->prefix}groupings_groups gg
 246                   WHERE gm.userid = $userid AND gm.groupid = gg.groupid AND gg.groupingid = {$cm->groupingid}";
 247  
 248      } else {
 249          // no grouping used - check all groups in course
 250          $sql = "SELECT 'x'
 251                    FROM {$CFG->prefix}groups_members gm, {$CFG->prefix}groups g
 252                   WHERE gm.userid = $userid AND gm.groupid = g.id AND g.courseid = {$cm->course}";
 253      }
 254  
 255      $cache[$cachekey] = record_exists_sql($sql);
 256  
 257      return $cache[$cachekey];
 258  }
 259  
 260  /**
 261   * Returns the users in the specified group.
 262   * @param int $groupid The groupid to get the users for
 263   * @param int $fields The fields to return
 264   * @param int $sort optional sorting of returned users
 265   * @return array | false Returns an array of the users for the specified
 266   * group or false if no users or an error returned.
 267   */
 268  function groups_get_members($groupid, $fields='u.*', $sort='lastname ASC') {
 269      global $CFG;
 270  
 271      return get_records_sql("SELECT $fields
 272                                FROM {$CFG->prefix}user u, {$CFG->prefix}groups_members gm
 273                               WHERE u.id = gm.userid AND gm.groupid = '$groupid'
 274                            ORDER BY $sort");
 275  }
 276  
 277  
 278  /**
 279   * Returns the users in the specified grouping.
 280   * @param int $groupingid The groupingid to get the users for
 281   * @param int $fields The fields to return
 282   * @param int $sort optional sorting of returned users
 283   * @return array | false Returns an array of the users for the specified
 284   * group or false if no users or an error returned.
 285   */
 286  function groups_get_grouping_members($groupingid, $fields='u.*', $sort='lastname ASC') {
 287      global $CFG;
 288  
 289      return get_records_sql("SELECT $fields
 290                                FROM {$CFG->prefix}user u
 291                                  INNER JOIN {$CFG->prefix}groups_members gm ON u.id = gm.userid
 292                                  INNER JOIN {$CFG->prefix}groupings_groups gg ON gm.groupid = gg.groupid
 293                               WHERE  gg.groupingid = $groupingid
 294                            ORDER BY $sort");
 295  }
 296  
 297  /**
 298   * Returns effective groupmode used in course
 299   * @return integer group mode
 300   */
 301  function groups_get_course_groupmode($course) {
 302      return $course->groupmode;
 303  }
 304  
 305  /**
 306   * Returns effective groupmode used in activity, course setting
 307   * overrides activity setting if groupmodeforce enabled.
 308   * @param $cm the course module object. Only the ->course and ->groupmode need to be set.
 309   * @param $course object optional course object to improve perf
 310   * @return integer group mode
 311   */
 312  function groups_get_activity_groupmode($cm, $course=null) {
 313      global $COURSE;
 314  
 315      // get course object (reuse COURSE if possible)
 316      if (isset($course->id) and $course->id == $cm->course) {
 317          //ok
 318      } else if ($cm->course == $COURSE->id) {
 319          $course = $COURSE;
 320      } else {
 321          if (!$course = get_record('course', 'id', $cm->course)) {
 322              error('Incorrect course id in cm');
 323          }
 324      }
 325  
 326      return empty($course->groupmodeforce) ? $cm->groupmode : $course->groupmode;
 327  }
 328  
 329  /**
 330   * Print group menu selector for course level.
 331   * @param object $course course object
 332   * @param string $urlroot return address
 333   * @param boolean $return return as string instead of printing
 334   * @return mixed void or string depending on $return param
 335   */
 336  function groups_print_course_menu($course, $urlroot, $return=false) {
 337      global $CFG, $USER, $SESSION;
 338  
 339      if (!$groupmode = $course->groupmode) {
 340          if ($return) {
 341              return '';
 342          } else {
 343              return;
 344          }
 345      }
 346  
 347      $context = get_context_instance(CONTEXT_COURSE, $course->id);
 348      if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context)) {
 349          $allowedgroups = groups_get_all_groups($course->id, 0);
 350          // detect changes related to groups and fix active group
 351          if (!empty($SESSION->activegroup[$course->id][VISIBLEGROUPS][0])) {
 352              if (!array_key_exists($SESSION->activegroup[$course->id][VISIBLEGROUPS][0], $allowedgroups)) {
 353                  // active does not exist anymore
 354                  unset($SESSION->activegroup[$course->id][VISIBLEGROUPS][0]);
 355              }
 356          }
 357          if (!empty($SESSION->activegroup[$course->id]['aag'][0])) {
 358              if (!array_key_exists($SESSION->activegroup[$course->id]['aag'][0], $allowedgroups)) {
 359                  // active group does not exist anymore
 360                  unset($SESSION->activegroup[$course->id]['aag'][0]);
 361              }
 362          }
 363  
 364      } else {
 365          $allowedgroups = groups_get_all_groups($course->id, $USER->id);
 366          // detect changes related to groups and fix active group
 367          if (isset($SESSION->activegroup[$course->id][SEPARATEGROUPS][0])) {
 368              if ($SESSION->activegroup[$course->id][SEPARATEGROUPS][0] == 0) {
 369                  if ($allowedgroups) {
 370                      // somebody must have assigned at least one group, we can select it now - yay!
 371                      unset($SESSION->activegroup[$course->id][SEPARATEGROUPS][0]);
 372                  }
 373              } else {
 374                  if (!array_key_exists($SESSION->activegroup[$course->id][SEPARATEGROUPS][0], $allowedgroups)) {
 375                      // active group not allowed or does not exist anymore
 376                      unset($SESSION->activegroup[$course->id][SEPARATEGROUPS][0]);
 377                  }
 378              }
 379          }
 380      }
 381  
 382      $activegroup = groups_get_course_group($course, true);
 383  
 384      $groupsmenu = array();
 385      if (!$allowedgroups or $groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context)) {
 386          $groupsmenu[0] = get_string('allparticipants');
 387      }
 388  
 389      if ($allowedgroups) {
 390          foreach ($allowedgroups as $group) {
 391              $groupsmenu[$group->id] = format_string($group->name);
 392          }
 393      }
 394  
 395      if ($groupmode == VISIBLEGROUPS) {
 396          $grouplabel = get_string('groupsvisible');
 397      } else {
 398          $grouplabel = get_string('groupsseparate');
 399      }
 400  
 401      if (count($groupsmenu) == 1) {
 402          $groupname = reset($groupsmenu);
 403          $output = $grouplabel.': '.$groupname;
 404      } else {
 405          $output = popup_form($urlroot.'&amp;group=', $groupsmenu, 'selectgroup', $activegroup, '', '', '', true, 'self', $grouplabel);
 406      }
 407  
 408      $output = '<div class="groupselector">'.$output.'</div>';
 409  
 410      if ($return) {
 411          return $output;
 412      } else {
 413          echo $output;
 414      }
 415  }
 416  
 417  /**
 418   * Print group menu selector for activity.
 419   * @param object $cm course module object
 420   * @param string $urlroot return address that users get to if they choose an option;
 421   *   should include any parameters needed, e.g. 'view.php?id=34'
 422   * @param boolean $return return as string instead of printing
 423   * @param boolean $hideallparticipants If true, this prevents the 'All participants'
 424   *   option from appearing in cases where it normally would. This is intended for
 425   *   use only by activities that cannot display all groups together. (Note that
 426   *   selecting this option does not prevent groups_get_activity_group from
 427   *   returning 0; it will still do that if the user has chosen 'all participants'
 428   *   in another activity, or not chosen anything.)
 429   * @return mixed void or string depending on $return param
 430   */
 431  function groups_print_activity_menu($cm, $urlroot, $return=false, $hideallparticipants=false) {
 432      global $CFG, $USER, $SESSION;
 433  
 434      // groupings are ignored when not enabled
 435      if (empty($CFG->enablegroupings)) {
 436          $cm->groupingid = 0;
 437      }
 438  
 439      if (!$groupmode = groups_get_activity_groupmode($cm)) {
 440          if ($return) {
 441              return '';
 442          } else {
 443              return;
 444          }
 445      }
 446  
 447      $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 448      if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context)) {
 449          $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid); // any group in grouping (all if groupings not used)
 450          // detect changes related to groups and fix active group
 451          if (!empty($SESSION->activegroup[$cm->course][VISIBLEGROUPS][$cm->groupingid])) {
 452              if (!array_key_exists($SESSION->activegroup[$cm->course][VISIBLEGROUPS][$cm->groupingid], $allowedgroups)) {
 453                  // active group does not exist anymore
 454                  unset($SESSION->activegroup[$cm->course][VISIBLEGROUPS][$cm->groupingid]);
 455              }
 456          }
 457          if (!empty($SESSION->activegroup[$cm->course]['aag'][$cm->groupingid])) {
 458              if (!array_key_exists($SESSION->activegroup[$cm->course]['aag'][$cm->groupingid], $allowedgroups)) {
 459                  // active group does not exist anymore
 460                  unset($SESSION->activegroup[$cm->course]['aag'][$cm->groupingid]);
 461              }
 462          }
 463  
 464      } else {
 465          $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid); // only assigned groups
 466          // detect changes related to groups and fix active group
 467          if (isset($SESSION->activegroup[$cm->course][SEPARATEGROUPS][$cm->groupingid])) {
 468              if ($SESSION->activegroup[$cm->course][SEPARATEGROUPS][$cm->groupingid] == 0) {
 469                  if ($allowedgroups) {
 470                      // somebody must have assigned at least one group, we can select it now - yay!
 471                      unset($SESSION->activegroup[$cm->course][SEPARATEGROUPS][$cm->groupingid]);
 472                  }
 473              } else {
 474                  if (!array_key_exists($SESSION->activegroup[$cm->course][SEPARATEGROUPS][$cm->groupingid], $allowedgroups)) {
 475                      // active group not allowed or does not exist anymore
 476                      unset($SESSION->activegroup[$cm->course][SEPARATEGROUPS][$cm->groupingid]);
 477                  }
 478              }
 479          }
 480      }
 481  
 482      $activegroup = groups_get_activity_group($cm, true);
 483  
 484      $groupsmenu = array();
 485      if ((!$allowedgroups or $groupmode == VISIBLEGROUPS or
 486        has_capability('moodle/site:accessallgroups', $context)) and !$hideallparticipants) {
 487          $groupsmenu[0] = get_string('allparticipants');
 488      }
 489  
 490      if ($allowedgroups) {
 491          foreach ($allowedgroups as $group) {
 492              $groupsmenu[$group->id] = format_string($group->name);
 493          }
 494      }
 495  
 496      if ($groupmode == VISIBLEGROUPS) {
 497          $grouplabel = get_string('groupsvisible');
 498      } else {
 499          $grouplabel = get_string('groupsseparate');
 500      }
 501  
 502      if (count($groupsmenu) == 1) {
 503          $groupname = reset($groupsmenu);
 504          $output = $grouplabel.': '.$groupname;
 505      } else {
 506          $output = popup_form($urlroot.'&amp;group=', $groupsmenu, 'selectgroup', $activegroup, '', '', '', true, 'self', $grouplabel);
 507      }
 508  
 509      $output = '<div class="groupselector">'.$output.'</div>';
 510  
 511      if ($return) {
 512          return $output;
 513      } else {
 514          echo $output;
 515      }
 516  }
 517  
 518  /**
 519   * Returns group active in course, changes the group by default if 'group' page param present
 520   *
 521   * @param object $course course bject
 522   * @param boolean $update change active group if group param submitted
 523   * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
 524   */
 525  function groups_get_course_group($course, $update=false) {
 526      global $CFG, $USER, $SESSION;
 527  
 528      if (!$groupmode = $course->groupmode) {
 529          // NOGROUPS used
 530          return false;
 531      }
 532  
 533      // init activegroup array
 534      if (!array_key_exists('activegroup', $SESSION)) {
 535          $SESSION->activegroup = array();
 536      }
 537      if (!array_key_exists($course->id, $SESSION->activegroup)) {
 538          $SESSION->activegroup[$course->id] = array(SEPARATEGROUPS=>array(), VISIBLEGROUPS=>array(), 'aag'=>array());
 539      }
 540  
 541      $context = get_context_instance(CONTEXT_COURSE, $course->id);
 542      if (has_capability('moodle/site:accessallgroups', $context)) {
 543          $groupmode = 'aag';
 544      }
 545  
 546      // grouping used the first time - add first user group as default
 547      if (!array_key_exists(0, $SESSION->activegroup[$course->id][$groupmode])) {
 548          if ($groupmode == 'aag') {
 549              $SESSION->activegroup[$course->id][$groupmode][0] = 0; // all groups by default if user has accessallgroups
 550  
 551          } else if ($usergroups = groups_get_all_groups($course->id, $USER->id, 0)) {
 552              $fistgroup = reset($usergroups);
 553              $SESSION->activegroup[$course->id][$groupmode][0] = $fistgroup->id;
 554  
 555          } else {
 556              // this happen when user not assigned into group in SEPARATEGROUPS mode or groups do not exist yet
 557              // mod authors must add extra checks for this when SEPARATEGROUPS mode used (such as when posting to forum)
 558              $SESSION->activegroup[$course->id][$groupmode][0] = 0;
 559          }
 560      }
 561  
 562      // set new active group if requested
 563      $changegroup = optional_param('group', -1, PARAM_INT);
 564      if ($update and $changegroup != -1) {
 565  
 566          if ($changegroup == 0) {
 567              // do not allow changing to all groups without accessallgroups capability
 568              if ($groupmode == VISIBLEGROUPS or $groupmode == 'aag') {
 569                  $SESSION->activegroup[$course->id][$groupmode][0] = 0;
 570              }
 571  
 572          } else {
 573              // first make list of allowed groups
 574              if ($groupmode == VISIBLEGROUPS or $groupmode == 'aag') {
 575                  $allowedgroups = groups_get_all_groups($course->id, 0, 0);
 576              } else {
 577                  $allowedgroups = groups_get_all_groups($course->id, $USER->id, 0);
 578              }
 579  
 580              if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
 581                  $SESSION->activegroup[$course->id][$groupmode][0] = $changegroup;
 582              }
 583          }
 584      }
 585  
 586      return $SESSION->activegroup[$course->id][$groupmode][0];
 587  }
 588  
 589  /**
 590   * Returns group active in activity, changes the group by default if 'group' page param present
 591   *
 592   * @param object $cm course module object
 593   * @param boolean $update change active group if group param submitted
 594   * @return mixed false if groups not used, int if groups used, 0 means all groups (access must be verified in SEPARATE mode)
 595   */
 596  function groups_get_activity_group($cm, $update=false) {
 597      global $CFG, $USER, $SESSION;
 598  
 599      // groupings are ignored when not enabled
 600      if (empty($CFG->enablegroupings)) {
 601          $cm->groupingid = 0;
 602      }
 603  
 604      if (!$groupmode = groups_get_activity_groupmode($cm)) {
 605          // NOGROUPS used
 606          return false;
 607      }
 608  
 609      // init activegroup array
 610      if (!array_key_exists('activegroup', $SESSION)) {
 611          $SESSION->activegroup = array();
 612      }
 613      if (!array_key_exists($cm->course, $SESSION->activegroup)) {
 614          $SESSION->activegroup[$cm->course] = array(SEPARATEGROUPS=>array(), VISIBLEGROUPS=>array(), 'aag'=>array());
 615      }
 616  
 617      $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 618      if (has_capability('moodle/site:accessallgroups', $context)) {
 619          $groupmode = 'aag';
 620      }
 621  
 622      // grouping used the first time - add first user group as default
 623      if (!array_key_exists($cm->groupingid, $SESSION->activegroup[$cm->course][$groupmode])) {
 624          if ($groupmode == 'aag') {
 625              $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = 0; // all groups by default if user has accessallgroups
 626  
 627          } else if ($usergroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid)) {
 628              $fistgroup = reset($usergroups);
 629              $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = $fistgroup->id;
 630  
 631          } else {
 632              // this happen when user not assigned into group in SEPARATEGROUPS mode or groups do not exist yet
 633              // mod authors must add extra checks for this when SEPARATEGROUPS mode used (such as when posting to forum)
 634              $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = 0;
 635          }
 636      }
 637  
 638      // set new active group if requested
 639      $changegroup = optional_param('group', -1, PARAM_INT);
 640      if ($update and $changegroup != -1) {
 641  
 642          if ($changegroup == 0) {
 643              // allgroups visible only in VISIBLEGROUPS or when accessallgroups
 644              if ($groupmode == VISIBLEGROUPS or $groupmode == 'aag') {
 645                  $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = 0;
 646              }
 647  
 648          } else {
 649              // first make list of allowed groups
 650              if ($groupmode == VISIBLEGROUPS or $groupmode == 'aag') {
 651                  $allowedgroups = groups_get_all_groups($cm->course, 0, $cm->groupingid); // any group in grouping (all if groupings not used)
 652              } else {
 653                  $allowedgroups = groups_get_all_groups($cm->course, $USER->id, $cm->groupingid); // only assigned groups
 654              }
 655  
 656              if ($allowedgroups and array_key_exists($changegroup, $allowedgroups)) {
 657                  $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid] = $changegroup;
 658              }
 659          }
 660      }
 661  
 662      return $SESSION->activegroup[$cm->course][$groupmode][$cm->groupingid];
 663  }
 664  
 665  /**
 666   * Gets a list of groups that the user is allowed to access within the
 667   * specified activity.
 668   * @param object $cm Course-module
 669   * @param int $userid User ID (defaults to current user)
 670   * @return array An array of group objects, or false if none
 671   */
 672  function groups_get_activity_allowed_groups($cm,$userid=0) {
 673      // Use current user by default
 674      global $USER;
 675      if(!$userid) {
 676          $userid=$USER->id;
 677      }
 678  
 679      // Get groupmode for activity, taking into account course settings
 680      $groupmode=groups_get_activity_groupmode($cm);
 681  
 682      // If visible groups mode, or user has the accessallgroups capability,
 683      // then they can access all groups for the activity...
 684      $context = get_context_instance(CONTEXT_MODULE, $cm->id);
 685      if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $context)) {
 686          return groups_get_all_groups($cm->course, 0, $cm->groupingid);
 687      } else {
 688          // ...otherwise they can only access groups they belong to
 689          return groups_get_all_groups($cm->course, $userid, $cm->groupingid);
 690      }
 691  }
 692  
 693  /**
 694   * Determine if a course module is currently visible to a user
 695   * @uses $USER If $userid is null, use the global object.
 696   * @param int $cm The course module
 697   * @param int $userid The user to check against the group.
 698   * @return boolean True if the user can view the course module, false otherwise.
 699   */
 700  function groups_course_module_visible($cm, $userid=null) {
 701      global $CFG, $USER;
 702  
 703      if (empty($userid)) {
 704          $userid = $USER->id;
 705      }
 706      if (empty($CFG->enablegroupings)) {
 707          return true;
 708      }
 709      if (empty($cm->groupmembersonly)) {
 710          return true;
 711      }
 712      if (has_capability('moodle/site:accessallgroups', get_context_instance(CONTEXT_MODULE, $cm->id), $userid) or groups_has_membership($cm, $userid)) {
 713          return true;
 714      }
 715      return false;
 716  }
 717  
 718  ?>