Merge branch 'w14_MDL-39004_m25_roledocs' of git://github.com/skodak/moodle
[moodle.git] / lib / accesslib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * This file contains functions for managing user access
19  *
20  * <b>Public API vs internals</b>
21  *
22  * General users probably only care about
23  *
24  * Context handling
25  * - context_course::instance($courseid), context_module::instance($cm->id), context_coursecat::instance($catid)
26  * - context::instance_by_id($contextid)
27  * - $context->get_parent_contexts();
28  * - $context->get_child_contexts();
29  *
30  * Whether the user can do something...
31  * - has_capability()
32  * - has_any_capability()
33  * - has_all_capabilities()
34  * - require_capability()
35  * - require_login() (from moodlelib)
36  * - is_enrolled()
37  * - is_viewing()
38  * - is_guest()
39  * - is_siteadmin()
40  * - isguestuser()
41  * - isloggedin()
42  *
43  * What courses has this user access to?
44  * - get_enrolled_users()
45  *
46  * What users can do X in this context?
47  * - get_enrolled_users() - at and bellow course context
48  * - get_users_by_capability() - above course context
49  *
50  * Modify roles
51  * - role_assign()
52  * - role_unassign()
53  * - role_unassign_all()
54  *
55  * Advanced - for internal use only
56  * - load_all_capabilities()
57  * - reload_all_capabilities()
58  * - has_capability_in_accessdata()
59  * - get_user_access_sitewide()
60  * - load_course_context()
61  * - load_role_access_by_context()
62  * - etc.
63  *
64  * <b>Name conventions</b>
65  *
66  * "ctx" means context
67  *
68  * <b>accessdata</b>
69  *
70  * Access control data is held in the "accessdata" array
71  * which - for the logged-in user, will be in $USER->access
72  *
73  * For other users can be generated and passed around (but may also be cached
74  * against userid in $ACCESSLIB_PRIVATE->accessdatabyuser).
75  *
76  * $accessdata is a multidimensional array, holding
77  * role assignments (RAs), role-capabilities-perm sets
78  * (role defs) and a list of courses we have loaded
79  * data for.
80  *
81  * Things are keyed on "contextpaths" (the path field of
82  * the context table) for fast walking up/down the tree.
83  * <code>
84  * $accessdata['ra'][$contextpath] = array($roleid=>$roleid)
85  *                  [$contextpath] = array($roleid=>$roleid)
86  *                  [$contextpath] = array($roleid=>$roleid)
87  * </code>
88  *
89  * Role definitions are stored like this
90  * (no cap merge is done - so it's compact)
91  *
92  * <code>
93  * $accessdata['rdef']["$contextpath:$roleid"]['mod/forum:viewpost'] = 1
94  *                                            ['mod/forum:editallpost'] = -1
95  *                                            ['mod/forum:startdiscussion'] = -1000
96  * </code>
97  *
98  * See how has_capability_in_accessdata() walks up the tree.
99  *
100  * First we only load rdef and ra down to the course level, but not below.
101  * This keeps accessdata small and compact. Below-the-course ra/rdef
102  * are loaded as needed. We keep track of which courses we have loaded ra/rdef in
103  * <code>
104  * $accessdata['loaded'] = array($courseid1=>1, $courseid2=>1)
105  * </code>
106  *
107  * <b>Stale accessdata</b>
108  *
109  * For the logged-in user, accessdata is long-lived.
110  *
111  * On each pageload we load $ACCESSLIB_PRIVATE->dirtycontexts which lists
112  * context paths affected by changes. Any check at-or-below
113  * a dirty context will trigger a transparent reload of accessdata.
114  *
115  * Changes at the system level will force the reload for everyone.
116  *
117  * <b>Default role caps</b>
118  * The default role assignment is not in the DB, so we
119  * add it manually to accessdata.
120  *
121  * This means that functions that work directly off the
122  * DB need to ensure that the default role caps
123  * are dealt with appropriately.
124  *
125  * @package    core_access
126  * @copyright  1999 onwards Martin Dougiamas  http://dougiamas.com
127  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
128  */
130 defined('MOODLE_INTERNAL') || die();
132 /** No capability change */
133 define('CAP_INHERIT', 0);
134 /** Allow permission, overrides CAP_PREVENT defined in parent contexts */
135 define('CAP_ALLOW', 1);
136 /** Prevent permission, overrides CAP_ALLOW defined in parent contexts */
137 define('CAP_PREVENT', -1);
138 /** Prohibit permission, overrides everything in current and child contexts */
139 define('CAP_PROHIBIT', -1000);
141 /** System context level - only one instance in every system */
142 define('CONTEXT_SYSTEM', 10);
143 /** User context level -  one instance for each user describing what others can do to user */
144 define('CONTEXT_USER', 30);
145 /** Course category context level - one instance for each category */
146 define('CONTEXT_COURSECAT', 40);
147 /** Course context level - one instances for each course */
148 define('CONTEXT_COURSE', 50);
149 /** Course module context level - one instance for each course module */
150 define('CONTEXT_MODULE', 70);
151 /**
152  * Block context level - one instance for each block, sticky blocks are tricky
153  * because ppl think they should be able to override them at lower contexts.
154  * Any other context level instance can be parent of block context.
155  */
156 define('CONTEXT_BLOCK', 80);
158 /** Capability allow management of trusts - NOT IMPLEMENTED YET - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
159 define('RISK_MANAGETRUST', 0x0001);
160 /** Capability allows changes in system configuration - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
161 define('RISK_CONFIG',      0x0002);
162 /** Capability allows user to add scripted content - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
163 define('RISK_XSS',         0x0004);
164 /** Capability allows access to personal user information - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
165 define('RISK_PERSONAL',    0x0008);
166 /** Capability allows users to add content others may see - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
167 define('RISK_SPAM',        0x0010);
168 /** capability allows mass delete of data belonging to other users - see {@link http://docs.moodle.org/dev/Hardening_new_Roles_system} */
169 define('RISK_DATALOSS',    0x0020);
171 /** rolename displays - the name as defined in the role definition, localised if name empty */
172 define('ROLENAME_ORIGINAL', 0);
173 /** rolename displays - the name as defined by a role alias at the course level, falls back to ROLENAME_ORIGINAL if alias not present */
174 define('ROLENAME_ALIAS', 1);
175 /** rolename displays - Both, like this:  Role alias (Original) */
176 define('ROLENAME_BOTH', 2);
177 /** rolename displays - the name as defined in the role definition and the shortname in brackets */
178 define('ROLENAME_ORIGINALANDSHORT', 3);
179 /** rolename displays - the name as defined by a role alias, in raw form suitable for editing */
180 define('ROLENAME_ALIAS_RAW', 4);
181 /** rolename displays - the name is simply short role name */
182 define('ROLENAME_SHORT', 5);
184 if (!defined('CONTEXT_CACHE_MAX_SIZE')) {
185     /** maximum size of context cache - it is possible to tweak this config.php or in any script before inclusion of context.php */
186     define('CONTEXT_CACHE_MAX_SIZE', 2500);
189 /**
190  * Although this looks like a global variable, it isn't really.
191  *
192  * It is just a private implementation detail to accesslib that MUST NOT be used elsewhere.
193  * It is used to cache various bits of data between function calls for performance reasons.
194  * Sadly, a PHP global variable is the only way to implement this, without rewriting everything
195  * as methods of a class, instead of functions.
196  *
197  * @access private
198  * @global stdClass $ACCESSLIB_PRIVATE
199  * @name $ACCESSLIB_PRIVATE
200  */
201 global $ACCESSLIB_PRIVATE;
202 $ACCESSLIB_PRIVATE = new stdClass();
203 $ACCESSLIB_PRIVATE->dirtycontexts    = null;    // Dirty contexts cache, loaded from DB once per page
204 $ACCESSLIB_PRIVATE->accessdatabyuser = array(); // Holds the cache of $accessdata structure for users (including $USER)
205 $ACCESSLIB_PRIVATE->rolepermissions  = array(); // role permissions cache - helps a lot with mem usage
206 $ACCESSLIB_PRIVATE->capabilities     = null;    // detailed information about the capabilities
208 /**
209  * Clears accesslib's private caches. ONLY BE USED BY UNIT TESTS
210  *
211  * This method should ONLY BE USED BY UNIT TESTS. It clears all of
212  * accesslib's private caches. You need to do this before setting up test data,
213  * and also at the end of the tests.
214  *
215  * @access private
216  * @return void
217  */
218 function accesslib_clear_all_caches_for_unit_testing() {
219     global $USER;
220     if (!PHPUNIT_TEST) {
221         throw new coding_exception('You must not call clear_all_caches outside of unit tests.');
222     }
224     accesslib_clear_all_caches(true);
226     unset($USER->access);
229 /**
230  * Clears accesslib's private caches. ONLY BE USED FROM THIS LIBRARY FILE!
231  *
232  * This reset does not touch global $USER.
233  *
234  * @access private
235  * @param bool $resetcontexts
236  * @return void
237  */
238 function accesslib_clear_all_caches($resetcontexts) {
239     global $ACCESSLIB_PRIVATE;
241     $ACCESSLIB_PRIVATE->dirtycontexts    = null;
242     $ACCESSLIB_PRIVATE->accessdatabyuser = array();
243     $ACCESSLIB_PRIVATE->rolepermissions  = array();
244     $ACCESSLIB_PRIVATE->capabilities     = null;
246     if ($resetcontexts) {
247         context_helper::reset_caches();
248     }
251 /**
252  * Gets the accessdata for role "sitewide" (system down to course)
253  *
254  * @access private
255  * @param int $roleid
256  * @return array
257  */
258 function get_role_access($roleid) {
259     global $DB, $ACCESSLIB_PRIVATE;
261     /* Get it in 1 DB query...
262      * - relevant role caps at the root and down
263      *   to the course level - but not below
264      */
266     //TODO: MUC - this could be cached in shared memory to speed up first page loading, web crawlers, etc.
268     $accessdata = get_empty_accessdata();
270     $accessdata['ra']['/'.SYSCONTEXTID] = array((int)$roleid => (int)$roleid);
272     // Overrides for the role IN ANY CONTEXTS down to COURSE - not below -.
274     /*
275     $sql = "SELECT ctx.path,
276                    rc.capability, rc.permission
277               FROM {context} ctx
278               JOIN {role_capabilities} rc ON rc.contextid = ctx.id
279          LEFT JOIN {context} cctx
280                    ON (cctx.contextlevel = ".CONTEXT_COURSE." AND ctx.path LIKE ".$DB->sql_concat('cctx.path',"'/%'").")
281              WHERE rc.roleid = ? AND cctx.id IS NULL";
282     $params = array($roleid);
283     */
285     // Note: the commented out query is 100% accurate but slow, so let's cheat instead by hardcoding the blocks mess directly.
287     $sql = "SELECT COALESCE(ctx.path, bctx.path) AS path, rc.capability, rc.permission
288               FROM {role_capabilities} rc
289          LEFT JOIN {context} ctx ON (ctx.id = rc.contextid AND ctx.contextlevel <= ".CONTEXT_COURSE.")
290          LEFT JOIN ({context} bctx
291                     JOIN {block_instances} bi ON (bi.id = bctx.instanceid)
292                     JOIN {context} pctx ON (pctx.id = bi.parentcontextid AND pctx.contextlevel < ".CONTEXT_COURSE.")
293                    ) ON (bctx.id = rc.contextid AND bctx.contextlevel = ".CONTEXT_BLOCK.")
294              WHERE rc.roleid = :roleid AND (ctx.id IS NOT NULL OR bctx.id IS NOT NULL)";
295     $params = array('roleid'=>$roleid);
297     // we need extra caching in CLI scripts and cron
298     $rs = $DB->get_recordset_sql($sql, $params);
299     foreach ($rs as $rd) {
300         $k = "{$rd->path}:{$roleid}";
301         $accessdata['rdef'][$k][$rd->capability] = (int)$rd->permission;
302     }
303     $rs->close();
305     // share the role definitions
306     foreach ($accessdata['rdef'] as $k=>$unused) {
307         if (!isset($ACCESSLIB_PRIVATE->rolepermissions[$k])) {
308             $ACCESSLIB_PRIVATE->rolepermissions[$k] = $accessdata['rdef'][$k];
309         }
310         $accessdata['rdef_count']++;
311         $accessdata['rdef'][$k] =& $ACCESSLIB_PRIVATE->rolepermissions[$k];
312     }
314     return $accessdata;
317 /**
318  * Get the default guest role, this is used for guest account,
319  * search engine spiders, etc.
320  *
321  * @return stdClass role record
322  */
323 function get_guest_role() {
324     global $CFG, $DB;
326     if (empty($CFG->guestroleid)) {
327         if ($roles = $DB->get_records('role', array('archetype'=>'guest'))) {
328             $guestrole = array_shift($roles);   // Pick the first one
329             set_config('guestroleid', $guestrole->id);
330             return $guestrole;
331         } else {
332             debugging('Can not find any guest role!');
333             return false;
334         }
335     } else {
336         if ($guestrole = $DB->get_record('role', array('id'=>$CFG->guestroleid))) {
337             return $guestrole;
338         } else {
339             // somebody is messing with guest roles, remove incorrect setting and try to find a new one
340             set_config('guestroleid', '');
341             return get_guest_role();
342         }
343     }
346 /**
347  * Check whether a user has a particular capability in a given context.
348  *
349  * For example:
350  *      $context = context_module::instance($cm->id);
351  *      has_capability('mod/forum:replypost', $context)
352  *
353  * By default checks the capabilities of the current user, but you can pass a
354  * different userid. By default will return true for admin users, but you can override that with the fourth argument.
355  *
356  * Guest and not-logged-in users can never get any dangerous capability - that is any write capability
357  * or capabilities with XSS, config or data loss risks.
358  *
359  * @category access
360  *
361  * @param string $capability the name of the capability to check. For example mod/forum:view
362  * @param context $context the context to check the capability in. You normally get this with instance method of a context class.
363  * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user.
364  * @param boolean $doanything If false, ignores effect of admin role assignment
365  * @return boolean true if the user has this capability. Otherwise false.
366  */
367 function has_capability($capability, context $context, $user = null, $doanything = true) {
368     global $USER, $CFG, $SCRIPT, $ACCESSLIB_PRIVATE;
370     if (during_initial_install()) {
371         if ($SCRIPT === "/$CFG->admin/index.php" or $SCRIPT === "/$CFG->admin/cli/install.php" or $SCRIPT === "/$CFG->admin/cli/install_database.php") {
372             // we are in an installer - roles can not work yet
373             return true;
374         } else {
375             return false;
376         }
377     }
379     if (strpos($capability, 'moodle/legacy:') === 0) {
380         throw new coding_exception('Legacy capabilities can not be used any more!');
381     }
383     if (!is_bool($doanything)) {
384         throw new coding_exception('Capability parameter "doanything" is wierd, only true or false is allowed. This has to be fixed in code.');
385     }
387     // capability must exist
388     if (!$capinfo = get_capability_info($capability)) {
389         debugging('Capability "'.$capability.'" was not found! This has to be fixed in code.');
390         return false;
391     }
393     if (!isset($USER->id)) {
394         // should never happen
395         $USER->id = 0;
396         debugging('Capability check being performed on a user with no ID.', DEBUG_DEVELOPER);
397     }
399     // make sure there is a real user specified
400     if ($user === null) {
401         $userid = $USER->id;
402     } else {
403         $userid = is_object($user) ? $user->id : $user;
404     }
406     // make sure forcelogin cuts off not-logged-in users if enabled
407     if (!empty($CFG->forcelogin) and $userid == 0) {
408         return false;
409     }
411     // make sure the guest account and not-logged-in users never get any risky caps no matter what the actual settings are.
412     if (($capinfo->captype === 'write') or ($capinfo->riskbitmask & (RISK_XSS | RISK_CONFIG | RISK_DATALOSS))) {
413         if (isguestuser($userid) or $userid == 0) {
414             return false;
415         }
416     }
418     // somehow make sure the user is not deleted and actually exists
419     if ($userid != 0) {
420         if ($userid == $USER->id and isset($USER->deleted)) {
421             // this prevents one query per page, it is a bit of cheating,
422             // but hopefully session is terminated properly once user is deleted
423             if ($USER->deleted) {
424                 return false;
425             }
426         } else {
427             if (!context_user::instance($userid, IGNORE_MISSING)) {
428                 // no user context == invalid userid
429                 return false;
430             }
431         }
432     }
434     // context path/depth must be valid
435     if (empty($context->path) or $context->depth == 0) {
436         // this should not happen often, each upgrade tries to rebuild the context paths
437         debugging('Context id '.$context->id.' does not have valid path, please use build_context_path()');
438         if (is_siteadmin($userid)) {
439             return true;
440         } else {
441             return false;
442         }
443     }
445     // Find out if user is admin - it is not possible to override the doanything in any way
446     // and it is not possible to switch to admin role either.
447     if ($doanything) {
448         if (is_siteadmin($userid)) {
449             if ($userid != $USER->id) {
450                 return true;
451             }
452             // make sure switchrole is not used in this context
453             if (empty($USER->access['rsw'])) {
454                 return true;
455             }
456             $parts = explode('/', trim($context->path, '/'));
457             $path = '';
458             $switched = false;
459             foreach ($parts as $part) {
460                 $path .= '/' . $part;
461                 if (!empty($USER->access['rsw'][$path])) {
462                     $switched = true;
463                     break;
464                 }
465             }
466             if (!$switched) {
467                 return true;
468             }
469             //ok, admin switched role in this context, let's use normal access control rules
470         }
471     }
473     // Careful check for staleness...
474     $context->reload_if_dirty();
476     if ($USER->id == $userid) {
477         if (!isset($USER->access)) {
478             load_all_capabilities();
479         }
480         $access =& $USER->access;
482     } else {
483         // make sure user accessdata is really loaded
484         get_user_accessdata($userid, true);
485         $access =& $ACCESSLIB_PRIVATE->accessdatabyuser[$userid];
486     }
489     // Load accessdata for below-the-course context if necessary,
490     // all contexts at and above all courses are already loaded
491     if ($context->contextlevel != CONTEXT_COURSE and $coursecontext = $context->get_course_context(false)) {
492         load_course_context($userid, $coursecontext, $access);
493     }
495     return has_capability_in_accessdata($capability, $context, $access);
498 /**
499  * Check if the user has any one of several capabilities from a list.
500  *
501  * This is just a utility method that calls has_capability in a loop. Try to put
502  * the capabilities that most users are likely to have first in the list for best
503  * performance.
504  *
505  * @category access
506  * @see has_capability()
507  *
508  * @param array $capabilities an array of capability names.
509  * @param context $context the context to check the capability in. You normally get this with instance method of a context class.
510  * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user.
511  * @param boolean $doanything If false, ignore effect of admin role assignment
512  * @return boolean true if the user has any of these capabilities. Otherwise false.
513  */
514 function has_any_capability(array $capabilities, context $context, $user = null, $doanything = true) {
515     foreach ($capabilities as $capability) {
516         if (has_capability($capability, $context, $user, $doanything)) {
517             return true;
518         }
519     }
520     return false;
523 /**
524  * Check if the user has all the capabilities in a list.
525  *
526  * This is just a utility method that calls has_capability in a loop. Try to put
527  * the capabilities that fewest users are likely to have first in the list for best
528  * performance.
529  *
530  * @category access
531  * @see has_capability()
532  *
533  * @param array $capabilities an array of capability names.
534  * @param context $context the context to check the capability in. You normally get this with instance method of a context class.
535  * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user.
536  * @param boolean $doanything If false, ignore effect of admin role assignment
537  * @return boolean true if the user has all of these capabilities. Otherwise false.
538  */
539 function has_all_capabilities(array $capabilities, context $context, $user = null, $doanything = true) {
540     foreach ($capabilities as $capability) {
541         if (!has_capability($capability, $context, $user, $doanything)) {
542             return false;
543         }
544     }
545     return true;
548 /**
549  * Check if the user is an admin at the site level.
550  *
551  * Please note that use of proper capabilities is always encouraged,
552  * this function is supposed to be used from core or for temporary hacks.
553  *
554  * @category access
555  *
556  * @param  int|stdClass  $user_or_id user id or user object
557  * @return bool true if user is one of the administrators, false otherwise
558  */
559 function is_siteadmin($user_or_id = null) {
560     global $CFG, $USER;
562     if ($user_or_id === null) {
563         $user_or_id = $USER;
564     }
566     if (empty($user_or_id)) {
567         return false;
568     }
569     if (!empty($user_or_id->id)) {
570         $userid = $user_or_id->id;
571     } else {
572         $userid = $user_or_id;
573     }
575     $siteadmins = explode(',', $CFG->siteadmins);
576     return in_array($userid, $siteadmins);
579 /**
580  * Returns true if user has at least one role assign
581  * of 'coursecontact' role (is potentially listed in some course descriptions).
582  *
583  * @param int $userid
584  * @return bool
585  */
586 function has_coursecontact_role($userid) {
587     global $DB, $CFG;
589     if (empty($CFG->coursecontact)) {
590         return false;
591     }
592     $sql = "SELECT 1
593               FROM {role_assignments}
594              WHERE userid = :userid AND roleid IN ($CFG->coursecontact)";
595     return $DB->record_exists_sql($sql, array('userid'=>$userid));
598 /**
599  * Does the user have a capability to do something?
600  *
601  * Walk the accessdata array and return true/false.
602  * Deals with prohibits, role switching, aggregating
603  * capabilities, etc.
604  *
605  * The main feature of here is being FAST and with no
606  * side effects.
607  *
608  * Notes:
609  *
610  * Switch Role merges with default role
611  * ------------------------------------
612  * If you are a teacher in course X, you have at least
613  * teacher-in-X + defaultloggedinuser-sitewide. So in the
614  * course you'll have techer+defaultloggedinuser.
615  * We try to mimic that in switchrole.
616  *
617  * Permission evaluation
618  * ---------------------
619  * Originally there was an extremely complicated way
620  * to determine the user access that dealt with
621  * "locality" or role assignments and role overrides.
622  * Now we simply evaluate access for each role separately
623  * and then verify if user has at least one role with allow
624  * and at the same time no role with prohibit.
625  *
626  * @access private
627  * @param string $capability
628  * @param context $context
629  * @param array $accessdata
630  * @return bool
631  */
632 function has_capability_in_accessdata($capability, context $context, array &$accessdata) {
633     global $CFG;
635     // Build $paths as a list of current + all parent "paths" with order bottom-to-top
636     $path = $context->path;
637     $paths = array($path);
638     while($path = rtrim($path, '0123456789')) {
639         $path = rtrim($path, '/');
640         if ($path === '') {
641             break;
642         }
643         $paths[] = $path;
644     }
646     $roles = array();
647     $switchedrole = false;
649     // Find out if role switched
650     if (!empty($accessdata['rsw'])) {
651         // From the bottom up...
652         foreach ($paths as $path) {
653             if (isset($accessdata['rsw'][$path])) {
654                 // Found a switchrole assignment - check for that role _plus_ the default user role
655                 $roles = array($accessdata['rsw'][$path]=>null, $CFG->defaultuserroleid=>null);
656                 $switchedrole = true;
657                 break;
658             }
659         }
660     }
662     if (!$switchedrole) {
663         // get all users roles in this context and above
664         foreach ($paths as $path) {
665             if (isset($accessdata['ra'][$path])) {
666                 foreach ($accessdata['ra'][$path] as $roleid) {
667                     $roles[$roleid] = null;
668                 }
669             }
670         }
671     }
673     // Now find out what access is given to each role, going bottom-->up direction
674     $allowed = false;
675     foreach ($roles as $roleid => $ignored) {
676         foreach ($paths as $path) {
677             if (isset($accessdata['rdef']["{$path}:$roleid"][$capability])) {
678                 $perm = (int)$accessdata['rdef']["{$path}:$roleid"][$capability];
679                 if ($perm === CAP_PROHIBIT) {
680                     // any CAP_PROHIBIT found means no permission for the user
681                     return false;
682                 }
683                 if (is_null($roles[$roleid])) {
684                     $roles[$roleid] = $perm;
685                 }
686             }
687         }
688         // CAP_ALLOW in any role means the user has a permission, we continue only to detect prohibits
689         $allowed = ($allowed or $roles[$roleid] === CAP_ALLOW);
690     }
692     return $allowed;
695 /**
696  * A convenience function that tests has_capability, and displays an error if
697  * the user does not have that capability.
698  *
699  * NOTE before Moodle 2.0, this function attempted to make an appropriate
700  * require_login call before checking the capability. This is no longer the case.
701  * You must call require_login (or one of its variants) if you want to check the
702  * user is logged in, before you call this function.
703  *
704  * @see has_capability()
705  *
706  * @param string $capability the name of the capability to check. For example mod/forum:view
707  * @param context $context the context to check the capability in. You normally get this with {@link get_context_instance}.
708  * @param int $userid A user id. By default (null) checks the permissions of the current user.
709  * @param bool $doanything If false, ignore effect of admin role assignment
710  * @param string $errormessage The error string to to user. Defaults to 'nopermissions'.
711  * @param string $stringfile The language file to load the error string from. Defaults to 'error'.
712  * @return void terminates with an error if the user does not have the given capability.
713  */
714 function require_capability($capability, context $context, $userid = null, $doanything = true,
715                             $errormessage = 'nopermissions', $stringfile = '') {
716     if (!has_capability($capability, $context, $userid, $doanything)) {
717         throw new required_capability_exception($context, $capability, $errormessage, $stringfile);
718     }
721 /**
722  * Return a nested array showing role assignments
723  * all relevant role capabilities for the user at
724  * site/course_category/course levels
725  *
726  * We do _not_ delve deeper than courses because the number of
727  * overrides at the module/block levels can be HUGE.
728  *
729  * [ra]   => [/path][roleid]=roleid
730  * [rdef] => [/path:roleid][capability]=permission
731  *
732  * @access private
733  * @param int $userid - the id of the user
734  * @return array access info array
735  */
736 function get_user_access_sitewide($userid) {
737     global $CFG, $DB, $ACCESSLIB_PRIVATE;
739     /* Get in a few cheap DB queries...
740      * - role assignments
741      * - relevant role caps
742      *   - above and within this user's RAs
743      *   - below this user's RAs - limited to course level
744      */
746     // raparents collects paths & roles we need to walk up the parenthood to build the minimal rdef
747     $raparents = array();
748     $accessdata = get_empty_accessdata();
750     // start with the default role
751     if (!empty($CFG->defaultuserroleid)) {
752         $syscontext = context_system::instance();
753         $accessdata['ra'][$syscontext->path][(int)$CFG->defaultuserroleid] = (int)$CFG->defaultuserroleid;
754         $raparents[$CFG->defaultuserroleid][$syscontext->id] = $syscontext->id;
755     }
757     // load the "default frontpage role"
758     if (!empty($CFG->defaultfrontpageroleid)) {
759         $frontpagecontext = context_course::instance(get_site()->id);
760         if ($frontpagecontext->path) {
761             $accessdata['ra'][$frontpagecontext->path][(int)$CFG->defaultfrontpageroleid] = (int)$CFG->defaultfrontpageroleid;
762             $raparents[$CFG->defaultfrontpageroleid][$frontpagecontext->id] = $frontpagecontext->id;
763         }
764     }
766     // preload every assigned role at and above course context
767     $sql = "SELECT ctx.path, ra.roleid, ra.contextid
768               FROM {role_assignments} ra
769               JOIN {context} ctx
770                    ON ctx.id = ra.contextid
771          LEFT JOIN {block_instances} bi
772                    ON (ctx.contextlevel = ".CONTEXT_BLOCK." AND bi.id = ctx.instanceid)
773          LEFT JOIN {context} bpctx
774                    ON (bpctx.id = bi.parentcontextid)
775              WHERE ra.userid = :userid
776                    AND (ctx.contextlevel <= ".CONTEXT_COURSE." OR bpctx.contextlevel < ".CONTEXT_COURSE.")";
777     $params = array('userid'=>$userid);
778     $rs = $DB->get_recordset_sql($sql, $params);
779     foreach ($rs as $ra) {
780         // RAs leafs are arrays to support multi-role assignments...
781         $accessdata['ra'][$ra->path][(int)$ra->roleid] = (int)$ra->roleid;
782         $raparents[$ra->roleid][$ra->contextid] = $ra->contextid;
783     }
784     $rs->close();
786     if (empty($raparents)) {
787         return $accessdata;
788     }
790     // now get overrides of interesting roles in all interesting child contexts
791     // hopefully we will not run out of SQL limits here,
792     // users would have to have very many roles at/above course context...
793     $sqls = array();
794     $params = array();
796     static $cp = 0;
797     foreach ($raparents as $roleid=>$ras) {
798         $cp++;
799         list($sqlcids, $cids) = $DB->get_in_or_equal($ras, SQL_PARAMS_NAMED, 'c'.$cp.'_');
800         $params = array_merge($params, $cids);
801         $params['r'.$cp] = $roleid;
802         $sqls[] = "(SELECT ctx.path, rc.roleid, rc.capability, rc.permission
803                      FROM {role_capabilities} rc
804                      JOIN {context} ctx
805                           ON (ctx.id = rc.contextid)
806                      JOIN {context} pctx
807                           ON (pctx.id $sqlcids
808                               AND (ctx.id = pctx.id
809                                    OR ctx.path LIKE ".$DB->sql_concat('pctx.path',"'/%'")."
810                                    OR pctx.path LIKE ".$DB->sql_concat('ctx.path',"'/%'")."))
811                 LEFT JOIN {block_instances} bi
812                           ON (ctx.contextlevel = ".CONTEXT_BLOCK." AND bi.id = ctx.instanceid)
813                 LEFT JOIN {context} bpctx
814                           ON (bpctx.id = bi.parentcontextid)
815                     WHERE rc.roleid = :r{$cp}
816                           AND (ctx.contextlevel <= ".CONTEXT_COURSE." OR bpctx.contextlevel < ".CONTEXT_COURSE.")
817                    )";
818     }
820     // fixed capability order is necessary for rdef dedupe
821     $rs = $DB->get_recordset_sql(implode("\nUNION\n", $sqls). "ORDER BY capability", $params);
823     foreach ($rs as $rd) {
824         $k = $rd->path.':'.$rd->roleid;
825         $accessdata['rdef'][$k][$rd->capability] = (int)$rd->permission;
826     }
827     $rs->close();
829     // share the role definitions
830     foreach ($accessdata['rdef'] as $k=>$unused) {
831         if (!isset($ACCESSLIB_PRIVATE->rolepermissions[$k])) {
832             $ACCESSLIB_PRIVATE->rolepermissions[$k] = $accessdata['rdef'][$k];
833         }
834         $accessdata['rdef_count']++;
835         $accessdata['rdef'][$k] =& $ACCESSLIB_PRIVATE->rolepermissions[$k];
836     }
838     return $accessdata;
841 /**
842  * Add to the access ctrl array the data needed by a user for a given course.
843  *
844  * This function injects all course related access info into the accessdata array.
845  *
846  * @access private
847  * @param int $userid the id of the user
848  * @param context_course $coursecontext course context
849  * @param array $accessdata accessdata array (modified)
850  * @return void modifies $accessdata parameter
851  */
852 function load_course_context($userid, context_course $coursecontext, &$accessdata) {
853     global $DB, $CFG, $ACCESSLIB_PRIVATE;
855     if (empty($coursecontext->path)) {
856         // weird, this should not happen
857         return;
858     }
860     if (isset($accessdata['loaded'][$coursecontext->instanceid])) {
861         // already loaded, great!
862         return;
863     }
865     $roles = array();
867     if (empty($userid)) {
868         if (!empty($CFG->notloggedinroleid)) {
869             $roles[$CFG->notloggedinroleid] = $CFG->notloggedinroleid;
870         }
872     } else if (isguestuser($userid)) {
873         if ($guestrole = get_guest_role()) {
874             $roles[$guestrole->id] = $guestrole->id;
875         }
877     } else {
878         // Interesting role assignments at, above and below the course context
879         list($parentsaself, $params) = $DB->get_in_or_equal($coursecontext->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'pc_');
880         $params['userid'] = $userid;
881         $params['children'] = $coursecontext->path."/%";
882         $sql = "SELECT ra.*, ctx.path
883                   FROM {role_assignments} ra
884                   JOIN {context} ctx ON ra.contextid = ctx.id
885                  WHERE ra.userid = :userid AND (ctx.id $parentsaself OR ctx.path LIKE :children)";
886         $rs = $DB->get_recordset_sql($sql, $params);
888         // add missing role definitions
889         foreach ($rs as $ra) {
890             $accessdata['ra'][$ra->path][(int)$ra->roleid] = (int)$ra->roleid;
891             $roles[$ra->roleid] = $ra->roleid;
892         }
893         $rs->close();
895         // add the "default frontpage role" when on the frontpage
896         if (!empty($CFG->defaultfrontpageroleid)) {
897             $frontpagecontext = context_course::instance(get_site()->id);
898             if ($frontpagecontext->id == $coursecontext->id) {
899                 $roles[$CFG->defaultfrontpageroleid] = $CFG->defaultfrontpageroleid;
900             }
901         }
903         // do not forget the default role
904         if (!empty($CFG->defaultuserroleid)) {
905             $roles[$CFG->defaultuserroleid] = $CFG->defaultuserroleid;
906         }
907     }
909     if (!$roles) {
910         // weird, default roles must be missing...
911         $accessdata['loaded'][$coursecontext->instanceid] = 1;
912         return;
913     }
915     // now get overrides of interesting roles in all interesting contexts (this course + children + parents)
916     $params = array('c'=>$coursecontext->id);
917     list($parentsaself, $rparams) = $DB->get_in_or_equal($coursecontext->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'pc_');
918     $params = array_merge($params, $rparams);
919     list($roleids, $rparams) = $DB->get_in_or_equal($roles, SQL_PARAMS_NAMED, 'r_');
920     $params = array_merge($params, $rparams);
922     $sql = "SELECT ctx.path, rc.roleid, rc.capability, rc.permission
923                  FROM {role_capabilities} rc
924                  JOIN {context} ctx
925                       ON (ctx.id = rc.contextid)
926                  JOIN {context} cctx
927                       ON (cctx.id = :c
928                           AND (ctx.id $parentsaself OR ctx.path LIKE ".$DB->sql_concat('cctx.path',"'/%'")."))
929                 WHERE rc.roleid $roleids
930              ORDER BY rc.capability"; // fixed capability order is necessary for rdef dedupe
931     $rs = $DB->get_recordset_sql($sql, $params);
933     $newrdefs = array();
934     foreach ($rs as $rd) {
935         $k = $rd->path.':'.$rd->roleid;
936         if (isset($accessdata['rdef'][$k])) {
937             continue;
938         }
939         $newrdefs[$k][$rd->capability] = (int)$rd->permission;
940     }
941     $rs->close();
943     // share new role definitions
944     foreach ($newrdefs as $k=>$unused) {
945         if (!isset($ACCESSLIB_PRIVATE->rolepermissions[$k])) {
946             $ACCESSLIB_PRIVATE->rolepermissions[$k] = $newrdefs[$k];
947         }
948         $accessdata['rdef_count']++;
949         $accessdata['rdef'][$k] =& $ACCESSLIB_PRIVATE->rolepermissions[$k];
950     }
952     $accessdata['loaded'][$coursecontext->instanceid] = 1;
954     // we want to deduplicate the USER->access from time to time, this looks like a good place,
955     // because we have to do it before the end of session
956     dedupe_user_access();
959 /**
960  * Add to the access ctrl array the data needed by a role for a given context.
961  *
962  * The data is added in the rdef key.
963  * This role-centric function is useful for role_switching
964  * and temporary course roles.
965  *
966  * @access private
967  * @param int $roleid the id of the user
968  * @param context $context needs path!
969  * @param array $accessdata accessdata array (is modified)
970  * @return array
971  */
972 function load_role_access_by_context($roleid, context $context, &$accessdata) {
973     global $DB, $ACCESSLIB_PRIVATE;
975     /* Get the relevant rolecaps into rdef
976      * - relevant role caps
977      *   - at ctx and above
978      *   - below this ctx
979      */
981     if (empty($context->path)) {
982         // weird, this should not happen
983         return;
984     }
986     list($parentsaself, $params) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'pc_');
987     $params['roleid'] = $roleid;
988     $params['childpath'] = $context->path.'/%';
990     $sql = "SELECT ctx.path, rc.capability, rc.permission
991               FROM {role_capabilities} rc
992               JOIN {context} ctx ON (rc.contextid = ctx.id)
993              WHERE rc.roleid = :roleid AND (ctx.id $parentsaself OR ctx.path LIKE :childpath)
994           ORDER BY rc.capability"; // fixed capability order is necessary for rdef dedupe
995     $rs = $DB->get_recordset_sql($sql, $params);
997     $newrdefs = array();
998     foreach ($rs as $rd) {
999         $k = $rd->path.':'.$roleid;
1000         if (isset($accessdata['rdef'][$k])) {
1001             continue;
1002         }
1003         $newrdefs[$k][$rd->capability] = (int)$rd->permission;
1004     }
1005     $rs->close();
1007     // share new role definitions
1008     foreach ($newrdefs as $k=>$unused) {
1009         if (!isset($ACCESSLIB_PRIVATE->rolepermissions[$k])) {
1010             $ACCESSLIB_PRIVATE->rolepermissions[$k] = $newrdefs[$k];
1011         }
1012         $accessdata['rdef_count']++;
1013         $accessdata['rdef'][$k] =& $ACCESSLIB_PRIVATE->rolepermissions[$k];
1014     }
1017 /**
1018  * Returns empty accessdata structure.
1019  *
1020  * @access private
1021  * @return array empt accessdata
1022  */
1023 function get_empty_accessdata() {
1024     $accessdata               = array(); // named list
1025     $accessdata['ra']         = array();
1026     $accessdata['rdef']       = array();
1027     $accessdata['rdef_count'] = 0;       // this bloody hack is necessary because count($array) is slooooowwww in PHP
1028     $accessdata['rdef_lcc']   = 0;       // rdef_count during the last compression
1029     $accessdata['loaded']     = array(); // loaded course contexts
1030     $accessdata['time']       = time();
1031     $accessdata['rsw']        = array();
1033     return $accessdata;
1036 /**
1037  * Get accessdata for a given user.
1038  *
1039  * @access private
1040  * @param int $userid
1041  * @param bool $preloadonly true means do not return access array
1042  * @return array accessdata
1043  */
1044 function get_user_accessdata($userid, $preloadonly=false) {
1045     global $CFG, $ACCESSLIB_PRIVATE, $USER;
1047     if (!empty($USER->acces['rdef']) and empty($ACCESSLIB_PRIVATE->rolepermissions)) {
1048         // share rdef from USER session with rolepermissions cache in order to conserve memory
1049         foreach($USER->acces['rdef'] as $k=>$v) {
1050             $ACCESSLIB_PRIVATE->rolepermissions[$k] =& $USER->acces['rdef'][$k];
1051         }
1052         $ACCESSLIB_PRIVATE->accessdatabyuser[$USER->id] = $USER->acces;
1053     }
1055     if (!isset($ACCESSLIB_PRIVATE->accessdatabyuser[$userid])) {
1056         if (empty($userid)) {
1057             if (!empty($CFG->notloggedinroleid)) {
1058                 $accessdata = get_role_access($CFG->notloggedinroleid);
1059             } else {
1060                 // weird
1061                 return get_empty_accessdata();
1062             }
1064         } else if (isguestuser($userid)) {
1065             if ($guestrole = get_guest_role()) {
1066                 $accessdata = get_role_access($guestrole->id);
1067             } else {
1068                 //weird
1069                 return get_empty_accessdata();
1070             }
1072         } else {
1073             $accessdata = get_user_access_sitewide($userid); // includes default role and frontpage role
1074         }
1076         $ACCESSLIB_PRIVATE->accessdatabyuser[$userid] = $accessdata;
1077     }
1079     if ($preloadonly) {
1080         return;
1081     } else {
1082         return $ACCESSLIB_PRIVATE->accessdatabyuser[$userid];
1083     }
1086 /**
1087  * Try to minimise the size of $USER->access by eliminating duplicate override storage,
1088  * this function looks for contexts with the same overrides and shares them.
1089  *
1090  * @access private
1091  * @return void
1092  */
1093 function dedupe_user_access() {
1094     global $USER;
1096     if (CLI_SCRIPT) {
1097         // no session in CLI --> no compression necessary
1098         return;
1099     }
1101     if (empty($USER->access['rdef_count'])) {
1102         // weird, this should not happen
1103         return;
1104     }
1106     // the rdef is growing only, we never remove stuff from it, the rdef_lcc helps us to detect new stuff in rdef
1107     if ($USER->access['rdef_count'] - $USER->access['rdef_lcc'] > 10) {
1108         // do not compress after each change, wait till there is more stuff to be done
1109         return;
1110     }
1112     $hashmap = array();
1113     foreach ($USER->access['rdef'] as $k=>$def) {
1114         $hash = sha1(serialize($def));
1115         if (isset($hashmap[$hash])) {
1116             $USER->access['rdef'][$k] =& $hashmap[$hash];
1117         } else {
1118             $hashmap[$hash] =& $USER->access['rdef'][$k];
1119         }
1120     }
1122     $USER->access['rdef_lcc'] = $USER->access['rdef_count'];
1125 /**
1126  * A convenience function to completely load all the capabilities
1127  * for the current user. It is called from has_capability() and functions change permissions.
1128  *
1129  * Call it only _after_ you've setup $USER and called check_enrolment_plugins();
1130  * @see check_enrolment_plugins()
1131  *
1132  * @access private
1133  * @return void
1134  */
1135 function load_all_capabilities() {
1136     global $USER;
1138     // roles not installed yet - we are in the middle of installation
1139     if (during_initial_install()) {
1140         return;
1141     }
1143     if (!isset($USER->id)) {
1144         // this should not happen
1145         $USER->id = 0;
1146     }
1148     unset($USER->access);
1149     $USER->access = get_user_accessdata($USER->id);
1151     // deduplicate the overrides to minimize session size
1152     dedupe_user_access();
1154     // Clear to force a refresh
1155     unset($USER->mycourses);
1157     // init/reset internal enrol caches - active course enrolments and temp access
1158     $USER->enrol = array('enrolled'=>array(), 'tempguest'=>array());
1161 /**
1162  * A convenience function to completely reload all the capabilities
1163  * for the current user when roles have been updated in a relevant
1164  * context -- but PRESERVING switchroles and loginas.
1165  * This function resets all accesslib and context caches.
1166  *
1167  * That is - completely transparent to the user.
1168  *
1169  * Note: reloads $USER->access completely.
1170  *
1171  * @access private
1172  * @return void
1173  */
1174 function reload_all_capabilities() {
1175     global $USER, $DB, $ACCESSLIB_PRIVATE;
1177     // copy switchroles
1178     $sw = array();
1179     if (!empty($USER->access['rsw'])) {
1180         $sw = $USER->access['rsw'];
1181     }
1183     accesslib_clear_all_caches(true);
1184     unset($USER->access);
1185     $ACCESSLIB_PRIVATE->dirtycontexts = array(); // prevent dirty flags refetching on this page
1187     load_all_capabilities();
1189     foreach ($sw as $path => $roleid) {
1190         if ($record = $DB->get_record('context', array('path'=>$path))) {
1191             $context = context::instance_by_id($record->id);
1192             role_switch($roleid, $context);
1193         }
1194     }
1197 /**
1198  * Adds a temp role to current USER->access array.
1199  *
1200  * Useful for the "temporary guest" access we grant to logged-in users.
1201  * This is useful for enrol plugins only.
1202  *
1203  * @since 2.2
1204  * @param context_course $coursecontext
1205  * @param int $roleid
1206  * @return void
1207  */
1208 function load_temp_course_role(context_course $coursecontext, $roleid) {
1209     global $USER, $SITE;
1211     if (empty($roleid)) {
1212         debugging('invalid role specified in load_temp_course_role()');
1213         return;
1214     }
1216     if ($coursecontext->instanceid == $SITE->id) {
1217         debugging('Can not use temp roles on the frontpage');
1218         return;
1219     }
1221     if (!isset($USER->access)) {
1222         load_all_capabilities();
1223     }
1225     $coursecontext->reload_if_dirty();
1227     if (isset($USER->access['ra'][$coursecontext->path][$roleid])) {
1228         return;
1229     }
1231     // load course stuff first
1232     load_course_context($USER->id, $coursecontext, $USER->access);
1234     $USER->access['ra'][$coursecontext->path][(int)$roleid] = (int)$roleid;
1236     load_role_access_by_context($roleid, $coursecontext, $USER->access);
1239 /**
1240  * Removes any extra guest roles from current USER->access array.
1241  * This is useful for enrol plugins only.
1242  *
1243  * @since 2.2
1244  * @param context_course $coursecontext
1245  * @return void
1246  */
1247 function remove_temp_course_roles(context_course $coursecontext) {
1248     global $DB, $USER, $SITE;
1250     if ($coursecontext->instanceid == $SITE->id) {
1251         debugging('Can not use temp roles on the frontpage');
1252         return;
1253     }
1255     if (empty($USER->access['ra'][$coursecontext->path])) {
1256         //no roles here, weird
1257         return;
1258     }
1260     $sql = "SELECT DISTINCT ra.roleid AS id
1261               FROM {role_assignments} ra
1262              WHERE ra.contextid = :contextid AND ra.userid = :userid";
1263     $ras = $DB->get_records_sql($sql, array('contextid'=>$coursecontext->id, 'userid'=>$USER->id));
1265     $USER->access['ra'][$coursecontext->path] = array();
1266     foreach($ras as $r) {
1267         $USER->access['ra'][$coursecontext->path][(int)$r->id] = (int)$r->id;
1268     }
1271 /**
1272  * Returns array of all role archetypes.
1273  *
1274  * @return array
1275  */
1276 function get_role_archetypes() {
1277     return array(
1278         'manager'        => 'manager',
1279         'coursecreator'  => 'coursecreator',
1280         'editingteacher' => 'editingteacher',
1281         'teacher'        => 'teacher',
1282         'student'        => 'student',
1283         'guest'          => 'guest',
1284         'user'           => 'user',
1285         'frontpage'      => 'frontpage'
1286     );
1289 /**
1290  * Assign the defaults found in this capability definition to roles that have
1291  * the corresponding legacy capabilities assigned to them.
1292  *
1293  * @param string $capability
1294  * @param array $legacyperms an array in the format (example):
1295  *                      'guest' => CAP_PREVENT,
1296  *                      'student' => CAP_ALLOW,
1297  *                      'teacher' => CAP_ALLOW,
1298  *                      'editingteacher' => CAP_ALLOW,
1299  *                      'coursecreator' => CAP_ALLOW,
1300  *                      'manager' => CAP_ALLOW
1301  * @return boolean success or failure.
1302  */
1303 function assign_legacy_capabilities($capability, $legacyperms) {
1305     $archetypes = get_role_archetypes();
1307     foreach ($legacyperms as $type => $perm) {
1309         $systemcontext = context_system::instance();
1310         if ($type === 'admin') {
1311             debugging('Legacy type admin in access.php was renamed to manager, please update the code.');
1312             $type = 'manager';
1313         }
1315         if (!array_key_exists($type, $archetypes)) {
1316             print_error('invalidlegacy', '', '', $type);
1317         }
1319         if ($roles = get_archetype_roles($type)) {
1320             foreach ($roles as $role) {
1321                 // Assign a site level capability.
1322                 if (!assign_capability($capability, $perm, $role->id, $systemcontext->id)) {
1323                     return false;
1324                 }
1325             }
1326         }
1327     }
1328     return true;
1331 /**
1332  * Verify capability risks.
1333  *
1334  * @param stdClass $capability a capability - a row from the capabilities table.
1335  * @return boolean whether this capability is safe - that is, whether people with the
1336  *      safeoverrides capability should be allowed to change it.
1337  */
1338 function is_safe_capability($capability) {
1339     return !((RISK_DATALOSS | RISK_MANAGETRUST | RISK_CONFIG | RISK_XSS | RISK_PERSONAL) & $capability->riskbitmask);
1342 /**
1343  * Get the local override (if any) for a given capability in a role in a context
1344  *
1345  * @param int $roleid
1346  * @param int $contextid
1347  * @param string $capability
1348  * @return stdClass local capability override
1349  */
1350 function get_local_override($roleid, $contextid, $capability) {
1351     global $DB;
1352     return $DB->get_record('role_capabilities', array('roleid'=>$roleid, 'capability'=>$capability, 'contextid'=>$contextid));
1355 /**
1356  * Returns context instance plus related course and cm instances
1357  *
1358  * @param int $contextid
1359  * @return array of ($context, $course, $cm)
1360  */
1361 function get_context_info_array($contextid) {
1362     global $DB;
1364     $context = context::instance_by_id($contextid, MUST_EXIST);
1365     $course  = null;
1366     $cm      = null;
1368     if ($context->contextlevel == CONTEXT_COURSE) {
1369         $course = $DB->get_record('course', array('id'=>$context->instanceid), '*', MUST_EXIST);
1371     } else if ($context->contextlevel == CONTEXT_MODULE) {
1372         $cm = get_coursemodule_from_id('', $context->instanceid, 0, false, MUST_EXIST);
1373         $course = $DB->get_record('course', array('id'=>$cm->course), '*', MUST_EXIST);
1375     } else if ($context->contextlevel == CONTEXT_BLOCK) {
1376         $parent = $context->get_parent_context();
1378         if ($parent->contextlevel == CONTEXT_COURSE) {
1379             $course = $DB->get_record('course', array('id'=>$parent->instanceid), '*', MUST_EXIST);
1380         } else if ($parent->contextlevel == CONTEXT_MODULE) {
1381             $cm = get_coursemodule_from_id('', $parent->instanceid, 0, false, MUST_EXIST);
1382             $course = $DB->get_record('course', array('id'=>$cm->course), '*', MUST_EXIST);
1383         }
1384     }
1386     return array($context, $course, $cm);
1389 /**
1390  * Function that creates a role
1391  *
1392  * @param string $name role name
1393  * @param string $shortname role short name
1394  * @param string $description role description
1395  * @param string $archetype
1396  * @return int id or dml_exception
1397  */
1398 function create_role($name, $shortname, $description, $archetype = '') {
1399     global $DB;
1401     if (strpos($archetype, 'moodle/legacy:') !== false) {
1402         throw new coding_exception('Use new role archetype parameter in create_role() instead of old legacy capabilities.');
1403     }
1405     // verify role archetype actually exists
1406     $archetypes = get_role_archetypes();
1407     if (empty($archetypes[$archetype])) {
1408         $archetype = '';
1409     }
1411     // Insert the role record.
1412     $role = new stdClass();
1413     $role->name        = $name;
1414     $role->shortname   = $shortname;
1415     $role->description = $description;
1416     $role->archetype   = $archetype;
1418     //find free sortorder number
1419     $role->sortorder = $DB->get_field('role', 'MAX(sortorder) + 1', array());
1420     if (empty($role->sortorder)) {
1421         $role->sortorder = 1;
1422     }
1423     $id = $DB->insert_record('role', $role);
1425     return $id;
1428 /**
1429  * Function that deletes a role and cleanups up after it
1430  *
1431  * @param int $roleid id of role to delete
1432  * @return bool always true
1433  */
1434 function delete_role($roleid) {
1435     global $DB;
1437     // first unssign all users
1438     role_unassign_all(array('roleid'=>$roleid));
1440     // cleanup all references to this role, ignore errors
1441     $DB->delete_records('role_capabilities',   array('roleid'=>$roleid));
1442     $DB->delete_records('role_allow_assign',   array('roleid'=>$roleid));
1443     $DB->delete_records('role_allow_assign',   array('allowassign'=>$roleid));
1444     $DB->delete_records('role_allow_override', array('roleid'=>$roleid));
1445     $DB->delete_records('role_allow_override', array('allowoverride'=>$roleid));
1446     $DB->delete_records('role_names',          array('roleid'=>$roleid));
1447     $DB->delete_records('role_context_levels', array('roleid'=>$roleid));
1449     // finally delete the role itself
1450     // get this before the name is gone for logging
1451     $rolename = $DB->get_field('role', 'name', array('id'=>$roleid));
1453     $DB->delete_records('role', array('id'=>$roleid));
1455     add_to_log(SITEID, 'role', 'delete', 'admin/roles/action=delete&roleid='.$roleid, $rolename, '');
1457     return true;
1460 /**
1461  * Function to write context specific overrides, or default capabilities.
1462  *
1463  * NOTE: use $context->mark_dirty() after this
1464  *
1465  * @param string $capability string name
1466  * @param int $permission CAP_ constants
1467  * @param int $roleid role id
1468  * @param int|context $contextid context id
1469  * @param bool $overwrite
1470  * @return bool always true or exception
1471  */
1472 function assign_capability($capability, $permission, $roleid, $contextid, $overwrite = false) {
1473     global $USER, $DB;
1475     if ($contextid instanceof context) {
1476         $context = $contextid;
1477     } else {
1478         $context = context::instance_by_id($contextid);
1479     }
1481     if (empty($permission) || $permission == CAP_INHERIT) { // if permission is not set
1482         unassign_capability($capability, $roleid, $context->id);
1483         return true;
1484     }
1486     $existing = $DB->get_record('role_capabilities', array('contextid'=>$context->id, 'roleid'=>$roleid, 'capability'=>$capability));
1488     if ($existing and !$overwrite) {   // We want to keep whatever is there already
1489         return true;
1490     }
1492     $cap = new stdClass();
1493     $cap->contextid    = $context->id;
1494     $cap->roleid       = $roleid;
1495     $cap->capability   = $capability;
1496     $cap->permission   = $permission;
1497     $cap->timemodified = time();
1498     $cap->modifierid   = empty($USER->id) ? 0 : $USER->id;
1500     if ($existing) {
1501         $cap->id = $existing->id;
1502         $DB->update_record('role_capabilities', $cap);
1503     } else {
1504         if ($DB->record_exists('context', array('id'=>$context->id))) {
1505             $DB->insert_record('role_capabilities', $cap);
1506         }
1507     }
1508     return true;
1511 /**
1512  * Unassign a capability from a role.
1513  *
1514  * NOTE: use $context->mark_dirty() after this
1515  *
1516  * @param string $capability the name of the capability
1517  * @param int $roleid the role id
1518  * @param int|context $contextid null means all contexts
1519  * @return boolean true or exception
1520  */
1521 function unassign_capability($capability, $roleid, $contextid = null) {
1522     global $DB;
1524     if (!empty($contextid)) {
1525         if ($contextid instanceof context) {
1526             $context = $contextid;
1527         } else {
1528             $context = context::instance_by_id($contextid);
1529         }
1530         // delete from context rel, if this is the last override in this context
1531         $DB->delete_records('role_capabilities', array('capability'=>$capability, 'roleid'=>$roleid, 'contextid'=>$context->id));
1532     } else {
1533         $DB->delete_records('role_capabilities', array('capability'=>$capability, 'roleid'=>$roleid));
1534     }
1535     return true;
1538 /**
1539  * Get the roles that have a given capability assigned to it
1540  *
1541  * This function does not resolve the actual permission of the capability.
1542  * It just checks for permissions and overrides.
1543  * Use get_roles_with_cap_in_context() if resolution is required.
1544  *
1545  * @param string $capability capability name (string)
1546  * @param string $permission optional, the permission defined for this capability
1547  *                      either CAP_ALLOW, CAP_PREVENT or CAP_PROHIBIT. Defaults to null which means any.
1548  * @param stdClass $context null means any
1549  * @return array of role records
1550  */
1551 function get_roles_with_capability($capability, $permission = null, $context = null) {
1552     global $DB;
1554     if ($context) {
1555         $contexts = $context->get_parent_context_ids(true);
1556         list($insql, $params) = $DB->get_in_or_equal($contexts, SQL_PARAMS_NAMED, 'ctx');
1557         $contextsql = "AND rc.contextid $insql";
1558     } else {
1559         $params = array();
1560         $contextsql = '';
1561     }
1563     if ($permission) {
1564         $permissionsql = " AND rc.permission = :permission";
1565         $params['permission'] = $permission;
1566     } else {
1567         $permissionsql = '';
1568     }
1570     $sql = "SELECT r.*
1571               FROM {role} r
1572              WHERE r.id IN (SELECT rc.roleid
1573                               FROM {role_capabilities} rc
1574                              WHERE rc.capability = :capname
1575                                    $contextsql
1576                                    $permissionsql)";
1577     $params['capname'] = $capability;
1580     return $DB->get_records_sql($sql, $params);
1583 /**
1584  * This function makes a role-assignment (a role for a user in a particular context)
1585  *
1586  * @param int $roleid the role of the id
1587  * @param int $userid userid
1588  * @param int|context $contextid id of the context
1589  * @param string $component example 'enrol_ldap', defaults to '' which means manual assignment,
1590  * @param int $itemid id of enrolment/auth plugin
1591  * @param string $timemodified defaults to current time
1592  * @return int new/existing id of the assignment
1593  */
1594 function role_assign($roleid, $userid, $contextid, $component = '', $itemid = 0, $timemodified = '') {
1595     global $USER, $DB;
1597     // first of all detect if somebody is using old style parameters
1598     if ($contextid === 0 or is_numeric($component)) {
1599         throw new coding_exception('Invalid call to role_assign(), code needs to be updated to use new order of parameters');
1600     }
1602     // now validate all parameters
1603     if (empty($roleid)) {
1604         throw new coding_exception('Invalid call to role_assign(), roleid can not be empty');
1605     }
1607     if (empty($userid)) {
1608         throw new coding_exception('Invalid call to role_assign(), userid can not be empty');
1609     }
1611     if ($itemid) {
1612         if (strpos($component, '_') === false) {
1613             throw new coding_exception('Invalid call to role_assign(), component must start with plugin type such as"enrol_" when itemid specified', 'component:'.$component);
1614         }
1615     } else {
1616         $itemid = 0;
1617         if ($component !== '' and strpos($component, '_') === false) {
1618             throw new coding_exception('Invalid call to role_assign(), invalid component string', 'component:'.$component);
1619         }
1620     }
1622     if (!$DB->record_exists('user', array('id'=>$userid, 'deleted'=>0))) {
1623         throw new coding_exception('User ID does not exist or is deleted!', 'userid:'.$userid);
1624     }
1626     if ($contextid instanceof context) {
1627         $context = $contextid;
1628     } else {
1629         $context = context::instance_by_id($contextid, MUST_EXIST);
1630     }
1632     if (!$timemodified) {
1633         $timemodified = time();
1634     }
1636     // Check for existing entry
1637     $ras = $DB->get_records('role_assignments', array('roleid'=>$roleid, 'contextid'=>$context->id, 'userid'=>$userid, 'component'=>$component, 'itemid'=>$itemid), 'id');
1639     if ($ras) {
1640         // role already assigned - this should not happen
1641         if (count($ras) > 1) {
1642             // very weird - remove all duplicates!
1643             $ra = array_shift($ras);
1644             foreach ($ras as $r) {
1645                 $DB->delete_records('role_assignments', array('id'=>$r->id));
1646             }
1647         } else {
1648             $ra = reset($ras);
1649         }
1651         // actually there is no need to update, reset anything or trigger any event, so just return
1652         return $ra->id;
1653     }
1655     // Create a new entry
1656     $ra = new stdClass();
1657     $ra->roleid       = $roleid;
1658     $ra->contextid    = $context->id;
1659     $ra->userid       = $userid;
1660     $ra->component    = $component;
1661     $ra->itemid       = $itemid;
1662     $ra->timemodified = $timemodified;
1663     $ra->modifierid   = empty($USER->id) ? 0 : $USER->id;
1665     $ra->id = $DB->insert_record('role_assignments', $ra);
1667     // mark context as dirty - again expensive, but needed
1668     $context->mark_dirty();
1670     if (!empty($USER->id) && $USER->id == $userid) {
1671         // If the user is the current user, then do full reload of capabilities too.
1672         reload_all_capabilities();
1673     }
1675     events_trigger('role_assigned', $ra);
1677     return $ra->id;
1680 /**
1681  * Removes one role assignment
1682  *
1683  * @param int $roleid
1684  * @param int  $userid
1685  * @param int|context  $contextid
1686  * @param string $component
1687  * @param int  $itemid
1688  * @return void
1689  */
1690 function role_unassign($roleid, $userid, $contextid, $component = '', $itemid = 0) {
1691     // first make sure the params make sense
1692     if ($roleid == 0 or $userid == 0 or $contextid == 0) {
1693         throw new coding_exception('Invalid call to role_unassign(), please use role_unassign_all() when removing multiple role assignments');
1694     }
1696     if ($itemid) {
1697         if (strpos($component, '_') === false) {
1698             throw new coding_exception('Invalid call to role_assign(), component must start with plugin type such as "enrol_" when itemid specified', 'component:'.$component);
1699         }
1700     } else {
1701         $itemid = 0;
1702         if ($component !== '' and strpos($component, '_') === false) {
1703             throw new coding_exception('Invalid call to role_assign(), invalid component string', 'component:'.$component);
1704         }
1705     }
1707     role_unassign_all(array('roleid'=>$roleid, 'userid'=>$userid, 'contextid'=>$contextid, 'component'=>$component, 'itemid'=>$itemid), false, false);
1710 /**
1711  * Removes multiple role assignments, parameters may contain:
1712  *   'roleid', 'userid', 'contextid', 'component', 'enrolid'.
1713  *
1714  * @param array $params role assignment parameters
1715  * @param bool $subcontexts unassign in subcontexts too
1716  * @param bool $includemanual include manual role assignments too
1717  * @return void
1718  */
1719 function role_unassign_all(array $params, $subcontexts = false, $includemanual = false) {
1720     global $USER, $CFG, $DB;
1722     if (!$params) {
1723         throw new coding_exception('Missing parameters in role_unsassign_all() call');
1724     }
1726     $allowed = array('roleid', 'userid', 'contextid', 'component', 'itemid');
1727     foreach ($params as $key=>$value) {
1728         if (!in_array($key, $allowed)) {
1729             throw new coding_exception('Unknown role_unsassign_all() parameter key', 'key:'.$key);
1730         }
1731     }
1733     if (isset($params['component']) and $params['component'] !== '' and strpos($params['component'], '_') === false) {
1734         throw new coding_exception('Invalid component paramter in role_unsassign_all() call', 'component:'.$params['component']);
1735     }
1737     if ($includemanual) {
1738         if (!isset($params['component']) or $params['component'] === '') {
1739             throw new coding_exception('include manual parameter requires component parameter in role_unsassign_all() call');
1740         }
1741     }
1743     if ($subcontexts) {
1744         if (empty($params['contextid'])) {
1745             throw new coding_exception('subcontexts paramtere requires component parameter in role_unsassign_all() call');
1746         }
1747     }
1749     $ras = $DB->get_records('role_assignments', $params);
1750     foreach($ras as $ra) {
1751         $DB->delete_records('role_assignments', array('id'=>$ra->id));
1752         if ($context = context::instance_by_id($ra->contextid, IGNORE_MISSING)) {
1753             // this is a bit expensive but necessary
1754             $context->mark_dirty();
1755             // If the user is the current user, then do full reload of capabilities too.
1756             if (!empty($USER->id) && $USER->id == $ra->userid) {
1757                 reload_all_capabilities();
1758             }
1759         }
1760         events_trigger('role_unassigned', $ra);
1761     }
1762     unset($ras);
1764     // process subcontexts
1765     if ($subcontexts and $context = context::instance_by_id($params['contextid'], IGNORE_MISSING)) {
1766         if ($params['contextid'] instanceof context) {
1767             $context = $params['contextid'];
1768         } else {
1769             $context = context::instance_by_id($params['contextid'], IGNORE_MISSING);
1770         }
1772         if ($context) {
1773             $contexts = $context->get_child_contexts();
1774             $mparams = $params;
1775             foreach($contexts as $context) {
1776                 $mparams['contextid'] = $context->id;
1777                 $ras = $DB->get_records('role_assignments', $mparams);
1778                 foreach($ras as $ra) {
1779                     $DB->delete_records('role_assignments', array('id'=>$ra->id));
1780                     // this is a bit expensive but necessary
1781                     $context->mark_dirty();
1782                     // If the user is the current user, then do full reload of capabilities too.
1783                     if (!empty($USER->id) && $USER->id == $ra->userid) {
1784                         reload_all_capabilities();
1785                     }
1786                     events_trigger('role_unassigned', $ra);
1787                 }
1788             }
1789         }
1790     }
1792     // do this once more for all manual role assignments
1793     if ($includemanual) {
1794         $params['component'] = '';
1795         role_unassign_all($params, $subcontexts, false);
1796     }
1799 /**
1800  * Determines if a user is currently logged in
1801  *
1802  * @category   access
1803  *
1804  * @return bool
1805  */
1806 function isloggedin() {
1807     global $USER;
1809     return (!empty($USER->id));
1812 /**
1813  * Determines if a user is logged in as real guest user with username 'guest'.
1814  *
1815  * @category   access
1816  *
1817  * @param int|object $user mixed user object or id, $USER if not specified
1818  * @return bool true if user is the real guest user, false if not logged in or other user
1819  */
1820 function isguestuser($user = null) {
1821     global $USER, $DB, $CFG;
1823     // make sure we have the user id cached in config table, because we are going to use it a lot
1824     if (empty($CFG->siteguest)) {
1825         if (!$guestid = $DB->get_field('user', 'id', array('username'=>'guest', 'mnethostid'=>$CFG->mnet_localhost_id))) {
1826             // guest does not exist yet, weird
1827             return false;
1828         }
1829         set_config('siteguest', $guestid);
1830     }
1831     if ($user === null) {
1832         $user = $USER;
1833     }
1835     if ($user === null) {
1836         // happens when setting the $USER
1837         return false;
1839     } else if (is_numeric($user)) {
1840         return ($CFG->siteguest == $user);
1842     } else if (is_object($user)) {
1843         if (empty($user->id)) {
1844             return false; // not logged in means is not be guest
1845         } else {
1846             return ($CFG->siteguest == $user->id);
1847         }
1849     } else {
1850         throw new coding_exception('Invalid user parameter supplied for isguestuser() function!');
1851     }
1854 /**
1855  * Does user have a (temporary or real) guest access to course?
1856  *
1857  * @category   access
1858  *
1859  * @param context $context
1860  * @param stdClass|int $user
1861  * @return bool
1862  */
1863 function is_guest(context $context, $user = null) {
1864     global $USER;
1866     // first find the course context
1867     $coursecontext = $context->get_course_context();
1869     // make sure there is a real user specified
1870     if ($user === null) {
1871         $userid = isset($USER->id) ? $USER->id : 0;
1872     } else {
1873         $userid = is_object($user) ? $user->id : $user;
1874     }
1876     if (isguestuser($userid)) {
1877         // can not inspect or be enrolled
1878         return true;
1879     }
1881     if (has_capability('moodle/course:view', $coursecontext, $user)) {
1882         // viewing users appear out of nowhere, they are neither guests nor participants
1883         return false;
1884     }
1886     // consider only real active enrolments here
1887     if (is_enrolled($coursecontext, $user, '', true)) {
1888         return false;
1889     }
1891     return true;
1894 /**
1895  * Returns true if the user has moodle/course:view capability in the course,
1896  * this is intended for admins, managers (aka small admins), inspectors, etc.
1897  *
1898  * @category   access
1899  *
1900  * @param context $context
1901  * @param int|stdClass $user if null $USER is used
1902  * @param string $withcapability extra capability name
1903  * @return bool
1904  */
1905 function is_viewing(context $context, $user = null, $withcapability = '') {
1906     // first find the course context
1907     $coursecontext = $context->get_course_context();
1909     if (isguestuser($user)) {
1910         // can not inspect
1911         return false;
1912     }
1914     if (!has_capability('moodle/course:view', $coursecontext, $user)) {
1915         // admins are allowed to inspect courses
1916         return false;
1917     }
1919     if ($withcapability and !has_capability($withcapability, $context, $user)) {
1920         // site admins always have the capability, but the enrolment above blocks
1921         return false;
1922     }
1924     return true;
1927 /**
1928  * Returns true if user is enrolled (is participating) in course
1929  * this is intended for students and teachers.
1930  *
1931  * Since 2.2 the result for active enrolments and current user are cached.
1932  *
1933  * @package   core_enrol
1934  * @category  access
1935  *
1936  * @param context $context
1937  * @param int|stdClass $user if null $USER is used, otherwise user object or id expected
1938  * @param string $withcapability extra capability name
1939  * @param bool $onlyactive consider only active enrolments in enabled plugins and time restrictions
1940  * @return bool
1941  */
1942 function is_enrolled(context $context, $user = null, $withcapability = '', $onlyactive = false) {
1943     global $USER, $DB;
1945     // first find the course context
1946     $coursecontext = $context->get_course_context();
1948     // make sure there is a real user specified
1949     if ($user === null) {
1950         $userid = isset($USER->id) ? $USER->id : 0;
1951     } else {
1952         $userid = is_object($user) ? $user->id : $user;
1953     }
1955     if (empty($userid)) {
1956         // not-logged-in!
1957         return false;
1958     } else if (isguestuser($userid)) {
1959         // guest account can not be enrolled anywhere
1960         return false;
1961     }
1963     if ($coursecontext->instanceid == SITEID) {
1964         // everybody participates on frontpage
1965     } else {
1966         // try cached info first - the enrolled flag is set only when active enrolment present
1967         if ($USER->id == $userid) {
1968             $coursecontext->reload_if_dirty();
1969             if (isset($USER->enrol['enrolled'][$coursecontext->instanceid])) {
1970                 if ($USER->enrol['enrolled'][$coursecontext->instanceid] > time()) {
1971                     if ($withcapability and !has_capability($withcapability, $context, $userid)) {
1972                         return false;
1973                     }
1974                     return true;
1975                 }
1976             }
1977         }
1979         if ($onlyactive) {
1980             // look for active enrolments only
1981             $until = enrol_get_enrolment_end($coursecontext->instanceid, $userid);
1983             if ($until === false) {
1984                 return false;
1985             }
1987             if ($USER->id == $userid) {
1988                 if ($until == 0) {
1989                     $until = ENROL_MAX_TIMESTAMP;
1990                 }
1991                 $USER->enrol['enrolled'][$coursecontext->instanceid] = $until;
1992                 if (isset($USER->enrol['tempguest'][$coursecontext->instanceid])) {
1993                     unset($USER->enrol['tempguest'][$coursecontext->instanceid]);
1994                     remove_temp_course_roles($coursecontext);
1995                 }
1996             }
1998         } else {
1999             // any enrolment is good for us here, even outdated, disabled or inactive
2000             $sql = "SELECT 'x'
2001                       FROM {user_enrolments} ue
2002                       JOIN {enrol} e ON (e.id = ue.enrolid AND e.courseid = :courseid)
2003                       JOIN {user} u ON u.id = ue.userid
2004                      WHERE ue.userid = :userid AND u.deleted = 0";
2005             $params = array('userid'=>$userid, 'courseid'=>$coursecontext->instanceid);
2006             if (!$DB->record_exists_sql($sql, $params)) {
2007                 return false;
2008             }
2009         }
2010     }
2012     if ($withcapability and !has_capability($withcapability, $context, $userid)) {
2013         return false;
2014     }
2016     return true;
2019 /**
2020  * Returns true if the user is able to access the course.
2021  *
2022  * This function is in no way, shape, or form a substitute for require_login.
2023  * It should only be used in circumstances where it is not possible to call require_login
2024  * such as the navigation.
2025  *
2026  * This function checks many of the methods of access to a course such as the view
2027  * capability, enrollments, and guest access. It also makes use of the cache
2028  * generated by require_login for guest access.
2029  *
2030  * The flags within the $USER object that are used here should NEVER be used outside
2031  * of this function can_access_course and require_login. Doing so WILL break future
2032  * versions.
2033  *
2034  * @param stdClass $course record
2035  * @param stdClass|int|null $user user record or id, current user if null
2036  * @param string $withcapability Check for this capability as well.
2037  * @param bool $onlyactive consider only active enrolments in enabled plugins and time restrictions
2038  * @return boolean Returns true if the user is able to access the course
2039  */
2040 function can_access_course(stdClass $course, $user = null, $withcapability = '', $onlyactive = false) {
2041     global $DB, $USER;
2043     // this function originally accepted $coursecontext parameter
2044     if ($course instanceof context) {
2045         if ($course instanceof context_course) {
2046             debugging('deprecated context parameter, please use $course record');
2047             $coursecontext = $course;
2048             $course = $DB->get_record('course', array('id'=>$coursecontext->instanceid));
2049         } else {
2050             debugging('Invalid context parameter, please use $course record');
2051             return false;
2052         }
2053     } else {
2054         $coursecontext = context_course::instance($course->id);
2055     }
2057     if (!isset($USER->id)) {
2058         // should never happen
2059         $USER->id = 0;
2060         debugging('Course access check being performed on a user with no ID.', DEBUG_DEVELOPER);
2061     }
2063     // make sure there is a user specified
2064     if ($user === null) {
2065         $userid = $USER->id;
2066     } else {
2067         $userid = is_object($user) ? $user->id : $user;
2068     }
2069     unset($user);
2071     if ($withcapability and !has_capability($withcapability, $coursecontext, $userid)) {
2072         return false;
2073     }
2075     if ($userid == $USER->id) {
2076         if (!empty($USER->access['rsw'][$coursecontext->path])) {
2077             // the fact that somebody switched role means they can access the course no matter to what role they switched
2078             return true;
2079         }
2080     }
2082     if (!$course->visible and !has_capability('moodle/course:viewhiddencourses', $coursecontext, $userid)) {
2083         return false;
2084     }
2086     if (is_viewing($coursecontext, $userid)) {
2087         return true;
2088     }
2090     if ($userid != $USER->id) {
2091         // for performance reasons we do not verify temporary guest access for other users, sorry...
2092         return is_enrolled($coursecontext, $userid, '', $onlyactive);
2093     }
2095     // === from here we deal only with $USER ===
2097     $coursecontext->reload_if_dirty();
2099     if (isset($USER->enrol['enrolled'][$course->id])) {
2100         if ($USER->enrol['enrolled'][$course->id] > time()) {
2101             return true;
2102         }
2103     }
2104     if (isset($USER->enrol['tempguest'][$course->id])) {
2105         if ($USER->enrol['tempguest'][$course->id] > time()) {
2106             return true;
2107         }
2108     }
2110     if (is_enrolled($coursecontext, $USER, '', $onlyactive)) {
2111         return true;
2112     }
2114     // if not enrolled try to gain temporary guest access
2115     $instances = $DB->get_records('enrol', array('courseid'=>$course->id, 'status'=>ENROL_INSTANCE_ENABLED), 'sortorder, id ASC');
2116     $enrols = enrol_get_plugins(true);
2117     foreach($instances as $instance) {
2118         if (!isset($enrols[$instance->enrol])) {
2119             continue;
2120         }
2121         // Get a duration for the guest access, a timestamp in the future, 0 (always) or false.
2122         $until = $enrols[$instance->enrol]->try_guestaccess($instance);
2123         if ($until !== false and $until > time()) {
2124             $USER->enrol['tempguest'][$course->id] = $until;
2125             return true;
2126         }
2127     }
2128     if (isset($USER->enrol['tempguest'][$course->id])) {
2129         unset($USER->enrol['tempguest'][$course->id]);
2130         remove_temp_course_roles($coursecontext);
2131     }
2133     return false;
2136 /**
2137  * Returns array with sql code and parameters returning all ids
2138  * of users enrolled into course.
2139  *
2140  * This function is using 'eu[0-9]+_' prefix for table names and parameters.
2141  *
2142  * @package   core_enrol
2143  * @category  access
2144  *
2145  * @param context $context
2146  * @param string $withcapability
2147  * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2148  * @param bool $onlyactive consider only active enrolments in enabled plugins and time restrictions
2149  * @return array list($sql, $params)
2150  */
2151 function get_enrolled_sql(context $context, $withcapability = '', $groupid = 0, $onlyactive = false) {
2152     global $DB, $CFG;
2154     // use unique prefix just in case somebody makes some SQL magic with the result
2155     static $i = 0;
2156     $i++;
2157     $prefix = 'eu'.$i.'_';
2159     // first find the course context
2160     $coursecontext = $context->get_course_context();
2162     $isfrontpage = ($coursecontext->instanceid == SITEID);
2164     $joins  = array();
2165     $wheres = array();
2166     $params = array();
2168     list($contextids, $contextpaths) = get_context_info_list($context);
2170     // get all relevant capability info for all roles
2171     if ($withcapability) {
2172         list($incontexts, $cparams) = $DB->get_in_or_equal($contextids, SQL_PARAMS_NAMED, 'ctx');
2173         $cparams['cap'] = $withcapability;
2175         $defs = array();
2176         $sql = "SELECT rc.id, rc.roleid, rc.permission, ctx.path
2177                   FROM {role_capabilities} rc
2178                   JOIN {context} ctx on rc.contextid = ctx.id
2179                  WHERE rc.contextid $incontexts AND rc.capability = :cap";
2180         $rcs = $DB->get_records_sql($sql, $cparams);
2181         foreach ($rcs as $rc) {
2182             $defs[$rc->path][$rc->roleid] = $rc->permission;
2183         }
2185         $access = array();
2186         if (!empty($defs)) {
2187             foreach ($contextpaths as $path) {
2188                 if (empty($defs[$path])) {
2189                     continue;
2190                 }
2191                 foreach($defs[$path] as $roleid => $perm) {
2192                     if ($perm == CAP_PROHIBIT) {
2193                         $access[$roleid] = CAP_PROHIBIT;
2194                         continue;
2195                     }
2196                     if (!isset($access[$roleid])) {
2197                         $access[$roleid] = (int)$perm;
2198                     }
2199                 }
2200             }
2201         }
2203         unset($defs);
2205         // make lists of roles that are needed and prohibited
2206         $needed     = array(); // one of these is enough
2207         $prohibited = array(); // must not have any of these
2208         foreach ($access as $roleid => $perm) {
2209             if ($perm == CAP_PROHIBIT) {
2210                 unset($needed[$roleid]);
2211                 $prohibited[$roleid] = true;
2212             } else if ($perm == CAP_ALLOW and empty($prohibited[$roleid])) {
2213                 $needed[$roleid] = true;
2214             }
2215         }
2217         $defaultuserroleid      = isset($CFG->defaultuserroleid) ? $CFG->defaultuserroleid : 0;
2218         $defaultfrontpageroleid = isset($CFG->defaultfrontpageroleid) ? $CFG->defaultfrontpageroleid : 0;
2220         $nobody = false;
2222         if ($isfrontpage) {
2223             if (!empty($prohibited[$defaultuserroleid]) or !empty($prohibited[$defaultfrontpageroleid])) {
2224                 $nobody = true;
2225             } else if (!empty($needed[$defaultuserroleid]) or !empty($needed[$defaultfrontpageroleid])) {
2226                 // everybody not having prohibit has the capability
2227                 $needed = array();
2228             } else if (empty($needed)) {
2229                 $nobody = true;
2230             }
2231         } else {
2232             if (!empty($prohibited[$defaultuserroleid])) {
2233                 $nobody = true;
2234             } else if (!empty($needed[$defaultuserroleid])) {
2235                 // everybody not having prohibit has the capability
2236                 $needed = array();
2237             } else if (empty($needed)) {
2238                 $nobody = true;
2239             }
2240         }
2242         if ($nobody) {
2243             // nobody can match so return some SQL that does not return any results
2244             $wheres[] = "1 = 2";
2246         } else {
2248             if ($needed) {
2249                 $ctxids = implode(',', $contextids);
2250                 $roleids = implode(',', array_keys($needed));
2251                 $joins[] = "JOIN {role_assignments} {$prefix}ra3 ON ({$prefix}ra3.userid = {$prefix}u.id AND {$prefix}ra3.roleid IN ($roleids) AND {$prefix}ra3.contextid IN ($ctxids))";
2252             }
2254             if ($prohibited) {
2255                 $ctxids = implode(',', $contextids);
2256                 $roleids = implode(',', array_keys($prohibited));
2257                 $joins[] = "LEFT JOIN {role_assignments} {$prefix}ra4 ON ({$prefix}ra4.userid = {$prefix}u.id AND {$prefix}ra4.roleid IN ($roleids) AND {$prefix}ra4.contextid IN ($ctxids))";
2258                 $wheres[] = "{$prefix}ra4.id IS NULL";
2259             }
2261             if ($groupid) {
2262                 $joins[] = "JOIN {groups_members} {$prefix}gm ON ({$prefix}gm.userid = {$prefix}u.id AND {$prefix}gm.groupid = :{$prefix}gmid)";
2263                 $params["{$prefix}gmid"] = $groupid;
2264             }
2265         }
2267     } else {
2268         if ($groupid) {
2269             $joins[] = "JOIN {groups_members} {$prefix}gm ON ({$prefix}gm.userid = {$prefix}u.id AND {$prefix}gm.groupid = :{$prefix}gmid)";
2270             $params["{$prefix}gmid"] = $groupid;
2271         }
2272     }
2274     $wheres[] = "{$prefix}u.deleted = 0 AND {$prefix}u.id <> :{$prefix}guestid";
2275     $params["{$prefix}guestid"] = $CFG->siteguest;
2277     if ($isfrontpage) {
2278         // all users are "enrolled" on the frontpage
2279     } else {
2280         $joins[] = "JOIN {user_enrolments} {$prefix}ue ON {$prefix}ue.userid = {$prefix}u.id";
2281         $joins[] = "JOIN {enrol} {$prefix}e ON ({$prefix}e.id = {$prefix}ue.enrolid AND {$prefix}e.courseid = :{$prefix}courseid)";
2282         $params[$prefix.'courseid'] = $coursecontext->instanceid;
2284         if ($onlyactive) {
2285             $wheres[] = "{$prefix}ue.status = :{$prefix}active AND {$prefix}e.status = :{$prefix}enabled";
2286             $wheres[] = "{$prefix}ue.timestart < :{$prefix}now1 AND ({$prefix}ue.timeend = 0 OR {$prefix}ue.timeend > :{$prefix}now2)";
2287             $now = round(time(), -2); // rounding helps caching in DB
2288             $params = array_merge($params, array($prefix.'enabled'=>ENROL_INSTANCE_ENABLED,
2289                                                  $prefix.'active'=>ENROL_USER_ACTIVE,
2290                                                  $prefix.'now1'=>$now, $prefix.'now2'=>$now));
2291         }
2292     }
2294     $joins = implode("\n", $joins);
2295     $wheres = "WHERE ".implode(" AND ", $wheres);
2297     $sql = "SELECT DISTINCT {$prefix}u.id
2298               FROM {user} {$prefix}u
2299             $joins
2300            $wheres";
2302     return array($sql, $params);
2305 /**
2306  * Returns list of users enrolled into course.
2307  *
2308  * @package   core_enrol
2309  * @category  access
2310  *
2311  * @param context $context
2312  * @param string $withcapability
2313  * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2314  * @param string $userfields requested user record fields
2315  * @param string $orderby
2316  * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set).
2317  * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set).
2318  * @param bool $onlyactive consider only active enrolments in enabled plugins and time restrictions
2319  * @return array of user records
2320  */
2321 function get_enrolled_users(context $context, $withcapability = '', $groupid = 0, $userfields = 'u.*', $orderby = null,
2322         $limitfrom = 0, $limitnum = 0, $onlyactive = false) {
2323     global $DB;
2325     list($esql, $params) = get_enrolled_sql($context, $withcapability, $groupid, $onlyactive);
2326     $sql = "SELECT $userfields
2327               FROM {user} u
2328               JOIN ($esql) je ON je.id = u.id
2329              WHERE u.deleted = 0";
2331     if ($orderby) {
2332         $sql = "$sql ORDER BY $orderby";
2333     } else {
2334         list($sort, $sortparams) = users_order_by_sql('u');
2335         $sql = "$sql ORDER BY $sort";
2336         $params = array_merge($params, $sortparams);
2337     }
2339     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
2342 /**
2343  * Counts list of users enrolled into course (as per above function)
2344  *
2345  * @package   core_enrol
2346  * @category  access
2347  *
2348  * @param context $context
2349  * @param string $withcapability
2350  * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2351  * @param bool $onlyactive consider only active enrolments in enabled plugins and time restrictions
2352  * @return array of user records
2353  */
2354 function count_enrolled_users(context $context, $withcapability = '', $groupid = 0, $onlyactive = false) {
2355     global $DB;
2357     list($esql, $params) = get_enrolled_sql($context, $withcapability, $groupid, $onlyactive);
2358     $sql = "SELECT count(u.id)
2359               FROM {user} u
2360               JOIN ($esql) je ON je.id = u.id
2361              WHERE u.deleted = 0";
2363     return $DB->count_records_sql($sql, $params);
2366 /**
2367  * Loads the capability definitions for the component (from file).
2368  *
2369  * Loads the capability definitions for the component (from file). If no
2370  * capabilities are defined for the component, we simply return an empty array.
2371  *
2372  * @access private
2373  * @param string $component full plugin name, examples: 'moodle', 'mod_forum'
2374  * @return array array of capabilities
2375  */
2376 function load_capability_def($component) {
2377     $defpath = get_component_directory($component).'/db/access.php';
2379     $capabilities = array();
2380     if (file_exists($defpath)) {
2381         require($defpath);
2382         if (!empty(${$component.'_capabilities'})) {
2383             // BC capability array name
2384             // since 2.0 we prefer $capabilities instead - it is easier to use and matches db/* files
2385             debugging('componentname_capabilities array is deprecated, please use $capabilities array only in access.php files');
2386             $capabilities = ${$component.'_capabilities'};
2387         }
2388     }
2390     return $capabilities;
2393 /**
2394  * Gets the capabilities that have been cached in the database for this component.
2395  *
2396  * @access private
2397  * @param string $component - examples: 'moodle', 'mod_forum'
2398  * @return array array of capabilities
2399  */
2400 function get_cached_capabilities($component = 'moodle') {
2401     global $DB;
2402     return $DB->get_records('capabilities', array('component'=>$component));
2405 /**
2406  * Returns default capabilities for given role archetype.
2407  *
2408  * @param string $archetype role archetype
2409  * @return array
2410  */
2411 function get_default_capabilities($archetype) {
2412     global $DB;
2414     if (!$archetype) {
2415         return array();
2416     }
2418     $alldefs = array();
2419     $defaults = array();
2420     $components = array();
2421     $allcaps = $DB->get_records('capabilities');
2423     foreach ($allcaps as $cap) {
2424         if (!in_array($cap->component, $components)) {
2425             $components[] = $cap->component;
2426             $alldefs = array_merge($alldefs, load_capability_def($cap->component));
2427         }
2428     }
2429     foreach($alldefs as $name=>$def) {
2430         // Use array 'archetypes if available. Only if not specified, use 'legacy'.
2431         if (isset($def['archetypes'])) {
2432             if (isset($def['archetypes'][$archetype])) {
2433                 $defaults[$name] = $def['archetypes'][$archetype];
2434             }
2435         // 'legacy' is for backward compatibility with 1.9 access.php
2436         } else {
2437             if (isset($def['legacy'][$archetype])) {
2438                 $defaults[$name] = $def['legacy'][$archetype];
2439             }
2440         }
2441     }
2443     return $defaults;
2446 /**
2447  * Reset role capabilities to default according to selected role archetype.
2448  * If no archetype selected, removes all capabilities.
2449  *
2450  * @param int $roleid
2451  * @return void
2452  */
2453 function reset_role_capabilities($roleid) {
2454     global $DB;
2456     $role = $DB->get_record('role', array('id'=>$roleid), '*', MUST_EXIST);
2457     $defaultcaps = get_default_capabilities($role->archetype);
2459     $systemcontext = context_system::instance();
2461     $DB->delete_records('role_capabilities', array('roleid'=>$roleid));
2463     foreach($defaultcaps as $cap=>$permission) {
2464         assign_capability($cap, $permission, $roleid, $systemcontext->id);
2465     }
2468 /**
2469  * Updates the capabilities table with the component capability definitions.
2470  * If no parameters are given, the function updates the core moodle
2471  * capabilities.
2472  *
2473  * Note that the absence of the db/access.php capabilities definition file
2474  * will cause any stored capabilities for the component to be removed from
2475  * the database.
2476  *
2477  * @access private
2478  * @param string $component examples: 'moodle', 'mod/forum', 'block/quiz_results'
2479  * @return boolean true if success, exception in case of any problems
2480  */
2481 function update_capabilities($component = 'moodle') {
2482     global $DB, $OUTPUT;
2484     $storedcaps = array();
2486     $filecaps = load_capability_def($component);
2487     foreach($filecaps as $capname=>$unused) {
2488         if (!preg_match('|^[a-z]+/[a-z_0-9]+:[a-z_0-9]+$|', $capname)) {
2489             debugging("Coding problem: Invalid capability name '$capname', use 'clonepermissionsfrom' field for migration.");
2490         }
2491     }
2493     $cachedcaps = get_cached_capabilities($component);
2494     if ($cachedcaps) {
2495         foreach ($cachedcaps as $cachedcap) {
2496             array_push($storedcaps, $cachedcap->name);
2497             // update risk bitmasks and context levels in existing capabilities if needed
2498             if (array_key_exists($cachedcap->name, $filecaps)) {
2499                 if (!array_key_exists('riskbitmask', $filecaps[$cachedcap->name])) {
2500                     $filecaps[$cachedcap->name]['riskbitmask'] = 0; // no risk if not specified
2501                 }
2502                 if ($cachedcap->captype != $filecaps[$cachedcap->name]['captype']) {
2503                     $updatecap = new stdClass();
2504                     $updatecap->id = $cachedcap->id;
2505                     $updatecap->captype = $filecaps[$cachedcap->name]['captype'];
2506                     $DB->update_record('capabilities', $updatecap);
2507                 }
2508                 if ($cachedcap->riskbitmask != $filecaps[$cachedcap->name]['riskbitmask']) {
2509                     $updatecap = new stdClass();
2510                     $updatecap->id = $cachedcap->id;
2511                     $updatecap->riskbitmask = $filecaps[$cachedcap->name]['riskbitmask'];
2512                     $DB->update_record('capabilities', $updatecap);
2513                 }
2515                 if (!array_key_exists('contextlevel', $filecaps[$cachedcap->name])) {
2516                     $filecaps[$cachedcap->name]['contextlevel'] = 0; // no context level defined
2517                 }
2518                 if ($cachedcap->contextlevel != $filecaps[$cachedcap->name]['contextlevel']) {
2519                     $updatecap = new stdClass();
2520                     $updatecap->id = $cachedcap->id;
2521                     $updatecap->contextlevel = $filecaps[$cachedcap->name]['contextlevel'];
2522                     $DB->update_record('capabilities', $updatecap);
2523                 }
2524             }
2525         }
2526     }
2528     // Are there new capabilities in the file definition?
2529     $newcaps = array();
2531     foreach ($filecaps as $filecap => $def) {
2532         if (!$storedcaps ||
2533                 ($storedcaps && in_array($filecap, $storedcaps) === false)) {
2534             if (!array_key_exists('riskbitmask', $def)) {
2535                 $def['riskbitmask'] = 0; // no risk if not specified
2536             }
2537             $newcaps[$filecap] = $def;
2538         }
2539     }
2540     // Add new capabilities to the stored definition.
2541     $existingcaps = $DB->get_records_menu('capabilities', array(), 'id', 'id, name');
2542     foreach ($newcaps as $capname => $capdef) {
2543         $capability = new stdClass();
2544         $capability->name         = $capname;
2545         $capability->captype      = $capdef['captype'];
2546         $capability->contextlevel = $capdef['contextlevel'];
2547         $capability->component    = $component;
2548         $capability->riskbitmask  = $capdef['riskbitmask'];
2550         $DB->insert_record('capabilities', $capability, false);
2552         if (isset($capdef['clonepermissionsfrom']) && in_array($capdef['clonepermissionsfrom'], $existingcaps)){
2553             if ($rolecapabilities = $DB->get_records('role_capabilities', array('capability'=>$capdef['clonepermissionsfrom']))){
2554                 foreach ($rolecapabilities as $rolecapability){
2555                     //assign_capability will update rather than insert if capability exists
2556                     if (!assign_capability($capname, $rolecapability->permission,
2557                                             $rolecapability->roleid, $rolecapability->contextid, true)){
2558                          echo $OUTPUT->notification('Could not clone capabilities for '.$capname);
2559                     }
2560                 }
2561             }
2562         // we ignore archetype key if we have cloned permissions
2563         } else if (isset($capdef['archetypes']) && is_array($capdef['archetypes'])) {
2564             assign_legacy_capabilities($capname, $capdef['archetypes']);
2565         // 'legacy' is for backward compatibility with 1.9 access.php
2566         } else if (isset($capdef['legacy']) && is_array($capdef['legacy'])) {
2567             assign_legacy_capabilities($capname, $capdef['legacy']);
2568         }
2569     }
2570     // Are there any capabilities that have been removed from the file
2571     // definition that we need to delete from the stored capabilities and
2572     // role assignments?
2573     capabilities_cleanup($component, $filecaps);
2575     // reset static caches
2576     accesslib_clear_all_caches(false);
2578     return true;
2581 /**
2582  * Deletes cached capabilities that are no longer needed by the component.
2583  * Also unassigns these capabilities from any roles that have them.
2584  *
2585  * @access private
2586  * @param string $component examples: 'moodle', 'mod_forum', 'block_quiz_results'
2587  * @param array $newcapdef array of the new capability definitions that will be
2588  *                     compared with the cached capabilities
2589  * @return int number of deprecated capabilities that have been removed
2590  */
2591 function capabilities_cleanup($component, $newcapdef = null) {
2592     global $DB;
2594     $removedcount = 0;
2596     if ($cachedcaps = get_cached_capabilities($component)) {
2597         foreach ($cachedcaps as $cachedcap) {
2598             if (empty($newcapdef) ||
2599                         array_key_exists($cachedcap->name, $newcapdef) === false) {
2601                 // Remove from capabilities cache.
2602                 $DB->delete_records('capabilities', array('name'=>$cachedcap->name));
2603                 $removedcount++;
2604                 // Delete from roles.
2605                 if ($roles = get_roles_with_capability($cachedcap->name)) {
2606                     foreach($roles as $role) {
2607                         if (!unassign_capability($cachedcap->name, $role->id)) {
2608                             print_error('cannotunassigncap', 'error', '', (object)array('cap'=>$cachedcap->name, 'role'=>$role->name));
2609                         }
2610                     }
2611                 }
2612             } // End if.
2613         }
2614     }
2615     return $removedcount;
2618 /**
2619  * Returns an array of all the known types of risk
2620  * The array keys can be used, for example as CSS class names, or in calls to
2621  * print_risk_icon. The values are the corresponding RISK_ constants.
2622  *
2623  * @return array all the known types of risk.
2624  */
2625 function get_all_risks() {
2626     return array(
2627         'riskmanagetrust' => RISK_MANAGETRUST,
2628         'riskconfig'      => RISK_CONFIG,
2629         'riskxss'         => RISK_XSS,
2630         'riskpersonal'    => RISK_PERSONAL,
2631         'riskspam'        => RISK_SPAM,
2632         'riskdataloss'    => RISK_DATALOSS,
2633     );
2636 /**
2637  * Return a link to moodle docs for a given capability name
2638  *
2639  * @param stdClass $capability a capability - a row from the mdl_capabilities table.
2640  * @return string the human-readable capability name as a link to Moodle Docs.
2641  */
2642 function get_capability_docs_link($capability) {
2643     $url = get_docs_url('Capabilities/' . $capability->name);
2644     return '<a onclick="this.target=\'docspopup\'" href="' . $url . '">' . get_capability_string($capability->name) . '</a>';
2647 /**
2648  * This function pulls out all the resolved capabilities (overrides and
2649  * defaults) of a role used in capability overrides in contexts at a given
2650  * context.
2651  *
2652  * @param int $roleid
2653  * @param context $context
2654  * @param string $cap capability, optional, defaults to ''
2655  * @return array Array of capabilities
2656  */
2657 function role_context_capabilities($roleid, context $context, $cap = '') {
2658     global $DB;
2660     $contexts = $context->get_parent_context_ids(true);
2661     $contexts = '('.implode(',', $contexts).')';
2663     $params = array($roleid);
2665     if ($cap) {
2666         $search = " AND rc.capability = ? ";
2667         $params[] = $cap;
2668     } else {
2669         $search = '';
2670     }
2672     $sql = "SELECT rc.*
2673               FROM {role_capabilities} rc, {context} c
2674              WHERE rc.contextid in $contexts
2675                    AND rc.roleid = ?
2676                    AND rc.contextid = c.id $search
2677           ORDER BY c.contextlevel DESC, rc.capability DESC";
2679     $capabilities = array();
2681     if ($records = $DB->get_records_sql($sql, $params)) {
2682         // We are traversing via reverse order.
2683         foreach ($records as $record) {
2684             // If not set yet (i.e. inherit or not set at all), or currently we have a prohibit
2685             if (!isset($capabilities[$record->capability]) || $record->permission<-500) {
2686                 $capabilities[$record->capability] = $record->permission;
2687             }
2688         }
2689     }
2690     return $capabilities;
2693 /**
2694  * Constructs array with contextids as first parameter and context paths,
2695  * in both cases bottom top including self.
2696  *
2697  * @access private
2698  * @param context $context
2699  * @return array
2700  */
2701 function get_context_info_list(context $context) {
2702     $contextids = explode('/', ltrim($context->path, '/'));
2703     $contextpaths = array();
2704     $contextids2 = $contextids;
2705     while ($contextids2) {
2706         $contextpaths[] = '/' . implode('/', $contextids2);
2707         array_pop($contextids2);
2708     }
2709     return array($contextids, $contextpaths);
2712 /**
2713  * Check if context is the front page context or a context inside it
2714  *
2715  * Returns true if this context is the front page context, or a context inside it,
2716  * otherwise false.
2717  *
2718  * @param context $context a context object.
2719  * @return bool
2720  */
2721 function is_inside_frontpage(context $context) {
2722     $frontpagecontext = context_course::instance(SITEID);
2723     return strpos($context->path . '/', $frontpagecontext->path . '/') === 0;
2726 /**
2727  * Returns capability information (cached)
2728  *
2729  * @param string $capabilityname
2730  * @return stdClass or null if capability not found
2731  */
2732 function get_capability_info($capabilityname) {
2733     global $ACCESSLIB_PRIVATE, $DB; // one request per page only
2735     //TODO: MUC - this could be cached in shared memory, it would eliminate 1 query per page
2737     if (empty($ACCESSLIB_PRIVATE->capabilities)) {
2738         $ACCESSLIB_PRIVATE->capabilities = array();
2739         $caps = $DB->get_records('capabilities', array(), 'id, name, captype, riskbitmask');
2740         foreach ($caps as $cap) {
2741             $capname = $cap->name;
2742             unset($cap->id);
2743             unset($cap->name);
2744             $cap->riskbitmask = (int)$cap->riskbitmask;
2745             $ACCESSLIB_PRIVATE->capabilities[$capname] = $cap;
2746         }
2747     }
2749     return isset($ACCESSLIB_PRIVATE->capabilities[$capabilityname]) ? $ACCESSLIB_PRIVATE->capabilities[$capabilityname] : null;
2752 /**
2753  * Returns the human-readable, translated version of the capability.
2754  * Basically a big switch statement.
2755  *
2756  * @param string $capabilityname e.g. mod/choice:readresponses
2757  * @return string
2758  */
2759 function get_capability_string($capabilityname) {
2761     // Typical capability name is 'plugintype/pluginname:capabilityname'
2762     list($type, $name, $capname) = preg_split('|[/:]|', $capabilityname);
2764     if ($type === 'moodle') {
2765         $component = 'core_role';
2766     } else if ($type === 'quizreport') {
2767         //ugly hack!!
2768         $component = 'quiz_'.$name;
2769     } else {
2770         $component = $type.'_'.$name;
2771     }
2773     $stringname = $name.':'.$capname;
2775     if ($component === 'core_role' or get_string_manager()->string_exists($stringname, $component)) {
2776         return get_string($stringname, $component);
2777     }
2779     $dir = get_component_directory($component);
2780     if (!file_exists($dir)) {
2781         // plugin broken or does not exist, do not bother with printing of debug message
2782         return $capabilityname.' ???';
2783     }
2785     // something is wrong in plugin, better print debug
2786     return get_string($stringname, $component);
2789 /**
2790  * This gets the mod/block/course/core etc strings.
2791  *
2792  * @param string $component
2793  * @param int $contextlevel
2794  * @return string|bool String is success, false if failed
2795  */
2796 function get_component_string($component, $contextlevel) {
2798     if ($component === 'moodle' or $component === 'core') {
2799         switch ($contextlevel) {
2800             // TODO: this should probably use context level names instead
2801             case CONTEXT_SYSTEM:    return get_string('coresystem');
2802             case CONTEXT_USER:      return get_string('users');
2803             case CONTEXT_COURSECAT: return get_string('categories');
2804             case CONTEXT_COURSE:    return get_string('course');
2805             case CONTEXT_MODULE:    return get_string('activities');
2806             case CONTEXT_BLOCK:     return get_string('block');
2807             default:                print_error('unknowncontext');
2808         }
2809     }
2811     list($type, $name) = normalize_component($component);
2812     $dir = get_plugin_directory($type, $name);
2813     if (!file_exists($dir)) {
2814         // plugin not installed, bad luck, there is no way to find the name
2815         return $component.' ???';
2816     }
2818     switch ($type) {
2819         // TODO: this is really hacky, anyway it should be probably moved to lib/pluginlib.php
2820         case 'quiz':         return get_string($name.':componentname', $component);// insane hack!!!
2821         case 'repository':   return get_string('repository', 'repository').': '.get_string('pluginname', $component);
2822         case 'gradeimport':  return get_string('gradeimport', 'grades').': '.get_string('pluginname', $component);
2823         case 'gradeexport':  return get_string('gradeexport', 'grades').': '.get_string('pluginname', $component);
2824         case 'gradereport':  return get_string('gradereport', 'grades').': '.get_string('pluginname', $component);
2825         case 'webservice':   return get_string('webservice', 'webservice').': '.get_string('pluginname', $component);
2826         case 'block':        return get_string('block').': '.get_string('pluginname', basename($component));
2827         case 'mod':
2828             if (get_string_manager()->string_exists('pluginname', $component)) {
2829                 return get_string('activity').': '.get_string('pluginname', $component);
2830             } else {
2831                 return get_string('activity').': '.get_string('modulename', $component);
2832             }
2833         default: return get_string('pluginname', $component);
2834     }
2837 /**
2838  * Gets the list of roles assigned to this context and up (parents)
2839  * from the list of roles that are visible on user profile page
2840  * and participants page.
2841  *
2842  * @param context $context
2843  * @return array
2844  */
2845 function get_profile_roles(context $context) {
2846     global $CFG, $DB;
2848     if (empty($CFG->profileroles)) {
2849         return array();
2850     }
2852     list($rallowed, $params) = $DB->get_in_or_equal(explode(',', $CFG->profileroles), SQL_PARAMS_NAMED, 'a');
2853     list($contextlist, $cparams) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'p');
2854     $params = array_merge($params, $cparams);
2856     if ($coursecontext = $context->get_course_context(false)) {
2857         $params['coursecontext'] = $coursecontext->id;
2858     } else {
2859         $params['coursecontext'] = 0;
2860     }
2862     $sql = "SELECT DISTINCT r.id, r.name, r.shortname, r.sortorder, rn.name AS coursealias
2863               FROM {role_assignments} ra, {role} r
2864          LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id)
2865              WHERE r.id = ra.roleid
2866                    AND ra.contextid $contextlist
2867                    AND r.id $rallowed
2868           ORDER BY r.sortorder ASC";
2870     return $DB->get_records_sql($sql, $params);
2873 /**
2874  * Gets the list of roles assigned to this context and up (parents)
2875  *
2876  * @param context $context
2877  * @return array
2878  */
2879 function get_roles_used_in_context(context $context) {
2880     global $DB;
2882     list($contextlist, $params) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'cl');
2884     if ($coursecontext = $context->get_course_context(false)) {
2885         $params['coursecontext'] = $coursecontext->id;
2886     } else {
2887         $params['coursecontext'] = 0;
2888     }
2890     $sql = "SELECT DISTINCT r.id, r.name, r.shortname, r.sortorder, rn.name AS coursealias
2891               FROM {role_assignments} ra, {role} r
2892          LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id)
2893              WHERE r.id = ra.roleid
2894                    AND ra.contextid $contextlist
2895           ORDER BY r.sortorder ASC";
2897     return $DB->get_records_sql($sql, $params);
2900 /**
2901  * This function is used to print roles column in user profile page.
2902  * It is using the CFG->profileroles to limit the list to only interesting roles.
2903  * (The permission tab has full details of user role assignments.)
2904  *
2905  * @param int $userid
2906  * @param int $courseid
2907  * @return string
2908  */
2909 function get_user_roles_in_course($userid, $courseid) {
2910     global $CFG, $DB;
2912     if (empty($CFG->profileroles)) {
2913         return '';
2914     }
2916     if ($courseid == SITEID) {
2917         $context = context_system::instance();
2918     } else {
2919         $context = context_course::instance($courseid);
2920     }
2922     if (empty($CFG->profileroles)) {
2923         return array();
2924     }
2926     list($rallowed, $params) = $DB->get_in_or_equal(explode(',', $CFG->profileroles), SQL_PARAMS_NAMED, 'a');
2927     list($contextlist, $cparams) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'p');
2928     $params = array_merge($params, $cparams);
2930     if ($coursecontext = $context->get_course_context(false)) {
2931         $params['coursecontext'] = $coursecontext->id;
2932     } else {
2933         $params['coursecontext'] = 0;
2934     }
2936     $sql = "SELECT DISTINCT r.id, r.name, r.shortname, r.sortorder, rn.name AS coursealias
2937               FROM {role_assignments} ra, {role} r
2938          LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id)
2939              WHERE r.id = ra.roleid
2940                    AND ra.contextid $contextlist
2941                    AND r.id $rallowed
2942                    AND ra.userid = :userid
2943           ORDER BY r.sortorder ASC";
2944     $params['userid'] = $userid;
2946     $rolestring = '';
2948     if ($roles = $DB->get_records_sql($sql, $params)) {
2949         $rolenames = role_fix_names($roles, $context, ROLENAME_ALIAS, true);   // Substitute aliases
2951         foreach ($rolenames as $roleid => $rolename) {
2952             $rolenames[$roleid] = '<a href="'.$CFG->wwwroot.'/user/index.php?contextid='.$context->id.'&amp;roleid='.$roleid.'">'.$rolename.'</a>';
2953         }
2954         $rolestring = implode(',', $rolenames);
2955     }
2957     return $rolestring;
2960 /**
2961  * Checks if a user can assign users to a particular role in this context
2962  *
2963  * @param context $context
2964  * @param int $targetroleid - the id of the role you want to assign users to
2965  * @return boolean
2966  */
2967 function user_can_assign(context $context, $targetroleid) {
2968     global $DB;
2970     // First check to see if the user is a site administrator.
2971     if (is_siteadmin()) {
2972         return true;
2973     }
2975     // Check if user has override capability.
2976     // If not return false.
2977     if (!has_capability('moodle/role:assign', $context)) {
2978         return false;
2979     }
2980     // pull out all active roles of this user from this context(or above)
2981     if ($userroles = get_user_roles($context)) {
2982         foreach ($userroles as $userrole) {
2983             // if any in the role_allow_override table, then it's ok
2984             if ($DB->get_record('role_allow_assign', array('roleid'=>$userrole->roleid, 'allowassign'=>$targetroleid))) {
2985                 return true;
2986             }
2987         }
2988     }
2990     return false;
2993 /**
2994  * Returns all site roles in correct sort order.
2995  *
2996  * Note: this method does not localise role names or descriptions,
2997  *       use role_get_names() if you need role names.
2998  *
2999  * @param context $context optional context for course role name aliases
3000  * @return array of role records with optional coursealias property
3001  */
3002 function get_all_roles(context $context = null) {
3003     global $DB;
3005     if (!$context or !$coursecontext = $context->get_course_context(false)) {
3006         $coursecontext = null;
3007     }
3009     if ($coursecontext) {
3010         $sql = "SELECT r.*, rn.name AS coursealias
3011                   FROM {role} r
3012              LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id)
3013               ORDER BY r.sortorder ASC";
3014         return $DB->get_records_sql($sql, array('coursecontext'=>$coursecontext->id));
3016     } else {
3017         return $DB->get_records('role', array(), 'sortorder ASC');
3018     }
3021 /**
3022  * Returns roles of a specified archetype
3023  *
3024  * @param string $archetype
3025  * @return array of full role records
3026  */
3027 function get_archetype_roles($archetype) {
3028     global $DB;
3029     return $DB->get_records('role', array('archetype'=>$archetype), 'sortorder ASC');
3032 /**
3033  * Gets all the user roles assigned in this context, or higher contexts
3034  * this is mainly used when checking if a user can assign a role, or overriding a role
3035  * i.e. we need to know what this user holds, in order to verify against allow_assign and
3036  * allow_override tables
3037  *
3038  * @param context $context
3039  * @param int $userid
3040  * @param bool $checkparentcontexts defaults to true
3041  * @param string $order defaults to 'c.contextlevel DESC, r.sortorder ASC'
3042  * @return array
3043  */
3044 function get_user_roles(context $context, $userid = 0, $checkparentcontexts = true, $order = 'c.contextlevel DESC, r.sortorder ASC') {
3045     global $USER, $DB;
3047     if (empty($userid)) {
3048         if (empty($USER->id)) {
3049             return array();
3050         }
3051         $userid = $USER->id;
3052     }
3054     if ($checkparentcontexts) {
3055         $contextids = $context->get_parent_context_ids();
3056     } else {
3057         $contextids = array();
3058     }
3059     $contextids[] = $context->id;
3061     list($contextids, $params) = $DB->get_in_or_equal($contextids, SQL_PARAMS_QM);
3063     array_unshift($params, $userid);
3065     $sql = "SELECT ra.*, r.name, r.shortname
3066               FROM {role_assignments} ra, {role} r, {context} c
3067              WHERE ra.userid = ?
3068                    AND ra.roleid = r.id
3069                    AND ra.contextid = c.id
3070                    AND ra.contextid $contextids
3071           ORDER BY $order";
3073     return $DB->get_records_sql($sql ,$params);
3076 /**
3077  * Like get_user_roles, but adds in the authenticated user role, and the front
3078  * page roles, if applicable.
3079  *
3080  * @param context $context the context.
3081  * @param int $userid optional. Defaults to $USER->id
3082  * @return array of objects with fields ->userid, ->contextid and ->roleid.
3083  */
3084 function get_user_roles_with_special(context $context, $userid = 0) {
3085     global $CFG, $USER;
3087     if (empty($userid)) {
3088         if (empty($USER->id)) {
3089             return array();
3090         }
3091         $userid = $USER->id;
3092     }
3094     $ras = get_user_roles($context, $userid);
3096     // Add front-page role if relevant.
3097     $defaultfrontpageroleid = isset($CFG->defaultfrontpageroleid) ? $CFG->defaultfrontpageroleid : 0;
3098     $isfrontpage = ($context->contextlevel == CONTEXT_COURSE && $context->instanceid == SITEID) ||
3099             is_inside_frontpage($context);
3100     if ($defaultfrontpageroleid && $isfrontpage) {
3101         $frontpagecontext = context_course::instance(SITEID);
3102         $ra = new stdClass();
3103         $ra->userid = $userid;
3104         $ra->contextid = $frontpagecontext->id;
3105         $ra->roleid = $defaultfrontpageroleid;
3106         $ras[] = $ra;
3107     }
3109     // Add authenticated user role if relevant.
3110     $defaultuserroleid      = isset($CFG->defaultuserroleid) ? $CFG->defaultuserroleid : 0;
3111     if ($defaultuserroleid && !isguestuser($userid)) {
3112         $systemcontext = context_system::instance();
3113         $ra = new stdClass();
3114         $ra->userid = $userid;
3115         $ra->contextid = $systemcontext->id;
3116         $ra->roleid = $defaultuserroleid;
3117         $ras[] = $ra;
3118     }
3120     return $ras;
3123 /**
3124  * Creates a record in the role_allow_override table
3125  *
3126  * @param int $sroleid source roleid
3127  * @param int $troleid target roleid
3128  * @return void
3129  */
3130 function allow_override($sroleid, $troleid) {
3131     global $DB;
3133     $record = new stdClass();
3134     $record->roleid        = $sroleid;
3135     $record->allowoverride = $troleid;
3136     $DB->insert_record('role_allow_override', $record);
3139 /**
3140  * Creates a record in the role_allow_assign table
3141  *
3142  * @param int $fromroleid source roleid
3143  * @param int $targetroleid target roleid
3144  * @return void
3145  */
3146 function allow_assign($fromroleid, $targetroleid) {
3147     global $DB;
3149     $record = new stdClass();
3150     $record->roleid      = $fromroleid;
3151     $record->allowassign = $targetroleid;
3152     $DB->insert_record('role_allow_assign', $record);
3155 /**
3156  * Creates a record in the role_allow_switch table
3157  *
3158  * @param int $fromroleid source roleid
3159  * @param int $targetroleid target roleid
3160  * @return void
3161  */
3162 function allow_switch($fromroleid, $targetroleid) {
3163     global $DB;
3165     $record = new stdClass();
3166     $record->roleid      = $fromroleid;
3167     $record->allowswitch = $targetroleid;
3168     $DB->insert_record('role_allow_switch', $record);
3171 /**
3172  * Gets a list of roles that this user can assign in this context
3173  *
3174  * @param context $context the context.
3175  * @param int $rolenamedisplay the type of role name to display. One of the
3176  *      ROLENAME_X constants. Default ROLENAME_ALIAS.
3177  * @param bool $withusercounts if true, count the number of users with each role.
3178  * @param integer|object $user A user id or object. By default (null) checks the permissions of the current user.
3179  * @return array if $withusercounts is false, then an array $roleid => $rolename.
3180  *      if $withusercounts is true, returns a list of three arrays,
3181  *      $rolenames, $rolecounts, and $nameswithcounts.
3182  */
3183 function get_assignable_roles(context $context, $rolenamedisplay = ROLENAME_ALIAS, $withusercounts = false, $user = null) {
3184     global $USER, $DB;
3186     // make sure there is a real user specified
3187     if ($user === null) {
3188         $userid = isset($USER->id) ? $USER->id : 0;
3189     } else {
3190         $userid = is_object($user) ? $user->id : $user;
3191     }
3193     if (!has_capability('moodle/role:assign', $context, $userid)) {
3194         if ($withusercounts) {
3195             return array(array(), array(), array());
3196         } else {
3197             return array();
3198         }
3199     }
3201     $params = array();
3202     $extrafields = '';
3204     if ($withusercounts) {
3205         $extrafields = ', (SELECT count(u.id)
3206                              FROM {role_assignments} cra JOIN {user} u ON cra.userid = u.id
3207                             WHERE cra.roleid = r.id AND cra.contextid = :conid AND u.deleted = 0
3208                           ) AS usercount';
3209         $params['conid'] = $context->id;
3210     }
3212     if (is_siteadmin($userid)) {
3213         // show all roles allowed in this context to admins
3214         $assignrestriction = "";
3215     } else {
3216         $parents = $context->get_parent_context_ids(true);
3217         $contexts = implode(',' , $parents);
3218         $assignrestriction = "JOIN (SELECT DISTINCT raa.allowassign AS id
3219                                       FROM {role_allow_assign} raa
3220                                       JOIN {role_assignments} ra ON ra.roleid = raa.roleid
3221                                      WHERE ra.userid = :userid AND ra.contextid IN ($contexts)
3222                                    ) ar ON ar.id = r.id";
3223         $params['userid'] = $userid;
3224     }
3225     $params['contextlevel'] = $context->contextlevel;
3227     if ($coursecontext = $context->get_course_context(false)) {
3228         $params['coursecontext'] = $coursecontext->id;
3229     } else {
3230         $params['coursecontext'] = 0; // no course aliases
3231         $coursecontext = null;
3232     }
3233     $sql = "SELECT r.id, r.name, r.shortname, rn.name AS coursealias $extrafields
3234               FROM {role} r
3235               $assignrestriction
3236               JOIN {role_context_levels} rcl ON (rcl.contextlevel = :contextlevel AND r.id = rcl.roleid)
3237          LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id)
3238           ORDER BY r.sortorder ASC";
3239     $roles = $DB->get_records_sql($sql, $params);
3241     $rolenames = role_fix_names($roles, $coursecontext, $rolenamedisplay, true);
3243     if (!$withusercounts) {
3244         return $rolenames;
3245     }
3247     $rolecounts = array();
3248     $nameswithcounts = array();
3249     foreach ($roles as $role) {
3250         $nameswithcounts[$role->id] = $rolenames[$role->id] . ' (' . $roles[$role->id]->usercount . ')';
3251         $rolecounts[$role->id] = $roles[$role->id]->usercount;
3252     }
3253     return array($rolenames, $rolecounts, $nameswithcounts);
3256 /**
3257  * Gets a list of roles that this user can switch to in a context
3258  *
3259  * Gets a list of roles that this user can switch to in a context, for the switchrole menu.
3260  * This function just process the contents of the role_allow_switch table. You also need to
3261  * test the moodle/role:switchroles to see if the user is allowed to switch in the first place.
3262  *
3263  * @param context $context a context.
3264  * @return array an array $roleid => $rolename.
3265  */
3266 function get_switchable_roles(context $context) {
3267     global $USER, $DB;
3269     $params = array();
3270     $extrajoins = '';
3271     $extrawhere = '';
3272     if (!is_siteadmin()) {
3273         // Admins are allowed to switch to any role with.
3274         // Others are subject to the additional constraint that the switch-to role must be allowed by
3275         // 'role_allow_switch' for some role they have assigned in this context or any parent.
3276         $parents = $context->get_parent_context_ids(true);
3277         $contexts = implode(',' , $parents);
3279         $extrajoins = "JOIN {role_allow_switch} ras ON ras.allowswitch = rc.roleid
3280         JOIN {role_assignments} ra ON ra.roleid = ras.roleid";
3281         $extrawhere = "WHERE ra.userid = :userid AND ra.contextid IN ($contexts)";
3282         $params['userid'] = $USER->id;
3283     }
3285     if ($coursecontext = $context->get_course_context(false)) {
3286         $params['coursecontext'] = $coursecontext->id;
3287     } else {
3288         $params['coursecontext'] = 0; // no course aliases
3289         $coursecontext = null;
3290     }
3292     $query = "
3293         SELECT r.id, r.name, r.shortname, rn.name AS coursealias
3294           FROM (SELECT DISTINCT rc.roleid
3295                   FROM {role_capabilities} rc
3296                   $extrajoins
3297                   $extrawhere) idlist
3298           JOIN {role} r ON r.id = idlist.roleid
3299      LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id)
3300       ORDER BY r.sortorder";
3301     $roles = $DB->get_records_sql($query, $params);
3303     return role_fix_names($roles, $context, ROLENAME_ALIAS, true);
3306 /**
3307  * Gets a list of roles that this user can override in this context.
3308  *
3309  * @param context $context the context.
3310  * @param int $rolenamedisplay the type of role name to display. One of the
3311  *      ROLENAME_X constants. Default ROLENAME_ALIAS.
3312  * @param bool $withcounts if true, count the number of overrides that are set for each role.
3313  * @return array if $withcounts is false, then an array $roleid => $rolename.
3314  *      if $withusercounts is true, returns a list of three arrays,
3315  *      $rolenames, $rolecounts, and $nameswithcounts.
3316  */
3317 function get_overridable_roles(context $context, $rolenamedisplay = ROLENAME_ALIAS, $withcounts = false) {
3318     global $USER, $DB;
3320     if (!has_any_capability(array('moodle/role:safeoverride', 'moodle/role:override'), $context)) {
3321         if ($withcounts) {
3322             return array(array(), array(), array());
3323         } else {
3324             return array();
3325         }
3326     }
3328     $parents = $context->get_parent_context_ids(true);
3329     $contexts = implode(',' , $parents);
3331     $params = array();
3332     $extrafields = '';
3334     $params['userid'] = $USER->id;
3335     if ($withcounts) {
3336         $extrafields = ', (SELECT COUNT(rc.id) FROM {role_capabilities} rc
3337                 WHERE rc.roleid = ro.id AND rc.contextid = :conid) AS overridecount';
3338         $params['conid'] = $context->id;
3339     }
3341     if ($coursecontext = $context->get_course_context(false)) {
3342         $params['coursecontext'] = $coursecontext->id;
3343     } else {
3344         $params['coursecontext'] = 0; // no course aliases
3345         $coursecontext = null;
3346     }
3348     if (is_siteadmin()) {
3349         // show all roles to admins
3350         $roles = $DB->get_records_sql("
3351             SELECT ro.id, ro.name, ro.shortname, rn.name AS coursealias $extrafields
3352               FROM {role} ro
3353          LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = ro.id)
3354           ORDER BY ro.sortorder ASC", $params);
3356     } else {
3357         $roles = $DB->get_records_sql("
3358             SELECT ro.id, ro.name, ro.shortname, rn.name AS coursealias $extrafields
3359               FROM {role} ro
3360               JOIN (SELECT DISTINCT r.id
3361                       FROM {role} r
3362                       JOIN {role_allow_override} rao ON r.id = rao.allowoverride
3363                       JOIN {role_assignments} ra ON rao.roleid = ra.roleid
3364                      WHERE ra.userid = :userid AND ra.contextid IN ($contexts)
3365                    ) inline_view ON ro.id = inline_view.id
3366          LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = ro.id)
3367           ORDER BY ro.sortorder ASC", $params);
3368     }
3370     $rolenames = role_fix_names($roles, $context, $rolenamedisplay, true);
3372     if (!$withcounts) {
3373         return $rolenames;
3374     }
3376     $rolecounts = array();
3377     $nameswithcounts = array();
3378     foreach ($roles as $role) {
3379         $nameswithcounts[$role->id] = $rolenames[$role->id] . ' (' . $roles[$role->id]->overridecount . ')';
3380         $rolecounts[$role->id] = $roles[$role->id]->overridecount;
3381     }
3382     return array($rolenames, $rolecounts, $nameswithcounts);
3385 /**
3386  * Create a role menu suitable for default role selection in enrol plugins.
3387  *
3388  * @package    core_enrol
3389  *
3390  * @param context $context
3391  * @param int $addroleid current or default role - always added to list
3392  * @return array roleid=>localised role name
3393  */
3394 function get_default_enrol_roles(context $context, $addroleid = null) {
3395     global $DB;
3397     $params = array('contextlevel'=>CONTEXT_COURSE);
3399     if ($coursecontext = $context->get_course_context(false)) {
3400         $params['coursecontext'] = $coursecontext->id;
3401     } else {
3402         $params['coursecontext'] = 0; // no course names
3403         $coursecontext = null;
3404     }
3406     if ($addroleid) {
3407         $addrole = "OR r.id = :addroleid";
3408         $params['addroleid'] = $addroleid;
3409     } else {
3410         $addrole = "";
3411     }
3413     $sql = "SELECT r.id, r.name, r.shortname, rn.name AS coursealias
3414               FROM {role} r
3415          LEFT JOIN {role_context_levels} rcl ON (rcl.roleid = r.id AND rcl.contextlevel = :contextlevel)
3416          LEFT JOIN {role_names} rn ON (rn.contextid = :coursecontext AND rn.roleid = r.id)
3417              WHERE rcl.id IS NOT NULL $addrole
3418           ORDER BY sortorder DESC";
3420     $roles = $DB->get_records_sql($sql, $params);
3422     return role_fix_names($roles, $context, ROLENAME_BOTH, true);
3425 /**
3426  * Return context levels where this role is assignable.
3427  *
3428  * @param integer $roleid the id of a role.
3429  * @return array list of the context levels at which this role may be assigned.
3430  */
3431 function get_role_contextlevels($roleid) {
3432     global $DB;
3433     return $DB->get_records_menu('role_context_levels', array('roleid' => $roleid),
3434             'contextlevel', 'id,contextlevel');
3437 /**
3438  * Return roles suitable for assignment at the specified context level.
3439  *
3440  * NOTE: this function name looks like a typo, should be probably get_roles_for_contextlevel()
3441  *
3442  * @param integer $contextlevel a contextlevel.
3443  * @return array list of role ids that are assignable at this context level.
3444  */
3445 function get_roles_for_contextlevels($contextlevel) {
3446     global $DB;
3447     return $DB->get_records_menu('role_context_levels', array('contextlevel' => $contextlevel),
3448             '', 'id,roleid');
3451 /**
3452  * Returns default context levels where roles can be assigned.
3453  *
3454  * @param string $rolearchetype one of the role archetypes - that is, one of the keys
3455  *      from the array returned by get_role_archetypes();
3456  * @return array list of the context levels at which this type of role may be assigned by default.
3457  */
3458 function get_default_contextlevels($rolearchetype) {
3459     static $defaults = array(
3460         'manager'        => array(CONTEXT_SYSTEM, CONTEXT_COURSECAT, CONTEXT_COURSE),
3461         'coursecreator'  => array(CONTEXT_SYSTEM, CONTEXT_COURSECAT),
3462         'editingteacher' => array(CONTEXT_COURSE, CONTEXT_MODULE),
3463         'teacher'        => array(CONTEXT_COURSE, CONTEXT_MODULE),
3464         'student'        => array(CONTEXT_COURSE, CONTEXT_MODULE),
3465         'guest'          => array(),
3466         'user'           => array(),
3467         'frontpage'      => array());
3469     if (isset($defaults[$rolearchetype])) {
3470         return $defaults[$rolearchetype];
3471     } else {
3472         return array();
3473     }
3476 /**
3477  * Set the context levels at which a particular role can be assigned.
3478  * Throws exceptions in case of error.
3479  *
3480  * @param integer $roleid the id of a role.
3481  * @param array $contextlevels the context levels at which this role should be assignable,
3482  *      duplicate levels are removed.
3483  * @return void
3484  */
3485 function set_role_contextlevels($roleid, array $contextlevels) {
3486     global $DB;
3487     $DB->delete_records('role_context_levels', array('roleid' => $roleid));
3488     $rcl = new stdClass();
3489     $rcl->roleid = $roleid;
3490     $contextlevels = array_unique($contextlevels);
3491     foreach ($contextlevels as $level) {
3492         $rcl->contextlevel = $level;
3493         $DB->insert_record('role_context_levels', $rcl, false, true);
3494     }
3497 /**
3498  * Who has this capability in this context?
3499  *
3500  * This can be a very expensive call - use sparingly and keep
3501  * the results if you are going to need them again soon.
3502  *
3503  * Note if $fields is empty this function attempts to get u.*
3504  * which can get rather large - and has a serious perf impact
3505  * on some DBs.
3506  *
3507  * @param context $context
3508  * @param string|array $capability - capability name(s)
3509  * @param string $fields - fields to be pulled. The user table is aliased to 'u'. u.id MUST be included.
3510  * @param string $sort - the sort order. Default is lastaccess time.
3511  * @param mixed $limitfrom - number of records to skip (offset)
3512  * @param mixed $limitnum - number of records to fetch
3513  * @param string|array $groups - single group or array of groups - only return
3514  *               users who are in one of these group(s).
3515  * @param string|array $exceptions - list of users to exclude, comma separated or array
3516  * @param bool $doanything_ignored not used any more, admin accounts are never returned
3517  * @param bool $view_ignored - use get_enrolled_sql() instead
3518  * @param bool $useviewallgroups if $groups is set the return users who
3519  *               have capability both $capability and moodle/site:accessallgroups
3520  *               in this context, as well as users who have $capability and who are
3521  *               in $groups.
3522  * @return array of user records
3523  */
3524 function get_users_by_capability(context $context, $capability, $fields = '', $sort = '', $limitfrom = '', $limitnum = '',
3525                                  $groups = '', $exceptions = '', $doanything_ignored = null, $view_ignored = null, $useviewallgroups = false) {
3526     global $CFG, $DB;
3528     $defaultuserroleid      = isset($CFG->defaultuserroleid) ? $CFG->defaultuserroleid : 0;
3529     $defaultfrontpageroleid = isset($CFG->defaultfrontpageroleid) ? $CFG->defaultfrontpageroleid : 0;
3531     $ctxids = trim($context->path, '/');
3532     $ctxids = str_replace('/', ',', $ctxids);
3534     // Context is the frontpage
3535     $iscoursepage = false; // coursepage other than fp
3536     $isfrontpage = false;
3537     if ($context->contextlevel == CONTEXT_COURSE) {
3538         if ($context->instanceid == SITEID) {
3539             $isfrontpage = true;
3540         } else {
3541             $iscoursepage = true;
3542         }
3543     }
3544     $isfrontpage = ($isfrontpage || is_inside_frontpage($context));
3546     $caps = (array)$capability;
3548     // construct list of context paths bottom-->top
3549     list($contextids, $paths) = get_context_info_list($context);
3551     // we need to find out all roles that have these capabilities either in definition or in overrides
3552     $defs = array();
3553     list($incontexts, $params) = $DB->get_in_or_equal($contextids, SQL_PARAMS_NAMED, 'con');
3554     list($incaps, $params2) = $DB->get_in_or_equal($caps, SQL_PARAMS_NAMED, 'cap');
3555     $params = array_merge($params, $params2);
3556     $sql = "SELECT rc.id, rc.roleid, rc.permission, rc.capability, ctx.path
3557               FROM {role_capabilities} rc
3558               JOIN {context} ctx on rc.contextid = ctx.id
3559              WHERE rc.contextid $incontexts AND rc.capability $incaps";
3561     $rcs = $DB->get_records_sql($sql, $params);
3562     foreach ($rcs as $rc) {
3563         $defs[$rc->capability][$rc->path][$rc->roleid] = $rc->permission;
3564     }
3566     // go through the permissions bottom-->top direction to evaluate the current permission,
3567     // first one wins (prohibit is an exception that always wins)
3568     $access = array();
3569     foreach ($caps as $cap) {
3570         foreach ($paths as $path) {
3571             if (empty($defs[$cap][$path])) {
3572                 continue;
3573             }
3574             foreach($defs[$cap][$path] as $roleid => $perm) {
3575                 if ($perm == CAP_PROHIBIT) {
3576                     $access[$cap][$roleid] = CAP_PROHIBIT;
3577                     continue;
3578                 }
3579                 if (!isset($access[$cap][$roleid])) {
3580                     $access[$cap][$roleid] = (int)$perm;
3581                 }
3582             }
3583         }
3584     }
3586     // make lists of roles that are needed and prohibited in this context
3587     $needed = array(); // one of these is enough
3588     $prohibited = array(); // must not have any of these
3589     foreach ($caps as $cap) {
3590         if (empty($access[$cap])) {
3591             continue;
3592         }
3593         foreach ($access[$cap] as $roleid => $perm) {
3594             if ($perm == CAP_PROHIBIT) {
3595                 unset($needed[$cap][$roleid]);
3596                 $prohibited[$cap][$roleid] = true;
3597             } else if ($perm == CAP_ALLOW and empty($prohibited[$cap][$roleid])) {
3598                 $needed[$cap][$roleid] = true;
3599             }
3600         }
3601         if (empty($needed[$cap]) or !empty($prohibited[$cap][$defaultuserroleid])) {
3602             // easy, nobody has the permission
3603             unset($needed[$cap]);
3604             unset($prohibited[$cap]);
3605         } else if ($isfrontpage and !empty($prohibited[$cap][$defaultfrontpageroleid])) {
3606             // everybody is disqualified on the frontpage
3607             unset($needed[$cap]);
3608             unset($prohibited[$cap]);
3609         }
3610         if (empty($prohibited[$cap])) {
3611             unset($prohibited[$cap]);
3612         }
3613     }
3615     if (empty($needed)) {
3616         // there can not be anybody if no roles match this request
3617         return array();
3618     }
3620     if (empty($prohibited)) {
3621         // we can compact the needed roles
3622         $n = array();
3623         foreach ($needed as $cap) {
3624             foreach ($cap as $roleid=>$unused) {
3625                 $n[$roleid] = true;
3626             }
3627         }
3628         $needed = array('any'=>$n);
3629         unset($n);
3630     }
3632     // ***** Set up default fields ******
3633     if (empty($fields)) {
3634         if ($iscoursepage) {
3635             $fields = 'u.*, ul.timeaccess AS lastaccess';
3636         } else {
3637             $fields = 'u.*';
3638         }
3639     } else {
3640         if (debugging('', DEBUG_DEVELOPER) && strpos($fields, 'u.*') === false && strpos($fields, 'u.id') === false) {
3641             debugging('u.id must be included in the list of fields passed to get_users_by_capability().', DEBUG_DEVELOPER);
3642         }
3643     }
3645     // Set up default sort
3646     if (empty($sort)) { // default to course lastaccess or just lastaccess
3647         if ($iscoursepage) {
3648             $sort = 'ul.timeaccess';
3649         } else {
3650             $sort = 'u.lastaccess';
3651         }
3652     }
3654     // Prepare query clauses
3655     $wherecond = array();
3656     $params    = array();
3657     $joins     = array();
3659     // User lastaccess JOIN
3660     if ((strpos($sort, 'ul.timeaccess') === false) and (strpos($fields, 'ul.timeaccess') === false)) {
3661          // user_lastaccess is not required MDL-13810
3662     } else {
3663         if ($iscoursepage) {
3664             $joins[] = "LEFT OUTER JOIN {user_lastaccess} ul ON (ul.userid = u.id AND ul.courseid = {$context->instanceid})";
3665         } else {
3666             throw new coding_exception('Invalid sort in get_users_by_capability(), ul.timeaccess allowed only for course contexts.');
3667         }
3668     }