Search moodle.org's
Developer Documentation

See Release Notes
Long Term Support Release

  • Bug fixes for general core bugs in 4.1.x will end 13 November 2023 (12 months).
  • Bug fixes for security issues in 4.1.x will end 10 November 2025 (36 months).
  • PHP version: minimum PHP 7.4.0 Note: minimum PHP version has increased since Moodle 4.0. PHP 8.0.x is supported too.
/lib/ -> accesslib.php (source)
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * This file contains functions for managing user access
 *
 * <b>Public API vs internals</b>
 *
 * General users probably only care about
 *
 * Context handling
 * - context_course::instance($courseid), context_module::instance($cm->id), context_coursecat::instance($catid)
 * - context::instance_by_id($contextid)
 * - $context->get_parent_contexts();
 * - $context->get_child_contexts();
 *
 * Whether the user can do something...
 * - has_capability()
 * - has_any_capability()
 * - has_all_capabilities()
 * - require_capability()
 * - require_login() (from moodlelib)
 * - is_enrolled()
 * - is_viewing()
 * - is_guest()
 * - is_siteadmin()
 * - isguestuser()
 * - isloggedin()
 *
 * What courses has this user access to?
 * - get_enrolled_users()
 *
 * What users can do X in this context?
 * - get_enrolled_users() - at and bellow course context
 * - get_users_by_capability() - above course context
 *
 * Modify roles
 * - role_assign()
 * - role_unassign()
 * - role_unassign_all()
 *
 * Advanced - for internal use only
 * - load_all_capabilities()
 * - reload_all_capabilities()
 * - has_capability_in_accessdata()
 * - get_user_roles_sitewide_accessdata()
 * - etc.
 *
 * <b>Name conventions</b>
 *
 * "ctx" means context
 * "ra" means role assignment
 * "rdef" means role definition
 *
 * <b>accessdata</b>
 *
 * Access control data is held in the "accessdata" array
 * which - for the logged-in user, will be in $USER->access
 *
 * For other users can be generated and passed around (but may also be cached
 * against userid in $ACCESSLIB_PRIVATE->accessdatabyuser).
 *
 * $accessdata is a multidimensional array, holding
 * role assignments (RAs), role switches and initialization time.
 *
 * Things are keyed on "contextpaths" (the path field of
 * the context table) for fast walking up/down the tree.
 * <code>
 * $accessdata['ra'][$contextpath] = array($roleid=>$roleid)
 *                  [$contextpath] = array($roleid=>$roleid)
 *                  [$contextpath] = array($roleid=>$roleid)
 * </code>
 *
 * <b>Stale accessdata</b>
 *
 * For the logged-in user, accessdata is long-lived.
 *
 * On each pageload we load $ACCESSLIB_PRIVATE->dirtycontexts which lists
 * context paths affected by changes. Any check at-or-below
 * a dirty context will trigger a transparent reload of accessdata.
 *
 * Changes at the system level will force the reload for everyone.
 *
 * <b>Default role caps</b>
 * The default role assignment is not in the DB, so we
 * add it manually to accessdata.
 *
 * This means that functions that work directly off the
 * DB need to ensure that the default role caps
 * are dealt with appropriately.
 *
 * @package    core_access
 * @copyright  1999 onwards Martin Dougiamas  http://dougiamas.com
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

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

/** No capability change */
define('CAP_INHERIT', 0);
/** Allow permission, overrides CAP_PREVENT defined in parent contexts */
define('CAP_ALLOW', 1);
/** Prevent permission, overrides CAP_ALLOW defined in parent contexts */
define('CAP_PREVENT', -1);
/** Prohibit permission, overrides everything in current and child contexts */
define('CAP_PROHIBIT', -1000);

/** System context level - only one instance in every system */
define('CONTEXT_SYSTEM', 10);
/** User context level -  one instance for each user describing what others can do to user */
define('CONTEXT_USER', 30);
/** Course category context level - one instance for each category */
define('CONTEXT_COURSECAT', 40);
/** Course context level - one instances for each course */
define('CONTEXT_COURSE', 50);
/** Course module context level - one instance for each course module */
define('CONTEXT_MODULE', 70);
/**
 * Block context level - one instance for each block, sticky blocks are tricky
 * because ppl think they should be able to override them at lower contexts.
 * Any other context level instance can be parent of block context.
 */
define('CONTEXT_BLOCK', 80);

< /** Capability allow management of trusts - NOT IMPLEMENTED YET - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
> /** Capability allow management of trusts - NOT IMPLEMENTED YET - see {@link https://moodledev.io/docs/apis/subsystems/roles} */
define('RISK_MANAGETRUST', 0x0001);
< /** Capability allows changes in system configuration - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
> /** Capability allows changes in system configuration - see {@link https://moodledev.io/docs/apis/subsystems/roles} */
define('RISK_CONFIG', 0x0002);
< /** Capability allows user to add scripted content - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
> /** Capability allows user to add scripted content - see {@link https://moodledev.io/docs/apis/subsystems/roles} */
define('RISK_XSS', 0x0004);
< /** Capability allows access to personal user information - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
> /** Capability allows access to personal user information - see {@link https://moodledev.io/docs/apis/subsystems/roles} */
define('RISK_PERSONAL', 0x0008);
< /** Capability allows users to add content others may see - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
> /** Capability allows users to add content others may see - see {@link https://moodledev.io/docs/apis/subsystems/roles} */
define('RISK_SPAM', 0x0010);
< /** capability allows mass delete of data belonging to other users - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
> /** capability allows mass delete of data belonging to other users - see {@link https://moodledev.io/docs/apis/subsystems/roles} */
define('RISK_DATALOSS', 0x0020); /** rolename displays - the name as defined in the role definition, localised if name empty */ define('ROLENAME_ORIGINAL', 0); /** rolename displays - the name as defined by a role alias at the course level, falls back to ROLENAME_ORIGINAL if alias not present */ define('ROLENAME_ALIAS', 1); /** rolename displays - Both, like this: Role alias (Original) */ define('ROLENAME_BOTH', 2); /** rolename displays - the name as defined in the role definition and the shortname in brackets */ define('ROLENAME_ORIGINALANDSHORT', 3); /** rolename displays - the name as defined by a role alias, in raw form suitable for editing */ define('ROLENAME_ALIAS_RAW', 4); /** rolename displays - the name is simply short role name */ define('ROLENAME_SHORT', 5); if (!defined('CONTEXT_CACHE_MAX_SIZE')) { /** maximum size of context cache - it is possible to tweak this config.php or in any script before inclusion of context.php */ define('CONTEXT_CACHE_MAX_SIZE', 2500); } /** * Although this looks like a global variable, it isn't really. * * It is just a private implementation detail to accesslib that MUST NOT be used elsewhere. * It is used to cache various bits of data between function calls for performance reasons. * Sadly, a PHP global variable is the only way to implement this, without rewriting everything * as methods of a class, instead of functions. * * @access private * @global stdClass $ACCESSLIB_PRIVATE * @name $ACCESSLIB_PRIVATE */ global $ACCESSLIB_PRIVATE; $ACCESSLIB_PRIVATE = new stdClass(); $ACCESSLIB_PRIVATE->cacheroledefs = array(); // Holds site-wide role definitions. $ACCESSLIB_PRIVATE->dirtycontexts = null; // Dirty contexts cache, loaded from DB once per page $ACCESSLIB_PRIVATE->dirtyusers = null; // Dirty users cache, loaded from DB once per $USER->id $ACCESSLIB_PRIVATE->accessdatabyuser = array(); // Holds the cache of $accessdata structure for users (including $USER) /** * Clears accesslib's private caches. ONLY BE USED BY UNIT TESTS * * This method should ONLY BE USED BY UNIT TESTS. It clears all of * accesslib's private caches. You need to do this before setting up test data, * and also at the end of the tests. * * @access private * @return void */ function accesslib_clear_all_caches_for_unit_testing() { global $USER; if (!PHPUNIT_TEST) { throw new coding_exception('You must not call clear_all_caches outside of unit tests.'); } accesslib_clear_all_caches(true); accesslib_reset_role_cache(); unset($USER->access); } /** * Clears accesslib's private caches. ONLY BE USED FROM THIS LIBRARY FILE! * * This reset does not touch global $USER. * * @access private * @param bool $resetcontexts * @return void */ function accesslib_clear_all_caches($resetcontexts) { global $ACCESSLIB_PRIVATE; $ACCESSLIB_PRIVATE->dirtycontexts = null; $ACCESSLIB_PRIVATE->dirtyusers = null; $ACCESSLIB_PRIVATE->accessdatabyuser = array(); if ($resetcontexts) { context_helper::reset_caches(); } } /** * Full reset of accesslib's private role cache. ONLY TO BE USED FROM THIS LIBRARY FILE! * * This reset does not touch global $USER. * * Note: Only use this when the roles that need a refresh are unknown. * * @see accesslib_clear_role_cache() * * @access private * @return void */ function accesslib_reset_role_cache() { global $ACCESSLIB_PRIVATE; $ACCESSLIB_PRIVATE->cacheroledefs = array(); $cache = cache::make('core', 'roledefs'); $cache->purge(); } /** * Clears accesslib's private cache of a specific role or roles. ONLY BE USED FROM THIS LIBRARY FILE! * * This reset does not touch global $USER. * * @access private * @param int|array $roles * @return void */ function accesslib_clear_role_cache($roles) { global $ACCESSLIB_PRIVATE; if (!is_array($roles)) { $roles = [$roles]; } foreach ($roles as $role) { if (isset($ACCESSLIB_PRIVATE->cacheroledefs[$role])) { unset($ACCESSLIB_PRIVATE->cacheroledefs[$role]); } } $cache = cache::make('core', 'roledefs'); $cache->delete_many($roles); } /** * Role is assigned at system context. * * @access private * @param int $roleid * @return array */ function get_role_access($roleid) { $accessdata = get_empty_accessdata(); $accessdata['ra']['/'.SYSCONTEXTID] = array((int)$roleid => (int)$roleid); return $accessdata; } /** * Fetch raw "site wide" role definitions. * Even MUC static acceleration cache appears a bit slow for this. * Important as can be hit hundreds of times per page. * * @param array $roleids List of role ids to fetch definitions for. * @return array Complete definition for each requested role. */ function get_role_definitions(array $roleids) { global $ACCESSLIB_PRIVATE; if (empty($roleids)) { return array(); } // Grab all keys we have not yet got in our static cache. if ($uncached = array_diff($roleids, array_keys($ACCESSLIB_PRIVATE->cacheroledefs))) { $cache = cache::make('core', 'roledefs'); foreach ($cache->get_many($uncached) as $roleid => $cachedroledef) { if (is_array($cachedroledef)) { $ACCESSLIB_PRIVATE->cacheroledefs[$roleid] = $cachedroledef; } } // Check we have the remaining keys from the MUC. if ($uncached = array_diff($roleids, array_keys($ACCESSLIB_PRIVATE->cacheroledefs))) { $uncached = get_role_definitions_uncached($uncached); $ACCESSLIB_PRIVATE->cacheroledefs += $uncached; $cache->set_many($uncached); } } // Return just the roles we need. return array_intersect_key($ACCESSLIB_PRIVATE->cacheroledefs, array_flip($roleids)); } /** * Query raw "site wide" role definitions. * * @param array $roleids List of role ids to fetch definitions for. * @return array Complete definition for each requested role. */ function get_role_definitions_uncached(array $roleids) { global $DB; if (empty($roleids)) { return array(); } // Create a blank results array: even if a role has no capabilities, // we need to ensure it is included in the results to show we have // loaded all the capabilities that there are. $rdefs = array(); foreach ($roleids as $roleid) { $rdefs[$roleid] = array(); } // Load all the capabilities for these roles in all contexts. list($sql, $params) = $DB->get_in_or_equal($roleids); $sql = "SELECT ctx.path, rc.roleid, rc.capability, rc.permission FROM {role_capabilities} rc JOIN {context} ctx ON rc.contextid = ctx.id JOIN {capabilities} cap ON rc.capability = cap.name WHERE rc.roleid $sql"; $rs = $DB->get_recordset_sql($sql, $params); // Store the capabilities into the expected data structure. foreach ($rs as $rd) { if (!isset($rdefs[$rd->roleid][$rd->path])) { $rdefs[$rd->roleid][$rd->path] = array(); } $rdefs[$rd->roleid][$rd->path][$rd->capability] = (int) $rd->permission; } $rs->close(); // Sometimes (e.g. get_user_capability_course_helper::get_capability_info_at_each_context) // we process role definitinons in a way that requires we see parent contexts // before child contexts. This sort ensures that works (and is faster than // sorting in the SQL query). foreach ($rdefs as $roleid => $rdef) { ksort($rdefs[$roleid]); } return $rdefs; } /** * Get the default guest role, this is used for guest account, * search engine spiders, etc. * * @return stdClass role record */ function get_guest_role() { global $CFG, $DB; if (empty($CFG->guestroleid)) { if ($roles = $DB->get_records('role', array('archetype'=>'guest'))) { $guestrole = array_shift($roles); // Pick the first one set_config('guestroleid', $guestrole->id); return $guestrole; } else { debugging('Can not find any guest role!'); return false; } } else { if ($guestrole = $DB->get_record('role', array('id'=>$CFG->guestroleid))) { return $guestrole; } else { // somebody is messing with guest roles, remove incorrect setting and try to find a new one set_config('guestroleid', ''); return get_guest_role(); } } } /** * Check whether a user has a particular capability in a given context. * * For example: * $context = context_module::instance($cm->id); * has_capability('mod/forum:replypost', $context) * * By default checks the capabilities of the current user, but you can pass a * different userid. By default will return true for admin users, but you can override that with the fourth argument. * * Guest and not-logged-in users can never get any dangerous capability - that is any write capability * or capabilities with XSS, config or data loss risks. * * @category access * * @param string $capability the name of the capability to check. For example mod/forum:view * @param context $context the context to check the capability in. You normally get this with instance method of a context class. * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user. * @param boolean $doanything If false, ignores effect of admin role assignment * @return boolean true if the user has this capability. Otherwise false. */ function has_capability($capability, context $context, $user = null, $doanything = true) { global $USER, $CFG, $SCRIPT, $ACCESSLIB_PRIVATE; if (during_initial_install()) { if ($SCRIPT === "/$CFG->admin/index.php" or $SCRIPT === "/$CFG->admin/cli/install.php" or $SCRIPT === "/$CFG->admin/cli/install_database.php" or (defined('BEHAT_UTIL') and BEHAT_UTIL) or (defined('PHPUNIT_UTIL') and PHPUNIT_UTIL)) { // we are in an installer - roles can not work yet return true; } else { return false; } } if (strpos($capability, 'moodle/legacy:') === 0) { throw new coding_exception('Legacy capabilities can not be used any more!'); } if (!is_bool($doanything)) { throw new coding_exception('Capability parameter "doanything" is wierd, only true or false is allowed. This has to be fixed in code.'); } // capability must exist if (!$capinfo = get_capability_info($capability)) { debugging('Capability "'.$capability.'" was not found! This has to be fixed in code.'); return false; } if (!isset($USER->id)) { // should never happen $USER->id = 0; debugging('Capability check being performed on a user with no ID.', DEBUG_DEVELOPER); } // make sure there is a real user specified if ($user === null) { $userid = $USER->id; } else { $userid = is_object($user) ? $user->id : $user; } // make sure forcelogin cuts off not-logged-in users if enabled if (!empty($CFG->forcelogin) and $userid == 0) { return false; } // make sure the guest account and not-logged-in users never get any risky caps no matter what the actual settings are. if (($capinfo->captype === 'write') or ($capinfo->riskbitmask & (RISK_XSS | RISK_CONFIG | RISK_DATALOSS))) { if (isguestuser($userid) or $userid == 0) { return false; } } // Check whether context locking is enabled. if (!empty($CFG->contextlocking)) { if ($capinfo->captype === 'write' && $context->locked) { // Context locking applies to any write capability in a locked context. // It does not apply to moodle/site:managecontextlocks - this is to allow context locking to be unlocked. if ($capinfo->name !== 'moodle/site:managecontextlocks') { // It applies to all users who are not site admins. // It also applies to site admins when contextlockappliestoadmin is set. if (!is_siteadmin($userid) || !empty($CFG->contextlockappliestoadmin)) { return false; } } } } // somehow make sure the user is not deleted and actually exists if ($userid != 0) { if ($userid == $USER->id and isset($USER->deleted)) { // this prevents one query per page, it is a bit of cheating, // but hopefully session is terminated properly once user is deleted if ($USER->deleted) { return false; } } else { if (!context_user::instance($userid, IGNORE_MISSING)) { // no user context == invalid userid return false; } } } // context path/depth must be valid if (empty($context->path) or $context->depth == 0) { // this should not happen often, each upgrade tries to rebuild the context paths debugging('Context id '.$context->id.' does not have valid path, please use context_helper::build_all_paths()'); if (is_siteadmin($userid)) { return true; } else { return false; } } if (!empty($USER->loginascontext)) { // The current user is logged in as another user and can assume their identity at or below the `loginascontext` // defined in the USER session. // The user may not assume their identity at any other location. if (!$USER->loginascontext->is_parent_of($context, true)) { // The context being checked is not the specified context, or one of its children. return false; } } // Find out if user is admin - it is not possible to override the doanything in any way // and it is not possible to switch to admin role either. if ($doanything) { if (is_siteadmin($userid)) { if ($userid != $USER->id) { return true; } // make sure switchrole is not used in this context if (empty($USER->access['rsw'])) { return true; } $parts = explode('/', trim($context->path, '/')); $path = ''; $switched = false; foreach ($parts as $part) { $path .= '/' . $part; if (!empty($USER->access['rsw'][$path])) { $switched = true; break; } } if (!$switched) { return true; } //ok, admin switched role in this context, let's use normal access control rules } } // Careful check for staleness... $context->reload_if_dirty(); if ($USER->id == $userid) { if (!isset($USER->access)) { load_all_capabilities(); } $access =& $USER->access; } else { // make sure user accessdata is really loaded get_user_accessdata($userid, true); $access =& $ACCESSLIB_PRIVATE->accessdatabyuser[$userid]; } return has_capability_in_accessdata($capability, $context, $access); } /** * Check if the user has any one of several capabilities from a list. * * This is just a utility method that calls has_capability in a loop. Try to put * the capabilities that most users are likely to have first in the list for best * performance. * * @category access * @see has_capability() * * @param array $capabilities an array of capability names. * @param context $context the context to check the capability in. You normally get this with instance method of a context class. * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user. * @param boolean $doanything If false, ignore effect of admin role assignment * @return boolean true if the user has any of these capabilities. Otherwise false. */ function has_any_capability(array $capabilities, context $context, $user = null, $doanything = true) { foreach ($capabilities as $capability) { if (has_capability($capability, $context, $user, $doanything)) { return true; } } return false; } /** * Check if the user has all the capabilities in a list. * * This is just a utility method that calls has_capability in a loop. Try to put * the capabilities that fewest users are likely to have first in the list for best * performance. * * @category access * @see has_capability() * * @param array $capabilities an array of capability names. * @param context $context the context to check the capability in. You normally get this with instance method of a context class. * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user. * @param boolean $doanything If false, ignore effect of admin role assignment * @return boolean true if the user has all of these capabilities. Otherwise false. */ function has_all_capabilities(array $capabilities, context $context, $user = null, $doanything = true) { foreach ($capabilities as $capability) { if (!has_capability($capability, $context, $user, $doanything)) { return false; } } return true; } /** * Is course creator going to have capability in a new course? * * This is intended to be used in enrolment plugins before or during course creation, * do not use after the course is fully created. * * @category access * * @param string $capability the name of the capability to check. * @param context $context course or category context where is course going to be created * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user. * @return boolean true if the user will have this capability. * * @throws coding_exception if different type of context submitted */ function guess_if_creator_will_have_course_capability($capability, context $context, $user = null) { global $CFG; if ($context->contextlevel != CONTEXT_COURSE and $context->contextlevel != CONTEXT_COURSECAT) { throw new coding_exception('Only course or course category context expected'); } if (has_capability($capability, $context, $user)) { // User already has the capability, it could be only removed if CAP_PROHIBIT // was involved here, but we ignore that. return true; } if (!has_capability('moodle/course:create', $context, $user)) { return false; } if (!enrol_is_enabled('manual')) { return false; } if (empty($CFG->creatornewroleid)) { return false; } if ($context->contextlevel == CONTEXT_COURSE) { if (is_viewing($context, $user, 'moodle/role:assign') or is_enrolled($context, $user, 'moodle/role:assign')) { return false; } } else { if (has_capability('moodle/course:view', $context, $user) and has_capability('moodle/role:assign', $context, $user)) { return false; } } // Most likely they will be enrolled after the course creation is finished, // does the new role have the required capability? list($neededroles, $forbiddenroles) = get_roles_with_cap_in_context($context, $capability); return isset($neededroles[$CFG->creatornewroleid]); } /** * Check if the user is an admin at the site level. * * Please note that use of proper capabilities is always encouraged, * this function is supposed to be used from core or for temporary hacks. * * @category access * * @param int|stdClass $user_or_id user id or user object * @return bool true if user is one of the administrators, false otherwise */ function is_siteadmin($user_or_id = null) { global $CFG, $USER; if ($user_or_id === null) { $user_or_id = $USER; } if (empty($user_or_id)) { return false; } if (!empty($user_or_id->id)) { $userid = $user_or_id->id; } else { $userid = $user_or_id; } // Because this script is called many times (150+ for course page) with // the same parameters, it is worth doing minor optimisations. This static // cache stores the value for a single userid, saving about 2ms from course // page load time without using significant memory. As the static cache // also includes the value it depends on, this cannot break unit tests. static $knownid, $knownresult, $knownsiteadmins; if ($knownid === $userid && $knownsiteadmins === $CFG->siteadmins) { return $knownresult; } $knownid = $userid; $knownsiteadmins = $CFG->siteadmins; $siteadmins = explode(',', $CFG->siteadmins); $knownresult = in_array($userid, $siteadmins); return $knownresult; } /** * Returns true if user has at least one role assign * of 'coursecontact' role (is potentially listed in some course descriptions). * * @param int $userid * @return bool */ function has_coursecontact_role($userid) { global $DB, $CFG; if (empty($CFG->coursecontact)) { return false; } $sql = "SELECT 1 FROM {role_assignments} WHERE userid = :userid AND roleid IN ($CFG->coursecontact)"; return $DB->record_exists_sql($sql, array('userid'=>$userid)); } /** * Does the user have a capability to do something? * * Walk the accessdata array and return true/false. * Deals with prohibits, role switching, aggregating * capabilities, etc. * * The main feature of here is being FAST and with no * side effects. * * Notes: * * Switch Role merges with default role * ------------------------------------ * If you are a teacher in course X, you have at least * teacher-in-X + defaultloggedinuser-sitewide. So in the * course you'll have techer+defaultloggedinuser. * We try to mimic that in switchrole. * * Permission evaluation * --------------------- * Originally there was an extremely complicated way * to determine the user access that dealt with * "locality" or role assignments and role overrides. * Now we simply evaluate access for each role separately * and then verify if user has at least one role with allow * and at the same time no role with prohibit. * * @access private * @param string $capability * @param context $context * @param array $accessdata * @return bool */ function has_capability_in_accessdata($capability, context $context, array &$accessdata) { global $CFG; // Build $paths as a list of current + all parent "paths" with order bottom-to-top $path = $context->path; $paths = array($path); while ($path = rtrim($path, '0123456789')) { $path = rtrim($path, '/'); if ($path === '') { break; } $paths[] = $path; } $roles = array(); $switchedrole = false; // Find out if role switched if (!empty($accessdata['rsw'])) { // From the bottom up... foreach ($paths as $path) { if (isset($accessdata['rsw'][$path])) { // Found a switchrole assignment - check for that role _plus_ the default user role $roles = array($accessdata['rsw'][$path]=>null, $CFG->defaultuserroleid=>null); $switchedrole = true; break; } } } if (!$switchedrole) { // get all users roles in this context and above foreach ($paths as $path) { if (isset($accessdata['ra'][$path])) { foreach ($accessdata['ra'][$path] as $roleid) { $roles[$roleid] = null; } } } } // Now find out what access is given to each role, going bottom-->up direction $rdefs = get_role_definitions(array_keys($roles)); $allowed = false; foreach ($roles as $roleid => $ignored) { foreach ($paths as $path) { if (isset($rdefs[$roleid][$path][$capability])) { $perm = (int)$rdefs[$roleid][$path][$capability]; if ($perm === CAP_PROHIBIT) { // any CAP_PROHIBIT found means no permission for the user return false; } if (is_null($roles[$roleid])) { $roles[$roleid] = $perm; } } } // CAP_ALLOW in any role means the user has a permission, we continue only to detect prohibits $allowed = ($allowed or $roles[$roleid] === CAP_ALLOW); } return $allowed; } /** * A convenience function that tests has_capability, and displays an error if * the user does not have that capability. * * NOTE before Moodle 2.0, this function attempted to make an appropriate * require_login call before checking the capability. This is no longer the case. * You must call require_login (or one of its variants) if you want to check the * user is logged in, before you call this function. * * @see has_capability() * * @param string $capability the name of the capability to check. For example mod/forum:view * @param context $context the context to check the capability in. You normally get this with context_xxxx::instance(). * @param int $userid A user id. By default (null) checks the permissions of the current user. * @param bool $doanything If false, ignore effect of admin role assignment * @param string $errormessage The error string to to user. Defaults to 'nopermissions'. * @param string $stringfile The language file to load the error string from. Defaults to 'error'. * @return void terminates with an error if the user does not have the given capability. */ function require_capability($capability, context $context, $userid = null, $doanything = true, $errormessage = 'nopermissions', $stringfile = '') { if (!has_capability($capability, $context, $userid, $doanything)) { throw new required_capability_exception($context, $capability, $errormessage, $stringfile); } } /** * A convenience function that tests has_capability for a list of capabilities, and displays an error if * the user does not have that capability. * * This is just a utility method that calls has_capability in a loop. Try to put * the capabilities that fewest users are likely to have first in the list for best * performance. * * @category access * @see has_capability() * * @param array $capabilities an array of capability names. * @param context $context the context to check the capability in. You normally get this with context_xxxx::instance(). * @param int $userid A user id. By default (null) checks the permissions of the current user. * @param bool $doanything If false, ignore effect of admin role assignment * @param string $errormessage The error string to to user. Defaults to 'nopermissions'. * @param string $stringfile The language file to load the error string from. Defaults to 'error'. * @return void terminates with an error if the user does not have the given capability. */ function require_all_capabilities(array $capabilities, context $context, $userid = null, $doanything = true, $errormessage = 'nopermissions', $stringfile = ''): void { foreach ($capabilities as $capability) { if (!has_capability($capability, $context, $userid, $doanything)) { throw new required_capability_exception($context, $capability, $errormessage, $stringfile); } } } /** * Return a nested array showing all role assignments for the user. * [ra] => [contextpath][roleid] = roleid * * @access private * @param int $userid - the id of the user * @return array access info array */ function get_user_roles_sitewide_accessdata($userid) { global $CFG, $DB; $accessdata = get_empty_accessdata(); // start with the default role if (!empty($CFG->defaultuserroleid)) { $syscontext = context_system::instance(); $accessdata['ra'][$syscontext->path][(int)$CFG->defaultuserroleid] = (int)$CFG->defaultuserroleid; } // load the "default frontpage role" if (!empty($CFG->defaultfrontpageroleid)) { $frontpagecontext = context_course::instance(get_site()->id); if ($frontpagecontext->path) { $accessdata['ra'][$frontpagecontext->path][(int)$CFG->defaultfrontpageroleid] = (int)$CFG->defaultfrontpageroleid; } } // Preload every assigned role. $sql = "SELECT ctx.path, ra.roleid, ra.contextid FROM {role_assignments} ra JOIN {context} ctx ON ctx.id = ra.contextid WHERE ra.userid = :userid"; $rs = $DB->get_recordset_sql($sql, array('userid' => $userid)); foreach ($rs as $ra) { // RAs leafs are arrays to support multi-role assignments... $accessdata['ra'][$ra->path][(int)$ra->roleid] = (int)$ra->roleid; } $rs->close(); return $accessdata; } /** * Returns empty accessdata structure. * * @access private * @return array empt accessdata */ function get_empty_accessdata() { $accessdata = array(); // named list $accessdata['ra'] = array(); $accessdata['time'] = time(); $accessdata['rsw'] = array(); return $accessdata; } /** * Get accessdata for a given user. * * @access private * @param int $userid * @param bool $preloadonly true means do not return access array * @return array accessdata */ function get_user_accessdata($userid, $preloadonly=false) { global $CFG, $ACCESSLIB_PRIVATE, $USER; if (isset($USER->access)) { $ACCESSLIB_PRIVATE->accessdatabyuser[$USER->id] = $USER->access; } if (!isset($ACCESSLIB_PRIVATE->accessdatabyuser[$userid])) { if (empty($userid)) { if (!empty($CFG->notloggedinroleid)) { $accessdata = get_role_access($CFG->notloggedinroleid); } else { // weird return get_empty_accessdata(); } } else if (isguestuser($userid)) { if ($guestrole = get_guest_role()) { $accessdata = get_role_access($guestrole->id); } else { //weird return get_empty_accessdata(); } } else { // Includes default role and frontpage role. $accessdata = get_user_roles_sitewide_accessdata($userid); } $ACCESSLIB_PRIVATE->accessdatabyuser[$userid] = $accessdata; } if ($preloadonly) { return; } else { return $ACCESSLIB_PRIVATE->accessdatabyuser[$userid]; } } /** * A convenience function to completely load all the capabilities * for the current user. It is called from has_capability() and functions change permissions. * * Call it only _after_ you've setup $USER and called check_enrolment_plugins(); * @see check_enrolment_plugins() * * @access private * @return void */ function load_all_capabilities() { global $USER; // roles not installed yet - we are in the middle of installation if (during_initial_install()) { return; } if (!isset($USER->id)) { // this should not happen $USER->id = 0; } unset($USER->access); $USER->access = get_user_accessdata($USER->id); // Clear to force a refresh unset($USER->mycourses); // init/reset internal enrol caches - active course enrolments and temp access $USER->enrol = array('enrolled'=>array(), 'tempguest'=>array()); } /** * A convenience function to completely reload all the capabilities * for the current user when roles have been updated in a relevant * context -- but PRESERVING switchroles and loginas. * This function resets all accesslib and context caches. * * That is - completely transparent to the user. * * Note: reloads $USER->access completely. * * @access private * @return void */ function reload_all_capabilities() { global $USER, $DB, $ACCESSLIB_PRIVATE; // copy switchroles $sw = array(); if (!empty($USER->access['rsw'])) { $sw = $USER->access['rsw']; } accesslib_clear_all_caches(true); unset($USER->access); // Prevent dirty flags refetching on this page. $ACCESSLIB_PRIVATE->dirtycontexts = array(); $ACCESSLIB_PRIVATE->dirtyusers = array($USER->id => false); load_all_capabilities(); foreach ($sw as $path => $roleid) { if ($record = $DB->get_record('context', array('path'=>$path))) { $context = context::instance_by_id($record->id); if (has_capability('moodle/role:switchroles', $context)) { role_switch($roleid, $context); } } } } /** * Adds a temp role to current USER->access array. * * Useful for the "temporary guest" access we grant to logged-in users. * This is useful for enrol plugins only. * * @since Moodle 2.2 * @param context_course $coursecontext * @param int $roleid * @return void */ function load_temp_course_role(context_course $coursecontext, $roleid) { global $USER, $SITE; if (empty($roleid)) { debugging('invalid role specified in load_temp_course_role()'); return; } if ($coursecontext->instanceid == $SITE->id) { debugging('Can not use temp roles on the frontpage'); return; } if (!isset($USER->access)) { load_all_capabilities(); } $coursecontext->reload_if_dirty(); if (isset($USER->access['ra'][$coursecontext->path][$roleid])) { return; } $USER->access['ra'][$coursecontext->path][(int)$roleid] = (int)$roleid; } /** * Removes any extra guest roles from current USER->access array. * This is useful for enrol plugins only. * * @since Moodle 2.2 * @param context_course $coursecontext * @return void */ function remove_temp_course_roles(context_course $coursecontext) { global $DB, $USER, $SITE; if ($coursecontext->instanceid == $SITE->id) { debugging('Can not use temp roles on the frontpage'); return; } if (empty($USER->access['ra'][$coursecontext->path])) { //no roles here, weird return; } $sql = "SELECT DISTINCT ra.roleid AS id FROM {role_assignments} ra WHERE ra.contextid = :contextid AND ra.userid = :userid"; $ras = $DB->get_records_sql($sql, array('contextid'=>$coursecontext->id, 'userid'=>$USER->id)); $USER->access['ra'][$coursecontext->path] = array(); foreach ($ras as $r) { $USER->access['ra'][$coursecontext->path][(int)$r->id] = (int)$r->id; } } /** * Returns array of all role archetypes. * * @return array */ function get_role_archetypes() { return array( 'manager' => 'manager', 'coursecreator' => 'coursecreator', 'editingteacher' => 'editingteacher', 'teacher' => 'teacher', 'student' => 'student', 'guest' => 'guest', 'user' => 'user', 'frontpage' => 'frontpage' ); } /** * Assign the defaults found in this capability definition to roles that have * the corresponding legacy capabilities assigned to them. * * @param string $capability * @param array $legacyperms an array in the format (example): * 'guest' => CAP_PREVENT, * 'student' => CAP_ALLOW, * 'teacher' => CAP_ALLOW, * 'editingteacher' => CAP_ALLOW, * 'coursecreator' => CAP_ALLOW, * 'manager' => CAP_ALLOW * @return boolean success or failure. */ function assign_legacy_capabilities($capability, $legacyperms) { $archetypes = get_role_archetypes(); foreach ($legacyperms as $type => $perm) { $systemcontext = context_system::instance(); if ($type === 'admin') { debugging('Legacy type admin in access.php was renamed to manager, please update the code.'); $type = 'manager'; } if (!array_key_exists($type, $archetypes)) {
< print_error('invalidlegacy', '', '', $type);
> throw new \moodle_exception('invalidlegacy', '', '', $type);
} if ($roles = get_archetype_roles($type)) { foreach ($roles as $role) { // Assign a site level capability. if (!assign_capability($capability, $perm, $role->id, $systemcontext->id)) { return false; } } } } return true; } /** * Verify capability risks. * * @param stdClass $capability a capability - a row from the capabilities table. * @return boolean whether this capability is safe - that is, whether people with the * safeoverrides capability should be allowed to change it. */ function is_safe_capability($capability) { return !((RISK_DATALOSS | RISK_MANAGETRUST | RISK_CONFIG | RISK_XSS | RISK_PERSONAL) & $capability->riskbitmask); } /** * Get the local override (if any) for a given capability in a role in a context * * @param int $roleid * @param int $contextid * @param string $capability * @return stdClass local capability override */ function get_local_override($roleid, $contextid, $capability) { global $DB; return $DB->get_record_sql(" SELECT rc.* FROM {role_capabilities} rc JOIN {capability} cap ON rc.capability = cap.name WHERE rc.roleid = :roleid AND rc.capability = :capability AND rc.contextid = :contextid", [ 'roleid' => $roleid, 'contextid' => $contextid, 'capability' => $capability, ]); } /** * Returns context instance plus related course and cm instances * * @param int $contextid * @return array of ($context, $course, $cm) */ function get_context_info_array($contextid) { global $DB; $context = context::instance_by_id($contextid, MUST_EXIST); $course = null; $cm = null; if ($context->contextlevel == CONTEXT_COURSE) { $course = $DB->get_record('course', array('id'=>$context->instanceid), '*', MUST_EXIST); } else if ($context->contextlevel == CONTEXT_MODULE) { $cm = get_coursemodule_from_id('', $context->instanceid, 0, false, MUST_EXIST); $course = $DB->get_record('course', array('id'=>$cm->course), '*', MUST_EXIST); } else if ($context->contextlevel == CONTEXT_BLOCK) { $parent = $context->get_parent_context(); if ($parent->contextlevel == CONTEXT_COURSE) { $course = $DB->get_record('course', array('id'=>$parent->instanceid), '*', MUST_EXIST); } else if ($parent->contextlevel == CONTEXT_MODULE) { $cm = get_coursemodule_from_id('', $parent->instanceid, 0, false, MUST_EXIST); $course = $DB->get_record('course', array('id'=>$cm->course), '*', MUST_EXIST); } } return array($context, $course, $cm); } /** * Function that creates a role * * @param string $name role name * @param string $shortname role short name * @param string $description role description * @param string $archetype * @return int id or dml_exception */ function create_role($name, $shortname, $description, $archetype = '') { global $DB; if (strpos($archetype, 'moodle/legacy:') !== false) { throw new coding_exception('Use new role archetype parameter in create_role() instead of old legacy capabilities.'); } // verify role archetype actually exists $archetypes = get_role_archetypes(); if (empty($archetypes[$archetype])) { $archetype = ''; } // Insert the role record. $role = new stdClass(); $role->name = $name; $role->shortname = $shortname; $role->description = $description; $role->archetype = $archetype; //find free sortorder number $role->sortorder = $DB->get_field('role', 'MAX(sortorder) + 1', array()); if (empty($role->sortorder)) { $role->sortorder = 1; } $id = $DB->insert_record('role', $role); return $id; } /** * Function that deletes a role and cleanups up after it * * @param int $roleid id of role to delete * @return bool always true */ function delete_role($roleid) { global $DB; // first unssign all users role_unassign_all(array('roleid'=>$roleid)); // cleanup all references to this role, ignore errors $DB->delete_records('role_capabilities', array('roleid'=>$roleid)); $DB->delete_records('role_allow_assign', array('roleid'=>$roleid)); $DB->delete_records('role_allow_assign', array('allowassign'=>$roleid)); $DB->delete_records('role_allow_override', array('roleid'=>$roleid)); $DB->delete_records('role_allow_override', array('allowoverride'=>$roleid)); $DB->delete_records('role_names', array('roleid'=>$roleid)); $DB->delete_records('role_context_levels', array('roleid'=>$roleid)); // Get role record before it's deleted. $role = $DB->get_record('role', array('id'=>$roleid)); // Finally delete the role itself. $DB->delete_records('role', array('id'=>$roleid)); // Trigger event. $event = \core\event\role_deleted::create( array( 'context' => context_system::instance(), 'objectid' => $roleid, 'other' => array( 'shortname' => $role->shortname, 'description' => $role->description, 'archetype' => $role->archetype ) ) ); $event->add_record_snapshot('role', $role); $event->trigger(); // Reset any cache of this role, including MUC. accesslib_clear_role_cache($roleid); return true; } /** * Function to write context specific overrides, or default capabilities. * * @param string $capability string name * @param int $permission CAP_ constants * @param int $roleid role id * @param int|context $contextid context id * @param bool $overwrite * @return bool always true or exception */ function assign_capability($capability, $permission, $roleid, $contextid, $overwrite = false) { global $USER, $DB; if ($contextid instanceof context) { $context = $contextid; } else { $context = context::instance_by_id($contextid); } // Capability must exist. if (!$capinfo = get_capability_info($capability)) { throw new coding_exception("Capability '{$capability}' was not found! This has to be fixed in code."); } if (empty($permission) || $permission == CAP_INHERIT) { // if permission is not set unassign_capability($capability, $roleid, $context->id); return true; } $existing = $DB->get_record('role_capabilities', array('contextid'=>$context->id, 'roleid'=>$roleid, 'capability'=>$capability)); if ($existing and !$overwrite) { // We want to keep whatever is there already return true; } $cap = new stdClass(); $cap->contextid = $context->id; $cap->roleid = $roleid; $cap->capability = $capability; $cap->permission = $permission; $cap->timemodified = time(); $cap->modifierid = empty($USER->id) ? 0 : $USER->id; if ($existing) { $cap->id = $existing->id; $DB->update_record('role_capabilities', $cap); } else { if ($DB->record_exists('context', array('id'=>$context->id))) { $DB->insert_record('role_capabilities', $cap); } } // Trigger capability_assigned event. \core\event\capability_assigned::create([ 'userid' => $cap->modifierid, 'context' => $context, 'objectid' => $roleid, 'other' => [ 'capability' => $capability, 'oldpermission' => $existing->permission ?? CAP_INHERIT, 'permission' => $permission ] ])->trigger(); // Reset any cache of this role, including MUC. accesslib_clear_role_cache($roleid); return true; } /** * Unassign a capability from a role. * * @param string $capability the name of the capability * @param int $roleid the role id * @param int|context $contextid null means all contexts * @return boolean true or exception */ function unassign_capability($capability, $roleid, $contextid = null) { global $DB, $USER; // Capability must exist. if (!$capinfo = get_capability_info($capability)) { throw new coding_exception("Capability '{$capability}' was not found! This has to be fixed in code."); } if (!empty($contextid)) { if ($contextid instanceof context) { $context = $contextid; } else { $context = context::instance_by_id($contextid); } // delete from context rel, if this is the last override in this context $DB->delete_records('role_capabilities', array('capability'=>$capability, 'roleid'=>$roleid, 'contextid'=>$context->id)); } else { $DB->delete_records('role_capabilities', array('capability'=>$capability, 'roleid'=>$roleid)); } // Trigger capability_assigned event. \core\event\capability_unassigned::create([ 'userid' => $USER->id, 'context' => $context ?? context_system::instance(), 'objectid' => $roleid, 'other' => [ 'capability' => $capability, ] ])->trigger(); // Reset any cache of this role, including MUC. accesslib_clear_role_cache($roleid); return true; } /** * Get the roles that have a given capability assigned to it * * This function does not resolve the actual permission of the capability. * It just checks for permissions and overrides. * Use get_roles_with_cap_in_context() if resolution is required. * * @param string $capability capability name (string) * @param string $permission optional, the permission defined for this capability * either CAP_ALLOW, CAP_PREVENT or CAP_PROHIBIT. Defaults to null which means any. * @param stdClass $context null means any * @return array of role records */ function get_roles_with_capability($capability, $permission = null, $context = null) { global $DB; if ($context) { $contexts = $context->get_parent_context_ids(true); list($insql, $params) = $DB->get_in_or_equal($contexts, SQL_PARAMS_NAMED, 'ctx'); $contextsql = "AND rc.contextid $insql"; } else { $params = array(); $contextsql = ''; } if ($permission) { $permissionsql = " AND rc.permission = :permission"; $params['permission'] = $permission; } else { $permissionsql = ''; } $sql = "SELECT r.* FROM {role} r WHERE r.id IN (SELECT rc.roleid FROM {role_capabilities} rc JOIN {capabilities} cap ON rc.capability = cap.name WHERE rc.capability = :capname $contextsql $permissionsql)"; $params['capname'] = $capability; return $DB->get_records_sql($sql, $params); } /** * This function makes a role-assignment (a role for a user in a particular context) * * @param int $roleid the role of the id * @param int $userid userid * @param int|context $contextid id of the context * @param string $component example 'enrol_ldap', defaults to '' which means manual assignment, * @param int $itemid id of enrolment/auth plugin * @param string $timemodified defaults to current time * @return int new/existing id of the assignment */ function role_assign($roleid, $userid, $contextid, $component = '', $itemid = 0, $timemodified = '') { global $USER, $DB; // first of all detect if somebody is using old style parameters if ($contextid === 0 or is_numeric($component)) { throw new coding_exception('Invalid call to role_assign(), code needs to be updated to use new order of parameters'); } // now validate all parameters if (empty($roleid)) { throw new coding_exception('Invalid call to role_assign(), roleid can not be empty'); } if (empty($userid)) { throw new coding_exception('Invalid call to role_assign(), userid can not be empty'); } if ($itemid) { if (strpos($component, '_') === false) { throw new coding_exception('Invalid call to role_assign(), component must start with plugin type such as"enrol_" when itemid specified', 'component:'.$component); } } else { $itemid = 0; if ($component !== '' and strpos($component, '_') === false) { throw new coding_exception('Invalid call to role_assign(), invalid component string', 'component:'.$component); } } if (!$DB->record_exists('user', array('id'=>$userid, 'deleted'=>0))) { throw new coding_exception('User ID does not exist or is deleted!', 'userid:'.$userid); } if ($contextid instanceof context) { $context = $contextid; } else { $context = context::instance_by_id($contextid, MUST_EXIST); } if (!$timemodified) { $timemodified = time(); } // Check for existing entry $ras = $DB->get_records('role_assignments', array('roleid'=>$roleid, 'contextid'=>$context->id, 'userid'=>$userid, 'component'=>$component, 'itemid'=>$itemid), 'id'); if ($ras) { // role already assigned - this should not happen if (count($ras) > 1) { // very weird - remove all duplicates! $ra = array_shift($ras); foreach ($ras as $r) { $DB->delete_records('role_assignments', array('id'=>$r->id)); } } else { $ra = reset($ras); } // actually there is no need to update, reset anything or trigger any event, so just return return $ra->id; } // Create a new entry $ra = new stdClass(); $ra->roleid = $roleid; $ra->contextid = $context->id; $ra->userid = $userid; $ra->component = $component; $ra->itemid = $itemid; $ra->timemodified = $timemodified; $ra->modifierid = empty($USER->id) ? 0 : $USER->id; $ra->sortorder = 0; $ra->id = $DB->insert_record('role_assignments', $ra); // Role assignments have changed, so mark user as dirty. mark_user_dirty($userid); core_course_category::role_assignment_changed($roleid, $context); $event = \core\event\role_assigned::create(array( 'context' => $context, 'objectid' => $ra->roleid, 'relateduserid' => $ra->userid, 'other' => array( 'id' => $ra->id, 'component' => $ra->component, 'itemid' => $ra->itemid ) )); $event->add_record_snapshot('role_assignments', $ra); $event->trigger(); return $ra->id; } /** * Removes one role assignment * * @param int $roleid * @param int $userid * @param int $contextid * @param string $component * @param int $itemid * @return void */ function role_unassign($roleid, $userid, $contextid, $component = '', $itemid = 0) { // first make sure the params make sense if ($roleid == 0 or $userid == 0 or $contextid == 0) { throw new coding_exception('Invalid call to role_unassign(), please use role_unassign_all() when removing multiple role assignments'); } if ($itemid) { if (strpos($component, '_') === false) { throw new coding_exception('Invalid call to role_assign(), component must start with plugin type such as "enrol_" when itemid specified', 'component:'.$component); } } else { $itemid = 0; if ($component !== '' and strpos($component, '_') === false) { throw new coding_exception('Invalid call to role_assign(), invalid component string', 'component:'.$component); } } role_unassign_all(array('roleid'=>$roleid, 'userid'=>$userid, 'contextid'=>$contextid, 'component'=>$component, 'itemid'=>$itemid), false, false); } /** * Removes multiple role assignments, parameters may contain: * 'roleid', 'userid', 'contextid', 'component', 'enrolid'. * * @param array $params role assignment parameters * @param bool $subcontexts unassign in subcontexts too * @param bool $includemanual include manual role assignments too * @return void */ function role_unassign_all(array $params, $subcontexts = false, $includemanual = false) { global $USER, $CFG, $DB; if (!$params) { throw new coding_exception('Missing parameters in role_unsassign_all() call'); } $allowed = array('roleid', 'userid', 'contextid', 'component', 'itemid'); foreach ($params as $key=>$value) { if (!in_array($key, $allowed)) { throw new coding_exception('Unknown role_unsassign_all() parameter key', 'key:'.$key); } } if (isset($params['component']) and $params['component'] !== '' and strpos($params['component'], '_') === false) { throw new coding_exception('Invalid component paramter in role_unsassign_all() call', 'component:'.$params['component']); } if ($includemanual) { if (!isset($params['component']) or $params['component'] === '') { throw new coding_exception('include manual parameter requires component parameter in role_unsassign_all() call'); } } if ($subcontexts) { if (empty($params['contextid'])) { throw new coding_exception('subcontexts paramtere requires component parameter in role_unsassign_all() call'); } } $ras = $DB->get_records('role_assignments', $params); foreach ($ras as $ra) { $DB->delete_records('role_assignments', array('id'=>$ra->id)); if ($context = context::instance_by_id($ra->contextid, IGNORE_MISSING)) { // Role assignments have changed, so mark user as dirty. mark_user_dirty($ra->userid); $event = \core\event\role_unassigned::create(array( 'context' => $context, 'objectid' => $ra->roleid, 'relateduserid' => $ra->userid, 'other' => array( 'id' => $ra->id, 'component' => $ra->component, 'itemid' => $ra->itemid ) )); $event->add_record_snapshot('role_assignments', $ra); $event->trigger(); core_course_category::role_assignment_changed($ra->roleid, $context); } } unset($ras); // process subcontexts if ($subcontexts and $context = context::instance_by_id($params['contextid'], IGNORE_MISSING)) { if ($params['contextid'] instanceof context) { $context = $params['contextid']; } else { $context = context::instance_by_id($params['contextid'], IGNORE_MISSING); } if ($context) { $contexts = $context->get_child_contexts(); $mparams = $params; foreach ($contexts as $context) { $mparams['contextid'] = $context->id; $ras = $DB->get_records('role_assignments', $mparams); foreach ($ras as $ra) { $DB->delete_records('role_assignments', array('id'=>$ra->id)); // Role assignments have changed, so mark user as dirty. mark_user_dirty($ra->userid); $event = \core\event\role_unassigned::create( array('context'=>$context, 'objectid'=>$ra->roleid, 'relateduserid'=>$ra->userid, 'other'=>array('id'=>$ra->id, 'component'=>$ra->component, 'itemid'=>$ra->itemid))); $event->add_record_snapshot('role_assignments', $ra); $event->trigger(); core_course_category::role_assignment_changed($ra->roleid, $context); } } } } // do this once more for all manual role assignments if ($includemanual) { $params['component'] = ''; role_unassign_all($params, $subcontexts, false); } } /** * Mark a user as dirty (with timestamp) so as to force reloading of the user session. * * @param int $userid * @return void */ function mark_user_dirty($userid) { global $CFG, $ACCESSLIB_PRIVATE; if (during_initial_install()) { return; } // Throw exception if invalid userid is provided. if (empty($userid)) { throw new coding_exception('Invalid user parameter supplied for mark_user_dirty() function!'); } // Set dirty flag in database, set dirty field locally, and clear local accessdata cache. set_cache_flag('accesslib/dirtyusers', $userid, 1, time() + $CFG->sessiontimeout); $ACCESSLIB_PRIVATE->dirtyusers[$userid] = 1; unset($ACCESSLIB_PRIVATE->accessdatabyuser[$userid]); } /** * Determines if a user is currently logged in * * @category access * * @return bool */ function isloggedin() { global $USER; return (!empty($USER->id)); } /** * Determines if a user is logged in as real guest user with username 'guest'. * * @category access * * @param int|object $user mixed user object or id, $USER if not specified * @return bool true if user is the real guest user, false if not logged in or other user */ function isguestuser($user = null) { global $USER, $DB, $CFG; // make sure we have the user id cached in config table, because we are going to use it a lot if (empty($CFG->siteguest)) { if (!$guestid = $DB->get_field('user', 'id', array('username'=>'guest', 'mnethostid'=>$CFG->mnet_localhost_id))) { // guest does not exist yet, weird return false; } set_config('siteguest', $guestid); } if ($user === null) { $user = $USER; } if ($user === null) { // happens when setting the $USER return false; } else if (is_numeric($user)) { return ($CFG->siteguest == $user); } else if (is_object($user)) { if (empty($user->id)) { return false; // not logged in means is not be guest } else { return ($CFG->siteguest == $user->id); } } else { throw new coding_exception('Invalid user parameter supplied for isguestuser() function!'); } } /** * Does user have a (temporary or real) guest access to course? * * @category access * * @param context $context * @param stdClass|int $user * @return bool */ function is_guest(context $context, $user = null) { global $USER; // first find the course context $coursecontext = $context->get_course_context(); // make sure there is a real user specified if ($user === null) { $userid = isset($USER->id) ? $USER->id : 0; } else { $userid = is_object($user) ? $user->id : $user; } if (isguestuser($userid)) { // can not inspect or be enrolled return true; } if (has_capability('moodle/course:view', $coursecontext, $user)) { // viewing users appear out of nowhere, they are neither guests nor participants return false; } // consider only real active enrolments here if (is_enrolled($coursecontext, $user, '', true)) { return false; } return true; } /** * Returns true if the user has moodle/course:view capability in the course, * this is intended for admins, managers (aka small admins), inspectors, etc. * * @category access * * @param context $context * @param int|stdClass $user if null $USER is used * @param string $withcapability extra capability name * @return bool */ function is_viewing(context $context, $user = null, $withcapability = '') { // first find the course context $coursecontext = $context->get_course_context(); if (isguestuser($user)) { // can not inspect return false; } if (!has_capability('moodle/course:view', $coursecontext, $user)) { // admins are allowed to inspect courses return false; } if ($withcapability and !has_capability($withcapability, $context, $user)) { // site admins always have the capability, but the enrolment above blocks return false; } return true; } /** * Returns true if the user is able to access the course. * * This function is in no way, shape, or form a substitute for require_login. * It should only be used in circumstances where it is not possible to call require_login * such as the navigation. * * This function checks many of the methods of access to a course such as the view * capability, enrollments, and guest access. It also makes use of the cache * generated by require_login for guest access. * * The flags within the $USER object that are used here should NEVER be used outside * of this function can_access_course and require_login. Doing so WILL break future * versions. * * @param stdClass $course record * @param stdClass|int|null $user user record or id, current user if null * @param string $withcapability Check for this capability as well. * @param bool $onlyactive consider only active enrolments in enabled plugins and time restrictions * @return boolean Returns true if the user is able to access the course */ function can_access_course(stdClass $course, $user = null, $withcapability = '', $onlyactive = false) { global $DB, $USER; // this function originally accepted $coursecontext parameter if ($course instanceof context) { if ($course instanceof context_course) { debugging('deprecated context parameter, please use $course record'); $coursecontext = $course; $course = $DB->get_record('course', array('id'=>$coursecontext->instanceid)); } else { debugging('Invalid context parameter, please use $course record'); return false; } } else { $coursecontext = context_course::instance($course->id); } if (!isset($USER->id)) { // should never happen $USER->id = 0; debugging('Course access check being performed on a user with no ID.', DEBUG_DEVELOPER); } // make sure there is a user specified if ($user === null) { $userid = $USER->id; } else { $userid = is_object($user) ? $user->id : $user; } unset($user); if ($withcapability and !has_capability($withcapability, $coursecontext, $userid)) { return false; } if ($userid == $USER->id) { if (!empty($USER->access['rsw'][$coursecontext->path])) { // the fact that somebody switched role means they can access the course no matter to what role they switched return true; } } if (!$course->visible and !has_capability('moodle/course:viewhiddencourses', $coursecontext, $userid)) { return false; } if (is_viewing($coursecontext, $userid)) { return true; } if ($userid != $USER->id) { // for performance reasons we do not verify temporary guest access for other users, sorry... return is_enrolled($coursecontext, $userid, '', $onlyactive); } // === from here we deal only with $USER === $coursecontext->reload_if_dirty(); if (isset($USER->enrol['enrolled'][$course->id])) { if ($USER->enrol['enrolled'][$course->id] > time()) { return true; } } if (isset($USER->enrol['tempguest'][$course->id])) { if ($USER->enrol['tempguest'][$course->id] > time()) { return true; } } if (is_enrolled($coursecontext, $USER, '', $onlyactive)) { return true; } if (!core_course_category::can_view_course_info($course)) { // No guest access if user does not have capability to browse courses. return false; } // if not enrolled try to gain temporary guest access $instances = $DB->get_records('enrol', array('courseid'=>$course->id, 'status'=>ENROL_INSTANCE_ENABLED), 'sortorder, id ASC'); $enrols = enrol_get_plugins(true); foreach ($instances as $instance) { if (!isset($enrols[$instance->enrol])) { continue; } // Get a duration for the guest access, a timestamp in the future, 0 (always) or false. $until = $enrols[$instance->enrol]->try_guestaccess($instance); if ($until !== false and $until > time()) { $USER->enrol['tempguest'][$course->id] = $until; return true; } } if (isset($USER->enrol['tempguest'][$course->id])) { unset($USER->enrol['tempguest'][$course->id]); remove_temp_course_roles($coursecontext); } return false; } /** * Loads the capability definitions for the component (from file). * * Loads the capability definitions for the component (from file). If no * capabilities are defined for the component, we simply return an empty array. * * @access private * @param string $component full plugin name, examples: 'moodle', 'mod_forum' * @return array array of capabilities */ function load_capability_def($component) { $defpath = core_component::get_component_directory($component).'/db/access.php'; $capabilities = array(); if (file_exists($defpath)) { require($defpath); if (!empty(${$component.'_capabilities'})) { // BC capability array name // since 2.0 we prefer $capabilities instead - it is easier to use and matches db/* files debugging('componentname_capabilities array is deprecated, please use $capabilities array only in access.php files'); $capabilities = ${$component.'_capabilities'}; } } return $capabilities; } /** * Gets the capabilities that have been cached in the database for this component. * * @access private * @param string $component - examples: 'moodle', 'mod_forum' * @return array array of capabilities */ function get_cached_capabilities($component = 'moodle') { global $DB; $caps = get_all_capabilities(); $componentcaps = array(); foreach ($caps as $cap) { if ($cap['component'] == $component) { $componentcaps[] = (object) $cap; } } return $componentcaps; } /** * Returns default capabilities for given role archetype. * * @param string $archetype role archetype * @return array */ function get_default_capabilities($archetype) { global $DB; if (!$archetype) { return array(); } $alldefs = array(); $defaults = array(); $components = array(); $allcaps = get_all_capabilities(); foreach ($allcaps as $cap) { if (!in_array($cap['component'], $components)) { $components[] = $cap['component']; $alldefs = array_merge($alldefs, load_capability_def($cap['component'])); } } foreach ($alldefs as $name=>$def) { // Use array 'archetypes if available. Only if not specified, use 'legacy'. if (isset($def['archetypes'])) { if (isset($def['archetypes'][$archetype])) { $defaults[$name] = $def['archetypes'][$archetype]; } // 'legacy' is for backward compatibility with 1.9 access.php } else { if (isset($def['legacy'][$archetype])) { $defaults[$name] = $def['legacy'][$archetype]; } } } return $defaults; } /** * Return default roles that can be assigned, overridden or switched * by give role archetype. * * @param string $type assign|override|switch|view * @param string $archetype * @return array of role ids */ function get_default_role_archetype_allows($type, $archetype) { global $DB; if (empty($archetype)) { return array(); } $roles = $DB->get_records('role'); $archetypemap = array(); foreach ($roles as $role) { if ($role->archetype) { $archetypemap[$role->archetype][$role->id] = $role->id; } } $defaults = array( 'assign' => array( 'manager' => array('manager', 'coursecreator', 'editingteacher', 'teacher', 'student'), 'coursecreator' => array(), 'editingteacher' => array('teacher', 'student'), 'teacher' => array(), 'student' => array(), 'guest' => array(), 'user' => array(), 'frontpage' => array(), ), 'override' => array( 'manager' => array('manager', 'coursecreator', 'editingteacher', 'teacher', 'student', 'guest', 'user', 'frontpage'), 'coursecreator' => array(), 'editingteacher' => array('teacher', 'student', 'guest'), 'teacher' => array(), 'student' => array(), 'guest' => array(), 'user' => array(), 'frontpage' => array(), ), 'switch' => array( 'manager' => array('editingteacher', 'teacher', 'student', 'guest'), 'coursecreator' => array(), 'editingteacher' => array('teacher', 'student', 'guest'), 'teacher' => array('student', 'guest'), 'student' => array(), 'guest' => array(), 'user' => array(), 'frontpage' => array(), ), 'view' => array( 'manager' => array('manager', 'coursecreator', 'editingteacher', 'teacher', 'student', 'guest', 'user', 'frontpage'), 'coursecreator' => array('coursecreator', 'editingteacher', 'teacher', 'student'), 'editingteacher' => array('coursecreator', 'editingteacher', 'teacher', 'student'), 'teacher' => array('coursecreator', 'editingteacher', 'teacher', 'student'), 'student' => array('coursecreator', 'editingteacher', 'teacher', 'student'), 'guest' => array(), 'user' => array(), 'frontpage' => array(), ), ); if (!isset($defaults[$type][$archetype])) { debugging("Unknown type '$type'' or archetype '$archetype''"); return array(); } $return = array(); foreach ($defaults[$type][$archetype] as $at) { if (isset($archetypemap[$at])) { foreach ($archetypemap[$at] as $roleid) { $return[$roleid] = $roleid; } } } return $return; } /** * Reset role capabilities to default according to selected role archetype. * If no archetype selected, removes all capabilities. * * This applies to capabilities that are assigned to the role (that you could * edit in the 'define roles' interface), and not to any capability overrides * in different locations. * * @param int $roleid ID of role to reset capabilities for */ function reset_role_capabilities($roleid) { global $DB; $role = $DB->get_record('role', array('id'=>$roleid), '*', MUST_EXIST); $defaultcaps = get_default_capabilities($role->archetype); $systemcontext = context_system::instance(); $DB->delete_records('role_capabilities', array('roleid' => $roleid, 'contextid' => $systemcontext->id)); foreach ($defaultcaps as $cap=>$permission) { assign_capability($cap, $permission, $roleid, $systemcontext->id); } // Reset any cache of this role, including MUC. accesslib_clear_role_cache($roleid); } /** * Updates the capabilities table with the component capability definitions. * If no parameters are given, the function updates the core moodle * capabilities. * * Note that the absence of the db/access.php capabilities definition file * will cause any stored capabilities for the component to be removed from * the database. * * @access private * @param string $component examples: 'moodle', 'mod_forum', 'block_activity_results' * @return boolean true if success, exception in case of any problems */ function update_capabilities($component = 'moodle') { global $DB, $OUTPUT; $storedcaps = array(); $filecaps = load_capability_def($component); foreach ($filecaps as $capname=>$unused) { if (!preg_match('|^[a-z]+/[a-z_0-9]+:[a-z_0-9]+$|', $capname)) { debugging("Coding problem: Invalid capability name '$capname', use 'clonepermissionsfrom' field for migration."); } } // It is possible somebody directly modified the DB (according to accesslib_test anyway). // So ensure our updating is based on fresh data. cache::make('core', 'capabilities')->delete('core_capabilities'); $cachedcaps = get_cached_capabilities($component); if ($cachedcaps) { foreach ($cachedcaps as $cachedcap) { array_push($storedcaps, $cachedcap->name); // update risk bitmasks and context levels in existing capabilities if needed if (array_key_exists($cachedcap->name, $filecaps)) { if (!array_key_exists('riskbitmask', $filecaps[$cachedcap->name])) { $filecaps[$cachedcap->name]['riskbitmask'] = 0; // no risk if not specified } if ($cachedcap->captype != $filecaps[$cachedcap->name]['captype']) { $updatecap = new stdClass(); $updatecap->id = $cachedcap->id; $updatecap->captype = $filecaps[$cachedcap->name]['captype']; $DB->update_record('capabilities', $updatecap); } if ($cachedcap->riskbitmask != $filecaps[$cachedcap->name]['riskbitmask']) { $updatecap = new stdClass(); $updatecap->id = $cachedcap->id; $updatecap->riskbitmask = $filecaps[$cachedcap->name]['riskbitmask']; $DB->update_record('capabilities', $updatecap); } if (!array_key_exists('contextlevel', $filecaps[$cachedcap->name])) { $filecaps[$cachedcap->name]['contextlevel'] = 0; // no context level defined } if ($cachedcap->contextlevel != $filecaps[$cachedcap->name]['contextlevel']) { $updatecap = new stdClass(); $updatecap->id = $cachedcap->id; $updatecap->contextlevel = $filecaps[$cachedcap->name]['contextlevel']; $DB->update_record('capabilities', $updatecap); } } } } // Flush the cached again, as we have changed DB. cache::make('core', 'capabilities')->delete('core_capabilities'); // Are there new capabilities in the file definition? $newcaps = array(); foreach ($filecaps as $filecap => $def) { if (!$storedcaps || ($storedcaps && in_array($filecap, $storedcaps) === false)) { if (!array_key_exists('riskbitmask', $def)) { $def['riskbitmask'] = 0; // no risk if not specified } $newcaps[$filecap] = $def; } } // Add new capabilities to the stored definition. $existingcaps = $DB->get_records_menu('capabilities', array(), 'id', 'id, name'); foreach ($newcaps as $capname => $capdef) { $capability = new stdClass(); $capability->name = $capname; $capability->captype = $capdef['captype']; $capability->contextlevel = $capdef['contextlevel']; $capability->component = $component; $capability->riskbitmask = $capdef['riskbitmask']; $DB->insert_record('capabilities', $capability, false); // Flush the cached, as we have changed DB. cache::make('core', 'capabilities')->delete('core_capabilities'); if (isset($capdef['clonepermissionsfrom']) && in_array($capdef['clonepermissionsfrom'], $existingcaps)){ if ($rolecapabilities = $DB->get_records('role_capabilities', array('capability'=>$capdef['clonepermissionsfrom']))){ foreach ($rolecapabilities as $rolecapability){ //assign_capability will update rather than insert if capability exists if (!assign_capability($capname, $rolecapability->permission, $rolecapability->roleid, $rolecapability->contextid, true)){ echo $OUTPUT->notification('Could not clone capabilities for '.$capname); } } } // we ignore archetype key if we have cloned permissions } else if (isset($capdef['archetypes']) && is_array($capdef['archetypes'])) { assign_legacy_capabilities($capname, $capdef['archetypes']); // 'legacy' is for backward compatibility with 1.9 access.php } else if (isset($capdef['legacy']) && is_array($capdef['legacy'])) { assign_legacy_capabilities($capname, $capdef['legacy']); } } // Are there any capabilities that have been removed from the file // definition that we need to delete from the stored capabilities and // role assignments? capabilities_cleanup($component, $filecaps); // reset static caches accesslib_reset_role_cache(); // Flush the cached again, as we have changed DB. cache::make('core', 'capabilities')->delete('core_capabilities'); return true; } /** * Deletes cached capabilities that are no longer needed by the component. * Also unassigns these capabilities from any roles that have them. * NOTE: this function is called from lib/db/upgrade.php * * @access private * @param string $component examples: 'moodle', 'mod_forum', 'block_activity_results' * @param array $newcapdef array of the new capability definitions that will be * compared with the cached capabilities * @return int number of deprecated capabilities that have been removed */ function capabilities_cleanup($component, $newcapdef = null) { global $DB; $removedcount = 0; if ($cachedcaps = get_cached_capabilities($component)) { foreach ($cachedcaps as $cachedcap) { if (empty($newcapdef) || array_key_exists($cachedcap->name, $newcapdef) === false) { // Delete from roles. if ($roles = get_roles_with_capability($cachedcap->name)) { foreach ($roles as $role) { if (!unassign_capability($cachedcap->name, $role->id)) {
< print_error('cannotunassigncap', 'error', '', (object)array('cap'=>$cachedcap->name, 'role'=>$role->name));
> throw new \moodle_exception('cannotunassigncap', 'error', '', > (object)array('cap' => $cachedcap->name, 'role' => $role->name));
} } } // Remove from role_capabilities for any old ones. $DB->delete_records('role_capabilities', array('capability' => $cachedcap->name)); // Remove from capabilities cache. $DB->delete_records('capabilities', array('name' => $cachedcap->name)); $removedcount++; } // End if. } } if ($removedcount) { cache::make('core', 'capabilities')->delete('core_capabilities'); } return $removedcount; } /** * Returns an array of all the known types of risk * The array keys can be used, for example as CSS class names, or in calls to * print_risk_icon. The values are the corresponding RISK_ constants. * * @return array all the known types of risk. */ function get_all_risks() { return array( 'riskmanagetrust' => RISK_MANAGETRUST, 'riskconfig' => RISK_CONFIG, 'riskxss' => RISK_XSS, 'riskpersonal' => RISK_PERSONAL, 'riskspam' => RISK_SPAM, 'riskdataloss' => RISK_DATALOSS, ); } /** * Return a link to moodle docs for a given capability name * * @param stdClass $capability a capability - a row from the mdl_capabilities table. * @return string the human-readable capability name as a link to Moodle Docs. */ function get_capability_docs_link($capability) { $url = get_docs_url('Capabilities/' . $capability->name); return '<a onclick="this.target=\'docspopup\'" href="' . $url . '">' . get_capability_string($capability->name) . '</a>'; } /** * This function pulls out all the resolved capabilities (overrides and * defaults) of a role used in capability overrides in contexts at a given * context. * * @param int $roleid * @param context $context * @param string $cap capability, optional, defaults to '' * @return array Array of capabilities */ function role_context_capabilities($roleid, context $context, $cap = '') { global $DB; $contexts = $context->get_parent_context_ids(true); $contexts = '('.implode(',', $contexts).')'; $params = array($roleid); if ($cap) { $search = " AND rc.capability = ? "; $params[] = $cap; } else { $search = ''; } $sql = "SELECT rc.* FROM {role_capabilities} rc JOIN {context} c ON rc.contextid = c.id JOIN {capabilities} cap ON rc.capability = cap.name WHERE rc.contextid in $contexts AND rc.roleid = ? $search ORDER BY c.contextlevel DESC, rc.capability DESC"; $capabilities = array(); if ($records = $DB->get_records_sql($sql, $params)) { // We are traversing via reverse order. foreach ($records as $record) { // If not set yet (i.e. inherit or not set at all), or currently we have a prohibit if (!isset($capabilities[$record->capability]) || $record->permission<-500) { $capabilities[$record->capability] = $record->permission; } } } return $capabilities; } /** * Constructs array with contextids as first parameter and context paths, * in both cases bottom top including self. * * @access private * @param context $context * @return array */ function get_context_info_list(context $context) { $contextids = explode('/', ltrim($context->path, '/')); $contextpaths = array(); $contextids2 = $contextids; while ($contextids2) { $contextpaths[] = '/' . implode('/', $contextids2); array_pop($contextids2); } return array($contextids, $contextpaths); } /** * Check if context is the front page context or a context inside it * * Returns true if this context is the front page context, or a context inside it, * otherwise false. * * @param context $context a context object. * @return bool */ function is_inside_frontpage(context $context) { $frontpagecontext = context_course::instance(SITEID); return strpos($context->path . '/', $frontpagecontext->path . '/') === 0; } /** * Returns capability information (cached) * * @param string $capabilityname * @return stdClass or null if capability not found */ function get_capability_info($capabilityname) { $caps = get_all_capabilities();
> // Check for deprecated capability. if (!isset($caps[$capabilityname])) { > if ($deprecatedinfo = get_deprecated_capability_info($capabilityname)) { return null; > if (!empty($deprecatedinfo['replacement'])) { } > // Let's try again with this capability if it exists. > if (isset($caps[$deprecatedinfo['replacement']])) { return (object) $caps[$capabilityname]; > $capabilityname = $deprecatedinfo['replacement']; } > } else { > debugging("Capability '{$capabilityname}' was supposed to be replaced with ". /** > "'{$deprecatedinfo['replacement']}', which does not exist !"); * Returns all capabilitiy records, preferably from MUC and not database. > } * > } * @return array All capability records indexed by capability name > $fullmessage = $deprecatedinfo['fullmessage']; */ > debugging($fullmessage, DEBUG_DEVELOPER); function get_all_capabilities() { > }
global $DB;
> * Returns deprecation info for this particular capabilty (cached) $cache = cache::make('core', 'capabilities'); > * if (!$allcaps = $cache->get('core_capabilities')) { > * Do not use this function except in the get_capability_info $rs = $DB->get_recordset('capabilities'); > * $allcaps = array(); > * @param string $capabilityname foreach ($rs as $capability) { > * @return stdClass|null with deprecation message and potential replacement if not null $capability->riskbitmask = (int) $capability->riskbitmask; > */ $allcaps[$capability->name] = (array) $capability; > function get_deprecated_capability_info($capabilityname) { } > $cache = cache::make('core', 'capabilities'); $rs->close(); > $alldeprecatedcaps = $cache->get('deprecated_capabilities'); $cache->set('core_capabilities', $allcaps); > if ($alldeprecatedcaps === false) { } > // Look for deprecated capabilities in each component. return $allcaps; > $allcaps = get_all_capabilities(); } > $components = []; > $alldeprecatedcaps = []; /** > foreach ($allcaps as $cap) { * Returns the human-readable, translated version of the capability. > if (!in_array($cap['component'], $components)) { * Basically a big switch statement. > $components[] = $cap['component']; * > $defpath = core_component::get_component_directory($cap['component']).'/db/access.php'; * @param string $capabilityname e.g. mod/choice:readresponses > if (file_exists($defpath)) { * @return string > $deprecatedcapabilities = []; */ > require($defpath); function get_capability_string($capabilityname) { > if (!empty($deprecatedcapabilities)) { > foreach ($deprecatedcapabilities as $cname => $cdef) { // Typical capability name is 'plugintype/pluginname:capabilityname' > $alldeprecatedcaps[$cname] = $cdef; list($type, $name, $capname) = preg_split('|[/:]|', $capabilityname); > } > } if ($type === 'moodle') { > } $component = 'core_role'; > } } else if ($type === 'quizreport') { > } //ugly hack!! > $cache->set('deprecated_capabilities', $alldeprecatedcaps); $component = 'quiz_'.$name; > } } else { > $component = $type.'_'.$name; > if (!isset($alldeprecatedcaps[$capabilityname])) { } > return null; > } $stringname = $name.':'.$capname; > $deprecatedinfo = $alldeprecatedcaps[$capabilityname]; > $deprecatedinfo['fullmessage'] = "The capability '{$capabilityname}' is deprecated."; if ($component === 'core_role' or get_string_manager()->string_exists($stringname, $component)) { > if (!empty($deprecatedinfo['message'])) { return get_string($stringname, $component); > $deprecatedinfo['fullmessage'] .= $deprecatedinfo['message']; } > } > if (!empty($deprecatedinfo['replacement'])) { $dir = core_component::get_component_directory($component); > $deprecatedinfo['fullmessage'] .= if (!file_exists($dir)) { > "It will be replaced by '{$deprecatedinfo['replacement']}'."; // plugin broken or does not exist, do not bother with printing of debug message > } return $capabilityname.' ???'; > return $deprecatedinfo; } > } > // something is wrong in plugin, better print debug > /**
< if (!file_exists($dir)) {
> if (!isset($dir) || !file_exists($dir)) {
} /** * This gets the mod/block/course/core etc strings. * * @param string $component * @param int $contextlevel * @return string|bool String is success, false if failed */ function get_component_string($component, $contextlevel) { if ($component === 'moodle' || $component === 'core') { return context_helper::get_level_name($contextlevel); } list($type, $name) = core_component::normalize_component($component); $dir = core_component::get_plugin_directory($type, $name);
< if (!file_exists($dir)) {
> if (!isset($dir) || !file_exists($dir)) {
// plugin not installed, bad luck, there is no way to find the name return $component . ' ???'; } // Some plugin types need an extra prefix to make the name easy to understand. switch ($type) { case 'quiz': $prefix = get_string('quizreport', 'quiz') . ': '; break; case 'repository': $prefix = get_string('repository', 'repository') . ': '; break; case 'gradeimport': $prefix = get_string('gradeimport', 'grades') . ': '; break; case 'gradeexport': $prefix = get_string('gradeexport', 'grades') . ': '; break; case 'gradereport': $prefix = get_string('gradereport', 'grades') . ': '; break; case 'webservice': $prefix = get_string('webservice', 'webservice') . ': '; break; case 'block': $prefix = get_string('block') . ': '; break; case 'mod': $prefix = get_string('activity') . ': '; break; // Default case, just use the plugin name. default: $prefix = ''; } return $prefix . get_string('pluginname', $component); } /** * Gets the list of roles assigned to this context and up (parents) * from the aggregation of: * a) the list of roles that are visible on user profile page and participants page (profileroles setting) and; * b) if applicable, those roles that are assigned in the context. * * @param context $context * @return array */ function get_profile_roles(context $context) { global $CFG, $DB; // If the current user can assign roles, then they can see all roles on the profile and participants page, // provided the roles are assigned to at least 1 user in the context. If not, only the policy-defined roles. if (has_capability('moodle/role:assign', $context)) { $rolesinscope = array_keys(get_all_roles($context)); } else { $rolesinscope = empty($CFG->profileroles) ? [] : array_map('trim', explode(',', $CFG->profileroles)); } if (empty($rolesinscope)) { return []; } list($rallowed, $params) = $DB->get_in_or_equal($rolesinscope, SQL_PARAMS_NAMED, 'a'); list($contextlist, $cparams) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'p'); $params = array_merge($params, $cparams); if ($coursecontext = $context->get_course_context(false)) { $params['coursecontext'] = $coursecontext->id; } else { $params['coursecontext'] = 0; } $sql = "SELECT DISTINCT r.id, r.name, r.shortname, r.sortorder, rn.name AS coursealias FROM {role_assignments} ra, {role} r LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id) WHERE r.id = ra.roleid AND ra.contextid $contextlist AND r.id $rallowed ORDER BY r.sortorder ASC"; return $DB->get_records_sql($sql, $params); } /** * Gets the list of roles assigned to this context and up (parents) * * @param context $context * @param boolean $includeparents, false means without parents. * @return array */ function get_roles_used_in_context(context $context, $includeparents = true) { global $DB; if ($includeparents === true) { list($contextlist, $params) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'cl'); } else { list($contextlist, $params) = $DB->get_in_or_equal($context->id, SQL_PARAMS_NAMED, 'cl'); } if ($coursecontext = $context->get_course_context(false)) { $params['coursecontext'] = $coursecontext->id; } else { $params['coursecontext'] = 0; } $sql = "SELECT DISTINCT r.id, r.name, r.shortname, r.sortorder, rn.name AS coursealias FROM {role_assignments} ra, {role} r LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id) WHERE r.id = ra.roleid AND ra.contextid $contextlist ORDER BY r.sortorder ASC"; return $DB->get_records_sql($sql, $params); } /** * This function is used to print roles column in user profile page. * It is using the CFG->profileroles to limit the list to only interesting roles. * (The permission tab has full details of user role assignments.) * * @param int $userid * @param int $courseid * @return string */ function get_user_roles_in_course($userid, $courseid) { global $CFG, $DB; if ($courseid == SITEID) { $context = context_system::instance(); } else { $context = context_course::instance($courseid); } // If the current user can assign roles, then they can see all roles on the profile and participants page, // provided the roles are assigned to at least 1 user in the context. If not, only the policy-defined roles. if (has_capability('moodle/role:assign', $context)) { $rolesinscope = array_keys(get_all_roles($context)); } else { $rolesinscope = empty($CFG->profileroles) ? [] : array_map('trim', explode(',', $CFG->profileroles)); } if (empty($rolesinscope)) { return ''; } list($rallowed, $params) = $DB->get_in_or_equal($rolesinscope, SQL_PARAMS_NAMED, 'a'); list($contextlist, $cparams) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'p'); $params = array_merge($params, $cparams); if ($coursecontext = $context->get_course_context(false)) { $params['coursecontext'] = $coursecontext->id; } else { $params['coursecontext'] = 0; } $sql = "SELECT DISTINCT r.id, r.name, r.shortname, r.sortorder, rn.name AS coursealias FROM {role_assignments} ra, {role} r LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id) WHERE r.id = ra.roleid AND ra.contextid $contextlist AND r.id $rallowed AND ra.userid = :userid ORDER BY r.sortorder ASC"; $params['userid'] = $userid; $rolestring = ''; if ($roles = $DB->get_records_sql($sql, $params)) { $viewableroles = get_viewable_roles($context, $userid); $rolenames = array(); foreach ($roles as $roleid => $unused) { if (isset($viewableroles[$roleid])) { $url = new moodle_url('/user/index.php', ['contextid' => $context->id, 'roleid' => $roleid]); $rolenames[] = '<a href="' . $url . '">' . $viewableroles[$roleid] . '</a>'; } } $rolestring = implode(', ', $rolenames); } return $rolestring; } /** * Checks if a user can assign users to a particular role in this context * * @param context $context * @param int $targetroleid - the id of the role you want to assign users to * @return boolean */ function user_can_assign(context $context, $targetroleid) { global $DB; // First check to see if the user is a site administrator. if (is_siteadmin()) { return true; } // Check if user has override capability. // If not return false. if (!has_capability('moodle/role:assign', $context)) { return false; } // pull out all active roles of this user from this context(or above) if ($userroles = get_user_roles($context)) { foreach ($userroles as $userrole) { // if any in the role_allow_override table, then it's ok if ($DB->get_record('role_allow_assign', array('roleid'=>$userrole->roleid, 'allowassign'=>$targetroleid))) { return true; } } } return false; } /** * Returns all site roles in correct sort order. * * Note: this method does not localise role names or descriptions, * use role_get_names() if you need role names. * * @param context $context optional context for course role name aliases * @return array of role records with optional coursealias property */ function get_all_roles(context $context = null) { global $DB; if (!$context or !$coursecontext = $context->get_course_context(false)) { $coursecontext = null; } if ($coursecontext) { $sql = "SELECT r.*, rn.name AS coursealias FROM {role} r LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id) ORDER BY r.sortorder ASC"; return $DB->get_records_sql($sql, array('coursecontext'=>$coursecontext->id)); } else { return $DB->get_records('role', array(), 'sortorder ASC'); } } /** * Returns roles of a specified archetype * * @param string $archetype * @return array of full role records */ function get_archetype_roles($archetype) { global $DB; return $DB->get_records('role', array('archetype'=>$archetype), 'sortorder ASC'); } /** * Gets all the user roles assigned in this context, or higher contexts for a list of users. * * If you try using the combination $userids = [], $checkparentcontexts = true then this is likely * to cause an out-of-memory error on large Moodle sites, so this combination is deprecated and * outputs a warning, even though it is the default. * * @param context $context * @param array $userids. An empty list means fetch all role assignments for the context. * @param bool $checkparentcontexts defaults to true * @param string $order defaults to 'c.contextlevel DESC, r.sortorder ASC' * @return array */ function get_users_roles(context $context, $userids = [], $checkparentcontexts = true, $order = 'c.contextlevel DESC, r.sortorder ASC') { global $DB; if (!$userids && $checkparentcontexts) { debugging('Please do not call get_users_roles() with $checkparentcontexts = true ' . 'and $userids array not set. This combination causes large Moodle sites ' . 'with lots of site-wide role assignemnts to run out of memory.', DEBUG_DEVELOPER); } if ($checkparentcontexts) { $contextids = $context->get_parent_context_ids(); } else { $contextids = array(); } $contextids[] = $context->id; list($contextids, $params) = $DB->get_in_or_equal($contextids, SQL_PARAMS_NAMED, 'con'); // If userids was passed as an empty array, we fetch all role assignments for the course. if (empty($userids)) { $useridlist = ' IS NOT NULL '; $uparams = []; } else { list($useridlist, $uparams) = $DB->get_in_or_equal($userids, SQL_PARAMS_NAMED, 'uids'); } $sql = "SELECT ra.*, r.name, r.shortname, ra.userid FROM {role_assignments} ra, {role} r, {context} c WHERE ra.userid $useridlist AND ra.roleid = r.id AND ra.contextid = c.id AND ra.contextid $contextids ORDER BY $order"; $all = $DB->get_records_sql($sql , array_merge($params, $uparams)); // Return results grouped by userid. $result = []; foreach ($all as $id => $record) { if (!isset($result[$record->userid])) { $result[$record->userid] = []; } $result[$record->userid][$record->id] = $record; } // Make sure all requested users are included in the result, even if they had no role assignments. foreach ($userids as $id) { if (!isset($result[$id])) { $result[$id] = []; } } return $result; } /** * Gets all the user roles assigned in this context, or higher contexts * this is mainly used when checking if a user can assign a role, or overriding a role * i.e. we need to know what this user holds, in order to verify against allow_assign and * allow_override tables * * @param context $context * @param int $userid * @param bool $checkparentcontexts defaults to true * @param string $order defaults to 'c.contextlevel DESC, r.sortorder ASC' * @return array */ function get_user_roles(context $context, $userid = 0, $checkparentcontexts = true, $order = 'c.contextlevel DESC, r.sortorder ASC') { global $USER, $DB; if (empty($userid)) { if (empty($USER->id)) { return array(); } $userid = $USER->id; } if ($checkparentcontexts) { $contextids = $context->get_parent_context_ids(); } else { $contextids = array(); } $contextids[] = $context->id; list($contextids, $params) = $DB->get_in_or_equal($contextids, SQL_PARAMS_QM); array_unshift($params, $userid); $sql = "SELECT ra.*, r.name, r.shortname FROM {role_assignments} ra, {role} r, {context} c WHERE ra.userid = ? AND ra.roleid = r.id AND ra.contextid = c.id AND ra.contextid $contextids ORDER BY $order"; return $DB->get_records_sql($sql ,$params); } /** * Like get_user_roles, but adds in the authenticated user role, and the front * page roles, if applicable. * * @param context $context the context. * @param int $userid optional. Defaults to $USER->id * @return array of objects with fields ->userid, ->contextid and ->roleid. */ function get_user_roles_with_special(context $context, $userid = 0) { global $CFG, $USER; if (empty($userid)) { if (empty($USER->id)) { return array(); } $userid = $USER->id; } $ras = get_user_roles($context, $userid); // Add front-page role if relevant. $defaultfrontpageroleid = isset($CFG->defaultfrontpageroleid) ? $CFG->defaultfrontpageroleid : 0; $isfrontpage = ($context->contextlevel == CONTEXT_COURSE && $context->instanceid == SITEID) || is_inside_frontpage($context); if ($defaultfrontpageroleid && $isfrontpage) { $frontpagecontext = context_course::instance(SITEID); $ra = new stdClass(); $ra->userid = $userid; $ra->contextid = $frontpagecontext->id; $ra->roleid = $defaultfrontpageroleid; $ras[] = $ra; } // Add authenticated user role if relevant. $defaultuserroleid = isset($CFG->defaultuserroleid) ? $CFG->defaultuserroleid : 0; if ($defaultuserroleid && !isguestuser($userid)) { $systemcontext = context_system::instance(); $ra = new stdClass(); $ra->userid = $userid; $ra->contextid = $systemcontext->id; $ra->roleid = $defaultuserroleid; $ras[] = $ra; } return $ras; } /** * Creates a record in the role_allow_override table * * @param int $fromroleid source roleid * @param int $targetroleid target roleid * @return void */ function core_role_set_override_allowed($fromroleid, $targetroleid) { global $DB; $record = new stdClass(); $record->roleid = $fromroleid; $record->allowoverride = $targetroleid; $DB->insert_record('role_allow_override', $record); } /** * Creates a record in the role_allow_assign table * * @param int $fromroleid source roleid * @param int $targetroleid target roleid * @return void */ function core_role_set_assign_allowed($fromroleid, $targetroleid) { global $DB; $record = new stdClass(); $record->roleid = $fromroleid; $record->allowassign = $targetroleid; $DB->insert_record('role_allow_assign', $record); } /** * Creates a record in the role_allow_switch table * * @param int $fromroleid source roleid * @param int $targetroleid target roleid * @return void */ function core_role_set_switch_allowed($fromroleid, $targetroleid) { global $DB; $record = new stdClass(); $record->roleid = $fromroleid; $record->allowswitch = $targetroleid; $DB->insert_record('role_allow_switch', $record); } /** * Creates a record in the role_allow_view table * * @param int $fromroleid source roleid * @param int $targetroleid target roleid * @return void */ function core_role_set_view_allowed($fromroleid, $targetroleid) { global $DB; $record = new stdClass(); $record->roleid = $fromroleid; $record->allowview = $targetroleid; $DB->insert_record('role_allow_view', $record); } /** * Gets a list of roles that this user can assign in this context * * @param context $context the context. * @param int $rolenamedisplay the type of role name to display. One of the * ROLENAME_X constants. Default ROLENAME_ALIAS. * @param bool $withusercounts if true, count the number of users with each role. * @param integer|object $user A user id or object. By default (null) checks the permissions of the current user. * @return array if $withusercounts is false, then an array $roleid => $rolename. * if $withusercounts is true, returns a list of three arrays, * $rolenames, $rolecounts, and $nameswithcounts. */ function get_assignable_roles(context $context, $rolenamedisplay = ROLENAME_ALIAS, $withusercounts = false, $user = null) { global $USER, $DB; // make sure there is a real user specified if ($user === null) { $userid = isset($USER->id) ? $USER->id : 0; } else { $userid = is_object($user) ? $user->id : $user; } if (!has_capability('moodle/role:assign', $context, $userid)) { if ($withusercounts) { return array(array(), array(), array()); } else { return array(); } } $params = array(); $extrafields = ''; if ($withusercounts) { $extrafields = ', (SELECT COUNT(DISTINCT u.id) FROM {role_assignments} cra JOIN {user} u ON cra.userid = u.id WHERE cra.roleid = r.id AND cra.contextid = :conid AND u.deleted = 0 ) AS usercount'; $params['conid'] = $context->id; } if (is_siteadmin($userid)) { // show all roles allowed in this context to admins $assignrestriction = ""; } else { $parents = $context->get_parent_context_ids(true); $contexts = implode(',' , $parents); $assignrestriction = "JOIN (SELECT DISTINCT raa.allowassign AS id FROM {role_allow_assign} raa JOIN {role_assignments} ra ON ra.roleid = raa.roleid WHERE ra.userid = :userid AND ra.contextid IN ($contexts) ) ar ON ar.id = r.id"; $params['userid'] = $userid; } $params['contextlevel'] = $context->contextlevel; if ($coursecontext = $context->get_course_context(false)) { $params['coursecontext'] = $coursecontext->id; } else { $params['coursecontext'] = 0; // no course aliases $coursecontext = null; } $sql = "SELECT r.id, r.name, r.shortname, rn.name AS coursealias $extrafields FROM {role} r $assignrestriction JOIN {role_context_levels} rcl ON (rcl.contextlevel = :contextlevel AND r.id = rcl.roleid) LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id) ORDER BY r.sortorder ASC"; $roles = $DB->get_records_sql($sql, $params); $rolenames = role_fix_names($roles, $coursecontext, $rolenamedisplay, true); if (!$withusercounts) { return $rolenames; } $rolecounts = array(); $nameswithcounts = array(); foreach ($roles as $role) { $nameswithcounts[$role->id] = $rolenames[$role->id] . ' (' . $roles[$role->id]->usercount . ')'; $rolecounts[$role->id] = $roles[$role->id]->usercount; } return array($rolenames, $rolecounts, $nameswithcounts); } /** * Gets a list of roles that this user can switch to in a context * * Gets a list of roles that this user can switch to in a context, for the switchrole menu. * This function just process the contents of the role_allow_switch table. You also need to * test the moodle/role:switchroles to see if the user is allowed to switch in the first place. * * @param context $context a context. * @param int $rolenamedisplay the type of role name to display. One of the * ROLENAME_X constants. Default ROLENAME_ALIAS. * @return array an array $roleid => $rolename. */ function get_switchable_roles(context $context, $rolenamedisplay = ROLENAME_ALIAS) { global $USER, $DB; // You can't switch roles without this capability. if (!has_capability('moodle/role:switchroles', $context)) { return []; } $params = array(); $extrajoins = ''; $extrawhere = ''; if (!is_siteadmin()) { // Admins are allowed to switch to any role with. // Others are subject to the additional constraint that the switch-to role must be allowed by // 'role_allow_switch' for some role they have assigned in this context or any parent. $parents = $context->get_parent_context_ids(true); $contexts = implode(',' , $parents); $extrajoins = "JOIN {role_allow_switch} ras ON ras.allowswitch = rc.roleid JOIN {role_assignments} ra ON ra.roleid = ras.roleid"; $extrawhere = "WHERE ra.userid = :userid AND ra.contextid IN ($contexts)"; $params['userid'] = $USER->id; } if ($coursecontext = $context->get_course_context(false)) { $params['coursecontext'] = $coursecontext->id; } else { $params['coursecontext'] = 0; // no course aliases $coursecontext = null; } $query = " SELECT r.id, r.name, r.shortname, rn.name AS coursealias FROM (SELECT DISTINCT rc.roleid FROM {role_capabilities} rc $extrajoins $extrawhere) idlist JOIN {role} r ON r.id = idlist.roleid LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id) ORDER BY r.sortorder"; $roles = $DB->get_records_sql($query, $params); return role_fix_names($roles, $context, $rolenamedisplay, true); } /** * Gets a list of roles that this user can view in a context * * @param context $context a context. * @param int $userid id of user. * @param int $rolenamedisplay the type of role name to display. One of the * ROLENAME_X constants. Default ROLENAME_ALIAS. * @return array an array $roleid => $rolename. */ function get_viewable_roles(context $context, $userid = null, $rolenamedisplay = ROLENAME_ALIAS) { global $USER, $DB; if ($userid == null) { $userid = $USER->id; } $params = array(); $extrajoins = ''; $extrawhere = ''; if (!is_siteadmin()) { // Admins are allowed to view any role. // Others are subject to the additional constraint that the view role must be allowed by // 'role_allow_view' for some role they have assigned in this context or any parent. $contexts = $context->get_parent_context_ids(true); list($insql, $inparams) = $DB->get_in_or_equal($contexts, SQL_PARAMS_NAMED); $extrajoins = "JOIN {role_allow_view} ras ON ras.allowview = r.id JOIN {role_assignments} ra ON ra.roleid = ras.roleid"; $extrawhere = "WHERE ra.userid = :userid AND ra.contextid $insql"; $params += $inparams; $params['userid'] = $userid; } if ($coursecontext = $context->get_course_context(false)) { $params['coursecontext'] = $coursecontext->id; } else { $params['coursecontext'] = 0; // No course aliases. $coursecontext = null; } $query = " SELECT r.id, r.name, r.shortname, rn.name AS coursealias, r.sortorder FROM {role} r $extrajoins LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id) $extrawhere GROUP BY r.id, r.name, r.shortname, rn.name, r.sortorder ORDER BY r.sortorder"; $roles = $DB->get_records_sql($query, $params); return role_fix_names($roles, $context, $rolenamedisplay, true); } /** * Gets a list of roles that this user can override in this context. * * @param context $context the context. * @param int $rolenamedisplay the type of role name to display. One of the * ROLENAME_X constants. Default ROLENAME_ALIAS. * @param bool $withcounts if true, count the number of overrides that are set for each role. * @return array if $withcounts is false, then an array $roleid => $rolename. * if $withusercounts is true, returns a list of three arrays, * $rolenames, $rolecounts, and $nameswithcounts. */ function get_overridable_roles(context $context, $rolenamedisplay = ROLENAME_ALIAS, $withcounts = false) { global $USER, $DB; if (!has_any_capability(array('moodle/role:safeoverride', 'moodle/role:override'), $context)) { if ($withcounts) { return array(array(), array(), array()); } else { return array(); } } $parents = $context->get_parent_context_ids(true); $contexts = implode(',' , $parents); $params = array(); $extrafields = ''; $params['userid'] = $USER->id; if ($withcounts) { $extrafields = ', (SELECT COUNT(rc.id) FROM {role_capabilities} rc WHERE rc.roleid = ro.id AND rc.contextid = :conid) AS overridecount'; $params['conid'] = $context->id; } if ($coursecontext = $context->get_course_context(false)) { $params['coursecontext'] = $coursecontext->id; } else { $params['coursecontext'] = 0; // no course aliases $coursecontext = null; } if (is_siteadmin()) { // show all roles to admins $roles = $DB->get_records_sql(" SELECT ro.id, ro.name, ro.shortname, rn.name AS coursealias $extrafields FROM {role} ro LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = ro.id) ORDER BY ro.sortorder ASC", $params); } else { $roles = $DB->get_records_sql(" SELECT ro.id, ro.name, ro.shortname, rn.name AS coursealias $extrafields FROM {role} ro JOIN (SELECT DISTINCT r.id FROM {role} r JOIN {role_allow_override} rao ON r.id = rao.allowoverride JOIN {role_assignments} ra ON rao.roleid = ra.roleid WHERE ra.userid = :userid AND ra.contextid IN ($contexts) ) inline_view ON ro.id = inline_view.id LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = ro.id) ORDER BY ro.sortorder ASC", $params); } $rolenames = role_fix_names($roles, $context, $rolenamedisplay, true); if (!$withcounts) { return $rolenames; } $rolecounts = array(); $nameswithcounts = array(); foreach ($roles as $role) { $nameswithcounts[$role->id] = $rolenames[$role->id] . ' (' . $roles[$role->id]->overridecount . ')'; $rolecounts[$role->id] = $roles[$role->id]->overridecount; } return array($rolenames, $rolecounts, $nameswithcounts); } /** * Create a role menu suitable for default role selection in enrol plugins. * * @package core_enrol * * @param context $context * @param int $addroleid current or default role - always added to list * @return array roleid=>localised role name */ function get_default_enrol_roles(context $context, $addroleid = null) { global $DB; $params = array('contextlevel'=>CONTEXT_COURSE); if ($coursecontext = $context->get_course_context(false)) { $params['coursecontext'] = $coursecontext->id; } else { $params['coursecontext'] = 0; // no course names $coursecontext = null; } if ($addroleid) { $addrole = "OR r.id = :addroleid"; $params['addroleid'] = $addroleid; } else { $addrole = ""; } $sql = "SELECT r.id, r.name, r.shortname, rn.name AS coursealias FROM {role} r LEFT JOIN {role_context_levels} rcl ON (rcl.roleid = r.id AND rcl.contextlevel = :contextlevel) LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id) WHERE rcl.id IS NOT NULL $addrole ORDER BY sortorder DESC"; $roles = $DB->get_records_sql($sql, $params); return role_fix_names($roles, $context, ROLENAME_BOTH, true); } /** * Return context levels where this role is assignable. * * @param integer $roleid the id of a role. * @return array list of the context levels at which this role may be assigned. */ function get_role_contextlevels($roleid) { global $DB; return $DB->get_records_menu('role_context_levels', array('roleid' => $roleid), 'contextlevel', 'id,contextlevel'); } /** * Return roles suitable for assignment at the specified context level. * * NOTE: this function name looks like a typo, should be probably get_roles_for_contextlevel() * * @param integer $contextlevel a contextlevel. * @return array list of role ids that are assignable at this context level. */ function get_roles_for_contextlevels($contextlevel) { global $DB; return $DB->get_records_menu('role_context_levels', array('contextlevel' => $contextlevel), '', 'id,roleid'); } /** * Returns default context levels where roles can be assigned. * * @param string $rolearchetype one of the role archetypes - that is, one of the keys * from the array returned by get_role_archetypes(); * @return array list of the context levels at which this type of role may be assigned by default. */ function get_default_contextlevels($rolearchetype) { static $defaults = array( 'manager' => array(CONTEXT_SYSTEM, CONTEXT_COURSECAT, CONTEXT_COURSE), 'coursecreator' => array(CONTEXT_SYSTEM, CONTEXT_COURSECAT), 'editingteacher' => array(CONTEXT_COURSE, CONTEXT_MODULE), 'teacher' => array(CONTEXT_COURSE, CONTEXT_MODULE), 'student' => array(CONTEXT_COURSE, CONTEXT_MODULE), 'guest' => array(), 'user' => array(), 'frontpage' => array()); if (isset($defaults[$rolearchetype])) { return $defaults[$rolearchetype]; } else { return array(); } } /** * Set the context levels at which a particular role can be assigned. * Throws exceptions in case of error. * * @param integer $roleid the id of a role. * @param array $contextlevels the context levels at which this role should be assignable, * duplicate levels are removed. * @return void */ function set_role_contextlevels($roleid, array $contextlevels) { global $DB; $DB->delete_records('role_context_levels', array('roleid' => $roleid)); $rcl = new stdClass(); $rcl->roleid = $roleid; $contextlevels = array_unique($contextlevels); foreach ($contextlevels as $level) { $rcl->contextlevel = $level; $DB->insert_record('role_context_levels', $rcl, false, true); } } /** * Gets sql joins for finding users with capability in the given context. * * @param context $context Context for the join. * @param string|array $capability Capability name or array of names. * If an array is provided then this is the equivalent of a logical 'OR', * i.e. the user needs to have one of these capabilities. * @param string $useridcolumn e.g. 'u.id'. * @return \core\dml\sql_join Contains joins, wheres, params. * This function will set ->cannotmatchanyrows if applicable. * This may let you skip doing a DB query. */ function get_with_capability_join(context $context, $capability, $useridcolumn) { global $CFG, $DB; // Add a unique prefix to param names to ensure they are unique. static $i = 0; $i++; $paramprefix = 'eu' . $i . '_'; $defaultuserroleid = isset($CFG->defaultuserroleid) ? $CFG->defaultuserroleid : 0; $defaultfrontpageroleid = isset($CFG->defaultfrontpageroleid) ? $CFG->defaultfrontpageroleid : 0; $ctxids = trim($context->path, '/'); $ctxids = str_replace('/', ',', $ctxids); // Context is the frontpage $isfrontpage = $context->contextlevel == CONTEXT_COURSE && $context->instanceid == SITEID; $isfrontpage = $isfrontpage || is_inside_frontpage($context); $caps = (array) $capability; // Construct list of context paths bottom --> top. list($contextids, $paths) = get_context_info_list($context); // We need to find out all roles that have these capabilities either in definition or in overrides. $defs = []; list($incontexts, $params) = $DB->get_in_or_equal($contextids, SQL_PARAMS_NAMED, $paramprefix . 'con'); list($incaps, $params2) = $DB->get_in_or_equal($caps, SQL_PARAMS_NAMED, $paramprefix . 'cap'); // Check whether context locking is enabled. // Filter out any write capability if this is the case. $excludelockedcaps = ''; $excludelockedcapsparams = []; if (!empty($CFG->contextlocking) && $context->locked) { $excludelockedcaps = 'AND (cap.captype = :capread OR cap.name = :managelockscap)'; $excludelockedcapsparams['capread'] = 'read'; $excludelockedcapsparams['managelockscap'] = 'moodle/site:managecontextlocks'; } $params = array_merge($params, $params2, $excludelockedcapsparams); $sql = "SELECT rc.id, rc.roleid, rc.permission, rc.capability, ctx.path FROM {role_capabilities} rc JOIN {capabilities} cap ON rc.capability = cap.name JOIN {context} ctx on rc.contextid = ctx.id WHERE rc.contextid $incontexts AND rc.capability $incaps $excludelockedcaps"; $rcs = $DB->get_records_sql($sql, $params); foreach ($rcs as $rc) { $defs[$rc->capability][$rc->path][$rc->roleid] = $rc->permission; } // Go through the permissions bottom-->top direction to evaluate the current permission, // first one wins (prohibit is an exception that always wins). $access = []; foreach ($caps as $cap) { foreach ($paths as $path) { if (empty($defs[$cap][$path])) { continue; } foreach ($defs[$cap][$path] as $roleid => $perm) { if ($perm == CAP_PROHIBIT) { $access[$cap][$roleid] = CAP_PROHIBIT; continue; } if (!isset($access[$cap][$roleid])) { $access[$cap][$roleid] = (int)$perm; } } } } // Make lists of roles that are needed and prohibited in this context. $needed = []; // One of these is enough. $prohibited = []; // Must not have any of these. foreach ($caps as $cap) { if (empty($access[$cap])) { continue; } foreach ($access[$cap] as $roleid => $perm) { if ($perm == CAP_PROHIBIT) { unset($needed[$cap][$roleid]); $prohibited[$cap][$roleid] = true; } else if ($perm == CAP_ALLOW and empty($prohibited[$cap][$roleid])) { $needed[$cap][$roleid] = true; } } if (empty($needed[$cap]) or !empty($prohibited[$cap][$defaultuserroleid])) { // Easy, nobody has the permission. unset($needed[$cap]); unset($prohibited[$cap]); } else if ($isfrontpage and !empty($prohibited[$cap][$defaultfrontpageroleid])) { // Everybody is disqualified on the frontpage. unset($needed[$cap]); unset($prohibited[$cap]); } if (empty($prohibited[$cap])) { unset($prohibited[$cap]); } } if (empty($needed)) { // There can not be anybody if no roles match this request. return new \core\dml\sql_join('', '1 = 2', [], true); } if (empty($prohibited)) { // We can compact the needed roles. $n = []; foreach ($needed as $cap) { foreach ($cap as $roleid => $unused) { $n[$roleid] = true; } } $needed = ['any' => $n]; unset($n); } // Prepare query clauses. $wherecond = []; $params = []; $joins = []; $cannotmatchanyrows = false; // We never return deleted users or guest account. // Use a hack to get the deleted user column without an API change. $deletedusercolumn = substr($useridcolumn, 0, -2) . 'deleted'; $wherecond[] = "$deletedusercolumn = 0 AND $useridcolumn <> :{$paramprefix}guestid"; $params[$paramprefix . 'guestid'] = $CFG->siteguest; // Now add the needed and prohibited roles conditions as joins. if (!empty($needed['any'])) { // Simple case - there are no prohibits involved. if (!empty($needed['any'][$defaultuserroleid]) || ($isfrontpage && !empty($needed['any'][$defaultfrontpageroleid]))) { // Everybody. } else { $joins[] = "JOIN (SELECT DISTINCT userid FROM {role_assignments} WHERE contextid IN ($ctxids) AND roleid IN (" . implode(',', array_keys($needed['any'])) . ") ) ra ON ra.userid = $useridcolumn"; } } else { $unions = []; $everybody = false; foreach ($needed as $cap => $unused) { if (empty($prohibited[$cap])) { if (!empty($needed[$cap][$defaultuserroleid]) || ($isfrontpage && !empty($needed[$cap][$defaultfrontpageroleid]))) { $everybody = true; break; } else { $unions[] = "SELECT userid FROM {role_assignments} WHERE contextid IN ($ctxids) AND roleid IN (".implode(',', array_keys($needed[$cap])) .")"; } } else { if (!empty($prohibited[$cap][$defaultuserroleid]) || ($isfrontpage && !empty($prohibited[$cap][$defaultfrontpageroleid]))) { // Nobody can have this cap because it is prohibited in default roles. continue; } else if (!empty($needed[$cap][$defaultuserroleid]) || ($isfrontpage && !empty($needed[$cap][$defaultfrontpageroleid]))) { // Everybody except the prohibited - hiding does not matter. $unions[] = "SELECT id AS userid FROM {user} WHERE id NOT IN (SELECT userid FROM {role_assignments} WHERE contextid IN ($ctxids) AND roleid IN (" . implode(',', array_keys($prohibited[$cap])) . "))"; } else { $unions[] = "SELECT userid FROM {role_assignments} WHERE contextid IN ($ctxids) AND roleid IN (" . implode(',', array_keys($needed[$cap])) . ") AND userid NOT IN ( SELECT userid FROM {role_assignments} WHERE contextid IN ($ctxids) AND roleid IN (" . implode(',', array_keys($prohibited[$cap])) . "))"; } } } if (!$everybody) { if ($unions) { $joins[] = "JOIN ( SELECT DISTINCT userid FROM ( " . implode("\n UNION \n", $unions) . " ) us ) ra ON ra.userid = $useridcolumn"; } else { // Only prohibits found - nobody can be matched. $wherecond[] = "1 = 2"; $cannotmatchanyrows = true; } } } return new \core\dml\sql_join(implode("\n", $joins), implode(" AND ", $wherecond), $params, $cannotmatchanyrows); } /** * Who has this capability in this context? * * This can be a very expensive call - use sparingly and keep * the results if you are going to need them again soon. * * Note if $fields is empty this function attempts to get u.* * which can get rather large - and has a serious perf impact * on some DBs. * * @param context $context * @param string|array $capability - capability name(s) * @param string $fields - fields to be pulled. The user table is aliased to 'u'. u.id MUST be included. * @param string $sort - the sort order. Default is lastaccess time. * @param mixed $limitfrom - number of records to skip (offset) * @param mixed $limitnum - number of records to fetch * @param string|array $groups - single group or array of groups - only return * users who are in one of these group(s). * @param string|array $exceptions - list of users to exclude, comma separated or array * @param bool $notuseddoanything not used any more, admin accounts are never returned * @param bool $notusedview - use get_enrolled_sql() instead * @param bool $useviewallgroups if $groups is set the return users who * have capability both $capability and moodle/site:accessallgroups * in this context, as well as users who have $capability and who are * in $groups. * @return array of user records */ function get_users_by_capability(context $context, $capability, $fields = '', $sort = '', $limitfrom = '', $limitnum = '', $groups = '', $exceptions = '', $notuseddoanything = null, $notusedview = null, $useviewallgroups = false) { global $CFG, $DB; // Context is a course page other than the frontpage. $iscoursepage = $context->contextlevel == CONTEXT_COURSE && $context->instanceid != SITEID; // Set up default fields list if necessary. if (empty($fields)) { if ($iscoursepage) { $fields = 'u.*, ul.timeaccess AS lastaccess'; } else { $fields = 'u.*'; } } else { if ($CFG->debugdeveloper && strpos($fields, 'u.*') === false && strpos($fields, 'u.id') === false) { debugging('u.id must be included in the list of fields passed to get_users_by_capability().', DEBUG_DEVELOPER); } } // Set up default sort if necessary. if (empty($sort)) { // default to course lastaccess or just lastaccess if ($iscoursepage) { $sort = 'ul.timeaccess'; } else { $sort = 'u.lastaccess'; } } // Get the bits of SQL relating to capabilities. $sqljoin = get_with_capability_join($context, $capability, 'u.id'); if ($sqljoin->cannotmatchanyrows) { return []; } // Prepare query clauses. $wherecond = [$sqljoin->wheres]; $params = $sqljoin->params; $joins = [$sqljoin->joins]; // Add user lastaccess JOIN, if required. if ((strpos($sort, 'ul.timeaccess') === false) and (strpos($fields, 'ul.timeaccess') === false)) { // Here user_lastaccess is not required MDL-13810. } else { if ($iscoursepage) { $joins[] = "LEFT OUTER JOIN {user_lastaccess} ul ON (ul.userid = u.id AND ul.courseid = {$context->instanceid})"; } else { throw new coding_exception('Invalid sort in get_users_by_capability(), ul.timeaccess allowed only for course contexts.'); } } // Groups. if ($groups) { $groups = (array)$groups; list($grouptest, $grpparams) = $DB->get_in_or_equal($groups, SQL_PARAMS_NAMED, 'grp'); $joins[] = "LEFT OUTER JOIN (SELECT DISTINCT userid FROM {groups_members} WHERE groupid $grouptest ) gm ON gm.userid = u.id"; $params = array_merge($params, $grpparams); $grouptest = 'gm.userid IS NOT NULL'; if ($useviewallgroups) { $viewallgroupsusers = get_users_by_capability($context, 'moodle/site:accessallgroups', 'u.id, u.id', '', '', '', '', $exceptions); if (!empty($viewallgroupsusers)) { $grouptest .= ' OR u.id IN (' . implode(',', array_keys($viewallgroupsusers)) . ')'; } } $wherecond[] = "($grouptest)"; } // User exceptions. if (!empty($exceptions)) { $exceptions = (array)$exceptions; list($exsql, $exparams) = $DB->get_in_or_equal($exceptions, SQL_PARAMS_NAMED, 'exc', false); $params = array_merge($params, $exparams); $wherecond[] = "u.id $exsql"; } // Collect WHERE conditions and needed joins. $where = implode(' AND ', $wherecond); if ($where !== '') { $where = 'WHERE ' . $where; } $joins = implode("\n", $joins); // Finally! we have all the bits, run the query. $sql = "SELECT $fields FROM {user} u $joins $where ORDER BY $sort"; return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum); } /** * Re-sort a users array based on a sorting policy * * Will re-sort a $users results array (from get_users_by_capability(), usually) * based on a sorting policy. This is to support the odd practice of * sorting teachers by 'authority', where authority was "lowest id of the role * assignment". * * Will execute 1 database query. Only suitable for small numbers of users, as it * uses an u.id IN() clause. * * Notes about the sorting criteria. * * As a default, we cannot rely on role.sortorder because then * admins/coursecreators will always win. That is why the sane * rule "is locality matters most", with sortorder as 2nd * consideration. * * If you want role.sortorder, use the 'sortorder' policy, and * name explicitly what roles you want to cover. It's probably * a good idea to see what roles have the capabilities you want * (array_diff() them against roiles that have 'can-do-anything' * to weed out admin-ish roles. Or fetch a list of roles from * variables like $CFG->coursecontact . * * @param array $users Users array, keyed on userid * @param context $context * @param array $roles ids of the roles to include, optional * @param string $sortpolicy defaults to locality, more about * @return array sorted copy of the array */ function sort_by_roleassignment_authority($users, context $context, $roles = array(), $sortpolicy = 'locality') { global $DB; $userswhere = ' ra.userid IN (' . implode(',',array_keys($users)) . ')'; $contextwhere = 'AND ra.contextid IN ('.str_replace('/', ',',substr($context->path, 1)).')'; if (empty($roles)) { $roleswhere = ''; } else { $roleswhere = ' AND ra.roleid IN ('.implode(',',$roles).')'; } $sql = "SELECT ra.userid FROM {role_assignments} ra JOIN {role} r ON ra.roleid=r.id JOIN {context} ctx ON ra.contextid=ctx.id WHERE $userswhere $contextwhere $roleswhere"; // Default 'locality' policy -- read PHPDoc notes // about sort policies... $orderby = 'ORDER BY ' .'ctx.depth DESC, ' /* locality wins */ .'r.sortorder ASC, ' /* rolesorting 2nd criteria */ .'ra.id'; /* role assignment order tie-breaker */ if ($sortpolicy === 'sortorder') { $orderby = 'ORDER BY ' .'r.sortorder ASC, ' /* rolesorting 2nd criteria */ .'ra.id'; /* role assignment order tie-breaker */ } $sortedids = $DB->get_fieldset_sql($sql . $orderby); $sortedusers = array(); $seen = array(); foreach ($sortedids as $id) { // Avoid duplicates if (isset($seen[$id])) { continue; } $seen[$id] = true; // assign $sortedusers[$id] = $users[$id]; } return $sortedusers; } /** * Gets all the users assigned this role in this context or higher * * Note that moodle is based on capabilities and it is usually better * to check permissions than to check role ids as the capabilities * system is more flexible. If you really need, you can to use this * function but consider has_capability() as a possible substitute. * * All $sort fields are added into $fields if not present there yet. * * If $roleid is an array or is empty (all roles) you need to set $fields * (and $sort by extension) params according to it, as the first field * returned by the database should be unique (ra.id is the best candidate). * * @param int $roleid (can also be an array of ints!) * @param context $context * @param bool $parent if true, get list of users assigned in higher context too * @param string $fields fields from user (u.) , role assignment (ra) or role (r.) * @param string $sort sort from user (u.) , role assignment (ra.) or role (r.). * null => use default sort from users_order_by_sql. * @param bool $all true means all, false means limit to enrolled users * @param string $group defaults to '' * @param mixed $limitfrom defaults to '' * @param mixed $limitnum defaults to '' * @param string $extrawheretest defaults to '' * @param array $whereorsortparams any paramter values used by $sort or $extrawheretest. * @return array */ function get_role_users($roleid, context $context, $parent = false, $fields = '', $sort = null, $all = true, $group = '', $limitfrom = '', $limitnum = '', $extrawheretest = '', $whereorsortparams = array()) { global $DB; if (empty($fields)) { $userfieldsapi = \core_user\fields::for_name(); $allnames = $userfieldsapi->get_sql('u', false, '', '', false)->selects; $fields = 'u.id, u.confirmed, u.username, '. $allnames . ', ' . 'u.maildisplay, u.mailformat, u.maildigest, u.email, u.emailstop, u.city, '. 'u.country, u.picture, u.idnumber, u.department, u.institution, '. 'u.lang, u.timezone, u.lastaccess, u.mnethostid, r.name AS rolename, r.sortorder, '. 'r.shortname AS roleshortname, rn.name AS rolecoursealias'; } // Prevent wrong function uses. if ((empty($roleid) || is_array($roleid)) && strpos($fields, 'ra.id') !== 0) { debugging('get_role_users() without specifying one single roleid needs to be called prefixing ' . 'role assignments id (ra.id) as unique field, you can use $fields param for it.'); if (!empty($roleid)) { // Solving partially the issue when specifying multiple roles. $users = array(); foreach ($roleid as $id) { // Ignoring duplicated keys keeping the first user appearance. $users = $users + get_role_users($id, $context, $parent, $fields, $sort, $all, $group, $limitfrom, $limitnum, $extrawheretest, $whereorsortparams); } return $users; } } $parentcontexts = ''; if ($parent) { $parentcontexts = substr($context->path, 1); // kill leading slash $parentcontexts = str_replace('/', ',', $parentcontexts); if ($parentcontexts !== '') { $parentcontexts = ' OR ra.contextid IN ('.$parentcontexts.' )'; } } if ($roleid) { list($rids, $params) = $DB->get_in_or_equal($roleid, SQL_PARAMS_NAMED, 'r'); $roleselect = "AND ra.roleid $rids"; } else { $params = array(); $roleselect = ''; } if ($coursecontext = $context->get_course_context(false)) { $params['coursecontext'] = $coursecontext->id; } else { $params['coursecontext'] = 0; } if ($group) { $groupjoin = "JOIN {groups_members} gm ON gm.userid = u.id"; $groupselect = " AND gm.groupid = :groupid "; $params['groupid'] = $group; } else { $groupjoin = ''; $groupselect = ''; } $params['contextid'] = $context->id; if ($extrawheretest) { $extrawheretest = ' AND ' . $extrawheretest; } if ($whereorsortparams) { $params = array_merge($params, $whereorsortparams); } if (!$sort) { list($sort, $sortparams) = users_order_by_sql('u'); $params = array_merge($params, $sortparams); } // Adding the fields from $sort that are not present in $fields. $sortarray = preg_split('/,\s*/', $sort); $fieldsarray = preg_split('/,\s*/', $fields); // Discarding aliases from the fields. $fieldnames = array(); foreach ($fieldsarray as $key => $field) { list($fieldnames[$key]) = explode(' ', $field); } $addedfields = array(); foreach ($sortarray as $sortfield) { // Throw away any additional arguments to the sort (e.g. ASC/DESC). list($sortfield) = explode(' ', $sortfield); list($tableprefix) = explode('.', $sortfield); $fieldpresent = false; foreach ($fieldnames as $fieldname) { if ($fieldname === $sortfield || $fieldname === $tableprefix.'.*') { $fieldpresent = true; break; } } if (!$fieldpresent) { $fieldsarray[] = $sortfield; $addedfields[] = $sortfield; } } $fields = implode(', ', $fieldsarray); if (!empty($addedfields)) { $addedfields = implode(', ', $addedfields); debugging('get_role_users() adding '.$addedfields.' to the query result because they were required by $sort but missing in $fields'); } if ($all === null) { // Previously null was used to indicate that parameter was not used. $all = true; } if (!$all and $coursecontext) { // Do not use get_enrolled_sql() here for performance reasons. $ejoin = "JOIN {user_enrolments} ue ON ue.userid = u.id JOIN {enrol} e ON (e.id = ue.enrolid AND e.courseid = :ecourseid)"; $params['ecourseid'] = $coursecontext->instanceid; } else { $ejoin = ""; } $sql = "SELECT DISTINCT $fields, ra.roleid FROM {role_assignments} ra JOIN {user} u ON u.id = ra.userid JOIN {role} r ON ra.roleid = r.id $ejoin LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id) $groupjoin WHERE (ra.contextid = :contextid $parentcontexts) $roleselect $groupselect $extrawheretest ORDER BY $sort"; // join now so that we can just use fullname() later return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum); } /** * Counts all the users assigned this role in this context or higher * * @param int|array $roleid either int or an array of ints * @param context $context * @param bool $parent if true, get list of users assigned in higher context too * @return int Returns the result count */ function count_role_users($roleid, context $context, $parent = false) { global $DB; if ($parent) { if ($contexts = $context->get_parent_context_ids()) { $parentcontexts = ' OR r.contextid IN ('.implode(',', $contexts).')'; } else { $parentcontexts = ''; } } else { $parentcontexts = ''; } if ($roleid) { list($rids, $params) = $DB->get_in_or_equal($roleid, SQL_PARAMS_QM); $roleselect = "AND r.roleid $rids"; } else { $params = array(); $roleselect = ''; } array_unshift($params, $context->id); $sql = "SELECT COUNT(DISTINCT u.id) FROM {role_assignments} r JOIN {user} u ON u.id = r.userid WHERE (r.contextid = ? $parentcontexts) $roleselect AND u.deleted = 0"; return $DB->count_records_sql($sql, $params); } /** * This function gets the list of course and course category contexts that this user has a particular capability in. * * It is now reasonably efficient, but bear in mind that if there are users who have the capability * everywhere, it may return an array of all contexts. * * @param string $capability Capability in question * @param int $userid User ID or null for current user * @param bool $getcategories Wether to return also course_categories * @param bool $doanything True if 'doanything' is permitted (default) * @param string $coursefieldsexceptid Leave blank if you only need 'id' in the course records; * otherwise use a comma-separated list of the fields you require, not including id. * Add ctxid, ctxpath, ctxdepth etc to return course context information for preloading. * @param string $categoryfieldsexceptid Leave blank if you only need 'id' in the course records; * otherwise use a comma-separated list of the fields you require, not including id. * Add ctxid, ctxpath, ctxdepth etc to return course context information for preloading. * @param string $courseorderby If set, use a comma-separated list of fields from course * table with sql modifiers (DESC) if needed * @param string $categoryorderby If set, use a comma-separated list of fields from course_category * table with sql modifiers (DESC) if needed * @param int $limit Limit the number of courses to return on success. Zero equals all entries. * @return array Array of categories and courses. */ function get_user_capability_contexts(string $capability, bool $getcategories, $userid = null, $doanything = true, $coursefieldsexceptid = '', $categoryfieldsexceptid = '', $courseorderby = '', $categoryorderby = '', $limit = 0): array { global $DB, $USER; // Default to current user. if (!$userid) { $userid = $USER->id; }
> if (!$capinfo = get_capability_info($capability)) { if ($doanything && is_siteadmin($userid)) { > debugging('Capability "'.$capability.'" was not found! This has to be fixed in code.'); // If the user is a site admin and $doanything is enabled then there is no need to restrict > return [false, false]; // the list of courses. > } $contextlimitsql = ''; >
$contextlimitparams = []; } else { // Gets SQL to limit contexts ('x' table) to those where the user has this capability. list ($contextlimitsql, $contextlimitparams) = \core\access\get_user_capability_course_helper::get_sql(
< $userid, $capability);
> $userid, $capinfo->name);
if (!$contextlimitsql) { // If the does not have this capability in any context, return false without querying. return [false, false]; } $contextlimitsql = 'WHERE' . $contextlimitsql; } $categories = []; if ($getcategories) { $fieldlist = \core\access\get_user_capability_course_helper::map_fieldnames($categoryfieldsexceptid); if ($categoryorderby) { $fields = explode(',', $categoryorderby); $categoryorderby = ''; foreach ($fields as $field) { if ($categoryorderby) { $categoryorderby .= ','; } $categoryorderby .= 'c.'.$field; } $categoryorderby = 'ORDER BY '.$categoryorderby; } $rs = $DB->get_recordset_sql(" SELECT c.id $fieldlist FROM {course_categories} c JOIN {context} x ON c.id = x.instanceid AND x.contextlevel = ? $contextlimitsql $categoryorderby", array_merge([CONTEXT_COURSECAT], $contextlimitparams)); $basedlimit = $limit; foreach ($rs as $category) { $categories[] = $category; $basedlimit--; if ($basedlimit == 0) { break; } } $rs->close(); } $courses = []; $fieldlist = \core\access\get_user_capability_course_helper::map_fieldnames($coursefieldsexceptid); if ($courseorderby) { $fields = explode(',', $courseorderby); $courseorderby = ''; foreach ($fields as $field) { if ($courseorderby) { $courseorderby .= ','; } $courseorderby .= 'c.'.$field; } $courseorderby = 'ORDER BY '.$courseorderby; } $rs = $DB->get_recordset_sql(" SELECT c.id $fieldlist FROM {course} c JOIN {context} x ON c.id = x.instanceid AND x.contextlevel = ? $contextlimitsql $courseorderby", array_merge([CONTEXT_COURSE], $contextlimitparams)); foreach ($rs as $course) { $courses[] = $course; $limit--; if ($limit == 0) { break; } } $rs->close(); return [$categories, $courses]; } /** * This function gets the list of courses that this user has a particular capability in. * * It is now reasonably efficient, but bear in mind that if there are users who have the capability * everywhere, it may return an array of all courses. * * @param string $capability Capability in question * @param int $userid User ID or null for current user * @param bool $doanything True if 'doanything' is permitted (default) * @param string $fieldsexceptid Leave blank if you only need 'id' in the course records; * otherwise use a comma-separated list of the fields you require, not including id. * Add ctxid, ctxpath, ctxdepth etc to return course context information for preloading. * @param string $orderby If set, use a comma-separated list of fields from course * table with sql modifiers (DESC) if needed * @param int $limit Limit the number of courses to return on success. Zero equals all entries. * @return array|bool Array of courses, if none found false is returned. */ function get_user_capability_course($capability, $userid = null, $doanything = true, $fieldsexceptid = '', $orderby = '', $limit = 0) { list($categories, $courses) = get_user_capability_contexts( $capability, false, $userid, $doanything, $fieldsexceptid, '', $orderby, '', $limit ); return $courses; } /** * Switches the current user to another role for the current session and only * in the given context. * * The caller *must* check * - that this op is allowed * - that the requested role can be switched to in this context (use get_switchable_roles) * - that the requested role is NOT $CFG->defaultuserroleid * * To "unswitch" pass 0 as the roleid. * * This function *will* modify $USER->access - beware * * @param integer $roleid the role to switch to. * @param context $context the context in which to perform the switch. * @return bool success or failure. */ function role_switch($roleid, context $context) { global $USER; // Add the ghost RA to $USER->access as $USER->access['rsw'][$path] = $roleid. // To un-switch just unset($USER->access['rsw'][$path]). // // Note: it is not possible to switch to roles that do not have course:view if (!isset($USER->access)) { load_all_capabilities(); } // Make sure that course index is refreshed. if ($coursecontext = $context->get_course_context()) { core_courseformat\base::session_cache_reset(get_course($coursecontext->instanceid)); } // Add the switch RA if ($roleid == 0) { unset($USER->access['rsw'][$context->path]); return true; } $USER->access['rsw'][$context->path] = $roleid; return true; } /** * Checks if the user has switched roles within the given course. * * Note: You can only switch roles within the course, hence it takes a course id * rather than a context. On that note Petr volunteered to implement this across * all other contexts, all requests for this should be forwarded to him ;) * * @param int $courseid The id of the course to check * @return bool True if the user has switched roles within the course. */ function is_role_switched($courseid) { global $USER; $context = context_course::instance($courseid, MUST_EXIST); return (!empty($USER->access['rsw'][$context->path])); } /** * Get any role that has an override on exact context * * @param context $context The context to check * @return array An array of roles */ function get_roles_with_override_on_context(context $context) { global $DB; return $DB->get_records_sql("SELECT r.* FROM {role_capabilities} rc, {role} r WHERE rc.roleid = r.id AND rc.contextid = ?", array($context->id)); } /** * Get all capabilities for this role on this context (overrides) * * @param stdClass $role * @param context $context * @return array */ function get_capabilities_from_role_on_context($role, context $context) { global $DB; return $DB->get_records_sql("SELECT * FROM {role_capabilities} WHERE contextid = ? AND roleid = ?", array($context->id, $role->id)); } /** * Find all user assignment of users for this role, on this context * * @param stdClass $role * @param context $context * @return array */ function get_users_from_role_on_context($role, context $context) { global $DB; return $DB->get_records_sql("SELECT * FROM {role_assignments} WHERE contextid = ? AND roleid = ?", array($context->id, $role->id)); } /** * Simple function returning a boolean true if user has roles * in context or parent contexts, otherwise false. * * @param int $userid * @param int $roleid * @param int $contextid empty means any context * @return bool */ function user_has_role_assignment($userid, $roleid, $contextid = 0) { global $DB; if ($contextid) { if (!$context = context::instance_by_id($contextid, IGNORE_MISSING)) { return false; } $parents = $context->get_parent_context_ids(true); list($contexts, $params) = $DB->get_in_or_equal($parents, SQL_PARAMS_NAMED, 'r'); $params['userid'] = $userid; $params['roleid'] = $roleid; $sql = "SELECT COUNT(ra.id) FROM {role_assignments} ra WHERE ra.userid = :userid AND ra.roleid = :roleid AND ra.contextid $contexts"; $count = $DB->get_field_sql($sql, $params); return ($count > 0); } else { return $DB->record_exists('role_assignments', array('userid'=>$userid, 'roleid'=>$roleid)); } } /** * Get localised role name or alias if exists and format the text. * * @param stdClass $role role object * - optional 'coursealias' property should be included for performance reasons if course context used * - description property is not required here * @param context|bool $context empty means system context * @param int $rolenamedisplay type of role name * @return string localised role name or course role name alias */ function role_get_name(stdClass $role, $context = null, $rolenamedisplay = ROLENAME_ALIAS) { global $DB; if ($rolenamedisplay == ROLENAME_SHORT) { return $role->shortname; } if (!$context or !$coursecontext = $context->get_course_context(false)) { $coursecontext = null; } if ($coursecontext and !property_exists($role, 'coursealias') and ($rolenamedisplay == ROLENAME_ALIAS or $rolenamedisplay == ROLENAME_BOTH or $rolenamedisplay == ROLENAME_ALIAS_RAW)) { $role = clone($role); // Do not modify parameters. if ($r = $DB->get_record('role_names', array('roleid'=>$role->id, 'contextid'=>$coursecontext->id))) { $role->coursealias = $r->name; } else { $role->coursealias = null; } } if ($rolenamedisplay == ROLENAME_ALIAS_RAW) { if ($coursecontext) { return $role->coursealias; } else { return null; } } if (trim($role->name) !== '') { // For filtering always use context where was the thing defined - system for roles here. $original = format_string($role->name, true, array('context'=>context_system::instance())); } else { // Empty role->name means we want to see localised role name based on shortname, // only default roles are supposed to be localised. switch ($role->shortname) { case 'manager': $original = get_string('manager', 'role'); break; case 'coursecreator': $original = get_string('coursecreators'); break; case 'editingteacher': $original = get_string('defaultcourseteacher'); break; case 'teacher': $original = get_string('noneditingteacher'); break; case 'student': $original = get_string('defaultcoursestudent'); break; case 'guest': $original = get_string('guest'); break; case 'user': $original = get_string('authenticateduser'); break; case 'frontpage': $original = get_string('frontpageuser', 'role'); break; // We should not get here, the role UI should require the name for custom roles! default: $original = $role->shortname; break; } } if ($rolenamedisplay == ROLENAME_ORIGINAL) { return $original; } if ($rolenamedisplay == ROLENAME_ORIGINALANDSHORT) { return "$original ($role->shortname)"; } if ($rolenamedisplay == ROLENAME_ALIAS) {
< if ($coursecontext and trim($role->coursealias) !== '') {
> if ($coursecontext && $role->coursealias && trim($role->coursealias) !== '') {
return format_string($role->coursealias, true, array('context'=>$coursecontext)); } else { return $original; } } if ($rolenamedisplay == ROLENAME_BOTH) {
< if ($coursecontext and trim($role->coursealias) !== '') {
> if ($coursecontext && $role->coursealias && trim($role->coursealias) !== '') {
return format_string($role->coursealias, true, array('context'=>$coursecontext)) . " ($original)"; } else { return $original; } } throw new coding_exception('Invalid $rolenamedisplay parameter specified in role_get_name()'); } /** * Returns localised role description if available. * If the name is empty it tries to find the default role name using * hardcoded list of default role names or other methods in the future. * * @param stdClass $role * @return string localised role name */ function role_get_description(stdClass $role) { if (!html_is_blank($role->description)) { return format_text($role->description, FORMAT_HTML, array('context'=>context_system::instance())); } switch ($role->shortname) { case 'manager': return get_string('managerdescription', 'role'); case 'coursecreator': return get_string('coursecreatorsdescription'); case 'editingteacher': return get_string('defaultcourseteacherdescription'); case 'teacher': return get_string('noneditingteacherdescription'); case 'student': return get_string('defaultcoursestudentdescription'); case 'guest': return get_string('guestdescription'); case 'user': return get_string('authenticateduserdescription'); case 'frontpage': return get_string('frontpageuserdescription', 'role'); default: return ''; } } /** * Get all the localised role names for a context. * * In new installs default roles have empty names, this function * add localised role names using current language pack. * * @param context $context the context, null means system context * @param array of role objects with a ->localname field containing the context-specific role name. * @param int $rolenamedisplay * @param bool $returnmenu true means id=>localname, false means id=>rolerecord * @return array Array of context-specific role names, or role objects with a ->localname field added. */ function role_get_names(context $context = null, $rolenamedisplay = ROLENAME_ALIAS, $returnmenu = null) { return role_fix_names(get_all_roles($context), $context, $rolenamedisplay, $returnmenu); } /** * Prepare list of roles for display, apply aliases and localise default role names. * * @param array $roleoptions array roleid => roleobject (with optional coursealias), strings are accepted for backwards compatibility only * @param context $context the context, null means system context * @param int $rolenamedisplay * @param bool $returnmenu null means keep the same format as $roleoptions, true means id=>localname, false means id=>rolerecord * @return array Array of context-specific role names, or role objects with a ->localname field added. */ function role_fix_names($roleoptions, context $context = null, $rolenamedisplay = ROLENAME_ALIAS, $returnmenu = null) { global $DB; if (empty($roleoptions)) { return array(); } if (!$context or !$coursecontext = $context->get_course_context(false)) { $coursecontext = null; } // We usually need all role columns... $first = reset($roleoptions); if ($returnmenu === null) { $returnmenu = !is_object($first); } if (!is_object($first) or !property_exists($first, 'shortname')) { $allroles = get_all_roles($context); foreach ($roleoptions as $rid => $unused) { $roleoptions[$rid] = $allroles[$rid]; } } // Inject coursealias if necessary. if ($coursecontext and ($rolenamedisplay == ROLENAME_ALIAS_RAW or $rolenamedisplay == ROLENAME_ALIAS or $rolenamedisplay == ROLENAME_BOTH)) { $first = reset($roleoptions); if (!property_exists($first, 'coursealias')) { $aliasnames = $DB->get_records('role_names', array('contextid'=>$coursecontext->id)); foreach ($aliasnames as $alias) { if (isset($roleoptions[$alias->roleid])) { $roleoptions[$alias->roleid]->coursealias = $alias->name; } } } } // Add localname property. foreach ($roleoptions as $rid => $role) { $roleoptions[$rid]->localname = role_get_name($role, $coursecontext, $rolenamedisplay); } if (!$returnmenu) { return $roleoptions; } $menu = array(); foreach ($roleoptions as $rid => $role) { $menu[$rid] = $role->localname; } return $menu; } /** * Aids in detecting if a new line is required when reading a new capability * * This function helps admin/roles/manage.php etc to detect if a new line should be printed * when we read in a new capability. * Most of the time, if the 2 components are different we should print a new line, (e.g. course system->rss client) * but when we are in grade, all reports/import/export capabilities should be together * * @param string $cap component string a * @param string $comp component string b * @param int $contextlevel * @return bool whether 2 component are in different "sections" */ function component_level_changed($cap, $comp, $contextlevel) { if (strstr($cap->component, '/') && strstr($comp, '/')) { $compsa = explode('/', $cap->component); $compsb = explode('/', $comp); // list of system reports if (($compsa[0] == 'report') && ($compsb[0] == 'report')) { return false; } // we are in gradebook, still if (($compsa[0] == 'gradeexport' || $compsa[0] == 'gradeimport' || $compsa[0] == 'gradereport') && ($compsb[0] == 'gradeexport' || $compsb[0] == 'gradeimport' || $compsb[0] == 'gradereport')) { return false; } if (($compsa[0] == 'coursereport') && ($compsb[0] == 'coursereport')) { return false; } } return ($cap->component != $comp || $cap->contextlevel != $contextlevel); } /** * Fix the roles.sortorder field in the database, so it contains sequential integers, * and return an array of roleids in order. * * @param array $allroles array of roles, as returned by get_all_roles(); * @return array $role->sortorder =-> $role->id with the keys in ascending order. */ function fix_role_sortorder($allroles) { global $DB; $rolesort = array(); $i = 0; foreach ($allroles as $role) { $rolesort[$i] = $role->id; if ($role->sortorder != $i) { $r = new stdClass(); $r->id = $role->id; $r->sortorder = $i; $DB->update_record('role', $r); $allroles[$role->id]->sortorder = $i; } $i++; } return $rolesort; } /** * Switch the sort order of two roles (used in admin/roles/manage.php). * * @param stdClass $first The first role. Actually, only ->sortorder is used. * @param stdClass $second The second role. Actually, only ->sortorder is used. * @return boolean success or failure */ function switch_roles($first, $second) { global $DB; $temp = $DB->get_field('role', 'MAX(sortorder) + 1', array()); $result = $DB->set_field('role', 'sortorder', $temp, array('sortorder' => $first->sortorder)); $result = $result && $DB->set_field('role', 'sortorder', $first->sortorder, array('sortorder' => $second->sortorder)); $result = $result && $DB->set_field('role', 'sortorder', $second->sortorder, array('sortorder' => $temp)); return $result; } /** * Duplicates all the base definitions of a role * * @param stdClass $sourcerole role to copy from * @param int $targetrole id of role to copy to */ function role_cap_duplicate($sourcerole, $targetrole) { global $DB; $systemcontext = context_system::instance(); $caps = $DB->get_records_sql("SELECT * FROM {role_capabilities} WHERE roleid = ? AND contextid = ?", array($sourcerole->id, $systemcontext->id)); // adding capabilities foreach ($caps as $cap) { unset($cap->id); $cap->roleid = $targetrole; $DB->insert_record('role_capabilities', $cap); } // Reset any cache of this role, including MUC. accesslib_clear_role_cache($targetrole); } /** * Returns two lists, this can be used to find out if user has capability. * Having any needed role and no forbidden role in this context means * user has this capability in this context. * Use get_role_names_with_cap_in_context() if you need role names to display in the UI * * @param stdClass $context * @param string $capability * @return array($neededroles, $forbiddenroles) */ function get_roles_with_cap_in_context($context, $capability) { global $DB; $ctxids = trim($context->path, '/'); // kill leading slash $ctxids = str_replace('/', ',', $ctxids); $sql = "SELECT rc.id, rc.roleid, rc.permission, ctx.depth FROM {role_capabilities} rc JOIN {context} ctx ON ctx.id = rc.contextid JOIN {capabilities} cap ON rc.capability = cap.name WHERE rc.capability = :cap AND ctx.id IN ($ctxids) ORDER BY rc.roleid ASC, ctx.depth DESC"; $params = array('cap'=>$capability); if (!$capdefs = $DB->get_records_sql($sql, $params)) { // no cap definitions --> no capability return array(array(), array()); } $forbidden = array(); $needed = array(); foreach ($capdefs as $def) { if (isset($forbidden[$def->roleid])) { continue; } if ($def->permission == CAP_PROHIBIT) { $forbidden[$def->roleid] = $def->roleid; unset($needed[$def->roleid]); continue; } if (!isset($needed[$def->roleid])) { if ($def->permission == CAP_ALLOW) { $needed[$def->roleid] = true; } else if ($def->permission == CAP_PREVENT) { $needed[$def->roleid] = false; } } } unset($capdefs); // remove all those roles not allowing foreach ($needed as $key=>$value) { if (!$value) { unset($needed[$key]); } else { $needed[$key] = $key; } } return array($needed, $forbidden); } /** * Returns an array of role IDs that have ALL of the the supplied capabilities * Uses get_roles_with_cap_in_context(). Returns $allowed minus $forbidden * * @param stdClass $context * @param array $capabilities An array of capabilities * @return array of roles with all of the required capabilities */ function get_roles_with_caps_in_context($context, $capabilities) { $neededarr = array(); $forbiddenarr = array(); foreach ($capabilities as $caprequired) { list($neededarr[], $forbiddenarr[]) = get_roles_with_cap_in_context($context, $caprequired); } $rolesthatcanrate = array(); if (!empty($neededarr)) { foreach ($neededarr as $needed) { if (empty($rolesthatcanrate)) { $rolesthatcanrate = $needed; } else { //only want roles that have all caps $rolesthatcanrate = array_intersect_key($rolesthatcanrate,$needed); } } } if (!empty($forbiddenarr) && !empty($rolesthatcanrate)) { foreach ($forbiddenarr as $forbidden) { //remove any roles that are forbidden any of the caps $rolesthatcanrate = array_diff($rolesthatcanrate, $forbidden); } } return $rolesthatcanrate; } /** * Returns an array of role names that have ALL of the the supplied capabilities * Uses get_roles_with_caps_in_context(). Returns $allowed minus $forbidden * * @param stdClass $context * @param array $capabilities An array of capabilities * @return array of roles with all of the required capabilities */ function get_role_names_with_caps_in_context($context, $capabilities) { global $DB; $rolesthatcanrate = get_roles_with_caps_in_context($context, $capabilities); $allroles = $DB->get_records('role', null, 'sortorder DESC'); $roles = array(); foreach ($rolesthatcanrate as $r) { $roles[$r] = $allroles[$r]; } return role_fix_names($roles, $context, ROLENAME_ALIAS, true); } /** * This function verifies the prohibit comes from this context * and there are no more prohibits in parent contexts. * * @param int $roleid * @param context $context * @param string $capability name * @return bool */ function prohibit_is_removable($roleid, context $context, $capability) { global $DB; $ctxids = trim($context->path, '/'); // kill leading slash $ctxids = str_replace('/', ',', $ctxids); $params = array('roleid'=>$roleid, 'cap'=>$capability, 'prohibit'=>CAP_PROHIBIT); $sql = "SELECT ctx.id FROM {role_capabilities} rc JOIN {context} ctx ON ctx.id = rc.contextid JOIN {capabilities} cap ON rc.capability = cap.name WHERE rc.roleid = :roleid AND rc.permission = :prohibit AND rc.capability = :cap AND ctx.id IN ($ctxids) ORDER BY ctx.depth DESC"; if (!$prohibits = $DB->get_records_sql($sql, $params)) { // no prohibits == nothing to remove return true; } if (count($prohibits) > 1) { // more prohibits can not be removed return false; } return !empty($prohibits[$context->id]); } /** * More user friendly role permission changing, * it should produce as few overrides as possible. * * @param int $roleid * @param stdClass $context * @param string $capname capability name * @param int $permission * @return void */ function role_change_permission($roleid, $context, $capname, $permission) { global $DB; if ($permission == CAP_INHERIT) { unassign_capability($capname, $roleid, $context->id); return; } $ctxids = trim($context->path, '/'); // kill leading slash $ctxids = str_replace('/', ',', $ctxids); $params = array('roleid'=>$roleid, 'cap'=>$capname); $sql = "SELECT ctx.id, rc.permission, ctx.depth FROM {role_capabilities} rc JOIN {context} ctx ON ctx.id = rc.contextid JOIN {capabilities} cap ON rc.capability = cap.name WHERE rc.roleid = :roleid AND rc.capability = :cap AND ctx.id IN ($ctxids) ORDER BY ctx.depth DESC"; if ($existing = $DB->get_records_sql($sql, $params)) { foreach ($existing as $e) { if ($e->permission == CAP_PROHIBIT) { // prohibit can not be overridden, no point in changing anything return; } } $lowest = array_shift($existing); if ($lowest->permission == $permission) { // permission already set in this context or parent - nothing to do return; } if ($existing) { $parent = array_shift($existing); if ($parent->permission == $permission) { // permission already set in parent context or parent - just unset in this context // we do this because we want as few overrides as possible for performance reasons unassign_capability($capname, $roleid, $context->id); return; } } } else { if ($permission == CAP_PREVENT) { // nothing means role does not have permission return; } } // assign the needed capability assign_capability($capname, $permission, $roleid, $context->id, true); } /** * Basic moodle context abstraction class. * * Google confirms that no other important framework is using "context" class, * we could use something else like mcontext or moodle_context, but we need to type * this very often which would be annoying and it would take too much space... * * This class is derived from stdClass for backwards compatibility with * odl $context record that was returned from DML $DB->get_record() * * @package core_access * @category access * @copyright Petr Skoda {@link http://skodak.org} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later * @since Moodle 2.2 * * @property-read int $id context id * @property-read int $contextlevel CONTEXT_SYSTEM, CONTEXT_COURSE, etc. * @property-read int $instanceid id of related instance in each context * @property-read string $path path to context, starts with system context * @property-read int $depth */ abstract class context extends stdClass implements IteratorAggregate { /** @var string Default sorting of capabilities in {@see get_capabilities} */ protected const DEFAULT_CAPABILITY_SORT = 'contextlevel, component, name'; /** * The context id * Can be accessed publicly through $context->id * @var int */ protected $_id; /** * The context level * Can be accessed publicly through $context->contextlevel * @var int One of CONTEXT_* e.g. CONTEXT_COURSE, CONTEXT_MODULE */ protected $_contextlevel; /** * Id of the item this context is related to e.g. COURSE_CONTEXT => course.id * Can be accessed publicly through $context->instanceid * @var int */ protected $_instanceid; /** * The path to the context always starting from the system context * Can be accessed publicly through $context->path * @var string */ protected $_path; /** * The depth of the context in relation to parent contexts * Can be accessed publicly through $context->depth * @var int */ protected $_depth; /** * Whether this context is locked or not. * * Can be accessed publicly through $context->locked. * * @var int */ protected $_locked; /** * @var array Context caching info */ private static $cache_contextsbyid = array(); /** * @var array Context caching info */ private static $cache_contexts = array(); /** * Context count * Why do we do count contexts? Because count($array) is horribly slow for large arrays * @var int */ protected static $cache_count = 0; /** * @var array Context caching info */ protected static $cache_preloaded = array(); /** * @var context_system The system context once initialised */ protected static $systemcontext = null; /** * Resets the cache to remove all data. * @static */ protected static function reset_caches() { self::$cache_contextsbyid = array(); self::$cache_contexts = array(); self::$cache_count = 0; self::$cache_preloaded = array(); self::$systemcontext = null; } /** * Adds a context to the cache. If the cache is full, discards a batch of * older entries. * * @static * @param context $context New context to add * @return void */ protected static function cache_add(context $context) { if (isset(self::$cache_contextsbyid[$context->id])) { // already cached, no need to do anything - this is relatively cheap, we do all this because count() is slow return; } if (self::$cache_count >= CONTEXT_CACHE_MAX_SIZE) { $i = 0; foreach (self::$cache_contextsbyid as $ctx) { $i++; if ($i <= 100) { // we want to keep the first contexts to be loaded on this page, hopefully they will be needed again later continue; } if ($i > (CONTEXT_CACHE_MAX_SIZE / 3)) { // we remove oldest third of the contexts to make room for more contexts break; } unset(self::$cache_contextsbyid[$ctx->id]); unset(self::$cache_contexts[$ctx->contextlevel][$ctx->instanceid]); self::$cache_count--; } } self::$cache_contexts[$context->contextlevel][$context->instanceid] = $context; self::$cache_contextsbyid[$context->id] = $context; self::$cache_count++; } /** * Removes a context from the cache. * * @static * @param context $context Context object to remove * @return void */ protected static function cache_remove(context $context) { if (!isset(self::$cache_contextsbyid[$context->id])) { // not cached, no need to do anything - this is relatively cheap, we do all this because count() is slow return; } unset(self::$cache_contexts[$context->contextlevel][$context->instanceid]); unset(self::$cache_contextsbyid[$context->id]); self::$cache_count--; if (self::$cache_count < 0) { self::$cache_count = 0; } } /** * Gets a context from the cache. * * @static * @param int $contextlevel Context level * @param int $instance Instance ID * @return context|bool Context or false if not in cache */ protected static function cache_get($contextlevel, $instance) { if (isset(self::$cache_contexts[$contextlevel][$instance])) { return self::$cache_contexts[$contextlevel][$instance]; } return false; } /** * Gets a context from the cache based on its id. * * @static * @param int $id Context ID * @return context|bool Context or false if not in cache */ protected static function cache_get_by_id($id) { if (isset(self::$cache_contextsbyid[$id])) { return self::$cache_contextsbyid[$id]; } return false; } /** * Preloads context information from db record and strips the cached info. * * @static * @param stdClass $rec * @return void (modifies $rec) */ protected static function preload_from_record(stdClass $rec) { $notenoughdata = false; $notenoughdata = $notenoughdata || empty($rec->ctxid); $notenoughdata = $notenoughdata || empty($rec->ctxlevel); $notenoughdata = $notenoughdata || !isset($rec->ctxinstance); $notenoughdata = $notenoughdata || empty($rec->ctxpath); $notenoughdata = $notenoughdata || empty($rec->ctxdepth); $notenoughdata = $notenoughdata || !isset($rec->ctxlocked); if ($notenoughdata) { // The record does not have enough data, passed here repeatedly or context does not exist yet. if (isset($rec->ctxid) && !isset($rec->ctxlocked)) { debugging('Locked value missing. Code is possibly not usings the getter properly.', DEBUG_DEVELOPER); } return; } $record = (object) [ 'id' => $rec->ctxid, 'contextlevel' => $rec->ctxlevel, 'instanceid' => $rec->ctxinstance, 'path' => $rec->ctxpath, 'depth' => $rec->ctxdepth, 'locked' => $rec->ctxlocked, ]; unset($rec->ctxid); unset($rec->ctxlevel); unset($rec->ctxinstance); unset($rec->ctxpath); unset($rec->ctxdepth); unset($rec->ctxlocked); return context::create_instance_from_record($record); } // ====== magic methods ======= /** * Magic setter method, we do not want anybody to modify properties from the outside * @param string $name * @param mixed $value */ public function __set($name, $value) { debugging('Can not change context instance properties!'); } /** * Magic method getter, redirects to read only values. * @param string $name * @return mixed */ public function __get($name) { switch ($name) { case 'id': return $this->_id; case 'contextlevel': return $this->_contextlevel; case 'instanceid': return $this->_instanceid; case 'path': return $this->_path; case 'depth': return $this->_depth; case 'locked': return $this->is_locked(); default: debugging('Invalid context property accessed! '.$name); return null; } } /** * Full support for isset on our magic read only properties. * @param string $name * @return bool */ public function __isset($name) { switch ($name) { case 'id': return isset($this->_id); case 'contextlevel': return isset($this->_contextlevel); case 'instanceid': return isset($this->_instanceid); case 'path': return isset($this->_path); case 'depth': return isset($this->_depth); case 'locked': // Locked is always set. return true; default: return false; } } /** * All properties are read only, sorry. * @param string $name */ public function __unset($name) { debugging('Can not unset context instance properties!'); } // ====== implementing method from interface IteratorAggregate ====== /** * Create an iterator because magic vars can't be seen by 'foreach'. * * Now we can convert context object to array using convert_to_array(), * and feed it properly to json_encode(). */
< public function getIterator() {
> public function getIterator(): Traversable {
$ret = array( 'id' => $this->id, 'contextlevel' => $this->contextlevel, 'instanceid' => $this->instanceid, 'path' => $this->path, 'depth' => $this->depth, 'locked' => $this->locked, ); return new ArrayIterator($ret); } // ====== general context methods ====== /** * Constructor is protected so that devs are forced to * use context_xxx::instance() or context::instance_by_id(). * * @param stdClass $record */ protected function __construct(stdClass $record) { $this->_id = (int)$record->id; $this->_contextlevel = (int)$record->contextlevel; $this->_instanceid = $record->instanceid; $this->_path = $record->path; $this->_depth = $record->depth; if (isset($record->locked)) { $this->_locked = $record->locked; } else if (!during_initial_install() && !moodle_needs_upgrading()) { debugging('Locked value missing. Code is possibly not usings the getter properly.', DEBUG_DEVELOPER); } } /** * This function is also used to work around 'protected' keyword problems in context_helper. * @static * @param stdClass $record * @return context instance */ protected static function create_instance_from_record(stdClass $record) { $classname = context_helper::get_class_for_level($record->contextlevel); if ($context = context::cache_get_by_id($record->id)) { return $context; } $context = new $classname($record); context::cache_add($context); return $context; } /** * Copy prepared new contexts from temp table to context table, * we do this in db specific way for perf reasons only. * @static */ protected static function merge_context_temp_table() { global $DB; /* MDL-11347: * - mysql does not allow to use FROM in UPDATE statements * - using two tables after UPDATE works in mysql, but might give unexpected * results in pg 8 (depends on configuration) * - using table alias in UPDATE does not work in pg < 8.2 * * Different code for each database - mostly for performance reasons */ $dbfamily = $DB->get_dbfamily(); if ($dbfamily == 'mysql') { $updatesql = "UPDATE {context} ct, {context_temp} temp SET ct.path = temp.path, ct.depth = temp.depth, ct.locked = temp.locked WHERE ct.id = temp.id"; } else if ($dbfamily == 'oracle') { $updatesql = "UPDATE {context} ct SET (ct.path, ct.depth, ct.locked) = (SELECT temp.path, temp.depth, temp.locked FROM {context_temp} temp WHERE temp.id=ct.id) WHERE EXISTS (SELECT 'x' FROM {context_temp} temp WHERE temp.id = ct.id)"; } else if ($dbfamily == 'postgres' or $dbfamily == 'mssql') { $updatesql = "UPDATE {context} SET path = temp.path, depth = temp.depth, locked = temp.locked FROM {context_temp} temp WHERE temp.id={context}.id"; } else { // sqlite and others $updatesql = "UPDATE {context} SET path = (SELECT path FROM {context_temp} WHERE id = {context}.id), depth = (SELECT depth FROM {context_temp} WHERE id = {context}.id), locked = (SELECT locked FROM {context_temp} WHERE id = {context}.id) WHERE id IN (SELECT id FROM {context_temp})"; } $DB->execute($updatesql); } /** * Get a context instance as an object, from a given context id. * * @static * @param int $id context id * @param int $strictness IGNORE_MISSING means compatible mode, false returned if record not found, debug message if more found; * MUST_EXIST means throw exception if no record found * @return context|bool the context object or false if not found */ public static function instance_by_id($id, $strictness = MUST_EXIST) { global $DB; if (get_called_class() !== 'context' and get_called_class() !== 'context_helper') { // some devs might confuse context->id and instanceid, better prevent these mistakes completely throw new coding_exception('use only context::instance_by_id() for real context levels use ::instance() methods'); } if ($id == SYSCONTEXTID) { return context_system::instance(0, $strictness); } if (is_array($id) or is_object($id) or empty($id)) { throw new coding_exception('Invalid context id specified context::instance_by_id()'); } if ($context = context::cache_get_by_id($id)) { return $context; } if ($record = $DB->get_record('context', array('id'=>$id), '*', $strictness)) { return context::create_instance_from_record($record); } return false; } /** * Update context info after moving context in the tree structure. * * @param context $newparent * @return void */ public function update_moved(context $newparent) { global $DB; $frompath = $this->_path; $newpath = $newparent->path . '/' . $this->_id; $trans = $DB->start_delegated_transaction(); $setdepth = ''; if (($newparent->depth +1) != $this->_depth) { $diff = $newparent->depth - $this->_depth + 1; $setdepth = ", depth = depth + $diff"; } $sql = "UPDATE {context} SET path = ? $setdepth WHERE id = ?"; $params = array($newpath, $this->_id); $DB->execute($sql, $params); $this->_path = $newpath; $this->_depth = $newparent->depth + 1; $sql = "UPDATE {context} SET path = ".$DB->sql_concat("?", $DB->sql_substr("path", strlen($frompath)+1))." $setdepth WHERE path LIKE ?"; $params = array($newpath, "{$frompath}/%"); $DB->execute($sql, $params); $this->mark_dirty(); context::reset_caches(); $trans->allow_commit(); } /** * Set whether this context has been locked or not. * * @param bool $locked * @return $this */ public function set_locked(bool $locked) { global $DB; if ($this->_locked == $locked) { return $this; } $this->_locked = $locked; $DB->set_field('context', 'locked', (int) $locked, ['id' => $this->id]); $this->mark_dirty(); if ($locked) { $eventname = '\\core\\event\\context_locked'; } else { $eventname = '\\core\\event\\context_unlocked'; } $event = $eventname::create(['context' => $this, 'objectid' => $this->id]); $event->trigger(); self::reset_caches(); return $this; } /** * Remove all context path info and optionally rebuild it. * * @param bool $rebuild * @return void */ public function reset_paths($rebuild = true) { global $DB; if ($this->_path) { $this->mark_dirty(); } $DB->set_field_select('context', 'depth', 0, "path LIKE '%/$this->_id/%'"); $DB->set_field_select('context', 'path', NULL, "path LIKE '%/$this->_id/%'"); if ($this->_contextlevel != CONTEXT_SYSTEM) { $DB->set_field('context', 'depth', 0, array('id'=>$this->_id)); $DB->set_field('context', 'path', NULL, array('id'=>$this->_id)); $this->_depth = 0; $this->_path = null; } if ($rebuild) { context_helper::build_all_paths(false); } context::reset_caches(); } /** * Delete all data linked to content, do not delete the context record itself */ public function delete_content() { global $CFG, $DB; blocks_delete_all_for_context($this->_id); filter_delete_all_for_context($this->_id); require_once($CFG->dirroot . '/comment/lib.php'); comment::delete_comments(array('contextid'=>$this->_id)); require_once($CFG->dirroot.'/rating/lib.php'); $delopt = new stdclass(); $delopt->contextid = $this->_id; $rm = new rating_manager(); $rm->delete_ratings($delopt); // delete all files attached to this context $fs = get_file_storage(); $fs->delete_area_files($this->_id); // Delete all repository instances attached to this context. require_once($CFG->dirroot . '/repository/lib.php'); repository::delete_all_for_context($this->_id); // delete all advanced grading data attached to this context require_once($CFG->dirroot.'/grade/grading/lib.php'); grading_manager::delete_all_for_context($this->_id); // now delete stuff from role related tables, role_unassign_all // and unenrol should be called earlier to do proper cleanup $DB->delete_records('role_assignments', array('contextid'=>$this->_id)); $DB->delete_records('role_names', array('contextid'=>$this->_id)); $this->delete_capabilities(); } /** * Unassign all capabilities from a context. */ public function delete_capabilities() { global $DB; $ids = $DB->get_fieldset_select('role_capabilities', 'DISTINCT roleid', 'contextid = ?', array($this->_id)); if ($ids) { $DB->delete_records('role_capabilities', array('contextid' => $this->_id)); // Reset any cache of these roles, including MUC. accesslib_clear_role_cache($ids); } } /** * Delete the context content and the context record itself */ public function delete() { global $DB; if ($this->_contextlevel <= CONTEXT_SYSTEM) { throw new coding_exception('Cannot delete system context'); } // double check the context still exists if (!$DB->record_exists('context', array('id'=>$this->_id))) { context::cache_remove($this); return; } $this->delete_content(); $DB->delete_records('context', array('id'=>$this->_id)); // purge static context cache if entry present context::cache_remove($this); // Inform search engine to delete data related to this context. \core_search\manager::context_deleted($this); } // ====== context level related methods ====== /** * Utility method for context creation * * @static * @param int $contextlevel * @param int $instanceid * @param string $parentpath * @return stdClass context record */ protected static function insert_context_record($contextlevel, $instanceid, $parentpath) { global $DB; $record = new stdClass(); $record->contextlevel = $contextlevel; $record->instanceid = $instanceid; $record->depth = 0; $record->path = null; //not known before insert $record->locked = 0; $record->id = $DB->insert_record('context', $record); // now add path if known - it can be added later if (!is_null($parentpath)) { $record->path = $parentpath.'/'.$record->id; $record->depth = substr_count($record->path, '/'); $DB->update_record('context', $record); } return $record; } /** * Returns human readable context identifier. * * @param boolean $withprefix whether to prefix the name of the context with the * type of context, e.g. User, Course, Forum, etc. * @param boolean $short whether to use the short name of the thing. Only applies * to course contexts * @param boolean $escape Whether the returned name of the thing is to be * HTML escaped or not. * @return string the human readable context name. */ public function get_context_name($withprefix = true, $short = false, $escape = true) { // must be implemented in all context levels throw new coding_exception('can not get name of abstract context'); } /** * Whether the current context is locked. * * @return bool */ public function is_locked() { if ($this->_locked) { return true; } if ($parent = $this->get_parent_context()) { return $parent->is_locked(); } return false; } /** * Returns the most relevant URL for this context. * * @return moodle_url */ public abstract function get_url(); /** * Returns array of relevant context capability records. * * @param string $sort SQL order by snippet for sorting returned capabilities sensibly for display * @return array */ public abstract function get_capabilities(string $sort = self::DEFAULT_CAPABILITY_SORT); /** * Recursive function which, given a context, find all its children context ids. * * For course category contexts it will return immediate children and all subcategory contexts. * It will NOT recurse into courses or subcategories categories. * If you want to do that, call it on the returned courses/categories. * * When called for a course context, it will return the modules and blocks * displayed in the course page and blocks displayed on the module pages. * * If called on a user/course/module context it _will_ populate the cache with the appropriate * contexts ;-) * * @return array Array of child records */ public function get_child_contexts() { global $DB; if (empty($this->_path) or empty($this->_depth)) { debugging('Can not find child contexts of context '.$this->_id.' try rebuilding of context paths'); return array(); } $sql = "SELECT ctx.* FROM {context} ctx WHERE ctx.path LIKE ?"; $params = array($this->_path.'/%'); $records = $DB->get_records_sql($sql, $params); $result = array(); foreach ($records as $record) { $result[$record->id] = context::create_instance_from_record($record); } return $result; } /** * Determine if the current context is a parent of the possible child. * * @param context $possiblechild * @param bool $includeself Whether to check the current context * @return bool */ public function is_parent_of(context $possiblechild, bool $includeself): bool { // A simple substring check is used on the context path. // The possible child's path is used as a haystack, with the current context as the needle. // The path is prefixed with '+' to ensure that the parent always starts at the top. // It is suffixed with '+' to ensure that parents are not included. // The needle always suffixes with a '/' to ensure that the contextid uses a complete match (i.e. 142/ instead of 14). // The haystack is suffixed with '/+' if $includeself is true to allow the current context to match. // The haystack is suffixed with '+' if $includeself is false to prevent the current context from matching. $haystacksuffix = $includeself ? '/+' : '+'; $strpos = strpos( "+{$possiblechild->path}{$haystacksuffix}", "+{$this->path}/" ); return $strpos === 0; } /** * Returns parent contexts of this context in reversed order, i.e. parent first, * then grand parent, etc. * * @param bool $includeself true means include self too * @return array of context instances */ public function get_parent_contexts($includeself = false) { if (!$contextids = $this->get_parent_context_ids($includeself)) { return array(); } // Preload the contexts to reduce DB calls. context_helper::preload_contexts_by_id($contextids); $result = array(); foreach ($contextids as $contextid) { $parent = context::instance_by_id($contextid, MUST_EXIST); $result[$parent->id] = $parent; } return $result; } /** * Determine if the current context is a child of the possible parent. * * @param context $possibleparent * @param bool $includeself Whether to check the current context * @return bool */ public function is_child_of(context $possibleparent, bool $includeself): bool { // A simple substring check is used on the context path. // The current context is used as a haystack, with the possible parent as the needle. // The path is prefixed with '+' to ensure that the parent always starts at the top. // It is suffixed with '+' to ensure that children are not included. // The needle always suffixes with a '/' to ensure that the contextid uses a complete match (i.e. 142/ instead of 14). // The haystack is suffixed with '/+' if $includeself is true to allow the current context to match. // The haystack is suffixed with '+' if $includeself is false to prevent the current context from matching. $haystacksuffix = $includeself ? '/+' : '+'; $strpos = strpos( "+{$this->path}{$haystacksuffix}", "+{$possibleparent->path}/" ); return $strpos === 0; } /** * Returns parent context ids of this context in reversed order, i.e. parent first, * then grand parent, etc. * * @param bool $includeself true means include self too * @return array of context ids */ public function get_parent_context_ids($includeself = false) { if (empty($this->_path)) { return array(); } $parentcontexts = trim($this->_path, '/'); // kill leading slash $parentcontexts = explode('/', $parentcontexts); if (!$includeself) { array_pop($parentcontexts); // and remove its own id } return array_reverse($parentcontexts); } /** * Returns parent context paths of this context. * * @param bool $includeself true means include self too * @return array of context paths */ public function get_parent_context_paths($includeself = false) { if (empty($this->_path)) { return array(); } $contextids = explode('/', $this->_path); $path = ''; $paths = array(); foreach ($contextids as $contextid) { if ($contextid) { $path .= '/' . $contextid; $paths[$contextid] = $path; } } if (!$includeself) { unset($paths[$this->_id]); } return $paths; } /** * Returns parent context * * @return context */ public function get_parent_context() { if (empty($this->_path) or $this->_id == SYSCONTEXTID) { return false; } $parentcontexts = trim($this->_path, '/'); // kill leading slash $parentcontexts = explode('/', $parentcontexts); array_pop($parentcontexts); // self $contextid = array_pop($parentcontexts); // immediate parent return context::instance_by_id($contextid, MUST_EXIST); } /** * Is this context part of any course? If yes return course context. * * @param bool $strict true means throw exception if not found, false means return false if not found * @return context_course context of the enclosing course, null if not found or exception */ public function get_course_context($strict = true) { if ($strict) { throw new coding_exception('Context does not belong to any course.'); } else { return false; } } /** * Returns sql necessary for purging of stale context instances. * * @static * @return string cleanup SQL */ protected static function get_cleanup_sql() { throw new coding_exception('get_cleanup_sql() method must be implemented in all context levels'); } /** * Rebuild context paths and depths at context level. * * @static * @param bool $force * @return void */ protected static function build_paths($force) { throw new coding_exception('build_paths() method must be implemented in all context levels'); } /** * Create missing context instances at given level * * @static * @return void */ protected static function create_level_instances() { throw new coding_exception('create_level_instances() method must be implemented in all context levels'); } /** * Reset all cached permissions and definitions if the necessary. * @return void */ public function reload_if_dirty() { global $ACCESSLIB_PRIVATE, $USER; // Load dirty contexts list if needed if (CLI_SCRIPT) { if (!isset($ACCESSLIB_PRIVATE->dirtycontexts)) { // we do not load dirty flags in CLI and cron $ACCESSLIB_PRIVATE->dirtycontexts = array(); } } else { if (!isset($USER->access['time'])) { // Nothing has been loaded yet, so we do not need to check dirty flags now. return; } // From skodak: No idea why -2 is there, server cluster time difference maybe... $changedsince = $USER->access['time'] - 2; if (!isset($ACCESSLIB_PRIVATE->dirtycontexts)) { $ACCESSLIB_PRIVATE->dirtycontexts = get_cache_flags('accesslib/dirtycontexts', $changedsince); } if (!isset($ACCESSLIB_PRIVATE->dirtyusers[$USER->id])) { $ACCESSLIB_PRIVATE->dirtyusers[$USER->id] = get_cache_flag('accesslib/dirtyusers', $USER->id, $changedsince); } } $dirty = false; if (!empty($ACCESSLIB_PRIVATE->dirtyusers[$USER->id])) { $dirty = true; } else if (!empty($ACCESSLIB_PRIVATE->dirtycontexts)) { $paths = $this->get_parent_context_paths(true); foreach ($paths as $path) { if (isset($ACCESSLIB_PRIVATE->dirtycontexts[$path])) { $dirty = true; break; } } } if ($dirty) { // Reload all capabilities of USER and others - preserving loginas, roleswitches, etc. // Then cleanup any marks of dirtyness... at least from our short term memory! reload_all_capabilities(); } } /** * Mark a context as dirty (with timestamp) so as to force reloading of the context. */ public function mark_dirty() { global $CFG, $USER, $ACCESSLIB_PRIVATE; if (during_initial_install()) { return; } // only if it is a non-empty string if (is_string($this->_path) && $this->_path !== '') { set_cache_flag('accesslib/dirtycontexts', $this->_path, 1, time()+$CFG->sessiontimeout); if (isset($ACCESSLIB_PRIVATE->dirtycontexts)) { $ACCESSLIB_PRIVATE->dirtycontexts[$this->_path] = 1; } else { if (CLI_SCRIPT) { $ACCESSLIB_PRIVATE->dirtycontexts = array($this->_path => 1); } else { if (isset($USER->access['time'])) { $ACCESSLIB_PRIVATE->dirtycontexts = get_cache_flags('accesslib/dirtycontexts', $USER->access['time']-2); } else { $ACCESSLIB_PRIVATE->dirtycontexts = array($this->_path => 1); } // flags not loaded yet, it will be done later in $context->reload_if_dirty() } } } } } /** * Context maintenance and helper methods. * * This is "extends context" is a bloody hack that tires to work around the deficiencies * in the "protected" keyword in PHP, this helps us to hide all the internals of context * level implementation from the rest of code, the code completion returns what developers need. * * Thank you Tim Hunt for helping me with this nasty trick. * * @package core_access * @category access * @copyright Petr Skoda {@link http://skodak.org} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later * @since Moodle 2.2 */ class context_helper extends context { /** * @var array An array mapping context levels to classes */ private static $alllevels; /** * Instance does not make sense here, only static use */ protected function __construct() { } /** * Reset internal context levels array. */ public static function reset_levels() { self::$alllevels = null; } /** * Initialise context levels, call before using self::$alllevels. */ private static function init_levels() { global $CFG; if (isset(self::$alllevels)) { return; } self::$alllevels = array( CONTEXT_SYSTEM => 'context_system', CONTEXT_USER => 'context_user', CONTEXT_COURSECAT => 'context_coursecat', CONTEXT_COURSE => 'context_course', CONTEXT_MODULE => 'context_module', CONTEXT_BLOCK => 'context_block', ); if (empty($CFG->custom_context_classes)) { return; } $levels = $CFG->custom_context_classes; if (!is_array($levels)) { $levels = @unserialize($levels); } if (!is_array($levels)) { debugging('Invalid $CFG->custom_context_classes detected, value ignored.', DEBUG_DEVELOPER); return; } // Unsupported custom levels, use with care!!! foreach ($levels as $level => $classname) { self::$alllevels[$level] = $classname; } ksort(self::$alllevels); } /** * Returns a class name of the context level class * * @static * @param int $contextlevel (CONTEXT_SYSTEM, etc.) * @return string class name of the context class */ public static function get_class_for_level($contextlevel) { self::init_levels(); if (isset(self::$alllevels[$contextlevel])) { return self::$alllevels[$contextlevel]; } else { throw new coding_exception('Invalid context level specified'); } } /** * Returns a list of all context levels * * @static * @return array int=>string (level=>level class name) */ public static function get_all_levels() { self::init_levels(); return self::$alllevels; } /** * Remove stale contexts that belonged to deleted instances. * Ideally all code should cleanup contexts properly, unfortunately accidents happen... * * @static * @return void */ public static function cleanup_instances() { global $DB; self::init_levels(); $sqls = array(); foreach (self::$alllevels as $level=>$classname) { $sqls[] = $classname::get_cleanup_sql(); } $sql = implode(" UNION ", $sqls); // it is probably better to use transactions, it might be faster too $transaction = $DB->start_delegated_transaction(); $rs = $DB->get_recordset_sql($sql); foreach ($rs as $record) { $context = context::create_instance_from_record($record); $context->delete(); } $rs->close(); $transaction->allow_commit(); } /** * Create all context instances at the given level and above. * * @static * @param int $contextlevel null means all levels * @param bool $buildpaths * @return void */ public static function create_instances($contextlevel = null, $buildpaths = true) { self::init_levels(); foreach (self::$alllevels as $level=>$classname) { if ($contextlevel and $level > $contextlevel) { // skip potential sub-contexts continue; } $classname::create_level_instances(); if ($buildpaths) { $classname::build_paths(false); } } } /** * Rebuild paths and depths in all context levels. * * @static * @param bool $force false means add missing only * @return void */ public static function build_all_paths($force = false) { self::init_levels(); foreach (self::$alllevels as $classname) { $classname::build_paths($force); } // reset static course cache - it might have incorrect cached data accesslib_clear_all_caches(true); } /** * Resets the cache to remove all data. * @static */ public static function reset_caches() { context::reset_caches(); } /** * Returns all fields necessary for context preloading from user $rec. * * This helps with performance when dealing with hundreds of contexts. * * @static * @param string $tablealias context table alias in the query * @return array (table.column=>alias, ...) */ public static function get_preload_record_columns($tablealias) { return [ "$tablealias.id" => "ctxid", "$tablealias.path" => "ctxpath", "$tablealias.depth" => "ctxdepth", "$tablealias.contextlevel" => "ctxlevel", "$tablealias.instanceid" => "ctxinstance", "$tablealias.locked" => "ctxlocked", ]; } /** * Returns all fields necessary for context preloading from user $rec. * * This helps with performance when dealing with hundreds of contexts. * * @static * @param string $tablealias context table alias in the query * @return string */ public static function get_preload_record_columns_sql($tablealias) { return "$tablealias.id AS ctxid, " . "$tablealias.path AS ctxpath, " . "$tablealias.depth AS ctxdepth, " . "$tablealias.contextlevel AS ctxlevel, " . "$tablealias.instanceid AS ctxinstance, " . "$tablealias.locked AS ctxlocked"; } /** * Preloads context cache with information from db record and strips the cached info. * * The db request has to contain all columns from context_helper::get_preload_record_columns(). * * @static * @param stdClass $rec * @return void This is intentional. See MDL-37115. You will need to get the context * in the normal way, but it is now cached, so that will be fast. */ public static function preload_from_record(stdClass $rec) { context::preload_from_record($rec); } /** * Preload a set of contexts using their contextid. * * @param array $contextids */ public static function preload_contexts_by_id(array $contextids) { global $DB; // Determine which contexts are not already cached. $tofetch = []; foreach ($contextids as $contextid) { if (!self::cache_get_by_id($contextid)) { $tofetch[] = $contextid; } } if (count($tofetch) > 1) { // There are at least two to fetch. // There is no point only fetching a single context as this would be no more efficient than calling the existing code. list($insql, $inparams) = $DB->get_in_or_equal($tofetch, SQL_PARAMS_NAMED); $ctxs = $DB->get_records_select('context', "id {$insql}", $inparams, '', \context_helper::get_preload_record_columns_sql('{context}')); foreach ($ctxs as $ctx) { self::preload_from_record($ctx); } } } /** * Preload all contexts instances from course. * * To be used if you expect multiple queries for course activities... * * @static * @param int $courseid */ public static function preload_course($courseid) { // Users can call this multiple times without doing any harm if (isset(context::$cache_preloaded[$courseid])) { return; } $coursecontext = context_course::instance($courseid); $coursecontext->get_child_contexts(); context::$cache_preloaded[$courseid] = true; } /** * Delete context instance * * @static * @param int $contextlevel * @param int $instanceid * @return void */ public static function delete_instance($contextlevel, $instanceid) { global $DB; // double check the context still exists if ($record = $DB->get_record('context', array('contextlevel'=>$contextlevel, 'instanceid'=>$instanceid))) { $context = context::create_instance_from_record($record); $context->delete(); } else { // we should try to purge the cache anyway } } /** * Returns the name of specified context level * * @static * @param int $contextlevel * @return string name of the context level */ public static function get_level_name($contextlevel) { $classname = context_helper::get_class_for_level($contextlevel); return $classname::get_level_name(); } /** * Gets the current context to be used for navigation tree filtering. * * @param context|null $context The current context to be checked against. * @return context|null the context that navigation tree filtering should use. */ public static function get_navigation_filter_context(?context $context): ?context { global $CFG; if (!empty($CFG->filternavigationwithsystemcontext)) { return context_system::instance(); } else { return $context; } } /** * not used */ public function get_url() { } /** * not used * * @param string $sort */ public function get_capabilities(string $sort = self::DEFAULT_CAPABILITY_SORT) { } } /** * System context class * * @package core_access * @category access * @copyright Petr Skoda {@link http://skodak.org} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later * @since Moodle 2.2 */ class context_system extends context { /** * Please use context_system::instance() if you need the instance of context. * * @param stdClass $record */ protected function __construct(stdClass $record) { parent::__construct($record); if ($record->contextlevel != CONTEXT_SYSTEM) { throw new coding_exception('Invalid $record->contextlevel in context_system constructor.'); } } /** * Returns human readable context level name. * * @static * @return string the human readable context level name. */ public static function get_level_name() { return get_string('coresystem'); } /** * Returns human readable context identifier. * * @param boolean $withprefix does not apply to system context * @param boolean $short does not apply to system context * @param boolean $escape does not apply to system context * @return string the human readable context name. */ public function get_context_name($withprefix = true, $short = false, $escape = true) { return self::get_level_name(); } /** * Returns the most relevant URL for this context. * * @return moodle_url */ public function get_url() { return new moodle_url('/'); } /** * Returns array of relevant context capability records. * * @param string $sort * @return array */ public function get_capabilities(string $sort = self::DEFAULT_CAPABILITY_SORT) { global $DB; return $DB->get_records('capabilities', [], $sort); } /** * Create missing context instances at system context * @static */ protected static function create_level_instances() { // nothing to do here, the system context is created automatically in installer self::instance(0); } /** * Returns system context instance. * * @static * @param int $instanceid should be 0 * @param int $strictness * @param bool $cache * @return context_system context instance */ public static function instance($instanceid = 0, $strictness = MUST_EXIST, $cache = true) { global $DB; if ($instanceid != 0) { debugging('context_system::instance(): invalid $id parameter detected, should be 0'); } // SYSCONTEXTID is cached in local cache to eliminate 1 query per page. if (defined('SYSCONTEXTID') and $cache) { if (!isset(context::$systemcontext)) { $record = new stdClass(); $record->id = SYSCONTEXTID; $record->contextlevel = CONTEXT_SYSTEM; $record->instanceid = 0; $record->path = '/'.SYSCONTEXTID; $record->depth = 1; $record->locked = 0; context::$systemcontext = new context_system($record); } return context::$systemcontext; } try { // We ignore the strictness completely because system context must exist except during install. $record = $DB->get_record('context', array('contextlevel'=>CONTEXT_SYSTEM), '*', MUST_EXIST); } catch (dml_exception $e) { //table or record does not exist if (!during_initial_install()) { // do not mess with system context after install, it simply must exist throw $e; } $record = null; } if (!$record) { $record = new stdClass(); $record->contextlevel = CONTEXT_SYSTEM; $record->instanceid = 0; $record->depth = 1; $record->path = null; // Not known before insert. $record->locked = 0; try { if ($DB->count_records('context')) { // contexts already exist, this is very weird, system must be first!!! return null; } if (defined('SYSCONTEXTID')) { // this would happen only in unittest on sites that went through weird 1.7 upgrade $record->id = SYSCONTEXTID; $DB->import_record('context', $record); $DB->get_manager()->reset_sequence('context'); } else { $record->id = $DB->insert_record('context', $record); } } catch (dml_exception $e) { // can not create context - table does not exist yet, sorry return null; } } if ($record->instanceid != 0) { // this is very weird, somebody must be messing with context table debugging('Invalid system context detected'); } if ($record->depth != 1 or $record->path != '/'.$record->id) { // fix path if necessary, initial install or path reset $record->depth = 1; $record->path = '/'.$record->id; $DB->update_record('context', $record); } if (empty($record->locked)) { $record->locked = 0; } if (!defined('SYSCONTEXTID')) { define('SYSCONTEXTID', $record->id); } context::$systemcontext = new context_system($record); return context::$systemcontext; } /** * Returns all site contexts except the system context, DO NOT call on production servers!! * * Contexts are not cached. * * @return array */ public function get_child_contexts() { global $DB; debugging('Fetching of system context child courses is strongly discouraged on production servers (it may eat all available memory)!'); // Just get all the contexts except for CONTEXT_SYSTEM level // and hope we don't OOM in the process - don't cache $sql = "SELECT c.* FROM {context} c WHERE contextlevel > ".CONTEXT_SYSTEM; $records = $DB->get_records_sql($sql); $result = array(); foreach ($records as $record) { $result[$record->id] = context::create_instance_from_record($record); } return $result; } /** * Returns sql necessary for purging of stale context instances. * * @static * @return string cleanup SQL */ protected static function get_cleanup_sql() { $sql = " SELECT c.* FROM {context} c WHERE 1=2 "; return $sql; } /** * Rebuild context paths and depths at system context level. * * @static * @param bool $force */ protected static function build_paths($force) { global $DB; /* note: ignore $force here, we always do full test of system context */ // exactly one record must exist $record = $DB->get_record('context', array('contextlevel'=>CONTEXT_SYSTEM), '*', MUST_EXIST); if ($record->instanceid != 0) { debugging('Invalid system context detected'); } if (defined('SYSCONTEXTID') and $record->id != SYSCONTEXTID) { debugging('Invalid SYSCONTEXTID detected'); } if ($record->depth != 1 or $record->path != '/'.$record->id) { // fix path if necessary, initial install or path reset $record->depth = 1; $record->path = '/'.$record->id; $DB->update_record('context', $record); } } /** * Set whether this context has been locked or not. * * @param bool $locked * @return $this */ public function set_locked(bool $locked) { throw new \coding_exception('It is not possible to lock the system context'); return $this; } } /** * User context class * * @package core_access * @category access * @copyright Petr Skoda {@link http://skodak.org} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later * @since Moodle 2.2 */ class context_user extends context { /** * Please use context_user::instance($userid) if you need the instance of context. * Alternatively if you know only the context id use context::instance_by_id($contextid) * * @param stdClass $record */ protected function __construct(stdClass $record) { parent::__construct($record); if ($record->contextlevel != CONTEXT_USER) { throw new coding_exception('Invalid $record->contextlevel in context_user constructor.'); } } /** * Returns human readable context level name. * * @static * @return string the human readable context level name. */ public static function get_level_name() { return get_string('user'); } /** * Returns human readable context identifier. * * @param boolean $withprefix whether to prefix the name of the context with User * @param boolean $short does not apply to user context * @param boolean $escape does not apply to user context * @return string the human readable context name. */ public function get_context_name($withprefix = true, $short = false, $escape = true) { global $DB; $name = ''; if ($user = $DB->get_record('user', array('id'=>$this->_instanceid, 'deleted'=>0))) { if ($withprefix){ $name = get_string('user').': '; } $name .= fullname($user); } return $name; } /** * Returns the most relevant URL for this context. * * @return moodle_url */ public function get_url() { global $COURSE; if ($COURSE->id == SITEID) { $url = new moodle_url('/user/profile.php', array('id'=>$this->_instanceid)); } else { $url = new moodle_url('/user/view.php', array('id'=>$this->_instanceid, 'courseid'=>$COURSE->id)); } return $url; } /** * Returns array of relevant context capability records. * * @param string $sort * @return array */ public function get_capabilities(string $sort = self::DEFAULT_CAPABILITY_SORT) { global $DB; $extracaps = array('moodle/grade:viewall'); list($extra, $params) = $DB->get_in_or_equal($extracaps, SQL_PARAMS_NAMED, 'cap'); return $DB->get_records_select('capabilities', "contextlevel = :level OR name {$extra}", $params + ['level' => CONTEXT_USER], $sort); } /** * Returns user context instance. * * @static * @param int $userid id from {user} table * @param int $strictness * @return context_user context instance */ public static function instance($userid, $strictness = MUST_EXIST) { global $DB; if ($context = context::cache_get(CONTEXT_USER, $userid)) { return $context; } if (!$record = $DB->get_record('context', array('contextlevel' => CONTEXT_USER, 'instanceid' => $userid))) { if ($user = $DB->get_record('user', array('id' => $userid, 'deleted' => 0), 'id', $strictness)) { $record = context::insert_context_record(CONTEXT_USER, $user->id, '/'.SYSCONTEXTID, 0); } } if ($record) { $context = new context_user($record); context::cache_add($context); return $context; } return false; } /** * Create missing context instances at user context level * @static */ protected static function create_level_instances() { global $DB; $sql = "SELECT ".CONTEXT_USER.", u.id FROM {user} u WHERE u.deleted = 0 AND NOT EXISTS (SELECT 'x' FROM {context} cx WHERE u.id = cx.instanceid AND cx.contextlevel=".CONTEXT_USER.")"; $contextdata = $DB->get_recordset_sql($sql); foreach ($contextdata as $context) { context::insert_context_record(CONTEXT_USER, $context->id, null); } $contextdata->close(); } /** * Returns sql necessary for purging of stale context instances. * * @static * @return string cleanup SQL */ protected static function get_cleanup_sql() { $sql = " SELECT c.* FROM {context} c LEFT OUTER JOIN {user} u ON (c.instanceid = u.id AND u.deleted = 0) WHERE u.id IS NULL AND c.contextlevel = ".CONTEXT_USER." "; return $sql; } /** * Rebuild context paths and depths at user context level. * * @static * @param bool $force */ protected static function build_paths($force) { global $DB; // First update normal users. $path = $DB->sql_concat('?', 'id'); $pathstart = '/' . SYSCONTEXTID . '/'; $params = array($pathstart); if ($force) { $where = "depth <> 2 OR path IS NULL OR path <> ({$path})"; $params[] = $pathstart; } else { $where = "depth = 0 OR path IS NULL"; } $sql = "UPDATE {context} SET depth = 2, path = {$path} WHERE contextlevel = " . CONTEXT_USER . " AND ($where)"; $DB->execute($sql, $params); } } /** * Course category context class * * @package core_access * @category access * @copyright Petr Skoda {@link http://skodak.org} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later * @since Moodle 2.2 */ class context_coursecat extends context { /** * Please use context_coursecat::instance($coursecatid) if you need the instance of context. * Alternatively if you know only the context id use context::instance_by_id($contextid) * * @param stdClass $record */ protected function __construct(stdClass $record) { parent::__construct($record); if ($record->contextlevel != CONTEXT_COURSECAT) { throw new coding_exception('Invalid $record->contextlevel in context_coursecat constructor.'); } } /** * Returns human readable context level name. * * @static * @return string the human readable context level name. */ public static function get_level_name() { return get_string('category'); } /** * Returns human readable context identifier. * * @param boolean $withprefix whether to prefix the name of the context with Category * @param boolean $short does not apply to course categories * @param boolean $escape Whether the returned name of the context is to be HTML escaped or not. * @return string the human readable context name. */ public function get_context_name($withprefix = true, $short = false, $escape = true) { global $DB; $name = ''; if ($category = $DB->get_record('course_categories', array('id'=>$this->_instanceid))) { if ($withprefix){ $name = get_string('category').': '; } if (!$escape) { $name .= format_string($category->name, true, array('context' => $this, 'escape' => false)); } else { $name .= format_string($category->name, true, array('context' => $this)); } } return $name; } /** * Returns the most relevant URL for this context. * * @return moodle_url */ public function get_url() { return new moodle_url('/course/index.php', array('categoryid' => $this->_instanceid)); } /** * Returns array of relevant context capability records. * * @param string $sort * @return array */ public function get_capabilities(string $sort = self::DEFAULT_CAPABILITY_SORT) { global $DB; return $DB->get_records_list('capabilities', 'contextlevel', [ CONTEXT_COURSECAT, CONTEXT_COURSE, CONTEXT_MODULE, CONTEXT_BLOCK, ], $sort); } /** * Returns course category context instance. * * @static * @param int $categoryid id from {course_categories} table * @param int $strictness * @return context_coursecat context instance */ public static function instance($categoryid, $strictness = MUST_EXIST) { global $DB; if ($context = context::cache_get(CONTEXT_COURSECAT, $categoryid)) { return $context; } if (!$record = $DB->get_record('context', array('contextlevel' => CONTEXT_COURSECAT, 'instanceid' => $categoryid))) { if ($category = $DB->get_record('course_categories', array('id' => $categoryid), 'id,parent', $strictness)) { if ($category->parent) { $parentcontext = context_coursecat::instance($category->parent); $record = context::insert_context_record(CONTEXT_COURSECAT, $category->id, $parentcontext->path); } else { $record = context::insert_context_record(CONTEXT_COURSECAT, $category->id, '/'.SYSCONTEXTID, 0); } } } if ($record) { $context = new context_coursecat($record); context::cache_add($context); return $context; } return false; } /** * Returns immediate child contexts of category and all subcategories, * children of subcategories and courses are not returned. * * @return array */ public function get_child_contexts() { global $DB; if (empty($this->_path) or empty($this->_depth)) { debugging('Can not find child contexts of context '.$this->_id.' try rebuilding of context paths'); return array(); } $sql = "SELECT ctx.* FROM {context} ctx WHERE ctx.path LIKE ? AND (ctx.depth = ? OR ctx.contextlevel = ?)"; $params = array($this->_path.'/%', $this->depth+1, CONTEXT_COURSECAT); $records = $DB->get_records_sql($sql, $params); $result = array(); foreach ($records as $record) { $result[$record->id] = context::create_instance_from_record($record); } return $result; } /** * Create missing context instances at course category context level * @static */ protected static function create_level_instances() { global $DB; $sql = "SELECT ".CONTEXT_COURSECAT.", cc.id FROM {course_categories} cc WHERE NOT EXISTS (SELECT 'x' FROM {context} cx WHERE cc.id = cx.instanceid AND cx.contextlevel=".CONTEXT_COURSECAT.")"; $contextdata = $DB->get_recordset_sql($sql); foreach ($contextdata as $context) { context::insert_context_record(CONTEXT_COURSECAT, $context->id, null); } $contextdata->close(); } /** * Returns sql necessary for purging of stale context instances. * * @static * @return string cleanup SQL */ protected static function get_cleanup_sql() { $sql = " SELECT c.* FROM {context} c LEFT OUTER JOIN {course_categories} cc ON c.instanceid = cc.id WHERE cc.id IS NULL AND c.contextlevel = ".CONTEXT_COURSECAT." "; return $sql; } /** * Rebuild context paths and depths at course category context level. * * @static * @param bool $force */ protected static function build_paths($force) { global $DB; if ($force or $DB->record_exists_select('context', "contextlevel = ".CONTEXT_COURSECAT." AND (depth = 0 OR path IS NULL)")) { if ($force) { $ctxemptyclause = $emptyclause = ''; } else { $ctxemptyclause = "AND (ctx.path IS NULL OR ctx.depth = 0)"; $emptyclause = "AND ({context}.path IS NULL OR {context}.depth = 0)"; } $base = '/'.SYSCONTEXTID; // Normal top level categories $sql = "UPDATE {context} SET depth=2, path=".$DB->sql_concat("'$base/'", 'id')." WHERE contextlevel=".CONTEXT_COURSECAT." AND EXISTS (SELECT 'x' FROM {course_categories} cc WHERE cc.id = {context}.instanceid AND cc.depth=1) $emptyclause"; $DB->execute($sql); // Deeper categories - one query per depthlevel $maxdepth = $DB->get_field_sql("SELECT MAX(depth) FROM {course_categories}"); for ($n=2; $n<=$maxdepth; $n++) { $sql = "INSERT INTO {context_temp} (id, path, depth, locked) SELECT ctx.id, ".$DB->sql_concat('pctx.path', "'/'", 'ctx.id').", pctx.depth+1, ctx.locked FROM {context} ctx JOIN {course_categories} cc ON (cc.id = ctx.instanceid AND ctx.contextlevel = ".CONTEXT_COURSECAT." AND cc.depth = $n) JOIN {context} pctx ON (pctx.instanceid = cc.parent AND pctx.contextlevel = ".CONTEXT_COURSECAT.") WHERE pctx.path IS NOT NULL AND pctx.depth > 0 $ctxemptyclause"; $trans = $DB->start_delegated_transaction(); $DB->delete_records('context_temp'); $DB->execute($sql); context::merge_context_temp_table(); $DB->delete_records('context_temp'); $trans->allow_commit(); } } } } /** * Course context class * * @package core_access * @category access * @copyright Petr Skoda {@link http://skodak.org} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later * @since Moodle 2.2 */ class context_course extends context { /** * Please use context_course::instance($courseid) if you need the instance of context. * Alternatively if you know only the context id use context::instance_by_id($contextid) * * @param stdClass $record */ protected function __construct(stdClass $record) { parent::__construct($record); if ($record->contextlevel != CONTEXT_COURSE) { throw new coding_exception('Invalid $record->contextlevel in context_course constructor.'); } } /** * Returns human readable context level name. * * @static * @return string the human readable context level name. */ public static function get_level_name() { return get_string('course'); } /** * Returns human readable context identifier. * * @param boolean $withprefix whether to prefix the name of the context with Course * @param boolean $short whether to use the short name of the thing. * @param bool $escape Whether the returned category name is to be HTML escaped or not. * @return string the human readable context name. */ public function get_context_name($withprefix = true, $short = false, $escape = true) { global $DB; $name = ''; if ($this->_instanceid == SITEID) { $name = get_string('frontpage', 'admin'); } else { if ($course = $DB->get_record('course', array('id'=>$this->_instanceid))) { if ($withprefix){ $name = get_string('course').': '; } if ($short){ if (!$escape) { $name .= format_string($course->shortname, true, array('context' => $this, 'escape' => false)); } else { $name .= format_string($course->shortname, true, array('context' => $this)); } } else { if (!$escape) { $name .= format_string(get_course_display_name_for_list($course), true, array('context' => $this, 'escape' => false)); } else { $name .= format_string(get_course_display_name_for_list($course), true, array('context' => $this)); } } } } return $name; } /** * Returns the most relevant URL for this context. * * @return moodle_url */ public function get_url() { if ($this->_instanceid != SITEID) { return new moodle_url('/course/view.php', array('id'=>$this->_instanceid)); } return new moodle_url('/'); } /** * Returns array of relevant context capability records. * * @param string $sort * @return array */ public function get_capabilities(string $sort = self::DEFAULT_CAPABILITY_SORT) { global $DB; return $DB->get_records_list('capabilities', 'contextlevel', [ CONTEXT_COURSE, CONTEXT_MODULE, CONTEXT_BLOCK, ], $sort); } /** * Is this context part of any course? If yes return course context. * * @param bool $strict true means throw exception if not found, false means return false if not found * @return context_course context of the enclosing course, null if not found or exception */ public function get_course_context($strict = true) { return $this; } /** * Returns course context instance. * * @static * @param int $courseid id from {course} table * @param int $strictness * @return context_course context instance */ public static function instance($courseid, $strictness = MUST_EXIST) { global $DB; if ($context = context::cache_get(CONTEXT_COURSE, $courseid)) { return $context; } if (!$record = $DB->get_record('context', array('contextlevel' => CONTEXT_COURSE, 'instanceid' => $courseid))) { if ($course = $DB->get_record('course', array('id' => $courseid), 'id,category', $strictness)) { if ($course->category) { $parentcontext = context_coursecat::instance($course->category); $record = context::insert_context_record(CONTEXT_COURSE, $course->id, $parentcontext->path); } else { $record = context::insert_context_record(CONTEXT_COURSE, $course->id, '/'.SYSCONTEXTID, 0); } } } if ($record) { $context = new context_course($record); context::cache_add($context); return $context; } return false; } /** * Create missing context instances at course context level * @static */ protected static function create_level_instances() { global $DB; $sql = "SELECT ".CONTEXT_COURSE.", c.id FROM {course} c WHERE NOT EXISTS (SELECT 'x' FROM {context} cx WHERE c.id = cx.instanceid AND cx.contextlevel=".CONTEXT_COURSE.")"; $contextdata = $DB->get_recordset_sql($sql); foreach ($contextdata as $context) { context::insert_context_record(CONTEXT_COURSE, $context->id, null); } $contextdata->close(); } /** * Returns sql necessary for purging of stale context instances. * * @static * @return string cleanup SQL */ protected static function get_cleanup_sql() { $sql = " SELECT c.* FROM {context} c LEFT OUTER JOIN {course} co ON c.instanceid = co.id WHERE co.id IS NULL AND c.contextlevel = ".CONTEXT_COURSE." "; return $sql; } /** * Rebuild context paths and depths at course context level. * * @static * @param bool $force */ protected static function build_paths($force) { global $DB; if ($force or $DB->record_exists_select('context', "contextlevel = ".CONTEXT_COURSE." AND (depth = 0 OR path IS NULL)")) { if ($force) { $ctxemptyclause = $emptyclause = ''; } else { $ctxemptyclause = "AND (ctx.path IS NULL OR ctx.depth = 0)"; $emptyclause = "AND ({context}.path IS NULL OR {context}.depth = 0)"; } $base = '/'.SYSCONTEXTID; // Standard frontpage $sql = "UPDATE {context} SET depth = 2, path = ".$DB->sql_concat("'$base/'", 'id')." WHERE contextlevel = ".CONTEXT_COURSE." AND EXISTS (SELECT 'x' FROM {course} c WHERE c.id = {context}.instanceid AND c.category = 0) $emptyclause"; $DB->execute($sql); // standard courses $sql = "INSERT INTO {context_temp} (id, path, depth, locked) SELECT ctx.id, ".$DB->sql_concat('pctx.path', "'/'", 'ctx.id').", pctx.depth+1, ctx.locked FROM {context} ctx JOIN {course} c ON (c.id = ctx.instanceid AND ctx.contextlevel = ".CONTEXT_COURSE." AND c.category <> 0) JOIN {context} pctx ON (pctx.instanceid = c.category AND pctx.contextlevel = ".CONTEXT_COURSECAT.") WHERE pctx.path IS NOT NULL AND pctx.depth > 0 $ctxemptyclause"; $trans = $DB->start_delegated_transaction(); $DB->delete_records('context_temp'); $DB->execute($sql); context::merge_context_temp_table(); $DB->delete_records('context_temp'); $trans->allow_commit(); } } } /** * Course module context class * * @package core_access * @category access * @copyright Petr Skoda {@link http://skodak.org} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later * @since Moodle 2.2 */ class context_module extends context { /** * Please use context_module::instance($cmid) if you need the instance of context. * Alternatively if you know only the context id use context::instance_by_id($contextid) * * @param stdClass $record */ protected function __construct(stdClass $record) { parent::__construct($record); if ($record->contextlevel != CONTEXT_MODULE) { throw new coding_exception('Invalid $record->contextlevel in context_module constructor.'); } } /** * Returns human readable context level name. * * @static * @return string the human readable context level name. */ public static function get_level_name() { return get_string('activitymodule'); } /** * Returns human readable context identifier. * * @param boolean $withprefix whether to prefix the name of the context with the * module name, e.g. Forum, Glossary, etc. * @param boolean $short does not apply to module context * @param boolean $escape Whether the returned name of the context is to be HTML escaped or not. * @return string the human readable context name. */ public function get_context_name($withprefix = true, $short = false, $escape = true) { global $DB; $name = ''; if ($cm = $DB->get_record_sql("SELECT cm.*, md.name AS modname FROM {course_modules} cm JOIN {modules} md ON md.id = cm.module WHERE cm.id = ?", array($this->_instanceid))) { if ($mod = $DB->get_record($cm->modname, array('id' => $cm->instance))) { if ($withprefix){ $name = get_string('modulename', $cm->modname).': '; } if (!$escape) { $name .= format_string($mod->name, true, array('context' => $this, 'escape' => false)); } else { $name .= format_string($mod->name, true, array('context' => $this)); } } } return $name; } /** * Returns the most relevant URL for this context. * * @return moodle_url */ public function get_url() { global $DB; if ($modname = $DB->get_field_sql("SELECT md.name AS modname FROM {course_modules} cm JOIN {modules} md ON md.id = cm.module WHERE cm.id = ?", array($this->_instanceid))) { return new moodle_url('/mod/' . $modname . '/view.php', array('id'=>$this->_instanceid)); } return new moodle_url('/'); } /** * Returns array of relevant context capability records. * * @param string $sort * @return array */ public function get_capabilities(string $sort = self::DEFAULT_CAPABILITY_SORT) { global $DB, $CFG; $cm = $DB->get_record('course_modules', array('id'=>$this->_instanceid)); $module = $DB->get_record('modules', array('id'=>$cm->module)); $subcaps = array(); $modulepath = "{$CFG->dirroot}/mod/{$module->name}"; if (file_exists("{$modulepath}/db/subplugins.json")) { $subplugins = (array) json_decode(file_get_contents("{$modulepath}/db/subplugins.json"))->plugintypes; } else if (file_exists("{$modulepath}/db/subplugins.php")) { debugging('Use of subplugins.php has been deprecated. ' . 'Please update your plugin to provide a subplugins.json file instead.', DEBUG_DEVELOPER); $subplugins = array(); // should be redefined in the file include("{$modulepath}/db/subplugins.php"); } if (!empty($subplugins)) { foreach (array_keys($subplugins) as $subplugintype) { foreach (array_keys(core_component::get_plugin_list($subplugintype)) as $subpluginname) { $subcaps = array_merge($subcaps, array_keys(load_capability_def($subplugintype.'_'.$subpluginname))); } } } $modfile = "{$modulepath}/lib.php"; $extracaps = array(); if (file_exists($modfile)) { include_once($modfile); $modfunction = $module->name.'_get_extra_capabilities'; if (function_exists($modfunction)) { $extracaps = $modfunction(); } } $extracaps = array_merge($subcaps, $extracaps); $extra = ''; list($extra, $params) = $DB->get_in_or_equal( $extracaps, SQL_PARAMS_NAMED, 'cap0', true, ''); if (!empty($extra)) { $extra = "OR name $extra"; } // Fetch the list of modules, and remove this one. $components = \core_component::get_component_list(); $componentnames = $components['mod']; unset($componentnames["mod_{$module->name}"]); $componentnames = array_keys($componentnames); // Exclude all other modules. list($notcompsql, $notcompparams) = $DB->get_in_or_equal($componentnames, SQL_PARAMS_NAMED, 'notcomp', false); $params = array_merge($params, $notcompparams); // Exclude other component submodules. $i = 0; $ignorecomponents = []; foreach ($componentnames as $mod) { if ($subplugins = \core_component::get_subplugins($mod)) { foreach (array_keys($subplugins) as $subplugintype) { $paramname = "notlike{$i}"; $ignorecomponents[] = $DB->sql_like('component', ":{$paramname}", true, true, true); $params[$paramname] = "{$subplugintype}_%"; $i++; } } } $notlikesql = "(" . implode(' AND ', $ignorecomponents) . ")"; $sql = "SELECT * FROM {capabilities} WHERE (contextlevel = ".CONTEXT_MODULE." AND component {$notcompsql} AND {$notlikesql}) $extra ORDER BY $sort"; return $DB->get_records_sql($sql, $params); } /** * Is this context part of any course? If yes return course context. * * @param bool $strict true means throw exception if not found, false means return false if not found * @return context_course context of the enclosing course, null if not found or exception */ public function get_course_context($strict = true) { return $this->get_parent_context(); } /** * Returns module context instance. * * @static * @param int $cmid id of the record from {course_modules} table; pass cmid there, NOT id in the instance column * @param int $strictness * @return context_module context instance */ public static function instance($cmid, $strictness = MUST_EXIST) { global $DB; if ($context = context::cache_get(CONTEXT_MODULE, $cmid)) { return $context; } if (!$record = $DB->get_record('context', array('contextlevel' => CONTEXT_MODULE, 'instanceid' => $cmid))) { if ($cm = $DB->get_record('course_modules', array('id' => $cmid), 'id,course', $strictness)) { $parentcontext = context_course::instance($cm->course); $record = context::insert_context_record(CONTEXT_MODULE, $cm->id, $parentcontext->path); } } if ($record) { $context = new context_module($record); context::cache_add($context); return $context; } return false; } /** * Create missing context instances at module context level * @static */ protected static function create_level_instances() { global $DB; $sql = "SELECT ".CONTEXT_MODULE.", cm.id FROM {course_modules} cm WHERE NOT EXISTS (SELECT 'x' FROM {context} cx WHERE cm.id = cx.instanceid AND cx.contextlevel=".CONTEXT_MODULE.")"; $contextdata = $DB->get_recordset_sql($sql); foreach ($contextdata as $context) { context::insert_context_record(CONTEXT_MODULE, $context->id, null); } $contextdata->close(); } /** * Returns sql necessary for purging of stale context instances. * * @static * @return string cleanup SQL */ protected static function get_cleanup_sql() { $sql = " SELECT c.* FROM {context} c LEFT OUTER JOIN {course_modules} cm ON c.instanceid = cm.id WHERE cm.id IS NULL AND c.contextlevel = ".CONTEXT_MODULE." "; return $sql; } /** * Rebuild context paths and depths at module context level. * * @static * @param bool $force */ protected static function build_paths($force) { global $DB; if ($force or $DB->record_exists_select('context', "contextlevel = ".CONTEXT_MODULE." AND (depth = 0 OR path IS NULL)")) { if ($force) { $ctxemptyclause = ''; } else { $ctxemptyclause = "AND (ctx.path IS NULL OR ctx.depth = 0)"; } $sql = "INSERT INTO {context_temp} (id, path, depth, locked) SELECT ctx.id, ".$DB->sql_concat('pctx.path', "'/'", 'ctx.id').", pctx.depth+1, ctx.locked FROM {context} ctx JOIN {course_modules} cm ON (cm.id = ctx.instanceid AND ctx.contextlevel = ".CONTEXT_MODULE.") JOIN {context} pctx ON (pctx.instanceid = cm.course AND pctx.contextlevel = ".CONTEXT_COURSE.") WHERE pctx.path IS NOT NULL AND pctx.depth > 0 $ctxemptyclause"; $trans = $DB->start_delegated_transaction(); $DB->delete_records('context_temp'); $DB->execute($sql); context::merge_context_temp_table(); $DB->delete_records('context_temp'); $trans->allow_commit(); } } } /** * Block context class * * @package core_access * @category access * @copyright Petr Skoda {@link http://skodak.org} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later * @since Moodle 2.2 */ class context_block extends context { /** * Please use context_block::instance($blockinstanceid) if you need the instance of context. * Alternatively if you know only the context id use context::instance_by_id($contextid) * * @param stdClass $record */ protected function __construct(stdClass $record) { parent::__construct($record); if ($record->contextlevel != CONTEXT_BLOCK) { throw new coding_exception('Invalid $record->contextlevel in context_block constructor'); } } /** * Returns human readable context level name. * * @static * @return string the human readable context level name. */ public static function get_level_name() { return get_string('block'); } /** * Returns human readable context identifier. * * @param boolean $withprefix whether to prefix the name of the context with Block * @param boolean $short does not apply to block context * @param boolean $escape does not apply to block context * @return string the human readable context name. */ public function get_context_name($withprefix = true, $short = false, $escape = true) { global $DB, $CFG; $name = ''; if ($blockinstance = $DB->get_record('block_instances', array('id'=>$this->_instanceid))) { global $CFG; require_once("$CFG->dirroot/blocks/moodleblock.class.php"); require_once("$CFG->dirroot/blocks/$blockinstance->blockname/block_$blockinstance->blockname.php"); $blockname = "block_$blockinstance->blockname"; if ($blockobject = new $blockname()) { if ($withprefix){ $name = get_string('block').': '; } $name .= $blockobject->title; } } return $name; } /** * Returns the most relevant URL for this context. * * @return moodle_url */ public function get_url() { $parentcontexts = $this->get_parent_context(); return $parentcontexts->get_url(); } /** * Returns array of relevant context capability records. * * @param string $sort * @return array */ public function get_capabilities(string $sort = self::DEFAULT_CAPABILITY_SORT) { global $DB; $bi = $DB->get_record('block_instances', array('id' => $this->_instanceid)); $select = '(contextlevel = :level AND component = :component)'; $params = [ 'level' => CONTEXT_BLOCK, 'component' => 'block_' . $bi->blockname, ]; $extracaps = block_method_result($bi->blockname, 'get_extra_capabilities'); if ($extracaps) { list($extra, $extraparams) = $DB->get_in_or_equal($extracaps, SQL_PARAMS_NAMED, 'cap'); $select .= " OR name $extra"; $params = array_merge($params, $extraparams); } return $DB->get_records_select('capabilities', $select, $params, $sort); } /** * Is this context part of any course? If yes return course context. * * @param bool $strict true means throw exception if not found, false means return false if not found * @return context_course context of the enclosing course, null if not found or exception */ public function get_course_context($strict = true) { $parentcontext = $this->get_parent_context(); return $parentcontext->get_course_context($strict); } /** * Returns block context instance. * * @static * @param int $blockinstanceid id from {block_instances} table. * @param int $strictness * @return context_block context instance */ public static function instance($blockinstanceid, $strictness = MUST_EXIST) { global $DB; if ($context = context::cache_get(CONTEXT_BLOCK, $blockinstanceid)) { return $context; } if (!$record = $DB->get_record('context', array('contextlevel' => CONTEXT_BLOCK, 'instanceid' => $blockinstanceid))) { if ($bi = $DB->get_record('block_instances', array('id' => $blockinstanceid), 'id,parentcontextid', $strictness)) { $parentcontext = context::instance_by_id($bi->parentcontextid); $record = context::insert_context_record(CONTEXT_BLOCK, $bi->id, $parentcontext->path); } } if ($record) { $context = new context_block($record); context::cache_add($context); return $context; } return false; } /** * Block do not have child contexts... * @return array */ public function get_child_contexts() { return array(); } /** * Create missing context instances at block context level * @static */ protected static function create_level_instances() { global $DB; $sql = <<<EOF INSERT INTO {context} ( contextlevel, instanceid ) SELECT :contextlevel, bi.id as instanceid FROM {block_instances} bi WHERE NOT EXISTS ( SELECT 'x' FROM {context} cx WHERE bi.id = cx.instanceid AND cx.contextlevel = :existingcontextlevel ) EOF; $DB->execute($sql, [ 'contextlevel' => CONTEXT_BLOCK, 'existingcontextlevel' => CONTEXT_BLOCK, ]); } /** * Returns sql necessary for purging of stale context instances. * * @static * @return string cleanup SQL */ protected static function get_cleanup_sql() { $sql = " SELECT c.* FROM {context} c LEFT OUTER JOIN {block_instances} bi ON c.instanceid = bi.id WHERE bi.id IS NULL AND c.contextlevel = ".CONTEXT_BLOCK." "; return $sql; } /** * Rebuild context paths and depths at block context level. * * @static * @param bool $force */ protected static function build_paths($force) { global $DB; if ($force or $DB->record_exists_select('context', "contextlevel = ".CONTEXT_BLOCK." AND (depth = 0 OR path IS NULL)")) { if ($force) { $ctxemptyclause = ''; } else { $ctxemptyclause = "AND (ctx.path IS NULL OR ctx.depth = 0)"; } // pctx.path IS NOT NULL prevents fatal problems with broken block instances that point to invalid context parent $sql = "INSERT INTO {context_temp} (id, path, depth, locked) SELECT ctx.id, ".$DB->sql_concat('pctx.path', "'/'", 'ctx.id').", pctx.depth+1, ctx.locked FROM {context} ctx JOIN {block_instances} bi ON (bi.id = ctx.instanceid AND ctx.contextlevel = ".CONTEXT_BLOCK.") JOIN {context} pctx ON (pctx.id = bi.parentcontextid) WHERE (pctx.path IS NOT NULL AND pctx.depth > 0) $ctxemptyclause"; $trans = $DB->start_delegated_transaction(); $DB->delete_records('context_temp'); $DB->execute($sql); context::merge_context_temp_table(); $DB->delete_records('context_temp'); $trans->allow_commit(); } } } // ============== DEPRECATED FUNCTIONS ========================================== // Old context related functions were deprecated in 2.0, it is recommended // to use context classes in new code. Old function can be used when // creating patches that are supposed to be backported to older stable branches. // These deprecated functions will not be removed in near future, // before removing devs will be warned with a debugging message first, // then we will add error message and only after that we can remove the functions // completely. /** * Runs get_records select on context table and returns the result * Does get_records_select on the context table, and returns the results ordered * by contextlevel, and then the natural sort order within each level. * for the purpose of $select, you need to know that the context table has been * aliased to ctx, so for example, you can call get_sorted_contexts('ctx.depth = 3'); * * @param string $select the contents of the WHERE clause. Remember to do ctx.fieldname. * @param array $params any parameters required by $select. * @return array the requested context records. */ function get_sorted_contexts($select, $params = array()) { //TODO: we should probably rewrite all the code that is using this thing, the trouble is we MUST NOT modify the context instances... global $DB; if ($select) { $select = 'WHERE ' . $select; } return $DB->get_records_sql(" SELECT ctx.* FROM {context} ctx LEFT JOIN {user} u ON ctx.contextlevel = " . CONTEXT_USER . " AND u.id = ctx.instanceid LEFT JOIN {course_categories} cat ON ctx.contextlevel = " . CONTEXT_COURSECAT . " AND cat.id = ctx.instanceid LEFT JOIN {course} c ON ctx.contextlevel = " . CONTEXT_COURSE . " AND c.id = ctx.instanceid LEFT JOIN {course_modules} cm ON ctx.contextlevel = " . CONTEXT_MODULE . " AND cm.id = ctx.instanceid LEFT JOIN {block_instances} bi ON ctx.contextlevel = " . CONTEXT_BLOCK . " AND bi.id = ctx.instanceid $select ORDER BY ctx.contextlevel, bi.defaultregion, COALESCE(cat.sortorder, c.sortorder, cm.section, bi.defaultweight), u.lastname, u.firstname, cm.id ", $params); } /** * Given context and array of users, returns array of users whose enrolment status is suspended, * or enrolment has expired or has not started. Also removes those users from the given array * * @param context $context context in which suspended users should be extracted. * @param array $users list of users. * @param array $ignoreusers array of user ids to ignore, e.g. guest * @return array list of suspended users. */ function extract_suspended_users($context, &$users, $ignoreusers=array()) { global $DB; // Get active enrolled users. list($sql, $params) = get_enrolled_sql($context, null, null, true); $activeusers = $DB->get_records_sql($sql, $params); // Move suspended users to a separate array & remove from the initial one. $susers = array(); if (sizeof($activeusers)) { foreach ($users as $userid => $user) { if (!array_key_exists($userid, $activeusers) && !in_array($userid, $ignoreusers)) { $susers[$userid] = $user; unset($users[$userid]); } } } return $susers; } /** * Given context and array of users, returns array of user ids whose enrolment status is suspended, * or enrolment has expired or not started. * * @param context $context context in which user enrolment is checked. * @param bool $usecache Enable or disable (default) the request cache * @return array list of suspended user id's. */ function get_suspended_userids(context $context, $usecache = false) { global $DB; if ($usecache) { $cache = cache::make('core', 'suspended_userids'); $susers = $cache->get($context->id); if ($susers !== false) { return $susers; } } $coursecontext = $context->get_course_context(); $susers = array(); // Front page users are always enrolled, so suspended list is empty. if ($coursecontext->instanceid != SITEID) { list($sql, $params) = get_enrolled_sql($context, null, null, false, true); $susers = $DB->get_fieldset_sql($sql, $params); $susers = array_combine($susers, $susers); } // Cache results for the remainder of this request. if ($usecache) { $cache->set($context->id, $susers); } return $susers; } /** * Gets sql for finding users with capability in the given context * * @param context $context * @param string|array $capability Capability name or array of names. * If an array is provided then this is the equivalent of a logical 'OR', * i.e. the user needs to have one of these capabilities. * @return array($sql, $params) */ function get_with_capability_sql(context $context, $capability) { static $i = 0; $i++; $prefix = 'cu' . $i . '_'; $capjoin = get_with_capability_join($context, $capability, $prefix . 'u.id'); $sql = "SELECT DISTINCT {$prefix}u.id FROM {user} {$prefix}u $capjoin->joins WHERE {$prefix}u.deleted = 0 AND $capjoin->wheres"; return array($sql, $capjoin->params); }