50a9ee4b606dd020793fa0d55029075565751582
[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 */
172 define('ROLENAME_ORIGINAL', 0);
173 /** rolename displays - the name as defined by a role alias */
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 $UNITTEST, $USER;
220     if (empty($UNITTEST->running) and !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     //
273     // Overrides for the role IN ANY CONTEXTS
274     // down to COURSE - not below -
275     //
276     $sql = "SELECT ctx.path,
277                    rc.capability, rc.permission
278               FROM {context} ctx
279               JOIN {role_capabilities} rc ON rc.contextid = ctx.id
280          LEFT JOIN {context} cctx
281                    ON (cctx.contextlevel = ".CONTEXT_COURSE." AND ctx.path LIKE ".$DB->sql_concat('cctx.path',"'/%'").")
282              WHERE rc.roleid = ? AND cctx.id IS NULL";
283     $params = array($roleid);
285     // we need extra caching in CLI scripts and cron
286     $rs = $DB->get_recordset_sql($sql, $params);
287     foreach ($rs as $rd) {
288         $k = "{$rd->path}:{$roleid}";
289         $accessdata['rdef'][$k][$rd->capability] = (int)$rd->permission;
290     }
291     $rs->close();
293     // share the role definitions
294     foreach ($accessdata['rdef'] as $k=>$unused) {
295         if (!isset($ACCESSLIB_PRIVATE->rolepermissions[$k])) {
296             $ACCESSLIB_PRIVATE->rolepermissions[$k] = $accessdata['rdef'][$k];
297         }
298         $accessdata['rdef_count']++;
299         $accessdata['rdef'][$k] =& $ACCESSLIB_PRIVATE->rolepermissions[$k];
300     }
302     return $accessdata;
305 /**
306  * Get the default guest role, this is used for guest account,
307  * search engine spiders, etc.
308  *
309  * @return stdClass role record
310  */
311 function get_guest_role() {
312     global $CFG, $DB;
314     if (empty($CFG->guestroleid)) {
315         if ($roles = $DB->get_records('role', array('archetype'=>'guest'))) {
316             $guestrole = array_shift($roles);   // Pick the first one
317             set_config('guestroleid', $guestrole->id);
318             return $guestrole;
319         } else {
320             debugging('Can not find any guest role!');
321             return false;
322         }
323     } else {
324         if ($guestrole = $DB->get_record('role', array('id'=>$CFG->guestroleid))) {
325             return $guestrole;
326         } else {
327             // somebody is messing with guest roles, remove incorrect setting and try to find a new one
328             set_config('guestroleid', '');
329             return get_guest_role();
330         }
331     }
334 /**
335  * Check whether a user has a particular capability in a given context.
336  *
337  * For example:
338  *      $context = context_module::instance($cm->id);
339  *      has_capability('mod/forum:replypost', $context)
340  *
341  * By default checks the capabilities of the current user, but you can pass a
342  * different userid. By default will return true for admin users, but you can override that with the fourth argument.
343  *
344  * Guest and not-logged-in users can never get any dangerous capability - that is any write capability
345  * or capabilities with XSS, config or data loss risks.
346  *
347  * @category access
348  *
349  * @param string $capability the name of the capability to check. For example mod/forum:view
350  * @param context $context the context to check the capability in. You normally get this with instance method of a context class.
351  * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user.
352  * @param boolean $doanything If false, ignores effect of admin role assignment
353  * @return boolean true if the user has this capability. Otherwise false.
354  */
355 function has_capability($capability, context $context, $user = null, $doanything = true) {
356     global $USER, $CFG, $SCRIPT, $ACCESSLIB_PRIVATE;
358     if (during_initial_install()) {
359         if ($SCRIPT === "/$CFG->admin/index.php" or $SCRIPT === "/$CFG->admin/cli/install.php" or $SCRIPT === "/$CFG->admin/cli/install_database.php") {
360             // we are in an installer - roles can not work yet
361             return true;
362         } else {
363             return false;
364         }
365     }
367     if (strpos($capability, 'moodle/legacy:') === 0) {
368         throw new coding_exception('Legacy capabilities can not be used any more!');
369     }
371     if (!is_bool($doanything)) {
372         throw new coding_exception('Capability parameter "doanything" is wierd, only true or false is allowed. This has to be fixed in code.');
373     }
375     // capability must exist
376     if (!$capinfo = get_capability_info($capability)) {
377         debugging('Capability "'.$capability.'" was not found! This has to be fixed in code.');
378         return false;
379     }
381     if (!isset($USER->id)) {
382         // should never happen
383         $USER->id = 0;
384     }
386     // make sure there is a real user specified
387     if ($user === null) {
388         $userid = $USER->id;
389     } else {
390         $userid = is_object($user) ? $user->id : $user;
391     }
393     // make sure forcelogin cuts off not-logged-in users if enabled
394     if (!empty($CFG->forcelogin) and $userid == 0) {
395         return false;
396     }
398     // make sure the guest account and not-logged-in users never get any risky caps no matter what the actual settings are.
399     if (($capinfo->captype === 'write') or ($capinfo->riskbitmask & (RISK_XSS | RISK_CONFIG | RISK_DATALOSS))) {
400         if (isguestuser($userid) or $userid == 0) {
401             return false;
402         }
403     }
405     // somehow make sure the user is not deleted and actually exists
406     if ($userid != 0) {
407         if ($userid == $USER->id and isset($USER->deleted)) {
408             // this prevents one query per page, it is a bit of cheating,
409             // but hopefully session is terminated properly once user is deleted
410             if ($USER->deleted) {
411                 return false;
412             }
413         } else {
414             if (!context_user::instance($userid, IGNORE_MISSING)) {
415                 // no user context == invalid userid
416                 return false;
417             }
418         }
419     }
421     // context path/depth must be valid
422     if (empty($context->path) or $context->depth == 0) {
423         // this should not happen often, each upgrade tries to rebuild the context paths
424         debugging('Context id '.$context->id.' does not have valid path, please use build_context_path()');
425         if (is_siteadmin($userid)) {
426             return true;
427         } else {
428             return false;
429         }
430     }
432     // Find out if user is admin - it is not possible to override the doanything in any way
433     // and it is not possible to switch to admin role either.
434     if ($doanything) {
435         if (is_siteadmin($userid)) {
436             if ($userid != $USER->id) {
437                 return true;
438             }
439             // make sure switchrole is not used in this context
440             if (empty($USER->access['rsw'])) {
441                 return true;
442             }
443             $parts = explode('/', trim($context->path, '/'));
444             $path = '';
445             $switched = false;
446             foreach ($parts as $part) {
447                 $path .= '/' . $part;
448                 if (!empty($USER->access['rsw'][$path])) {
449                     $switched = true;
450                     break;
451                 }
452             }
453             if (!$switched) {
454                 return true;
455             }
456             //ok, admin switched role in this context, let's use normal access control rules
457         }
458     }
460     // Careful check for staleness...
461     $context->reload_if_dirty();
463     if ($USER->id == $userid) {
464         if (!isset($USER->access)) {
465             load_all_capabilities();
466         }
467         $access =& $USER->access;
469     } else {
470         // make sure user accessdata is really loaded
471         get_user_accessdata($userid, true);
472         $access =& $ACCESSLIB_PRIVATE->accessdatabyuser[$userid];
473     }
476     // Load accessdata for below-the-course context if necessary,
477     // all contexts at and above all courses are already loaded
478     if ($context->contextlevel != CONTEXT_COURSE and $coursecontext = $context->get_course_context(false)) {
479         load_course_context($userid, $coursecontext, $access);
480     }
482     return has_capability_in_accessdata($capability, $context, $access);
485 /**
486  * Check if the user has any one of several capabilities from a list.
487  *
488  * This is just a utility method that calls has_capability in a loop. Try to put
489  * the capabilities that most users are likely to have first in the list for best
490  * performance.
491  *
492  * @category access
493  * @see has_capability()
494  *
495  * @param array $capabilities an array of capability names.
496  * @param context $context the context to check the capability in. You normally get this with instance method of a context class.
497  * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user.
498  * @param boolean $doanything If false, ignore effect of admin role assignment
499  * @return boolean true if the user has any of these capabilities. Otherwise false.
500  */
501 function has_any_capability(array $capabilities, context $context, $user = null, $doanything = true) {
502     foreach ($capabilities as $capability) {
503         if (has_capability($capability, $context, $user, $doanything)) {
504             return true;
505         }
506     }
507     return false;
510 /**
511  * Check if the user has all the capabilities in a list.
512  *
513  * This is just a utility method that calls has_capability in a loop. Try to put
514  * the capabilities that fewest users are likely to have first in the list for best
515  * performance.
516  *
517  * @category access
518  * @see has_capability()
519  *
520  * @param array $capabilities an array of capability names.
521  * @param context $context the context to check the capability in. You normally get this with instance method of a context class.
522  * @param integer|stdClass $user A user id or object. By default (null) checks the permissions of the current user.
523  * @param boolean $doanything If false, ignore effect of admin role assignment
524  * @return boolean true if the user has all of these capabilities. Otherwise false.
525  */
526 function has_all_capabilities(array $capabilities, context $context, $user = null, $doanything = true) {
527     foreach ($capabilities as $capability) {
528         if (!has_capability($capability, $context, $user, $doanything)) {
529             return false;
530         }
531     }
532     return true;
535 /**
536  * Check if the user is an admin at the site level.
537  *
538  * Please note that use of proper capabilities is always encouraged,
539  * this function is supposed to be used from core or for temporary hacks.
540  *
541  * @category access
542  *
543  * @param  int|stdClass  $user_or_id user id or user object
544  * @return bool true if user is one of the administrators, false otherwise
545  */
546 function is_siteadmin($user_or_id = null) {
547     global $CFG, $USER;
549     if ($user_or_id === null) {
550         $user_or_id = $USER;
551     }
553     if (empty($user_or_id)) {
554         return false;
555     }
556     if (!empty($user_or_id->id)) {
557         $userid = $user_or_id->id;
558     } else {
559         $userid = $user_or_id;
560     }
562     $siteadmins = explode(',', $CFG->siteadmins);
563     return in_array($userid, $siteadmins);
566 /**
567  * Returns true if user has at least one role assign
568  * of 'coursecontact' role (is potentially listed in some course descriptions).
569  *
570  * @param int $userid
571  * @return bool
572  */
573 function has_coursecontact_role($userid) {
574     global $DB, $CFG;
576     if (empty($CFG->coursecontact)) {
577         return false;
578     }
579     $sql = "SELECT 1
580               FROM {role_assignments}
581              WHERE userid = :userid AND roleid IN ($CFG->coursecontact)";
582     return $DB->record_exists_sql($sql, array('userid'=>$userid));
585 /**
586  * Does the user have a capability to do something?
587  *
588  * Walk the accessdata array and return true/false.
589  * Deals with prohibits, role switching, aggregating
590  * capabilities, etc.
591  *
592  * The main feature of here is being FAST and with no
593  * side effects.
594  *
595  * Notes:
596  *
597  * Switch Role merges with default role
598  * ------------------------------------
599  * If you are a teacher in course X, you have at least
600  * teacher-in-X + defaultloggedinuser-sitewide. So in the
601  * course you'll have techer+defaultloggedinuser.
602  * We try to mimic that in switchrole.
603  *
604  * Permission evaluation
605  * ---------------------
606  * Originally there was an extremely complicated way
607  * to determine the user access that dealt with
608  * "locality" or role assignments and role overrides.
609  * Now we simply evaluate access for each role separately
610  * and then verify if user has at least one role with allow
611  * and at the same time no role with prohibit.
612  *
613  * @access private
614  * @param string $capability
615  * @param context $context
616  * @param array $accessdata
617  * @return bool
618  */
619 function has_capability_in_accessdata($capability, context $context, array &$accessdata) {
620     global $CFG;
622     // Build $paths as a list of current + all parent "paths" with order bottom-to-top
623     $path = $context->path;
624     $paths = array($path);
625     while($path = rtrim($path, '0123456789')) {
626         $path = rtrim($path, '/');
627         if ($path === '') {
628             break;
629         }
630         $paths[] = $path;
631     }
633     $roles = array();
634     $switchedrole = false;
636     // Find out if role switched
637     if (!empty($accessdata['rsw'])) {
638         // From the bottom up...
639         foreach ($paths as $path) {
640             if (isset($accessdata['rsw'][$path])) {
641                 // Found a switchrole assignment - check for that role _plus_ the default user role
642                 $roles = array($accessdata['rsw'][$path]=>null, $CFG->defaultuserroleid=>null);
643                 $switchedrole = true;
644                 break;
645             }
646         }
647     }
649     if (!$switchedrole) {
650         // get all users roles in this context and above
651         foreach ($paths as $path) {
652             if (isset($accessdata['ra'][$path])) {
653                 foreach ($accessdata['ra'][$path] as $roleid) {
654                     $roles[$roleid] = null;
655                 }
656             }
657         }
658     }
660     // Now find out what access is given to each role, going bottom-->up direction
661     $allowed = false;
662     foreach ($roles as $roleid => $ignored) {
663         foreach ($paths as $path) {
664             if (isset($accessdata['rdef']["{$path}:$roleid"][$capability])) {
665                 $perm = (int)$accessdata['rdef']["{$path}:$roleid"][$capability];
666                 if ($perm === CAP_PROHIBIT) {
667                     // any CAP_PROHIBIT found means no permission for the user
668                     return false;
669                 }
670                 if (is_null($roles[$roleid])) {
671                     $roles[$roleid] = $perm;
672                 }
673             }
674         }
675         // CAP_ALLOW in any role means the user has a permission, we continue only to detect prohibits
676         $allowed = ($allowed or $roles[$roleid] === CAP_ALLOW);
677     }
679     return $allowed;
682 /**
683  * A convenience function that tests has_capability, and displays an error if
684  * the user does not have that capability.
685  *
686  * NOTE before Moodle 2.0, this function attempted to make an appropriate
687  * require_login call before checking the capability. This is no longer the case.
688  * You must call require_login (or one of its variants) if you want to check the
689  * user is logged in, before you call this function.
690  *
691  * @see has_capability()
692  *
693  * @param string $capability the name of the capability to check. For example mod/forum:view
694  * @param context $context the context to check the capability in. You normally get this with {@link get_context_instance}.
695  * @param int $userid A user id. By default (null) checks the permissions of the current user.
696  * @param bool $doanything If false, ignore effect of admin role assignment
697  * @param string $errormessage The error string to to user. Defaults to 'nopermissions'.
698  * @param string $stringfile The language file to load the error string from. Defaults to 'error'.
699  * @return void terminates with an error if the user does not have the given capability.
700  */
701 function require_capability($capability, context $context, $userid = null, $doanything = true,
702                             $errormessage = 'nopermissions', $stringfile = '') {
703     if (!has_capability($capability, $context, $userid, $doanything)) {
704         throw new required_capability_exception($context, $capability, $errormessage, $stringfile);
705     }
708 /**
709  * Return a nested array showing role assignments
710  * all relevant role capabilities for the user at
711  * site/course_category/course levels
712  *
713  * We do _not_ delve deeper than courses because the number of
714  * overrides at the module/block levels can be HUGE.
715  *
716  * [ra]   => [/path][roleid]=roleid
717  * [rdef] => [/path:roleid][capability]=permission
718  *
719  * @access private
720  * @param int $userid - the id of the user
721  * @return array access info array
722  */
723 function get_user_access_sitewide($userid) {
724     global $CFG, $DB, $ACCESSLIB_PRIVATE;
726     /* Get in a few cheap DB queries...
727      * - role assignments
728      * - relevant role caps
729      *   - above and within this user's RAs
730      *   - below this user's RAs - limited to course level
731      */
733     // raparents collects paths & roles we need to walk up the parenthood to build the minimal rdef
734     $raparents = array();
735     $accessdata = get_empty_accessdata();
737     // start with the default role
738     if (!empty($CFG->defaultuserroleid)) {
739         $syscontext = context_system::instance();
740         $accessdata['ra'][$syscontext->path][(int)$CFG->defaultuserroleid] = (int)$CFG->defaultuserroleid;
741         $raparents[$CFG->defaultuserroleid][$syscontext->id] = $syscontext->id;
742     }
744     // load the "default frontpage role"
745     if (!empty($CFG->defaultfrontpageroleid)) {
746         $frontpagecontext = context_course::instance(get_site()->id);
747         if ($frontpagecontext->path) {
748             $accessdata['ra'][$frontpagecontext->path][(int)$CFG->defaultfrontpageroleid] = (int)$CFG->defaultfrontpageroleid;
749             $raparents[$CFG->defaultfrontpageroleid][$frontpagecontext->id] = $frontpagecontext->id;
750         }
751     }
753     // preload every assigned role at and above course context
754     $sql = "SELECT ctx.path, ra.roleid, ra.contextid
755               FROM {role_assignments} ra
756               JOIN {context} ctx
757                    ON ctx.id = ra.contextid
758          LEFT JOIN {block_instances} bi
759                    ON (ctx.contextlevel = ".CONTEXT_BLOCK." AND bi.id = ctx.instanceid)
760          LEFT JOIN {context} bpctx
761                    ON (bpctx.id = bi.parentcontextid)
762              WHERE ra.userid = :userid
763                    AND (ctx.contextlevel <= ".CONTEXT_COURSE." OR bpctx.contextlevel < ".CONTEXT_COURSE.")";
764     $params = array('userid'=>$userid);
765     $rs = $DB->get_recordset_sql($sql, $params);
766     foreach ($rs as $ra) {
767         // RAs leafs are arrays to support multi-role assignments...
768         $accessdata['ra'][$ra->path][(int)$ra->roleid] = (int)$ra->roleid;
769         $raparents[$ra->roleid][$ra->contextid] = $ra->contextid;
770     }
771     $rs->close();
773     if (empty($raparents)) {
774         return $accessdata;
775     }
777     // now get overrides of interesting roles in all interesting child contexts
778     // hopefully we will not run out of SQL limits here,
779     // users would have to have very many roles at/above course context...
780     $sqls = array();
781     $params = array();
783     static $cp = 0;
784     foreach ($raparents as $roleid=>$ras) {
785         $cp++;
786         list($sqlcids, $cids) = $DB->get_in_or_equal($ras, SQL_PARAMS_NAMED, 'c'.$cp.'_');
787         $params = array_merge($params, $cids);
788         $params['r'.$cp] = $roleid;
789         $sqls[] = "(SELECT ctx.path, rc.roleid, rc.capability, rc.permission
790                      FROM {role_capabilities} rc
791                      JOIN {context} ctx
792                           ON (ctx.id = rc.contextid)
793                      JOIN {context} pctx
794                           ON (pctx.id $sqlcids
795                               AND (ctx.id = pctx.id
796                                    OR ctx.path LIKE ".$DB->sql_concat('pctx.path',"'/%'")."
797                                    OR pctx.path LIKE ".$DB->sql_concat('ctx.path',"'/%'")."))
798                 LEFT JOIN {block_instances} bi
799                           ON (ctx.contextlevel = ".CONTEXT_BLOCK." AND bi.id = ctx.instanceid)
800                 LEFT JOIN {context} bpctx
801                           ON (bpctx.id = bi.parentcontextid)
802                     WHERE rc.roleid = :r{$cp}
803                           AND (ctx.contextlevel <= ".CONTEXT_COURSE." OR bpctx.contextlevel < ".CONTEXT_COURSE.")
804                    )";
805     }
807     // fixed capability order is necessary for rdef dedupe
808     $rs = $DB->get_recordset_sql(implode("\nUNION\n", $sqls). "ORDER BY capability", $params);
810     foreach ($rs as $rd) {
811         $k = $rd->path.':'.$rd->roleid;
812         $accessdata['rdef'][$k][$rd->capability] = (int)$rd->permission;
813     }
814     $rs->close();
816     // share the role definitions
817     foreach ($accessdata['rdef'] as $k=>$unused) {
818         if (!isset($ACCESSLIB_PRIVATE->rolepermissions[$k])) {
819             $ACCESSLIB_PRIVATE->rolepermissions[$k] = $accessdata['rdef'][$k];
820         }
821         $accessdata['rdef_count']++;
822         $accessdata['rdef'][$k] =& $ACCESSLIB_PRIVATE->rolepermissions[$k];
823     }
825     return $accessdata;
828 /**
829  * Add to the access ctrl array the data needed by a user for a given course.
830  *
831  * This function injects all course related access info into the accessdata array.
832  *
833  * @access private
834  * @param int $userid the id of the user
835  * @param context_course $coursecontext course context
836  * @param array $accessdata accessdata array (modified)
837  * @return void modifies $accessdata parameter
838  */
839 function load_course_context($userid, context_course $coursecontext, &$accessdata) {
840     global $DB, $CFG, $ACCESSLIB_PRIVATE;
842     if (empty($coursecontext->path)) {
843         // weird, this should not happen
844         return;
845     }
847     if (isset($accessdata['loaded'][$coursecontext->instanceid])) {
848         // already loaded, great!
849         return;
850     }
852     $roles = array();
854     if (empty($userid)) {
855         if (!empty($CFG->notloggedinroleid)) {
856             $roles[$CFG->notloggedinroleid] = $CFG->notloggedinroleid;
857         }
859     } else if (isguestuser($userid)) {
860         if ($guestrole = get_guest_role()) {
861             $roles[$guestrole->id] = $guestrole->id;
862         }
864     } else {
865         // Interesting role assignments at, above and below the course context
866         list($parentsaself, $params) = $DB->get_in_or_equal($coursecontext->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'pc_');
867         $params['userid'] = $userid;
868         $params['children'] = $coursecontext->path."/%";
869         $sql = "SELECT ra.*, ctx.path
870                   FROM {role_assignments} ra
871                   JOIN {context} ctx ON ra.contextid = ctx.id
872                  WHERE ra.userid = :userid AND (ctx.id $parentsaself OR ctx.path LIKE :children)";
873         $rs = $DB->get_recordset_sql($sql, $params);
875         // add missing role definitions
876         foreach ($rs as $ra) {
877             $accessdata['ra'][$ra->path][(int)$ra->roleid] = (int)$ra->roleid;
878             $roles[$ra->roleid] = $ra->roleid;
879         }
880         $rs->close();
882         // add the "default frontpage role" when on the frontpage
883         if (!empty($CFG->defaultfrontpageroleid)) {
884             $frontpagecontext = context_course::instance(get_site()->id);
885             if ($frontpagecontext->id == $coursecontext->id) {
886                 $roles[$CFG->defaultfrontpageroleid] = $CFG->defaultfrontpageroleid;
887             }
888         }
890         // do not forget the default role
891         if (!empty($CFG->defaultuserroleid)) {
892             $roles[$CFG->defaultuserroleid] = $CFG->defaultuserroleid;
893         }
894     }
896     if (!$roles) {
897         // weird, default roles must be missing...
898         $accessdata['loaded'][$coursecontext->instanceid] = 1;
899         return;
900     }
902     // now get overrides of interesting roles in all interesting contexts (this course + children + parents)
903     $params = array('c'=>$coursecontext->id);
904     list($parentsaself, $rparams) = $DB->get_in_or_equal($coursecontext->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'pc_');
905     $params = array_merge($params, $rparams);
906     list($roleids, $rparams) = $DB->get_in_or_equal($roles, SQL_PARAMS_NAMED, 'r_');
907     $params = array_merge($params, $rparams);
909     $sql = "SELECT ctx.path, rc.roleid, rc.capability, rc.permission
910                  FROM {role_capabilities} rc
911                  JOIN {context} ctx
912                       ON (ctx.id = rc.contextid)
913                  JOIN {context} cctx
914                       ON (cctx.id = :c
915                           AND (ctx.id $parentsaself OR ctx.path LIKE ".$DB->sql_concat('cctx.path',"'/%'")."))
916                 WHERE rc.roleid $roleids
917              ORDER BY rc.capability"; // fixed capability order is necessary for rdef dedupe
918     $rs = $DB->get_recordset_sql($sql, $params);
920     $newrdefs = array();
921     foreach ($rs as $rd) {
922         $k = $rd->path.':'.$rd->roleid;
923         if (isset($accessdata['rdef'][$k])) {
924             continue;
925         }
926         $newrdefs[$k][$rd->capability] = (int)$rd->permission;
927     }
928     $rs->close();
930     // share new role definitions
931     foreach ($newrdefs as $k=>$unused) {
932         if (!isset($ACCESSLIB_PRIVATE->rolepermissions[$k])) {
933             $ACCESSLIB_PRIVATE->rolepermissions[$k] = $newrdefs[$k];
934         }
935         $accessdata['rdef_count']++;
936         $accessdata['rdef'][$k] =& $ACCESSLIB_PRIVATE->rolepermissions[$k];
937     }
939     $accessdata['loaded'][$coursecontext->instanceid] = 1;
941     // we want to deduplicate the USER->access from time to time, this looks like a good place,
942     // because we have to do it before the end of session
943     dedupe_user_access();
946 /**
947  * Add to the access ctrl array the data needed by a role for a given context.
948  *
949  * The data is added in the rdef key.
950  * This role-centric function is useful for role_switching
951  * and temporary course roles.
952  *
953  * @access private
954  * @param int $roleid the id of the user
955  * @param context $context needs path!
956  * @param array $accessdata accessdata array (is modified)
957  * @return array
958  */
959 function load_role_access_by_context($roleid, context $context, &$accessdata) {
960     global $DB, $ACCESSLIB_PRIVATE;
962     /* Get the relevant rolecaps into rdef
963      * - relevant role caps
964      *   - at ctx and above
965      *   - below this ctx
966      */
968     if (empty($context->path)) {
969         // weird, this should not happen
970         return;
971     }
973     list($parentsaself, $params) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'pc_');
974     $params['roleid'] = $roleid;
975     $params['childpath'] = $context->path.'/%';
977     $sql = "SELECT ctx.path, rc.capability, rc.permission
978               FROM {role_capabilities} rc
979               JOIN {context} ctx ON (rc.contextid = ctx.id)
980              WHERE rc.roleid = :roleid AND (ctx.id $parentsaself OR ctx.path LIKE :childpath)
981           ORDER BY rc.capability"; // fixed capability order is necessary for rdef dedupe
982     $rs = $DB->get_recordset_sql($sql, $params);
984     $newrdefs = array();
985     foreach ($rs as $rd) {
986         $k = $rd->path.':'.$roleid;
987         if (isset($accessdata['rdef'][$k])) {
988             continue;
989         }
990         $newrdefs[$k][$rd->capability] = (int)$rd->permission;
991     }
992     $rs->close();
994     // share new role definitions
995     foreach ($newrdefs as $k=>$unused) {
996         if (!isset($ACCESSLIB_PRIVATE->rolepermissions[$k])) {
997             $ACCESSLIB_PRIVATE->rolepermissions[$k] = $newrdefs[$k];
998         }
999         $accessdata['rdef_count']++;
1000         $accessdata['rdef'][$k] =& $ACCESSLIB_PRIVATE->rolepermissions[$k];
1001     }
1004 /**
1005  * Returns empty accessdata structure.
1006  *
1007  * @access private
1008  * @return array empt accessdata
1009  */
1010 function get_empty_accessdata() {
1011     $accessdata               = array(); // named list
1012     $accessdata['ra']         = array();
1013     $accessdata['rdef']       = array();
1014     $accessdata['rdef_count'] = 0;       // this bloody hack is necessary because count($array) is slooooowwww in PHP
1015     $accessdata['rdef_lcc']   = 0;       // rdef_count during the last compression
1016     $accessdata['loaded']     = array(); // loaded course contexts
1017     $accessdata['time']       = time();
1018     $accessdata['rsw']        = array();
1020     return $accessdata;
1023 /**
1024  * Get accessdata for a given user.
1025  *
1026  * @access private
1027  * @param int $userid
1028  * @param bool $preloadonly true means do not return access array
1029  * @return array accessdata
1030  */
1031 function get_user_accessdata($userid, $preloadonly=false) {
1032     global $CFG, $ACCESSLIB_PRIVATE, $USER;
1034     if (!empty($USER->acces['rdef']) and empty($ACCESSLIB_PRIVATE->rolepermissions)) {
1035         // share rdef from USER session with rolepermissions cache in order to conserve memory
1036         foreach($USER->acces['rdef'] as $k=>$v) {
1037             $ACCESSLIB_PRIVATE->rolepermissions[$k] =& $USER->acces['rdef'][$k];
1038         }
1039         $ACCESSLIB_PRIVATE->accessdatabyuser[$USER->id] = $USER->acces;
1040     }
1042     if (!isset($ACCESSLIB_PRIVATE->accessdatabyuser[$userid])) {
1043         if (empty($userid)) {
1044             if (!empty($CFG->notloggedinroleid)) {
1045                 $accessdata = get_role_access($CFG->notloggedinroleid);
1046             } else {
1047                 // weird
1048                 return get_empty_accessdata();
1049             }
1051         } else if (isguestuser($userid)) {
1052             if ($guestrole = get_guest_role()) {
1053                 $accessdata = get_role_access($guestrole->id);
1054             } else {
1055                 //weird
1056                 return get_empty_accessdata();
1057             }
1059         } else {
1060             $accessdata = get_user_access_sitewide($userid); // includes default role and frontpage role
1061         }
1063         $ACCESSLIB_PRIVATE->accessdatabyuser[$userid] = $accessdata;
1064     }
1066     if ($preloadonly) {
1067         return;
1068     } else {
1069         return $ACCESSLIB_PRIVATE->accessdatabyuser[$userid];
1070     }
1073 /**
1074  * Try to minimise the size of $USER->access by eliminating duplicate override storage,
1075  * this function looks for contexts with the same overrides and shares them.
1076  *
1077  * @access private
1078  * @return void
1079  */
1080 function dedupe_user_access() {
1081     global $USER;
1083     if (CLI_SCRIPT) {
1084         // no session in CLI --> no compression necessary
1085         return;
1086     }
1088     if (empty($USER->access['rdef_count'])) {
1089         // weird, this should not happen
1090         return;
1091     }
1093     // the rdef is growing only, we never remove stuff from it, the rdef_lcc helps us to detect new stuff in rdef
1094     if ($USER->access['rdef_count'] - $USER->access['rdef_lcc'] > 10) {
1095         // do not compress after each change, wait till there is more stuff to be done
1096         return;
1097     }
1099     $hashmap = array();
1100     foreach ($USER->access['rdef'] as $k=>$def) {
1101         $hash = sha1(serialize($def));
1102         if (isset($hashmap[$hash])) {
1103             $USER->access['rdef'][$k] =& $hashmap[$hash];
1104         } else {
1105             $hashmap[$hash] =& $USER->access['rdef'][$k];
1106         }
1107     }
1109     $USER->access['rdef_lcc'] = $USER->access['rdef_count'];
1112 /**
1113  * A convenience function to completely load all the capabilities
1114  * for the current user. It is called from has_capability() and functions change permissions.
1115  *
1116  * Call it only _after_ you've setup $USER and called check_enrolment_plugins();
1117  * @see check_enrolment_plugins()
1118  *
1119  * @access private
1120  * @return void
1121  */
1122 function load_all_capabilities() {
1123     global $USER;
1125     // roles not installed yet - we are in the middle of installation
1126     if (during_initial_install()) {
1127         return;
1128     }
1130     if (!isset($USER->id)) {
1131         // this should not happen
1132         $USER->id = 0;
1133     }
1135     unset($USER->access);
1136     $USER->access = get_user_accessdata($USER->id);
1138     // deduplicate the overrides to minimize session size
1139     dedupe_user_access();
1141     // Clear to force a refresh
1142     unset($USER->mycourses);
1144     // init/reset internal enrol caches - active course enrolments and temp access
1145     $USER->enrol = array('enrolled'=>array(), 'tempguest'=>array());
1148 /**
1149  * A convenience function to completely reload all the capabilities
1150  * for the current user when roles have been updated in a relevant
1151  * context -- but PRESERVING switchroles and loginas.
1152  * This function resets all accesslib and context caches.
1153  *
1154  * That is - completely transparent to the user.
1155  *
1156  * Note: reloads $USER->access completely.
1157  *
1158  * @access private
1159  * @return void
1160  */
1161 function reload_all_capabilities() {
1162     global $USER, $DB, $ACCESSLIB_PRIVATE;
1164     // copy switchroles
1165     $sw = array();
1166     if (!empty($USER->access['rsw'])) {
1167         $sw = $USER->access['rsw'];
1168     }
1170     accesslib_clear_all_caches(true);
1171     unset($USER->access);
1172     $ACCESSLIB_PRIVATE->dirtycontexts = array(); // prevent dirty flags refetching on this page
1174     load_all_capabilities();
1176     foreach ($sw as $path => $roleid) {
1177         if ($record = $DB->get_record('context', array('path'=>$path))) {
1178             $context = context::instance_by_id($record->id);
1179             role_switch($roleid, $context);
1180         }
1181     }
1184 /**
1185  * Adds a temp role to current USER->access array.
1186  *
1187  * Useful for the "temporary guest" access we grant to logged-in users.
1188  * This is useful for enrol plugins only.
1189  *
1190  * @since 2.2
1191  * @param context_course $coursecontext
1192  * @param int $roleid
1193  * @return void
1194  */
1195 function load_temp_course_role(context_course $coursecontext, $roleid) {
1196     global $USER, $SITE;
1198     if (empty($roleid)) {
1199         debugging('invalid role specified in load_temp_course_role()');
1200         return;
1201     }
1203     if ($coursecontext->instanceid == $SITE->id) {
1204         debugging('Can not use temp roles on the frontpage');
1205         return;
1206     }
1208     if (!isset($USER->access)) {
1209         load_all_capabilities();
1210     }
1212     $coursecontext->reload_if_dirty();
1214     if (isset($USER->access['ra'][$coursecontext->path][$roleid])) {
1215         return;
1216     }
1218     // load course stuff first
1219     load_course_context($USER->id, $coursecontext, $USER->access);
1221     $USER->access['ra'][$coursecontext->path][(int)$roleid] = (int)$roleid;
1223     load_role_access_by_context($roleid, $coursecontext, $USER->access);
1226 /**
1227  * Removes any extra guest roles from current USER->access array.
1228  * This is useful for enrol plugins only.
1229  *
1230  * @since 2.2
1231  * @param context_course $coursecontext
1232  * @return void
1233  */
1234 function remove_temp_course_roles(context_course $coursecontext) {
1235     global $DB, $USER, $SITE;
1237     if ($coursecontext->instanceid == $SITE->id) {
1238         debugging('Can not use temp roles on the frontpage');
1239         return;
1240     }
1242     if (empty($USER->access['ra'][$coursecontext->path])) {
1243         //no roles here, weird
1244         return;
1245     }
1247     $sql = "SELECT DISTINCT ra.roleid AS id
1248               FROM {role_assignments} ra
1249              WHERE ra.contextid = :contextid AND ra.userid = :userid";
1250     $ras = $DB->get_records_sql($sql, array('contextid'=>$coursecontext->id, 'userid'=>$USER->id));
1252     $USER->access['ra'][$coursecontext->path] = array();
1253     foreach($ras as $r) {
1254         $USER->access['ra'][$coursecontext->path][(int)$r->id] = (int)$r->id;
1255     }
1258 /**
1259  * Returns array of all role archetypes.
1260  *
1261  * @return array
1262  */
1263 function get_role_archetypes() {
1264     return array(
1265         'manager'        => 'manager',
1266         'coursecreator'  => 'coursecreator',
1267         'editingteacher' => 'editingteacher',
1268         'teacher'        => 'teacher',
1269         'student'        => 'student',
1270         'guest'          => 'guest',
1271         'user'           => 'user',
1272         'frontpage'      => 'frontpage'
1273     );
1276 /**
1277  * Assign the defaults found in this capability definition to roles that have
1278  * the corresponding legacy capabilities assigned to them.
1279  *
1280  * @param string $capability
1281  * @param array $legacyperms an array in the format (example):
1282  *                      'guest' => CAP_PREVENT,
1283  *                      'student' => CAP_ALLOW,
1284  *                      'teacher' => CAP_ALLOW,
1285  *                      'editingteacher' => CAP_ALLOW,
1286  *                      'coursecreator' => CAP_ALLOW,
1287  *                      'manager' => CAP_ALLOW
1288  * @return boolean success or failure.
1289  */
1290 function assign_legacy_capabilities($capability, $legacyperms) {
1292     $archetypes = get_role_archetypes();
1294     foreach ($legacyperms as $type => $perm) {
1296         $systemcontext = context_system::instance();
1297         if ($type === 'admin') {
1298             debugging('Legacy type admin in access.php was renamed to manager, please update the code.');
1299             $type = 'manager';
1300         }
1302         if (!array_key_exists($type, $archetypes)) {
1303             print_error('invalidlegacy', '', '', $type);
1304         }
1306         if ($roles = get_archetype_roles($type)) {
1307             foreach ($roles as $role) {
1308                 // Assign a site level capability.
1309                 if (!assign_capability($capability, $perm, $role->id, $systemcontext->id)) {
1310                     return false;
1311                 }
1312             }
1313         }
1314     }
1315     return true;
1318 /**
1319  * Verify capability risks.
1320  *
1321  * @param stdClass $capability a capability - a row from the capabilities table.
1322  * @return boolean whether this capability is safe - that is, whether people with the
1323  *      safeoverrides capability should be allowed to change it.
1324  */
1325 function is_safe_capability($capability) {
1326     return !((RISK_DATALOSS | RISK_MANAGETRUST | RISK_CONFIG | RISK_XSS | RISK_PERSONAL) & $capability->riskbitmask);
1329 /**
1330  * Get the local override (if any) for a given capability in a role in a context
1331  *
1332  * @param int $roleid
1333  * @param int $contextid
1334  * @param string $capability
1335  * @return stdClass local capability override
1336  */
1337 function get_local_override($roleid, $contextid, $capability) {
1338     global $DB;
1339     return $DB->get_record('role_capabilities', array('roleid'=>$roleid, 'capability'=>$capability, 'contextid'=>$contextid));
1342 /**
1343  * Returns context instance plus related course and cm instances
1344  *
1345  * @param int $contextid
1346  * @return array of ($context, $course, $cm)
1347  */
1348 function get_context_info_array($contextid) {
1349     global $DB;
1351     $context = context::instance_by_id($contextid, MUST_EXIST);
1352     $course  = null;
1353     $cm      = null;
1355     if ($context->contextlevel == CONTEXT_COURSE) {
1356         $course = $DB->get_record('course', array('id'=>$context->instanceid), '*', MUST_EXIST);
1358     } else if ($context->contextlevel == CONTEXT_MODULE) {
1359         $cm = get_coursemodule_from_id('', $context->instanceid, 0, false, MUST_EXIST);
1360         $course = $DB->get_record('course', array('id'=>$cm->course), '*', MUST_EXIST);
1362     } else if ($context->contextlevel == CONTEXT_BLOCK) {
1363         $parent = $context->get_parent_context();
1365         if ($parent->contextlevel == CONTEXT_COURSE) {
1366             $course = $DB->get_record('course', array('id'=>$parent->instanceid), '*', MUST_EXIST);
1367         } else if ($parent->contextlevel == CONTEXT_MODULE) {
1368             $cm = get_coursemodule_from_id('', $parent->instanceid, 0, false, MUST_EXIST);
1369             $course = $DB->get_record('course', array('id'=>$cm->course), '*', MUST_EXIST);
1370         }
1371     }
1373     return array($context, $course, $cm);
1376 /**
1377  * Function that creates a role
1378  *
1379  * @param string $name role name
1380  * @param string $shortname role short name
1381  * @param string $description role description
1382  * @param string $archetype
1383  * @return int id or dml_exception
1384  */
1385 function create_role($name, $shortname, $description, $archetype = '') {
1386     global $DB;
1388     if (strpos($archetype, 'moodle/legacy:') !== false) {
1389         throw new coding_exception('Use new role archetype parameter in create_role() instead of old legacy capabilities.');
1390     }
1392     // verify role archetype actually exists
1393     $archetypes = get_role_archetypes();
1394     if (empty($archetypes[$archetype])) {
1395         $archetype = '';
1396     }
1398     // Insert the role record.
1399     $role = new stdClass();
1400     $role->name        = $name;
1401     $role->shortname   = $shortname;
1402     $role->description = $description;
1403     $role->archetype   = $archetype;
1405     //find free sortorder number
1406     $role->sortorder = $DB->get_field('role', 'MAX(sortorder) + 1', array());
1407     if (empty($role->sortorder)) {
1408         $role->sortorder = 1;
1409     }
1410     $id = $DB->insert_record('role', $role);
1412     return $id;
1415 /**
1416  * Function that deletes a role and cleanups up after it
1417  *
1418  * @param int $roleid id of role to delete
1419  * @return bool always true
1420  */
1421 function delete_role($roleid) {
1422     global $DB;
1424     // first unssign all users
1425     role_unassign_all(array('roleid'=>$roleid));
1427     // cleanup all references to this role, ignore errors
1428     $DB->delete_records('role_capabilities',   array('roleid'=>$roleid));
1429     $DB->delete_records('role_allow_assign',   array('roleid'=>$roleid));
1430     $DB->delete_records('role_allow_assign',   array('allowassign'=>$roleid));
1431     $DB->delete_records('role_allow_override', array('roleid'=>$roleid));
1432     $DB->delete_records('role_allow_override', array('allowoverride'=>$roleid));
1433     $DB->delete_records('role_names',          array('roleid'=>$roleid));
1434     $DB->delete_records('role_context_levels', array('roleid'=>$roleid));
1436     // finally delete the role itself
1437     // get this before the name is gone for logging
1438     $rolename = $DB->get_field('role', 'name', array('id'=>$roleid));
1440     $DB->delete_records('role', array('id'=>$roleid));
1442     add_to_log(SITEID, 'role', 'delete', 'admin/roles/action=delete&roleid='.$roleid, $rolename, '');
1444     return true;
1447 /**
1448  * Function to write context specific overrides, or default capabilities.
1449  *
1450  * NOTE: use $context->mark_dirty() after this
1451  *
1452  * @param string $capability string name
1453  * @param int $permission CAP_ constants
1454  * @param int $roleid role id
1455  * @param int|context $contextid context id
1456  * @param bool $overwrite
1457  * @return bool always true or exception
1458  */
1459 function assign_capability($capability, $permission, $roleid, $contextid, $overwrite = false) {
1460     global $USER, $DB;
1462     if ($contextid instanceof context) {
1463         $context = $contextid;
1464     } else {
1465         $context = context::instance_by_id($contextid);
1466     }
1468     if (empty($permission) || $permission == CAP_INHERIT) { // if permission is not set
1469         unassign_capability($capability, $roleid, $context->id);
1470         return true;
1471     }
1473     $existing = $DB->get_record('role_capabilities', array('contextid'=>$context->id, 'roleid'=>$roleid, 'capability'=>$capability));
1475     if ($existing and !$overwrite) {   // We want to keep whatever is there already
1476         return true;
1477     }
1479     $cap = new stdClass();
1480     $cap->contextid    = $context->id;
1481     $cap->roleid       = $roleid;
1482     $cap->capability   = $capability;
1483     $cap->permission   = $permission;
1484     $cap->timemodified = time();
1485     $cap->modifierid   = empty($USER->id) ? 0 : $USER->id;
1487     if ($existing) {
1488         $cap->id = $existing->id;
1489         $DB->update_record('role_capabilities', $cap);
1490     } else {
1491         if ($DB->record_exists('context', array('id'=>$context->id))) {
1492             $DB->insert_record('role_capabilities', $cap);
1493         }
1494     }
1495     return true;
1498 /**
1499  * Unassign a capability from a role.
1500  *
1501  * NOTE: use $context->mark_dirty() after this
1502  *
1503  * @param string $capability the name of the capability
1504  * @param int $roleid the role id
1505  * @param int|context $contextid null means all contexts
1506  * @return boolean true or exception
1507  */
1508 function unassign_capability($capability, $roleid, $contextid = null) {
1509     global $DB;
1511     if (!empty($contextid)) {
1512         if ($contextid instanceof context) {
1513             $context = $contextid;
1514         } else {
1515             $context = context::instance_by_id($contextid);
1516         }
1517         // delete from context rel, if this is the last override in this context
1518         $DB->delete_records('role_capabilities', array('capability'=>$capability, 'roleid'=>$roleid, 'contextid'=>$context->id));
1519     } else {
1520         $DB->delete_records('role_capabilities', array('capability'=>$capability, 'roleid'=>$roleid));
1521     }
1522     return true;
1525 /**
1526  * Get the roles that have a given capability assigned to it
1527  *
1528  * This function does not resolve the actual permission of the capability.
1529  * It just checks for permissions and overrides.
1530  * Use get_roles_with_cap_in_context() if resolution is required.
1531  *
1532  * @param string $capability capability name (string)
1533  * @param string $permission optional, the permission defined for this capability
1534  *                      either CAP_ALLOW, CAP_PREVENT or CAP_PROHIBIT. Defaults to null which means any.
1535  * @param stdClass $context null means any
1536  * @return array of role records
1537  */
1538 function get_roles_with_capability($capability, $permission = null, $context = null) {
1539     global $DB;
1541     if ($context) {
1542         $contexts = $context->get_parent_context_ids(true);
1543         list($insql, $params) = $DB->get_in_or_equal($contexts, SQL_PARAMS_NAMED, 'ctx');
1544         $contextsql = "AND rc.contextid $insql";
1545     } else {
1546         $params = array();
1547         $contextsql = '';
1548     }
1550     if ($permission) {
1551         $permissionsql = " AND rc.permission = :permission";
1552         $params['permission'] = $permission;
1553     } else {
1554         $permissionsql = '';
1555     }
1557     $sql = "SELECT r.*
1558               FROM {role} r
1559              WHERE r.id IN (SELECT rc.roleid
1560                               FROM {role_capabilities} rc
1561                              WHERE rc.capability = :capname
1562                                    $contextsql
1563                                    $permissionsql)";
1564     $params['capname'] = $capability;
1567     return $DB->get_records_sql($sql, $params);
1570 /**
1571  * This function makes a role-assignment (a role for a user in a particular context)
1572  *
1573  * @param int $roleid the role of the id
1574  * @param int $userid userid
1575  * @param int|context $contextid id of the context
1576  * @param string $component example 'enrol_ldap', defaults to '' which means manual assignment,
1577  * @param int $itemid id of enrolment/auth plugin
1578  * @param string $timemodified defaults to current time
1579  * @return int new/existing id of the assignment
1580  */
1581 function role_assign($roleid, $userid, $contextid, $component = '', $itemid = 0, $timemodified = '') {
1582     global $USER, $DB;
1584     // first of all detect if somebody is using old style parameters
1585     if ($contextid === 0 or is_numeric($component)) {
1586         throw new coding_exception('Invalid call to role_assign(), code needs to be updated to use new order of parameters');
1587     }
1589     // now validate all parameters
1590     if (empty($roleid)) {
1591         throw new coding_exception('Invalid call to role_assign(), roleid can not be empty');
1592     }
1594     if (empty($userid)) {
1595         throw new coding_exception('Invalid call to role_assign(), userid can not be empty');
1596     }
1598     if ($itemid) {
1599         if (strpos($component, '_') === false) {
1600             throw new coding_exception('Invalid call to role_assign(), component must start with plugin type such as"enrol_" when itemid specified', 'component:'.$component);
1601         }
1602     } else {
1603         $itemid = 0;
1604         if ($component !== '' and strpos($component, '_') === false) {
1605             throw new coding_exception('Invalid call to role_assign(), invalid component string', 'component:'.$component);
1606         }
1607     }
1609     if (!$DB->record_exists('user', array('id'=>$userid, 'deleted'=>0))) {
1610         throw new coding_exception('User ID does not exist or is deleted!', 'userid:'.$userid);
1611     }
1613     if ($contextid instanceof context) {
1614         $context = $contextid;
1615     } else {
1616         $context = context::instance_by_id($contextid, MUST_EXIST);
1617     }
1619     if (!$timemodified) {
1620         $timemodified = time();
1621     }
1623     // Check for existing entry
1624     // TODO: Revisit this sql_empty() use once Oracle bindings are improved. MDL-29765
1625     $component = ($component === '') ? $DB->sql_empty() : $component;
1626     $ras = $DB->get_records('role_assignments', array('roleid'=>$roleid, 'contextid'=>$context->id, 'userid'=>$userid, 'component'=>$component, 'itemid'=>$itemid), 'id');
1628     if ($ras) {
1629         // role already assigned - this should not happen
1630         if (count($ras) > 1) {
1631             // very weird - remove all duplicates!
1632             $ra = array_shift($ras);
1633             foreach ($ras as $r) {
1634                 $DB->delete_records('role_assignments', array('id'=>$r->id));
1635             }
1636         } else {
1637             $ra = reset($ras);
1638         }
1640         // actually there is no need to update, reset anything or trigger any event, so just return
1641         return $ra->id;
1642     }
1644     // Create a new entry
1645     $ra = new stdClass();
1646     $ra->roleid       = $roleid;
1647     $ra->contextid    = $context->id;
1648     $ra->userid       = $userid;
1649     $ra->component    = $component;
1650     $ra->itemid       = $itemid;
1651     $ra->timemodified = $timemodified;
1652     $ra->modifierid   = empty($USER->id) ? 0 : $USER->id;
1654     $ra->id = $DB->insert_record('role_assignments', $ra);
1656     // mark context as dirty - again expensive, but needed
1657     $context->mark_dirty();
1659     if (!empty($USER->id) && $USER->id == $userid) {
1660         // If the user is the current user, then do full reload of capabilities too.
1661         reload_all_capabilities();
1662     }
1664     events_trigger('role_assigned', $ra);
1666     return $ra->id;
1669 /**
1670  * Removes one role assignment
1671  *
1672  * @param int $roleid
1673  * @param int  $userid
1674  * @param int|context  $contextid
1675  * @param string $component
1676  * @param int  $itemid
1677  * @return void
1678  */
1679 function role_unassign($roleid, $userid, $contextid, $component = '', $itemid = 0) {
1680     // first make sure the params make sense
1681     if ($roleid == 0 or $userid == 0 or $contextid == 0) {
1682         throw new coding_exception('Invalid call to role_unassign(), please use role_unassign_all() when removing multiple role assignments');
1683     }
1685     if ($itemid) {
1686         if (strpos($component, '_') === false) {
1687             throw new coding_exception('Invalid call to role_assign(), component must start with plugin type such as "enrol_" when itemid specified', 'component:'.$component);
1688         }
1689     } else {
1690         $itemid = 0;
1691         if ($component !== '' and strpos($component, '_') === false) {
1692             throw new coding_exception('Invalid call to role_assign(), invalid component string', 'component:'.$component);
1693         }
1694     }
1696     role_unassign_all(array('roleid'=>$roleid, 'userid'=>$userid, 'contextid'=>$contextid, 'component'=>$component, 'itemid'=>$itemid), false, false);
1699 /**
1700  * Removes multiple role assignments, parameters may contain:
1701  *   'roleid', 'userid', 'contextid', 'component', 'enrolid'.
1702  *
1703  * @param array $params role assignment parameters
1704  * @param bool $subcontexts unassign in subcontexts too
1705  * @param bool $includemanual include manual role assignments too
1706  * @return void
1707  */
1708 function role_unassign_all(array $params, $subcontexts = false, $includemanual = false) {
1709     global $USER, $CFG, $DB;
1711     if (!$params) {
1712         throw new coding_exception('Missing parameters in role_unsassign_all() call');
1713     }
1715     $allowed = array('roleid', 'userid', 'contextid', 'component', 'itemid');
1716     foreach ($params as $key=>$value) {
1717         if (!in_array($key, $allowed)) {
1718             throw new coding_exception('Unknown role_unsassign_all() parameter key', 'key:'.$key);
1719         }
1720     }
1722     if (isset($params['component']) and $params['component'] !== '' and strpos($params['component'], '_') === false) {
1723         throw new coding_exception('Invalid component paramter in role_unsassign_all() call', 'component:'.$params['component']);
1724     }
1726     if ($includemanual) {
1727         if (!isset($params['component']) or $params['component'] === '') {
1728             throw new coding_exception('include manual parameter requires component parameter in role_unsassign_all() call');
1729         }
1730     }
1732     if ($subcontexts) {
1733         if (empty($params['contextid'])) {
1734             throw new coding_exception('subcontexts paramtere requires component parameter in role_unsassign_all() call');
1735         }
1736     }
1738     // TODO: Revisit this sql_empty() use once Oracle bindings are improved. MDL-29765
1739     if (isset($params['component'])) {
1740         $params['component'] = ($params['component'] === '') ? $DB->sql_empty() : $params['component'];
1741     }
1742     $ras = $DB->get_records('role_assignments', $params);
1743     foreach($ras as $ra) {
1744         $DB->delete_records('role_assignments', array('id'=>$ra->id));
1745         if ($context = context::instance_by_id($ra->contextid, IGNORE_MISSING)) {
1746             // this is a bit expensive but necessary
1747             $context->mark_dirty();
1748             // If the user is the current user, then do full reload of capabilities too.
1749             if (!empty($USER->id) && $USER->id == $ra->userid) {
1750                 reload_all_capabilities();
1751             }
1752         }
1753         events_trigger('role_unassigned', $ra);
1754     }
1755     unset($ras);
1757     // process subcontexts
1758     if ($subcontexts and $context = context::instance_by_id($params['contextid'], IGNORE_MISSING)) {
1759         if ($params['contextid'] instanceof context) {
1760             $context = $params['contextid'];
1761         } else {
1762             $context = context::instance_by_id($params['contextid'], IGNORE_MISSING);
1763         }
1765         if ($context) {
1766             $contexts = $context->get_child_contexts();
1767             $mparams = $params;
1768             foreach($contexts as $context) {
1769                 $mparams['contextid'] = $context->id;
1770                 $ras = $DB->get_records('role_assignments', $mparams);
1771                 foreach($ras as $ra) {
1772                     $DB->delete_records('role_assignments', array('id'=>$ra->id));
1773                     // this is a bit expensive but necessary
1774                     $context->mark_dirty();
1775                     // If the user is the current user, then do full reload of capabilities too.
1776                     if (!empty($USER->id) && $USER->id == $ra->userid) {
1777                         reload_all_capabilities();
1778                     }
1779                     events_trigger('role_unassigned', $ra);
1780                 }
1781             }
1782         }
1783     }
1785     // do this once more for all manual role assignments
1786     if ($includemanual) {
1787         $params['component'] = '';
1788         role_unassign_all($params, $subcontexts, false);
1789     }
1792 /**
1793  * Determines if a user is currently logged in
1794  *
1795  * @category   access
1796  *
1797  * @return bool
1798  */
1799 function isloggedin() {
1800     global $USER;
1802     return (!empty($USER->id));
1805 /**
1806  * Determines if a user is logged in as real guest user with username 'guest'.
1807  *
1808  * @category   access
1809  *
1810  * @param int|object $user mixed user object or id, $USER if not specified
1811  * @return bool true if user is the real guest user, false if not logged in or other user
1812  */
1813 function isguestuser($user = null) {
1814     global $USER, $DB, $CFG;
1816     // make sure we have the user id cached in config table, because we are going to use it a lot
1817     if (empty($CFG->siteguest)) {
1818         if (!$guestid = $DB->get_field('user', 'id', array('username'=>'guest', 'mnethostid'=>$CFG->mnet_localhost_id))) {
1819             // guest does not exist yet, weird
1820             return false;
1821         }
1822         set_config('siteguest', $guestid);
1823     }
1824     if ($user === null) {
1825         $user = $USER;
1826     }
1828     if ($user === null) {
1829         // happens when setting the $USER
1830         return false;
1832     } else if (is_numeric($user)) {
1833         return ($CFG->siteguest == $user);
1835     } else if (is_object($user)) {
1836         if (empty($user->id)) {
1837             return false; // not logged in means is not be guest
1838         } else {
1839             return ($CFG->siteguest == $user->id);
1840         }
1842     } else {
1843         throw new coding_exception('Invalid user parameter supplied for isguestuser() function!');
1844     }
1847 /**
1848  * Does user have a (temporary or real) guest access to course?
1849  *
1850  * @category   access
1851  *
1852  * @param context $context
1853  * @param stdClass|int $user
1854  * @return bool
1855  */
1856 function is_guest(context $context, $user = null) {
1857     global $USER;
1859     // first find the course context
1860     $coursecontext = $context->get_course_context();
1862     // make sure there is a real user specified
1863     if ($user === null) {
1864         $userid = isset($USER->id) ? $USER->id : 0;
1865     } else {
1866         $userid = is_object($user) ? $user->id : $user;
1867     }
1869     if (isguestuser($userid)) {
1870         // can not inspect or be enrolled
1871         return true;
1872     }
1874     if (has_capability('moodle/course:view', $coursecontext, $user)) {
1875         // viewing users appear out of nowhere, they are neither guests nor participants
1876         return false;
1877     }
1879     // consider only real active enrolments here
1880     if (is_enrolled($coursecontext, $user, '', true)) {
1881         return false;
1882     }
1884     return true;
1887 /**
1888  * Returns true if the user has moodle/course:view capability in the course,
1889  * this is intended for admins, managers (aka small admins), inspectors, etc.
1890  *
1891  * @category   access
1892  *
1893  * @param context $context
1894  * @param int|stdClass $user if null $USER is used
1895  * @param string $withcapability extra capability name
1896  * @return bool
1897  */
1898 function is_viewing(context $context, $user = null, $withcapability = '') {
1899     // first find the course context
1900     $coursecontext = $context->get_course_context();
1902     if (isguestuser($user)) {
1903         // can not inspect
1904         return false;
1905     }
1907     if (!has_capability('moodle/course:view', $coursecontext, $user)) {
1908         // admins are allowed to inspect courses
1909         return false;
1910     }
1912     if ($withcapability and !has_capability($withcapability, $context, $user)) {
1913         // site admins always have the capability, but the enrolment above blocks
1914         return false;
1915     }
1917     return true;
1920 /**
1921  * Returns true if user is enrolled (is participating) in course
1922  * this is intended for students and teachers.
1923  *
1924  * Since 2.2 the result for active enrolments and current user are cached.
1925  *
1926  * @package   core_enrol
1927  * @category  access
1928  *
1929  * @param context $context
1930  * @param int|stdClass $user if null $USER is used, otherwise user object or id expected
1931  * @param string $withcapability extra capability name
1932  * @param bool $onlyactive consider only active enrolments in enabled plugins and time restrictions
1933  * @return bool
1934  */
1935 function is_enrolled(context $context, $user = null, $withcapability = '', $onlyactive = false) {
1936     global $USER, $DB;
1938     // first find the course context
1939     $coursecontext = $context->get_course_context();
1941     // make sure there is a real user specified
1942     if ($user === null) {
1943         $userid = isset($USER->id) ? $USER->id : 0;
1944     } else {
1945         $userid = is_object($user) ? $user->id : $user;
1946     }
1948     if (empty($userid)) {
1949         // not-logged-in!
1950         return false;
1951     } else if (isguestuser($userid)) {
1952         // guest account can not be enrolled anywhere
1953         return false;
1954     }
1956     if ($coursecontext->instanceid == SITEID) {
1957         // everybody participates on frontpage
1958     } else {
1959         // try cached info first - the enrolled flag is set only when active enrolment present
1960         if ($USER->id == $userid) {
1961             $coursecontext->reload_if_dirty();
1962             if (isset($USER->enrol['enrolled'][$coursecontext->instanceid])) {
1963                 if ($USER->enrol['enrolled'][$coursecontext->instanceid] > time()) {
1964                     if ($withcapability and !has_capability($withcapability, $context, $userid)) {
1965                         return false;
1966                     }
1967                     return true;
1968                 }
1969             }
1970         }
1972         if ($onlyactive) {
1973             // look for active enrolments only
1974             $until = enrol_get_enrolment_end($coursecontext->instanceid, $userid);
1976             if ($until === false) {
1977                 return false;
1978             }
1980             if ($USER->id == $userid) {
1981                 if ($until == 0) {
1982                     $until = ENROL_MAX_TIMESTAMP;
1983                 }
1984                 $USER->enrol['enrolled'][$coursecontext->instanceid] = $until;
1985                 if (isset($USER->enrol['tempguest'][$coursecontext->instanceid])) {
1986                     unset($USER->enrol['tempguest'][$coursecontext->instanceid]);
1987                     remove_temp_course_roles($coursecontext);
1988                 }
1989             }
1991         } else {
1992             // any enrolment is good for us here, even outdated, disabled or inactive
1993             $sql = "SELECT 'x'
1994                       FROM {user_enrolments} ue
1995                       JOIN {enrol} e ON (e.id = ue.enrolid AND e.courseid = :courseid)
1996                       JOIN {user} u ON u.id = ue.userid
1997                      WHERE ue.userid = :userid AND u.deleted = 0";
1998             $params = array('userid'=>$userid, 'courseid'=>$coursecontext->instanceid);
1999             if (!$DB->record_exists_sql($sql, $params)) {
2000                 return false;
2001             }
2002         }
2003     }
2005     if ($withcapability and !has_capability($withcapability, $context, $userid)) {
2006         return false;
2007     }
2009     return true;
2012 /**
2013  * Returns true if the user is able to access the course.
2014  *
2015  * This function is in no way, shape, or form a substitute for require_login.
2016  * It should only be used in circumstances where it is not possible to call require_login
2017  * such as the navigation.
2018  *
2019  * This function checks many of the methods of access to a course such as the view
2020  * capability, enrollments, and guest access. It also makes use of the cache
2021  * generated by require_login for guest access.
2022  *
2023  * The flags within the $USER object that are used here should NEVER be used outside
2024  * of this function can_access_course and require_login. Doing so WILL break future
2025  * versions.
2026  *
2027  * @param stdClass $course record
2028  * @param stdClass|int|null $user user record or id, current user if null
2029  * @param string $withcapability Check for this capability as well.
2030  * @param bool $onlyactive consider only active enrolments in enabled plugins and time restrictions
2031  * @return boolean Returns true if the user is able to access the course
2032  */
2033 function can_access_course(stdClass $course, $user = null, $withcapability = '', $onlyactive = false) {
2034     global $DB, $USER;
2036     // this function originally accepted $coursecontext parameter
2037     if ($course instanceof context) {
2038         if ($course instanceof context_course) {
2039             debugging('deprecated context parameter, please use $course record');
2040             $coursecontext = $course;
2041             $course = $DB->get_record('course', array('id'=>$coursecontext->instanceid));
2042         } else {
2043             debugging('Invalid context parameter, please use $course record');
2044             return false;
2045         }
2046     } else {
2047         $coursecontext = context_course::instance($course->id);
2048     }
2050     if (!isset($USER->id)) {
2051         // should never happen
2052         $USER->id = 0;
2053     }
2055     // make sure there is a user specified
2056     if ($user === null) {
2057         $userid = $USER->id;
2058     } else {
2059         $userid = is_object($user) ? $user->id : $user;
2060     }
2061     unset($user);
2063     if ($withcapability and !has_capability($withcapability, $coursecontext, $userid)) {
2064         return false;
2065     }
2067     if ($userid == $USER->id) {
2068         if (!empty($USER->access['rsw'][$coursecontext->path])) {
2069             // the fact that somebody switched role means they can access the course no matter to what role they switched
2070             return true;
2071         }
2072     }
2074     if (!$course->visible and !has_capability('moodle/course:viewhiddencourses', $coursecontext, $userid)) {
2075         return false;
2076     }
2078     if (is_viewing($coursecontext, $userid)) {
2079         return true;
2080     }
2082     if ($userid != $USER->id) {
2083         // for performance reasons we do not verify temporary guest access for other users, sorry...
2084         return is_enrolled($coursecontext, $userid, '', $onlyactive);
2085     }
2087     // === from here we deal only with $USER ===
2089     $coursecontext->reload_if_dirty();
2091     if (isset($USER->enrol['enrolled'][$course->id])) {
2092         if ($USER->enrol['enrolled'][$course->id] > time()) {
2093             return true;
2094         }
2095     }
2096     if (isset($USER->enrol['tempguest'][$course->id])) {
2097         if ($USER->enrol['tempguest'][$course->id] > time()) {
2098             return true;
2099         }
2100     }
2102     if (is_enrolled($coursecontext, $USER, '', $onlyactive)) {
2103         return true;
2104     }
2106     // if not enrolled try to gain temporary guest access
2107     $instances = $DB->get_records('enrol', array('courseid'=>$course->id, 'status'=>ENROL_INSTANCE_ENABLED), 'sortorder, id ASC');
2108     $enrols = enrol_get_plugins(true);
2109     foreach($instances as $instance) {
2110         if (!isset($enrols[$instance->enrol])) {
2111             continue;
2112         }
2113         // Get a duration for the guest access, a timestamp in the future, 0 (always) or false.
2114         $until = $enrols[$instance->enrol]->try_guestaccess($instance);
2115         if ($until !== false and $until > time()) {
2116             $USER->enrol['tempguest'][$course->id] = $until;
2117             return true;
2118         }
2119     }
2120     if (isset($USER->enrol['tempguest'][$course->id])) {
2121         unset($USER->enrol['tempguest'][$course->id]);
2122         remove_temp_course_roles($coursecontext);
2123     }
2125     return false;
2128 /**
2129  * Returns array with sql code and parameters returning all ids
2130  * of users enrolled into course.
2131  *
2132  * This function is using 'eu[0-9]+_' prefix for table names and parameters.
2133  *
2134  * @package   core_enrol
2135  * @category  access
2136  *
2137  * @param context $context
2138  * @param string $withcapability
2139  * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2140  * @param bool $onlyactive consider only active enrolments in enabled plugins and time restrictions
2141  * @return array list($sql, $params)
2142  */
2143 function get_enrolled_sql(context $context, $withcapability = '', $groupid = 0, $onlyactive = false) {
2144     global $DB, $CFG;
2146     // use unique prefix just in case somebody makes some SQL magic with the result
2147     static $i = 0;
2148     $i++;
2149     $prefix = 'eu'.$i.'_';
2151     // first find the course context
2152     $coursecontext = $context->get_course_context();
2154     $isfrontpage = ($coursecontext->instanceid == SITEID);
2156     $joins  = array();
2157     $wheres = array();
2158     $params = array();
2160     list($contextids, $contextpaths) = get_context_info_list($context);
2162     // get all relevant capability info for all roles
2163     if ($withcapability) {
2164         list($incontexts, $cparams) = $DB->get_in_or_equal($contextids, SQL_PARAMS_NAMED, 'ctx');
2165         $cparams['cap'] = $withcapability;
2167         $defs = array();
2168         $sql = "SELECT rc.id, rc.roleid, rc.permission, ctx.path
2169                   FROM {role_capabilities} rc
2170                   JOIN {context} ctx on rc.contextid = ctx.id
2171                  WHERE rc.contextid $incontexts AND rc.capability = :cap";
2172         $rcs = $DB->get_records_sql($sql, $cparams);
2173         foreach ($rcs as $rc) {
2174             $defs[$rc->path][$rc->roleid] = $rc->permission;
2175         }
2177         $access = array();
2178         if (!empty($defs)) {
2179             foreach ($contextpaths as $path) {
2180                 if (empty($defs[$path])) {
2181                     continue;
2182                 }
2183                 foreach($defs[$path] as $roleid => $perm) {
2184                     if ($perm == CAP_PROHIBIT) {
2185                         $access[$roleid] = CAP_PROHIBIT;
2186                         continue;
2187                     }
2188                     if (!isset($access[$roleid])) {
2189                         $access[$roleid] = (int)$perm;
2190                     }
2191                 }
2192             }
2193         }
2195         unset($defs);
2197         // make lists of roles that are needed and prohibited
2198         $needed     = array(); // one of these is enough
2199         $prohibited = array(); // must not have any of these
2200         foreach ($access as $roleid => $perm) {
2201             if ($perm == CAP_PROHIBIT) {
2202                 unset($needed[$roleid]);
2203                 $prohibited[$roleid] = true;
2204             } else if ($perm == CAP_ALLOW and empty($prohibited[$roleid])) {
2205                 $needed[$roleid] = true;
2206             }
2207         }
2209         $defaultuserroleid      = isset($CFG->defaultuserroleid) ? $CFG->defaultuserroleid : 0;
2210         $defaultfrontpageroleid = isset($CFG->defaultfrontpageroleid) ? $CFG->defaultfrontpageroleid : 0;
2212         $nobody = false;
2214         if ($isfrontpage) {
2215             if (!empty($prohibited[$defaultuserroleid]) or !empty($prohibited[$defaultfrontpageroleid])) {
2216                 $nobody = true;
2217             } else if (!empty($needed[$defaultuserroleid]) or !empty($needed[$defaultfrontpageroleid])) {
2218                 // everybody not having prohibit has the capability
2219                 $needed = array();
2220             } else if (empty($needed)) {
2221                 $nobody = true;
2222             }
2223         } else {
2224             if (!empty($prohibited[$defaultuserroleid])) {
2225                 $nobody = true;
2226             } else if (!empty($needed[$defaultuserroleid])) {
2227                 // everybody not having prohibit has the capability
2228                 $needed = array();
2229             } else if (empty($needed)) {
2230                 $nobody = true;
2231             }
2232         }
2234         if ($nobody) {
2235             // nobody can match so return some SQL that does not return any results
2236             $wheres[] = "1 = 2";
2238         } else {
2240             if ($needed) {
2241                 $ctxids = implode(',', $contextids);
2242                 $roleids = implode(',', array_keys($needed));
2243                 $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))";
2244             }
2246             if ($prohibited) {
2247                 $ctxids = implode(',', $contextids);
2248                 $roleids = implode(',', array_keys($prohibited));
2249                 $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))";
2250                 $wheres[] = "{$prefix}ra4.id IS NULL";
2251             }
2253             if ($groupid) {
2254                 $joins[] = "JOIN {groups_members} {$prefix}gm ON ({$prefix}gm.userid = {$prefix}u.id AND {$prefix}gm.groupid = :{$prefix}gmid)";
2255                 $params["{$prefix}gmid"] = $groupid;
2256             }
2257         }
2259     } else {
2260         if ($groupid) {
2261             $joins[] = "JOIN {groups_members} {$prefix}gm ON ({$prefix}gm.userid = {$prefix}u.id AND {$prefix}gm.groupid = :{$prefix}gmid)";
2262             $params["{$prefix}gmid"] = $groupid;
2263         }
2264     }
2266     $wheres[] = "{$prefix}u.deleted = 0 AND {$prefix}u.id <> :{$prefix}guestid";
2267     $params["{$prefix}guestid"] = $CFG->siteguest;
2269     if ($isfrontpage) {
2270         // all users are "enrolled" on the frontpage
2271     } else {
2272         $joins[] = "JOIN {user_enrolments} {$prefix}ue ON {$prefix}ue.userid = {$prefix}u.id";
2273         $joins[] = "JOIN {enrol} {$prefix}e ON ({$prefix}e.id = {$prefix}ue.enrolid AND {$prefix}e.courseid = :{$prefix}courseid)";
2274         $params[$prefix.'courseid'] = $coursecontext->instanceid;
2276         if ($onlyactive) {
2277             $wheres[] = "{$prefix}ue.status = :{$prefix}active AND {$prefix}e.status = :{$prefix}enabled";
2278             $wheres[] = "{$prefix}ue.timestart < :{$prefix}now1 AND ({$prefix}ue.timeend = 0 OR {$prefix}ue.timeend > :{$prefix}now2)";
2279             $now = round(time(), -2); // rounding helps caching in DB
2280             $params = array_merge($params, array($prefix.'enabled'=>ENROL_INSTANCE_ENABLED,
2281                                                  $prefix.'active'=>ENROL_USER_ACTIVE,
2282                                                  $prefix.'now1'=>$now, $prefix.'now2'=>$now));
2283         }
2284     }
2286     $joins = implode("\n", $joins);
2287     $wheres = "WHERE ".implode(" AND ", $wheres);
2289     $sql = "SELECT DISTINCT {$prefix}u.id
2290               FROM {user} {$prefix}u
2291             $joins
2292            $wheres";
2294     return array($sql, $params);
2297 /**
2298  * Returns list of users enrolled into course.
2299  *
2300  * @package   core_enrol
2301  * @category  access
2302  *
2303  * @param context $context
2304  * @param string $withcapability
2305  * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2306  * @param string $userfields requested user record fields
2307  * @param string $orderby
2308  * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set).
2309  * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set).
2310  * @return array of user records
2311  */
2312 function get_enrolled_users(context $context, $withcapability = '', $groupid = 0, $userfields = 'u.*', $orderby = '', $limitfrom = 0, $limitnum = 0) {
2313     global $DB;
2315     list($esql, $params) = get_enrolled_sql($context, $withcapability, $groupid);
2316     $sql = "SELECT $userfields
2317               FROM {user} u
2318               JOIN ($esql) je ON je.id = u.id
2319              WHERE u.deleted = 0";
2321     if ($orderby) {
2322         $sql = "$sql ORDER BY $orderby";
2323     } else {
2324         $sql = "$sql ORDER BY u.lastname ASC, u.firstname ASC";
2325     }
2327     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
2330 /**
2331  * Counts list of users enrolled into course (as per above function)
2332  *
2333  * @package   core_enrol
2334  * @category  access
2335  *
2336  * @param context $context
2337  * @param string $withcapability
2338  * @param int $groupid 0 means ignore groups, any other value limits the result by group id
2339  * @return array of user records
2340  */
2341 function count_enrolled_users(context $context, $withcapability = '', $groupid = 0) {
2342     global $DB;
2344     list($esql, $params) = get_enrolled_sql($context, $withcapability, $groupid);
2345     $sql = "SELECT count(u.id)
2346               FROM {user} u
2347               JOIN ($esql) je ON je.id = u.id
2348              WHERE u.deleted = 0";
2350     return $DB->count_records_sql($sql, $params);
2353 /**
2354  * Loads the capability definitions for the component (from file).
2355  *
2356  * Loads the capability definitions for the component (from file). If no
2357  * capabilities are defined for the component, we simply return an empty array.
2358  *
2359  * @access private
2360  * @param string $component full plugin name, examples: 'moodle', 'mod_forum'
2361  * @return array array of capabilities
2362  */
2363 function load_capability_def($component) {
2364     $defpath = get_component_directory($component).'/db/access.php';
2366     $capabilities = array();
2367     if (file_exists($defpath)) {
2368         require($defpath);
2369         if (!empty(${$component.'_capabilities'})) {
2370             // BC capability array name
2371             // since 2.0 we prefer $capabilities instead - it is easier to use and matches db/* files
2372             debugging('componentname_capabilities array is deprecated, please use $capabilities array only in access.php files');
2373             $capabilities = ${$component.'_capabilities'};
2374         }
2375     }
2377     return $capabilities;
2380 /**
2381  * Gets the capabilities that have been cached in the database for this component.
2382  *
2383  * @access private
2384  * @param string $component - examples: 'moodle', 'mod_forum'
2385  * @return array array of capabilities
2386  */
2387 function get_cached_capabilities($component = 'moodle') {
2388     global $DB;
2389     return $DB->get_records('capabilities', array('component'=>$component));
2392 /**
2393  * Returns default capabilities for given role archetype.
2394  *
2395  * @param string $archetype role archetype
2396  * @return array
2397  */
2398 function get_default_capabilities($archetype) {
2399     global $DB;
2401     if (!$archetype) {
2402         return array();
2403     }
2405     $alldefs = array();
2406     $defaults = array();
2407     $components = array();
2408     $allcaps = $DB->get_records('capabilities');
2410     foreach ($allcaps as $cap) {
2411         if (!in_array($cap->component, $components)) {
2412             $components[] = $cap->component;
2413             $alldefs = array_merge($alldefs, load_capability_def($cap->component));
2414         }
2415     }
2416     foreach($alldefs as $name=>$def) {
2417         // Use array 'archetypes if available. Only if not specified, use 'legacy'.
2418         if (isset($def['archetypes'])) {
2419             if (isset($def['archetypes'][$archetype])) {
2420                 $defaults[$name] = $def['archetypes'][$archetype];
2421             }
2422         // 'legacy' is for backward compatibility with 1.9 access.php
2423         } else {
2424             if (isset($def['legacy'][$archetype])) {
2425                 $defaults[$name] = $def['legacy'][$archetype];
2426             }
2427         }
2428     }
2430     return $defaults;
2433 /**
2434  * Reset role capabilities to default according to selected role archetype.
2435  * If no archetype selected, removes all capabilities.
2436  *
2437  * @param int $roleid
2438  * @return void
2439  */
2440 function reset_role_capabilities($roleid) {
2441     global $DB;
2443     $role = $DB->get_record('role', array('id'=>$roleid), '*', MUST_EXIST);
2444     $defaultcaps = get_default_capabilities($role->archetype);
2446     $systemcontext = context_system::instance();
2448     $DB->delete_records('role_capabilities', array('roleid'=>$roleid));
2450     foreach($defaultcaps as $cap=>$permission) {
2451         assign_capability($cap, $permission, $roleid, $systemcontext->id);
2452     }
2455 /**
2456  * Updates the capabilities table with the component capability definitions.
2457  * If no parameters are given, the function updates the core moodle
2458  * capabilities.
2459  *
2460  * Note that the absence of the db/access.php capabilities definition file
2461  * will cause any stored capabilities for the component to be removed from
2462  * the database.
2463  *
2464  * @access private
2465  * @param string $component examples: 'moodle', 'mod/forum', 'block/quiz_results'
2466  * @return boolean true if success, exception in case of any problems
2467  */
2468 function update_capabilities($component = 'moodle') {
2469     global $DB, $OUTPUT;
2471     $storedcaps = array();
2473     $filecaps = load_capability_def($component);
2474     foreach($filecaps as $capname=>$unused) {
2475         if (!preg_match('|^[a-z]+/[a-z_0-9]+:[a-z_0-9]+$|', $capname)) {
2476             debugging("Coding problem: Invalid capability name '$capname', use 'clonepermissionsfrom' field for migration.");
2477         }
2478     }
2480     $cachedcaps = get_cached_capabilities($component);
2481     if ($cachedcaps) {
2482         foreach ($cachedcaps as $cachedcap) {
2483             array_push($storedcaps, $cachedcap->name);
2484             // update risk bitmasks and context levels in existing capabilities if needed
2485             if (array_key_exists($cachedcap->name, $filecaps)) {
2486                 if (!array_key_exists('riskbitmask', $filecaps[$cachedcap->name])) {
2487                     $filecaps[$cachedcap->name]['riskbitmask'] = 0; // no risk if not specified
2488                 }
2489                 if ($cachedcap->captype != $filecaps[$cachedcap->name]['captype']) {
2490                     $updatecap = new stdClass();
2491                     $updatecap->id = $cachedcap->id;
2492                     $updatecap->captype = $filecaps[$cachedcap->name]['captype'];
2493                     $DB->update_record('capabilities', $updatecap);
2494                 }
2495                 if ($cachedcap->riskbitmask != $filecaps[$cachedcap->name]['riskbitmask']) {
2496                     $updatecap = new stdClass();
2497                     $updatecap->id = $cachedcap->id;
2498                     $updatecap->riskbitmask = $filecaps[$cachedcap->name]['riskbitmask'];
2499                     $DB->update_record('capabilities', $updatecap);
2500                 }
2502                 if (!array_key_exists('contextlevel', $filecaps[$cachedcap->name])) {
2503                     $filecaps[$cachedcap->name]['contextlevel'] = 0; // no context level defined
2504                 }
2505                 if ($cachedcap->contextlevel != $filecaps[$cachedcap->name]['contextlevel']) {
2506                     $updatecap = new stdClass();
2507                     $updatecap->id = $cachedcap->id;
2508                     $updatecap->contextlevel = $filecaps[$cachedcap->name]['contextlevel'];
2509                     $DB->update_record('capabilities', $updatecap);
2510                 }
2511             }
2512         }
2513     }
2515     // Are there new capabilities in the file definition?
2516     $newcaps = array();
2518     foreach ($filecaps as $filecap => $def) {
2519         if (!$storedcaps ||
2520                 ($storedcaps && in_array($filecap, $storedcaps) === false)) {
2521             if (!array_key_exists('riskbitmask', $def)) {
2522                 $def['riskbitmask'] = 0; // no risk if not specified
2523             }
2524             $newcaps[$filecap] = $def;
2525         }
2526     }
2527     // Add new capabilities to the stored definition.
2528     $existingcaps = $DB->get_records_menu('capabilities', array(), 'id', 'id, name');
2529     foreach ($newcaps as $capname => $capdef) {
2530         $capability = new stdClass();
2531         $capability->name         = $capname;
2532         $capability->captype      = $capdef['captype'];
2533         $capability->contextlevel = $capdef['contextlevel'];
2534         $capability->component    = $component;
2535         $capability->riskbitmask  = $capdef['riskbitmask'];
2537         $DB->insert_record('capabilities', $capability, false);
2539         if (isset($capdef['clonepermissionsfrom']) && in_array($capdef['clonepermissionsfrom'], $existingcaps)){
2540             if ($rolecapabilities = $DB->get_records('role_capabilities', array('capability'=>$capdef['clonepermissionsfrom']))){
2541                 foreach ($rolecapabilities as $rolecapability){
2542                     //assign_capability will update rather than insert if capability exists
2543                     if (!assign_capability($capname, $rolecapability->permission,
2544                                             $rolecapability->roleid, $rolecapability->contextid, true)){
2545                          echo $OUTPUT->notification('Could not clone capabilities for '.$capname);
2546                     }
2547                 }
2548             }
2549         // we ignore archetype key if we have cloned permissions
2550         } else if (isset($capdef['archetypes']) && is_array($capdef['archetypes'])) {
2551             assign_legacy_capabilities($capname, $capdef['archetypes']);
2552         // 'legacy' is for backward compatibility with 1.9 access.php
2553         } else if (isset($capdef['legacy']) && is_array($capdef['legacy'])) {
2554             assign_legacy_capabilities($capname, $capdef['legacy']);
2555         }
2556     }
2557     // Are there any capabilities that have been removed from the file
2558     // definition that we need to delete from the stored capabilities and
2559     // role assignments?
2560     capabilities_cleanup($component, $filecaps);
2562     // reset static caches
2563     accesslib_clear_all_caches(false);
2565     return true;
2568 /**
2569  * Deletes cached capabilities that are no longer needed by the component.
2570  * Also unassigns these capabilities from any roles that have them.
2571  *
2572  * @access private
2573  * @param string $component examples: 'moodle', 'mod_forum', 'block_quiz_results'
2574  * @param array $newcapdef array of the new capability definitions that will be
2575  *                     compared with the cached capabilities
2576  * @return int number of deprecated capabilities that have been removed
2577  */
2578 function capabilities_cleanup($component, $newcapdef = null) {
2579     global $DB;
2581     $removedcount = 0;
2583     if ($cachedcaps = get_cached_capabilities($component)) {
2584         foreach ($cachedcaps as $cachedcap) {
2585             if (empty($newcapdef) ||
2586                         array_key_exists($cachedcap->name, $newcapdef) === false) {
2588                 // Remove from capabilities cache.
2589                 $DB->delete_records('capabilities', array('name'=>$cachedcap->name));
2590                 $removedcount++;
2591                 // Delete from roles.
2592                 if ($roles = get_roles_with_capability($cachedcap->name)) {
2593                     foreach($roles as $role) {
2594                         if (!unassign_capability($cachedcap->name, $role->id)) {
2595                             print_error('cannotunassigncap', 'error', '', (object)array('cap'=>$cachedcap->name, 'role'=>$role->name));
2596                         }
2597                     }
2598                 }
2599             } // End if.
2600         }
2601     }
2602     return $removedcount;
2605 /**
2606  * Returns an array of all the known types of risk
2607  * The array keys can be used, for example as CSS class names, or in calls to
2608  * print_risk_icon. The values are the corresponding RISK_ constants.
2609  *
2610  * @return array all the known types of risk.
2611  */
2612 function get_all_risks() {
2613     return array(
2614         'riskmanagetrust' => RISK_MANAGETRUST,
2615         'riskconfig'      => RISK_CONFIG,
2616         'riskxss'         => RISK_XSS,
2617         'riskpersonal'    => RISK_PERSONAL,
2618         'riskspam'        => RISK_SPAM,
2619         'riskdataloss'    => RISK_DATALOSS,
2620     );
2623 /**
2624  * Return a link to moodle docs for a given capability name
2625  *
2626  * @param stdClass $capability a capability - a row from the mdl_capabilities table.
2627  * @return string the human-readable capability name as a link to Moodle Docs.
2628  */
2629 function get_capability_docs_link($capability) {
2630     $url = get_docs_url('Capabilities/' . $capability->name);
2631     return '<a onclick="this.target=\'docspopup\'" href="' . $url . '">' . get_capability_string($capability->name) . '</a>';
2634 /**
2635  * This function pulls out all the resolved capabilities (overrides and
2636  * defaults) of a role used in capability overrides in contexts at a given
2637  * context.
2638  *
2639  * @param int $roleid
2640  * @param context $context
2641  * @param string $cap capability, optional, defaults to ''
2642  * @return array Array of capabilities
2643  */
2644 function role_context_capabilities($roleid, context $context, $cap = '') {
2645     global $DB;
2647     $contexts = $context->get_parent_context_ids(true);
2648     $contexts = '('.implode(',', $contexts).')';
2650     $params = array($roleid);
2652     if ($cap) {
2653         $search = " AND rc.capability = ? ";
2654         $params[] = $cap;
2655     } else {
2656         $search = '';
2657     }
2659     $sql = "SELECT rc.*
2660               FROM {role_capabilities} rc, {context} c
2661              WHERE rc.contextid in $contexts
2662                    AND rc.roleid = ?
2663                    AND rc.contextid = c.id $search
2664           ORDER BY c.contextlevel DESC, rc.capability DESC";
2666     $capabilities = array();
2668     if ($records = $DB->get_records_sql($sql, $params)) {
2669         // We are traversing via reverse order.
2670         foreach ($records as $record) {
2671             // If not set yet (i.e. inherit or not set at all), or currently we have a prohibit
2672             if (!isset($capabilities[$record->capability]) || $record->permission<-500) {
2673                 $capabilities[$record->capability] = $record->permission;
2674             }
2675         }
2676     }
2677     return $capabilities;
2680 /**
2681  * Constructs array with contextids as first parameter and context paths,
2682  * in both cases bottom top including self.
2683  *
2684  * @access private
2685  * @param context $context
2686  * @return array
2687  */
2688 function get_context_info_list(context $context) {
2689     $contextids = explode('/', ltrim($context->path, '/'));
2690     $contextpaths = array();
2691     $contextids2 = $contextids;
2692     while ($contextids2) {
2693         $contextpaths[] = '/' . implode('/', $contextids2);
2694         array_pop($contextids2);
2695     }
2696     return array($contextids, $contextpaths);
2699 /**
2700  * Check if context is the front page context or a context inside it
2701  *
2702  * Returns true if this context is the front page context, or a context inside it,
2703  * otherwise false.
2704  *
2705  * @param context $context a context object.
2706  * @return bool
2707  */
2708 function is_inside_frontpage(context $context) {
2709     $frontpagecontext = context_course::instance(SITEID);
2710     return strpos($context->path . '/', $frontpagecontext->path . '/') === 0;
2713 /**
2714  * Returns capability information (cached)
2715  *
2716  * @param string $capabilityname
2717  * @return stdClass or null if capability not found
2718  */
2719 function get_capability_info($capabilityname) {
2720     global $ACCESSLIB_PRIVATE, $DB; // one request per page only
2722     //TODO: MUC - this could be cached in shared memory, it would eliminate 1 query per page
2724     if (empty($ACCESSLIB_PRIVATE->capabilities)) {
2725         $ACCESSLIB_PRIVATE->capabilities = array();
2726         $caps = $DB->get_records('capabilities', array(), 'id, name, captype, riskbitmask');
2727         foreach ($caps as $cap) {
2728             $capname = $cap->name;
2729             unset($cap->id);
2730             unset($cap->name);
2731             $cap->riskbitmask = (int)$cap->riskbitmask;
2732             $ACCESSLIB_PRIVATE->capabilities[$capname] = $cap;
2733         }
2734     }
2736     return isset($ACCESSLIB_PRIVATE->capabilities[$capabilityname]) ? $ACCESSLIB_PRIVATE->capabilities[$capabilityname] : null;
2739 /**
2740  * Returns the human-readable, translated version of the capability.
2741  * Basically a big switch statement.
2742  *
2743  * @param string $capabilityname e.g. mod/choice:readresponses
2744  * @return string
2745  */
2746 function get_capability_string($capabilityname) {
2748     // Typical capability name is 'plugintype/pluginname:capabilityname'
2749     list($type, $name, $capname) = preg_split('|[/:]|', $capabilityname);
2751     if ($type === 'moodle') {
2752         $component = 'core_role';
2753     } else if ($type === 'quizreport') {
2754         //ugly hack!!
2755         $component = 'quiz_'.$name;
2756     } else {
2757         $component = $type.'_'.$name;
2758     }
2760     $stringname = $name.':'.$capname;
2762     if ($component === 'core_role' or get_string_manager()->string_exists($stringname, $component)) {
2763         return get_string($stringname, $component);
2764     }
2766     $dir = get_component_directory($component);
2767     if (!file_exists($dir)) {
2768         // plugin broken or does not exist, do not bother with printing of debug message
2769         return $capabilityname.' ???';
2770     }
2772     // something is wrong in plugin, better print debug
2773     return get_string($stringname, $component);
2776 /**
2777  * This gets the mod/block/course/core etc strings.
2778  *
2779  * @param string $component
2780  * @param int $contextlevel
2781  * @return string|bool String is success, false if failed
2782  */
2783 function get_component_string($component, $contextlevel) {
2785     if ($component === 'moodle' or $component === 'core') {
2786         switch ($contextlevel) {
2787             // TODO: this should probably use context level names instead
2788             case CONTEXT_SYSTEM:    return get_string('coresystem');
2789             case CONTEXT_USER:      return get_string('users');
2790             case CONTEXT_COURSECAT: return get_string('categories');
2791             case CONTEXT_COURSE:    return get_string('course');
2792             case CONTEXT_MODULE:    return get_string('activities');
2793             case CONTEXT_BLOCK:     return get_string('block');
2794             default:                print_error('unknowncontext');
2795         }
2796     }
2798     list($type, $name) = normalize_component($component);
2799     $dir = get_plugin_directory($type, $name);
2800     if (!file_exists($dir)) {
2801         // plugin not installed, bad luck, there is no way to find the name
2802         return $component.' ???';
2803     }
2805     switch ($type) {
2806         // TODO: this is really hacky, anyway it should be probably moved to lib/pluginlib.php
2807         case 'quiz':         return get_string($name.':componentname', $component);// insane hack!!!
2808         case 'repository':   return get_string('repository', 'repository').': '.get_string('pluginname', $component);
2809         case 'gradeimport':  return get_string('gradeimport', 'grades').': '.get_string('pluginname', $component);
2810         case 'gradeexport':  return get_string('gradeexport', 'grades').': '.get_string('pluginname', $component);
2811         case 'gradereport':  return get_string('gradereport', 'grades').': '.get_string('pluginname', $component);
2812         case 'webservice':   return get_string('webservice', 'webservice').': '.get_string('pluginname', $component);
2813         case 'block':        return get_string('block').': '.get_string('pluginname', basename($component));
2814         case 'mod':
2815             if (get_string_manager()->string_exists('pluginname', $component)) {
2816                 return get_string('activity').': '.get_string('pluginname', $component);
2817             } else {
2818                 return get_string('activity').': '.get_string('modulename', $component);
2819             }
2820         default: return get_string('pluginname', $component);
2821     }
2824 /**
2825  * Gets the list of roles assigned to this context and up (parents)
2826  * from the list of roles that are visible on user profile page
2827  * and participants page.
2828  *
2829  * @param context $context
2830  * @return array
2831  */
2832 function get_profile_roles(context $context) {
2833     global $CFG, $DB;
2835     if (empty($CFG->profileroles)) {
2836         return array();
2837     }
2839     list($rallowed, $params) = $DB->get_in_or_equal(explode(',', $CFG->profileroles), SQL_PARAMS_NAMED, 'a');
2840     list($contextlist, $cparams) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'p');
2841     $params = array_merge($params, $cparams);
2843     $sql = "SELECT DISTINCT r.id, r.name, r.shortname, r.sortorder
2844               FROM {role_assignments} ra, {role} r
2845              WHERE r.id = ra.roleid
2846                    AND ra.contextid $contextlist
2847                    AND r.id $rallowed
2848           ORDER BY r.sortorder ASC";
2850     return $DB->get_records_sql($sql, $params);
2853 /**
2854  * Gets the list of roles assigned to this context and up (parents)
2855  *
2856  * @param context $context
2857  * @return array
2858  */
2859 function get_roles_used_in_context(context $context) {
2860     global $DB;
2862     list($contextlist, $params) = $DB->get_in_or_equal($context->get_parent_context_ids(true));
2864     $sql = "SELECT DISTINCT r.id, r.name, r.shortname, r.sortorder
2865               FROM {role_assignments} ra, {role} r
2866              WHERE r.id = ra.roleid
2867                    AND ra.contextid $contextlist
2868           ORDER BY r.sortorder ASC";
2870     return $DB->get_records_sql($sql, $params);
2873 /**
2874  * This function is used to print roles column in user profile page.
2875  * It is using the CFG->profileroles to limit the list to only interesting roles.
2876  * (The permission tab has full details of user role assignments.)
2877  *
2878  * @param int $userid
2879  * @param int $courseid
2880  * @return string
2881  */
2882 function get_user_roles_in_course($userid, $courseid) {
2883     global $CFG, $DB;
2885     if (empty($CFG->profileroles)) {
2886         return '';
2887     }
2889     if ($courseid == SITEID) {
2890         $context = context_system::instance();
2891     } else {
2892         $context = context_course::instance($courseid);
2893     }
2895     if (empty($CFG->profileroles)) {
2896         return array();
2897     }
2899     list($rallowed, $params) = $DB->get_in_or_equal(explode(',', $CFG->profileroles), SQL_PARAMS_NAMED, 'a');
2900     list($contextlist, $cparams) = $DB->get_in_or_equal($context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'p');
2901     $params = array_merge($params, $cparams);
2903     $sql = "SELECT DISTINCT r.id, r.name, r.shortname, r.sortorder
2904               FROM {role_assignments} ra, {role} r
2905              WHERE r.id = ra.roleid
2906                    AND ra.contextid $contextlist
2907                    AND r.id $rallowed
2908                    AND ra.userid = :userid
2909           ORDER BY r.sortorder ASC";
2910     $params['userid'] = $userid;
2912     $rolestring = '';
2914     if ($roles = $DB->get_records_sql($sql, $params)) {
2915         foreach ($roles as $userrole) {
2916             $rolenames[$userrole->id] = $userrole->name;
2917         }
2919         $rolenames = role_fix_names($rolenames, $context);   // Substitute aliases
2921         foreach ($rolenames as $roleid => $rolename) {
2922             $rolenames[$roleid] = '<a href="'.$CFG->wwwroot.'/user/index.php?contextid='.$context->id.'&amp;roleid='.$roleid.'">'.$rolename.'</a>';
2923         }
2924         $rolestring = implode(',', $rolenames);
2925     }
2927     return $rolestring;
2930 /**
2931  * Checks if a user can assign users to a particular role in this context
2932  *
2933  * @param context $context
2934  * @param int $targetroleid - the id of the role you want to assign users to
2935  * @return boolean
2936  */
2937 function user_can_assign(context $context, $targetroleid) {
2938     global $DB;
2940     // first check if user has override capability
2941     // if not return false;
2942     if (!has_capability('moodle/role:assign', $context)) {
2943         return false;
2944     }
2945     // pull out all active roles of this user from this context(or above)
2946     if ($userroles = get_user_roles($context)) {
2947         foreach ($userroles as $userrole) {
2948             // if any in the role_allow_override table, then it's ok
2949             if ($DB->get_record('role_allow_assign', array('roleid'=>$userrole->roleid, 'allowassign'=>$targetroleid))) {
2950                 return true;
2951             }
2952         }
2953     }
2955     return false;
2958 /**
2959  * Returns all site roles in correct sort order.
2960  *
2961  * @return array
2962  */
2963 function get_all_roles() {
2964     global $DB;
2965     return $DB->get_records('role', null, 'sortorder ASC');
2968 /**
2969  * Returns roles of a specified archetype
2970  *
2971  * @param string $archetype
2972  * @return array of full role records
2973  */
2974 function get_archetype_roles($archetype) {
2975     global $DB;
2976     return $DB->get_records('role', array('archetype'=>$archetype), 'sortorder ASC');
2979 /**
2980  * Gets all the user roles assigned in this context, or higher contexts
2981  * this is mainly used when checking if a user can assign a role, or overriding a role
2982  * i.e. we need to know what this user holds, in order to verify against allow_assign and
2983  * allow_override tables
2984  *
2985  * @param context $context
2986  * @param int $userid
2987  * @param bool $checkparentcontexts defaults to true
2988  * @param string $order defaults to 'c.contextlevel DESC, r.sortorder ASC'
2989  * @return array
2990  */
2991 function get_user_roles(context $context, $userid = 0, $checkparentcontexts = true, $order = 'c.contextlevel DESC, r.sortorder ASC') {
2992     global $USER, $DB;
2994     if (empty($userid)) {
2995         if (empty($USER->id)) {
2996             return array();
2997         }
2998         $userid = $USER->id;
2999     }
3001     if ($checkparentcontexts) {
3002         $contextids = $context->get_parent_context_ids();
3003     } else {
3004         $contextids = array();
3005     }
3006     $contextids[] = $context->id;
3008     list($contextids, $params) = $DB->get_in_or_equal($contextids, SQL_PARAMS_QM);
3010     array_unshift($params, $userid);
3012     $sql = "SELECT ra.*, r.name, r.shortname
3013               FROM {role_assignments} ra, {role} r, {context} c
3014              WHERE ra.userid = ?
3015                    AND ra.roleid = r.id
3016                    AND ra.contextid = c.id
3017                    AND ra.contextid $contextids
3018           ORDER BY $order";
3020     return $DB->get_records_sql($sql ,$params);
3023 /**
3024  * Like get_user_roles, but adds in the authenticated user role, and the front
3025  * page roles, if applicable.
3026  *
3027  * @param context $context the context.
3028  * @param int $userid optional. Defaults to $USER->id
3029  * @return array of objects with fields ->userid, ->contextid and ->roleid.
3030  */
3031 function get_user_roles_with_special(context $context, $userid = 0) {
3032     global $CFG, $USER;
3034     if (empty($userid)) {
3035         if (empty($USER->id)) {
3036             return array();
3037         }
3038         $userid = $USER->id;
3039     }
3041     $ras = get_user_roles($context, $userid);
3043     // Add front-page role if relevant.
3044     $defaultfrontpageroleid = isset($CFG->defaultfrontpageroleid) ? $CFG->defaultfrontpageroleid : 0;
3045     $isfrontpage = ($context->contextlevel == CONTEXT_COURSE && $context->instanceid == SITEID) ||
3046             is_inside_frontpage($context);
3047     if ($defaultfrontpageroleid && $isfrontpage) {
3048         $frontpagecontext = context_course::instance(SITEID);
3049         $ra = new stdClass();
3050         $ra->userid = $userid;
3051         $ra->contextid = $frontpagecontext->id;
3052         $ra->roleid = $defaultfrontpageroleid;
3053         $ras[] = $ra;
3054     }
3056     // Add authenticated user role if relevant.
3057     $defaultuserroleid      = isset($CFG->defaultuserroleid) ? $CFG->defaultuserroleid : 0;
3058     if ($defaultuserroleid && !isguestuser($userid)) {
3059         $systemcontext = context_system::instance();
3060         $ra = new stdClass();
3061         $ra->userid = $userid;
3062         $ra->contextid = $systemcontext->id;
3063         $ra->roleid = $defaultuserroleid;
3064         $ras[] = $ra;
3065     }
3067     return $ras;
3070 /**
3071  * Creates a record in the role_allow_override table
3072  *
3073  * @param int $sroleid source roleid
3074  * @param int $troleid target roleid
3075  * @return void
3076  */
3077 function allow_override($sroleid, $troleid) {
3078     global $DB;
3080     $record = new stdClass();
3081     $record->roleid        = $sroleid;
3082     $record->allowoverride = $troleid;
3083     $DB->insert_record('role_allow_override', $record);
3086 /**
3087  * Creates a record in the role_allow_assign table
3088  *
3089  * @param int $fromroleid source roleid
3090  * @param int $targetroleid target roleid
3091  * @return void
3092  */
3093 function allow_assign($fromroleid, $targetroleid) {
3094     global $DB;
3096     $record = new stdClass();
3097     $record->roleid      = $fromroleid;
3098     $record->allowassign = $targetroleid;
3099     $DB->insert_record('role_allow_assign', $record);
3102 /**
3103  * Creates a record in the role_allow_switch table
3104  *
3105  * @param int $fromroleid source roleid
3106  * @param int $targetroleid target roleid
3107  * @return void
3108  */
3109 function allow_switch($fromroleid, $targetroleid) {
3110     global $DB;
3112     $record = new stdClass();
3113     $record->roleid      = $fromroleid;
3114     $record->allowswitch = $targetroleid;
3115     $DB->insert_record('role_allow_switch', $record);
3118 /**
3119  * Gets a list of roles that this user can assign in this context
3120  *
3121  * @param context $context the context.
3122  * @param int $rolenamedisplay the type of role name to display. One of the
3123  *      ROLENAME_X constants. Default ROLENAME_ALIAS.
3124  * @param bool $withusercounts if true, count the number of users with each role.
3125  * @param integer|object $user A user id or object. By default (null) checks the permissions of the current user.
3126  * @return array if $withusercounts is false, then an array $roleid => $rolename.
3127  *      if $withusercounts is true, returns a list of three arrays,
3128  *      $rolenames, $rolecounts, and $nameswithcounts.
3129  */
3130 function get_assignable_roles(context $context, $rolenamedisplay = ROLENAME_ALIAS, $withusercounts = false, $user = null) {
3131     global $USER, $DB;
3133     // make sure there is a real user specified
3134     if ($user === null) {
3135         $userid = isset($USER->id) ? $USER->id : 0;
3136     } else {
3137         $userid = is_object($user) ? $user->id : $user;
3138     }
3140     if (!has_capability('moodle/role:assign', $context, $userid)) {
3141         if ($withusercounts) {
3142             return array(array(), array(), array());
3143         } else {
3144             return array();
3145         }
3146     }
3148     $parents = $context->get_parent_context_ids(true);
3149     $contexts = implode(',' , $parents);
3151     $params = array();
3152     $extrafields = '';
3153     if ($rolenamedisplay == ROLENAME_ORIGINALANDSHORT or $rolenamedisplay == ROLENAME_SHORT) {
3154         $extrafields .= ', r.shortname';
3155     }
3157     if ($withusercounts) {
3158         $extrafields = ', (SELECT count(u.id)
3159                              FROM {role_assignments} cra JOIN {user} u ON cra.userid = u.id
3160                             WHERE cra.roleid = r.id AND cra.contextid = :conid AND u.deleted = 0
3161                           ) AS usercount';
3162         $params['conid'] = $context->id;
3163     }
3165     if (is_siteadmin($userid)) {
3166         // show all roles allowed in this context to admins
3167         $assignrestriction = "";
3168     } else {
3169         $assignrestriction = "JOIN (SELECT DISTINCT raa.allowassign AS id
3170                                       FROM {role_allow_assign} raa
3171                                       JOIN {role_assignments} ra ON ra.roleid = raa.roleid
3172                                      WHERE ra.userid = :userid AND ra.contextid IN ($contexts)
3173                                    ) ar ON ar.id = r.id";
3174         $params['userid'] = $userid;
3175     }
3176     $params['contextlevel'] = $context->contextlevel;
3177     $sql = "SELECT r.id, r.name $extrafields
3178               FROM {role} r
3179               $assignrestriction
3180               JOIN {role_context_levels} rcl ON r.id = rcl.roleid
3181              WHERE rcl.contextlevel = :contextlevel
3182           ORDER BY r.sortorder ASC";
3183     $roles = $DB->get_records_sql($sql, $params);
3185     $rolenames = array();
3186     foreach ($roles as $role) {
3187         if ($rolenamedisplay == ROLENAME_SHORT) {
3188             $rolenames[$role->id] = $role->shortname;
3189             continue;
3190         }
3191         $rolenames[$role->id] = $role->name;
3192         if ($rolenamedisplay == ROLENAME_ORIGINALANDSHORT) {
3193             $rolenames[$role->id] .= ' (' . $role->shortname . ')';
3194         }
3195     }
3196     if ($rolenamedisplay != ROLENAME_ORIGINALANDSHORT and $rolenamedisplay != ROLENAME_SHORT) {
3197         $rolenames = role_fix_names($rolenames, $context, $rolenamedisplay);
3198     }
3200     if (!$withusercounts) {
3201         return $rolenames;
3202     }
3204     $rolecounts = array();
3205     $nameswithcounts = array();
3206     foreach ($roles as $role) {
3207         $nameswithcounts[$role->id] = $rolenames[$role->id] . ' (' . $roles[$role->id]->usercount . ')';
3208         $rolecounts[$role->id] = $roles[$role->id]->usercount;
3209     }
3210     return array($rolenames, $rolecounts, $nameswithcounts);
3213 /**
3214  * Gets a list of roles that this user can switch to in a context
3215  *
3216  * Gets a list of roles that this user can switch to in a context, for the switchrole menu.
3217  * This function just process the contents of the role_allow_switch table. You also need to
3218  * test the moodle/role:switchroles to see if the user is allowed to switch in the first place.
3219  *
3220  * @param context $context a context.
3221  * @return array an array $roleid => $rolename.
3222  */
3223 function get_switchable_roles(context $context) {
3224     global $USER, $DB;
3226     $params = array();
3227     $extrajoins = '';
3228     $extrawhere = '';
3229     if (!is_siteadmin()) {
3230         // Admins are allowed to switch to any role with.
3231         // Others are subject to the additional constraint that the switch-to role must be allowed by
3232         // 'role_allow_switch' for some role they have assigned in this context or any parent.
3233         $parents = $context->get_parent_context_ids(true);
3234         $contexts = implode(',' , $parents);
3236         $extrajoins = "JOIN {role_allow_switch} ras ON ras.allowswitch = rc.roleid
3237         JOIN {role_assignments} ra ON ra.roleid = ras.roleid";
3238         $extrawhere = "WHERE ra.userid = :userid AND ra.contextid IN ($contexts)";
3239         $params['userid'] = $USER->id;
3240     }
3242     $query = "
3243         SELECT r.id, r.name
3244           FROM (SELECT DISTINCT rc.roleid
3245                   FROM {role_capabilities} rc
3246                   $extrajoins
3247                   $extrawhere) idlist
3248           JOIN {role} r ON r.id = idlist.roleid
3249       ORDER BY r.sortorder";
3251     $rolenames = $DB->get_records_sql_menu($query, $params);
3252     return role_fix_names($rolenames, $context, ROLENAME_ALIAS);
3255 /**
3256  * Gets a list of roles that this user can override in this context.
3257  *
3258  * @param context $context the context.
3259  * @param int $rolenamedisplay the type of role name to display. One of the
3260  *      ROLENAME_X constants. Default ROLENAME_ALIAS.
3261  * @param bool $withcounts if true, count the number of overrides that are set for each role.
3262  * @return array if $withcounts is false, then an array $roleid => $rolename.
3263  *      if $withusercounts is true, returns a list of three arrays,
3264  *      $rolenames, $rolecounts, and $nameswithcounts.
3265  */
3266 function get_overridable_roles(context $context, $rolenamedisplay = ROLENAME_ALIAS, $withcounts = false) {
3267     global $USER, $DB;
3269     if (!has_any_capability(array('moodle/role:safeoverride', 'moodle/role:override'), $context)) {
3270         if ($withcounts) {
3271             return array(array(), array(), array());
3272         } else {
3273             return array();
3274         }
3275     }
3277     $parents = $context->get_parent_context_ids(true);
3278     $contexts = implode(',' , $parents);
3280     $params = array();
3281     $extrafields = '';
3282     if ($rolenamedisplay == ROLENAME_ORIGINALANDSHORT) {
3283         $extrafields .= ', ro.shortname';
3284     }
3286     $params['userid'] = $USER->id;
3287     if ($withcounts) {
3288         $extrafields = ', (SELECT COUNT(rc.id) FROM {role_capabilities} rc
3289                 WHERE rc.roleid = ro.id AND rc.contextid = :conid) AS overridecount';
3290         $params['conid'] = $context->id;
3291     }
3293     if (is_siteadmin()) {
3294         // show all roles to admins
3295         $roles = $DB->get_records_sql("
3296             SELECT ro.id, ro.name$extrafields
3297               FROM {role} ro
3298           ORDER BY ro.sortorder ASC", $params);
3300     } else {
3301         $roles = $DB->get_records_sql("
3302             SELECT ro.id, ro.name$extrafields
3303               FROM {role} ro
3304               JOIN (SELECT DISTINCT r.id
3305                       FROM {role} r
3306                       JOIN {role_allow_override} rao ON r.id = rao.allowoverride
3307                       JOIN {role_assignments} ra ON rao.roleid = ra.roleid
3308                      WHERE ra.userid = :userid AND ra.contextid IN ($contexts)
3309                    ) inline_view ON ro.id = inline_view.id
3310           ORDER BY ro.sortorder ASC", $params);
3311     }
3313     $rolenames = array();
3314     foreach ($roles as $role) {
3315         $rolenames[$role->id] = $role->name;
3316         if ($rolenamedisplay == ROLENAME_ORIGINALANDSHORT) {
3317             $rolenames[$role->id] .= ' (' . $role->shortname . ')';
3318         }
3319     }
3320     if ($rolenamedisplay != ROLENAME_ORIGINALANDSHORT) {
3321         $rolenames = role_fix_names($rolenames, $context, $rolenamedisplay);
3322     }
3324     if (!$withcounts) {
3325         return $rolenames;
3328     $rolecounts = array();
3329     $nameswithcounts = array();
3330     foreach ($roles as $role) {
3331         $nameswithcounts[$role->id] = $rolenames[$role->id] . ' (' . $roles[$role->id]->overridecount . ')';
3332         $rolecounts[$role->id] = $roles[$role->id]->overridecount;
3333     }
3334     return array($rolenames, $rolecounts, $nameswithcounts);
3337 /**
3338  * Create a role menu suitable for default role selection in enrol plugins.
3339  *
3340  * @package    core_enrol
3341  *
3342  * @param context $context
3343  * @param int $addroleid current or default role - always added to list
3344  * @return array roleid=>localised role name
3345  */
3346 function get_default_enrol_roles(context $context, $addroleid = null) {
3347     global $DB;
3349     $params = array('contextlevel'=>CONTEXT_COURSE);
3350     if ($addroleid) {
3351         $addrole = "OR r.id = :addroleid";
3352         $params['addroleid'] = $addroleid;
3353     } else {
3354         $addrole = "";
3355     }
3356     $sql = "SELECT r.id, r.name
3357               FROM {role} r
3358          LEFT JOIN {role_context_levels} rcl ON (rcl.roleid = r.id AND rcl.contextlevel = :contextlevel)
3359              WHERE rcl.id IS NOT NULL $addrole
3360           ORDER BY sortorder DESC";
3362     $roles = $DB->get_records_sql_menu($sql, $params);
3363     $roles = role_fix_names($roles, $context, ROLENAME_BOTH);
3365     return $roles;
3368 /**
3369  * Return context levels where this role is assignable.
3370  *
3371  * @param integer $roleid the id of a role.
3372  * @return array list of the context levels at which this role may be assigned.
3373  */
3374 function get_role_contextlevels($roleid) {
3375     global $DB;
3376     return $DB->get_records_menu('role_context_levels', array('roleid' => $roleid),
3377             'contextlevel', 'id,contextlevel');
3380 /**
3381  * Return roles suitable for assignment at the specified context level.
3382  *
3383  * NOTE: this function name looks like a typo, should be probably get_roles_for_contextlevel()
3384  *
3385  * @param integer $contextlevel a contextlevel.
3386  * @return array list of role ids that are assignable at this context level.
3387  */
3388 function get_roles_for_contextlevels($contextlevel) {
3389     global $DB;
3390     return $DB->get_records_menu('role_context_levels', array('contextlevel' => $contextlevel),
3391             '', 'id,roleid');
3394 /**
3395  * Returns default context levels where roles can be assigned.
3396  *
3397  * @param string $rolearchetype one of the role archetypes - that is, one of the keys
3398  *      from the array returned by get_role_archetypes();
3399  * @return array list of the context levels at which this type of role may be assigned by default.
3400  */
3401 function get_default_contextlevels($rolearchetype) {
3402     static $defaults = array(
3403         'manager'        => array(CONTEXT_SYSTEM, CONTEXT_COURSECAT, CONTEXT_COURSE),
3404         'coursecreator'  => array(CONTEXT_SYSTEM, CONTEXT_COURSECAT),
3405         'editingteacher' => array(CONTEXT_COURSE, CONTEXT_MODULE),
3406         'teacher'        => array(CONTEXT_COURSE, CONTEXT_MODULE),
3407         'student'        => array(CONTEXT_COURSE, CONTEXT_MODULE),
3408         'guest'          => array(),
3409         'user'           => array(),
3410         'frontpage'      => array());
3412     if (isset($defaults[$rolearchetype])) {
3413         return $defaults[$rolearchetype];
3414     } else {
3415         return array();
3416     }
3419 /**
3420  * Set the context levels at which a particular role can be assigned.
3421  * Throws exceptions in case of error.
3422  *
3423  * @param integer $roleid the id of a role.
3424  * @param array $contextlevels the context levels at which this role should be assignable,
3425  *      duplicate levels are removed.
3426  * @return void
3427  */
3428 function set_role_contextlevels($roleid, array $contextlevels) {
3429     global $DB;
3430     $DB->delete_records('role_context_levels', array('roleid' => $roleid));
3431     $rcl = new stdClass();
3432     $rcl->roleid = $roleid;
3433     $contextlevels = array_unique($contextlevels);
3434     foreach ($contextlevels as $level) {
3435         $rcl->contextlevel = $level;
3436         $DB->insert_record('role_context_levels', $rcl, false, true);
3437     }
3440 /**
3441  * Who has this capability in this context?
3442  *
3443  * This can be a very expensive call - use sparingly and keep
3444  * the results if you are going to need them again soon.
3445  *
3446  * Note if $fields is empty this function attempts to get u.*
3447  * which can get rather large - and has a serious perf impact
3448  * on some DBs.
3449  *
3450  * @param context $context
3451  * @param string|array $capability - capability name(s)
3452  * @param string $fields - fields to be pulled. The user table is aliased to 'u'. u.id MUST be included.
3453  * @param string $sort - the sort order. Default is lastaccess time.
3454  * @param mixed $limitfrom - number of records to skip (offset)
3455  * @param mixed $limitnum - number of records to fetch
3456  * @param string|array $groups - single group or array of groups - only return
3457  *               users who are in one of these group(s).
3458  * @param string|array $exceptions - list of users to exclude, comma separated or array
3459  * @param bool $doanything_ignored not used any more, admin accounts are never returned
3460  * @param bool $view_ignored - use get_enrolled_sql() instead
3461  * @param bool $useviewallgroups if $groups is set the return users who
3462  *               have capability both $capability and moodle/site:accessallgroups
3463  *               in this context, as well as users who have $capability and who are
3464  *               in $groups.
3465  * @return array of user records
3466  */
3467 function get_users_by_capability(context $context, $capability, $fields = '', $sort = '', $limitfrom = '', $limitnum = '',
3468                                  $groups = '', $exceptions = '', $doanything_ignored = null, $view_ignored = null, $useviewallgroups = false) {
3469     global $CFG, $DB;
3471     $defaultuserroleid      = isset($CFG->defaultuserroleid) ? $CFG->defaultuserroleid : 0;
3472     $defaultfrontpageroleid = isset($CFG->defaultfrontpageroleid) ? $CFG->defaultfrontpageroleid : 0;
3474     $ctxids = trim($context->path, '/');
3475     $ctxids = str_replace('/', ',', $ctxids);
3477     // Context is the frontpage
3478     $iscoursepage = false; // coursepage other than fp
3479     $isfrontpage = false;
3480     if ($context->contextlevel == CONTEXT_COURSE) {
3481         if ($context->instanceid == SITEID) {
3482             $isfrontpage = true;
3483         } else {
3484             $iscoursepage = true;
3485         }
3486     }
3487     $isfrontpage = ($isfrontpage || is_inside_frontpage($context));
3489     $caps = (array)$capability;
3491     // construct list of context paths bottom-->top
3492     list($contextids, $paths) = get_context_info_list($context);
3494     // we need to find out all roles that have these capabilities either in definition or in overrides
3495     $defs = array();
3496     list($incontexts, $params) = $DB->get_in_or_equal($contextids, SQL_PARAMS_NAMED, 'con');
3497     list($incaps, $params2) = $DB->get_in_or_equal($caps, SQL_PARAMS_NAMED, 'cap');
3498     $params = array_merge($params, $params2);
3499     $sql = "SELECT rc.id, rc.roleid, rc.permission, rc.capability, ctx.path
3500               FROM {role_capabilities} rc
3501               JOIN {context} ctx on rc.contextid = ctx.id
3502              WHERE rc.contextid $incontexts AND rc.capability $incaps";
3504     $rcs = $DB->get_records_sql($sql, $params);
3505     foreach ($rcs as $rc) {
3506         $defs[$rc->capability][$rc->path][$rc->roleid] = $rc->permission;
3507     }
3509     // go through the permissions bottom-->top direction to evaluate the current permission,
3510     // first one wins (prohibit is an exception that always wins)
3511     $access = array();
3512     foreach ($caps as $cap) {
3513         foreach ($paths as $path) {
3514             if (empty($defs[$cap][$path])) {
3515                 continue;
3516             }
3517             foreach($defs[$cap][$path] as $roleid => $perm) {
3518                 if ($perm == CAP_PROHIBIT) {
3519                     $access[$cap][$roleid] = CAP_PROHIBIT;
3520                     continue;
3521                 }
3522                 if (!isset($access[$cap][$roleid])) {
3523                     $access[$cap][$roleid] = (int)$perm;
3524                 }
3525             }
3526         }
3527     }
3529     // make lists of roles that are needed and prohibited in this context
3530     $needed = array(); // one of these is enough
3531     $prohibited = array(); // must not have any of these
3532     foreach ($caps as $cap) {
3533         if (empty($access[$cap])) {
3534             continue;
3535         }
3536         foreach ($access[$cap] as $roleid => $perm) {
3537             if ($perm == CAP_PROHIBIT) {
3538                 unset($needed[$cap][$roleid]);
3539                 $prohibited[$cap][$roleid] = true;
3540             } else if ($perm == CAP_ALLOW and empty($prohibited[$cap][$roleid])) {
3541                 $needed[$cap][$roleid] = true;
3542             }
3543         }
3544         if (empty($needed[$cap]) or !empty($prohibited[$cap][$defaultuserroleid])) {
3545             // easy, nobody has the permission
3546             unset($needed[$cap]);
3547             unset($prohibited[$cap]);
3548         } else if ($isfrontpage and !empty($prohibited[$cap][$defaultfrontpageroleid])) {
3549             // everybody is disqualified on the frontpage
3550             unset($needed[$cap]);
3551             unset($prohibited[$cap]);
3552         }
3553         if (empty($prohibited[$cap])) {
3554             unset($prohibited[$cap]);
3555         }
3556     }
3558     if (empty($needed)) {
3559         // there can not be anybody if no roles match this request
3560         return array();
3561     }
3563     if (empty($prohibited)) {
3564         // we can compact the needed roles
3565         $n = array();
3566         foreach ($needed as $cap) {
3567             foreach ($cap as $roleid=>$unused) {
3568                 $n[$roleid] = true;
3569             }
3570         }
3571         $needed = array('any'=>$n);
3572         unset($n);
3573     }
3575     // ***** Set up default fields ******
3576     if (empty($fields)) {
3577         if ($iscoursepage) {
3578             $fields = 'u.*, ul.timeaccess AS lastaccess';
3579         } else {
3580             $fields = 'u.*';
3581         }
3582     } else {
3583         if (debugging('', DEBUG_DEVELOPER) && strpos($fields, 'u.*') === false && strpos($fields, 'u.id') === false) {
3584             debugging('u.id must be included in the list of fields passed to get_users_by_capability().', DEBUG_DEVELOPER);
3585         }
3586     }
3588     // Set up default sort
3589     if (empty($sort)) { // default to course lastaccess or just lastaccess
3590         if ($iscoursepage) {
3591             $sort = 'ul.timeaccess';
3592         } else {
3593             $sort = 'u.lastaccess';
3594         }
3595     }
3597     // Prepare query clauses
3598     $wherecond = array();
3599     $params    = array();
3600     $joins     = array();
3602     // User lastaccess JOIN
3603     if ((strpos($sort, 'ul.timeaccess') === false) and (strpos($fields, 'ul.timeaccess') === false)) {
3604          // user_lastaccess is not required MDL-13810
3605     } else {
3606         if ($iscoursepage) {
3607             $joins[] = "LEFT OUTER JOIN {user_lastaccess} ul ON (ul.userid = u.id AND ul.courseid = {$context->instanceid})";
3608         } else {
3609             throw new coding_exception('Invalid sort in get_users_by_capability(), ul.timeaccess allowed only for course contexts.');
3610         }
3611     }
3613     // We never return deleted users or guest account.
3614     $wherecond[] = "u.deleted = 0 AND u.id <> :guestid";
3615     $params['guestid'] = $CFG->siteguest;
3617     // Groups
3618     if ($groups) {
3619         $groups = (array)$groups;
3620         list($grouptest, $grpparams) = $DB->get_in_or_equal($groups, SQL_PARAMS_NAMED, 'grp');
3621         $grouptest = "u.id IN (SELECT userid FROM {groups_members} gm WHERE gm.groupid $grouptest)";
3622         $params = array_merge($params, $grpparams);
3624         if ($useviewallgroups) {
3625             $viewallgroupsusers = get_users_by_capability($context, 'moodle/site:accessallgroups', 'u.id, u.id', '', '', '', '', $exceptions);
3626             if (!empty($viewallgroupsusers)) {
3627                 $wherecond[] =  "($grouptest OR u.id IN (" . implode(',', array_keys($viewallgroupsusers)) . '))';
3628             } else {
3629                 $wherecond[] =  "($grouptest)";
3630             }
3631         } else {
3632             $wherecond[] =  "($grouptest)";
3633         }
3634     }
3636     // User exceptions
3637     if (!empty($exceptions)) {
3638         $exceptions = (array)$exceptions;
3639         list($exsql, $exparams) = $DB->get_in_or_equal($exceptions, SQL_PARAMS_NAMED, 'exc', false);
3640         $params = array_merge($params, $exparams);
3641         $wherecond[] = "u.id $exsql";
3642     }
3644     // now add the needed and prohibited roles conditions as joins
3645     if (!empty($needed['any'])) {
3646         // simple case - there are no prohibits involved
3647         if (!empty($needed['any'][$defaultuserroleid]) or ($isfrontpage and !empty($needed['any'][$defaultfrontpageroleid]))) {
3648             // everybody
3649         } else {
3650             $joins[] = "JOIN (SELECT DISTINCT userid
3651                                 FROM {role_assignments}
3652                                WHERE contextid IN ($ctxids)
3653                                      AND roleid IN (".implode(',', array_keys($needed['any'])) .")
3654                              ) ra ON ra.userid = u.id";
3655         }
3656     } else {
3657         $unions = array();
3658         $everybody = false;
3659         foreach ($needed as $cap=>$unused) {
3660             if (empty($prohibited[$cap])) {
3661                 if (!empty($needed[$cap][$defaultuserroleid]) or ($isfrontpage and !empty($needed[$cap][$defaultfrontpageroleid]))) {
3662                     $everybody = true;
3663                     break;
3664                 } else {
3665                     $unions[] = "SELECT userid
3666                                    FROM {role_assignments}
3667                                   WHERE contextid IN ($ctxids)
3668                                         AND roleid IN (".implode(',', array_keys($needed[$cap])) .")";
3669                 }
3670             } else {
3671                 if (!empty($prohibited[$cap][$defaultuserroleid]) or ($isfrontpage and !empty($prohibited[$cap][$defaultfrontpageroleid]))) {
3672                     // nobody can have this cap because it is prevented in default roles
3673                     continue;
3675                 } else if (!empty($needed[$cap][$defaultuserroleid]) or ($isfrontpage and !empty($needed[$cap][$defaultfrontpageroleid]))) {
3676                     // everybody except the prohibitted - hiding does not matter
3677                     $unions[] = "SELECT id AS userid
3678                                    FROM {user}
3679                                   WHERE id NOT IN (SELECT userid
3680                                                      FROM {role_assignments}
3681                                                     WHERE contextid IN ($ctxids)
3682                                                           AND roleid IN (".implode(',', array_keys($prohibited[$cap])) ."))";
3684                 } else {
3685                     $unions[] = "SELECT userid
3686                                    FROM {role_assignments}
3687                                   WHERE contextid IN ($ctxids)
3688                                         AND roleid IN (".implode(',', array_keys($needed[$cap])) .")
3689                                         AND roleid NOT IN (".implode(',', array_keys($prohibited[$cap])) .")";
3690                 }
3691             }
3692         }
3693         if (!$everybody) {
3694             if ($unions) {
3695                 $joins[] = "JOIN (SELECT DISTINCT userid FROM ( ".implode(' UNION ', $unions)." ) us) ra ON ra.userid = u.id";
3696             } else {
3697                 // only prohibits found - nobody can be matched
3698                 $wherecond[] = "1 = 2";
3699             }
3700         }
3701     }
3703     // Collect WHERE conditions and needed joins
3704     $where = implode(' AND ', $wherecond);
3705     if ($where !== '') {
3706         $where = 'WHERE ' . $where;
3707     }
3708     $joins = implode("\n", $joins);
3710     // Ok, let's get the users!
3711     $sql = "SELECT $fields
3712               FROM {user} u
3713             $joins
3714             $where
3715           ORDER BY $sort";
3717     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
3720 /**
3721  * Re-sort a users array based on a sorting policy
3722  *
3723  * Will re-sort a $users results array (from get_users_by_capability(), usually)
3724  * based on a sorting policy. This is to support the odd practice of
3725  * sorting teachers by 'authority', where authority was "lowest id of the role
3726  * assignment".
3727  *
3728  * Will execute 1 database query. Only suitable for small numbers of users, as it
3729  * uses an u.id IN() clause.
3730  *
3731  * Notes about the sorting criteria.
3732  *
3733  * As a default, we cannot rely on role.sortorder because then
3734  * admins/coursecreators will always win. That is why the sane
3735  * rule "is locality matters most", with sortorder as 2nd
3736  * consideration.
3737  *
3738  * If you want role.sortorder, use the 'sortorder' policy, and
3739  * name explicitly what roles you want to cover. It's probably
3740  * a good idea to see what roles have the capabilities you want
3741  * (array_diff() them against roiles that have 'can-do-anything'
3742  * to weed out admin-ish roles. Or fetch a list of roles from
3743  * variables like $CFG->coursecontact .
3744  *
3745  * @param array $users Users array, keyed on userid
3746  * @param context $context
3747  * @param array $roles ids of the roles to include, optional
3748  * @param string $sortpolicy defaults to locality, more about
3749  * @return array sorted copy of the array
3750  */
3751 function sort_by_roleassignment_authority($users, context $context, $roles = array(), $sortpolicy = 'locality') {
3752     global $DB;
3754     $userswhere = ' ra.userid IN (' . implode(',',array_keys($users)) . ')';
3755     $contextwhere = 'AND ra.contextid IN ('.str_replace('/', ',',substr($context->path, 1)).')';
3756     if (empty($roles)) {
3757         $roleswhere = '';
3758     } else {
3759         $roleswhere = ' AND ra.roleid IN ('.implode(',',$roles).')';
3760     }
3762     $sql = "SELECT ra.userid
3763               FROM {role_assignments} ra
3764               JOIN {role} r
3765                    ON ra.roleid=r.id
3766               JOIN {context} ctx
3767                    ON ra.contextid=ctx.id
3768              WHERE $userswhere
3769                    $contextwhere
3770                    $roleswhere";
3772     // Default 'locality' policy -- read PHPDoc notes
3773     // about sort policies...
3774     $orderby = 'ORDER BY '
3775                     .'ctx.depth DESC, '  /* locality wins */
3776                     .'r.sortorder ASC, ' /* rolesorting 2nd criteria */
3777                     .'ra.id';            /* role assignment order tie-breaker */
3778     if ($sortpolicy === 'sortorder') {
3779         $orderby = 'ORDER BY '
3780                         .'r.sortorder ASC, ' /* rolesorting 2nd criteria */
3781                         .'ra.id';            /* role assignment order tie-breaker */
3782     }
3784     $sortedids = $DB->get_fieldset_sql($sql . $orderby);
3785     $sortedusers = array();
3786     $seen = array();
3788     foreach ($sortedids as $id) {
3789         // Avoid duplicates
3790         if (isset($seen[$id])) {
3791             continue;
3792         }
3793         $seen[$id] = true;
3795         // assign
3796         $sortedusers[$id] = $users[$id];
3797     }
3798     return $sortedusers;
3801 /**
3802  * Gets all the users assigned this role in this context or higher
3803  *
3804  * @param int $roleid (can also be an array of ints!)
3805  * @param context $context
3806  * @param bool $parent if true, get list of users assigned in higher context too
3807  * @param string $fields fields from user (u.) , role assignment (ra) or role (r.)
3808  * @param string $sort sort from user (u.) , role assignment (ra) or role (r.)
3809  * @param bool $gethidden_ignored use enrolments instead
3810  * @param string $group defaults to ''
3811  * @param mixed $limitfrom defaults to ''
3812  * @param mixed $limitnum defaults to ''
3813  * @param string $extrawheretest defaults to ''
3814  * @param string|array $whereparams defaults to ''
3815  * @return array
3816  */
3817 function get_role_users($roleid, context $context, $parent = false, $fields = '',
3818         $sort = 'u.lastname, u.firstname', $gethidden_ignored = null, $group = '',
3819         $limitfrom = '', $limitnum = '', $extrawheretest = '', $whereparams = array()) {
3820     global $DB;
3822     if (empty($fields)) {
3823         $fields = 'u.id, u.confirmed, u.username, u.firstname, u.lastname, '.
3824                   'u.maildisplay, u.mailformat, u.maildigest, u.email, u.emailstop, u.city, '.
3825                   'u.country, u.picture, u.idnumber, u.department, u.institution, '.
3826                   'u.lang, u.timezone, u.lastaccess, u.mnethostid, r.name AS rolename, r.sortorder';
3827     }
3829     $parentcontexts = '';
3830     if ($parent) {
3831         $parentcontexts = substr($context->path, 1); // kill leading slash
3832         $parentcontexts = str_replace('/', ',', $parentcontexts);
3833         if ($parentcontexts !== '') {
3834             $parentcontexts = ' OR ra.contextid IN ('.$parentcontexts.' )';
3835         }
3836     }
3838     if ($roleid) {
3839         list($rids, $params) = $DB->get_in_or_equal($roleid, SQL_PARAMS_QM);
3840         $roleselect = "AND ra.roleid $rids";
3841     } else {
3842         $params = array();
3843         $roleselect = '';
3844     }
3846     if ($group) {
3847         $groupjoin   = "JOIN {groups_members} gm ON gm.userid = u.id";
3848         $groupselect = " AND gm.groupid = ? ";
3849         $params[] = $group;
3850     } else {
3851         $groupjoin   = '';
3852         $groupselect = '';
3853     }
3855     array_unshift($params, $context->id);
3857     if ($extrawheretest) {
3858         $extrawheretest = ' AND ' . $extrawheretest;
3859         $params = array_merge($params, $whereparams);
3860     }
3862     $sql = "SELECT DISTINCT $fields, ra.roleid
3863               FROM {role_assignments} ra
3864               JOIN {user} u ON u.id = ra.userid
3865               JOIN {role} r ON ra.roleid = r.id
3866         $groupjoin
3867              WHERE (ra.contextid = ? $parentcontexts)
3868                    $roleselect
3869                    $groupselect
3870                    $extrawheretest
3871           ORDER BY $sort";                  // join now so that we can just use fullname() later
3873     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
3876 /**
3877  * Counts all the users assigned this role in this context or higher
3878  *
3879  * @param int|array $roleid either int or an array of ints
3880  * @param context $context
3881  * @param bool $parent if true, get list of users assigned in higher context too
3882  * @return int Returns the result count
3883  */
3884 function count_role_users($roleid, context $context, $parent = false) {
3885     global $DB;
3887     if ($parent) {
3888         if ($contexts = $context->get_parent_context_ids()) {
3889             $parentcontexts = ' OR r.contextid IN ('.implode(',', $contexts).')';
3890         } else {
3891             $parentcontexts = '';
3892         }
3893     } else {
3894         $parentcontexts = '';
3895     }
3897     if ($roleid) {
3898         list($rids, $params) = $DB->get_in_or_equal($roleid, SQL_PARAMS_QM);
3899         $roleselect = "AND r.roleid $rids";
3900     } else {
3901         $params = array();
3902         $roleselect = '';
3903     }
3905     array_unshift($params, $context->id);
3907     $sql = "SELECT COUNT(u.id)
3908               FROM {role_assignments} r
3909               JOIN {user} u ON u.id = r.userid
3910              WHERE (r.contextid = ? $parentcontexts)
3911                    $roleselect
3912                    AND u.deleted = 0";
3914     return $DB->count_records_sql($sql, $params);
3917 /**
3918  * This function gets the list of courses that this user has a particular capability in.
3919  * It is still not very efficient.
3920  *
3921  * @param string $capability Capability in question
3922  * @param int $userid User ID or null for current user
3923  * @param bool $doanything True if 'doanything' is permitted (default)
3924  * @param string $fieldsexceptid Leave blank if you only need 'id' in the course records;
3925  *   otherwise use a comma-separated list of the fields you require, not including id
3926  * @param string $orderby If set, use a comma-separated list of fields from course
3927  *   table with sql modifiers (DESC) if needed
3928  * @return array Array of courses, may have zero entries. Or false if query failed.
3929  */
3930 function get_user_capability_course($capability, $userid = null, $doanything = true, $fieldsexceptid = '', $orderby = '') {
3931     global $DB;
3933     // Convert fields list and ordering
3934     $fieldlist = '';
3935     if ($fieldsexceptid) {
3936         $fields = explode(',', $fieldsexceptid);
3937         foreach($fields as $field) {
3938             $fieldlist .= ',c.'.$field;
3939         }
3940     }
3941     if ($orderby) {
3942         $fields = explode(',', $orderby);
3943         $orderby = '';
3944         foreach($fields as $field) {
3945             if ($orderby) {
3946                 $orderby .= ',';
3947             }
3948             $orderby .= 'c.'.$field;
3949         }
3950         $orderby = 'ORDER BY '.$orderby;
3951     }
3953     // Obtain a list of everything relevant about all courses including context.
3954     // Note the result can be used directly as a context (we are going to), the course
3955     // fields are just appended.
3957     $contextpreload = context_helper::get_preload_record_columns_sql('x');
3959     $courses = array();
3960     $rs = $DB->get_recordset_sql("SELECT c.id $fieldlist, $contextpreload
3961                                     FROM {course} c
3962                                     JOIN {context} x ON (c.id=x.instanceid AND x.contextlevel=".CONTEXT_COURSE.")
3963                                 $orderby");
3964     // Check capability for each course in turn
3965     foreach ($rs as $course) {
3966         context_helper::preload_from_record($course);
3967         $context = context_course::instance($course->id);
3968         if (has_capability($capability, $context, $userid, $doanything)) {
3969             // We've got the capability. Make the record look like a course record
3970             // and store it
3971             $courses[] = $course;
3972         }
3973     }
3974     $rs->close();
3975     return empty($courses) ? false : $courses;
3978 /**
3979  * This function finds the roles assigned directly to this context only
3980  * i.e. no roles in parent contexts
3981  *
3982  * @param context $context
3983  * @return array
3984  */
3985 function get_roles_on_exact_context(context $context) {
3986     global $DB;
3988     return $DB->get_records_sql("SELECT r.*
3989                                    FROM {role_assignments} ra, {role} r
3990                                   WHERE ra.roleid = r.id AND ra.contextid = ?",
3991                                 array($context->id));
3994 /**
3995  * Switches the current user to another role for the current session and only
3996  * in the given context.
3997  *
3998  * The caller *must* check
3999  * - that this op is allowed
4000  * - that the requested role can be switched to in this context (use get_switchable_roles)
4001  * - that the requested role is NOT $CFG->defaultuserroleid
4002  *
4003  * To "unswitch" pass 0 as the roleid.
4004  *
4005  * This function *will* modify $USER->access - beware
4006  *
4007  * @param integer $roleid the role to switch to.
4008  * @param context $context the context in which to perform the switch.
4009  * @return bool success or failure.
4010  */
4011 function role_switch($roleid, context $context) {
4012     global $USER;
4014     //
4015     // Plan of action
4016     //
4017     // - Add the ghost RA to $USER->access
4018     //   as $USER->access['rsw'][$path] = $roleid
4019     //
4020     // - Make sure $USER->access['rdef'] has the roledefs
4021     //   it needs to honour the switcherole
4022     //
4023     // Roledefs will get loaded "deep" here - down to the last child
4024     // context. Note that
4025     //
4026     // - When visiting subcontexts, our selective accessdata loading
4027     //   will still work fine - though those ra/rdefs will be ignored
4028     //   appropriately while the switch is in place
4029     //
4030     // - If a switcherole happens at a category with tons of courses
4031     //   (that have many overrides for switched-to role), the session
4032     //   will get... quite large. Sometimes you just can't win.
4033     //
4034     // To un-switch just unset($USER->access['rsw'][$path])
4035     //
4036     // Note: it is not possible to switch to roles that do not have course:view
4038     if (!isset($USER->access)) {
4039         load_all_capabilities();
4040     }
4043     // Add the switch RA
4044     if ($roleid == 0) {
4045         unset($USER->access['rsw'][$context->path]);
4046         return true;
4047     }
4049     $USER->access['rsw'][$context->path] = $roleid;
4051     // Load roledefs
4052     load_role_access_by_context($roleid, $context, $USER->access);
4054     return true;
4057 /**
4058  * Checks if the user has switched roles within the given course.
4059  *
4060  * Note: You can only switch roles within the course, hence it takes a course id
4061  * rather than a context. On that note Petr volunteered to implement this across
4062  * all other contexts, all requests for this should be forwarded to him ;)
4063  *
4064  * @param int $courseid The id of the course to check
4065  * @return bool True if the user has switched roles within the course.
4066  */
4067 function is_role_switched($courseid) {
4068     global $USER;
4069     $context = context_course::instance($courseid, MUST_EXIST);
4070     return (!empty($USER->access['rsw'][$context->path]));
4073 /**
4074  * Get any role that has an override on exact context
4075  *
4076  * @param context $context The context to check
4077  * @return array An array of roles
4078  */
4079 function get_roles_with_override_on_context(context $context) {
4080     global $DB;
4082     return $DB->get_records_sql("SELECT r.*
4083                                    FROM {role_capabilities} rc, {role} r
4084                                   WHERE rc.roleid = r.id AND rc.contextid = ?",
4085                                 array($context->id));
4088 /**
4089  * Get all capabilities for this role on this context (overrides)
4090  *
4091  * @param stdClass $role
4092  * @param context $context
4093  * @return array
4094  */
4095 function get_capabilities_from_role_on_context($role, context $context) {
4096     global $DB;
4098     return $DB->get_records_sql("SELECT *
4099                                    FROM {role_capabilities}
4100                                   WHERE contextid = ? AND roleid = ?",
4101                                 array($context->id, $role->id));
4104 /**
4105  * Find out which roles has assignment on this context
4106  *
4107  * @param context $context
4108  * @return array
4109  *
4110  */
4111 function get_roles_with_assignment_on_context(context $context) {
4112     global $DB;
4114     return $DB->get_records_sql("SELECT r.*
4115                                    FROM {role_assignments} ra, {role} r
4116                                   WHERE ra.roleid = r.id AND ra.contextid = ?",
4117                                 array($context->id));
4120 /**
4121  * Find all user assignment of users for this role, on this context
4122  *
4123  * @param stdClass $role
4124  * @param context $context
4125  * @return array
4126  */
4127 function get_users_from_role_on_context($role, context $context) {
4128     global $DB;
4130     return $DB->get_records_sql("SELECT *
4131                                    FROM {role_assignments}
4132                                   WHERE contextid = ? AND roleid = ?",
4133                                 array($context->id, $role->id));
4136 /**
4137  * Simple function returning a boolean true if user has roles
4138  * in context or parent contexts, otherwise false.
4139  *
4140  * @param int $userid
4141  * @param int $roleid
4142  * @param int $contextid empty means any context
4143  * @return bool
4144  */
4145 function user_has_role_assignment($userid, $roleid, $contextid = 0) {
4146     global $DB;
4148     if ($contextid) {
4149         if (!$context = context::instance_by_id($contextid, IGNORE_MISSING)) {
4150             return false;
4151         }
4152         $parents = $context->get_parent_context_ids(true);
4153         list($contexts, $params) = $DB->get_in_or_equal($parents, SQL_PARAMS_NAMED, 'r');
4154         $params['userid'] = $userid;
4155         $params['roleid'] = $roleid;
4157         $sql = "SELECT COUNT(ra.id)
4158                   FROM {role_assignments} ra
4159                  WHERE ra.userid = :userid AND ra.roleid = :roleid AND ra.contextid $contexts";
4161         $count = $DB->get_field_sql($sql, $params);
4162         return ($count > 0);
4164     } else {
4165         return $DB->record_exists('role_assignments', array('userid'=>$userid, 'roleid'=>$roleid));
4166     }
4169 /**
4170  * Get role name or alias if exists and format the text.
4171  *
4172  * @param stdClass $role role object
4173  * @param context_course $coursecontext
4174  * @return string name of role in course context
4175  */
4176 function role_get_name($role, context_course $coursecontext) {
4177     global $DB;
4179     if ($r = $DB->get_record('role_names', array('roleid'=>$role->id, 'contextid'=>$coursecontext->id))) {
4180         return strip_tags(format_string($r->name));
4181     } else {
4182         return strip_tags(format_string($role->name));
4183     }
4186 /**
4187  * Get all the localised role names for a context.
4188  * @param context $context the context
4189  * @param array of role objects with a ->localname field containing the context-specific role name.
4190  */
4191 function role_get_names(context $context) {
4192     return role_fix_names(get_all_roles(), $context);
4195 /**
4196  * Prepare list of roles for display, apply aliases and format text
4197  *
4198  * @param array $roleoptions array roleid => rolename or roleid => roleobject
4199  * @param context $context a context
4200  * @param int $rolenamedisplay
4201  * @return array Array of context-specific role names, or role objects with a ->localname field added.
4202  */
4203 function role_fix_names($roleoptions, context $context, $rolenamedisplay = ROLENAME_ALIAS) {
4204     global $DB;
4206     // Make sure we have a course context.
4207     $coursecontext = $context->get_course_context(false);
4209     // Make sure we are working with an array roleid => name. Normally we
4210     // want to use the unlocalised name if the localised one is not present.
4211     $newnames = array();
4212     foreach ($roleoptions as $rid => $roleorname) {
4213         if ($rolenamedisplay != ROLENAME_ALIAS_RAW) {
4214             if (is_object($roleorname)) {
4215                 $newnames[$rid] = $roleorname->name;
4216             } else {
4217                 $newnames[$rid] = $roleorname;
4218             }
4219         } else {
4220             $newnames[$rid] = '';
4221         }
4222     }
4224     // If necessary, get the localised names.
4225     if ($rolenamedisplay != ROLENAME_ORIGINAL && !empty($coursecontext->id)) {
4226         // The get the relevant renames, and use them.
4227         $aliasnames = $DB->get_records('role_names', array('contextid'=>$coursecontext->id));
4228         foreach ($aliasnames as $alias) {
4229             if (isset($newnames[$alias->roleid])) {
4230                 if ($rolenamedisplay == ROLENAME_ALIAS || $rolenamedisplay == ROLENAME_ALIAS_RAW) {
4231                     $newnames[$alias->roleid] = $alias->name;
4232                 } else if ($rolenamedisplay == ROLENAME_BOTH) {
4233                     $newnames[$alias->roleid] = $alias->name . ' (' . $roleoptions[$alias->roleid] . ')';
4234                 }
4235             }
4236         }
4237     }
4239     // Finally, apply format_string and put the result in the right place.
4240     foreach ($roleoptions as $rid => $roleorname) {
4241         if ($rolenamedisplay != ROLENAME_ALIAS_RAW) {
4242             $newnames[$rid] = strip_tags(format_string($newnames[$rid]));
4243         }
4244         if (is_object($roleorname)) {
4245             $roleoptions[$rid]->localname = $newnames[$rid];
4246         } else {
4247             $roleoptions[$rid] = $newnames[$rid];
4248         }
4249     }
4250     return $roleoptions;
4253 /**
4254  * Aids in detecting if a new line is required when reading a new capability
4255  *
4256  * This function helps admin/roles/manage.php etc to detect if a new line should be printed
4257  * when we read in a new capability.
4258  * Most of the time, if the 2 components are different we should print a new line, (e.g. course system->rss client)
4259  * but when we are in grade, all reports/import/export capabilities should be together
4260  *
4261  * @param string $cap component string a
4262  * @param string $comp component string b
4263  * @param int $contextlevel
4264  * @return bool whether 2 component are in different "sections"
4265  */
4266 function component_level_changed($cap, $comp, $contextlevel) {
4268     if (strstr($cap->component, '/') && strstr($comp, '/')) {
4269         $compsa = explode('/', $cap->component);
4270         $compsb = explode('/', $comp);
4272         // list of system reports
4273         if (($compsa[0] == 'report') && ($compsb[0] == 'report')) {
4274             return false;
4275         }
4277         // we are in gradebook, still
4278         if (($compsa[0] == 'gradeexport' || $compsa[0] == 'gradeimport' || $compsa[0] == 'gradereport') &&
4279             ($compsb[0] == 'gradeexport' || $compsb[0] == 'gradeimport' || $compsb[0] == 'gradereport')) {
4280             return false;
4281         }
4283         if (($compsa[0] == 'coursereport') && ($compsb[0] == 'coursereport')) {
4284             return false;
4285         }
4286     }
4288     return ($cap->component != $comp || $cap->contextlevel != $contextlevel);
4291 /**
4292  * Fix the roles.sortorder field in the database, so it contains sequential integers,
4293  * and return an array of roleids in order.
4294  *
4295  * @param array $allroles array of roles, as returned by get_all_roles();
4296  * @return array $role->sortorder =-> $role->id with the keys in ascending order.
4297  */
4298 function fix_role_sortorder($allroles) {
4299     global $DB;
4301     $rolesort = array();
4302     $i = 0;
4303     foreach ($allroles as $role) {
4304         $rolesort[$i] = $role->id;
4305         if ($role->sortorder != $i) {
4306             $r = new stdClass();
4307             $r->id = $role->id;
4308             $r->sortorder = $i;
4309             $DB->update_record('role', $r);
4310             $allroles[$role->id]->sortorder = $i;
4311         }
4312         $i++;
4313     }
4314     return $rolesort;
4317 /**
4318  * Switch the sort order of two roles (used in admin/roles/manage.php).
4319  *
4320  * @param stdClass $first The first role. Actually, only ->sortorder is used.
4321  * @param stdClass $second The second role. Actually, only ->sortorder is used.
4322  * @return boolean success or failure
4323  */
4324 function switch_roles($first, $second) {
4325     global $DB;
4326     $temp = $DB->get_field('role', 'MAX(sortorder) + 1', array());
4327     $result = $DB->set_field('role', 'sortorder', $temp, array('sortorder' => $first->sortorder));
4328     $result = $result && $DB->set_field('role', 'sortorder', $first->sortorder, array('sortorder' => $second->sortorder));