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