Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

6243 lines (5319 sloc) 194.646 kb
<?php // $Id$
///////////////////////////////////////////////////////////////////////////
// //
// NOTICE OF COPYRIGHT //
// //
// Moodle - Modular Object-Oriented Dynamic Learning Environment //
// http://moodle.org //
// //
// Copyright (C) 1999-2004 Martin Dougiamas http://dougiamas.com //
// //
// This program is free software; you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation; either version 2 of the License, or //
// (at your option) any later version. //
// //
// This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details: //
// //
// http://www.gnu.org/copyleft/gpl.html //
// //
///////////////////////////////////////////////////////////////////////////
/**
* moodlelib.php - Moodle main library
*
* Main library file of miscellaneous general-purpose Moodle functions.
* Other main libraries:
* - weblib.php - functions that produce web output
* - datalib.php - functions that access the database
* @author Martin Dougiamas
* @version $Id$
* @license http://www.gnu.org/copyleft/gpl.html GNU Public License
* @package moodlecore
*/
/// CONSTANTS /////////////////////////////////////////////////////////////
/**
* Used by some scripts to check they are being called by Moodle
*/
define('MOODLE_INTERNAL', true);
/**
* No groups used?
*/
define('NOGROUPS', 0);
/**
* Groups used?
*/
define('SEPARATEGROUPS', 1);
/**
* Groups visible?
*/
define('VISIBLEGROUPS', 2);
/**
* Time constant - the number of seconds in a week
*/
define('WEEKSECS', 604800);
/**
* Time constant - the number of seconds in a day
*/
define('DAYSECS', 86400);
/**
* Time constant - the number of seconds in an hour
*/
define('HOURSECS', 3600);
/**
* Time constant - the number of seconds in a minute
*/
define('MINSECS', 60);
/**
* Time constant - the number of minutes in a day
*/
define('DAYMINS', 1440);
/**
* Time constant - the number of minutes in an hour
*/
define('HOURMINS', 60);
/**
* Parameter constants - if set then the parameter is cleaned of scripts etc
*/
define('PARAM_RAW', 0x0000);
define('PARAM_CLEAN', 0x0001);
define('PARAM_INT', 0x0002);
define('PARAM_INTEGER', 0x0002); // Alias for PARAM_INT
define('PARAM_ALPHA', 0x0004);
define('PARAM_ACTION', 0x0004); // Alias for PARAM_ALPHA
define('PARAM_FORMAT', 0x0004); // Alias for PARAM_ALPHA
define('PARAM_NOTAGS', 0x0008);
define('PARAM_FILE', 0x0010);
define('PARAM_PATH', 0x0020);
define('PARAM_HOST', 0x0040); // FQDN or IPv4 dotted quad
define('PARAM_URL', 0x0080);
define('PARAM_LOCALURL', 0x0180); // NOT orthogonal to the others! Implies PARAM_URL!
define('PARAM_CLEANFILE',0x0200);
define('PARAM_ALPHANUM', 0x0400); //numbers or letters only
define('PARAM_BOOL', 0x0800); //convert to value 1 or 0 using empty()
define('PARAM_CLEANHTML',0x1000); //actual HTML code that you want cleaned and slashes removed
define('PARAM_ALPHAEXT', 0x2000); // PARAM_ALPHA plus the chars in quotes: "/-_" allowed
/**
* Definition of page types
*/
define('PAGE_COURSE_VIEW', 'course-view');
/// PARAMETER HANDLING ////////////////////////////////////////////////////
/**
* Returns a particular value for the named variable, taken from
* POST or GET. If the parameter doesn't exist then an error is
* thrown because we require this variable.
*
* This function should be used to initialise all required values
* in a script that are based on parameters. Usually it will be
* used like this:
* $id = required_param('id');
*
* @param string $varname the name of the parameter variable we want
* @param integer $options a bit field that specifies any cleaning needed
* @return mixed
*/
function required_param($varname, $options=PARAM_CLEAN) {
if (isset($_POST[$varname])) { // POST has precedence
$param = $_POST[$varname];
} else if (isset($_GET[$varname])) {
$param = $_GET[$varname];
} else {
error('A required parameter ('.$varname.') was missing');
}
return clean_param($param, $options);
}
/**
* Returns a particular value for the named variable, taken from
* POST or GET, otherwise returning a given default.
*
* This function should be used to initialise all optional values
* in a script that are based on parameters. Usually it will be
* used like this:
* $name = optional_param('name', 'Fred');
*
* @param string $varname the name of the parameter variable we want
* @param mixed $default the default value to return if nothing is found
* @param integer $options a bit field that specifies any cleaning needed
* @return mixed
*/
function optional_param($varname, $default=NULL, $options=PARAM_CLEAN) {
if (isset($_POST[$varname])) { // POST has precedence
$param = $_POST[$varname];
} else if (isset($_GET[$varname])) {
$param = $_GET[$varname];
} else {
return $default;
}
return clean_param($param, $options);
}
/**
* Used by {@link optional_param()} and {@link required_param()} to
* clean the variables and/or cast to specific types, based on
* an options field.
*
* @param mixed $param the variable we are cleaning
* @param integer $options a bit field that specifies the cleaning needed
* @return mixed
*/
function clean_param($param, $options) {
global $CFG;
if (!$options) {
return $param; // Return raw value
}
if ((string)$param == (string)(int)$param) { // It's just an integer
return (int)$param;
}
if ($options & PARAM_CLEAN) {
$param = stripslashes($param); // Needed by kses to work fine
$param = clean_text($param); // Sweep for scripts, etc
$param = addslashes($param); // Restore original request parameter slashes
}
if ($options & PARAM_INT) {
$param = (int)$param; // Convert to integer
}
if ($options & PARAM_ALPHA) { // Remove everything not a-z
$param = eregi_replace('[^a-zA-Z]', '', $param);
}
if ($options & PARAM_ALPHANUM) { // Remove everything not a-zA-Z0-9
$param = eregi_replace('[^A-Za-z0-9]', '', $param);
}
if ($options & PARAM_ALPHAEXT) { // Remove everything not a-zA-Z/_-
$param = eregi_replace('[^a-zA-Z/_-]', '', $param);
}
if ($options & PARAM_BOOL) { // Convert to 1 or 0
$param = empty($param) ? 0 : 1;
}
if ($options & PARAM_NOTAGS) { // Strip all tags completely
$param = strip_tags($param);
}
if ($options & PARAM_CLEANFILE) { // allow only safe characters
$param = clean_filename($param);
}
if ($options & PARAM_FILE) { // Strip all suspicious characters from filename
$param = ereg_replace('[[:cntrl:]]|[<>"`\|\':\\/]', '', $param);
$param = ereg_replace('\.\.+', '', $param);
if($param == '.') {
$param = '';
}
}
if ($options & PARAM_PATH) { // Strip all suspicious characters from file path
$param = str_replace('\\\'', '\'', $param);
$param = str_replace('\\"', '"', $param);
$param = str_replace('\\', '/', $param);
$param = ereg_replace('[[:cntrl:]]|[<>"`\|\':]', '', $param);
$param = ereg_replace('\.\.+', '', $param);
$param = ereg_replace('//+', '/', $param);
$param = ereg_replace('/(\./)+', '/', $param);
}
if ($options & PARAM_HOST) { // allow FQDN or IPv4 dotted quad
preg_replace('/[^\.\d\w-]/','', $param ); // only allowed chars
// match ipv4 dotted quad
if (preg_match('/(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/',$param, $match)){
// confirm values are ok
if ( $match[0] > 255
|| $match[1] > 255
|| $match[3] > 255
|| $match[4] > 255 ) {
// hmmm, what kind of dotted quad is this?
$param = '';
}
} elseif ( preg_match('/^[\w\d\.-]+$/', $param) // dots, hyphens, numbers
&& !preg_match('/^[\.-]/', $param) // no leading dots/hyphens
&& !preg_match('/[\.-]$/', $param) // no trailing dots/hyphens
) {
// all is ok - $param is respected
} else {
// all is not ok...
$param='';
}
}
if ($options & PARAM_URL) { // allow safe ftp, http, mailto urls
include_once($CFG->dirroot . '/lib/validateurlsyntax.php');
//
// Parameters to validateurlsyntax()
//
// s? scheme is optional
// H? http optional
// S? https optional
// F? ftp optional
// E? mailto optional
// u- user section not allowed
// P- password not allowed
// a? address optional
// I? Numeric IP address optional (can use IP or domain)
// p- port not allowed -- restrict to default port
// f? "file" path section optional
// q? query section optional
// r? fragment (anchor) optional
//
if (!empty($param) && validateUrlSyntax($param, 's?H?S?F?E?u-P-a?I?p-f?q?r?')) {
// all is ok, param is respected
} else {
$param =''; // not really ok
}
$options ^= PARAM_URL; // Turn off the URL bit so that simple PARAM_URLs don't test true for PARAM_LOCALURL
}
if ($options & PARAM_LOCALURL) {
// assume we passed the PARAM_URL test...
// allow http absolute, root relative and relative URLs within wwwroot
if (!empty($param)) {
if (preg_match(':^/:', $param)) {
// root-relative, ok!
} elseif (preg_match('/^'.preg_quote($CFG->wwwroot, '/').'/i',$param)) {
// absolute, and matches our wwwroot
} else {
// relative - let's make sure there are no tricks
if (validateUrlSyntax($param, 's-u-P-a-p-f+q?r?')) {
// looks ok.
} else {
$param = '';
}
}
}
}
if ($options & PARAM_CLEANHTML) {
$param = stripslashes($param); // Remove any slashes
$param = clean_text($param); // Sweep for scripts, etc
$param = trim($param); // Sweep for scripts, etc
}
return $param;
}
/**
* For security purposes, this function will check that the currently
* given sesskey (passed as a parameter to the script or this function)
* matches that of the current user.
*
* @param string $sesskey optionally provided sesskey
* @return boolean
*/
function confirm_sesskey($sesskey=NULL) {
global $USER;
if (!empty($USER->ignoresesskey) || !empty($CFG->ignoresesskey)) {
return true;
}
if (empty($sesskey)) {
$sesskey = required_param('sesskey'); // Check script parameters
}
if (!isset($USER->sesskey)) {
return false;
}
return ($USER->sesskey === $sesskey);
}
/**
* Improved ensure a variable is set
* Issue a (custom) error message if not
* @param mixed $var the variable
* @param string $error optional additional error message
*/
function assert_var_set( $var, $error='' ) {
if (! isset($var)) {
error( "a required variable is not set - $error" );
}
}
/**
* Ensure that a variable is set
*
* If $var is undefined throw an error, otherwise return $var.
* This function will soon be made obsolete by {@link required_param()}
*
* @param mixed $var the variable which may be unset
* @param mixed $default the value to return if $var is unset
*/
function require_variable($var) {
if (! isset($var)) {
error('A required parameter was missing');
}
}
/**
* Ensure that a variable is set
*
* If $var is undefined set it (by reference), otherwise return $var.
*
* @param mixed $var the variable which may be unset
* @param mixed $default the value to return if $var is unset
*/
function optional_variable(&$var, $default=0) {
if (! isset($var)) {
$var = $default;
}
}
/**
* Set a key in global configuration
*
* Set a key/value pair in both this session's {@link $CFG} global variable
* and in the 'config' database table for future sessions.
*
* Can also be used to update keys for plugin-scoped configs in config_plugin table.
* In that case it doesn't affect $CFG.
*
* @param string $name the key to set
* @param string $value the value to set
* @param string $plugin (optional) the plugin scope
* @uses $CFG
* @return bool
*/
function set_config($name, $value, $plugin=NULL) {
/// No need for get_config because they are usually always available in $CFG
global $CFG;
if (empty($plugin)) {
$CFG->$name = $value; // So it's defined for this invocation at least
if (get_field('config', 'name', 'name', $name)) {
return set_field('config', 'value', $value, 'name', $name);
} else {
$config->name = $name;
$config->value = $value;
return insert_record('config', $config);
}
} else { // plugin scope
if ($id = get_field('config_plugins', 'id', 'name', $name, 'plugin', $plugin)) {
return set_field('config_plugins', 'value', $value, 'id', $id);
} else {
$config->plugin = $plugin;
$config->name = $name;
$config->value = $value;
return insert_record('config_plugins', $config);
}
}
}
/**
* Get configuration values from the global config table
* or the config_plugins table.
*
* If called with no parameters it will do the right thing
* generating $CFG safely from the database without overwriting
* existing values.
*
* @param string $plugin
* @param string $name
* @uses $CFG
* @return hash-like object or single value
*
*/
function get_config($plugin=NULL, $name=NULL) {
global $CFG;
if (!empty($name)) { // the user is asking for a specific value
if (!empty($plugin)) {
return get_record('config_plugins', 'plugin' , $plugin, 'name', $name);
} else {
return get_record('config', 'name', $name);
}
}
// the user is after a recordset
if (!empty($plugin)) {
if ($configs=get_records('config_plugins', 'plugin', $plugin, '', 'name,value')) {
$configs = (array)$configs;
$localcfg = array();
foreach ($configs as $config) {
$localcfg[$config->name] = $config->value;
}
return (object)$localcfg;
} else {
return false;
}
} else {
// this was originally in setup.php
if ($configs = get_records('config')) {
$localcfg = (array)$CFG;
foreach ($configs as $config) {
if (!isset($localcfg[$config->name])) {
$localcfg[$config->name] = $config->value;
} else {
if ($localcfg[$config->name] != $config->value ) {
// complain if the DB has a different
// value than config.php does
error_log("\$CFG->{$config->name} in config.php ({$localcfg[$config->name]}) overrides database setting ({$config->value})");
}
}
}
$localcfg = (object)$localcfg;
return $localcfg;
} else {
// preserve $CFG if DB returns nothing or error
return $CFG;
}
}
}
/**
* Refresh current $USER session global variable with all their current preferences.
* @uses $USER
*/
function reload_user_preferences() {
global $USER;
if(empty($USER) || empty($USER->id)) {
return false;
}
unset($USER->preference);
if ($preferences = get_records('user_preferences', 'userid', $USER->id)) {
foreach ($preferences as $preference) {
$USER->preference[$preference->name] = $preference->value;
}
} else {
//return empty preference array to hold new values
$USER->preference = array();
}
}
/**
* Sets a preference for the current user
* Optionally, can set a preference for a different user object
* @uses $USER
* @todo Add a better description and include usage examples.
* @param string $name The key to set as preference for the specified user
* @param string $value The value to set forthe $name key in the specified user's record
* @param int $userid A moodle user ID
* @todo Add inline links to $USER and user functions in above line.
* @return boolean
*/
function set_user_preference($name, $value, $otheruser=NULL) {
global $USER;
if (empty($otheruser)){
if (!empty($USER) && !empty($USER->id)) {
$userid = $USER->id;
} else {
return false;
}
} else {
$userid = $otheruser;
}
if (empty($name)) {
return false;
}
if ($preference = get_record('user_preferences', 'userid', $userid, 'name', $name)) {
if (set_field('user_preferences', 'value', $value, 'id', $preference->id)) {
if (empty($otheruser) and !empty($USER)) {
$USER->preference[$name] = $value;
}
return true;
} else {
return false;
}
} else {
$preference->userid = $userid;
$preference->name = $name;
$preference->value = (string)$value;
if (insert_record('user_preferences', $preference)) {
if (empty($otheruser) and !empty($USER)) {
$USER->preference[$name] = $value;
}
return true;
} else {
return false;
}
}
}
/**
* Unsets a preference completely by deleting it from the database
* Optionally, can set a preference for a different user id
* @uses $USER
* @param string $name The key to unset as preference for the specified user
* @param int $userid A moodle user ID
* @return boolean
*/
function unset_user_preference($name, $userid=NULL) {
global $USER;
if (empty($userid)){
if(!empty($USER) && !empty($USER->id)) {
$userid = $USER->id;
}
else {
return false;
}
}
return delete_records('user_preferences', 'userid', $userid, 'name', $name);
}
/**
* Sets a whole array of preferences for the current user
* @param array $prefarray An array of key/value pairs to be set
* @param int $userid A moodle user ID
* @return boolean
*/
function set_user_preferences($prefarray, $userid=NULL) {
global $USER;
if (!is_array($prefarray) or empty($prefarray)) {
return false;
}
if (empty($userid)){
if (!empty($USER) && !empty($USER->id)) {
$userid = NULL; // Continue with the current user below
} else {
return false; // No-one to set!
}
}
$return = true;
foreach ($prefarray as $name => $value) {
// The order is important; if the test for return is done first, then
// if one function call fails all the remaining ones will be "optimized away"
$return = set_user_preference($name, $value, $userid) and $return;
}
return $return;
}
/**
* If no arguments are supplied this function will return
* all of the current user preferences as an array.
* If a name is specified then this function
* attempts to return that particular preference value. If
* none is found, then the optional value $default is returned,
* otherwise NULL.
* @param string $name Name of the key to use in finding a preference value
* @param string $default Value to be returned if the $name key is not set in the user preferences
* @param int $userid A moodle user ID
* @uses $USER
* @return string
*/
function get_user_preferences($name=NULL, $default=NULL, $userid=NULL) {
global $USER;
if (empty($userid)) { // assume current user
if (empty($USER->preference)) {
return $default; // Default value (or NULL)
}
if (empty($name)) {
return $USER->preference; // Whole array
}
if (!isset($USER->preference[$name])) {
return $default; // Default value (or NULL)
}
return $USER->preference[$name]; // The single value
} else {
$preference = get_records_menu('user_preferences', 'userid', $userid, 'name', 'name,value');
if (empty($name)) {
return $preference;
}
if (!isset($preference[$name])) {
return $default; // Default value (or NULL)
}
return $preference[$name]; // The single value
}
}
/// FUNCTIONS FOR HANDLING TIME ////////////////////////////////////////////
/**
* Given date parts in user time produce a GMT timestamp.
*
* @param int $year The year part to create timestamp of.
* @param int $month The month part to create timestamp of.
* @param int $day The day part to create timestamp of.
* @param int $hour The hour part to create timestamp of.
* @param int $minute The minute part to create timestamp of.
* @param int $second The second part to create timestamp of.
* @param float $timezone
* @return int timestamp
* @todo Finish documenting this function
*/
function make_timestamp($year, $month=1, $day=1, $hour=0, $minute=0, $second=0, $timezone=99, $applydst=true) {
$timezone = get_user_timezone_offset($timezone);
if (abs($timezone) > 13) {
$time = mktime((int)$hour,(int)$minute,(int)$second,(int)$month,(int)$day,(int)$year);
} else {
$time = gmmktime((int)$hour,(int)$minute,(int)$second,(int)$month,(int)$day,(int)$year);
$time = usertime($time, $timezone);
if($applydst) {
$time -= dst_offset_on($time);
}
}
return $time;
}
/**
* Given an amount of time in seconds, returns string
* formatted nicely as months, days, hours etc as needed
*
* @uses MINSECS
* @uses HOURSECS
* @uses DAYSECS
* @param int $totalsecs ?
* @param array $str ?
* @return string
* @todo Finish documenting this function
*/
function format_time($totalsecs, $str=NULL) {
$totalsecs = abs($totalsecs);
if (!$str) { // Create the str structure the slow way
$str->day = get_string('day');
$str->days = get_string('days');
$str->hour = get_string('hour');
$str->hours = get_string('hours');
$str->min = get_string('min');
$str->mins = get_string('mins');
$str->sec = get_string('sec');
$str->secs = get_string('secs');
}
$days = floor($totalsecs/DAYSECS);
$remainder = $totalsecs - ($days*DAYSECS);
$hours = floor($remainder/HOURSECS);
$remainder = $remainder - ($hours*HOURSECS);
$mins = floor($remainder/MINSECS);
$secs = $remainder - ($mins*MINSECS);
$ss = ($secs == 1) ? $str->sec : $str->secs;
$sm = ($mins == 1) ? $str->min : $str->mins;
$sh = ($hours == 1) ? $str->hour : $str->hours;
$sd = ($days == 1) ? $str->day : $str->days;
$odays = '';
$ohours = '';
$omins = '';
$osecs = '';
if ($days) $odays = $days .' '. $sd;
if ($hours) $ohours = $hours .' '. $sh;
if ($mins) $omins = $mins .' '. $sm;
if ($secs) $osecs = $secs .' '. $ss;
if ($days) return $odays .' '. $ohours;
if ($hours) return $ohours .' '. $omins;
if ($mins) return $omins .' '. $osecs;
if ($secs) return $osecs;
return get_string('now');
}
/**
* Returns a formatted string that represents a date in user time
* <b>WARNING: note that the format is for strftime(), not date().</b>
* Because of a bug in most Windows time libraries, we can't use
* the nicer %e, so we have to use %d which has leading zeroes.
* A lot of the fuss in the function is just getting rid of these leading
* zeroes as efficiently as possible.
*
* If parameter fixday = true (default), then take off leading
* zero from %d, else mantain it.
*
* @uses HOURSECS
* @param int $date timestamp in GMT
* @param string $format strftime format
* @param float $timezone
* @param boolean $fixday If true (default) then the leading
* zero from %d is removed. If false then the leading zero is mantained.
* @return string
*/
function userdate($date, $format='', $timezone=99, $fixday = true) {
global $CFG;
static $strftimedaydatetime;
if ($format == '') {
if (empty($strftimedaydatetime)) {
$strftimedaydatetime = get_string('strftimedaydatetime');
}
$format = $strftimedaydatetime;
}
if (!empty($CFG->nofixday)) { // Config.php can force %d not to be fixed.
$fixday = false;
} else if ($fixday) {
$formatnoday = str_replace('%d', 'DD', $format);
$fixday = ($formatnoday != $format);
}
$date += dst_offset_on($date);
$timezone = get_user_timezone_offset($timezone);
if (abs($timezone) > 13) { /// Server time
if ($fixday) {
$datestring = strftime($formatnoday, $date);
$daystring = str_replace(' 0', '', strftime(' %d', $date));
$datestring = str_replace('DD', $daystring, $datestring);
} else {
$datestring = strftime($format, $date);
}
} else {
$date += (int)($timezone * 3600);
if ($fixday) {
$datestring = gmstrftime($formatnoday, $date);
$daystring = str_replace(' 0', '', gmstrftime(' %d', $date));
$datestring = str_replace('DD', $daystring, $datestring);
} else {
$datestring = gmstrftime($format, $date);
}
}
return $datestring;
}
/**
* Given a $time timestamp in GMT (seconds since epoch),
* returns an array that represents the date in user time
*
* @uses HOURSECS
* @param int $time Timestamp in GMT
* @param float $timezone
* @return array An array that represents the date in user time
* @todo Finish documenting this function
*/
function usergetdate($time, $timezone=99) {
$timezone = get_user_timezone_offset($timezone);
if (abs($timezone) > 13) { // Server time
return getdate($time);
}
// There is no gmgetdate so we use gmdate instead
$time += dst_offset_on($time);
$time += intval((float)$timezone * HOURSECS);
$datestring = gmstrftime('%S_%M_%H_%d_%m_%Y_%w_%j_%A_%B', $time);
list(
$getdate['seconds'],
$getdate['minutes'],
$getdate['hours'],
$getdate['mday'],
$getdate['mon'],
$getdate['year'],
$getdate['wday'],
$getdate['yday'],
$getdate['weekday'],
$getdate['month']
) = explode('_', $datestring);
return $getdate;
}
/**
* Given a GMT timestamp (seconds since epoch), offsets it by
* the timezone. eg 3pm in India is 3pm GMT - 7 * 3600 seconds
*
* @uses HOURSECS
* @param int $date Timestamp in GMT
* @param float $timezone
* @return int
*/
function usertime($date, $timezone=99) {
$timezone = get_user_timezone_offset($timezone);
if (abs($timezone) > 13) {
return $date;
}
return $date - (int)($timezone * HOURSECS);
}
/**
* Given a time, return the GMT timestamp of the most recent midnight
* for the current user.
*
* @param int $date Timestamp in GMT
* @param float $timezone ?
* @return ?
*/
function usergetmidnight($date, $timezone=99) {
$timezone = get_user_timezone_offset($timezone);
$userdate = usergetdate($date, $timezone);
// Time of midnight of this user's day, in GMT
return make_timestamp($userdate['year'], $userdate['mon'], $userdate['mday'], 0, 0, 0, $timezone);
}
/**
* Returns a string that prints the user's timezone
*
* @param float $timezone The user's timezone
* @return string
*/
function usertimezone($timezone=99) {
$tz = get_user_timezone($timezone);
if (!is_float($tz)) {
return $tz;
}
if(abs($tz) > 13) { // Server time
return get_string('serverlocaltime');
}
if($tz == intval($tz)) {
// Don't show .0 for whole hours
$tz = intval($tz);
}
if($tz == 0) {
return 'GMT';
}
else if($tz > 0) {
return 'GMT+'.$tz;
}
else {
return 'GMT'.$tz;
}
}
/**
* Returns a float which represents the user's timezone difference from GMT in hours
* Checks various settings and picks the most dominant of those which have a value
*
* @uses $CFG
* @uses $USER
* @param float $tz The user's timezone
* @return int
*/
function get_user_timezone_offset($tz = 99) {
global $USER, $CFG;
$tz = get_user_timezone($tz);
if (is_float($tz)) {
return $tz;
} else {
$tzrecord = get_timezone_record($tz);
if (empty($tzrecord)) {
return 99.0;
}
return (float)$tzrecord->gmtoff / HOURMINS;
}
}
function get_user_timezone($tz = 99) {
global $USER, $CFG;
$timezones = array(
$tz,
isset($CFG->forcetimezone) ? $CFG->forcetimezone : 99,
isset($USER->timezone) ? $USER->timezone : 99,
isset($CFG->timezone) ? $CFG->timezone : 99,
);
$tz = 99;
while(($tz == '' || $tz == 99) && $next = each($timezones)) {
$tz = $next['value'];
}
return is_numeric($tz) ? (float) $tz : $tz;
}
function get_timezone_record($timezonename) {
global $CFG, $db;
static $cache = NULL;
if ($cache === NULL) {
$cache = array();
}
if (isset($cache[$timezonename])) {
return $cache[$timezonename];
}
return get_record_sql('SELECT * FROM '.$CFG->prefix.'timezone
WHERE name = '.$db->qstr($timezonename).' ORDER BY year DESC', true);
}
function calculate_user_dst_table($from_year = NULL, $to_year = NULL) {
global $CFG, $USER;
if (empty($USER)) {
return false;
}
$usertz = get_user_timezone();
if (is_float($usertz)) {
// Trivial timezone, no DST
return false;
}
if (!empty($USER->dstoffsettz) && $USER->dstoffsettz != $usertz) {
// We have precalculated values, but the user's effective TZ has changed in the meantime, so reset
unset($USER->dstoffsets);
unset($USER->dstrange);
}
if (!empty($USER->dstoffsets) && empty($from_year) && empty($to_year)) {
// Repeat calls which do not request specific year ranges stop here, we have already calculated the table
// This will be the return path most of the time, pretty light computationally
return true;
}
// Reaching here means we either need to extend our table or create it from scratch
// Remember which TZ we calculated these changes for
$USER->dstoffsettz = $usertz;
if(empty($USER->dstoffsets)) {
// If we 're creating from scratch, put the two guard elements in there
$USER->dstoffsets = array(1 => NULL, 0 => NULL);
}
if(empty($USER->dstrange)) {
// If creating from scratch
$from = max((empty($from_year) ? intval(date('Y')) - 3 : $from_year), 1971);
$to = min((empty($to_year) ? intval(date('Y')) + 3 : $to_year), 2035);
// Fill in the array with the extra years we need to process
$yearstoprocess = array();
for($i = $from; $i <= $to; ++$i) {
$yearstoprocess[] = $i;
}
// Take note of which years we have processed for future calls
$USER->dstrange = array($from, $to);
}
else {
// If needing to extend the table, do the same
$yearstoprocess = array();
$from = max((empty($from_year) ? $USER->dstrange[0] : $from_year), 1971);
$to = min((empty($to_year) ? $USER->dstrange[1] : $to_year), 2035);
if($from < $USER->dstrange[0]) {
// Take note of which years we need to process and then note that we have processed them for future calls
for($i = $from; $i < $USER->dstrange[0]; ++$i) {
$yearstoprocess[] = $i;
}
$USER->dstrange[0] = $from;
}
if($to > $USER->dstrange[1]) {
// Take note of which years we need to process and then note that we have processed them for future calls
for($i = $USER->dstrange[1] + 1; $i <= $to; ++$i) {
$yearstoprocess[] = $i;
}
$USER->dstrange[1] = $to;
}
}
if(empty($yearstoprocess)) {
// This means that there was a call requesting a SMALLER range than we have already calculated
return true;
}
// From now on, we know that the array has at least the two guard elements, and $yearstoprocess has the years we need
// Also, the array is sorted in descending timestamp order!
// Get DB data
$presetrecords = get_records('timezone', 'name', $usertz, 'year DESC', 'year, gmtoff, dstoff, dst_month, dst_startday, dst_weekday, dst_skipweeks, dst_time, std_month, std_startday, std_weekday, std_skipweeks, std_time');
if(empty($presetrecords)) {
return false;
}
// Remove ending guard (first element of the array)
reset($USER->dstoffsets);
unset($USER->dstoffsets[key($USER->dstoffsets)]);
// Add all required change timestamps
foreach($yearstoprocess as $y) {
// Find the record which is in effect for the year $y
foreach($presetrecords as $year => $preset) {
if($year <= $y) {
break;
}
}
$changes = dst_changes_for_year($y, $preset);
if($changes === NULL) {
continue;
}
if($changes['dst'] != 0) {
$USER->dstoffsets[$changes['dst']] = $preset->dstoff * MINSECS;
}
if($changes['std'] != 0) {
$USER->dstoffsets[$changes['std']] = 0;
}
}
// Put in a guard element at the top
$maxtimestamp = max(array_keys($USER->dstoffsets));
$USER->dstoffsets[($maxtimestamp + DAYSECS)] = NULL; // DAYSECS is arbitrary, any "small" number will do
// Sort again
krsort($USER->dstoffsets);
return true;
}
function dst_changes_for_year($year, $timezone) {
if($timezone->dst_startday == 0 && $timezone->dst_weekday == 0 && $timezone->std_startday == 0 && $timezone->std_weekday == 0) {
return NULL;
}
$monthdaydst = find_day_in_month($timezone->dst_startday, $timezone->dst_weekday, $timezone->dst_month, $year);
$monthdaystd = find_day_in_month($timezone->std_startday, $timezone->std_weekday, $timezone->std_month, $year);
list($dst_hour, $dst_min) = explode(':', $timezone->dst_time);
list($std_hour, $std_min) = explode(':', $timezone->std_time);
$timedst = make_timestamp($year, $timezone->dst_month, $monthdaydst, 0, 0, 0, 99, false);
$timestd = make_timestamp($year, $timezone->std_month, $monthdaystd, 0, 0, 0, 99, false);
// Instead of putting hour and minute in make_timestamp(), we add them afterwards.
// This has the advantage of being able to have negative values for hour, i.e. for timezones
// where GMT time would be in the PREVIOUS day than the local one on which DST changes.
$timedst += $dst_hour * HOURSECS + $dst_min * MINSECS;
$timestd += $std_hour * HOURSECS + $std_min * MINSECS;
return array('dst' => $timedst, 0 => $timedst, 'std' => $timestd, 1 => $timestd);
}
// $time must NOT be compensated at all, it has to be a pure timestamp
function dst_offset_on($time) {
global $USER;
if(!calculate_user_dst_table()) {
return 0;
}
if(empty($USER) || empty($USER->dstoffsets)) {
return 0;
}
reset($USER->dstoffsets);
while(list($from, $offset) = each($USER->dstoffsets)) {
if($from <= $time) {
break;
}
}
// This is the normal return path
if($offset !== NULL) {
return $offset;
}
// Reaching this point means we haven't calculated far enough, do it now:
// Calculate extra DST changes if needed and recurse. The recursion always
// moves toward the stopping condition, so will always end.
if($from == 0) {
// We need a year smaller than $USER->dstrange[0]
if($USER->dstrange[0] == 1971) {
return 0;
}
calculate_user_dst_table($USER->dstrange[0] - 5, NULL);
return dst_offset_on($time);
}
else {
// We need a year larger than $USER->dstrange[1]
if($USER->dstrange[1] == 2035) {
return 0;
}
calculate_user_dst_table(NULL, $USER->dstrange[1] + 5);
return dst_offset_on($time);
}
}
function find_day_in_month($startday, $weekday, $month, $year) {
$daysinmonth = days_in_month($month, $year);
if($weekday == -1) {
// Don't care about weekday, so return:
// abs($startday) if $startday != -1
// $daysinmonth otherwise
return ($startday == -1) ? $daysinmonth : abs($startday);
}
// From now on we 're looking for a specific weekday
// Give "end of month" its actual value, since we know it
if($startday == -1) {
$startday = -1 * $daysinmonth;
}
// Starting from day $startday, the sign is the direction
if($startday < 1) {
$startday = abs($startday);
$lastmonthweekday = strftime('%w', mktime(12, 0, 0, $month, $daysinmonth, $year, 0));
// This is the last such weekday of the month
$lastinmonth = $daysinmonth + $weekday - $lastmonthweekday;
if($lastinmonth > $daysinmonth) {
$lastinmonth -= 7;
}
// Find the first such weekday <= $startday
while($lastinmonth > $startday) {
$lastinmonth -= 7;
}
return $lastinmonth;
}
else {
$indexweekday = strftime('%w', mktime(12, 0, 0, $month, $startday, $year, 0));
$diff = $weekday - $indexweekday;
if($diff < 0) {
$diff += 7;
}
// This is the first such weekday of the month equal to or after $startday
$firstfromindex = $startday + $diff;
return $firstfromindex;
}
}
function days_in_month($month, $year) {
return intval(date('t', mktime(12, 0, 0, $month, 1, $year, 0)));
}
function dayofweek($day, $month, $year) {
// I wonder if this is any different from
// strftime('%w', mktime(12, 0, 0, $month, $daysinmonth, $year, 0));
return intval(date('w', mktime(12, 0, 0, $month, $day, $year, 0)));
}
/// USER AUTHENTICATION AND LOGIN ////////////////////////////////////////
// Makes sure that $USER->sesskey exists, if $USER itself exists. It sets a new sesskey
// if one does not already exist, but does not overwrite existing sesskeys. Returns the
// sesskey string if $USER exists, or boolean false if not.
function sesskey() {
global $USER;
if(!isset($USER)) {
return false;
}
if (empty($USER->sesskey)) {
$USER->sesskey = random_string(10);
}
return $USER->sesskey;
}
/**
* This function checks that the current user is logged in and has the
* required privileges
*
* This function checks that the current user is logged in, and optionally
* whether they are allowed to be in a particular course and view a particular
* course module.
* If they are not logged in, then it redirects them to the site login unless
* $autologinguest is set and {@link $CFG}->autologinguests is set to 1 in which
* case they are automatically logged in as guests.
* If $courseid is given and the user is not enrolled in that course then the
* user is redirected to the course enrolment page.
* If $cm is given and the coursemodule is hidden and the user is not a teacher
* in the course then the user is redirected to the course home page.
*
* @uses $CFG
* @uses $SESSION
* @uses $USER
* @uses $FULLME
* @uses SITEID
* @uses $MoodleSession
* @param int $courseid id of the course
* @param boolean $autologinguest
* @param $cm course module object
*/
function require_login($courseid=0, $autologinguest=true, $cm=null) {
global $CFG, $SESSION, $USER, $FULLME, $MoodleSession;
// First check that the user is logged in to the site.
if (! (isset($USER->loggedin) and $USER->confirmed and ($USER->site == $CFG->wwwroot)) ) { // They're not
$SESSION->wantsurl = $FULLME;
if (!empty($_SERVER['HTTP_REFERER'])) {
$SESSION->fromurl = $_SERVER['HTTP_REFERER'];
}
$USER = NULL;
if ($autologinguest and $CFG->autologinguests and $courseid and get_field('course','guest','id',$courseid)) {
$loginguest = '?loginguest=true';
} else {
$loginguest = '';
}
if (empty($CFG->loginhttps)) {
redirect($CFG->wwwroot .'/login/index.php'. $loginguest);
} else {
$wwwroot = str_replace('http','https', $CFG->wwwroot);
redirect($wwwroot .'/login/index.php'. $loginguest);
}
exit;
}
// check whether the user should be changing password
// reload_user_preferences(); // Why is this necessary? Seems wasteful. - MD
if (!empty($USER->preference['auth_forcepasswordchange'])){
if (is_internal_auth() || $CFG->{'auth_'.$USER->auth.'_stdchangepassword'}){
$SESSION->wantsurl = $FULLME;
redirect($CFG->wwwroot .'/login/change_password.php');
} elseif($CFG->changepassword) {
redirect($CFG->changepassword);
} else {
error('You cannot proceed without changing your password.
However there is no available page for changing it.
Please contact your Moodle Administrator.');
}
}
// Check that the user account is properly set up
if (user_not_fully_set_up($USER)) {
$SESSION->wantsurl = $FULLME;
redirect($CFG->wwwroot .'/user/edit.php?id='. $USER->id .'&amp;course='. SITEID);
}
// Make sure current IP matches the one for this session (if required)
if (!empty($CFG->tracksessionip)) {
if ($USER->sessionIP != md5(getremoteaddr())) {
error(get_string('sessionipnomatch', 'error'));
}
}
// Make sure the USER has a sesskey set up. Used for checking script parameters.
sesskey();
// Check that the user has agreed to a site policy if there is one
if (!empty($CFG->sitepolicy)) {
if (!$USER->policyagreed) {
$SESSION->wantsurl = $FULLME;
redirect($CFG->wwwroot .'/user/policy.php');
}
}
// If the site is currently under maintenance, then print a message
if (!isadmin()) {
if (file_exists($CFG->dataroot.'/'.SITEID.'/maintenance.html')) {
print_maintenance_message();
exit;
}
}
// Next, check if the user can be in a particular course
if ($courseid) {
if ($courseid == SITEID) { // Anyone can be in the site course
if (isset($cm) and !$cm->visible and !isteacher(SITEID)) { // Not allowed to see module, send to course page
redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course, get_string('activityiscurrentlyhidden'));
}
return;
}
if (!empty($USER->student[$courseid]) or !empty($USER->teacher[$courseid]) or !empty($USER->admin)) {
if (isset($USER->realuser)) { // Make sure the REAL person can also access this course
if (!isteacher($courseid, $USER->realuser)) {
print_header();
notice(get_string('studentnotallowed', '', fullname($USER, true)), $CFG->wwwroot .'/');
}
}
if (isset($cm) and !$cm->visible and !isteacher($courseid)) { // Not allowed to see module, send to course page
redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course, get_string('activityiscurrentlyhidden'));
}
return; // user is a member of this course.
}
if (! $course = get_record('course', 'id', $courseid)) {
error('That course doesn\'t exist');
}
if (!$course->visible) {
print_header();
notice(get_string('coursehidden'), $CFG->wwwroot .'/');
}
if ($USER->username == 'guest') {
switch ($course->guest) {
case 0: // Guests not allowed
print_header();
notice(get_string('guestsnotallowed', '', $course->fullname), "$CFG->wwwroot/login/index.php");
break;
case 1: // Guests allowed
if (isset($cm) and !$cm->visible) { // Not allowed to see module, send to course page
redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course, get_string('activityiscurrentlyhidden'));
}
return;
case 2: // Guests allowed with key (drop through)
break;
}
}
//User is not enrolled in the course, wants to access course content
//as a guest, and course setting allow unlimited guest access
//Code cribbed from course/loginas.php
if (strstr($FULLME,"username=guest") && ($course->guest==1)) {
$realuser = $USER->id;
$realname = fullname($USER, true);
$USER = guest_user();
$USER->loggedin = true;
$USER->site = $CFG->wwwroot;
$USER->realuser = $realuser;
$USER->sessionIP = md5(getremoteaddr()); // Store the current IP in the session
if (isset($SESSION->currentgroup)) { // Remember current cache setting for later
$SESSION->oldcurrentgroup = $SESSION->currentgroup;
unset($SESSION->currentgroup);
}
$guest_name = fullname($USER, true);
add_to_log($course->id, "course", "loginas", "../user/view.php?id=$course->id&$USER->id$", "$realname -> $guest_name");
if (isset($cm) and !$cm->visible) { // Not allowed to see module, send to course page
redirect($CFG->wwwroot.'/course/view.php?id='.$cm->course, get_string('activityiscurrentlyhidden'));
}
return;
}
// Currently not enrolled in the course, so see if they want to enrol
$SESSION->wantsurl = $FULLME;
redirect($CFG->wwwroot .'/course/enrol.php?id='. $courseid);
die;
}
}
/**
* This is a weaker version of {@link require_login()} which only requires login
* when called from within a course rather than the site page, unless
* the forcelogin option is turned on.
*
* @uses $CFG
* @param object $course The course object in question
* @param boolean $autologinguest Allow autologin guests if that is wanted
* @param object $cm Course activity module if known
*/
function require_course_login($course, $autologinguest=true, $cm=null) {
global $CFG;
if (!empty($CFG->forcelogin)) {
require_login();
}
if ($course->id != SITEID) {
require_login($course->id, $autologinguest, $cm);
}
}
/**
* Modify the user table by setting the currently logged in user's
* last login to now.
*
* @uses $USER
* @return boolean
*/
function update_user_login_times() {
global $USER;
$USER->lastlogin = $user->lastlogin = $USER->currentlogin;
$USER->currentlogin = $user->lastaccess = $user->currentlogin = time();
$user->id = $USER->id;
return update_record('user', $user);
}
/**
* Determines if a user has completed setting up their account.
*
* @param user $user A {@link $USER} object to test for the existance of a valid name and email
* @return boolean
*/
function user_not_fully_set_up($user) {
return ($user->username != 'guest' and (empty($user->firstname) or empty($user->lastname) or empty($user->email) or over_bounce_threshold($user)));
}
function over_bounce_threshold($user) {
global $CFG;
if (empty($CFG->handlebounces)) {
return false;
}
// set sensible defaults
if (empty($CFG->minbounces)) {
$CFG->minbounces = 10;
}
if (empty($CFG->bounceratio)) {
$CFG->bounceratio = .20;
}
$bouncecount = 0;
$sendcount = 0;
if ($bounce = get_record('user_preferences','userid',$user->id,'name','email_bounce_count')) {
$bouncecount = $bounce->value;
}
if ($send = get_record('user_preferences','userid',$user->id,'name','email_send_count')) {
$sendcount = $send->value;
}
return ($bouncecount >= $CFG->minbounces && $bouncecount/$sendcount >= $CFG->bounceratio);
}
/**
* @param $user - object containing an id
* @param $reset - will reset the count to 0
*/
function set_send_count($user,$reset=false) {
if ($pref = get_record('user_preferences','userid',$user->id,'name','email_send_count')) {
$pref->value = (!empty($reset)) ? 0 : $pref->value+1;
update_record('user_preferences',$pref);
}
else if (!empty($reset)) { // if it's not there and we're resetting, don't bother.
// make a new one
$pref->name = 'email_send_count';
$pref->value = 1;
$pref->userid = $user->id;
insert_record('user_preferences',$pref);
}
}
/**
* @param $user - object containing an id
* @param $reset - will reset the count to 0
*/
function set_bounce_count($user,$reset=false) {
if ($pref = get_record('user_preferences','userid',$user->id,'name','email_bounce_count')) {
$pref->value = (!empty($reset)) ? 0 : $pref->value+1;
update_record('user_preferences',$pref);
}
else if (!empty($reset)) { // if it's not there and we're resetting, don't bother.
// make a new one
$pref->name = 'email_bounce_count';
$pref->value = 1;
$pref->userid = $user->id;
insert_record('user_preferences',$pref);
}
}
/**
* Keeps track of login attempts
*
* @uses $SESSION
*/
function update_login_count() {
global $SESSION;
$max_logins = 10;
if (empty($SESSION->logincount)) {
$SESSION->logincount = 1;
} else {
$SESSION->logincount++;
}
if ($SESSION->logincount > $max_logins) {
unset($SESSION->wantsurl);
error(get_string('errortoomanylogins'));
}
}
/**
* Resets login attempts
*
* @uses $SESSION
*/
function reset_login_count() {
global $SESSION;
$SESSION->logincount = 0;
}
/**
* check_for_restricted_user
*
* @uses $CFG
* @uses $USER
* @param string $username ?
* @param string $redirect ?
* @todo Finish documenting this function
*/
function check_for_restricted_user($username=NULL, $redirect='') {
global $CFG, $USER;
if (!$username) {
if (!empty($USER->username)) {
$username = $USER->username;
} else {
return false;
}
}
if (!empty($CFG->restrictusers)) {
$names = explode(',', $CFG->restrictusers);
if (in_array($username, $names)) {
error(get_string('restricteduser', 'error', fullname($USER)), $redirect);
}
}
}
function sync_metacourses() {
global $CFG;
if (!$courses = get_records_sql("SELECT DISTINCT parent_course,1 FROM {$CFG->prefix}course_meta")) {
return;
}
foreach ($courses as $course) {
sync_metacourse($course->parent_course);
}
}
/**
* Goes through all enrolment records for the courses inside the metacourse and sync with them.
*/
function sync_metacourse($metacourseid) {
global $CFG,$db;
if (!$metacourse = get_record("course","id",$metacourseid)) {
return false;
}
if (count_records('course_meta','parent_course',$metacourseid) == 0) { // if there are no child courses for this meta course, nuke the enrolments
if ($enrolments = get_records('user_students','course',$metacourseid,'','userid,1')) {
foreach ($enrolments as $enrolment) {
unenrol_student($enrolment->userid,$metacourseid);
}
}
return true;
}
// this will return a list of userids from user_student for enrolments in the metacourse that shouldn't be there.
$sql = "SELECT parent.userid,max(child.course) as course
FROM {$CFG->prefix}course_meta meta
JOIN {$CFG->prefix}user_students parent
ON meta.parent_course = parent.course
LEFT OUTER JOIN {$CFG->prefix}user_students child
ON child.course = meta.child_course
AND child.userid = parent.userid
WHERE meta.parent_course = $metacourseid
GROUP BY child.course,parent.userid
ORDER BY parent.userid,child.course";
$res = $db->Execute($sql);
//iterate results
$enrolmentstodelete = array();
while( !$res->EOF && isset($res->fields) ) {
$enrolmentstodelete[] = $res->fields;
$res->MoveNext();
}
if (!empty($enrolmentstodelete)) {
$last->id = 0;
$last->course = 0;
foreach ($enrolmentstodelete as $enrolment) {
$enrolment = (object)$enrolment;
if (count($enrolmentstodelete) == 1 && empty($enrolment->course)) {
unenrol_student($enrolment->userid,$metacourseid);
break;
}
if ($last->id != $enrolment->userid) { // we've changed
if (empty($last->course) && !empty($last->id)) {
unenrol_student($last->id,$metacourseid); // doing it this way for forum subscriptions etc.
}
$last->course = 0;
$last->id = $enrolment->userid;
}
if (!empty($enrolment->course)) {
$last->course = $enrolment->course;
}
}
if (!empty($last->id) && empty($last->course)) {
unenrol_student($last->id,$metacourseid); // doing it this way for forum subscriptions etc.
}
}
// this will return a list of userids that need to be enrolled in the metacourse
$sql = "SELECT DISTINCT child.userid,1
FROM {$CFG->prefix}course_meta meta
JOIN {$CFG->prefix}user_students child
ON meta.child_course = child.course
LEFT OUTER JOIN {$CFG->prefix}user_students parent
ON meta.parent_course = parent.course
AND parent.userid = child.userid
WHERE parent.course IS NULL
AND meta.parent_course = $metacourseid";
if ($userstoadd = get_records_sql($sql)) {
foreach ($userstoadd as $user) {
enrol_student($user->userid,$metacourseid);
}
}
// and next make sure that we have the right start time and end time (ie max and min) for them all.
if ($enrolments = get_records('user_students','course',$metacourseid,'','id,userid')) {
foreach ($enrolments as $enrol) {
if ($maxmin = get_record_sql("SELECT min(timestart) AS timestart, max(timeend) AS timeend
FROM {$CFG->prefix}user_students u JOIN {$CFG->prefix}course_meta mc ON u.course = mc.child_course WHERE userid = $enrol->userid
AND mc.parent_course = $metacourseid")) {
$enrol->timestart = $maxmin->timestart;
$enrol->timeend = $maxmin->timeend;
update_record('user_students',$enrol);
}
}
}
return true;
}
/**
* Adds a record to the metacourse table and calls sync_metacoures
*/
function add_to_metacourse ($metacourseid, $courseid) {
if (!$metacourse = get_record("course","id",$metacourseid)) {
return false;
}
if (!$course = get_record("course","id",$courseid)) {
return false;
}
if (!$record = get_record("course_meta","parent_course",$metacourseid,"child_course",$courseid)) {
$rec->parent_course = $metacourseid;
$rec->child_course = $courseid;
if (!insert_record('course_meta',$rec)) {
return false;
}
return sync_metacourse($metacourseid);
}
return true;
}
/**
* Removes the record from the metacourse table and calls sync_metacourse
*/
function remove_from_metacourse($metacourseid, $courseid) {
if (delete_records('course_meta','parent_course',$metacourseid,'child_course',$courseid)) {
return sync_metacourse($metacourseid);
}
return false;
}
/**
* Determines if a user is currently logged in
*
* @uses $USER
* @return boolean
*/
function isloggedin() {
global $USER;
return (!empty($USER->id));
}
/**
* Determines if a user an admin
*
* @uses $USER
* @param int $userid The id of the user as is found in the 'user' table
* @staticvar array $admin ?
* @staticvar array $nonadmins ?
* @return boolean
* @todo Complete documentation for this function
*/
function isadmin($userid=0) {
global $USER;
static $admins, $nonadmins;
if (!isset($admins)) {
$admins = array();
$nonadmins = array();
}
if (!$userid){
if (empty($USER->id)) {
return false;
}
$userid = $USER->id;
}
if (!empty($USER->id) and ($userid == $USER->id)) { // Check session cache
return !empty($USER->admin);
}
if (in_array($userid, $admins)) {
return true;
} else if (in_array($userid, $nonadmins)) {
return false;
} else if (record_exists('user_admins', 'userid', $userid)){
$admins[] = $userid;
return true;
} else {
$nonadmins[] = $userid;
return false;
}
}
/**
* Determines if a user is a teacher (or better)
*
* @uses $USER
* @param int $courseid The id of the course that is being viewed, if any
* @param int $userid The id of the user that is being tested against. Set this to 0 if you would just like to test against the currently logged in user.
* @param boolean $includeadmin If true this function will return true when it encounters an admin user.
* @return boolean
* @todo Finish documenting this function
*/
function isteacher($courseid=0, $userid=0, $includeadmin=true) {
/// Is the user able to access this course as a teacher?
global $USER, $CFG;
if (empty($userid)) { // we are relying on $USER
if (empty($USER) or empty($USER->id)) { // not logged in so can't be a teacher
return false;
}
if (!empty($USER->teacher) and $courseid) { // look in session cache
if (!empty($USER->teacher[$courseid])) { // Explicitly a teacher, good
return true;
}
}
$userid = $USER->id; // we need to make further checks
}
if ($includeadmin and isadmin($userid)) { // admins can do anything the teacher can
return true;
}
if (empty($courseid)) { // should not happen, but we handle it
if (isadmin() or $CFG->debug > 7) {
notify('Coding error: isteacher() should not be used without a valid course id '.
'as argument. Please notify the developer for this module.');
}
return isteacherinanycourse($userid, $includeadmin);
}
/// Last resort, check the database
return record_exists('user_teachers', 'userid', $userid, 'course', $courseid);
}
/**
* Determines if a user is a teacher in any course, or an admin
*
* @uses $USER
* @param int $userid The id of the user that is being tested against. Set this to 0 if you would just like to test against the currently logged in user.
* @param boolean $includeadmin If true this function will return true when it encounters an admin user.
* @return boolean
* @todo Finish documenting this function
*/
function isteacherinanycourse($userid=0, $includeadmin=true) {
global $USER;
if (empty($userid)) {
if (empty($USER) or empty($USER->id)) {
return false;
}
if (!empty($USER->teacher)) { // look in session cache
return true;
}
$userid = $USER->id;
}
if ($includeadmin and isadmin($userid)) { // admins can do anything
return true;
}
return record_exists('user_teachers', 'userid', $userid);
}
/**
* Determines if a user is allowed to edit a given course
*
* @uses $USER
* @param int $courseid The id of the course that is being edited
* @param int $userid The id of the user that is being tested against. Set this to 0 if you would just like to test against the currently logged in user.
* @return boolean
*/
function isteacheredit($courseid, $userid=0) {
global $USER;
if (isadmin($userid)) { // admins can do anything
return true;
}
if (!$userid) {
if (empty($USER) or empty($USER->id)) { // not logged in so can't be a teacher
return false;
}
if (empty($USER->teacheredit)) { // we are relying on session cache
return false;
}
return !empty($USER->teacheredit[$courseid]);
}
return get_field('user_teachers', 'editall', 'userid', $userid, 'course', $courseid);
}
/**
* Determines if a user can create new courses
*
* @uses $USER
* @param int $userid The user being tested. You can set this to 0 or leave it blank to test the currently logged in user.
* @return boolean
*/
function iscreator ($userid=0) {
global $USER;
if (empty($USER->id)) {
return false;
}
if (isadmin($userid)) { // admins can do anything
return true;
}
if (empty($userid)) {
return record_exists('user_coursecreators', 'userid', $USER->id);
}
return record_exists('user_coursecreators', 'userid', $userid);
}
/**
* Determines if a user is a student in the specified course
*
* If the course id specifies the site then the function determines
* if the user is a confirmed and valid user of this site.
*
* @uses $USER
* @uses $CFG
* @uses SITEID
* @param int $courseid The id of the course being tested
* @param int $userid The user being tested. You can set this to 0 or leave it blank to test the currently logged in user.
* @return boolean
*/
function isstudent($courseid, $userid=0) {
global $USER, $CFG;
if (empty($USER->id) and !$userid) {
return false;
}
if ($courseid == SITEID) {
if (!$userid) {
$userid = $USER->id;
}
if (isguest($userid)) {
return false;
}
// a site teacher can never be a site student
if (isteacher($courseid, $userid)) {
return false;
}
if ($CFG->allusersaresitestudents) {
return record_exists('user', 'id', $userid);
} else {
return (record_exists('user_students', 'userid', $userid)
or record_exists('user_teachers', 'userid', $userid));
}
}
if (!$userid) {
return !empty($USER->student[$courseid]);
}
// $timenow = time(); // todo: add time check below
return record_exists('user_students', 'userid', $userid, 'course', $courseid);
}
/**
* Determines if the specified user is logged in as guest.
*
* @uses $USER
* @param int $userid The user being tested. You can set this to 0 or leave it blank to test the currently logged in user.
* @return boolean
*/
function isguest($userid=0) {
global $USER;
if (!$userid) {
if (empty($USER->username)) {
return false;
}
return ($USER->username == 'guest');
}
return record_exists('user', 'id', $userid, 'username', 'guest');
}
/**
* Determines if the currently logged in user is in editing mode
*
* @uses $USER
* @param int $courseid The id of the course being tested
* @param user $user A {@link $USER} object. If null then the currently logged in user is used.
* @return boolean
*/
function isediting($courseid, $user=NULL) {
global $USER;
if (!$user){
$user = $USER;
}
if (empty($user->editing)) {
return false;
}
return ($user->editing and isteacher($courseid, $user->id));
}
/**
* Determines if the logged in user is currently moving an activity
*
* @uses $USER
* @param int $courseid The id of the course being tested
* @return boolean
*/
function ismoving($courseid) {
global $USER;
if (!empty($USER->activitycopy)) {
return ($USER->activitycopycourse == $courseid);
}
return false;
}
/**
* Given an object containing firstname and lastname
* values, this function returns a string with the
* full name of the person.
* The result may depend on system settings
* or language. 'override' will force both names
* to be used even if system settings specify one.
* @uses $CFG
* @uses $SESSION
* @param type description
* @todo Finish documenting this function
*/
function fullname($user, $override=false) {
global $CFG, $SESSION;
if (!isset($user->firstname) and !isset($user->lastname)) {
return '';
}
if (!$override) {
if (!empty($CFG->forcefirstname)) {
$user->firstname = $CFG->forcefirstname;
}
if (!empty($CFG->forcelastname)) {
$user->lastname = $CFG->forcelastname;
}
}
if (!empty($SESSION->fullnamedisplay)) {
$CFG->fullnamedisplay = $SESSION->fullnamedisplay;
}
if ($CFG->fullnamedisplay == 'firstname lastname') {
return $user->firstname .' '. $user->lastname;
} else if ($CFG->fullnamedisplay == 'lastname firstname') {
return $user->lastname .' '. $user->firstname;
} else if ($CFG->fullnamedisplay == 'firstname') {
if ($override) {
return get_string('fullnamedisplay', '', $user);
} else {
return $user->firstname;
}
}
return get_string('fullnamedisplay', '', $user);
}
/**
* Sets a moodle cookie with an encrypted string
*
* @uses $CFG
* @uses DAYSECS
* @uses HOURSECS
* @param string $thing The string to encrypt and place in a cookie
*/
function set_moodle_cookie($thing) {
global $CFG;
if ($thing == 'guest') { // Ignore guest account
return;
}
$cookiename = 'MOODLEID_'.$CFG->sessioncookie;
$days = 60;
$seconds = DAYSECS*$days;
setCookie($cookiename, '', time() - HOURSECS, '/');
setCookie($cookiename, rc4encrypt($thing), time()+$seconds, '/');
}
/**
* Gets a moodle cookie with an encrypted string
*
* @uses $CFG
* @return string
*/
function get_moodle_cookie() {
global $CFG;
$cookiename = 'MOODLEID_'.$CFG->sessioncookie;
if (empty($_COOKIE[$cookiename])) {
return '';
} else {
$thing = rc4decrypt($_COOKIE[$cookiename]);
return ($thing == 'guest') ? '': $thing; // Ignore guest account
}
}
/**
* Returns true if an internal authentication method is being used.
* if method not specified then, global default is assumed
*
* @uses $CFG
* @param string $auth Form of authentication required
* @return boolean
* @todo Outline auth types and provide code example
*/
function is_internal_auth($auth='') {
/// Returns true if an internal authentication method is being used.
/// If auth not specified then global default is assumed
global $CFG;
if (empty($auth)) {
$auth = $CFG->auth;
}
return ($auth == "email" || $auth == "none" || $auth == "manual");
}
/**
* Returns an array of user fields
*
* @uses $CFG
* @uses $db
* @return array User field/column names
* @todo Finish documenting this function
*/
function get_user_fieldnames() {
global $CFG, $db;
$fieldarray = $db->MetaColumnNames($CFG->prefix.'user');
unset($fieldarray['ID']);
return $fieldarray;
}
/**
* Creates a bare-bones user record
*
* @uses $CFG
* @param string $username New user's username to add to record
* @param string $password New user's password to add to record
* @param string $auth Form of authentication required
* @return user A {@link $USER} object
* @todo Outline auth types and provide code example
*/
function create_user_record($username, $password, $auth='') {
global $CFG;
//just in case check text case
$username = trim(moodle_strtolower($username));
if (function_exists('auth_get_userinfo')) {
if ($newinfo = auth_get_userinfo($username)) {
$newinfo = truncate_userinfo($newinfo);
foreach ($newinfo as $key => $value){
$newuser->$key = addslashes(stripslashes($value)); // Just in case
}
}
}
if (!empty($newuser->email)) {
if (email_is_not_allowed($newuser->email)) {
unset($newuser->email);
}
}
$newuser->auth = (empty($auth)) ? $CFG->auth : $auth;
$newuser->username = $username;
$newuser->password = md5($password);
$newuser->lang = $CFG->lang;
$newuser->confirmed = 1;
$newuser->lastIP = getremoteaddr();
$newuser->timemodified = time();
if (insert_record('user', $newuser)) {
$user = get_complete_user_data('username', $newuser->username);
if($CFG->{'auth_'.$newuser->auth.'_forcechangepassword'}){
set_user_preference('auth_forcepasswordchange', 1, $user);
}
return $user;
}
return false;
}
/**
* Will update a local user record from an external source
*
* @uses $CFG
* @param string $username New user's username to add to record
* @return user A {@link $USER} object
*/
function update_user_record($username) {
global $CFG;
if (function_exists('auth_get_userinfo')) {
$username = trim(moodle_strtolower($username)); /// just in case check text case
$oldinfo = get_record('user', 'username', $username, '','','','', 'username, auth');
$authconfig = get_config('auth/' . $oldinfo->auth);
if ($newinfo = auth_get_userinfo($username)) {
foreach ($newinfo as $key => $value){
$confkey = 'field_updatelocal_' . $key;
if (!empty($authconfig->$confkey) && $authconfig->$confkey === 'onlogin') {
$value = addslashes(stripslashes($value)); // Just in case
set_field('user', $key, $value, 'username', $username);
}
}
}
}
return get_complete_user_data('username', $username);
}
function truncate_userinfo($info) {
/// will truncate userinfo as it comes from auth_get_userinfo (from external auth)
/// which may have large fields
// define the limits
$limit = array(
'username' => 100,
'idnumber' => 64,
'firstname' => 20,
'lastname' => 20,
'email' => 100,
'icq' => 15,
'phone1' => 20,
'phone2' => 20,
'institution' => 40,
'department' => 30,
'address' => 70,
'city' => 20,
'country' => 2,
'url' => 255,
);
// apply where needed
foreach (array_keys($info) as $key) {
if (!empty($limit[$key])) {
$info[$key] = trim(substr($info[$key],0, $limit[$key]));
}
}
return $info;
}
/**
* Retrieve the guest user object
*
* @uses $CFG
* @return user A {@link $USER} object
*/
function guest_user() {
global $CFG;
if ($newuser = get_record('user', 'username', 'guest')) {
$newuser->loggedin = true;
$newuser->confirmed = 1;
$newuser->site = $CFG->wwwroot;
$newuser->lang = $CFG->lang;
$newuser->lastIP = getremoteaddr();
}
return $newuser;
}
/**
* Given a username and password, this function looks them
* up using the currently selected authentication mechanism,
* and if the authentication is successful, it returns a
* valid $user object from the 'user' table.
*
* Uses auth_ functions from the currently active auth module
*
* @uses $CFG
* @param string $username User's username
* @param string $password User's password
* @return user|flase A {@link $USER} object or false if error
*/
function authenticate_user_login($username, $password) {
global $CFG;
$md5password = md5($password);
// First try to find the user in the database
if (!$user = get_complete_user_data('username', $username)) {
$user->id = 0; // Not a user
$user->auth = $CFG->auth;
}
// Sort out the authentication method we are using.
if (empty($CFG->auth)) {
$CFG->auth = 'manual'; // Default authentication module
}
if (empty($user->auth)) { // For some reason it isn't set yet
if (!empty($user->id) && (isadmin($user->id) || isguest($user->id))) {
$auth = 'manual'; // Always assume these guys are internal
} else {
$auth = $CFG->auth; // Normal users default to site method
}
// update user record from external DB
if ($user->auth != 'manual' && $user->auth != 'email') {
$user = update_user_record($username);
}
} else {
$auth = $user->auth;
}
if (detect_munged_arguments($auth, 0)) { // For safety on the next require
return false;
}
if (!file_exists($CFG->dirroot .'/auth/'. $auth .'/lib.php')) {
$auth = 'manual'; // Can't find auth module, default to internal
}
require_once($CFG->dirroot .'/auth/'. $auth .'/lib.php');
if (auth_user_login($username, $password)) { // Successful authentication
if ($user->id) { // User already exists in database
if (empty($user->auth)) { // For some reason auth isn't set yet
set_field('user', 'auth', $auth, 'username', $username);
}
if ($md5password <> $user->password) { // Update local copy of password for reference
set_field('user', 'password', $md5password, 'username', $username);
}
if (!is_internal_auth()) { // update user record from external DB
$user = update_user_record($username);
}
} else {
$user = create_user_record($username, $password, $auth);
}
if (function_exists('auth_iscreator')) { // Check if the user is a creator
$useriscreator = auth_iscreator($username);
if (!is_null($useriscreator)) {
if ($useriscreator) {
if (! record_exists('user_coursecreators', 'userid', $user->id)) {
$cdata->userid = $user->id;
if (! insert_record('user_coursecreators', $cdata)) {
error('Cannot add user to course creators.');
}
}
} else {
if (record_exists('user_coursecreators', 'userid', $user->id)) {
if (! delete_records('user_coursecreators', 'userid', $user->id)) {
error('Cannot remove user from course creators.');
}
}
}
}
}
return $user;
} else {
add_to_log(0, 'login', 'error', 'index.php', $username);
error_log('[client '.$_SERVER['REMOTE_ADDR']."] $CFG->wwwroot Failed Login: $username ".$_SERVER['HTTP_USER_AGENT']);
return false;
}
}
/**
* Get a complete user record, which includes all the info
* in the user record, as well as membership information
* Intended for setting as $USER session variable
*
* @uses $CFG
* @uses SITEID
* @param string $field The user field to be checked for a given value.
* @param string $value The value to match for $field.
* @return user A {@link $USER} object.
*/
function get_complete_user_data($field, $value) {
global $CFG;
if (!$field || !$value) {
return false;
}
/// Get all the basic user data
if (! $user = get_record_select('user', $field .' = \''. $value .'\' AND deleted <> \'1\'')) {
return false;
}
/// Add membership information
if ($admins = get_records('user_admins', 'userid', $user->id)) {
$user->admin = true;
}
$user->student[SITEID] = isstudent(SITEID, $user->id);
/// Determine enrolments based on current enrolment module
require_once($CFG->dirroot .'/enrol/'. $CFG->enrol .'/enrol.php');
$enrol = new enrolment_plugin();
$enrol->get_student_courses($user);
$enrol->get_teacher_courses($user);
/// Get various settings and preferences
if ($displays = get_records('course_display', 'userid', $user->id)) {
foreach ($displays as $display) {
$user->display[$display->course] = $display->display;
}
}
if ($preferences = get_records('user_preferences', 'userid', $user->id)) {
foreach ($preferences as $preference) {
$user->preference[$preference->name] = $preference->value;
}
}
if ($groups = get_records('groups_members', 'userid', $user->id)) {
foreach ($groups as $groupmember) {
$courseid = get_field('groups', 'courseid', 'id', $groupmember->groupid);
$user->groupmember[$courseid] = $groupmember->groupid;
}
}
/// Rewrite some variables if necessary
if (!empty($user->description)) {
$user->description = true; // No need to cart all of it around
}
if ($user->username == 'guest') {
$user->lang = $CFG->lang; // Guest language always same as site
$user->firstname = get_string('guestuser'); // Name always in current language
$user->lastname = ' ';
}
$user->loggedin = true;
$user->site = $CFG->wwwroot; // for added security, store the site in the session
$user->sesskey = random_string(10);
$user->sessionIP = md5(getremoteaddr()); // Store the current IP in the session
return $user;
}
function get_user_info_from_db($field, $value) { // For backward compatibility
return get_complete_user_data($field, $value);
}
/*
* When logging in, this function is run to set certain preferences
* for the current SESSION
*/
function set_login_session_preferences() {
global $SESSION, $CFG;
$SESSION->justloggedin = true;
unset($SESSION->lang);
unset($SESSION->encoding);
$SESSION->encoding = get_string('thischarset');
// Restore the calendar filters, if saved
if (intval(get_user_preferences('calendar_persistflt', 0))) {
include_once($CFG->dirroot.'/calendar/lib.php');
calendar_set_filters_status(get_user_preferences('calendar_savedflt', 0xff));
}
}
/**
* Enrols (or re-enrols) a student in a given course
*
* @param int $courseid The id of the course that is being viewed
* @param int $userid The id of the user that is being tested against. Set this to 0 if you would just like to test against the currently logged in user.
* @param int $timestart ?
* @param int $timeend ?
* @return boolean
* @todo Finish documenting this function
*/
function enrol_student($userid, $courseid, $timestart=0, $timeend=0, $enrol='') {
global $CFG;
if (!$course = get_record('course', 'id', $courseid)) { // Check course
return false;
}
if (!$user = get_record('user', 'id', $userid)) { // Check user
return false;
}
// enrol the student in any parent meta courses...
if ($parents = get_records('course_meta','child_course',$courseid)) {
foreach ($parents as $parent) {
enrol_student($userid, $parent->parent_course,$timestart,$timeend,$enrol);
}
}
if (empty($enrol)) {
$enrol = $CFG->enrol; // Default current method
}
if ($student = get_record('user_students', 'userid', $userid, 'course', $courseid)) {
$student->timestart = $timestart;
$student->timeend = $timeend;
$student->time = time();
$student->enrol = $enrol;
return update_record('user_students', $student);
} else {
require_once("$CFG->dirroot/mod/forum/lib.php");
forum_add_user($userid, $courseid);
$student->userid = $userid;
$student->course = $courseid;
$student->timestart = $timestart;
$student->timeend = $timeend;
$student->time = time();
$student->enrol = $enrol;
return insert_record('user_students', $student);
}
}
/**
* Unenrols a student from a given course
*
* @param int $courseid The id of the course that is being viewed, if any
* @param int $userid The id of the user that is being tested against.
* @return boolean
*/
function unenrol_student($userid, $courseid=0) {
if ($courseid) {
/// First delete any crucial stuff that might still send mail
if ($forums = get_records('forum', 'course', $courseid)) {
foreach ($forums as $forum) {
delete_records('forum_subscriptions', 'forum', $forum->id, 'userid', $userid);
}
}
if ($groups = get_groups($courseid, $userid)) {
foreach ($groups as $group) {
delete_records('groups_members', 'groupid', $group->id, 'userid', $userid);
}
}
// enrol the student in any parent meta courses...
if ($parents = get_records('course_meta','child_course',$courseid)) {
foreach ($parents as $parent) {
unenrol_student($userid, $parent->parent_course);
}
}
return delete_records('user_students', 'userid', $userid, 'course', $courseid);
} else {
delete_records('forum_subscriptions', 'userid', $userid);
delete_records('groups_members', 'userid', $userid);
return delete_records('user_students', 'userid', $userid);
}
}
/**
* Add a teacher to a given course
*
* @uses $USER
* @param int $courseid The id of the course that is being viewed, if any
* @param int $userid The id of the user that is being tested against. Set this to 0 if you would just like to test against the currently logged in user.
* @param int $editall ?
* @param string $role ?
* @param int $timestart ?
* @param int $timeend ?
* @return boolean
* @todo Finish documenting this function
*/
function add_teacher($userid, $courseid, $editall=1, $role='', $timestart=0, $timeend=0, $enrol='manual') {
global $CFG;
if ($teacher = get_record('user_teachers', 'userid', $userid, 'course', $courseid)) {
$newteacher = NULL;
$newteacher->id = $teacher->id;
$newteacher->editall = $editall;
$newteacher->enrol = $enrol;
if ($role) {
$newteacher->role = $role;
}
if ($timestart) {
$newteacher->timestart = $timestart;
}
if ($timeend) {
$newteacher->timeend = $timeend;
}
return update_record('user_teachers', $newteacher);
}
if (!record_exists('user', 'id', $userid)) {
return false; // no such user
}
if (!record_exists('course', 'id', $courseid)) {
return false; // no such course
}
$teacher = NULL;
$teacher->userid = $userid;
$teacher->course = $courseid;
$teacher->editall = $editall;
$teacher->role = $role;
$teacher->timemodified = time();
$newteacher->timestart = $timestart;
$newteacher->timeend = $timeend;
if ($student = get_record('user_students', 'userid', $userid, 'course', $courseid)) {
$teacher->timestart = $student->timestart;
$teacher->timeend = $student->timeend;
$teacher->timeaccess = $student->timeaccess;
}
if (record_exists('user_teachers', 'course', $courseid)) {
$teacher->authority = 2;
} else {
$teacher->authority = 1;
}
delete_records('user_students', 'userid', $userid, 'course', $courseid); // Unenrol as student
/// Add forum subscriptions for new users
require_once('../mod/forum/lib.php');
forum_add_user($userid, $courseid);
return insert_record('user_teachers', $teacher);
}
/**
* Removes a teacher from a given course (or ALL courses)
* Does not delete the user account
*
* @param int $courseid The id of the course that is being viewed, if any
* @param int $userid The id of the user that is being tested against.
* @return boolean
*/
function remove_teacher($userid, $courseid=0) {
if ($courseid) {
/// First delete any crucial stuff that might still send mail
if ($forums = get_records('forum', 'course', $courseid)) {
foreach ($forums as $forum) {
delete_records('forum_subscriptions', 'forum', $forum->id, 'userid', $userid);
}
}
/// Next if the teacher is not registered as a student, but is
/// a member of a group, remove them from the group.
if (!isstudent($courseid, $userid)) {
if ($groups = get_groups($courseid, $userid)) {
foreach ($groups as $group) {
delete_records('groups_members', 'groupid', $group->id, 'userid', $userid);
}
}
}
return delete_records('user_teachers', 'userid', $userid, 'course', $courseid);
} else {
delete_records('forum_subscriptions', 'userid', $userid);
return delete_records('user_teachers', 'userid', $userid);
}
}
/**
* Add a creator to the site
*
* @param int $userid The id of the user that is being tested against.
* @return boolean
*/
function add_creator($userid) {
if (!record_exists('user_admins', 'userid', $userid)) {
if (record_exists('user', 'id', $userid)) {
$creator->userid = $userid;
return insert_record('user_coursecreators', $creator);
}
return false;
}
return true;
}
/**
* Remove a creator from a site
*
* @uses $db
* @param int $userid The id of the user that is being tested against.
* @return boolean
*/
function remove_creator($userid) {
global $db;
return delete_records('user_coursecreators', 'userid', $userid);
}
/**
* Add an admin to a site
*
* @uses SITEID
* @param int $userid The id of the user that is being tested against.
* @return boolean
*/
function add_admin($userid) {
if (!record_exists('user_admins', 'userid', $userid)) {
if (record_exists('user', 'id', $userid)) {
$admin->userid = $userid;
// any admin is also a teacher on the site course
if (!record_exists('user_teachers', 'course', SITEID, 'userid', $userid)) {
if (!add_teacher($userid, SITEID)) {
return false;
}
}
return insert_record('user_admins', $admin);
}
return false;
}
return true;
}
/**
* Removes an admin from a site
*
* @uses $db
* @uses SITEID
* @param int $userid The id of the user that is being tested against.
* @return boolean
*/
function remove_admin($userid) {
global $db;
// remove also from the list of site teachers
remove_teacher($userid, SITEID);
return delete_records('user_admins', 'userid', $userid);
}
/**
* Clear a course out completely, deleting all content
* but don't delete the course itself
*
* @uses $USER
* @uses $SESSION
* @uses $CFG
* @param int $courseid The id of the course that is being viewed
* @param boolean $showfeedback Set this to false to suppress notifications from being printed as the functions performs its steps.
* @return boolean
*/
function remove_course_contents($courseid, $showfeedback=true) {
global $CFG, $USER, $SESSION;
$result = true;
if (! $course = get_record('course', 'id', $courseid)) {
error('Course ID was incorrect (can\'t find it)');
}
$strdeleted = get_string('deleted');
// First delete every instance of every module
if ($allmods = get_records('modules') ) {
foreach ($allmods as $mod) {
$modname = $mod->name;
$modfile = $CFG->dirroot .'/mod/'. $modname .'/lib.php';
$moddelete = $modname .'_delete_instance'; // Delete everything connected to an instance
$moddeletecourse = $modname .'_delete_course'; // Delete other stray stuff (uncommon)
$count=0;
if (file_exists($modfile)) {
include_once($modfile);
if (function_exists($moddelete)) {
if ($instances = get_records($modname, 'course', $course->id)) {
foreach ($instances as $instance) {
if ($moddelete($instance->id)) {
$count++;
} else {
notify('Could not delete '. $modname .' instance '. $instance->id .' ('. format_string($instance->name) .')');
$result = false;
}
}
}
} else {
notify('Function '. $moddelete() .'doesn\'t exist!');
$result = false;
}
if (function_exists($moddeletecourse)) {
$moddeletecourse($course);
}
}
if ($showfeedback) {
notify($strdeleted .' '. $count .' x '. $modname);
}
}
} else {
error('No modules are installed!');
}
// Delete course blocks
if (delete_records('block_instance', 'pagetype', PAGE_COURSE_VIEW, 'pageid', $course->id)) {
if ($showfeedback) {
notify($strdeleted .' block_instance');
}
} else {
$result = false;
}
// Delete any user stuff
if (delete_records('user_students', 'course', $course->id)) {
if ($showfeedback) {
notify($strdeleted .' user_students');
}
} else {
$result = false;
}
if (delete_records('user_teachers', 'course', $course->id)) {
if ($showfeedback) {
notify($strdeleted .' user_teachers');
}
} else {
$result = false;
}
// Delete any groups
if ($groups = get_records('groups', 'courseid', $course->id)) {
foreach ($groups as $group) {
if (delete_records('groups_members', 'groupid', $group->id)) {
if ($showfeedback) {
notify($strdeleted .' groups_members');
}
} else {
$result = false;
}
if (delete_records('groups', 'id', $group->id)) {
if ($showfeedback) {
notify($strdeleted .' groups');
}
} else {
$result = false;
}
}
}
// Delete events
if (delete_records('event', 'courseid', $course->id)) {
if ($showfeedback) {
notify($strdeleted .' event');
}
} else {
$result = false;
}
// Delete logs
if (delete_records('log', 'course', $course->id)) {
if ($showfeedback) {
notify($strdeleted .' log');
}
} else {
$result = false;
}
// Delete any course stuff
if (delete_records('course_sections', 'course', $course->id)) {
if ($showfeedback) {
notify($strdeleted .' course_sections');
}
} else {
$result = false;
}
if (delete_records('course_modules', 'course', $course->id)) {
if ($showfeedback) {
notify($strdeleted .' course_modules');
}
} else {
$result = false;
}
// Delete gradebook stuff
if (delete_records("grade_category", "course", $course->id)) {
if ($showfeedback) {
notify("$strdeleted grade categories");
} else {
$result = false;
}
}
if (delete_records("grade_exceptions", "course", $course->id)) {
if ($showfeedback) {
notify("$strdeleted grade exceptions");
} else {
$result = false;
}
}
if (delete_records("grade_item", "course", $course->id)) {
if ($showfeedback) {
notify("$strdeleted grade items");
} else {
$result = false;
}
}
if (delete_records("grade_letter", "course", $course->id)) {
if ($showfeedback) {
notify("$strdeleted grade letters");
} else {
$result = false;
}
}
if (delete_records("grade_preferences", "course", $course->id)) {
if ($showfeedback) {
notify("$strdeleted grade preferences");
} else {
$result = false;
}
}
if ($course->metacourse) {
delete_records("course_meta","parent_course",$course->id);
sync_metacourse($course->id); // have to do it here so the enrolments get nuked. sync_metacourses won't find it without the id.
if ($showfeedback) {
notify("$strdeleted course_meta");
}
} else {
if ($parents = get_records("course_meta","child_course",$course->id)) {
foreach ($parents as $parent) {
remove_from_metacourse($parent->parent_course,$parent->child_course); // this will do the unenrolments as well.
}
if ($showfeedback) {
notify("$strdeleted course_meta");
}
}
}
return $result;
}
/**
* This function will empty a course of USER data as much as
/// possible. It will retain the activities and the structure
/// of the course.
*
* @uses $USER
* @uses $SESSION
* @uses $CFG
* @param int $courseid The id of the course that is being viewed
* @param boolean $showfeedback Set this to false to suppress notifications from being printed as the functions performs its steps.
* @param boolean $removestudents ?
* @param boolean $removeteachers ?
* @param boolean $removegroups ?
* @param boolean $removeevents ?
* @param boolean $removelogs ?
* @return boolean
* @todo Finish documenting this function
*/
function remove_course_userdata($courseid, $showfeedback=true,
$removestudents=true, $removeteachers=false, $removegroups=true,
$removeevents=true, $removelogs=false) {
global $CFG, $USER, $SESSION;
$result = true;
if (! $course = get_record('course', 'id', $courseid)) {
error('Course ID was incorrect (can\'t find it)');