[Summary view]

Differences Between: [Versions 311 and 401] [Versions 311 and 402] [Versions 311 and 403]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  /**
  18   * Local stuff for meta course enrolment plugin.
  19   *
  20   * @package    enrol_meta
  21   * @copyright  2010 Petr Skoda {@link http://skodak.org}
  22   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  defined('MOODLE_INTERNAL') || die();
  26  
  27  
  28  /**
  29   * Event handler for meta enrolment plugin.
  30   *
  31   * We try to keep everything in sync via listening to events,
  32   * it may fail sometimes, so we always do a full sync in cron too.
  33   */
  34  class enrol_meta_handler {
  35  
  36      /**
  37       * Synchronise meta enrolments of this user in this course
  38       * @static
  39       * @param int $courseid
  40       * @param int $userid
  41       * @return void
  42       */
  43      protected static function sync_course_instances($courseid, $userid) {
  44          global $DB;
  45  
  46          static $preventrecursion = false;
  47  
  48          // does anything want to sync with this parent?
  49          if (!$enrols = $DB->get_records('enrol', array('customint1'=>$courseid, 'enrol'=>'meta'), 'id ASC')) {
  50              return;
  51          }
  52  
  53          if ($preventrecursion) {
  54              return;
  55          }
  56  
  57          $preventrecursion = true;
  58  
  59          try {
  60              foreach ($enrols as $enrol) {
  61                  self::sync_with_parent_course($enrol, $userid);
  62              }
  63          } catch (Exception $e) {
  64              $preventrecursion = false;
  65              throw $e;
  66          }
  67  
  68          $preventrecursion = false;
  69      }
  70  
  71      /**
  72       * Synchronise user enrolments in given instance as fast as possible.
  73       *
  74       * All roles are removed if the meta plugin disabled.
  75       *
  76       * @static
  77       * @param stdClass $instance
  78       * @param int $userid
  79       * @return void
  80       */
  81      protected static function sync_with_parent_course(stdClass $instance, $userid) {
  82          global $DB, $CFG;
  83          require_once($CFG->dirroot . '/group/lib.php');
  84  
  85          $plugin = enrol_get_plugin('meta');
  86  
  87          if ($instance->customint1 == $instance->courseid) {
  88              // can not sync with self!!!
  89              return;
  90          }
  91  
  92          $context = context_course::instance($instance->courseid);
  93  
  94          // list of enrolments in parent course (we ignore meta enrols in parents completely)
  95          list($enabled, $params) = $DB->get_in_or_equal(explode(',', $CFG->enrol_plugins_enabled), SQL_PARAMS_NAMED, 'e');
  96          $params['userid'] = $userid;
  97          $params['parentcourse'] = $instance->customint1;
  98          $sql = "SELECT ue.*, e.status AS enrolstatus
  99                    FROM {user_enrolments} ue
 100                    JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol <> 'meta' AND e.courseid = :parentcourse AND e.enrol $enabled)
 101                   WHERE ue.userid = :userid";
 102          $parentues = $DB->get_records_sql($sql, $params);
 103          // current enrolments for this instance
 104          $ue = $DB->get_record('user_enrolments', array('enrolid'=>$instance->id, 'userid'=>$userid));
 105  
 106          // first deal with users that are not enrolled in parent
 107          if (empty($parentues)) {
 108              self::user_not_supposed_to_be_here($instance, $ue, $context, $plugin);
 109              return;
 110          }
 111  
 112          if (!$parentcontext = context_course::instance($instance->customint1, IGNORE_MISSING)) {
 113              // Weird, we should not get here.
 114              return;
 115          }
 116  
 117          $skiproles = $plugin->get_config('nosyncroleids', '');
 118          $skiproles = empty($skiproles) ? array() : explode(',', $skiproles);
 119          $syncall   = $plugin->get_config('syncall', 1);
 120  
 121          // roles in parent course (meta enrols must be ignored!)
 122          $parentroles = array();
 123          list($ignoreroles, $params) = $DB->get_in_or_equal($skiproles, SQL_PARAMS_NAMED, 'ri', false, -1);
 124          $params['contextid'] = $parentcontext->id;
 125          $params['userid'] = $userid;
 126          $select = "contextid = :contextid AND userid = :userid AND component <> 'enrol_meta' AND roleid $ignoreroles";
 127          foreach($DB->get_records_select('role_assignments', $select, $params) as $ra) {
 128              $parentroles[$ra->roleid] = $ra->roleid;
 129          }
 130  
 131          // roles from this instance
 132          $roles = array();
 133          $ras = $DB->get_records('role_assignments', array('contextid'=>$context->id, 'userid'=>$userid, 'component'=>'enrol_meta', 'itemid'=>$instance->id));
 134          foreach($ras as $ra) {
 135              $roles[$ra->roleid] = $ra->roleid;
 136          }
 137          unset($ras);
 138  
 139          // do we want users without roles?
 140          if (!$syncall and empty($parentroles)) {
 141              self::user_not_supposed_to_be_here($instance, $ue, $context, $plugin);
 142              return;
 143          }
 144  
 145          // Is parent enrol active? Find minimum timestart and maximum timeend of all active enrolments.
 146          $parentstatus = ENROL_USER_SUSPENDED;
 147          $parenttimeend = null;
 148          $parenttimestart = null;
 149          foreach ($parentues as $pue) {
 150              if ($pue->status == ENROL_USER_ACTIVE && $pue->enrolstatus == ENROL_INSTANCE_ENABLED) {
 151                  $parentstatus = ENROL_USER_ACTIVE;
 152                  if ($parenttimeend === null || $pue->timeend == 0 || ($parenttimeend && $parenttimeend < $pue->timeend)) {
 153                      $parenttimeend = $pue->timeend;
 154                  }
 155                  if ($parenttimestart === null || $parenttimestart > $pue->timestart) {
 156                      $parenttimestart = $pue->timestart;
 157                  }
 158              }
 159          }
 160  
 161          // Enrol user if not enrolled yet or fix status/timestart/timeend. Use the minimum timestart and maximum timeend found above.
 162          if ($ue) {
 163              if ($parentstatus != $ue->status ||
 164                      ($parentstatus == ENROL_USER_ACTIVE && ($parenttimestart != $ue->timestart || $parenttimeend != $ue->timeend))) {
 165                  $plugin->update_user_enrol($instance, $userid, $parentstatus, $parenttimestart, $parenttimeend);
 166                  $ue->status = $parentstatus;
 167                  $ue->timestart = $parenttimestart;
 168                  $ue->timeend = $parenttimeend;
 169              }
 170          } else {
 171              $plugin->enrol_user($instance, $userid, NULL, (int)$parenttimestart, (int)$parenttimeend, $parentstatus);
 172              $ue = new stdClass();
 173              $ue->userid = $userid;
 174              $ue->enrolid = $instance->id;
 175              $ue->status = $parentstatus;
 176              if ($instance->customint2) {
 177                  groups_add_member($instance->customint2, $userid, 'enrol_meta', $instance->id);
 178              }
 179          }
 180  
 181          $unenrolaction = $plugin->get_config('unenrolaction', ENROL_EXT_REMOVED_SUSPENDNOROLES);
 182  
 183          // Only active users in enabled instances are supposed to have roles (we can reassign the roles any time later).
 184          if ($ue->status != ENROL_USER_ACTIVE or $instance->status != ENROL_INSTANCE_ENABLED or
 185                  ($parenttimeend and $parenttimeend < time()) or ($parenttimestart > time())) {
 186              if ($unenrolaction == ENROL_EXT_REMOVED_SUSPEND) {
 187                  // Always keep the roles.
 188              } else if ($roles) {
 189                  // This will only unassign roles that were assigned in this enrolment method, leaving all manual role assignments intact.
 190                  role_unassign_all(array('userid'=>$userid, 'contextid'=>$context->id, 'component'=>'enrol_meta', 'itemid'=>$instance->id));
 191              }
 192              return;
 193          }
 194  
 195          // add new roles
 196          foreach ($parentroles as $rid) {
 197              if (!isset($roles[$rid])) {
 198                  role_assign($rid, $userid, $context->id, 'enrol_meta', $instance->id);
 199              }
 200          }
 201  
 202          if ($unenrolaction == ENROL_EXT_REMOVED_SUSPEND) {
 203              // Always keep the roles.
 204              return;
 205          }
 206  
 207          // remove roles
 208          foreach ($roles as $rid) {
 209              if (!isset($parentroles[$rid])) {
 210                  role_unassign($rid, $userid, $context->id, 'enrol_meta', $instance->id);
 211              }
 212          }
 213      }
 214  
 215      /**
 216       * Deal with users that are not supposed to be enrolled via this instance
 217       * @static
 218       * @param stdClass $instance
 219       * @param stdClass $ue
 220       * @param context_course $context
 221       * @param enrol_meta $plugin
 222       * @return void
 223       */
 224      protected static function user_not_supposed_to_be_here($instance, $ue, context_course $context, $plugin) {
 225          if (!$ue) {
 226              // Not enrolled yet - simple!
 227              return;
 228          }
 229  
 230          $userid = $ue->userid;
 231          $unenrolaction = $plugin->get_config('unenrolaction', ENROL_EXT_REMOVED_SUSPENDNOROLES);
 232  
 233          if ($unenrolaction == ENROL_EXT_REMOVED_UNENROL) {
 234              // Purges grades, group membership, preferences, etc. - admins were warned!
 235              $plugin->unenrol_user($instance, $userid);
 236  
 237          } else if ($unenrolaction == ENROL_EXT_REMOVED_SUSPEND) {
 238              if ($ue->status != ENROL_USER_SUSPENDED) {
 239                  $plugin->update_user_enrol($instance, $userid, ENROL_USER_SUSPENDED);
 240              }
 241  
 242          } else if ($unenrolaction == ENROL_EXT_REMOVED_SUSPENDNOROLES) {
 243              if ($ue->status != ENROL_USER_SUSPENDED) {
 244                  $plugin->update_user_enrol($instance, $userid, ENROL_USER_SUSPENDED);
 245              }
 246              role_unassign_all(array('userid'=>$userid, 'contextid'=>$context->id, 'component'=>'enrol_meta', 'itemid'=>$instance->id));
 247  
 248          } else {
 249              debugging('Unknown unenrol action '.$unenrolaction);
 250          }
 251      }
 252  }
 253  
 254  /**
 255   * Sync all meta course links.
 256   *
 257   * @param int $courseid one course, empty mean all
 258   * @param bool $verbose verbose CLI output
 259   * @return int 0 means ok, 1 means error, 2 means plugin disabled
 260   */
 261  function enrol_meta_sync($courseid = NULL, $verbose = false) {
 262      global $CFG, $DB;
 263      require_once("{$CFG->dirroot}/group/lib.php");
 264  
 265      // purge all roles if meta sync disabled, those can be recreated later here in cron
 266      if (!enrol_is_enabled('meta')) {
 267          if ($verbose) {
 268              mtrace('Meta sync plugin is disabled, unassigning all plugin roles and stopping.');
 269          }
 270          role_unassign_all(array('component'=>'enrol_meta'));
 271          return 2;
 272      }
 273  
 274      // unfortunately this may take a long time, execution can be interrupted safely
 275      core_php_time_limit::raise();
 276      raise_memory_limit(MEMORY_HUGE);
 277  
 278      if ($verbose) {
 279          mtrace('Starting user enrolment synchronisation...');
 280      }
 281  
 282      $instances = array(); // cache instances
 283  
 284      $meta = enrol_get_plugin('meta');
 285  
 286      $unenrolaction = $meta->get_config('unenrolaction', ENROL_EXT_REMOVED_SUSPENDNOROLES);
 287      $skiproles     = $meta->get_config('nosyncroleids', '');
 288      $skiproles     = empty($skiproles) ? array() : explode(',', $skiproles);
 289      $syncall       = $meta->get_config('syncall', 1);
 290  
 291      $allroles = get_all_roles();
 292  
 293  
 294      // Iterate through all not enrolled yet users. For each active enrolment of each user find the minimum
 295      // enrolment startdate and maximum enrolment enddate.
 296      // This SQL relies on the fact that ENROL_USER_ACTIVE < ENROL_USER_SUSPENDED
 297      // and ENROL_INSTANCE_ENABLED < ENROL_INSTANCE_DISABLED. Condition "pue.status + pe.status = 0" means
 298      // that enrolment is active. When MIN(pue.status + pe.status)=0 it means there exists an active
 299      // enrolment.
 300      $onecourse = $courseid ? "AND e.courseid = :courseid" : "";
 301      list($enabled, $params) = $DB->get_in_or_equal(explode(',', $CFG->enrol_plugins_enabled), SQL_PARAMS_NAMED, 'e');
 302      $params['courseid'] = $courseid;
 303      $sql = "SELECT pue.userid, e.id AS enrolid, MIN(pue.status + pe.status) AS status,
 304                        MIN(CASE WHEN (pue.status + pe.status = 0) THEN pue.timestart ELSE 9999999999 END) AS timestart,
 305                        MAX(CASE WHEN (pue.status + pe.status = 0) THEN
 306                                  (CASE WHEN pue.timeend = 0 THEN 9999999999 ELSE pue.timeend END)
 307                                  ELSE 0 END) AS timeend
 308                FROM {user_enrolments} pue
 309                JOIN {enrol} pe ON (pe.id = pue.enrolid AND pe.enrol <> 'meta' AND pe.enrol $enabled)
 310                JOIN {enrol} e ON (e.customint1 = pe.courseid AND e.enrol = 'meta' AND e.status = :enrolstatus $onecourse)
 311                JOIN {user} u ON (u.id = pue.userid AND u.deleted = 0)
 312           LEFT JOIN {user_enrolments} ue ON (ue.enrolid = e.id AND ue.userid = pue.userid)
 313               WHERE ue.id IS NULL
 314               GROUP BY pue.userid, e.id";
 315      $params['enrolstatus'] = ENROL_INSTANCE_ENABLED;
 316  
 317      $rs = $DB->get_recordset_sql($sql, $params);
 318      foreach($rs as $ue) {
 319          if (!isset($instances[$ue->enrolid])) {
 320              $instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
 321          }
 322          $instance = $instances[$ue->enrolid];
 323  
 324          if (!$syncall) {
 325              // this may be slow if very many users are ignored in sync
 326              $parentcontext = context_course::instance($instance->customint1);
 327              list($ignoreroles, $params) = $DB->get_in_or_equal($skiproles, SQL_PARAMS_NAMED, 'ri', false, -1);
 328              $params['contextid'] = $parentcontext->id;
 329              $params['userid'] = $ue->userid;
 330              $select = "contextid = :contextid AND userid = :userid AND component <> 'enrol_meta' AND roleid $ignoreroles";
 331              if (!$DB->record_exists_select('role_assignments', $select, $params)) {
 332                  // bad luck, this user does not have any role we want in parent course
 333                  if ($verbose) {
 334                      mtrace("  skipping enrolling: $ue->userid ==> $instance->courseid (user without role)");
 335                  }
 336                  continue;
 337              }
 338          }
 339  
 340          // So now we have aggregated values that we will use for the meta enrolment status, timeend and timestart.
 341          // Again, we use the fact that active=0 and disabled/suspended=1. Only when MIN(pue.status + pe.status)=0 the enrolment is active:
 342          $ue->status = ($ue->status == ENROL_USER_ACTIVE + ENROL_INSTANCE_ENABLED) ? ENROL_USER_ACTIVE : ENROL_USER_SUSPENDED;
 343          // Timeend 9999999999 was used instead of 0 in the "MAX()" function:
 344          $ue->timeend = ($ue->timeend == 9999999999) ? 0 : (int)$ue->timeend;
 345          // Timestart 9999999999 is only possible when there are no active enrolments:
 346          $ue->timestart = ($ue->timestart == 9999999999) ? 0 : (int)$ue->timestart;
 347  
 348          $meta->enrol_user($instance, $ue->userid, null, $ue->timestart, $ue->timeend, $ue->status);
 349          if ($instance->customint2) {
 350              groups_add_member($instance->customint2, $ue->userid, 'enrol_meta', $instance->id);
 351          }
 352          if ($verbose) {
 353              mtrace("  enrolling: $ue->userid ==> $instance->courseid");
 354          }
 355      }
 356      $rs->close();
 357  
 358  
 359      // unenrol as necessary - ignore enabled flag, we want to get rid of existing enrols in any case
 360      $onecourse = $courseid ? "AND e.courseid = :courseid" : "";
 361      list($enabled, $params) = $DB->get_in_or_equal(explode(',', $CFG->enrol_plugins_enabled), SQL_PARAMS_NAMED, 'e');
 362      $params['courseid'] = $courseid;
 363      $sql = "SELECT ue.*
 364                FROM {user_enrolments} ue
 365                JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = 'meta' $onecourse)
 366           LEFT JOIN ({user_enrolments} xpue
 367                        JOIN {enrol} xpe ON (xpe.id = xpue.enrolid AND xpe.enrol <> 'meta' AND xpe.enrol $enabled)
 368                     ) ON (xpe.courseid = e.customint1 AND xpue.userid = ue.userid)
 369               WHERE xpue.userid IS NULL";
 370      $rs = $DB->get_recordset_sql($sql, $params);
 371      foreach($rs as $ue) {
 372          if (!isset($instances[$ue->enrolid])) {
 373              $instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
 374          }
 375          $instance = $instances[$ue->enrolid];
 376  
 377          if ($unenrolaction == ENROL_EXT_REMOVED_UNENROL) {
 378              $meta->unenrol_user($instance, $ue->userid);
 379              if ($verbose) {
 380                  mtrace("  unenrolling: $ue->userid ==> $instance->courseid");
 381              }
 382  
 383          } else if ($unenrolaction == ENROL_EXT_REMOVED_SUSPEND) {
 384              if ($ue->status != ENROL_USER_SUSPENDED) {
 385                  $meta->update_user_enrol($instance, $ue->userid, ENROL_USER_SUSPENDED);
 386                  if ($verbose) {
 387                      mtrace("  suspending: $ue->userid ==> $instance->courseid");
 388                  }
 389              }
 390  
 391          } else if ($unenrolaction == ENROL_EXT_REMOVED_SUSPENDNOROLES) {
 392              if ($ue->status != ENROL_USER_SUSPENDED) {
 393                  $meta->update_user_enrol($instance, $ue->userid, ENROL_USER_SUSPENDED);
 394                  $context = context_course::instance($instance->courseid);
 395                  role_unassign_all(array('userid'=>$ue->userid, 'contextid'=>$context->id, 'component'=>'enrol_meta', 'itemid'=>$instance->id));
 396                  if ($verbose) {
 397                      mtrace("  suspending and removing all roles: $ue->userid ==> $instance->courseid");
 398                  }
 399              }
 400          }
 401      }
 402      $rs->close();
 403  
 404  
 405      // Update status - meta enrols are ignored to avoid recursion.
 406      // Note the trick here is that the active enrolment and instance constants have value 0.
 407      $onecourse = $courseid ? "AND e.courseid = :courseid" : "";
 408      list($enabled, $params) = $DB->get_in_or_equal(explode(',', $CFG->enrol_plugins_enabled), SQL_PARAMS_NAMED, 'e');
 409      $params['courseid'] = $courseid;
 410      // The query builds a a list of all the non-meta enrolments that are on courses (the children) that are linked to by a meta
 411      // enrolment, it then groups them by the course that linked to them (the parents).
 412      //
 413      // It will only return results where the there is a difference between the status of the parent and the lowest status
 414      // of the children (remember that 0 is active, any other status is some form of inactive), or the time the earliest non-zero
 415      // start time of a child is different to the parent, or the longest effective end date has changed.
 416      //
 417      // The last two case statements in the HAVING clause are designed to ignore any inactive child records when calculating
 418      // the start and end time.
 419      $sql = "SELECT ue.userid, ue.enrolid,
 420                     MIN(xpue.status + xpe.status) AS pstatus,
 421                     MIN(CASE WHEN (xpue.status + xpe.status = 0) THEN xpue.timestart ELSE 9999999999 END) AS ptimestart,
 422                     MAX(CASE WHEN (xpue.status + xpe.status = 0) THEN
 423                                   (CASE WHEN xpue.timeend = 0 THEN 9999999999 ELSE xpue.timeend END)
 424                              ELSE 0 END) AS ptimeend
 425                FROM {user_enrolments} ue
 426                JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = 'meta' $onecourse)
 427                JOIN {user_enrolments} xpue ON (xpue.userid = ue.userid)
 428                JOIN {enrol} xpe ON (xpe.id = xpue.enrolid AND xpe.enrol <> 'meta'
 429                     AND xpe.enrol $enabled AND xpe.courseid = e.customint1)
 430            GROUP BY ue.userid, ue.enrolid
 431              HAVING (MIN(xpue.status + xpe.status) = 0 AND MIN(ue.status) > 0)
 432                     OR (MIN(xpue.status + xpe.status) > 0 AND MIN(ue.status) = 0)
 433                     OR ((CASE WHEN
 434                                    MIN(CASE WHEN (xpue.status + xpe.status = 0) THEN xpue.timestart ELSE 9999999999 END) = 9999999999
 435                               THEN 0
 436                               ELSE
 437                                    MIN(CASE WHEN (xpue.status + xpe.status = 0) THEN xpue.timestart ELSE 9999999999 END)
 438                                END) <> MIN(ue.timestart))
 439                     OR ((CASE
 440                           WHEN MAX(CASE WHEN (xpue.status + xpe.status = 0)
 441                                         THEN (CASE WHEN xpue.timeend = 0 THEN 9999999999 ELSE xpue.timeend END)
 442                                         ELSE 0 END) = 9999999999
 443                           THEN 0 ELSE MAX(CASE WHEN (xpue.status + xpe.status = 0)
 444                                                THEN (CASE WHEN xpue.timeend = 0 THEN 9999999999 ELSE xpue.timeend END)
 445                                                ELSE 0 END)
 446                            END) <> MAX(ue.timeend))";
 447      $rs = $DB->get_recordset_sql($sql, $params);
 448      foreach($rs as $ue) {
 449          if (!isset($instances[$ue->enrolid])) {
 450              $instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
 451          }
 452          $instance = $instances[$ue->enrolid];
 453          $ue->pstatus = ($ue->pstatus == ENROL_USER_ACTIVE + ENROL_INSTANCE_ENABLED) ? ENROL_USER_ACTIVE : ENROL_USER_SUSPENDED;
 454          $ue->ptimeend = ($ue->ptimeend == 9999999999) ? 0 : (int)$ue->ptimeend;
 455          $ue->ptimestart = ($ue->ptimestart == 9999999999) ? 0 : (int)$ue->ptimestart;
 456  
 457          if ($ue->pstatus == ENROL_USER_ACTIVE and (!$ue->ptimeend || $ue->ptimeend > time())
 458                  and !$syncall and $unenrolaction != ENROL_EXT_REMOVED_UNENROL) {
 459              // this may be slow if very many users are ignored in sync
 460              $parentcontext = context_course::instance($instance->customint1);
 461              list($ignoreroles, $params) = $DB->get_in_or_equal($skiproles, SQL_PARAMS_NAMED, 'ri', false, -1);
 462              $params['contextid'] = $parentcontext->id;
 463              $params['userid'] = $ue->userid;
 464              $select = "contextid = :contextid AND userid = :userid AND component <> 'enrol_meta' AND roleid $ignoreroles";
 465              if (!$DB->record_exists_select('role_assignments', $select, $params)) {
 466                  // bad luck, this user does not have any role we want in parent course
 467                  if ($verbose) {
 468                      mtrace("  skipping unsuspending: $ue->userid ==> $instance->courseid (user without role)");
 469                  }
 470                  continue;
 471              }
 472          }
 473  
 474          $meta->update_user_enrol($instance, $ue->userid, $ue->pstatus, $ue->ptimestart, $ue->ptimeend);
 475          if ($verbose) {
 476              if ($ue->pstatus == ENROL_USER_ACTIVE) {
 477                  mtrace("  unsuspending: $ue->userid ==> $instance->courseid");
 478              } else {
 479                  mtrace("  suspending: $ue->userid ==> $instance->courseid");
 480              }
 481          }
 482      }
 483      $rs->close();
 484  
 485  
 486      // now assign all necessary roles
 487      $enabled = explode(',', $CFG->enrol_plugins_enabled);
 488      foreach($enabled as $k=>$v) {
 489          if ($v === 'meta') {
 490              continue; // no meta sync of meta roles
 491          }
 492          $enabled[$k] = 'enrol_'.$v;
 493      }
 494      $enabled[] = ''; // manual assignments are replicated too
 495  
 496      $onecourse = $courseid ? "AND e.courseid = :courseid" : "";
 497      list($enabled, $params) = $DB->get_in_or_equal($enabled, SQL_PARAMS_NAMED, 'e');
 498      $params['coursecontext'] = CONTEXT_COURSE;
 499      $params['courseid'] = $courseid;
 500      $params['activeuser'] = ENROL_USER_ACTIVE;
 501      $params['enabledinstance'] = ENROL_INSTANCE_ENABLED;
 502      $sql = "SELECT DISTINCT pra.roleid, pra.userid, c.id AS contextid, e.id AS enrolid, e.courseid
 503                FROM {role_assignments} pra
 504                JOIN {user} u ON (u.id = pra.userid AND u.deleted = 0)
 505                JOIN {context} pc ON (pc.id = pra.contextid AND pc.contextlevel = :coursecontext AND pra.component $enabled)
 506                JOIN {enrol} e ON (e.customint1 = pc.instanceid AND e.enrol = 'meta' $onecourse AND e.status = :enabledinstance)
 507                JOIN {user_enrolments} ue ON (ue.enrolid = e.id AND ue.userid = u.id AND ue.status = :activeuser)
 508                JOIN {context} c ON (c.contextlevel = pc.contextlevel AND c.instanceid = e.courseid)
 509           LEFT JOIN {role_assignments} ra ON (ra.contextid = c.id AND ra.userid = pra.userid AND ra.roleid = pra.roleid AND ra.itemid = e.id AND ra.component = 'enrol_meta')
 510               WHERE ra.id IS NULL";
 511  
 512      if ($ignored = $meta->get_config('nosyncroleids')) {
 513          list($notignored, $xparams) = $DB->get_in_or_equal(explode(',', $ignored), SQL_PARAMS_NAMED, 'ig', false);
 514          $params = array_merge($params, $xparams);
 515          $sql = "$sql AND pra.roleid $notignored";
 516      }
 517  
 518      $rs = $DB->get_recordset_sql($sql, $params);
 519      foreach($rs as $ra) {
 520          role_assign($ra->roleid, $ra->userid, $ra->contextid, 'enrol_meta', $ra->enrolid);
 521          if ($verbose) {
 522              mtrace("  assigning role: $ra->userid ==> $ra->courseid as ".$allroles[$ra->roleid]->shortname);
 523          }
 524      }
 525      $rs->close();
 526  
 527  
 528      // remove unwanted roles - include ignored roles and disabled plugins too
 529      $onecourse = $courseid ? "AND e.courseid = :courseid" : "";
 530      $params = array();
 531      $params['coursecontext'] = CONTEXT_COURSE;
 532      $params['courseid'] = $courseid;
 533      $params['activeuser'] = ENROL_USER_ACTIVE;
 534      $params['enabledinstance'] = ENROL_INSTANCE_ENABLED;
 535      if ($ignored = $meta->get_config('nosyncroleids')) {
 536          list($notignored, $xparams) = $DB->get_in_or_equal(explode(',', $ignored), SQL_PARAMS_NAMED, 'ig', false);
 537          $params = array_merge($params, $xparams);
 538          $notignored = "AND pra.roleid $notignored";
 539      } else {
 540          $notignored = "";
 541      }
 542  
 543      $sql = "SELECT ra.roleid, ra.userid, ra.contextid, ra.itemid, e.courseid
 544                FROM {role_assignments} ra
 545                JOIN {enrol} e ON (e.id = ra.itemid AND ra.component = 'enrol_meta' AND e.enrol = 'meta' $onecourse)
 546                JOIN {context} pc ON (pc.instanceid = e.customint1 AND pc.contextlevel = :coursecontext)
 547           LEFT JOIN {role_assignments} pra ON (pra.contextid = pc.id AND pra.userid = ra.userid AND pra.roleid = ra.roleid AND pra.component <> 'enrol_meta' $notignored)
 548           LEFT JOIN {user_enrolments} ue ON (ue.enrolid = e.id AND ue.userid = ra.userid AND ue.status = :activeuser)
 549               WHERE pra.id IS NULL OR ue.id IS NULL OR e.status <> :enabledinstance";
 550  
 551      if ($unenrolaction != ENROL_EXT_REMOVED_SUSPEND) {
 552          $rs = $DB->get_recordset_sql($sql, $params);
 553          foreach($rs as $ra) {
 554              role_unassign($ra->roleid, $ra->userid, $ra->contextid, 'enrol_meta', $ra->itemid);
 555              if ($verbose) {
 556                  mtrace("  unassigning role: $ra->userid ==> $ra->courseid as ".$allroles[$ra->roleid]->shortname);
 557              }
 558          }
 559          $rs->close();
 560      }
 561  
 562  
 563      // kick out or suspend users without synced roles if syncall disabled
 564      if (!$syncall) {
 565          if ($unenrolaction == ENROL_EXT_REMOVED_UNENROL) {
 566              $onecourse = $courseid ? "AND e.courseid = :courseid" : "";
 567              $params = array();
 568              $params['coursecontext'] = CONTEXT_COURSE;
 569              $params['courseid'] = $courseid;
 570              $sql = "SELECT ue.userid, ue.enrolid
 571                        FROM {user_enrolments} ue
 572                        JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = 'meta' $onecourse)
 573                        JOIN {context} c ON (e.courseid = c.instanceid AND c.contextlevel = :coursecontext)
 574                   LEFT JOIN {role_assignments} ra ON (ra.contextid = c.id AND ra.itemid = e.id AND ra.userid = ue.userid)
 575                       WHERE ra.id IS NULL";
 576              $ues = $DB->get_recordset_sql($sql, $params);
 577              foreach($ues as $ue) {
 578                  if (!isset($instances[$ue->enrolid])) {
 579                      $instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
 580                  }
 581                  $instance = $instances[$ue->enrolid];
 582                  $meta->unenrol_user($instance, $ue->userid);
 583                  if ($verbose) {
 584                      mtrace("  unenrolling: $ue->userid ==> $instance->courseid (user without role)");
 585                  }
 586              }
 587              $ues->close();
 588  
 589          } else {
 590              // just suspend the users
 591              $onecourse = $courseid ? "AND e.courseid = :courseid" : "";
 592              $params = array();
 593              $params['coursecontext'] = CONTEXT_COURSE;
 594              $params['courseid'] = $courseid;
 595              $params['active'] = ENROL_USER_ACTIVE;
 596              $sql = "SELECT ue.userid, ue.enrolid
 597                        FROM {user_enrolments} ue
 598                        JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = 'meta' $onecourse)
 599                        JOIN {context} c ON (e.courseid = c.instanceid AND c.contextlevel = :coursecontext)
 600                   LEFT JOIN {role_assignments} ra ON (ra.contextid = c.id AND ra.itemid = e.id AND ra.userid = ue.userid)
 601                       WHERE ra.id IS NULL AND ue.status = :active";
 602              $ues = $DB->get_recordset_sql($sql, $params);
 603              foreach($ues as $ue) {
 604                  if (!isset($instances[$ue->enrolid])) {
 605                      $instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
 606                  }
 607                  $instance = $instances[$ue->enrolid];
 608                  $meta->update_user_enrol($instance, $ue->userid, ENROL_USER_SUSPENDED);
 609                  if ($verbose) {
 610                      mtrace("  suspending: $ue->userid ==> $instance->courseid (user without role)");
 611                  }
 612              }
 613              $ues->close();
 614          }
 615      }
 616  
 617      // Finally sync groups.
 618      $affectedusers = groups_sync_with_enrolment('meta', $courseid);
 619      if ($verbose) {
 620          foreach ($affectedusers['removed'] as $gm) {
 621              mtrace("removing user from group: $gm->userid ==> $gm->courseid - $gm->groupname", 1);
 622          }
 623          foreach ($affectedusers['added'] as $ue) {
 624              mtrace("adding user to group: $ue->userid ==> $ue->courseid - $ue->groupname", 1);
 625          }
 626      }
 627  
 628      if ($verbose) {
 629          mtrace('...user enrolment synchronisation finished.');
 630      }
 631  
 632      return 0;
 633  }
 634  
 635  /**
 636   * Create a new group with the course's name.
 637   *
 638   * @param int $courseid
 639   * @param int $linkedcourseid
 640   * @return int $groupid Group ID for this cohort.
 641   */
 642  function enrol_meta_create_new_group($courseid, $linkedcourseid) {
 643      global $DB, $CFG;
 644  
 645      require_once($CFG->dirroot.'/group/lib.php');
 646  
 647      $coursename = $DB->get_field('course', 'fullname', array('id' => $linkedcourseid), MUST_EXIST);
 648      $a = new stdClass();
 649      $a->name = $coursename;
 650      $a->increment = '';
 651      $inc = 1;
 652      $groupname = trim(get_string('defaultgroupnametext', 'enrol_meta', $a));
 653      // Check to see if the group name already exists in this course. Add an incremented number if it does.
 654      while ($DB->record_exists('groups', array('name' => $groupname, 'courseid' => $courseid))) {
 655          $a->increment = '(' . (++$inc) . ')';
 656          $groupname = trim(get_string('defaultgroupnametext', 'enrol_meta', $a));
 657      }
 658      // Create a new group for the course meta sync.
 659      $groupdata = new stdClass();
 660      $groupdata->courseid = $courseid;
 661      $groupdata->name = $groupname;
 662      $groupid = groups_create_group($groupdata);
 663  
 664      return $groupid;
 665  }