Search moodle.org's
Developer Documentation


  • Bug fixes for general core bugs in 2.8.x ended 9 November 2015 (12 months).
  • Bug fixes for security issues in 2.8.x ended 9 May 2016 (18 months).
  • minimum PHP 5.4.4 (always use latest PHP 5.4.x or 5.5.x on Windows - http://windows.php.net/download/), PHP 7 is NOT supported
  • /lib/ -> enrollib.php (source)

    Differences Between: [Versions 28 and 29] [Versions 28 and 30] [Versions 28 and 31] [Versions 28 and 32] [Versions 28 and 33] [Versions 28 and 34] [Versions 28 and 35] [Versions 28 and 36] [Versions 28 and 37]

       1  <?php
       2  
       3  // This file is part of Moodle - http://moodle.org/
       4  //
       5  // Moodle is free software: you can redistribute it and/or modify
       6  // it under the terms of the GNU General Public License as published by
       7  // the Free Software Foundation, either version 3 of the License, or
       8  // (at your option) any later version.
       9  //
      10  // Moodle is distributed in the hope that it will be useful,
      11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
      12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      13  // GNU General Public License for more details.
      14  //
      15  // You should have received a copy of the GNU General Public License
      16  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
      17  
      18  /**
      19   * This library includes the basic parts of enrol api.
      20   * It is available on each page.
      21   *
      22   * @package    core
      23   * @subpackage enrol
      24   * @copyright  2010 Petr Skoda {@link http://skodak.org}
      25   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
      26   */
      27  
      28  defined('MOODLE_INTERNAL') || die();
      29  
      30  /** Course enrol instance enabled. (used in enrol->status) */
      31  define('ENROL_INSTANCE_ENABLED', 0);
      32  
      33  /** Course enrol instance disabled, user may enter course if other enrol instance enabled. (used in enrol->status)*/
      34  define('ENROL_INSTANCE_DISABLED', 1);
      35  
      36  /** User is active participant (used in user_enrolments->status)*/
      37  define('ENROL_USER_ACTIVE', 0);
      38  
      39  /** User participation in course is suspended (used in user_enrolments->status) */
      40  define('ENROL_USER_SUSPENDED', 1);
      41  
      42  /** @deprecated - enrol caching was reworked, use ENROL_MAX_TIMESTAMP instead */
      43  define('ENROL_REQUIRE_LOGIN_CACHE_PERIOD', 1800);
      44  
      45  /** The timestamp indicating forever */
      46  define('ENROL_MAX_TIMESTAMP', 2147483647);
      47  
      48  /** When user disappears from external source, the enrolment is completely removed */
      49  define('ENROL_EXT_REMOVED_UNENROL', 0);
      50  
      51  /** When user disappears from external source, the enrolment is kept as is - one way sync */
      52  define('ENROL_EXT_REMOVED_KEEP', 1);
      53  
      54  /** @deprecated since 2.4 not used any more, migrate plugin to new restore methods */
      55  define('ENROL_RESTORE_TYPE', 'enrolrestore');
      56  
      57  /**
      58   * When user disappears from external source, user enrolment is suspended, roles are kept as is.
      59   * In some cases user needs a role with some capability to be visible in UI - suc has in gradebook,
      60   * assignments, etc.
      61   */
      62  define('ENROL_EXT_REMOVED_SUSPEND', 2);
      63  
      64  /**
      65   * When user disappears from external source, the enrolment is suspended and roles assigned
      66   * by enrol instance are removed. Please note that user may "disappear" from gradebook and other areas.
      67   * */
      68  define('ENROL_EXT_REMOVED_SUSPENDNOROLES', 3);
      69  
      70  /**
      71   * Returns instances of enrol plugins
      72   * @param bool $enabled return enabled only
      73   * @return array of enrol plugins name=>instance
      74   */
      75  function enrol_get_plugins($enabled) {
      76      global $CFG;
      77  
      78      $result = array();
      79  
      80      if ($enabled) {
      81          // sorted by enabled plugin order
      82          $enabled = explode(',', $CFG->enrol_plugins_enabled);
      83          $plugins = array();
      84          foreach ($enabled as $plugin) {
      85              $plugins[$plugin] = "$CFG->dirroot/enrol/$plugin";
      86          }
      87      } else {
      88          // sorted alphabetically
      89          $plugins = core_component::get_plugin_list('enrol');
      90          ksort($plugins);
      91      }
      92  
      93      foreach ($plugins as $plugin=>$location) {
      94          $class = "enrol_{$plugin}_plugin";
      95          if (!class_exists($class)) {
      96              if (!file_exists("$location/lib.php")) {
      97                  continue;
      98              }
      99              include_once("$location/lib.php");
     100              if (!class_exists($class)) {
     101                  continue;
     102              }
     103          }
     104  
     105          $result[$plugin] = new $class();
     106      }
     107  
     108      return $result;
     109  }
     110  
     111  /**
     112   * Returns instance of enrol plugin
     113   * @param  string $name name of enrol plugin ('manual', 'guest', ...)
     114   * @return enrol_plugin
     115   */
     116  function enrol_get_plugin($name) {
     117      global $CFG;
     118  
     119      $name = clean_param($name, PARAM_PLUGIN);
     120  
     121      if (empty($name)) {
     122          // ignore malformed or missing plugin names completely
     123          return null;
     124      }
     125  
     126      $location = "$CFG->dirroot/enrol/$name";
     127  
     128      if (!file_exists("$location/lib.php")) {
     129          return null;
     130      }
     131      include_once("$location/lib.php");
     132      $class = "enrol_{$name}_plugin";
     133      if (!class_exists($class)) {
     134          return null;
     135      }
     136  
     137      return new $class();
     138  }
     139  
     140  /**
     141   * Returns enrolment instances in given course.
     142   * @param int $courseid
     143   * @param bool $enabled
     144   * @return array of enrol instances
     145   */
     146  function enrol_get_instances($courseid, $enabled) {
     147      global $DB, $CFG;
     148  
     149      if (!$enabled) {
     150          return $DB->get_records('enrol', array('courseid'=>$courseid), 'sortorder,id');
     151      }
     152  
     153      $result = $DB->get_records('enrol', array('courseid'=>$courseid, 'status'=>ENROL_INSTANCE_ENABLED), 'sortorder,id');
     154  
     155      $enabled = explode(',', $CFG->enrol_plugins_enabled);
     156      foreach ($result as $key=>$instance) {
     157          if (!in_array($instance->enrol, $enabled)) {
     158              unset($result[$key]);
     159              continue;
     160          }
     161          if (!file_exists("$CFG->dirroot/enrol/$instance->enrol/lib.php")) {
     162              // broken plugin
     163              unset($result[$key]);
     164              continue;
     165          }
     166      }
     167  
     168      return $result;
     169  }
     170  
     171  /**
     172   * Checks if a given plugin is in the list of enabled enrolment plugins.
     173   *
     174   * @param string $enrol Enrolment plugin name
     175   * @return boolean Whether the plugin is enabled
     176   */
     177  function enrol_is_enabled($enrol) {
     178      global $CFG;
     179  
     180      if (empty($CFG->enrol_plugins_enabled)) {
     181          return false;
     182      }
     183      return in_array($enrol, explode(',', $CFG->enrol_plugins_enabled));
     184  }
     185  
     186  /**
     187   * Check all the login enrolment information for the given user object
     188   * by querying the enrolment plugins
     189   *
     190   * This function may be very slow, use only once after log-in or login-as.
     191   *
     192   * @param stdClass $user
     193   * @return void
     194   */
     195  function enrol_check_plugins($user) {
     196      global $CFG;
     197  
     198      if (empty($user->id) or isguestuser($user)) {
     199          // shortcut - there is no enrolment work for guests and not-logged-in users
     200          return;
     201      }
     202  
     203      // originally there was a broken admin test, but accidentally it was non-functional in 2.2,
     204      // which proved it was actually not necessary.
     205  
     206      static $inprogress = array();  // To prevent this function being called more than once in an invocation
     207  
     208      if (!empty($inprogress[$user->id])) {
     209          return;
     210      }
     211  
     212      $inprogress[$user->id] = true;  // Set the flag
     213  
     214      $enabled = enrol_get_plugins(true);
     215  
     216      foreach($enabled as $enrol) {
     217          $enrol->sync_user_enrolments($user);
     218      }
     219  
     220      unset($inprogress[$user->id]);  // Unset the flag
     221  }
     222  
     223  /**
     224   * Do these two students share any course?
     225   *
     226   * The courses has to be visible and enrolments has to be active,
     227   * timestart and timeend restrictions are ignored.
     228   *
     229   * This function calls {@see enrol_get_shared_courses()} setting checkexistsonly
     230   * to true.
     231   *
     232   * @param stdClass|int $user1
     233   * @param stdClass|int $user2
     234   * @return bool
     235   */
     236  function enrol_sharing_course($user1, $user2) {
     237      return enrol_get_shared_courses($user1, $user2, false, true);
     238  }
     239  
     240  /**
     241   * Returns any courses shared by the two users
     242   *
     243   * The courses has to be visible and enrolments has to be active,
     244   * timestart and timeend restrictions are ignored.
     245   *
     246   * @global moodle_database $DB
     247   * @param stdClass|int $user1
     248   * @param stdClass|int $user2
     249   * @param bool $preloadcontexts If set to true contexts for the returned courses
     250   *              will be preloaded.
     251   * @param bool $checkexistsonly If set to true then this function will return true
     252   *              if the users share any courses and false if not.
     253   * @return array|bool An array of courses that both users are enrolled in OR if
     254   *              $checkexistsonly set returns true if the users share any courses
     255   *              and false if not.
     256   */
     257  function enrol_get_shared_courses($user1, $user2, $preloadcontexts = false, $checkexistsonly = false) {
     258      global $DB, $CFG;
     259  
     260      $user1 = isset($user1->id) ? $user1->id : $user1;
     261      $user2 = isset($user2->id) ? $user2->id : $user2;
     262  
     263      if (empty($user1) or empty($user2)) {
     264          return false;
     265      }
     266  
     267      if (!$plugins = explode(',', $CFG->enrol_plugins_enabled)) {
     268          return false;
     269      }
     270  
     271      list($plugins, $params) = $DB->get_in_or_equal($plugins, SQL_PARAMS_NAMED, 'ee');
     272      $params['enabled'] = ENROL_INSTANCE_ENABLED;
     273      $params['active1'] = ENROL_USER_ACTIVE;
     274      $params['active2'] = ENROL_USER_ACTIVE;
     275      $params['user1']   = $user1;
     276      $params['user2']   = $user2;
     277  
     278      $ctxselect = '';
     279      $ctxjoin = '';
     280      if ($preloadcontexts) {
     281          $ctxselect = ', ' . context_helper::get_preload_record_columns_sql('ctx');
     282          $ctxjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = c.id AND ctx.contextlevel = :contextlevel)";
     283          $params['contextlevel'] = CONTEXT_COURSE;
     284      }
     285  
     286      $sql = "SELECT c.* $ctxselect
     287                FROM {course} c
     288                JOIN (
     289                  SELECT DISTINCT c.id
     290                    FROM {enrol} e
     291                    JOIN {user_enrolments} ue1 ON (ue1.enrolid = e.id AND ue1.status = :active1 AND ue1.userid = :user1)
     292                    JOIN {user_enrolments} ue2 ON (ue2.enrolid = e.id AND ue2.status = :active2 AND ue2.userid = :user2)
     293                    JOIN {course} c ON (c.id = e.courseid AND c.visible = 1)
     294                   WHERE e.status = :enabled AND e.enrol $plugins
     295                ) ec ON ec.id = c.id
     296                $ctxjoin";
     297  
     298      if ($checkexistsonly) {
     299          return $DB->record_exists_sql($sql, $params);
     300      } else {
     301          $courses = $DB->get_records_sql($sql, $params);
     302          if ($preloadcontexts) {
     303              array_map('context_helper::preload_from_record', $courses);
     304          }
     305          return $courses;
     306      }
     307  }
     308  
     309  /**
     310   * This function adds necessary enrol plugins UI into the course edit form.
     311   *
     312   * @param MoodleQuickForm $mform
     313   * @param object $data course edit form data
     314   * @param object $context context of existing course or parent category if course does not exist
     315   * @return void
     316   */
     317  function enrol_course_edit_form(MoodleQuickForm $mform, $data, $context) {
     318      $plugins = enrol_get_plugins(true);
     319      if (!empty($data->id)) {
     320          $instances = enrol_get_instances($data->id, false);
     321          foreach ($instances as $instance) {
     322              if (!isset($plugins[$instance->enrol])) {
     323                  continue;
     324              }
     325              $plugin = $plugins[$instance->enrol];
     326              $plugin->course_edit_form($instance, $mform, $data, $context);
     327          }
     328      } else {
     329          foreach ($plugins as $plugin) {
     330              $plugin->course_edit_form(NULL, $mform, $data, $context);
     331          }
     332      }
     333  }
     334  
     335  /**
     336   * Validate course edit form data
     337   *
     338   * @param array $data raw form data
     339   * @param object $context context of existing course or parent category if course does not exist
     340   * @return array errors array
     341   */
     342  function enrol_course_edit_validation(array $data, $context) {
     343      $errors = array();
     344      $plugins = enrol_get_plugins(true);
     345  
     346      if (!empty($data['id'])) {
     347          $instances = enrol_get_instances($data['id'], false);
     348          foreach ($instances as $instance) {
     349              if (!isset($plugins[$instance->enrol])) {
     350                  continue;
     351              }
     352              $plugin = $plugins[$instance->enrol];
     353              $errors = array_merge($errors, $plugin->course_edit_validation($instance, $data, $context));
     354          }
     355      } else {
     356          foreach ($plugins as $plugin) {
     357              $errors = array_merge($errors, $plugin->course_edit_validation(NULL, $data, $context));
     358          }
     359      }
     360  
     361      return $errors;
     362  }
     363  
     364  /**
     365   * Update enrol instances after course edit form submission
     366   * @param bool $inserted true means new course added, false course already existed
     367   * @param object $course
     368   * @param object $data form data
     369   * @return void
     370   */
     371  function enrol_course_updated($inserted, $course, $data) {
     372      global $DB, $CFG;
     373  
     374      $plugins = enrol_get_plugins(true);
     375  
     376      foreach ($plugins as $plugin) {
     377          $plugin->course_updated($inserted, $course, $data);
     378      }
     379  }
     380  
     381  /**
     382   * Add navigation nodes
     383   * @param navigation_node $coursenode
     384   * @param object $course
     385   * @return void
     386   */
     387  function enrol_add_course_navigation(navigation_node $coursenode, $course) {
     388      global $CFG;
     389  
     390      $coursecontext = context_course::instance($course->id);
     391  
     392      $instances = enrol_get_instances($course->id, true);
     393      $plugins   = enrol_get_plugins(true);
     394  
     395      // we do not want to break all course pages if there is some borked enrol plugin, right?
     396      foreach ($instances as $k=>$instance) {
     397          if (!isset($plugins[$instance->enrol])) {
     398              unset($instances[$k]);
     399          }
     400      }
     401  
     402      $usersnode = $coursenode->add(get_string('users'), null, navigation_node::TYPE_CONTAINER, null, 'users');
     403  
     404      if ($course->id != SITEID) {
     405          // list all participants - allows assigning roles, groups, etc.
     406          if (has_capability('moodle/course:enrolreview', $coursecontext)) {
     407              $url = new moodle_url('/enrol/users.php', array('id'=>$course->id));
     408              $usersnode->add(get_string('enrolledusers', 'enrol'), $url, navigation_node::TYPE_SETTING, null, 'review', new pix_icon('i/enrolusers', ''));
     409          }
     410  
     411          // manage enrol plugin instances
     412          if (has_capability('moodle/course:enrolconfig', $coursecontext) or has_capability('moodle/course:enrolreview', $coursecontext)) {
     413              $url = new moodle_url('/enrol/instances.php', array('id'=>$course->id));
     414          } else {
     415              $url = NULL;
     416          }
     417          $instancesnode = $usersnode->add(get_string('enrolmentinstances', 'enrol'), $url, navigation_node::TYPE_SETTING, null, 'manageinstances');
     418  
     419          // each instance decides how to configure itself or how many other nav items are exposed
     420          foreach ($instances as $instance) {
     421              if (!isset($plugins[$instance->enrol])) {
     422                  continue;
     423              }
     424              $plugins[$instance->enrol]->add_course_navigation($instancesnode, $instance);
     425          }
     426  
     427          if (!$url) {
     428              $instancesnode->trim_if_empty();
     429          }
     430      }
     431  
     432      // Manage groups in this course or even frontpage
     433      if (($course->groupmode || !$course->groupmodeforce) && has_capability('moodle/course:managegroups', $coursecontext)) {
     434          $url = new moodle_url('/group/index.php', array('id'=>$course->id));
     435          $usersnode->add(get_string('groups'), $url, navigation_node::TYPE_SETTING, null, 'groups', new pix_icon('i/group', ''));
     436      }
     437  
     438       if (has_any_capability(array( 'moodle/role:assign', 'moodle/role:safeoverride','moodle/role:override', 'moodle/role:review'), $coursecontext)) {
     439          // Override roles
     440          if (has_capability('moodle/role:review', $coursecontext)) {
     441              $url = new moodle_url('/admin/roles/permissions.php', array('contextid'=>$coursecontext->id));
     442          } else {
     443              $url = NULL;
     444          }
     445          $permissionsnode = $usersnode->add(get_string('permissions', 'role'), $url, navigation_node::TYPE_SETTING, null, 'override');
     446  
     447          // Add assign or override roles if allowed
     448          if ($course->id == SITEID or (!empty($CFG->adminsassignrolesincourse) and is_siteadmin())) {
     449              if (has_capability('moodle/role:assign', $coursecontext)) {
     450                  $url = new moodle_url('/admin/roles/assign.php', array('contextid'=>$coursecontext->id));
     451                  $permissionsnode->add(get_string('assignedroles', 'role'), $url, navigation_node::TYPE_SETTING, null, 'roles', new pix_icon('i/assignroles', ''));
     452              }
     453          }
     454          // Check role permissions
     455          if (has_any_capability(array('moodle/role:assign', 'moodle/role:safeoverride','moodle/role:override', 'moodle/role:assign'), $coursecontext)) {
     456              $url = new moodle_url('/admin/roles/check.php', array('contextid'=>$coursecontext->id));
     457              $permissionsnode->add(get_string('checkpermissions', 'role'), $url, navigation_node::TYPE_SETTING, null, 'permissions', new pix_icon('i/checkpermissions', ''));
     458          }
     459       }
     460  
     461       // Deal somehow with users that are not enrolled but still got a role somehow
     462      if ($course->id != SITEID) {
     463          //TODO, create some new UI for role assignments at course level
     464          if (has_capability('moodle/course:reviewotherusers', $coursecontext)) {
     465              $url = new moodle_url('/enrol/otherusers.php', array('id'=>$course->id));
     466              $usersnode->add(get_string('notenrolledusers', 'enrol'), $url, navigation_node::TYPE_SETTING, null, 'otherusers', new pix_icon('i/assignroles', ''));
     467          }
     468      }
     469  
     470      // just in case nothing was actually added
     471      $usersnode->trim_if_empty();
     472  
     473      if ($course->id != SITEID) {
     474          if (isguestuser() or !isloggedin()) {
     475              // guest account can not be enrolled - no links for them
     476          } else if (is_enrolled($coursecontext)) {
     477              // unenrol link if possible
     478              foreach ($instances as $instance) {
     479                  if (!isset($plugins[$instance->enrol])) {
     480                      continue;
     481                  }
     482                  $plugin = $plugins[$instance->enrol];
     483                  if ($unenrollink = $plugin->get_unenrolself_link($instance)) {
     484                      $shortname = format_string($course->shortname, true, array('context' => $coursecontext));
     485                      $coursenode->add(get_string('unenrolme', 'core_enrol', $shortname), $unenrollink, navigation_node::TYPE_SETTING, null, 'unenrolself', new pix_icon('i/user', ''));
     486                      break;
     487                      //TODO. deal with multiple unenrol links - not likely case, but still...
     488                  }
     489              }
     490          } else {
     491              // enrol link if possible
     492              if (is_viewing($coursecontext)) {
     493                  // better not show any enrol link, this is intended for managers and inspectors
     494              } else {
     495                  foreach ($instances as $instance) {
     496                      if (!isset($plugins[$instance->enrol])) {
     497                          continue;
     498                      }
     499                      $plugin = $plugins[$instance->enrol];
     500                      if ($plugin->show_enrolme_link($instance)) {
     501                          $url = new moodle_url('/enrol/index.php', array('id'=>$course->id));
     502                          $shortname = format_string($course->shortname, true, array('context' => $coursecontext));
     503                          $coursenode->add(get_string('enrolme', 'core_enrol', $shortname), $url, navigation_node::TYPE_SETTING, null, 'enrolself', new pix_icon('i/user', ''));
     504                          break;
     505                      }
     506                  }
     507              }
     508          }
     509      }
     510  }
     511  
     512  /**
     513   * Returns list of courses current $USER is enrolled in and can access
     514   *
     515   * - $fields is an array of field names to ADD
     516   *   so name the fields you really need, which will
     517   *   be added and uniq'd
     518   *
     519   * @param string|array $fields
     520   * @param string $sort
     521   * @param int $limit max number of courses
     522   * @return array
     523   */
     524  function enrol_get_my_courses($fields = NULL, $sort = 'visible DESC,sortorder ASC', $limit = 0) {
     525      global $DB, $USER;
     526  
     527      // Guest account does not have any courses
     528      if (isguestuser() or !isloggedin()) {
     529          return(array());
     530      }
     531  
     532      $basefields = array('id', 'category', 'sortorder',
     533                          'shortname', 'fullname', 'idnumber',
     534                          'startdate', 'visible',
     535                          'groupmode', 'groupmodeforce', 'cacherev');
     536  
     537      if (empty($fields)) {
     538          $fields = $basefields;
     539      } else if (is_string($fields)) {
     540          // turn the fields from a string to an array
     541          $fields = explode(',', $fields);
     542          $fields = array_map('trim', $fields);
     543          $fields = array_unique(array_merge($basefields, $fields));
     544      } else if (is_array($fields)) {
     545          $fields = array_unique(array_merge($basefields, $fields));
     546      } else {
     547          throw new coding_exception('Invalid $fileds parameter in enrol_get_my_courses()');
     548      }
     549      if (in_array('*', $fields)) {
     550          $fields = array('*');
     551      }
     552  
     553      $orderby = "";
     554      $sort    = trim($sort);
     555      if (!empty($sort)) {
     556          $rawsorts = explode(',', $sort);
     557          $sorts = array();
     558          foreach ($rawsorts as $rawsort) {
     559              $rawsort = trim($rawsort);
     560              if (strpos($rawsort, 'c.') === 0) {
     561                  $rawsort = substr($rawsort, 2);
     562              }
     563              $sorts[] = trim($rawsort);
     564          }
     565          $sort = 'c.'.implode(',c.', $sorts);
     566          $orderby = "ORDER BY $sort";
     567      }
     568  
     569      $wheres = array("c.id <> :siteid");
     570      $params = array('siteid'=>SITEID);
     571  
     572      if (isset($USER->loginascontext) and $USER->loginascontext->contextlevel == CONTEXT_COURSE) {
     573          // list _only_ this course - anything else is asking for trouble...
     574          $wheres[] = "courseid = :loginas";
     575          $params['loginas'] = $USER->loginascontext->instanceid;
     576      }
     577  
     578      $coursefields = 'c.' .join(',c.', $fields);
     579      $ccselect = ', ' . context_helper::get_preload_record_columns_sql('ctx');
     580      $ccjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = c.id AND ctx.contextlevel = :contextlevel)";
     581      $params['contextlevel'] = CONTEXT_COURSE;
     582      $wheres = implode(" AND ", $wheres);
     583  
     584      //note: we can not use DISTINCT + text fields due to Oracle and MS limitations, that is why we have the subselect there
     585      $sql = "SELECT $coursefields $ccselect
     586                FROM {course} c
     587                JOIN (SELECT DISTINCT e.courseid
     588                        FROM {enrol} e
     589                        JOIN {user_enrolments} ue ON (ue.enrolid = e.id AND ue.userid = :userid)
     590                       WHERE ue.status = :active AND e.status = :enabled AND ue.timestart < :now1 AND (ue.timeend = 0 OR ue.timeend > :now2)
     591                     ) en ON (en.courseid = c.id)
     592             $ccjoin
     593               WHERE $wheres
     594            $orderby";
     595      $params['userid']  = $USER->id;
     596      $params['active']  = ENROL_USER_ACTIVE;
     597      $params['enabled'] = ENROL_INSTANCE_ENABLED;
     598      $params['now1']    = round(time(), -2); // improves db caching
     599      $params['now2']    = $params['now1'];
     600  
     601      $courses = $DB->get_records_sql($sql, $params, 0, $limit);
     602  
     603      // preload contexts and check visibility
     604      foreach ($courses as $id=>$course) {
     605          context_helper::preload_from_record($course);
     606          if (!$course->visible) {
     607              if (!$context = context_course::instance($id, IGNORE_MISSING)) {
     608                  unset($courses[$id]);
     609                  continue;
     610              }
     611              if (!has_capability('moodle/course:viewhiddencourses', $context)) {
     612                  unset($courses[$id]);
     613                  continue;
     614              }
     615          }
     616          $courses[$id] = $course;
     617      }
     618  
     619      //wow! Is that really all? :-D
     620  
     621      return $courses;
     622  }
     623  
     624  /**
     625   * Returns course enrolment information icons.
     626   *
     627   * @param object $course
     628   * @param array $instances enrol instances of this course, improves performance
     629   * @return array of pix_icon
     630   */
     631  function enrol_get_course_info_icons($course, array $instances = NULL) {
     632      $icons = array();
     633      if (is_null($instances)) {
     634          $instances = enrol_get_instances($course->id, true);
     635      }
     636      $plugins = enrol_get_plugins(true);
     637      foreach ($plugins as $name => $plugin) {
     638          $pis = array();
     639          foreach ($instances as $instance) {
     640              if ($instance->status != ENROL_INSTANCE_ENABLED or $instance->courseid != $course->id) {
     641                  debugging('Invalid instances parameter submitted in enrol_get_info_icons()');
     642                  continue;
     643              }
     644              if ($instance->enrol == $name) {
     645                  $pis[$instance->id] = $instance;
     646              }
     647          }
     648          if ($pis) {
     649              $icons = array_merge($icons, $plugin->get_info_icons($pis));
     650          }
     651      }
     652      return $icons;
     653  }
     654  
     655  /**
     656   * Returns course enrolment detailed information.
     657   *
     658   * @param object $course
     659   * @return array of html fragments - can be used to construct lists
     660   */
     661  function enrol_get_course_description_texts($course) {
     662      $lines = array();
     663      $instances = enrol_get_instances($course->id, true);
     664      $plugins = enrol_get_plugins(true);
     665      foreach ($instances as $instance) {
     666          if (!isset($plugins[$instance->enrol])) {
     667              //weird
     668              continue;
     669          }
     670          $plugin = $plugins[$instance->enrol];
     671          $text = $plugin->get_description_text($instance);
     672          if ($text !== NULL) {
     673              $lines[] = $text;
     674          }
     675      }
     676      return $lines;
     677  }
     678  
     679  /**
     680   * Returns list of courses user is enrolled into.
     681   * (Note: use enrol_get_all_users_courses if you want to use the list wihtout any cap checks )
     682   *
     683   * - $fields is an array of fieldnames to ADD
     684   *   so name the fields you really need, which will
     685   *   be added and uniq'd
     686   *
     687   * @param int $userid
     688   * @param bool $onlyactive return only active enrolments in courses user may see
     689   * @param string|array $fields
     690   * @param string $sort
     691   * @return array
     692   */
     693  function enrol_get_users_courses($userid, $onlyactive = false, $fields = NULL, $sort = 'visible DESC,sortorder ASC') {
     694      global $DB;
     695  
     696      $courses = enrol_get_all_users_courses($userid, $onlyactive, $fields, $sort);
     697  
     698      // preload contexts and check visibility
     699      if ($onlyactive) {
     700          foreach ($courses as $id=>$course) {
     701              context_helper::preload_from_record($course);
     702              if (!$course->visible) {
     703                  if (!$context = context_course::instance($id)) {
     704                      unset($courses[$id]);
     705                      continue;
     706                  }
     707                  if (!has_capability('moodle/course:viewhiddencourses', $context, $userid)) {
     708                      unset($courses[$id]);
     709                      continue;
     710                  }
     711              }
     712          }
     713      }
     714  
     715      return $courses;
     716  
     717  }
     718  
     719  /**
     720   * Can user access at least one enrolled course?
     721   *
     722   * Cheat if necessary, but find out as fast as possible!
     723   *
     724   * @param int|stdClass $user null means use current user
     725   * @return bool
     726   */
     727  function enrol_user_sees_own_courses($user = null) {
     728      global $USER;
     729  
     730      if ($user === null) {
     731          $user = $USER;
     732      }
     733      $userid = is_object($user) ? $user->id : $user;
     734  
     735      // Guest account does not have any courses
     736      if (isguestuser($userid) or empty($userid)) {
     737          return false;
     738      }
     739  
     740      // Let's cheat here if this is the current user,
     741      // if user accessed any course recently, then most probably
     742      // we do not need to query the database at all.
     743      if ($USER->id == $userid) {
     744          if (!empty($USER->enrol['enrolled'])) {
     745              foreach ($USER->enrol['enrolled'] as $until) {
     746                  if ($until > time()) {
     747                      return true;
     748                  }
     749              }
     750          }
     751      }
     752  
     753      // Now the slow way.
     754      $courses = enrol_get_all_users_courses($userid, true);
     755      foreach($courses as $course) {
     756          if ($course->visible) {
     757              return true;
     758          }
     759          context_helper::preload_from_record($course);
     760          $context = context_course::instance($course->id);
     761          if (has_capability('moodle/course:viewhiddencourses', $context, $user)) {
     762              return true;
     763          }
     764      }
     765  
     766      return false;
     767  }
     768  
     769  /**
     770   * Returns list of courses user is enrolled into without any capability checks
     771   * - $fields is an array of fieldnames to ADD
     772   *   so name the fields you really need, which will
     773   *   be added and uniq'd
     774   *
     775   * @param int $userid
     776   * @param bool $onlyactive return only active enrolments in courses user may see
     777   * @param string|array $fields
     778   * @param string $sort
     779   * @return array
     780   */
     781  function enrol_get_all_users_courses($userid, $onlyactive = false, $fields = NULL, $sort = 'visible DESC,sortorder ASC') {
     782      global $DB;
     783  
     784      // Guest account does not have any courses
     785      if (isguestuser($userid) or empty($userid)) {
     786          return(array());
     787      }
     788  
     789      $basefields = array('id', 'category', 'sortorder',
     790              'shortname', 'fullname', 'idnumber',
     791              'startdate', 'visible',
     792              'groupmode', 'groupmodeforce');
     793  
     794      if (empty($fields)) {
     795          $fields = $basefields;
     796      } else if (is_string($fields)) {
     797          // turn the fields from a string to an array
     798          $fields = explode(',', $fields);
     799          $fields = array_map('trim', $fields);
     800          $fields = array_unique(array_merge($basefields, $fields));
     801      } else if (is_array($fields)) {
     802          $fields = array_unique(array_merge($basefields, $fields));
     803      } else {
     804          throw new coding_exception('Invalid $fileds parameter in enrol_get_my_courses()');
     805      }
     806      if (in_array('*', $fields)) {
     807          $fields = array('*');
     808      }
     809  
     810      $orderby = "";
     811      $sort    = trim($sort);
     812      if (!empty($sort)) {
     813          $rawsorts = explode(',', $sort);
     814          $sorts = array();
     815          foreach ($rawsorts as $rawsort) {
     816              $rawsort = trim($rawsort);
     817              if (strpos($rawsort, 'c.') === 0) {
     818                  $rawsort = substr($rawsort, 2);
     819              }
     820              $sorts[] = trim($rawsort);
     821          }
     822          $sort = 'c.'.implode(',c.', $sorts);
     823          $orderby = "ORDER BY $sort";
     824      }
     825  
     826      $params = array('siteid'=>SITEID);
     827  
     828      if ($onlyactive) {
     829          $subwhere = "WHERE ue.status = :active AND e.status = :enabled AND ue.timestart < :now1 AND (ue.timeend = 0 OR ue.timeend > :now2)";
     830          $params['now1']    = round(time(), -2); // improves db caching
     831          $params['now2']    = $params['now1'];
     832          $params['active']  = ENROL_USER_ACTIVE;
     833          $params['enabled'] = ENROL_INSTANCE_ENABLED;
     834      } else {
     835          $subwhere = "";
     836      }
     837  
     838      $coursefields = 'c.' .join(',c.', $fields);
     839      $ccselect = ', ' . context_helper::get_preload_record_columns_sql('ctx');
     840      $ccjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = c.id AND ctx.contextlevel = :contextlevel)";
     841      $params['contextlevel'] = CONTEXT_COURSE;
     842  
     843      //note: we can not use DISTINCT + text fields due to Oracle and MS limitations, that is why we have the subselect there
     844      $sql = "SELECT $coursefields $ccselect
     845                FROM {course} c
     846                JOIN (SELECT DISTINCT e.courseid
     847                        FROM {enrol} e
     848                        JOIN {user_enrolments} ue ON (ue.enrolid = e.id AND ue.userid = :userid)
     849                   $subwhere
     850                     ) en ON (en.courseid = c.id)
     851             $ccjoin
     852               WHERE c.id <> :siteid
     853            $orderby";
     854      $params['userid']  = $userid;
     855  
     856      $courses = $DB->get_records_sql($sql, $params);
     857  
     858      return $courses;
     859  }
     860  
     861  
     862  
     863  /**
     864   * Called when user is about to be deleted.
     865   * @param object $user
     866   * @return void
     867   */
     868  function enrol_user_delete($user) {
     869      global $DB;
     870  
     871      $plugins = enrol_get_plugins(true);
     872      foreach ($plugins as $plugin) {
     873          $plugin->user_delete($user);
     874      }
     875  
     876      // force cleanup of all broken enrolments
     877      $DB->delete_records('user_enrolments', array('userid'=>$user->id));
     878  }
     879  
     880  /**
     881   * Called when course is about to be deleted.
     882   * @param stdClass $course
     883   * @return void
     884   */
     885  function enrol_course_delete($course) {
     886      global $DB;
     887  
     888      $instances = enrol_get_instances($course->id, false);
     889      $plugins = enrol_get_plugins(true);
     890      foreach ($instances as $instance) {
     891          if (isset($plugins[$instance->enrol])) {
     892              $plugins[$instance->enrol]->delete_instance($instance);
     893          }
     894          // low level delete in case plugin did not do it
     895          $DB->delete_records('user_enrolments', array('enrolid'=>$instance->id));
     896          $DB->delete_records('role_assignments', array('itemid'=>$instance->id, 'component'=>'enrol_'.$instance->enrol));
     897          $DB->delete_records('user_enrolments', array('enrolid'=>$instance->id));
     898          $DB->delete_records('enrol', array('id'=>$instance->id));
     899      }
     900  }
     901  
     902  /**
     903   * Try to enrol user via default internal auth plugin.
     904   *
     905   * For now this is always using the manual enrol plugin...
     906   *
     907   * @param $courseid
     908   * @param $userid
     909   * @param $roleid
     910   * @param $timestart
     911   * @param $timeend
     912   * @return bool success
     913   */
     914  function enrol_try_internal_enrol($courseid, $userid, $roleid = null, $timestart = 0, $timeend = 0) {
     915      global $DB;
     916  
     917      //note: this is hardcoded to manual plugin for now
     918  
     919      if (!enrol_is_enabled('manual')) {
     920          return false;
     921      }
     922  
     923      if (!$enrol = enrol_get_plugin('manual')) {
     924          return false;
     925      }
     926      if (!$instances = $DB->get_records('enrol', array('enrol'=>'manual', 'courseid'=>$courseid, 'status'=>ENROL_INSTANCE_ENABLED), 'sortorder,id ASC')) {
     927          return false;
     928      }
     929      $instance = reset($instances);
     930  
     931      $enrol->enrol_user($instance, $userid, $roleid, $timestart, $timeend);
     932  
     933      return true;
     934  }
     935  
     936  /**
     937   * Is there a chance users might self enrol
     938   * @param int $courseid
     939   * @return bool
     940   */
     941  function enrol_selfenrol_available($courseid) {
     942      $result = false;
     943  
     944      $plugins = enrol_get_plugins(true);
     945      $enrolinstances = enrol_get_instances($courseid, true);
     946      foreach($enrolinstances as $instance) {
     947          if (!isset($plugins[$instance->enrol])) {
     948              continue;
     949          }
     950          if ($instance->enrol === 'guest') {
     951              // blacklist known temporary guest plugins
     952              continue;
     953          }
     954          if ($plugins[$instance->enrol]->show_enrolme_link($instance)) {
     955              $result = true;
     956              break;
     957          }
     958      }
     959  
     960      return $result;
     961  }
     962  
     963  /**
     964   * This function returns the end of current active user enrolment.
     965   *
     966   * It deals correctly with multiple overlapping user enrolments.
     967   *
     968   * @param int $courseid
     969   * @param int $userid
     970   * @return int|bool timestamp when active enrolment ends, false means no active enrolment now, 0 means never
     971   */
     972  function enrol_get_enrolment_end($courseid, $userid) {
     973      global $DB;
     974  
     975      $sql = "SELECT ue.*
     976                FROM {user_enrolments} ue
     977                JOIN {enrol} e ON (e.id = ue.enrolid AND e.courseid = :courseid)
     978                JOIN {user} u ON u.id = ue.userid
     979               WHERE ue.userid = :userid AND ue.status = :active AND e.status = :enabled AND u.deleted = 0";
     980      $params = array('enabled'=>ENROL_INSTANCE_ENABLED, 'active'=>ENROL_USER_ACTIVE, 'userid'=>$userid, 'courseid'=>$courseid);
     981  
     982      if (!$enrolments = $DB->get_records_sql($sql, $params)) {
     983          return false;
     984      }
     985  
     986      $changes = array();
     987  
     988      foreach ($enrolments as $ue) {
     989          $start = (int)$ue->timestart;
     990          $end = (int)$ue->timeend;
     991          if ($end != 0 and $end < $start) {
     992              debugging('Invalid enrolment start or end in user_enrolment id:'.$ue->id);
     993              continue;
     994          }
     995          if (isset($changes[$start])) {
     996              $changes[$start] = $changes[$start] + 1;
     997          } else {
     998              $changes[$start] = 1;
     999          }
    1000          if ($end === 0) {
    1001              // no end
    1002          } else if (isset($changes[$end])) {
    1003              $changes[$end] = $changes[$end] - 1;
    1004          } else {
    1005              $changes[$end] = -1;
    1006          }
    1007      }
    1008  
    1009      // let's sort then enrolment starts&ends and go through them chronologically,
    1010      // looking for current status and the next future end of enrolment
    1011      ksort($changes);
    1012  
    1013      $now = time();
    1014      $current = 0;
    1015      $present = null;
    1016  
    1017      foreach ($changes as $time => $change) {
    1018          if ($time > $now) {
    1019              if ($present === null) {
    1020                  // we have just went past current time
    1021                  $present = $current;
    1022                  if ($present < 1) {
    1023                      // no enrolment active
    1024                      return false;
    1025                  }
    1026              }
    1027              if ($present !== null) {
    1028                  // we are already in the future - look for possible end
    1029                  if ($current + $change < 1) {
    1030                      return $time;
    1031                  }
    1032              }
    1033          }
    1034          $current += $change;
    1035      }
    1036  
    1037      if ($current > 0) {
    1038          return 0;
    1039      } else {
    1040          return false;
    1041      }
    1042  }
    1043  
    1044  /**
    1045   * Is current user accessing course via this enrolment method?
    1046   *
    1047   * This is intended for operations that are going to affect enrol instances.
    1048   *
    1049   * @param stdClass $instance enrol instance
    1050   * @return bool
    1051   */
    1052  function enrol_accessing_via_instance(stdClass $instance) {
    1053      global $DB, $USER;
    1054  
    1055      if (empty($instance->id)) {
    1056          return false;
    1057      }
    1058  
    1059      if (is_siteadmin()) {
    1060          // Admins may go anywhere.
    1061          return false;
    1062      }
    1063  
    1064      return $DB->record_exists('user_enrolments', array('userid'=>$USER->id, 'enrolid'=>$instance->id));
    1065  }
    1066  
    1067  
    1068  /**
    1069   * All enrol plugins should be based on this class,
    1070   * this is also the main source of documentation.
    1071   */
    1072  abstract class enrol_plugin {
    1073      protected $config = null;
    1074  
    1075      /**
    1076       * Returns name of this enrol plugin
    1077       * @return string
    1078       */
    1079      public function get_name() {
    1080          // second word in class is always enrol name, sorry, no fancy plugin names with _
    1081          $words = explode('_', get_class($this));
    1082          return $words[1];
    1083      }
    1084  
    1085      /**
    1086       * Returns localised name of enrol instance
    1087       *
    1088       * @param object $instance (null is accepted too)
    1089       * @return string
    1090       */
    1091      public function get_instance_name($instance) {
    1092          if (empty($instance->name)) {
    1093              $enrol = $this->get_name();
    1094              return get_string('pluginname', 'enrol_'.$enrol);
    1095          } else {
    1096              $context = context_course::instance($instance->courseid);
    1097              return format_string($instance->name, true, array('context'=>$context));
    1098          }
    1099      }
    1100  
    1101      /**
    1102       * Returns optional enrolment information icons.
    1103       *
    1104       * This is used in course list for quick overview of enrolment options.
    1105       *
    1106       * We are not using single instance parameter because sometimes
    1107       * we might want to prevent icon repetition when multiple instances
    1108       * of one type exist. One instance may also produce several icons.
    1109       *
    1110       * @param array $instances all enrol instances of this type in one course
    1111       * @return array of pix_icon
    1112       */
    1113      public function get_info_icons(array $instances) {
    1114          return array();
    1115      }
    1116  
    1117      /**
    1118       * Returns optional enrolment instance description text.
    1119       *
    1120       * This is used in detailed course information.
    1121       *
    1122       *
    1123       * @param object $instance
    1124       * @return string short html text
    1125       */
    1126      public function get_description_text($instance) {
    1127          return null;
    1128      }
    1129  
    1130      /**
    1131       * Makes sure config is loaded and cached.
    1132       * @return void
    1133       */
    1134      protected function load_config() {
    1135          if (!isset($this->config)) {
    1136              $name = $this->get_name();
    1137              $this->config = get_config("enrol_$name");
    1138          }
    1139      }
    1140  
    1141      /**
    1142       * Returns plugin config value
    1143       * @param  string $name
    1144       * @param  string $default value if config does not exist yet
    1145       * @return string value or default
    1146       */
    1147      public function get_config($name, $default = NULL) {
    1148          $this->load_config();
    1149          return isset($this->config->$name) ? $this->config->$name : $default;
    1150      }
    1151  
    1152      /**
    1153       * Sets plugin config value
    1154       * @param  string $name name of config
    1155       * @param  string $value string config value, null means delete
    1156       * @return string value
    1157       */
    1158      public function set_config($name, $value) {
    1159          $pluginname = $this->get_name();
    1160          $this->load_config();
    1161          if ($value === NULL) {
    1162              unset($this->config->$name);
    1163          } else {
    1164              $this->config->$name = $value;
    1165          }
    1166          set_config($name, $value, "enrol_$pluginname");
    1167      }
    1168  
    1169      /**
    1170       * Does this plugin assign protected roles are can they be manually removed?
    1171       * @return bool - false means anybody may tweak roles, it does not use itemid and component when assigning roles
    1172       */
    1173      public function roles_protected() {
    1174          return true;
    1175      }
    1176  
    1177      /**
    1178       * Does this plugin allow manual enrolments?
    1179       *
    1180       * @param stdClass $instance course enrol instance
    1181       * All plugins allowing this must implement 'enrol/xxx:enrol' capability
    1182       *
    1183       * @return bool - true means user with 'enrol/xxx:enrol' may enrol others freely, false means nobody may add more enrolments manually
    1184       */
    1185      public function allow_enrol(stdClass $instance) {
    1186          return false;
    1187      }
    1188  
    1189      /**
    1190       * Does this plugin allow manual unenrolment of all users?
    1191       * All plugins allowing this must implement 'enrol/xxx:unenrol' capability
    1192       *
    1193       * @param stdClass $instance course enrol instance
    1194       * @return bool - true means user with 'enrol/xxx:unenrol' may unenrol others freely, false means nobody may touch user_enrolments
    1195       */
    1196      public function allow_unenrol(stdClass $instance) {
    1197          return false;
    1198      }
    1199  
    1200      /**
    1201       * Does this plugin allow manual unenrolment of a specific user?
    1202       * All plugins allowing this must implement 'enrol/xxx:unenrol' capability
    1203       *
    1204       * This is useful especially for synchronisation plugins that
    1205       * do suspend instead of full unenrolment.
    1206       *
    1207       * @param stdClass $instance course enrol instance
    1208       * @param stdClass $ue record from user_enrolments table, specifies user
    1209       *
    1210       * @return bool - true means user with 'enrol/xxx:unenrol' may unenrol this user, false means nobody may touch this user enrolment
    1211       */
    1212      public function allow_unenrol_user(stdClass $instance, stdClass $ue) {
    1213          return $this->allow_unenrol($instance);
    1214      }
    1215  
    1216      /**
    1217       * Does this plugin allow manual changes in user_enrolments table?
    1218       *
    1219       * All plugins allowing this must implement 'enrol/xxx:manage' capability
    1220       *
    1221       * @param stdClass $instance course enrol instance
    1222       * @return bool - true means it is possible to change enrol period and status in user_enrolments table
    1223       */
    1224      public function allow_manage(stdClass $instance) {
    1225          return false;
    1226      }
    1227  
    1228      /**
    1229       * Does this plugin support some way to user to self enrol?
    1230       *
    1231       * @param stdClass $instance course enrol instance
    1232       *
    1233       * @return bool - true means show "Enrol me in this course" link in course UI
    1234       */
    1235      public function show_enrolme_link(stdClass $instance) {
    1236          return false;
    1237      }
    1238  
    1239      /**
    1240       * Attempt to automatically enrol current user in course without any interaction,
    1241       * calling code has to make sure the plugin and instance are active.
    1242       *
    1243       * This should return either a timestamp in the future or false.
    1244       *
    1245       * @param stdClass $instance course enrol instance
    1246       * @return bool|int false means not enrolled, integer means timeend
    1247       */
    1248      public function try_autoenrol(stdClass $instance) {
    1249          global $USER;
    1250  
    1251          return false;
    1252      }
    1253  
    1254      /**
    1255       * Attempt to automatically gain temporary guest access to course,
    1256       * calling code has to make sure the plugin and instance are active.
    1257       *
    1258       * This should return either a timestamp in the future or false.
    1259       *
    1260       * @param stdClass $instance course enrol instance
    1261       * @return bool|int false means no guest access, integer means timeend
    1262       */
    1263      public function try_guestaccess(stdClass $instance) {
    1264          global $USER;
    1265  
    1266          return false;
    1267      }
    1268  
    1269      /**
    1270       * Enrol user into course via enrol instance.
    1271       *
    1272       * @param stdClass $instance
    1273       * @param int $userid
    1274       * @param int $roleid optional role id
    1275       * @param int $timestart 0 means unknown
    1276       * @param int $timeend 0 means forever
    1277       * @param int $status default to ENROL_USER_ACTIVE for new enrolments, no change by default in updates
    1278       * @param bool $recovergrades restore grade history
    1279       * @return void
    1280       */
    1281      public function enrol_user(stdClass $instance, $userid, $roleid = null, $timestart = 0, $timeend = 0, $status = null, $recovergrades = null) {
    1282          global $DB, $USER, $CFG; // CFG necessary!!!
    1283  
    1284          if ($instance->courseid == SITEID) {
    1285              throw new coding_exception('invalid attempt to enrol into frontpage course!');
    1286          }
    1287  
    1288          $name = $this->get_name();
    1289          $courseid = $instance->courseid;
    1290  
    1291          if ($instance->enrol !== $name) {
    1292              throw new coding_exception('invalid enrol instance!');
    1293          }
    1294          $context = context_course::instance($instance->courseid, MUST_EXIST);
    1295          if (!isset($recovergrades)) {
    1296              $recovergrades = $CFG->recovergradesdefault;
    1297          }
    1298  
    1299          $inserted = false;
    1300          $updated  = false;
    1301          if ($ue = $DB->get_record('user_enrolments', array('enrolid'=>$instance->id, 'userid'=>$userid))) {
    1302              //only update if timestart or timeend or status are different.
    1303              if ($ue->timestart != $timestart or $ue->timeend != $timeend or (!is_null($status) and $ue->status != $status)) {
    1304                  $this->update_user_enrol($instance, $userid, $status, $timestart, $timeend);
    1305              }
    1306          } else {
    1307              $ue = new stdClass();
    1308              $ue->enrolid      = $instance->id;
    1309              $ue->status       = is_null($status) ? ENROL_USER_ACTIVE : $status;
    1310              $ue->userid       = $userid;
    1311              $ue->timestart    = $timestart;
    1312              $ue->timeend      = $timeend;
    1313              $ue->modifierid   = $USER->id;
    1314              $ue->timecreated  = time();
    1315              $ue->timemodified = $ue->timecreated;
    1316              $ue->id = $DB->insert_record('user_enrolments', $ue);
    1317  
    1318              $inserted = true;
    1319          }
    1320  
    1321          if ($inserted) {
    1322              // Trigger event.
    1323              $event = \core\event\user_enrolment_created::create(
    1324                      array(
    1325                          'objectid' => $ue->id,
    1326                          'courseid' => $courseid,
    1327                          'context' => $context,
    1328                          'relateduserid' => $ue->userid,
    1329                          'other' => array('enrol' => $name)
    1330                          )
    1331                      );
    1332              $event->trigger();
    1333          }
    1334  
    1335          if ($roleid) {
    1336              // this must be done after the enrolment event so that the role_assigned event is triggered afterwards
    1337              if ($this->roles_protected()) {
    1338                  role_assign($roleid, $userid, $context->id, 'enrol_'.$name, $instance->id);
    1339              } else {
    1340                  role_assign($roleid, $userid, $context->id);
    1341              }
    1342          }
    1343  
    1344          // Recover old grades if present.
    1345          if ($recovergrades) {
    1346              require_once("$CFG->libdir/gradelib.php");
    1347              grade_recover_history_grades($userid, $courseid);
    1348          }
    1349  
    1350          // reset current user enrolment caching
    1351          if ($userid == $USER->id) {
    1352              if (isset($USER->enrol['enrolled'][$courseid])) {
    1353                  unset($USER->enrol['enrolled'][$courseid]);
    1354              }
    1355              if (isset($USER->enrol['tempguest'][$courseid])) {
    1356                  unset($USER->enrol['tempguest'][$courseid]);
    1357                  remove_temp_course_roles($context);
    1358              }
    1359          }
    1360      }
    1361  
    1362      /**
    1363       * Store user_enrolments changes and trigger event.
    1364       *
    1365       * @param stdClass $instance
    1366       * @param int $userid
    1367       * @param int $status
    1368       * @param int $timestart
    1369       * @param int $timeend
    1370       * @return void
    1371       */
    1372      public function update_user_enrol(stdClass $instance, $userid, $status = NULL, $timestart = NULL, $timeend = NULL) {
    1373          global $DB, $USER;
    1374  
    1375          $name = $this->get_name();
    1376  
    1377          if ($instance->enrol !== $name) {
    1378              throw new coding_exception('invalid enrol instance!');
    1379          }
    1380  
    1381          if (!$ue = $DB->get_record('user_enrolments', array('enrolid'=>$instance->id, 'userid'=>$userid))) {
    1382              // weird, user not enrolled
    1383              return;
    1384          }
    1385  
    1386          $modified = false;
    1387          if (isset($status) and $ue->status != $status) {
    1388              $ue->status = $status;
    1389              $modified = true;
    1390          }
    1391          if (isset($timestart) and $ue->timestart != $timestart) {
    1392              $ue->timestart = $timestart;
    1393              $modified = true;
    1394          }
    1395          if (isset($timeend) and $ue->timeend != $timeend) {
    1396              $ue->timeend = $timeend;
    1397              $modified = true;
    1398          }
    1399  
    1400          if (!$modified) {
    1401              // no change
    1402              return;
    1403          }
    1404  
    1405          $ue->modifierid = $USER->id;
    1406          $DB->update_record('user_enrolments', $ue);
    1407          context_course::instance($instance->courseid)->mark_dirty(); // reset enrol caches
    1408  
    1409          // Invalidate core_access cache for get_suspended_userids.
    1410          cache_helper::invalidate_by_definition('core', 'suspended_userids', array(), array($instance->courseid));
    1411  
    1412          // Trigger event.
    1413          $event = \core\event\user_enrolment_updated::create(
    1414                  array(
    1415                      'objectid' => $ue->id,
    1416                      'courseid' => $instance->courseid,
    1417                      'context' => context_course::instance($instance->courseid),
    1418                      'relateduserid' => $ue->userid,
    1419                      'other' => array('enrol' => $name)
    1420                      )
    1421                  );
    1422          $event->trigger();
    1423      }
    1424  
    1425      /**
    1426       * Unenrol user from course,
    1427       * the last unenrolment removes all remaining roles.
    1428       *
    1429       * @param stdClass $instance
    1430       * @param int $userid
    1431       * @return void
    1432       */
    1433      public function unenrol_user(stdClass $instance, $userid) {
    1434          global $CFG, $USER, $DB;
    1435          require_once("$CFG->dirroot/group/lib.php");
    1436  
    1437          $name = $this->get_name();
    1438          $courseid = $instance->courseid;
    1439  
    1440          if ($instance->enrol !== $name) {
    1441              throw new coding_exception('invalid enrol instance!');
    1442          }
    1443          $context = context_course::instance($instance->courseid, MUST_EXIST);
    1444  
    1445          if (!$ue = $DB->get_record('user_enrolments', array('enrolid'=>$instance->id, 'userid'=>$userid))) {
    1446              // weird, user not enrolled
    1447              return;
    1448          }
    1449  
    1450          // Remove all users groups linked to this enrolment instance.
    1451          if ($gms = $DB->get_records('groups_members', array('userid'=>$userid, 'component'=>'enrol_'.$name, 'itemid'=>$instance->id))) {
    1452              foreach ($gms as $gm) {
    1453                  groups_remove_member($gm->groupid, $gm->userid);
    1454              }
    1455          }
    1456  
    1457          role_unassign_all(array('userid'=>$userid, 'contextid'=>$context->id, 'component'=>'enrol_'.$name, 'itemid'=>$instance->id));
    1458          $DB->delete_records('user_enrolments', array('id'=>$ue->id));
    1459  
    1460          // add extra info and trigger event
    1461          $ue->courseid  = $courseid;
    1462          $ue->enrol     = $name;
    1463  
    1464          $sql = "SELECT 'x'
    1465                    FROM {user_enrolments} ue
    1466                    JOIN {enrol} e ON (e.id = ue.enrolid)
    1467                   WHERE ue.userid = :userid AND e.courseid = :courseid";
    1468          if ($DB->record_exists_sql($sql, array('userid'=>$userid, 'courseid'=>$courseid))) {
    1469              $ue->lastenrol = false;
    1470  
    1471          } else {
    1472              // the big cleanup IS necessary!
    1473              require_once("$CFG->libdir/gradelib.php");
    1474  
    1475              // remove all remaining roles
    1476              role_unassign_all(array('userid'=>$userid, 'contextid'=>$context->id), true, false);
    1477  
    1478              //clean up ALL invisible user data from course if this is the last enrolment - groups, grades, etc.
    1479              groups_delete_group_members($courseid, $userid);
    1480  
    1481              grade_user_unenrol($courseid, $userid);
    1482  
    1483              $DB->delete_records('user_lastaccess', array('userid'=>$userid, 'courseid'=>$courseid));
    1484  
    1485              $ue->lastenrol = true; // means user not enrolled any more
    1486          }
    1487          // Trigger event.
    1488          $event = \core\event\user_enrolment_deleted::create(
    1489                  array(
    1490                      'courseid' => $courseid,
    1491                      'context' => $context,
    1492                      'relateduserid' => $ue->userid,
    1493                      'objectid' => $ue->id,
    1494                      'other' => array(
    1495                          'userenrolment' => (array)$ue,
    1496                          'enrol' => $name
    1497                          )
    1498                      )
    1499                  );
    1500          $event->trigger();
    1501          // reset all enrol caches
    1502          $context->mark_dirty();
    1503  
    1504          // reset current user enrolment caching
    1505          if ($userid == $USER->id) {
    1506              if (isset($USER->enrol['enrolled'][$courseid])) {
    1507                  unset($USER->enrol['enrolled'][$courseid]);
    1508              }
    1509              if (isset($USER->enrol['tempguest'][$courseid])) {
    1510                  unset($USER->enrol['tempguest'][$courseid]);
    1511                  remove_temp_course_roles($context);
    1512              }
    1513          }
    1514      }
    1515  
    1516      /**
    1517       * Forces synchronisation of user enrolments.
    1518       *
    1519       * This is important especially for external enrol plugins,
    1520       * this function is called for all enabled enrol plugins
    1521       * right after every user login.
    1522       *
    1523       * @param object $user user record
    1524       * @return void
    1525       */
    1526      public function sync_user_enrolments($user) {
    1527          // override if necessary
    1528      }
    1529  
    1530      /**
    1531       * Returns link to page which may be used to add new instance of enrolment plugin in course.
    1532       * @param int $courseid
    1533       * @return moodle_url page url
    1534       */
    1535      public function get_newinstance_link($courseid) {
    1536          // override for most plugins, check if instance already exists in cases only one instance is supported
    1537          return NULL;
    1538      }
    1539  
    1540      /**
    1541       * Is it possible to delete enrol instance via standard UI?
    1542       *
    1543       * @deprecated since Moodle 2.8 MDL-35864 - please use can_delete_instance() instead.
    1544       * @todo MDL-46479 This will be deleted in Moodle 3.0.
    1545       * @see class_name::can_delete_instance()
    1546       * @param object $instance
    1547       * @return bool
    1548       */
    1549      public function instance_deleteable($instance) {
    1550          debugging('Function enrol_plugin::instance_deleteable() is deprecated', DEBUG_DEVELOPER);
    1551          return $this->can_delete_instance($instance);
    1552      }
    1553  
    1554      /**
    1555       * Is it possible to delete enrol instance via standard UI?
    1556       *
    1557       * @param stdClass  $instance
    1558       * @return bool
    1559       */
    1560      public function can_delete_instance($instance) {
    1561          return false;
    1562      }
    1563  
    1564      /**
    1565       * Is it possible to hide/show enrol instance via standard UI?
    1566       *
    1567       * @param stdClass $instance
    1568       * @return bool
    1569       */
    1570      public function can_hide_show_instance($instance) {
    1571          debugging("The enrolment plugin '".$this->get_name()."' should override the function can_hide_show_instance().", DEBUG_DEVELOPER);
    1572          return true;
    1573      }
    1574  
    1575      /**
    1576       * Returns link to manual enrol UI if exists.
    1577       * Does the access control tests automatically.
    1578       *
    1579       * @param object $instance
    1580       * @return moodle_url
    1581       */
    1582      public function get_manual_enrol_link($instance) {
    1583          return NULL;
    1584      }
    1585  
    1586      /**
    1587       * Returns list of unenrol links for all enrol instances in course.
    1588       *
    1589       * @param int $instance
    1590       * @return moodle_url or NULL if self unenrolment not supported
    1591       */
    1592      public function get_unenrolself_link($instance) {
    1593          global $USER, $CFG, $DB;
    1594  
    1595          $name = $this->get_name();
    1596          if ($instance->enrol !== $name) {
    1597              throw new coding_exception('invalid enrol instance!');
    1598          }
    1599  
    1600          if ($instance->courseid == SITEID) {
    1601              return NULL;
    1602          }
    1603  
    1604          if (!enrol_is_enabled($name)) {
    1605              return NULL;
    1606          }
    1607  
    1608          if ($instance->status != ENROL_INSTANCE_ENABLED) {
    1609              return NULL;
    1610          }
    1611  
    1612          if (!file_exists("$CFG->dirroot/enrol/$name/unenrolself.php")) {
    1613              return NULL;
    1614          }
    1615  
    1616          $context = context_course::instance($instance->courseid, MUST_EXIST);
    1617  
    1618          if (!has_capability("enrol/$name:unenrolself", $context)) {
    1619              return NULL;
    1620          }
    1621  
    1622          if (!$DB->record_exists('user_enrolments', array('enrolid'=>$instance->id, 'userid'=>$USER->id, 'status'=>ENROL_USER_ACTIVE))) {
    1623              return NULL;
    1624          }
    1625  
    1626          return new moodle_url("/enrol/$name/unenrolself.php", array('enrolid'=>$instance->id));
    1627      }
    1628  
    1629      /**
    1630       * Adds enrol instance UI to course edit form
    1631       *
    1632       * @param object $instance enrol instance or null if does not exist yet
    1633       * @param MoodleQuickForm $mform
    1634       * @param object $data
    1635       * @param object $context context of existing course or parent category if course does not exist
    1636       * @return void
    1637       */
    1638      public function course_edit_form($instance, MoodleQuickForm $mform, $data, $context) {
    1639          // override - usually at least enable/disable switch, has to add own form header
    1640      }
    1641  
    1642      /**
    1643       * Validates course edit form data
    1644       *
    1645       * @param object $instance enrol instance or null if does not exist yet
    1646       * @param array $data
    1647       * @param object $context context of existing course or parent category if course does not exist
    1648       * @return array errors array
    1649       */
    1650      public function course_edit_validation($instance, array $data, $context) {
    1651          return array();
    1652      }
    1653  
    1654      /**
    1655       * Called after updating/inserting course.
    1656       *
    1657       * @param bool $inserted true if course just inserted
    1658       * @param object $course
    1659       * @param object $data form data
    1660       * @return void
    1661       */
    1662      public function course_updated($inserted, $course, $data) {
    1663          if ($inserted) {
    1664              if ($this->get_config('defaultenrol')) {
    1665                  $this->add_default_instance($course);
    1666              }
    1667          }
    1668      }
    1669  
    1670      /**
    1671       * Add new instance of enrol plugin.
    1672       * @param object $course
    1673       * @param array instance fields
    1674       * @return int id of new instance, null if can not be created
    1675       */
    1676      public function add_instance($course, array $fields = NULL) {
    1677          global $DB;
    1678  
    1679          if ($course->id == SITEID) {
    1680              throw new coding_exception('Invalid request to add enrol instance to frontpage.');
    1681          }
    1682  
    1683          $instance = new stdClass();
    1684          $instance->enrol          = $this->get_name();
    1685          $instance->status         = ENROL_INSTANCE_ENABLED;
    1686          $instance->courseid       = $course->id;
    1687          $instance->enrolstartdate = 0;
    1688          $instance->enrolenddate   = 0;
    1689          $instance->timemodified   = time();
    1690          $instance->timecreated    = $instance->timemodified;
    1691          $instance->sortorder      = $DB->get_field('enrol', 'COALESCE(MAX(sortorder), -1) + 1', array('courseid'=>$course->id));
    1692  
    1693          $fields = (array)$fields;
    1694          unset($fields['enrol']);
    1695          unset($fields['courseid']);
    1696          unset($fields['sortorder']);
    1697          foreach($fields as $field=>$value) {
    1698              $instance->$field = $value;
    1699          }
    1700  
    1701          return $DB->insert_record('enrol', $instance);
    1702      }
    1703  
    1704      /**
    1705       * Add new instance of enrol plugin with default settings,
    1706       * called when adding new instance manually or when adding new course.
    1707       *
    1708       * Not all plugins support this.
    1709       *
    1710       * @param object $course
    1711       * @return int id of new instance or null if no default supported
    1712       */
    1713      public function add_default_instance($course) {
    1714          return null;
    1715      }
    1716  
    1717      /**
    1718       * Update instance status
    1719       *
    1720       * Override when plugin needs to do some action when enabled or disabled.
    1721       *
    1722       * @param stdClass $instance
    1723       * @param int $newstatus ENROL_INSTANCE_ENABLED, ENROL_INSTANCE_DISABLED
    1724       * @return void
    1725       */
    1726      public function update_status($instance, $newstatus) {
    1727          global $DB;
    1728  
    1729          $instance->status = $newstatus;
    1730          $DB->update_record('enrol', $instance);
    1731  
    1732          // invalidate all enrol caches
    1733          $context = context_course::instance($instance->courseid);
    1734          $context->mark_dirty();
    1735      }
    1736  
    1737      /**
    1738       * Delete course enrol plugin instance, unenrol all users.
    1739       * @param object $instance
    1740       * @return void
    1741       */
    1742      public function delete_instance($instance) {
    1743          global $DB;
    1744  
    1745          $name = $this->get_name();
    1746          if ($instance->enrol !== $name) {
    1747              throw new coding_exception('invalid enrol instance!');
    1748          }
    1749  
    1750          //first unenrol all users
    1751          $participants = $DB->get_recordset('user_enrolments', array('enrolid'=>$instance->id));
    1752          foreach ($participants as $participant) {
    1753              $this->unenrol_user($instance, $participant->userid);
    1754          }
    1755          $participants->close();
    1756  
    1757          // now clean up all remainders that were not removed correctly
    1758          $DB->delete_records('groups_members', array('itemid'=>$instance->id, 'component'=>'enrol_'.$name));
    1759          $DB->delete_records('role_assignments', array('itemid'=>$instance->id, 'component'=>'enrol_'.$name));
    1760          $DB->delete_records('user_enrolments', array('enrolid'=>$instance->id));
    1761  
    1762          // finally drop the enrol row
    1763          $DB->delete_records('enrol', array('id'=>$instance->id));
    1764  
    1765          // invalidate all enrol caches
    1766          $context = context_course::instance($instance->courseid);
    1767          $context->mark_dirty();
    1768      }
    1769  
    1770      /**
    1771       * Creates course enrol form, checks if form submitted
    1772       * and enrols user if necessary. It can also redirect.
    1773       *
    1774       * @param stdClass $instance
    1775       * @return string html text, usually a form in a text box
    1776       */
    1777      public function enrol_page_hook(stdClass $instance) {
    1778          return null;
    1779      }
    1780  
    1781      /**
    1782       * Checks if user can self enrol.
    1783       *
    1784       * @param stdClass $instance enrolment instance
    1785       * @param bool $checkuserenrolment if true will check if user enrolment is inactive.
    1786       *             used by navigation to improve performance.
    1787       * @return bool|string true if successful, else error message or false
    1788       */
    1789      public function can_self_enrol(stdClass $instance, $checkuserenrolment = true) {
    1790          return false;
    1791      }
    1792  
    1793      /**
    1794       * Return information for enrolment instance containing list of parameters required
    1795       * for enrolment, name of enrolment plugin etc.
    1796       *
    1797       * @param stdClass $instance enrolment instance
    1798       * @return array instance info.
    1799       */
    1800      public function get_enrol_info(stdClass $instance) {
    1801          return null;
    1802      }
    1803  
    1804      /**
    1805       * Adds navigation links into course admin block.
    1806       *
    1807       * By defaults looks for manage links only.
    1808       *
    1809       * @param navigation_node $instancesnode
    1810       * @param stdClass $instance
    1811       * @return void
    1812       */
    1813      public function add_course_navigation($instancesnode, stdClass $instance) {
    1814          // usually adds manage users
    1815      }
    1816  
    1817      /**
    1818       * Returns edit icons for the page with list of instances
    1819       * @param stdClass $instance
    1820       * @return array
    1821       */
    1822      public function get_action_icons(stdClass $instance) {
    1823          return array();
    1824      }
    1825  
    1826      /**
    1827       * Reads version.php and determines if it is necessary
    1828       * to execute the cron job now.
    1829       * @return bool
    1830       */
    1831      public function is_cron_required() {
    1832          global $CFG;
    1833  
    1834          $name = $this->get_name();
    1835          $versionfile = "$CFG->dirroot/enrol/$name/version.php";
    1836          $plugin = new stdClass();
    1837          include($versionfile);
    1838          if (empty($plugin->cron)) {
    1839              return false;
    1840          }
    1841          $lastexecuted = $this->get_config('lastcron', 0);
    1842          if ($lastexecuted + $plugin->cron < time()) {
    1843              return true;
    1844          } else {
    1845              return false;
    1846          }
    1847      }
    1848  
    1849      /**
    1850       * Called for all enabled enrol plugins that returned true from is_cron_required().
    1851       * @return void
    1852       */
    1853      public function cron() {
    1854      }
    1855  
    1856      /**
    1857       * Called when user is about to be deleted
    1858       * @param object $user
    1859       * @return void
    1860       */
    1861      public function user_delete($user) {
    1862          global $DB;
    1863  
    1864          $sql = "SELECT e.*
    1865                    FROM {enrol} e
    1866                    JOIN {user_enrolments} ue ON (ue.enrolid = e.id)
    1867                   WHERE e.enrol = :name AND ue.userid = :userid";
    1868          $params = array('name'=>$this->get_name(), 'userid'=>$user->id);
    1869  
    1870          $rs = $DB->get_recordset_sql($sql, $params);
    1871          foreach($rs as $instance) {
    1872              $this->unenrol_user($instance, $user->id);
    1873          }
    1874          $rs->close();
    1875      }
    1876  
    1877      /**
    1878       * Returns an enrol_user_button that takes the user to a page where they are able to
    1879       * enrol users into the managers course through this plugin.
    1880       *
    1881       * Optional: If the plugin supports manual enrolments it can choose to override this
    1882       * otherwise it shouldn't
    1883       *
    1884       * @param course_enrolment_manager $manager
    1885       * @return enrol_user_button|false
    1886       */
    1887      public function get_manual_enrol_button(course_enrolment_manager $manager) {
    1888          return false;
    1889      }
    1890  
    1891      /**
    1892       * Gets an array of the user enrolment actions
    1893       *
    1894       * @param course_enrolment_manager $manager
    1895       * @param stdClass $ue
    1896       * @return array An array of user_enrolment_actions
    1897       */
    1898      public function get_user_enrolment_actions(course_enrolment_manager $manager, $ue) {
    1899          return array();
    1900      }
    1901  
    1902      /**
    1903       * Returns true if the plugin has one or more bulk operations that can be performed on
    1904       * user enrolments.
    1905       *
    1906       * @param course_enrolment_manager $manager
    1907       * @return bool
    1908       */
    1909      public function has_bulk_operations(course_enrolment_manager $manager) {
    1910         return false;
    1911      }
    1912  
    1913      /**
    1914       * Return an array of enrol_bulk_enrolment_operation objects that define
    1915       * the bulk actions that can be performed on user enrolments by the plugin.
    1916       *
    1917       * @param course_enrolment_manager $manager
    1918       * @return array
    1919       */
    1920      public function get_bulk_operations(course_enrolment_manager $manager) {
    1921          return array();
    1922      }
    1923  
    1924      /**
    1925       * Do any enrolments need expiration processing.
    1926       *
    1927       * Plugins that want to call this functionality must implement 'expiredaction' config setting.
    1928       *
    1929       * @param progress_trace $trace
    1930       * @param int $courseid one course, empty mean all
    1931       * @return bool true if any data processed, false if not
    1932       */
    1933      public function process_expirations(progress_trace $trace, $courseid = null) {
    1934          global $DB;
    1935  
    1936          $name = $this->get_name();
    1937          if (!enrol_is_enabled($name)) {
    1938              $trace->finished();
    1939              return false;
    1940          }
    1941  
    1942          $processed = false;
    1943          $params = array();
    1944          $coursesql = "";
    1945          if ($courseid) {
    1946              $coursesql = "AND e.courseid = :courseid";
    1947          }
    1948  
    1949          // Deal with expired accounts.
    1950          $action = $this->get_config('expiredaction', ENROL_EXT_REMOVED_KEEP);
    1951  
    1952          if ($action == ENROL_EXT_REMOVED_UNENROL) {
    1953              $instances = array();
    1954              $sql = "SELECT ue.*, e.courseid, c.id AS contextid
    1955                        FROM {user_enrolments} ue
    1956                        JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = :enrol)
    1957                        JOIN {context} c ON (c.instanceid = e.courseid AND c.contextlevel = :courselevel)
    1958                       WHERE ue.timeend > 0 AND ue.timeend < :now $coursesql";
    1959              $params = array('now'=>time(), 'courselevel'=>CONTEXT_COURSE, 'enrol'=>$name, 'courseid'=>$courseid);
    1960  
    1961              $rs = $DB->get_recordset_sql($sql, $params);
    1962              foreach ($rs as $ue) {
    1963                  if (!$processed) {
    1964                      $trace->output("Starting processing of enrol_$name expirations...");
    1965                      $processed = true;
    1966                  }
    1967                  if (empty($instances[$ue->enrolid])) {
    1968                      $instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
    1969                  }
    1970                  $instance = $instances[$ue->enrolid];
    1971                  if (!$this->roles_protected()) {
    1972                      // Let's just guess what extra roles are supposed to be removed.
    1973                      if ($instance->roleid) {
    1974                          role_unassign($instance->roleid, $ue->userid, $ue->contextid);
    1975                      }
    1976                  }
    1977                  // The unenrol cleans up all subcontexts if this is the only course enrolment for this user.
    1978                  $this->unenrol_user($instance, $ue->userid);
    1979                  $trace->output("Unenrolling expired user $ue->userid from course $instance->courseid", 1);
    1980              }
    1981              $rs->close();
    1982              unset($instances);
    1983  
    1984          } else if ($action == ENROL_EXT_REMOVED_SUSPENDNOROLES or $action == ENROL_EXT_REMOVED_SUSPEND) {
    1985              $instances = array();
    1986              $sql = "SELECT ue.*, e.courseid, c.id AS contextid
    1987                        FROM {user_enrolments} ue
    1988                        JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = :enrol)
    1989                        JOIN {context} c ON (c.instanceid = e.courseid AND c.contextlevel = :courselevel)
    1990                       WHERE ue.timeend > 0 AND ue.timeend < :now
    1991                             AND ue.status = :useractive $coursesql";
    1992              $params = array('now'=>time(), 'courselevel'=>CONTEXT_COURSE, 'useractive'=>ENROL_USER_ACTIVE, 'enrol'=>$name, 'courseid'=>$courseid);
    1993              $rs = $DB->get_recordset_sql($sql, $params);
    1994              foreach ($rs as $ue) {
    1995                  if (!$processed) {
    1996                      $trace->output("Starting processing of enrol_$name expirations...");
    1997                      $processed = true;
    1998                  }
    1999                  if (empty($instances[$ue->enrolid])) {
    2000                      $instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
    2001                  }
    2002                  $instance = $instances[$ue->enrolid];
    2003  
    2004                  if ($action == ENROL_EXT_REMOVED_SUSPENDNOROLES) {
    2005                      if (!$this->roles_protected()) {
    2006                          // Let's just guess what roles should be removed.
    2007                          $count = $DB->count_records('role_assignments', array('userid'=>$ue->userid, 'contextid'=>$ue->contextid));
    2008                          if ($count == 1) {
    2009                              role_unassign_all(array('userid'=>$ue->userid, 'contextid'=>$ue->contextid, 'component'=>'', 'itemid'=>0));
    2010  
    2011                          } else if ($count > 1 and $instance->roleid) {
    2012                              role_unassign($instance->roleid, $ue->userid, $ue->contextid, '', 0);
    2013                          }
    2014                      }
    2015                      // In any case remove all roles that belong to this instance and user.
    2016                      role_unassign_all(array('userid'=>$ue->userid, 'contextid'=>$ue->contextid, 'component'=>'enrol_'.$name, 'itemid'=>$instance->id), true);
    2017                      // Final cleanup of subcontexts if there are no more course roles.
    2018                      if (0 == $DB->count_records('role_assignments', array('userid'=>$ue->userid, 'contextid'=>$ue->contextid))) {
    2019                          role_unassign_all(array('userid'=>$ue->userid, 'contextid'=>$ue->contextid, 'component'=>'', 'itemid'=>0), true);
    2020                      }
    2021                  }
    2022  
    2023                  $this->update_user_enrol($instance, $ue->userid, ENROL_USER_SUSPENDED);
    2024                  $trace->output("Suspending expired user $ue->userid in course $instance->courseid", 1);
    2025              }
    2026              $rs->close();
    2027              unset($instances);
    2028  
    2029          } else {
    2030              // ENROL_EXT_REMOVED_KEEP means no changes.
    2031          }
    2032  
    2033          if ($processed) {
    2034              $trace->output("...finished processing of enrol_$name expirations");
    2035          } else {
    2036              $trace->output("No expired enrol_$name enrolments detected");
    2037          }
    2038          $trace->finished();
    2039  
    2040          return $processed;
    2041      }
    2042  
    2043      /**
    2044       * Send expiry notifications.
    2045       *
    2046       * Plugin that wants to have expiry notification MUST implement following:
    2047       * - expirynotifyhour plugin setting,
    2048       * - configuration options in instance edit form (expirynotify, notifyall and expirythreshold),
    2049       * - notification strings (expirymessageenrollersubject, expirymessageenrollerbody,
    2050       *   expirymessageenrolledsubject and expirymessageenrolledbody),
    2051       * - expiry_notification provider in db/messages.php,
    2052       * - upgrade code that sets default thresholds for existing courses (should be 1 day),
    2053       * - something that calls this method, such as cron.
    2054       *
    2055       * @param progress_trace $trace (accepts bool for backwards compatibility only)
    2056       */
    2057      public function send_expiry_notifications($trace) {
    2058          global $DB, $CFG;
    2059  
    2060          $name = $this->get_name();
    2061          if (!enrol_is_enabled($name)) {
    2062              $trace->finished();
    2063              return;
    2064          }
    2065  
    2066          // Unfortunately this may take a long time, it should not be interrupted,
    2067          // otherwise users get duplicate notification.
    2068  
    2069          core_php_time_limit::raise();
    2070          raise_memory_limit(MEMORY_HUGE);
    2071  
    2072  
    2073          $expirynotifylast = $this->get_config('expirynotifylast', 0);
    2074          $expirynotifyhour = $this->get_config('expirynotifyhour');
    2075          if (is_null($expirynotifyhour)) {
    2076              debugging("send_expiry_notifications() in $name enrolment plugin needs expirynotifyhour setting");
    2077              $trace->finished();
    2078              return;
    2079          }
    2080  
    2081          if (!($trace instanceof progress_trace)) {
    2082              $trace = $trace ? new text_progress_trace() : new null_progress_trace();
    2083              debugging('enrol_plugin::send_expiry_notifications() now expects progress_trace instance as parameter!', DEBUG_DEVELOPER);
    2084          }
    2085  
    2086          $timenow = time();
    2087          $notifytime = usergetmidnight($timenow, $CFG->timezone) + ($expirynotifyhour * 3600);
    2088  
    2089          if ($expirynotifylast > $notifytime) {
    2090              $trace->output($name.' enrolment expiry notifications were already sent today at '.userdate($expirynotifylast, '', $CFG->timezone).'.');
    2091              $trace->finished();
    2092              return;
    2093  
    2094          } else if ($timenow < $notifytime) {
    2095              $trace->output($name.' enrolment expiry notifications will be sent at '.userdate($notifytime, '', $CFG->timezone).'.');
    2096              $trace->finished();
    2097              return;
    2098          }
    2099  
    2100          $trace->output('Processing '.$name.' enrolment expiration notifications...');
    2101  
    2102          // Notify users responsible for enrolment once every day.
    2103          $sql = "SELECT ue.*, e.expirynotify, e.notifyall, e.expirythreshold, e.courseid, c.fullname
    2104                    FROM {user_enrolments} ue
    2105                    JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = :name AND e.expirynotify > 0 AND e.status = :enabled)
    2106                    JOIN {course} c ON (c.id = e.courseid)
    2107                    JOIN {user} u ON (u.id = ue.userid AND u.deleted = 0 AND u.suspended = 0)
    2108                   WHERE ue.status = :active AND ue.timeend > 0 AND ue.timeend > :now1 AND ue.timeend < (e.expirythreshold + :now2)
    2109                ORDER BY ue.enrolid ASC, u.lastname ASC, u.firstname ASC, u.id ASC";
    2110          $params = array('enabled'=>ENROL_INSTANCE_ENABLED, 'active'=>ENROL_USER_ACTIVE, 'now1'=>$timenow, 'now2'=>$timenow, 'name'=>$name);
    2111  
    2112          $rs = $DB->get_recordset_sql($sql, $params);
    2113  
    2114          $lastenrollid = 0;
    2115          $users = array();
    2116  
    2117          foreach($rs as $ue) {
    2118              if ($lastenrollid and $lastenrollid != $ue->enrolid) {
    2119                  $this->notify_expiry_enroller($lastenrollid, $users, $trace);
    2120                  $users = array();
    2121              }
    2122              $lastenrollid = $ue->enrolid;
    2123  
    2124              $enroller = $this->get_enroller($ue->enrolid);
    2125              $context = context_course::instance($ue->courseid);
    2126  
    2127              $user = $DB->get_record('user', array('id'=>$ue->userid));
    2128  
    2129              $users[] = array('fullname'=>fullname($user, has_capability('moodle/site:viewfullnames', $context, $enroller)), 'timeend'=>$ue->timeend);
    2130  
    2131              if (!$ue->notifyall) {
    2132                  continue;
    2133              }
    2134  
    2135              if ($ue->timeend - $ue->expirythreshold + 86400 < $timenow) {
    2136                  // Notify enrolled users only once at the start of the threshold.
    2137                  $trace->output("user $ue->userid was already notified that enrolment in course $ue->courseid expires on ".userdate($ue->timeend, '', $CFG->timezone), 1);
    2138                  continue;
    2139              }
    2140  
    2141              $this->notify_expiry_enrolled($user, $ue, $trace);
    2142          }
    2143          $rs->close();
    2144  
    2145          if ($lastenrollid and $users) {
    2146              $this->notify_expiry_enroller($lastenrollid, $users, $trace);
    2147          }
    2148  
    2149          $trace->output('...notification processing finished.');
    2150          $trace->finished();
    2151  
    2152          $this->set_config('expirynotifylast', $timenow);
    2153      }
    2154  
    2155      /**
    2156       * Returns the user who is responsible for enrolments for given instance.
    2157       *
    2158       * Override if plugin knows anybody better than admin.
    2159       *
    2160       * @param int $instanceid enrolment instance id
    2161       * @return stdClass user record
    2162       */
    2163      protected function get_enroller($instanceid) {
    2164          return get_admin();
    2165      }
    2166  
    2167      /**
    2168       * Notify user about incoming expiration of their enrolment,
    2169       * it is called only if notification of enrolled users (aka students) is enabled in course.
    2170       *
    2171       * This is executed only once for each expiring enrolment right
    2172       * at the start of the expiration threshold.
    2173       *
    2174       * @param stdClass $user
    2175       * @param stdClass $ue
    2176       * @param progress_trace $trace
    2177       */
    2178      protected function notify_expiry_enrolled($user, $ue, progress_trace $trace) {
    2179          global $CFG;
    2180  
    2181          $name = $this->get_name();
    2182  
    2183          $oldforcelang = force_current_language($user->lang);
    2184  
    2185          $enroller = $this->get_enroller($ue->enrolid);
    2186          $context = context_course::instance($ue->courseid);
    2187  
    2188          $a = new stdClass();
    2189          $a->course   = format_string($ue->fullname, true, array('context'=>$context));
    2190          $a->user     = fullname($user, true);
    2191          $a->timeend  = userdate($ue->timeend, '', $user->timezone);
    2192          $a->enroller = fullname($enroller, has_capability('moodle/site:viewfullnames', $context, $user));
    2193  
    2194          $subject = get_string('expirymessageenrolledsubject', 'enrol_'.$name, $a);
    2195          $body = get_string('expirymessageenrolledbody', 'enrol_'.$name, $a);
    2196  
    2197          $message = new stdClass();
    2198          $message->notification      = 1;
    2199          $message->component         = 'enrol_'.$name;
    2200          $message->name              = 'expiry_notification';
    2201          $message->userfrom          = $enroller;
    2202          $message->userto            = $user;
    2203          $message->subject           = $subject;
    2204          $message->fullmessage       = $body;
    2205          $message->fullmessageformat = FORMAT_MARKDOWN;
    2206          $message->fullmessagehtml   = markdown_to_html($body);
    2207          $message->smallmessage      = $subject;
    2208          $message->contexturlname    = $a->course;
    2209          $message->contexturl        = (string)new moodle_url('/course/view.php', array('id'=>$ue->courseid));
    2210  
    2211          if (message_send($message)) {
    2212              $trace->output("notifying user $ue->userid that enrolment in course $ue->courseid expires on ".userdate($ue->timeend, '', $CFG->timezone), 1);
    2213          } else {
    2214              $trace->output("error notifying user $ue->userid that enrolment in course $ue->courseid expires on ".userdate($ue->timeend, '', $CFG->timezone), 1);
    2215          }
    2216  
    2217          force_current_language($oldforcelang);
    2218      }
    2219  
    2220      /**
    2221       * Notify person responsible for enrolments that some user enrolments will be expired soon,
    2222       * it is called only if notification of enrollers (aka teachers) is enabled in course.
    2223       *
    2224       * This is called repeatedly every day for each course if there are any pending expiration
    2225       * in the expiration threshold.
    2226       *
    2227       * @param int $eid
    2228       * @param array $users
    2229       * @param progress_trace $trace
    2230       */
    2231      protected function notify_expiry_enroller($eid, $users, progress_trace $trace) {
    2232          global $DB;
    2233  
    2234          $name = $this->get_name();
    2235  
    2236          $instance = $DB->get_record('enrol', array('id'=>$eid, 'enrol'=>$name));
    2237          $context = context_course::instance($instance->courseid);
    2238          $course = $DB->get_record('course', array('id'=>$instance->courseid));
    2239  
    2240          $enroller = $this->get_enroller($instance->id);
    2241          $admin = get_admin();
    2242  
    2243          $oldforcelang = force_current_language($enroller->lang);
    2244  
    2245          foreach($users as $key=>$info) {
    2246              $users[$key] = '* '.$info['fullname'].' - '.userdate($info['timeend'], '', $enroller->timezone);
    2247          }
    2248  
    2249          $a = new stdClass();
    2250          $a->course    = format_string($course->fullname, true, array('context'=>$context));
    2251          $a->threshold = get_string('numdays', '', $instance->expirythreshold / (60*60*24));
    2252          $a->users     = implode("\n", $users);
    2253          $a->extendurl = (string)new moodle_url('/enrol/users.php', array('id'=>$instance->courseid));
    2254  
    2255          $subject = get_string('expirymessageenrollersubject', 'enrol_'.$name, $a);
    2256          $body = get_string('expirymessageenrollerbody', 'enrol_'.$name, $a);
    2257  
    2258          $message = new stdClass();
    2259          $message->notification      = 1;
    2260          $message->component         = 'enrol_'.$name;
    2261          $message->name              = 'expiry_notification';
    2262          $message->userfrom          = $admin;
    2263          $message->userto            = $enroller;
    2264          $message->subject           = $subject;
    2265          $message->fullmessage       = $body;
    2266          $message->fullmessageformat = FORMAT_MARKDOWN;
    2267          $message->fullmessagehtml   = markdown_to_html($body);
    2268          $message->smallmessage      = $subject;
    2269          $message->contexturlname    = $a->course;
    2270          $message->contexturl        = $a->extendurl;
    2271  
    2272          if (message_send($message)) {
    2273              $trace->output("notifying user $enroller->id about all expiring $name enrolments in course $instance->courseid", 1);
    2274          } else {
    2275              $trace->output("error notifying user $enroller->id about all expiring $name enrolments in course $instance->courseid", 1);
    2276          }
    2277  
    2278          force_current_language($oldforcelang);
    2279      }
    2280  
    2281      /**
    2282       * Backup execution step hook to annotate custom fields.
    2283       *
    2284       * @param backup_enrolments_execution_step $step
    2285       * @param stdClass $enrol
    2286       */
    2287      public function backup_annotate_custom_fields(backup_enrolments_execution_step $step, stdClass $enrol) {
    2288          // Override as necessary to annotate custom fields in the enrol table.
    2289      }
    2290  
    2291      /**
    2292       * Automatic enrol sync executed during restore.
    2293       * Useful for automatic sync by course->idnumber or course category.
    2294       * @param stdClass $course course record
    2295       */
    2296      public function restore_sync_course($course) {
    2297          // Override if necessary.
    2298      }
    2299  
    2300      /**
    2301       * Restore instance and map settings.
    2302       *
    2303       * @param restore_enrolments_structure_step $step
    2304       * @param stdClass $data
    2305       * @param stdClass $course
    2306       * @param int $oldid
    2307       */
    2308      public function restore_instance(restore_enrolments_structure_step $step, stdClass $data, $course, $oldid) {
    2309          // Do not call this from overridden methods, restore and set new id there.
    2310          $step->set_mapping('enrol', $oldid, 0);
    2311      }
    2312  
    2313      /**
    2314       * Restore user enrolment.
    2315       *
    2316       * @param restore_enrolments_structure_step $step
    2317       * @param stdClass $data
    2318       * @param stdClass $instance
    2319       * @param int $oldinstancestatus
    2320       * @param int $userid
    2321       */
    2322      public function restore_user_enrolment(restore_enrolments_structure_step $step, $data, $instance, $userid, $oldinstancestatus) {
    2323          // Override as necessary if plugin supports restore of enrolments.
    2324      }
    2325  
    2326      /**
    2327       * Restore role assignment.
    2328       *
    2329       * @param stdClass $instance
    2330       * @param int $roleid
    2331       * @param int $userid
    2332       * @param int $contextid
    2333       */
    2334      public function restore_role_assignment($instance, $roleid, $userid, $contextid) {
    2335          // No role assignment by default, override if necessary.
    2336      }
    2337  
    2338      /**
    2339       * Restore user group membership.
    2340       * @param stdClass $instance
    2341       * @param int $groupid
    2342       * @param int $userid
    2343       */
    2344      public function restore_group_member($instance, $groupid, $userid) {
    2345          // Implement if you want to restore protected group memberships,
    2346          // usually this is not necessary because plugins should be able to recreate the memberships automatically.
    2347      }
    2348  }
    

    Search This Site: