';
echo '';
print_footer('none');
die();
} else {
$strdatabasesuccess = get_string("databasesuccess");
$navigation = build_navigation(array(array('name'=>$strdatabasesuccess, 'link'=>null, 'type'=>'misc')));
print_header($strdatabasechecking, $stradministration, $navigation,
"", upgrade_get_javascript(), false, " ", " ");
/// return to original debugging level
$CFG->debug = $origdebug;
error_reporting($CFG->debug);
upgrade_log_start();
/// Upgrade current language pack if we can
if (empty($CFG->skiplangupgrade)) {
upgrade_language_pack();
}
print_heading($strdatabasechecking);
$DB->set_debug(true);
/// Launch the old main upgrade (if exists)
$status = true;
if (function_exists('main_upgrade')) {
$status = main_upgrade($CFG->version);
}
/// If succesful and exists launch the new main upgrade (XMLDB), called xmldb_main_upgrade
if ($status && function_exists('xmldb_main_upgrade')) {
$status = xmldb_main_upgrade($CFG->version);
}
$DB->set_debug(false);
/// If successful, continue upgrading roles and setting everything properly
if ($status) {
if (!update_capabilities()) {
print_error('cannotupgradecapabilities', 'debug');
}
// Update core events
events_update_definition();
// Update core message providers
message_update_providers();
message_update_providers('message');
if (set_config("version", $version)) {
remove_dir($CFG->dataroot . '/cache', true); // flush cache
notify($strdatabasesuccess, "green");
if ($unittest) {
print_continue("index.php?testtablesok=1");
} else {
print_continue("upgradesettings.php");
}
print_footer('none');
exit;
} else {
print_error('cannotupdateversion', 'debug');
}
/// Main upgrade not success
} else {
notify('Main Upgrade failed! See lib/db/upgrade.php');
print_continue('index.php?confirmupgrade=1&confirmrelease=1&confirmplugincheck=1');
print_footer('none');
die;
}
upgrade_log_finish();
}
} else if ($version < $CFG->version) {
upgrade_log_start();
notify("WARNING!!! The code you are using is OLDER than the version that made these databases!");
upgrade_log_finish();
}
/// Updated human-readable release version if necessary
if ($release <> $CFG->release) { // Update the release version
if (!set_config("release", $release)) {
print_error("cannotupdaterelease", 'debug');
}
}
// Turn off xmlstrictheaders during upgrade.
$origxmlstrictheaders = !empty($CFG->xmlstrictheaders);
$CFG->xmlstrictheaders = false;
/// Find and check all main modules and load them up or upgrade them if necessary
/// first old *.php update and then the new upgrade.php script
upgrade_activity_modules($return_url); // Return here afterwards
/// Check all questiontype plugins and upgrade if necessary
/// first old *.php update and then the new upgrade.php script
/// It is important that this is done AFTER the quiz module has been upgraded
upgrade_plugins('qtype', 'question/type', $return_url); // Return here afterwards
/// Upgrade backup/restore system if necessary
/// first old *.php update and then the new upgrade.php script
require_once("$CFG->dirroot/backup/lib.php");
upgrade_backup_db($return_url); // Return here afterwards
/// Upgrade blocks system if necessary
/// first old *.php update and then the new upgrade.php script
require_once("$CFG->dirroot/lib/blocklib.php");
upgrade_blocks_db($return_url); // Return here afterwards
/// Check all blocks and load (or upgrade them if necessary)
/// first old *.php update and then the new upgrade.php script
upgrade_blocks_plugins($return_url); // Return here afterwards
/// Check all enrolment plugins and upgrade if necessary
/// first old *.php update and then the new upgrade.php script
upgrade_plugins('enrol', 'enrol', $return_url); // Return here afterwards
/// Check all auth plugins and upgrade if necessary
upgrade_plugins('auth','auth',$return_url);
/// Check all course formats and upgrade if necessary
upgrade_plugins('format','course/format',$return_url);
/// Check for local database customisations
/// first old *.php update and then the new upgrade.php script
require_once("$CFG->dirroot/lib/locallib.php");
upgrade_local_db($return_url); // Return here afterwards
/// Check for changes to RPC functions
require_once("$CFG->dirroot/$CFG->admin/mnet/adminlib.php");
upgrade_RPC_functions($return_url); // Return here afterwards
/// Upgrade all plugins for gradebook
upgrade_plugins('gradeexport', 'grade/export', $return_url);
upgrade_plugins('gradeimport', 'grade/import', $return_url);
upgrade_plugins('gradereport', 'grade/report', $return_url);
/// Check all message output plugins and upgrade if necessary
upgrade_plugins('message','message/output',$return_url);
/// Check all course report plugins and upgrade if necessary
upgrade_plugins('coursereport', 'course/report', $return_url);
/// Check all admin report plugins and upgrade if necessary
upgrade_plugins('report', $CFG->admin.'/report', $return_url);
/// Check all quiz report plugins and upgrade if necessary
upgrade_plugins('quizreport', 'mod/quiz/report', $return_url);
/// Check all portfolio plugins and upgrade if necessary
upgrade_plugins('portfolio', 'portfolio/type', $return_url);
/// Check all progress tracker plugins and upgrade if necessary
upgrade_plugins('trackerexport', 'tracker/export', $return_url);
upgrade_plugins('trackerimport', 'tracker/import', $return_url);
upgrade_plugins('trackerreport', 'tracker/report', $return_url);
/// just make sure upgrade logging is properly terminated
upgrade_log_finish();
unset($SESSION->installautopilot);
// Turn xmlstrictheaders back on now.
$CFG->xmlstrictheaders = $origxmlstrictheaders;
if (!$unittest) {
/// Set up the blank site - to be customized later at the end of install.
if (! $site = get_site()) {
build_site_course();
redirect("index.php?continuesetuptesttables=$continuesetuptesttables&upgradetesttables=$upgradetesttables");
}
// initialise default blocks on admin and site page if needed
if (empty($CFG->adminblocks_initialised)) {
require_once("$CFG->dirroot/$CFG->admin/pagelib.php");
require_once($CFG->libdir.'/blocklib.php');
page_map_class(PAGE_ADMIN, 'page_admin');
$page = page_create_object(PAGE_ADMIN, 0); // there must be some id number
blocks_repopulate_page($page);
//add admin_tree block to site if not already present
if ($admintree = $DB->get_record('block', array('name'=>'admin_tree'))) {
$page = page_create_object(PAGE_COURSE_VIEW, SITEID);
$pageblocks=blocks_get_by_page($page);
blocks_execute_action($page, $pageblocks, 'add', (int)$admintree->id, false, false);
if ($admintreeinstance = $DB->get_record('block_instance', array('pagetype'=>$page->type, 'pageid'=>SITEID, 'blockid'=>$admintree->id))) {
$pageblocks=blocks_get_by_page($page);
blocks_execute_action($page, $pageblocks, 'moveleft', $admintreeinstance, false, false);
}
}
set_config('adminblocks_initialised', 1);
}
/// Define the unique site ID code if it isn't already
if (empty($CFG->siteidentifier)) { // Unique site identification code
set_config('siteidentifier', random_string(32).$_SERVER['HTTP_HOST']);
}
/// ugly hack - if mnet is not initialised include the mnet lib, it adds needed mnet records and configures config options
/// we should not do such crazy stuff in lib functions!!!
if (empty($CFG->mnet_localhost_id)) {
require_once $CFG->dirroot.'/mnet/lib.php';
}
/// Check if the guest user exists. If not, create one.
if (!$DB->record_exists('user', array('username'=>'guest'))) {
if (! $guest = create_guest_record()) {
notify("Could not create guest user record !!!");
}
}
/// Set up the admin user
if (empty($CFG->rolesactive)) {
build_context_path(); // just in case - should not be needed
create_admin_user();
}
} else {
build_site_course();
create_guest_record();
create_admin_user();
redirect($return_url);
}
}
function build_site_course() {
global $CFG, $DB, $unittest;
$continuesetuptesttables= optional_param('continuesetuptesttables', $unittest, PARAM_BOOL);
// We are about to create the site "course"
require_once($CFG->libdir.'/blocklib.php');
$newsite = new object();
$newsite->fullname = "";
$newsite->shortname = "";
$newsite->summary = NULL;
$newsite->newsitems = 3;
$newsite->numsections = 0;
$newsite->category = 0;
$newsite->format = 'site'; // Only for this course
$newsite->teacher = get_string("defaultcourseteacher");
$newsite->teachers = get_string("defaultcourseteachers");
$newsite->student = get_string("defaultcoursestudent");
$newsite->students = get_string("defaultcoursestudents");
$newsite->timemodified = time();
if (!$newid = $DB->insert_record('course', $newsite)) {
print_error('cannotsetupsite', 'error');
}
// make sure course context exists
get_context_instance(CONTEXT_COURSE, $newid);
// Site created, add blocks for it
$page = page_create_object(PAGE_COURSE_VIEW, $newid);
blocks_repopulate_page($page); // Return value not checked because you can always edit later
// create default course category
$cat = get_course_category();
}
/**
* Upgrade savepoint, marks end of each upgrade block.
* It stores new main version, resets upgrade timeout
* and abort upgrade if user cancels page loading.
*
* Please do not make large upgrade blocks with lots of operations,
* for example when adding tables keep only one table operation per block.
*
* @param bool $result false if upgrade step failed, true if completed
* @param string or float $version main version
* @return void
*/
function upgrade_main_savepoint($result, $version) {
global $CFG;
if ($result) {
if ($CFG->version >= $version) {
// something really wrong is going on in main upgrade script
print_error('cannotdowngrade', 'debug', '', (object)array('oldversion'=>$CFG->version, 'newversion'=>$version));
}
set_config('version', $version);
} else {
notify ("Upgrade savepoint: Error during main upgrade to version $version");
}
// reset upgrade timeout to default
upgrade_set_timeout();
// this is a safe place to stop upgrades if user aborts page loading
if (connection_aborted()) {
die;
}
}
/**
* Module upgrade savepoint, marks end of module upgrade blocks
* It stores module version, resets upgrade timeout
* and abort upgrade if usercancels page loading.
*
* @param bool $result false if upgrade step failed, true if completed
* @param string or float $version main version
* @return void
*/
function upgrade_mod_savepoint($result, $version, $modname) {
global $DB;
if (!$module = $DB->get_record('modules', array('name'=>$modname))) {
print_error('modulenotexist', 'debug', '', $modname);
}
if ($result) {
if ($module->version >= $version) {
// something really wrong is going on in upgrade script
print_error('cannotdowngrade', 'debug', '', (object)array('oldversion'=>$module->version, 'newversion'=>$version));
}
$module->version = $version;
$DB->update_record('modules', $module);
} else {
notify ("Upgrade savepoint: Error during mod upgrade to version $version");
}
// reset upgrade timeout to default
upgrade_set_timeout();
// this is a safe place to stop upgrades if user aborts page loading
if (connection_aborted()) {
die;
}
}
function upgrade_blocks_savepoint($result, $version, $blockname) {
global $DB;
if (!$block = $DB->get_record('block', array('name'=>$blockname))) {
print_error('blocknotexist', 'debug', '', $blockname);
}
if ($result) {
if ($block->version >= $version) {
// something really wrong is going on in upgrade script
print_error('cannotdowngrade', 'debug', '', (object)array('oldversion'=>$block->version, 'newversion'=>$version));
}
$block->version = $version;
$DB->update_record('block', $block);
} else {
notify ("Upgrade savepoint: Error during mod upgrade to version $version");
}
// reset upgrade timeout to default
upgrade_set_timeout();
// this is a safe place to stop upgrades if user aborts page loading
if (connection_aborted()) {
die;
}
}
function upgrade_plugin_savepoint($result, $version, $type, $dir) {
if ($result) {
$fullname = $type . '_' . $dir;
$installedversion = get_config($fullname, 'version');
if ($installedversion >= $version) {
// Something really wrong is going on in the upgrade script
$a = new stdClass;
$a->oldversion = $installedversion;
$a->newversion = $version;
print_error('cannotdowngrade', 'debug', '', $a);
}
set_config('version', $version, $fullname);
} else {
notify ("Upgrade savepoint: Error during mod upgrade to version $version");
}
// Reset upgrade timeout to default
upgrade_set_timeout();
// This is a safe place to stop upgrades if user aborts page loading
if (connection_aborted()) {
die;
}
}
function upgrade_backup_savepoint($result, $version) {
//TODO
}
/**
* Delete all plugin tables
* @name string name of plugin, used as table prefix
* @file string path to install.xml file
* @feedback boolean
*/
function drop_plugin_tables($name, $file, $feedback=true) {
global $CFG, $DB;
// first try normal delete
if (file_exists($file) and $DB->get_manager()->delete_tables_from_xmldb_file($file)) {
return true;
}
// then try to find all tables that start with name and are not in any xml file
$used_tables = get_used_table_names();
$tables = $DB->get_tables();
/// Iterate over, fixing id fields as necessary
foreach ($tables as $table) {
if (in_array($table, $used_tables)) {
continue;
}
if (strpos($table, $name) !== 0) {
continue;
}
// found orphan table --> delete it
if ($DB->get_manager()->table_exists($table)) {
$xmldb_table = new xmldb_table($table);
$DB->get_manager()->drop_table($xmldb_table);
}
}
return true;
}
/**
* Returns names of all known tables == tables that moodle knowns about.
* @return array of lowercase table names
*/
function get_used_table_names() {
$table_names = array();
$dbdirs = get_db_directories();
foreach ($dbdirs as $dbdir) {
$file = $dbdir.'/install.xml';
$xmldb_file = new xmldb_file($file);
if (!$xmldb_file->fileExists()) {
continue;
}
$loaded = $xmldb_file->loadXMLStructure();
$structure =& $xmldb_file->getStructure();
if ($loaded and $tables = $structure->getTables()) {
foreach($tables as $table) {
$table_names[] = strtolower($table->name);
}
}
}
return $table_names;
}
/**
* Returns list of all directories where we expect install.xml files
* @return array of paths
*/
function get_db_directories() {
global $CFG;
$dbdirs = array();
/// First, the main one (lib/db)
$dbdirs[] = $CFG->libdir.'/db';
/// Now, activity modules (mod/xxx/db)
if ($plugins = get_list_of_plugins('mod')) {
foreach ($plugins as $plugin) {
$dbdirs[] = $CFG->dirroot.'/mod/'.$plugin.'/db';
}
}
/// Now, assignment submodules (mod/assignment/type/xxx/db)
if ($plugins = get_list_of_plugins('mod/assignment/type')) {
foreach ($plugins as $plugin) {
$dbdirs[] = $CFG->dirroot.'/mod/assignment/type/'.$plugin.'/db';
}
}
/// Now, question types (question/type/xxx/db)
if ($plugins = get_list_of_plugins('question/type')) {
foreach ($plugins as $plugin) {
$dbdirs[] = $CFG->dirroot.'/question/type/'.$plugin.'/db';
}
}
/// Now, backup/restore stuff (backup/db)
$dbdirs[] = $CFG->dirroot.'/backup/db';
/// Now, block system stuff (blocks/db)
$dbdirs[] = $CFG->dirroot.'/blocks/db';
/// Now, blocks (blocks/xxx/db)
if ($plugins = get_list_of_plugins('blocks', 'db')) {
foreach ($plugins as $plugin) {
$dbdirs[] = $CFG->dirroot.'/blocks/'.$plugin.'/db';
}
}
/// Now, course formats (course/format/xxx/db)
if ($plugins = get_list_of_plugins('course/format', 'db')) {
foreach ($plugins as $plugin) {
$dbdirs[] = $CFG->dirroot.'/course/format/'.$plugin.'/db';
}
}
/// Now, enrolment plugins (enrol/xxx/db)
if ($plugins = get_list_of_plugins('enrol', 'db')) {
foreach ($plugins as $plugin) {
$dbdirs[] = $CFG->dirroot.'/enrol/'.$plugin.'/db';
}
}
/// Now admin report plugins (admin/report/xxx/db)
if ($plugins = get_list_of_plugins($CFG->admin.'/report', 'db')) {
foreach ($plugins as $plugin) {
$dbdirs[] = $CFG->dirroot.'/'.$CFG->admin.'/report/'.$plugin.'/db';
}
}
/// Now quiz report plugins (mod/quiz/report/xxx/db)
if ($plugins = get_list_of_plugins('mod/quiz/report', 'db')) {
foreach ($plugins as $plugin) {
$dbdirs[] = $CFG->dirroot.'/mod/quiz/report/'.$plugin.'/db';
}
}
if ($plugins = get_list_of_plugins('portfolio/type', 'db')) {
foreach ($plugins as $plugin) {
$dbdirs[] = $CFG->dirroot . '/portfolio/type/' . $plugin . '/db';
}
}
/// Local database changes, if the local folder exists.
if (file_exists($CFG->dirroot . '/local')) {
$dbdirs[] = $CFG->dirroot.'/local/db';
}
return $dbdirs;
}
/**
* Upgrade plugins
*
* @uses $CFG
* @param string $type The type of plugins that should be updated (e.g. 'enrol', 'qtype')
* @param string $dir The directory where the plugins are located (e.g. 'question/questiontypes')
* @param string $return The url to prompt the user to continue to
*/
function upgrade_plugins($type, $dir, $return) {
global $CFG, $interactive, $DB;
/// Let's know if the header has been printed, so the funcion is being called embedded in an outer page
$embedded = defined('HEADER_PRINTED');
$plugs = get_list_of_plugins($dir);
$updated_plugins = false;
$strpluginsetup = get_string('pluginsetup');
foreach ($plugs as $plug) {
$fullplug = $CFG->dirroot .'/'.$dir.'/'. $plug;
unset($plugin);
if (is_readable($fullplug .'/version.php')) {
include_once($fullplug .'/version.php'); // defines $plugin with version etc
} else {
continue; // Nothing to do.
}
$newupgrade = false;
if (is_readable($fullplug . '/db/upgrade.php')) {
include_once($fullplug . '/db/upgrade.php'); // defines new upgrading function
$newupgrade = true;
}
if (!isset($plugin)) {
continue;
}
if (!empty($plugin->requires)) {
if ($plugin->requires > $CFG->version) {
$info = new object();
$info->pluginname = $plug;
$info->pluginversion = $plugin->version;
$info->currentmoodle = $CFG->version;
$info->requiremoodle = $plugin->requires;
if (!$updated_plugins && !$embedded) {
print_header($strpluginsetup, $strpluginsetup,
build_navigation(array(array('name' => $strpluginsetup, 'link' => null, 'type' => 'misc'))), '',
upgrade_get_javascript(), false, ' ', ' ');
}
upgrade_log_start();
notify(get_string('pluginrequirementsnotmet', 'error', $info));
$updated_plugins = true;
continue;
}
}
$plugin->name = $plug; // The name MUST match the directory
$plugin->fullname = $type.'_'.$plug; // The name MUST match the directory
$installedversion = get_config($plugin->fullname, 'version');
if ($installedversion === false) {
set_config('version', 0, $plugin->fullname);
}
if ($installedversion == $plugin->version) {
// do nothing
} else if ($installedversion < $plugin->version) {
if (!$updated_plugins && !$embedded) {
print_header($strpluginsetup, $strpluginsetup,
build_navigation(array(array('name' => $strpluginsetup, 'link' => null, 'type' => 'misc'))), '',
upgrade_get_javascript(), false, ' ', ' ');
}
$updated_plugins = true;
upgrade_log_start();
print_heading($dir.'/'. $plugin->name .' plugin needs upgrading');
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE ) {
$DB->set_debug(true);
}
@set_time_limit(0); // To allow slow databases to complete the long SQL
if ($installedversion == 0) { // It's a new install of this plugin
/// Both old .sql files and new install.xml are supported
/// but we priorize install.xml (XMLDB) if present
if (file_exists($fullplug . '/db/install.xml')) {
$DB->get_manager()->install_from_xmldb_file($fullplug . '/db/install.xml'); //New method
}
$status = true;
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE ) {
$DB->set_debug(false);
}
/// Continue with the instalation, roles and other stuff
if ($status) {
/// OK so far, now update the plugins record
set_config('version', $plugin->version, $plugin->fullname);
/// Install capabilities
if (!update_capabilities($type.'/'.$plug)) {
print_error('cannotsetupcapforplugin', '', '', $plugin->name);
}
/// Install events
events_update_definition($type.'/'.$plug);
/// Install message providers
message_update_providers($type.'/'.$plug);
/// Run local install function if there is one
if (is_readable($fullplug . '/lib.php')) {
include_once($fullplug . '/lib.php');
$installfunction = $plugin->name.'_install';
if (function_exists($installfunction)) {
if (! $installfunction() ) {
notify('Encountered a problem running install function for '.$module->name.'!');
}
}
}
notify(get_string('modulesuccess', '', $plugin->name), 'notifysuccess');
} else {
notify('Installing '. $plugin->name .' FAILED!');
}
} else { // Upgrade existing install
/// Run the upgrade function for the plugin.
$newupgrade_function = 'xmldb_' .$plugin->fullname .'_upgrade';
$newupgrade_status = true;
if ($newupgrade && function_exists($newupgrade_function)) {
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE ) {
$DB->set_debug(true);
}
$newupgrade_status = $newupgrade_function($installedversion);
} else if ($newupgrade) {
notify ('Upgrade function ' . $newupgrade_function . ' was not available in ' .
$fullplug . '/db/upgrade.php');
}
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE ) {
$DB->set_debug(false);
}
/// Now analyze upgrade results
if ($newupgrade_status) { // No upgrading failed
/// OK so far, now update the plugins record
set_config('version', $plugin->version, $plugin->fullname);
if (!update_capabilities($type.'/'.$plug)) {
print_error('cannotupdateplugincap', '', '', $plugin->name);
}
/// Update events
events_update_definition($type.'/'.$plug);
/// Update message providers
message_update_providers($type.'/'.$plug);
notify(get_string('modulesuccess', '', $plugin->name), 'notifysuccess');
} else {
notify('Upgrading '. $plugin->name .' from '. $installedversion .' to '. $plugin->version .' FAILED!');
}
}
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE ) {
echo '';
}
} else {
upgrade_log_start();
print_error('cannotdowngrade', 'debug', '', (object)array('oldversion'=>$installedversion, 'newversion'=>$plugin->version));
}
}
upgrade_log_finish();
if ($updated_plugins && !$embedded) {
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE ) {
print_continue($return);
print_footer('none');
die;
} else if (CLI_UPGRADE && ($interactive > CLI_SEMI )) {
console_write(STDOUT,'askcontinue');
if (read_boolean()){
return ;
} else {
console_write(STDERR,'','',false);
}
}
}
}
/**
* Find and check all modules and load them up or upgrade them if necessary
*
* @uses $CFG
* @param string $return The url to prompt the user to continue to
* @todo Finish documenting this function
*/
function upgrade_activity_modules($return) {
global $CFG, $interactive, $DB, $unittest;
if (!$mods = get_list_of_plugins('mod') ) {
print_error('nomodules', 'debug');
}
$updated_modules = false;
$strmodulesetup = get_string('modulesetup');
foreach ($mods as $mod) {
if ($mod == 'NEWMODULE') { // Someone has unzipped the template, ignore it
continue;
}
$fullmod = $CFG->dirroot .'/mod/'. $mod;
unset($module);
if ( is_readable($fullmod .'/version.php')) {
include_once($fullmod .'/version.php'); // defines $module with version etc
} else {
notify('Module '. $mod .': '. $fullmod .'/version.php was not readable');
continue;
}
$newupgrade = false;
if ( is_readable($fullmod . '/db/upgrade.php')) {
include_once($fullmod . '/db/upgrade.php'); // defines new upgrading function
$newupgrade = true;
}
if (!isset($module)) {
continue;
}
if (!empty($module->requires)) {
if ($module->requires > $CFG->version) {
$info = new object();
$info->modulename = $mod;
$info->moduleversion = $module->version;
$info->currentmoodle = $CFG->version;
$info->requiremoodle = $module->requires;
if (!$updated_modules) {
print_header($strmodulesetup, $strmodulesetup,
build_navigation(array(array('name' => $strmodulesetup, 'link' => null, 'type' => 'misc'))), '',
upgrade_get_javascript(), false, ' ', ' ');
}
upgrade_log_start();
notify(get_string('modulerequirementsnotmet', 'error', $info));
$updated_modules = true;
continue;
}
}
$module->name = $mod; // The name MUST match the directory
include_once($fullmod.'/lib.php'); // defines upgrading and/or installing functions
if ($currmodule = $DB->get_record('modules', array('name'=>$module->name))) {
if ($currmodule->version == $module->version) {
// do nothing
} else if ($currmodule->version < $module->version) {
/// If versions say that we need to upgrade but no upgrade files are available, notify and continue
if (!$newupgrade) {
notify('Upgrade file ' . $mod . ': ' . $fullmod . '/db/upgrade.php is not readable');
continue;
}
if (!$updated_modules) {
print_header($strmodulesetup, $strmodulesetup,
build_navigation(array(array('name' => $strmodulesetup, 'link' => null, 'type' => 'misc'))), '',
upgrade_get_javascript(), false, ' ', ' ');
}
upgrade_log_start();
print_heading($module->name .' module needs upgrading');
/// Run de old and new upgrade functions for the module
$newupgrade_function = 'xmldb_' . $module->name . '_upgrade';
/// Then, the new function if exists and the old one was ok
$newupgrade_status = true;
if ($newupgrade && function_exists($newupgrade_function)) {
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE ) {
$DB->set_debug(true);
}
$newupgrade_status = $newupgrade_function($currmodule->version, $module);
} else if ($newupgrade) {
notify ('Upgrade function ' . $newupgrade_function . ' was not available in ' .
$mod . ': ' . $fullmod . '/db/upgrade.php');
}
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE ) {
$DB->set_debug(false);
}
/// Now analyze upgrade results
if ($newupgrade_status) { // No upgrading failed
// OK so far, now update the modules record
$module->id = $currmodule->id;
if (!$DB->update_record('modules', $module)) {
print_error('cannotupdatemod', '', '', $module->name);
}
remove_dir($CFG->dataroot . '/cache', true); // flush cache
notify(get_string('modulesuccess', '', $module->name), 'notifysuccess');
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE) {
echo '';
}
} else {
notify('Upgrading '. $module->name .' from '. $currmodule->version .' to '. $module->version .' FAILED!');
}
/// Update the capabilities table?
if (!update_capabilities('mod/'.$module->name)) {
print_error('cannotupdatemodcap', '', '', $module->name);
}
/// Update events
events_update_definition('mod/'.$module->name);
/// Update message providers
message_update_providers('mod/'.$module->name);
$updated_modules = true;
} else {
upgrade_log_start();
print_error('cannotdowngrade', 'debug', '', (object)array('oldversion'=>$currmodule->version, 'newversion'=>$module->version));
}
} else { // module not installed yet, so install it
if (!$updated_modules) {
if ((!defined('CLI_UPGRADE') || !CLI_UPGRADE) && !$unittest) {
print_header($strmodulesetup, $strmodulesetup,
build_navigation(array(array('name' => $strmodulesetup, 'link' => null, 'type' => 'misc'))), '',
upgrade_get_javascript(), false, ' ', ' ');
}
}
upgrade_log_start();
print_heading($module->name);
$updated_modules = true;
// To avoid unnecessary output from the SQL queries in the CLI version
if (!defined('CLI_UPGRADE')|| !CLI_UPGRADE ) {
$DB->set_debug(true);
}
@set_time_limit(0); // To allow slow databases to complete the long SQL
/// Both old .sql files and new install.xml are supported
/// but we priorize install.xml (XMLDB) if present
if (file_exists($fullmod . '/db/install.xml')) {
$DB->get_manager()->install_from_xmldb_file($fullmod . '/db/install.xml'); //New method
$status = true;
}
if (!defined('CLI_UPGRADE') || !CLI_UPGRADE ) {
$DB->set_debug(false);
}
/// Continue with the installation, roles and other stuff
if ($status) {
if ($module->id = $DB->insert_record('modules', $module)) {
/// Capabilities
if (!update_capabilities('mod/'.$module->name)) {
print_error('cannotsetupcapformod', '', '', $module->name);
}
/// Events
events_update_definition('mod/'.$module->name);
/// Message providers
message_update_providers('mod/'.$module->name);
/// Run local install function if there is one
$installfunction = $module->name.'_install';
if (function_exists($installfunction)) {
if (! $installfunction() ) {
notify('Encountered a problem running install function for '.$module->name.'!');
}
}
notify(get_string('modulesuccess', '', $module->name), 'notifysuccess');
if (!defined('CLI_UPGRADE')|| !CLI_UPGRADE ) {
echo '';
}
} else {
print_error('cannotaddmodule', '', '', $module->name);
}
} else {
print_error('cannotsetuptable', 'debug', '', $module->name);
}
}
/// Check submodules of this module if necessary
$submoduleupgrade = $module->name.'_upgrade_submodules';
if (function_exists($submoduleupgrade)) {
$submoduleupgrade();
}
/// Run any defaults or final code that is necessary for this module
if ( is_readable($fullmod .'/defaults.php')) {
// Insert default values for any important configuration variables
unset($defaults);
include($fullmod .'/defaults.php'); // include here means execute, not library include
if (!empty($defaults)) {
if (!empty($defaults['_use_config_plugins'])) {
unset($defaults['_use_config_plugins']);
$localcfg = get_config($module->name);
foreach ($defaults as $name => $value) {
if (!isset($localcfg->$name)) {
set_config($name, $value, $module->name);
}
}
} else {
foreach ($defaults as $name => $value) {
if (!isset($CFG->$name)) {
set_config($name, $value);
}
}
}
}
}
}
upgrade_log_finish(); // finish logging if started
if ($updated_modules) {
if (!defined('CLI_UPGRADE')|| !CLI_UPGRADE ) {
print_continue($return);
print_footer('none');
die;
} else if ( CLI_UPGRADE && ($interactive > CLI_SEMI) ) {
console_write(STDOUT,'askcontinue');
if (read_boolean()){
return ;
}else {
console_write(STDERR,'','',false);
}
}
}
}
/**
* Try to obtain or release the cron lock.
*
* @param string $name name of lock
* @param int $until timestamp when this lock considered stale, null means remove lock unconditionaly
* @param bool $ignorecurrent ignore current lock state, usually entend previous lock
* @return bool true if lock obtained
*/
function set_cron_lock($name, $until, $ignorecurrent=false) {
global $DB;
if (empty($name)) {
debugging("Tried to get a cron lock for a null fieldname");
return false;
}
// remove lock by force == remove from config table
if (is_null($until)) {
set_config($name, null);
return true;
}
if (!$ignorecurrent) {
// read value from db - other processes might have changed it
$value = $DB->get_field('config', 'value', array('name'=>$name));
if ($value and $value > time()) {
//lock active
return false;
}
}
set_config($name, $until);
return true;
}
function print_progress($done, $total, $updatetime=5, $sleeptime=1, $donetext='') {
static $thisbarid;
static $starttime;
static $lasttime;
if ($total < 2) { // No need to show anything
return;
}
// Are we done?
if ($done >= $total) {
$done = $total;
if (!empty($thisbarid)) {
$donetext .= ' ('.$done.'/'.$total.') '.get_string('success');
print_progress_redraw($thisbarid, $done, $total, 500, $donetext);
$thisbarid = $starttime = $lasttime = NULL;
}
return;
}
if (empty($starttime)) {
$starttime = $lasttime = time();
$lasttime = $starttime - $updatetime;
$thisbarid = uniqid();
echo '
';
echo '
';
echo '';
echo '
';
echo '';
echo '
';
echo '';
}
$now = time();
if ($done && (($now - $lasttime) >= $updatetime)) {
$elapsedtime = $now - $starttime;
$projectedtime = (int)(((float)$total / (float)$done) * $elapsedtime) - $elapsedtime;
$percentage = round((float)$done / (float)$total, 2);
$width = (int)(500 * $percentage);
if ($projectedtime > 10) {
$projectedtext = ' Ending: '.format_time($projectedtime);
} else {
$projectedtext = '';
}
$donetext .= ' ('.$done.'/'.$total.') '.$projectedtext;
print_progress_redraw($thisbarid, $done, $total, $width, $donetext);
$lasttime = $now;
}
}
// Don't call this function directly, it's called from print_progress.
function print_progress_redraw($thisbarid, $done, $total, $width, $donetext='') {
if (empty($thisbarid)) {
return;
}
echo '';
}
function upgrade_get_javascript() {
global $CFG, $SESSION;
if (!empty($SESSION->installautopilot)) {
$linktoscrolltoerrors = ''."\n";
} else {
$linktoscrolltoerrors = ''."\n";
}
$linktoscrolltoerrors .= '';
return $linktoscrolltoerrors;
}
function create_admin_user($user_input=NULL) {
global $CFG, $USER, $DB, $unittest;
if (empty($CFG->rolesactive)) { // No admin user yet.
$user = new object();
$user->auth = 'manual';
$user->firstname = get_string('admin');
$user->lastname = get_string('user');
$user->username = 'admin';
$user->password = hash_internal_user_password('admin');
$user->email = 'root@localhost';
$user->confirmed = 1;
$user->mnethostid = $CFG->mnet_localhost_id;
$user->lang = $CFG->lang;
$user->maildisplay = 1;
$user->timemodified = time();
if ($user_input) {
$user = $user_input;
}
if (!$user->id = $DB->insert_record('user', $user)) {
print_error('cannotcreateadminuser', 'debug');
}
if (!$user = $DB->get_record('user', array('id'=>$user->id))) { // Double check.
print_error('invaliduserid');
}
if (!$unittest) {
// Assign the default admin roles to the new user.
if (!$adminroles = get_roles_with_capability('moodle/legacy:admin', CAP_ALLOW)) {
print_error('noadminrole', 'message');
}
$sitecontext = get_context_instance(CONTEXT_SYSTEM);
foreach ($adminroles as $adminrole) {
role_assign($adminrole->id, $user->id, 0, $sitecontext->id);
}
//set default message preferences
if (!message_set_default_message_preferences( $user )){
print_error('cannotsavemessageprefs', 'message');
}
// Log the user in.
set_config('rolesactive', 1);
$user = get_complete_user_data('username', 'admin');
$user->newadminuser = 1;
complete_user_login($user);
if (!defined('CLI_UPGRADE')||!CLI_UPGRADE) {
redirect("$CFG->wwwroot/user/editadvanced.php?id=$user->id"); // Edit thyself
}
} else {
redirect("$CFG->wwwroot/$CFG->admin/report/unittest/index.php?testtablesok=1");
}
} else {
print_error('cannotcreateadminuser', 'debug');
}
}
////////////////////////////////////////////////
/// upgrade logging functions
////////////////////////////////////////////////
/**
* Marks start of upgrade, blocks any other access to site.
* The upgrade is finished at the end of script or after timeout.
*/
function start_upgrade() {
global $CFG, $DB;
static $started = false;
if ($started) {
upgrade_set_timeout(120);
} else {
ignore_user_abort(true);
register_shutdown_function('upgrade_finished_handler');
if ($CFG->version === '' || !$DB->get_manager()->table_exists(new xmldb_table('config'))) {
// db not installed yet
$CFG->upgraderunning = time()+300;
} else {
set_config('upgraderunning', time()+300);
}
$started = true;
}
}
/**
* Internal function - executed at the very end of each upgrade.
*/
function upgrade_finished_handler() {
upgrade_log_finish();
unset_config('upgraderunning');
ignore_user_abort(false);
}
/**
* Start logging of output into file (if not disabled) and
* prevent aborting and concurrent execution of upgrade script.
*
* Please note that you can not write into session variables after calling this function!
*
* This function may be called repeatedly.
*/
function upgrade_log_start() {
global $upgradeloghandle;
start_upgrade(); // make sure the upgrade is started
if ($upgradeloghandle and ($upgradeloghandle !== 'error')) {
return;
}
make_upload_directory('upgradelogs');
ob_start('upgrade_log_callback', 2); // function for logging to disk; flush each line of text ASAP
}
/**
* Terminate logging of output, flush all data.
*
* Please make sure that each upgrade_log_start() is properly terminated by
* this function or print_error().
*
* This function may be called repeatedly.
*/
function upgrade_log_finish() {
global $CFG, $upgradeloghandle, $upgradelogbuffer;
@ob_end_flush();
if ($upgradelogbuffer !== '') {
@fwrite($upgradeloghandle, $upgradelogbuffer);
$upgradelogbuffer = '';
}
if ($upgradeloghandle and ($upgradeloghandle !== 'error')) {
@fclose($upgradeloghandle);
$upgradeloghandle = false;
}
}
/**
* Callback function for logging into files. Not more than one file is created per minute,
* upgrade session (terminated by upgrade_log_finish()) is always stored in one file.
*
* This function must not output any characters or throw warnigns and errors!
*/
function upgrade_log_callback($string) {
global $CFG, $upgradeloghandle, $upgradelogbuffer;
if (empty($CFG->disableupgradelogging) and ($string != '') and ($upgradeloghandle !== 'error')) {
if ($upgradeloghandle or ($upgradeloghandle = @fopen($CFG->dataroot.'/upgradelogs/upg_'.date('Ymd-Hi').'.html', 'a'))) {
$upgradelogbuffer .= $string;
if (strlen($upgradelogbuffer) > 2048) { // 2kB write buffer
@fwrite($upgradeloghandle, $upgradelogbuffer);
$upgradelogbuffer = '';
}
} else {
$upgradeloghandle = 'error';
}
}
return $string;
}
/**
* Test if and critical warnings are present
* @return bool
*/
function admin_critical_warnings_present() {
global $SESSION;
if (!has_capability('moodle/site:config', get_context_instance(CONTEXT_SYSTEM))) {
return 0;
}
if (!isset($SESSION->admin_critical_warning)) {
$SESSION->admin_critical_warning = 0;
if (ini_get_bool('register_globals')) {
$SESSION->admin_critical_warning = 1;
} else if (is_dataroot_insecure(true) === INSECURE_DATAROOT_ERROR) {
$SESSION->admin_critical_warning = 1;
}
}
return $SESSION->admin_critical_warning;
}
/**
* Try to verify that dataroot is not accessible from web.
* It is not 100% correct but might help to reduce number of vulnerable sites.
*
* Protection from httpd.conf and .htaccess is not detected properly.
* @param bool $fetchtest try to test public access by fetching file
* @return mixed empty means secure, INSECURE_DATAROOT_ERROR found a critical problem, INSECURE_DATAROOT_WARNING migth be problematic
*/
function is_dataroot_insecure($fetchtest=false) {
global $CFG;
$siteroot = str_replace('\\', '/', strrev($CFG->dirroot.'/')); // win32 backslash workaround
$rp = preg_replace('|https?://[^/]+|i', '', $CFG->wwwroot, 1);
$rp = strrev(trim($rp, '/'));
$rp = explode('/', $rp);
foreach($rp as $r) {
if (strpos($siteroot, '/'.$r.'/') === 0) {
$siteroot = substr($siteroot, strlen($r)+1); // moodle web in subdirectory
} else {
break; // probably alias root
}
}
$siteroot = strrev($siteroot);
$dataroot = str_replace('\\', '/', $CFG->dataroot.'/');
if (strpos($dataroot, $siteroot) !== 0) {
return false;
}
if (!$fetchtest) {
return INSECURE_DATAROOT_WARNING;
}
// now try all methods to fetch a test file using http protocol
$httpdocroot = str_replace('\\', '/', strrev($CFG->dirroot.'/'));
preg_match('|(https?://[^/]+)|i', $CFG->wwwroot, $matches);
$httpdocroot = $matches[1];
$datarooturl = $httpdocroot.'/'. substr($dataroot, strlen($siteroot));
if (make_upload_directory('diag', false) === false) {
return INSECURE_DATAROOT_WARNING;
}
$testfile = $CFG->dataroot.'/diag/public.txt';
if (!file_exists($testfile)) {
file_put_contents($testfile, 'test file, do not delete');
}
$teststr = trim(file_get_contents($testfile));
if (empty($teststr)) {
// hmm, strange
return INSECURE_DATAROOT_WARNING;
}
$testurl = $datarooturl.'/diag/public.txt';
if (extension_loaded('curl') and
!(stripos(ini_get('disable_functions'), 'curl_init') !== FALSE) and
!(stripos(ini_get('disable_functions'), 'curl_setop') !== FALSE) and
($ch = @curl_init($testurl)) !== false) {
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HEADER, false);
$data = curl_exec($ch);
if (!curl_errno($ch)) {
$data = trim($data);
if ($data === $teststr) {
curl_close($ch);
return INSECURE_DATAROOT_ERROR;
}
}
curl_close($ch);
}
if ($data = @file_get_contents($testurl)) {
$data = trim($data);
if ($data === $teststr) {
return INSECURE_DATAROOT_ERROR;
}
}
preg_match('|https?://([^/]+)|i', $testurl, $matches);
$sitename = $matches[1];
$error = 0;
if ($fp = @fsockopen($sitename, 80, $error)) {
preg_match('|https?://[^/]+(.*)|i', $testurl, $matches);
$localurl = $matches[1];
$out = "GET $localurl HTTP/1.1\r\n";
$out .= "Host: $sitename\r\n";
$out .= "Connection: Close\r\n\r\n";
fwrite($fp, $out);
$data = '';
$incoming = false;
while (!feof($fp)) {
if ($incoming) {
$data .= fgets($fp, 1024);
} else if (@fgets($fp, 1024) === "\r\n") {
$incoming = true;
}
}
fclose($fp);
$data = trim($data);
if ($data === $teststr) {
return INSECURE_DATAROOT_ERROR;
}
}
return INSECURE_DATAROOT_WARNING;
}
/// =============================================================================================================
/// administration tree classes and functions
// n.b. documentation is still in progress for this code
/// INTRODUCTION
/// This file performs the following tasks:
/// -it defines the necessary objects and interfaces to build the Moodle
/// admin hierarchy
/// -it defines the admin_externalpage_setup(), admin_externalpage_print_header(),
/// and admin_externalpage_print_footer() functions used on admin pages
/// ADMIN_SETTING OBJECTS
/// Moodle settings are represented by objects that inherit from the admin_setting
/// class. These objects encapsulate how to read a setting, how to write a new value
/// to a setting, and how to appropriately display the HTML to modify the setting.
/// ADMIN_SETTINGPAGE OBJECTS
/// The admin_setting objects are then grouped into admin_settingpages. The latter
/// appear in the Moodle admin tree block. All interaction with admin_settingpage
/// objects is handled by the admin/settings.php file.
/// ADMIN_EXTERNALPAGE OBJECTS
/// There are some settings in Moodle that are too complex to (efficiently) handle
/// with admin_settingpages. (Consider, for example, user management and displaying
/// lists of users.) In this case, we use the admin_externalpage object. This object
/// places a link to an external PHP file in the admin tree block.
/// If you're using an admin_externalpage object for some settings, you can take
/// advantage of the admin_externalpage_* functions. For example, suppose you wanted
/// to add a foo.php file into admin. First off, you add the following line to
/// admin/settings/first.php (at the end of the file) or to some other file in
/// admin/settings:
/// $ADMIN->add('userinterface', new admin_externalpage('foo', get_string('foo'),
/// $CFG->wwwdir . '/' . '$CFG->admin . '/foo.php', 'some_role_permission'));
/// Next, in foo.php, your file structure would resemble the following:
/// require_once('.../config.php');
/// require_once($CFG->libdir.'/adminlib.php');
/// admin_externalpage_setup('foo');
/// // functionality like processing form submissions goes here
/// admin_externalpage_print_header();
/// // your HTML goes here
/// admin_externalpage_print_footer();
/// The admin_externalpage_setup() function call ensures the user is logged in,
/// and makes sure that they have the proper role permission to access the page.
/// The admin_externalpage_print_header() function prints the header (it figures
/// out what category and subcategories the page is classified under) and ensures
/// that you're using the admin pagelib (which provides the admin tree block and
/// the admin bookmarks block).
/// The admin_externalpage_print_footer() function properly closes the tables
/// opened up by the admin_externalpage_print_header() function and prints the
/// standard Moodle footer.
/// ADMIN_CATEGORY OBJECTS
/// Above and beyond all this, we have admin_category objects. These objects
/// appear as folders in the admin tree block. They contain admin_settingpage's,
/// admin_externalpage's, and other admin_category's.
/// OTHER NOTES
/// admin_settingpage's, admin_externalpage's, and admin_category's all inherit
/// from part_of_admin_tree (a pseudointerface). This interface insists that
/// a class has a check_access method for access permissions, a locate method
/// used to find a specific node in the admin tree and find parent path.
/// admin_category's inherit from parentable_part_of_admin_tree. This pseudo-
/// interface ensures that the class implements a recursive add function which
/// accepts a part_of_admin_tree object and searches for the proper place to
/// put it. parentable_part_of_admin_tree implies part_of_admin_tree.
/// Please note that the $this->name field of any part_of_admin_tree must be
/// UNIQUE throughout the ENTIRE admin tree.
/// The $this->name field of an admin_setting object (which is *not* part_of_
/// admin_tree) must be unique on the respective admin_settingpage where it is
/// used.
/// CLASS DEFINITIONS /////////////////////////////////////////////////////////
/**
* Pseudointerface for anything appearing in the admin tree
*
* The pseudointerface that is implemented by anything that appears in the admin tree
* block. It forces inheriting classes to define a method for checking user permissions
* and methods for finding something in the admin tree.
*
* @author Vincenzo K. Marcovecchio
* @package admin
*/
class part_of_admin_tree {
/**
* Finds a named part_of_admin_tree.
*
* Used to find a part_of_admin_tree. If a class only inherits part_of_admin_tree
* and not parentable_part_of_admin_tree, then this function should only check if
* $this->name matches $name. If it does, it should return a reference to $this,
* otherwise, it should return a reference to NULL.
*
* If a class inherits parentable_part_of_admin_tree, this method should be called
* recursively on all child objects (assuming, of course, the parent object's name
* doesn't match the search criterion).
*
* @param string $name The internal name of the part_of_admin_tree we're searching for.
* @return mixed An object reference or a NULL reference.
*/
function &locate($name) {
trigger_error('Admin class does not implement method locate()', E_USER_WARNING);
return;
}
/**
* Removes named part_of_admin_tree.
*
* @param string $name The internal name of the part_of_admin_tree we want to remove.
* @return bool success.
*/
function prune($name) {
trigger_error('Admin class does not implement method prune()', E_USER_WARNING);
return;
}
/**
* Search using query
* @param strin query
* @return mixed array-object structure of found settings and pages
*/
function search($query) {
trigger_error('Admin class does not implement method search()', E_USER_WARNING);
return;
}
/**
* Verifies current user's access to this part_of_admin_tree.
*
* Used to check if the current user has access to this part of the admin tree or
* not. If a class only inherits part_of_admin_tree and not parentable_part_of_admin_tree,
* then this method is usually just a call to has_capability() in the site context.
*
* If a class inherits parentable_part_of_admin_tree, this method should return the
* logical OR of the return of check_access() on all child objects.
*
* @return bool True if the user has access, false if she doesn't.
*/
function check_access() {
trigger_error('Admin class does not implement method check_access()', E_USER_WARNING);
return;
}
/**
* Mostly usefull for removing of some parts of the tree in admin tree block.
*
* @return True is hidden from normal list view
*/
function is_hidden() {
trigger_error('Admin class does not implement method is_hidden()', E_USER_WARNING);
return;
}
}
/**
* Pseudointerface implemented by any part_of_admin_tree that has children.
*
* The pseudointerface implemented by any part_of_admin_tree that can be a parent
* to other part_of_admin_tree's. (For now, this only includes admin_category.) Apart
* from ensuring part_of_admin_tree compliancy, it also ensures inheriting methods
* include an add method for adding other part_of_admin_tree objects as children.
*
* @author Vincenzo K. Marcovecchio
* @package admin
*/
class parentable_part_of_admin_tree extends part_of_admin_tree {
/**
* Adds a part_of_admin_tree object to the admin tree.
*
* Used to add a part_of_admin_tree object to this object or a child of this
* object. $something should only be added if $destinationname matches
* $this->name. If it doesn't, add should be called on child objects that are
* also parentable_part_of_admin_tree's.
*
* @param string $destinationname The internal name of the new parent for $something.
* @param part_of_admin_tree &$something The object to be added.
* @return bool True on success, false on failure.
*/
function add($destinationname, $something) {
trigger_error('Admin class does not implement method add()', E_USER_WARNING);
return;
}
}
/**
* The object used to represent folders (a.k.a. categories) in the admin tree block.
*
* Each admin_category object contains a number of part_of_admin_tree objects.
*
* @author Vincenzo K. Marcovecchio
* @package admin
*/
class admin_category extends parentable_part_of_admin_tree {
/**
* @var mixed An array of part_of_admin_tree objects that are this object's children
*/
var $children;
/**
* @var string An internal name for this category. Must be unique amongst ALL part_of_admin_tree objects
*/
var $name;
/**
* @var string The displayed name for this category. Usually obtained through get_string()
*/
var $visiblename;
/**
* @var bool Should this category be hidden in admin tree block?
*/
var $hidden;
/**
* paths
*/
var $path;
var $visiblepath;
/**
* Constructor for an empty admin category
*
* @param string $name The internal name for this category. Must be unique amongst ALL part_of_admin_tree objects
* @param string $visiblename The displayed named for this category. Usually obtained through get_string()
* @param bool $hidden hide category in admin tree block
*/
function admin_category($name, $visiblename, $hidden=false) {
$this->children = array();
$this->name = $name;
$this->visiblename = $visiblename;
$this->hidden = $hidden;
}
/**
* Returns a reference to the part_of_admin_tree object with internal name $name.
*
* @param string $name The internal name of the object we want.
* @param bool $findpath initialize path and visiblepath arrays
* @return mixed A reference to the object with internal name $name if found, otherwise a reference to NULL.
*/
function &locate($name, $findpath=false) {
if ($this->name == $name) {
if ($findpath) {
$this->visiblepath[] = $this->visiblename;
$this->path[] = $this->name;
}
return $this;
}
$return = NULL;
foreach($this->children as $childid=>$unused) {
if ($return =& $this->children[$childid]->locate($name, $findpath)) {
break;
}
}
if (!is_null($return) and $findpath) {
$return->visiblepath[] = $this->visiblename;
$return->path[] = $this->name;
}
return $return;
}
/**
* Search using query
* @param strin query
* @return mixed array-object structure of found settings and pages
*/
function search($query) {
$result = array();
foreach ($this->children as $child) {
$subsearch = $child->search($query);
if (!is_array($subsearch)) {
debugging('Incorrect search result from '.$child->name);
continue;
}
$result = array_merge($result, $subsearch);
}
return $result;
}
/**
* Removes part_of_admin_tree object with internal name $name.
*
* @param string $name The internal name of the object we want to remove.
* @return bool success
*/
function prune($name) {
if ($this->name == $name) {
return false; //can not remove itself
}
foreach($this->children as $precedence => $child) {
if ($child->name == $name) {
// found it!
unset($this->children[$precedence]);
return true;
}
if ($this->children[$precedence]->prune($name)) {
return true;
}
}
return false;
}
/**
* Adds a part_of_admin_tree to a child or grandchild (or great-grandchild, and so forth) of this object.
*
* @param string $destinationame The internal name of the immediate parent that we want for $something.
* @param mixed $something A part_of_admin_tree or setting instanceto be added.
* @return bool True if successfully added, false if $something can not be added.
*/
function add($parentname, $something) {
$parent =& $this->locate($parentname);
if (is_null($parent)) {
debugging('parent does not exist!');
return false;
}
if (is_a($something, 'part_of_admin_tree')) {
if (!is_a($parent, 'parentable_part_of_admin_tree')) {
debugging('error - parts of tree can be inserted only into parentable parts');
return false;
}
$parent->children[] = $something;
return true;
} else {
debugging('error - can not add this element');
return false;
}
}
/**
* Checks if the user has access to anything in this category.
*
* @return bool True if the user has access to atleast one child in this category, false otherwise.
*/
function check_access() {
foreach ($this->children as $child) {
if ($child->check_access()) {
return true;
}
}
return false;
}
/**
* Is this category hidden in admin tree block?
*
* @return bool True if hidden
*/
function is_hidden() {
return $this->hidden;
}
}
class admin_root extends admin_category {
/**
* list of errors
*/
var $errors;
/**
* search query
*/
var $search;
/**
* full tree flag - true means all settings required, false onlypages required
*/
var $fulltree;
function admin_root() {
parent::admin_category('root', get_string('administration'), false);
$this->errors = array();
$this->search = '';
$this->fulltree = true;
}
}
/**
* Links external PHP pages into the admin tree.
*
* See detailed usage example at the top of this document (adminlib.php)
*
* @author Vincenzo K. Marcovecchio
* @package admin
*/
class admin_externalpage extends part_of_admin_tree {
/**
* @var string An internal name for this external page. Must be unique amongst ALL part_of_admin_tree objects
*/
var $name;
/**
* @var string The displayed name for this external page. Usually obtained through get_string().
*/
var $visiblename;
/**
* @var string The external URL that we should link to when someone requests this external page.
*/
var $url;
/**
* @var string The role capability/permission a user must have to access this external page.
*/
var $req_capability;
/**
* @var object The context in which capability/permission should be checked, default is site context.
*/
var $context;
/**
* @var bool hidden in admin tree block.
*/
var $hidden;
/**
* visible path
*/
var $path;
var $visiblepath;
/**
* Constructor for adding an external page into the admin tree.
*
* @param string $name The internal name for this external page. Must be unique amongst ALL part_of_admin_tree objects.
* @param string $visiblename The displayed name for this external page. Usually obtained through get_string().
* @param string $url The external URL that we should link to when someone requests this external page.
* @param mixed $req_capability The role capability/permission a user must have to access this external page. Defaults to 'moodle/site:config'.
* @param boolean $hidden Is this external page hidden in admin tree block? Default false.
* @param context $context The context the page relates to. Not sure what happens
* if you specify something other than system or front page. Defaults to system.
*/
function admin_externalpage($name, $visiblename, $url, $req_capability='moodle/site:config', $hidden=false, $context=NULL) {
$this->name = $name;
$this->visiblename = $visiblename;
$this->url = $url;
if (is_array($req_capability)) {
$this->req_capability = $req_capability;
} else {
$this->req_capability = array($req_capability);
}
$this->hidden = $hidden;
$this->context = $context;
}
/**
* Returns a reference to the part_of_admin_tree object with internal name $name.
*
* @param string $name The internal name of the object we want.
* @return mixed A reference to the object with internal name $name if found, otherwise a reference to NULL.
*/
function &locate($name, $findpath=false) {
if ($this->name == $name) {
if ($findpath) {
$this->visiblepath = array($this->visiblename);
$this->path = array($this->name);
}
return $this;
} else {
$return = NULL;
return $return;
}
}
function prune($name) {
return false;
}
/**
* Search using query
* @param strin query
* @return mixed array-object structure of found settings and pages
*/
function search($query) {
$textlib = textlib_get_instance();
$found = false;
if (strpos(strtolower($this->name), $query) !== false) {
$found = true;
} else if (strpos($textlib->strtolower($this->visiblename), $query) !== false) {
$found = true;
}
if ($found) {
$result = new object();
$result->page = $this;
$result->settings = array();
return array($this->name => $result);
} else {
return array();
}
}
/**
* Determines if the current user has access to this external page based on $this->req_capability.
* @return bool True if user has access, false otherwise.
*/
function check_access() {
if (!get_site()) {
return true; // no access check before site is fully set up
}
$context = empty($this->context) ? get_context_instance(CONTEXT_SYSTEM) : $this->context;
foreach($this->req_capability as $cap) {
if (is_valid_capability($cap) and has_capability($cap, $context)) {
return true;
}
}
return false;
}
/**
* Is this external page hidden in admin tree block?
*
* @return bool True if hidden
*/
function is_hidden() {
return $this->hidden;
}
}
/**
* Used to group a number of admin_setting objects into a page and add them to the admin tree.
*
* @author Vincenzo K. Marcovecchio
* @package admin
*/
class admin_settingpage extends part_of_admin_tree {
/**
* @var string An internal name for this external page. Must be unique amongst ALL part_of_admin_tree objects
*/
var $name;
/**
* @var string The displayed name for this external page. Usually obtained through get_string().
*/
var $visiblename;
/**
* @var mixed An array of admin_setting objects that are part of this setting page.
*/
var $settings;
/**
* @var string The role capability/permission a user must have to access this external page.
*/
var $req_capability;
/**
* @var object The context in which capability/permission should be checked, default is site context.
*/
var $context;
/**
* @var bool hidden in admin tree block.
*/
var $hidden;
/**
* paths
*/
var $path;
var $visiblepath;
// see admin_externalpage
function admin_settingpage($name, $visiblename, $req_capability='moodle/site:config', $hidden=false, $context=NULL) {
$this->settings = new object();
$this->name = $name;
$this->visiblename = $visiblename;
if (is_array($req_capability)) {
$this->req_capability = $req_capability;
} else {
$this->req_capability = array($req_capability);
}
$this->hidden = $hidden;
$this->context = $context;
}
// see admin_category
function &locate($name, $findpath=false) {
if ($this->name == $name) {
if ($findpath) {
$this->visiblepath = array($this->visiblename);
$this->path = array($this->name);
}
return $this;
} else {
$return = NULL;
return $return;
}
}
function search($query) {
$found = array();
foreach ($this->settings as $setting) {
if ($setting->is_related($query)) {
$found[] = $setting;
}
}
if ($found) {
$result = new object();
$result->page = $this;
$result->settings = $found;
return array($this->name => $result);
}
$textlib = textlib_get_instance();
$found = false;
if (strpos(strtolower($this->name), $query) !== false) {
$found = true;
} else if (strpos($textlib->strtolower($this->visiblename), $query) !== false) {
$found = true;
}
if ($found) {
$result = new object();
$result->page = $this;
$result->settings = array();
return array($this->name => $result);
} else {
return array();
}
}
function prune($name) {
return false;
}
/**
* not the same as add for admin_category. adds an admin_setting to this admin_settingpage. settings appear (on the settingpage) in the order in which they're added
* n.b. each admin_setting in an admin_settingpage must have a unique internal name
* @param object $setting is the admin_setting object you want to add
* @return true if successful, false if not
*/
function add($setting) {
if (!is_a($setting, 'admin_setting')) {
debugging('error - not a setting instance');
return false;
}
$this->settings->{$setting->name} = $setting;
return true;
}
// see admin_externalpage
function check_access() {
if (!get_site()) {
return true; // no access check before site is fully set up
}
$context = empty($this->context) ? get_context_instance(CONTEXT_SYSTEM) : $this->context;
foreach($this->req_capability as $cap) {
if (is_valid_capability($cap) and has_capability($cap, $context)) {
return true;
}
}
return false;
}
/**
* outputs this page as html in a table (suitable for inclusion in an admin pagetype)
* returns a string of the html
*/
function output_html() {
$adminroot =& admin_get_root();
$return = '';
return $return;
}
/**
* Is this settigns page hidden in admin tree block?
*
* @return bool True if hidden
*/
function is_hidden() {
return $this->hidden;
}
}
/**
* Admin settings class. Only exists on setting pages.
* Read & write happens at this level; no authentication.
*/
class admin_setting {
var $name;
var $visiblename;
var $description;
var $defaultsetting;
var $updatedcallback;
var $plugin; // null means main config table
/**
* Constructor
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $visiblename localised name
* @param string $description localised long description
* @param mixed $defaultsetting string or array depending on implementation
*/
function admin_setting($name, $visiblename, $description, $defaultsetting) {
$this->parse_setting_name($name);
$this->visiblename = $visiblename;
$this->description = $description;
$this->defaultsetting = $defaultsetting;
}
/**
* Set up $this->name and possibly $this->plugin based on whether $name looks
* like 'settingname' or 'plugin/settingname'. Also, do some sanity checking
* on the names, that is, output a developer debug warning if the name
* contains anything other than [a-zA-Z0-9_]+.
*
* @param string $name the setting name passed in to the constructor.
*/
private function parse_setting_name($name) {
$bits = explode('/', $name);
if (count($bits) > 2) {
throw new moodle_exception('invalidadminsettingname', '', '', $name);
}
$this->name = array_pop($bits);
if (!preg_match('/^[a-zA-Z0-9_]+$/', $this->name)) {
throw new moodle_exception('invalidadminsettingname', '', '', $name);
}
if (!empty($bits)) {
$this->plugin = array_pop($bits);
if (!preg_match('/^[a-zA-Z0-9_]+$/', $this->plugin)) {
throw new moodle_exception('invalidadminsettingname', '', '', $name);
}
}
}
function get_full_name() {
return 's_'.$this->plugin.'_'.$this->name;
}
function get_id() {
return 'id_s_'.$this->plugin.'_'.$this->name;
}
function config_read($name) {
global $CFG;
if ($this->plugin === 'backup') {
require_once($CFG->dirroot.'/backup/lib.php');
$backupconfig = backup_get_config();
if (isset($backupconfig->$name)) {
return $backupconfig->$name;
} else {
return NULL;
}
} else if (!empty($this->plugin)) {
$value = get_config($this->plugin, $name);
return $value === false ? NULL : $value;
} else {
if (isset($CFG->$name)) {
return $CFG->$name;
} else {
return NULL;
}
}
}
function config_write($name, $value) {
global $CFG;
if ($this->plugin === 'backup') {
require_once($CFG->dirroot.'/backup/lib.php');
return (boolean)backup_set_config($name, $value);
} else {
return (boolean)set_config($name, $value, $this->plugin);
}
}
/**
* Returns current value of this setting
* @return mixed array or string depending on instance, NULL means not set yet
*/
function get_setting() {
// has to be overridden
return NULL;
}
/**
* Returns default setting if exists
* @return mixed array or string depending on instance; NULL means no default, user must supply
*/
function get_defaultsetting() {
return $this->defaultsetting;
}
/**
* Store new setting
* @param mixed string or array, must not be NULL
* @return '' if ok, string error message otherwise
*/
function write_setting($data) {
// should be overridden
return '';
}
/**
* Return part of form with setting
* @param mixed data array or string depending on setting
* @return string
*/
function output_html($data, $query='') {
// should be overridden
return;
}
/**
* function called if setting updated - cleanup, cache reset, etc.
*/
function set_updatedcallback($functionname) {
$this->updatedcallback = $functionname;
}
/**
* Is setting related to query text - used when searching
* @param string $query
* @return bool
*/
function is_related($query) {
if (strpos(strtolower($this->name), $query) !== false) {
return true;
}
$textlib = textlib_get_instance();
if (strpos($textlib->strtolower($this->visiblename), $query) !== false) {
return true;
}
if (strpos($textlib->strtolower($this->description), $query) !== false) {
return true;
}
$current = $this->get_setting();
if (!is_null($current)) {
if (is_string($current)) {
if (strpos($textlib->strtolower($current), $query) !== false) {
return true;
}
}
}
$default = $this->get_defaultsetting();
if (!is_null($default)) {
if (is_string($default)) {
if (strpos($textlib->strtolower($default), $query) !== false) {
return true;
}
}
}
return false;
}
}
/**
* No setting - just heading and text.
*/
class admin_setting_heading extends admin_setting {
/**
* not a setting, just text
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $heading heading
* @param string $information text in box
*/
function admin_setting_heading($name, $heading, $information) {
parent::admin_setting($name, $heading, $information, '');
}
function get_setting() {
return true;
}
function get_defaultsetting() {
return true;
}
function write_setting($data) {
// do not write any setting
return '';
}
function output_html($data, $query='') {
$return = '';
if ($this->visiblename != '') {
$return .= print_heading(''.highlightfast($query, $this->visiblename).'', '', 3, 'main', true);
}
if ($this->description != '') {
$return .= print_box(highlight($query, $this->description), 'generalbox formsettingheading', '', true);
}
return $return;
}
}
/**
* The most flexibly setting, user is typing text
*/
class admin_setting_configtext extends admin_setting {
var $paramtype;
var $size;
/**
* config text contructor
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $visiblename localised
* @param string $description long localised info
* @param string $defaultsetting
* @param mixed $paramtype int means PARAM_XXX type, string is a allowed format in regex
* @param int $size default field size
*/
function admin_setting_configtext($name, $visiblename, $description, $defaultsetting, $paramtype=PARAM_RAW, $size=null) {
$this->paramtype = $paramtype;
if (!is_null($size)) {
$this->size = $size;
} else {
$this->size = ($paramtype == PARAM_INT) ? 5 : 30;
}
parent::admin_setting($name, $visiblename, $description, $defaultsetting);
}
function get_setting() {
return $this->config_read($this->name);
}
function write_setting($data) {
if ($this->paramtype === PARAM_INT and $data === '') {
// do not complain if '' used instead of 0
$data = 0;
}
// $data is a string
$validated = $this->validate($data);
if ($validated !== true) {
return $validated;
}
return ($this->config_write($this->name, $data) ? '' : get_string('errorsetting', 'admin'));
}
/**
* Validate data before storage
* @param string data
* @return mixed true if ok string if error found
*/
function validate($data) {
if (is_string($this->paramtype)) {
if (preg_match($this->paramtype, $data)) {
return true;
} else {
return get_string('validateerror', 'admin');
}
} else if ($this->paramtype === PARAM_RAW) {
return true;
} else {
$cleaned = clean_param($data, $this->paramtype);
if ("$data" == "$cleaned") { // implicit conversion to string is needed to do exact comparison
return true;
} else {
return get_string('validateerror', 'admin');
}
}
}
function output_html($data, $query='') {
$default = $this->get_defaultsetting();
return format_admin_setting($this, $this->visiblename,
'',
$this->description, true, '', $default, $query);
}
}
/**
* General text area without html editor.
*/
class admin_setting_configtextarea extends admin_setting_configtext {
var $rows;
var $cols;
function admin_setting_configtextarea($name, $visiblename, $description, $defaultsetting, $paramtype=PARAM_RAW, $cols='60', $rows='8') {
$this->rows = $rows;
$this->cols = $cols;
parent::admin_setting_configtext($name, $visiblename, $description, $defaultsetting, $paramtype);
}
function output_html($data, $query='') {
$default = $this->get_defaultsetting();
$defaultinfo = $default;
if (!is_null($default) and $default !== '') {
$defaultinfo = "\n".$default;
}
return format_admin_setting($this, $this->visiblename,
'',
$this->description, true, '', $defaultinfo, $query);
}
}
/**
* Password field, allows unmasking of password
*/
class admin_setting_configpasswordunmask extends admin_setting_configtext {
/**
* Constructor
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $visiblename localised
* @param string $description long localised info
* @param string $defaultsetting default password
*/
function admin_setting_configpasswordunmask($name, $visiblename, $description, $defaultsetting) {
parent::admin_setting_configtext($name, $visiblename, $description, $defaultsetting, PARAM_RAW, 30);
}
function output_html($data, $query='') {
$id = $this->get_id();
$unmask = get_string('unmaskpassword', 'form');
$unmaskjs = '';
return format_admin_setting($this, $this->visiblename,
'
'.$unmaskjs.'
',
$this->description, true, '', NULL, $query);
}
}
/**
* Path to directory
*/
class admin_setting_configfile extends admin_setting_configtext {
/**
* Constructor
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $visiblename localised
* @param string $description long localised info
* @param string $defaultdirectory default directory location
*/
function admin_setting_configfile($name, $visiblename, $description, $defaultdirectory) {
parent::admin_setting_configtext($name, $visiblename, $description, $defaultdirectory, PARAM_RAW, 50);
}
function output_html($data, $query='') {
$default = $this->get_defaultsetting();
if ($data) {
if (file_exists($data)) {
$executable = '✔';
} else {
$executable = '✘';
}
} else {
$executable = '';
}
return format_admin_setting($this, $this->visiblename,
'
'.$executable.'
',
$this->description, true, '', $default, $query);
}
}
/**
* Path to executable file
*/
class admin_setting_configexecutable extends admin_setting_configfile {
function output_html($data, $query='') {
$default = $this->get_defaultsetting();
if ($data) {
if (file_exists($data) and is_executable($data)) {
$executable = '✔';
} else {
$executable = '✘';
}
} else {
$executable = '';
}
return format_admin_setting($this, $this->visiblename,
'
'.$executable.'
',
$this->description, true, '', $default, $query);
}
}
/**
* Path to directory
*/
class admin_setting_configdirectory extends admin_setting_configfile {
function output_html($data, $query='') {
$default = $this->get_defaultsetting();
if ($data) {
if (file_exists($data) and is_dir($data)) {
$executable = '✔';
} else {
$executable = '✘';
}
} else {
$executable = '';
}
return format_admin_setting($this, $this->visiblename,
'
'.$executable.'
',
$this->description, true, '', $default, $query);
}
}
/**
* Checkbox
*/
class admin_setting_configcheckbox extends admin_setting {
var $yes;
var $no;
/**
* Constructor
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $visiblename localised
* @param string $description long localised info
* @param string $defaultsetting
* @param string $yes value used when checked
* @param string $no value used when not checked
*/
function admin_setting_configcheckbox($name, $visiblename, $description, $defaultsetting, $yes='1', $no='0') {
parent::admin_setting($name, $visiblename, $description, $defaultsetting);
$this->yes = (string)$yes;
$this->no = (string)$no;
}
function get_setting() {
return $this->config_read($this->name);
}
function write_setting($data) {
if ((string)$data === $this->yes) { // convert to strings before comparison
$data = $this->yes;
} else {
$data = $this->no;
}
return ($this->config_write($this->name, $data) ? '' : get_string('errorsetting', 'admin'));
}
function output_html($data, $query='') {
$default = $this->get_defaultsetting();
if (!is_null($default)) {
if ((string)$default === $this->yes) {
$defaultinfo = get_string('checkboxyes', 'admin');
} else {
$defaultinfo = get_string('checkboxno', 'admin');
}
} else {
$defaultinfo = NULL;
}
if ((string)$data === $this->yes) { // convert to strings before comparison
$checked = 'checked="checked"';
} else {
$checked = '';
}
return format_admin_setting($this, $this->visiblename,
'
'
.'
',
$this->description, true, '', $defaultinfo, $query);
}
}
/**
* Multiple checkboxes, each represents different value, stored in csv format
*/
class admin_setting_configmulticheckbox extends admin_setting {
var $choices;
/**
* Constructor
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $visiblename localised
* @param string $description long localised info
* @param array $defaultsetting array of selected
* @param array $choices array of $value=>$label for each checkbox
*/
function admin_setting_configmulticheckbox($name, $visiblename, $description, $defaultsetting, $choices) {
$this->choices = $choices;
parent::admin_setting($name, $visiblename, $description, $defaultsetting);
}
/**
* This function may be used in ancestors for lazy loading of choices
* @return true if loaded, false if error
*/
function load_choices() {
/*
if (is_array($this->choices)) {
return true;
}
.... load choices here
*/
return true;
}
/**
* Is setting related to query text - used when searching
* @param string $query
* @return bool
*/
function is_related($query) {
if (!$this->load_choices() or empty($this->choices)) {
return false;
}
if (parent::is_related($query)) {
return true;
}
$textlib = textlib_get_instance();
foreach ($this->choices as $desc) {
if (strpos($textlib->strtolower($desc), $query) !== false) {
return true;
}
}
return false;
}
function get_setting() {
$result = $this->config_read($this->name);
if (is_null($result)) {
return NULL;
}
if ($result === '') {
return array();
}
$enabled = explode(',', $result);
$setting = array();
foreach ($enabled as $option) {
$setting[$option] = 1;
}
return $setting;
}
function write_setting($data) {
if (!is_array($data)) {
return ''; // ignore it
}
if (!$this->load_choices() or empty($this->choices)) {
return '';
}
unset($data['xxxxx']);
$result = array();
foreach ($data as $key => $value) {
if ($value and array_key_exists($key, $this->choices)) {
$result[] = $key;
}
}
return $this->config_write($this->name, implode(',', $result)) ? '' : get_string('errorsetting', 'admin');
}
function output_html($data, $query='') {
if (!$this->load_choices() or empty($this->choices)) {
return '';
}
$default = $this->get_defaultsetting();
if (is_null($default)) {
$default = array();
}
if (is_null($data)) {
$data = array();
}
$options = array();
$defaults = array();
foreach ($this->choices as $key=>$description) {
if (!empty($data[$key])) {
$checked = 'checked="checked"';
} else {
$checked = '';
}
if (!empty($default[$key])) {
$defaults[] = $description;
}
$options[] = ''
.'';
}
if (is_null($default)) {
$defaultinfo = NULL;
} else if (!empty($defaults)) {
$defaultinfo = implode(', ', $defaults);
} else {
$defaultinfo = get_string('none');
}
$return = '
';
$return .= ''; // something must be submitted even if nothing selected
if ($options) {
$return .= '
';
foreach ($options as $option) {
$return .= '
'.$option.'
';
}
$return .= '
';
}
$return .= '
';
return format_admin_setting($this, $this->visiblename, $return, $this->description, false, '', $defaultinfo, $query);
}
}
/**
* Multiple checkboxes 2, value stored as string 00101011
*/
class admin_setting_configmulticheckbox2 extends admin_setting_configmulticheckbox {
function get_setting() {
$result = $this->config_read($this->name);
if (is_null($result)) {
return NULL;
}
if (!$this->load_choices()) {
return NULL;
}
$result = str_pad($result, count($this->choices), '0');
$result = preg_split('//', $result, -1, PREG_SPLIT_NO_EMPTY);
$setting = array();
foreach ($this->choices as $key=>$unused) {
$value = array_shift($result);
if ($value) {
$setting[$key] = 1;
}
}
return $setting;
}
function write_setting($data) {
if (!is_array($data)) {
return ''; // ignore it
}
if (!$this->load_choices() or empty($this->choices)) {
return '';
}
$result = '';
foreach ($this->choices as $key=>$unused) {
if (!empty($data[$key])) {
$result .= '1';
} else {
$result .= '0';
}
}
return $this->config_write($this->name, $result) ? '' : get_string('errorsetting', 'admin');
}
}
/**
* Select one value from list
*/
class admin_setting_configselect extends admin_setting {
var $choices;
/**
* Constructor
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $visiblename localised
* @param string $description long localised info
* @param string $defaultsetting
* @param array $choices array of $value=>$label for each selection
*/
function admin_setting_configselect($name, $visiblename, $description, $defaultsetting, $choices) {
$this->choices = $choices;
parent::admin_setting($name, $visiblename, $description, $defaultsetting);
}
/**
* This function may be used in ancestors for lazy loading of choices
* @return true if loaded, false if error
*/
function load_choices() {
/*
if (is_array($this->choices)) {
return true;
}
.... load choices here
*/
return true;
}
function is_related($query) {
if (parent::is_related($query)) {
return true;
}
if (!$this->load_choices()) {
return false;
}
$textlib = textlib_get_instance();
foreach ($this->choices as $key=>$value) {
if (strpos($textlib->strtolower($key), $query) !== false) {
return true;
}
if (strpos($textlib->strtolower($value), $query) !== false) {
return true;
}
}
return false;
}
function get_setting() {
return $this->config_read($this->name);
}
function write_setting($data) {
if (!$this->load_choices() or empty($this->choices)) {
return '';
}
if (!array_key_exists($data, $this->choices)) {
return ''; // ignore it
}
return ($this->config_write($this->name, $data) ? '' : get_string('errorsetting', 'admin'));
}
/**
* Ensure the options are loaded, and generate the HTML for the select
* element and any warning message. Separating this out from output_html
* makes it easier to subclass this class.
*
* @param string $data the option to show as selected.
* @param string $current the currently selected option in the database, null if none.
* @param string $default the default selected option.
* @return array the HTML for the select element, and a warning message.
*/
function output_select_html($data, $current, $default, $extraname = '') {
if (!$this->load_choices() or empty($this->choices)) {
return array('', '');
}
$warning = '';
if (is_null($current)) {
// first run
} else if (empty($current) and (array_key_exists('', $this->choices) or array_key_exists(0, $this->choices))) {
// no warning
} else if (!array_key_exists($current, $this->choices)) {
$warning = get_string('warningcurrentsetting', 'admin', s($current));
if (!is_null($default) and $data == $current) {
$data = $default; // use default instead of first value when showing the form
}
}
$selecthtml = '';
return array($selecthtml, $warning);
}
function output_html($data, $query='') {
$default = $this->get_defaultsetting();
$current = $this->get_setting();
list($selecthtml, $warning) = $this->output_select_html($data, $current, $default);
if (!$selecthtml) {
return '';
}
if (!is_null($default) and array_key_exists($default, $this->choices)) {
$defaultinfo = $this->choices[$default];
} else {
$defaultinfo = NULL;
}
$return = '
' . $selecthtml . '
';
return format_admin_setting($this, $this->visiblename, $return, $this->description, true, $warning, $defaultinfo, $query);
}
}
/**
* Select multiple items from list
*/
class admin_setting_configmultiselect extends admin_setting_configselect {
/**
* Constructor
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $visiblename localised
* @param string $description long localised info
* @param array $defaultsetting array of selected items
* @param array $choices array of $value=>$label for each list item
*/
function admin_setting_configmultiselect($name, $visiblename, $description, $defaultsetting, $choices) {
parent::admin_setting_configselect($name, $visiblename, $description, $defaultsetting, $choices);
}
function get_setting() {
$result = $this->config_read($this->name);
if (is_null($result)) {
return NULL;
}
if ($result === '') {
return array();
}
return explode(',', $result);
}
function write_setting($data) {
if (!is_array($data)) {
return ''; //ignore it
}
if (!$this->load_choices() or empty($this->choices)) {
return '';
}
unset($data['xxxxx']);
$save = array();
foreach ($data as $value) {
if (!array_key_exists($value, $this->choices)) {
continue; // ignore it
}
$save[] = $value;
}
return ($this->config_write($this->name, implode(',', $save)) ? '' : get_string('errorsetting', 'admin'));
}
/**
* Is setting related to query text - used when searching
* @param string $query
* @return bool
*/
function is_related($query) {
if (!$this->load_choices() or empty($this->choices)) {
return false;
}
if (parent::is_related($query)) {
return true;
}
$textlib = textlib_get_instance();
foreach ($this->choices as $desc) {
if (strpos($textlib->strtolower($desc), $query) !== false) {
return true;
}
}
return false;
}
function output_html($data, $query='') {
if (!$this->load_choices() or empty($this->choices)) {
return '';
}
$choices = $this->choices;
$default = $this->get_defaultsetting();
if (is_null($default)) {
$default = array();
}
if (is_null($data)) {
$data = array();
}
$defaults = array();
$size = min(10, count($this->choices));
$return = '
'; // something must be submitted even if nothing selected
$return .= '
';
return format_admin_setting($this, $this->visiblename, $return, $this->description, true, '', $defaultinfo, $query);
}
}
/**
* Time selector
* this is a liiitle bit messy. we're using two selects, but we're returning
* them as an array named after $name (so we only use $name2 internally for the setting)
*/
class admin_setting_configtime extends admin_setting {
var $name2;
/**
* Constructor
* @param string $hoursname setting for hours
* @param string $minutesname setting for hours
* @param string $visiblename localised
* @param string $description long localised info
* @param array $defaultsetting array representing default time 'h'=>hours, 'm'=>minutes
*/
function admin_setting_configtime($hoursname, $minutesname, $visiblename, $description, $defaultsetting) {
$this->name2 = $minutesname;
parent::admin_setting($hoursname, $visiblename, $description, $defaultsetting);
}
function get_setting() {
$result1 = $this->config_read($this->name);
$result2 = $this->config_read($this->name2);
if (is_null($result1) or is_null($result2)) {
return NULL;
}
return array('h' => $result1, 'm' => $result2);
}
function write_setting($data) {
if (!is_array($data)) {
return '';
}
$result = $this->config_write($this->name, (int)$data['h']) && $this->config_write($this->name2, (int)$data['m']);
return ($result ? '' : get_string('errorsetting', 'admin'));
}
function output_html($data, $query='') {
$default = $this->get_defaultsetting();
if (is_array($default)) {
$defaultinfo = $default['h'].':'.$default['m'];
} else {
$defaultinfo = NULL;
}
$return = '
'.
':
';
return format_admin_setting($this, $this->visiblename, $return, $this->description, false, '', $defaultinfo, $query);
}
}
class admin_setting_configiplist extends admin_setting_configtextarea {
function validate($data) {
if(!empty($data)) {
$ips = explode("\n", $data);
} else {
return true;
}
$result = true;
foreach($ips as $ip) {
$ip = trim($ip);
if(preg_match('#^(\d{1,3})(\.\d{1,3}){0,3}$#', $ip, $match) ||
preg_match('#^(\d{1,3})(\.\d{1,3}){0,3}(\/\d{1,2})$#', $ip, $match) ||
preg_match('#^(\d{1,3})(\.\d{1,3}){3}(-\d{1,3})$#', $ip, $match)) {
$result = true;
} else {
$result = false;
break;
}
}
if($result){
return true;
} else {
return get_string('validateerror', 'admin');
}
}
}
/**
* An admin setting for selecting one or more users, who have a particular capability
* in the system context. Warning, make sure the list will never be too long. There is
* no paging or searching of this list.
*
* To correctly get a list of users from this config setting, you need to call the
* get_users_from_config($CFG->mysetting, $capability); function in moodlelib.php.
*/
class admin_setting_users_with_capability extends admin_setting_configmultiselect {
protected $capability;
/**
* Constructor.
*
* @param string $name unique ascii name, either 'mysetting' for settings that in config, or 'myplugin/mysetting' for ones in config_plugins.
* @param string $visiblename localised name
* @param string $description localised long description
* @param array $defaultsetting array of usernames
* @param string $capability string capability name.
*/
function __construct($name, $visiblename, $description, $defaultsetting, $capability) {
$users = get_users_by_capability(get_context_instance(CONTEXT_SYSTEM),
$capability, 'username,firstname,lastname', 'lastname,firstname');
$choices = array(
'$@NONE@$' => get_string('nobody'),
'$@ALL@$' => get_string('everyonewhocan', 'admin', get_capability_string($capability)),
);
foreach ($users as $user) {
$choices[$user->username] = fullname($user);
}
parent::admin_setting_configmultiselect($name, $visiblename, $description, $defaultsetting, $choices);
}
function get_defaultsetting() {
$this->load_choices();
if (empty($this->defaultsetting)) {
return array('$@NONE@$');
} else if (array_key_exists($this->defaultsetting, $this->choices)) {
return $this->defaultsetting;
} else {
return '';
}
}
function get_setting() {
$result = parent::get_setting();
if (empty($result)) {
$result = array('$@NONE@$');
}
return $result;
}
function write_setting($data) {
// If all is selected, remove any explicit options.
if (in_array('$@ALL@$', $data)) {
$data = array('$@ALL@$');
}
// None never needs to be writted to the DB.
if (in_array('$@NONE@$', $data)) {
unset($data[array_search('$@NONE@$', $data)]);
}
return parent::write_setting($data);
}
}
/**
* Special checkbox for calendar - resets SESSION vars.
*/
class admin_setting_special_adminseesall extends admin_setting_configcheckbox {
function admin_setting_special_adminseesall() {
parent::admin_setting_configcheckbox('calendar_adminseesall', get_string('adminseesall', 'admin'),
get_string('helpadminseesall', 'admin'), '0');
}
function write_setting($data) {
global $SESSION;
unset($SESSION->cal_courses_shown);
return parent::write_setting($data);
}
}
/**
* Special select for settings that are altered in setup.php and can not be altered on the fly
*/
class admin_setting_special_selectsetup extends admin_setting_configselect {
function get_setting() {
// read directly from db!
return get_config(NULL, $this->name);
}
function write_setting($data) {
global $CFG;
// do not change active CFG setting!
$current = $CFG->{$this->name};
$result = parent::write_setting($data);
$CFG->{$this->name} = $current;
return $result;
}
}
/**
* Special select for frontpage - stores data in course table
*/
class admin_setting_sitesetselect extends admin_setting_configselect {
function get_setting() {
$site = get_site();
return $site->{$this->name};
}
function write_setting($data) {
global $DB;
if (!in_array($data, array_keys($this->choices))) {
return get_string('errorsetting', 'admin');
}
$record = new stdClass();
$record->id = SITEID;
$temp = $this->name;
$record->$temp = $data;
$record->timemodified = time();
return ($DB->update_record('course', $record) ? '' : get_string('errorsetting', 'admin'));
}
}
/**
* Special select - lists on the frontpage - hacky
*/
class admin_setting_courselist_frontpage extends admin_setting {
var $choices;
function admin_setting_courselist_frontpage($loggedin) {
global $CFG;
require_once($CFG->dirroot.'/course/lib.php');
$name = 'frontpage'.($loggedin ? 'loggedin' : '');
$visiblename = get_string('frontpage'.($loggedin ? 'loggedin' : ''),'admin');
$description = get_string('configfrontpage'.($loggedin ? 'loggedin' : ''),'admin');
$defaults = array(FRONTPAGECOURSELIST);
parent::admin_setting($name, $visiblename, $description, $defaults);
}
function load_choices() {
global $DB;
if (is_array($this->choices)) {
return true;
}
$this->choices = array(FRONTPAGENEWS => get_string('frontpagenews'),
FRONTPAGECOURSELIST => get_string('frontpagecourselist'),
FRONTPAGECATEGORYNAMES => get_string('frontpagecategorynames'),
FRONTPAGECATEGORYCOMBO => get_string('frontpagecategorycombo'),
'none' => get_string('none'));
if ($this->name == 'frontpage' and $DB->count_records('course') > FRONTPAGECOURSELIMIT) {
unset($this->choices[FRONTPAGECOURSELIST]);
}
return true;
}
function get_setting() {
$result = $this->config_read($this->name);
if (is_null($result)) {
return NULL;
}
if ($result === '') {
return array();
}
return explode(',', $result);
}
function write_setting($data) {
if (!is_array($data)) {
return '';
}
$this->load_choices();
$save = array();
foreach($data as $datum) {
if ($datum == 'none' or !array_key_exists($datum, $this->choices)) {
continue;
}
$save[$datum] = $datum; // no duplicates
}
return ($this->config_write($this->name, implode(',', $save)) ? '' : get_string('errorsetting', 'admin'));
}
function output_html($data, $query='') {
$this->load_choices();
$currentsetting = array();
foreach ($data as $key) {
if ($key != 'none' and array_key_exists($key, $this->choices)) {
$currentsetting[] = $key; // already selected first
}
}
$return = '
';
$addable = 0;
foreach ($plugins as $p) {
if (!portfolio_static_function($p, 'allows_multiple') && in_array($p, $alreadyplugins)) {
continue;
}
if (array_key_exists($p, $insane)) {
continue;
}
$instancehtml .= '' . portfolio_static_function($p, 'get_name') . ' (' . s($p) . ')' . ' ' . "\n";
$addable++;
}
if ($addable) {
$output .= $instancehtml;
}
$output .= print_simple_box_end(true);
return highlight($query, $output);
}
}
/**
* Initialise admin page - this function does require login and permission
* checks specified in page definition.
* This function must be called on each admin page before other code.
* @param string $section name of page
* @param string $extrabutton extra HTML that is added after the blocks editing on/off button.
* @param string $extraurlparams an array paramname => paramvalue, or parameters that need to be
* added to the turn blocks editing on/off form, so this page reloads correctly.
* @param string $actualurl if the actual page being viewed is not the normal one for this
* page (e.g. admin/roles/allowassin.php, instead of admin/roles/manage.php, you can pass the alternate URL here.
*/
function admin_externalpage_setup($section, $extrabutton='', $extraurlparams=array(), $actualurl='') {
global $CFG, $PAGE, $USER;
require_once($CFG->libdir.'/blocklib.php');
require_once($CFG->dirroot.'/'.$CFG->admin.'/pagelib.php');
if ($site = get_site()) {
require_login();
} else {
redirect($CFG->wwwroot.'/'.$CFG->admin.'/index.php');
die;
}
$adminroot =& admin_get_root(false, false); // settings not required for external pages
$extpage =& $adminroot->locate($section);
if (empty($extpage) or !is_a($extpage, 'admin_externalpage')) {
print_error('sectionerror', 'admin', "$CFG->wwwroot/$CFG->admin/");
die;
}
// this eliminates our need to authenticate on the actual pages
if (!($extpage->check_access())) {
print_error('accessdenied', 'admin');
die;
}
page_map_class(PAGE_ADMIN, 'page_admin');
$PAGE = page_create_object(PAGE_ADMIN, 0); // there must be any constant id number
$PAGE->init_extra($section); // hack alert!
$PAGE->set_extra_button($extrabutton);
$PAGE->set_extra_url_params($extraurlparams, $actualurl);
$adminediting = optional_param('adminedit', -1, PARAM_BOOL);
if (!isset($USER->adminediting)) {
$USER->adminediting = false;
}
if ($PAGE->user_allowed_editing()) {
if ($adminediting == 1) {
$USER->adminediting = true;
} elseif ($adminediting == 0) {
$USER->adminediting = false;
}
}
}
/**
* Print header for admin page
* @param string $focus focus element
*/
function admin_externalpage_print_header($focus='') {
if (!is_string($focus)) {
$focus = ''; // BC compatibility, there used to be adminroot parameter
}
global $CFG, $PAGE, $SITE, $THEME;
define('ADMIN_EXT_HEADER_PRINTED', 'true');
if (!empty($SITE->fullname)) {
$pageblocks = blocks_setup($PAGE);
$preferred_width_left = bounded_number(BLOCK_L_MIN_WIDTH,
blocks_preferred_width($pageblocks[BLOCK_POS_LEFT]),
BLOCK_L_MAX_WIDTH);
$preferred_width_right = bounded_number(BLOCK_R_MIN_WIDTH,
blocks_preferred_width($pageblocks[BLOCK_POS_RIGHT]),
BLOCK_R_MAX_WIDTH);
$PAGE->print_header('', $focus);
echo '
';
$lt = (empty($THEME->layouttable)) ? array('left', 'middle', 'right') : $THEME->layouttable;
foreach ($lt as $column) {
$lt1[] = $column;
if ($column == 'middle') break;
}
foreach ($lt1 as $column) {
switch ($column) {
case 'left':
echo '
';
print_container_start(true);
$THEME->open_header_containers++; // this is hacky workaround for the print_error()/notice() autoclosing problems on admin pages
break;
case 'right':
if (blocks_have_content($pageblocks, BLOCK_POS_RIGHT)) {
echo '
';
break;
case 'middle':
print_container_end();
$THEME->open_header_containers--; // this is hacky workaround for the print_error()/notice() autoclosing problems on admin pages
echo '';
break;
case 'right':
if (blocks_have_content($pageblocks, BLOCK_POS_RIGHT)) {
echo '
';
$adminroot =& admin_get_root();
if (array_key_exists($fullname, $adminroot->errors)) {
$str = '';
}
return $str;
}
/**
* Try to upgrade the given language pack (or current language)
* If it doesn't work, fail silently and return false
*/
function upgrade_language_pack($lang='') {
global $CFG;
if (empty($lang)) {
$lang = current_language();
}
if ($lang == 'en_utf8') {
return true; // Nothing to do
}
notify(get_string('langimport', 'admin').': '.$lang.' ... ', 'notifysuccess');
@mkdir ($CFG->dataroot.'/temp/'); //make it in case it's a fresh install, it might not be there
@mkdir ($CFG->dataroot.'/lang/');
require_once($CFG->libdir.'/componentlib.class.php');
if ($cd = new component_installer('http://download.moodle.org', 'lang16', $lang.'.zip', 'languages.md5', 'lang')) {
$status = $cd->install(); //returns COMPONENT_(ERROR | UPTODATE | INSTALLED)
if ($status == COMPONENT_INSTALLED) {
debugging('Downloading successful: '.$lang);
@unlink($CFG->dataroot.'/cache/languages');
return true;
}
}
return false;
}
/**
* Based on find_new_settings{@link ()} in upgradesettings.php
* Looks to find any admin settings that have not been initialized. Returns 1 if it finds any.
*
* @param string $node The node at which to start searching.
* @return boolen true if any settings haven't been initialised, false if they all have
*/
function any_new_admin_settings($node) {
if (is_a($node, 'admin_category')) {
$entries = array_keys($node->children);
foreach ($entries as $entry) {
if (any_new_admin_settings($node->children[$entry])){
return true;
}
}
} else if (is_a($node, 'admin_settingpage')) {
foreach ($node->settings as $setting) {
if ($setting->get_setting() === NULL) {
return true;
}
}
}
return false;
}
/**
* Moved from admin/replace.php so that we can use this in cron
* @param string $search - string to look for
* @param string $replace - string to replace
* @return bool - success or fail
*/
function db_replace($search, $replace) {
global $DB, $CFG;
/// Turn off time limits, sometimes upgrades can be slow.
@set_time_limit(0);
@ob_implicit_flush(true);
while(@ob_end_flush());
if (!$tables = $DB->get_tables() ) { // No tables yet at all.
return false;
}
foreach ($tables as $table) {
if (in_array($table, array('config'))) { // Don't process these
continue;
}
if ($columns = $DB->get_columns($table)) {
$DB->set_debug(true);
foreach ($columns as $column => $data) {
if (in_array($data->meta_type, array('C', 'X'))) { // Text stuff only
$DB->execute("UPDATE {".$table."} SET $column = REPLACE($column, ?, ?)", array($search, $replace));
}
}
$DB->set_debug(false);
}
}
return true;
}
/**
* Prints tables of detected plugins, one table per plugin type,
* and prints whether they are part of the standard Moodle
* distribution or not.
*/
function print_plugin_tables() {
global $DB;
$plugins_standard = array();
$plugins_standard['mod'] = array('assignment',
'chat',
'choice',
'data',
'feedback',
'forum',
'glossary',
'hotpot',
'label',
'lesson',
'quiz',
'resource',
'scorm',
'survey',
'wiki');
$plugins_standard['blocks'] = array('activity_modules',
'admin',
'admin_bookmarks',
'admin_tree',
'blog_menu',
'blog_tags',
'calendar_month',
'calendar_upcoming',
'course_list',
'course_summary',
'glossary_random',
'html',
'loancalc',
'login',
'mentees',
'messages',
'mnet_hosts',
'news_items',
'online_users',
'participants',
'quiz_results',
'recent_activity',
'rss_client',
'search',
'search_forums',
'section_links',
'site_main_menu',
'social_activities',
'tag_flickr',
'tag_youtube',
'tags');
$plugins_standard['filter'] = array('activitynames',
'algebra',
'censor',
'emailprotect',
'filter',
'mediaplugin',
'multilang',
'tex',
'tidy');
$plugins_installed = array();
$installed_mods = $DB->get_records('modules', null, 'name');
$installed_blocks = $DB->get_records('block', null, 'name');
foreach($installed_mods as $mod) {
$plugins_installed['mod'][] = $mod->name;
}
foreach($installed_blocks as $block) {
$plugins_installed['blocks'][] = $block->name;
}
$plugins_ondisk = array();
$plugins_ondisk['mod'] = get_list_of_plugins('mod', 'db');
$plugins_ondisk['blocks'] = get_list_of_plugins('blocks', 'db');
$plugins_ondisk['filter'] = get_list_of_plugins('filter', 'db');
$strstandard = get_string('standard');
$strnonstandard = get_string('nonstandard');
$strmissingfromdisk = '(' . get_string('missingfromdisk') . ')';
$strabouttobeinstalled = '(' . get_string('abouttobeinstalled') . ')';
$html = '';
$html .= '
\n";
$row = 1;
foreach ($list_ondisk as $k => $plugin) {
$status = 'ok';
$standard = 'standard';
$note = '';
if (!in_array($plugin, $plugins_standard[$cat])) {
$standard = 'nonstandard';
$status = 'warning';
}
// Get real name and full path of plugin
$plugin_name = "[[$plugin]]";
$plugin_path = "$cat/$plugin";
$plugin_name = get_plugin_name($plugin, $cat);
// Determine if the plugin is about to be installed
if ($cat != 'filter' && !in_array($plugin, $plugins_installed[$cat])) {
$note = $strabouttobeinstalled;
$plugin_name = $plugin;
}
$html .= "
\n"
. "
$plugin_path
\n"
. "
$plugin_name
\n"
. "
" . ${'str' . $standard} . " $note
\n
\n";
$row++;
// If the plugin was both on disk and in the db, unset the value from the installed plugins list
if ($key = array_search($plugin, $plugins_installed[$cat])) {
unset($plugins_installed[$cat][$key]);
}
}
// If there are plugins left in the plugins_installed list, it means they are missing from disk
foreach ($plugins_installed[$cat] as $k => $missing_plugin) {
// Make sure the plugin really is missing from disk
if (!in_array($missing_plugin, $plugins_ondisk[$cat])) {
$standard = 'standard';
$status = 'warning';
if (!in_array($missing_plugin, $plugins_standard[$cat])) {
$standard = 'nonstandard';
}
$plugin_name = $missing_plugin;
$html .= "
\n"
. "
?
\n"
. "
$plugin_name
\n"
. "
" . ${'str' . $standard} . " $strmissingfromdisk
\n
\n";
$row++;
}
}
$html .= '
';
}
$html .= '
';
echo $html;
}
class admin_setting_managerepository extends admin_setting {
private $baseurl;
function admin_setting_managerepository() {
global $CFG;
parent::admin_setting('managerepository', get_string('managerepository', 'repository'), '', '');
$this->baseurl = $CFG->wwwroot . '/' . $CFG->admin . '/repository.php?sesskey=' . sesskey();
}
function get_setting() {
return true;
}
function get_defaultsetting() {
return true;
}
function get_full_name() {
return 's_managerepository';
}
function write_setting($data) {
$url = $this->baseurl . '&new=' . $data;
// TODO
// Should not use redirect and exit here
// Find a better way to do this.
// redirect($url);
// exit;
}
function is_related($query) {
if (parent::is_related($query)) {
return true;
}
$textlib = textlib_get_instance();
$repositories= get_list_of_plugins('repository');
foreach ($repositories as $p) {
if (strpos($p, $query) !== false) {
return true;
}
}
foreach (repository::get_types() as $instance) {
$title = $instance->get_typename();
if (strpos($textlib->strtolower($title), $query) !== false) {
return true;
}
}
return false;
}
function output_html($data, $query='') {
global $CFG, $USER;
$output = print_box_start('generalbox','',true);
$namestr = get_string('name');
$settingsstr = get_string('settings');
$updownstr = get_string('updown', 'repository');
$hiddenstr = get_string('hiddenshow', 'repository');
$deletestr = get_string('delete');
$plugins = get_list_of_plugins('repository');
$instances = repository::get_types();
$instancesnumber = count($instances);
$alreadyplugins = array();
$table = new StdClass;
$table->head = array($namestr, $updownstr, $hiddenstr, $deletestr, $settingsstr);
$table->align = array('left', 'center', 'center','center','center');
$table->data = array();
$updowncount=1;
foreach ($instances as $i) {
$settings = '';
//display edit link only if you can config the type or if it has multiple instances (e.g. has instance config)
$typeoptionnames = repository::static_function($i->get_typename(), 'get_type_option_names');
$instanceoptionnames = repository::static_function($i->get_typename(), 'get_instance_option_names');
if ( !empty($typeoptionnames) || !empty($instanceoptionnames)) {
$settings .= ''
. $settingsstr .'' . "\n";
}
$delete = ''
. $deletestr . '' . "\n";
$hidetitle = $i->get_visible() ? get_string('clicktohide', 'repository') : get_string('clicktoshow', 'repository');
$hiddenshow = ' '
.''
.'' . "\n";
// display up/down link
$updown = '';
if ($updowncount > 1) {
$updown .= "baseurl&move=up&type=".$i->get_typename()."\">";
$updown .= "pixpath}/t/up.gif\" alt=\"up\" /> ";
}
else {
$updown .= "pixpath}/spacer.gif\" class=\"icon\" alt=\"\" /> ";
}
if ($updowncount < count($instances)) {
$updown .= "baseurl&move=down&type=".$i->get_typename()."\">";
$updown .= "pixpath}/t/down.gif\" alt=\"down\" />";
}
else {
$updown .= "pixpath}/spacer.gif\" class=\"icon\" alt=\"\" />";
}
$updowncount++;
$table->data[] = array($i->get_readablename(), $updown, $hiddenshow, $delete, $settings);
//display a grey row if the type is defined as not visible
if (!$i->get_visible()){
$table->rowclass[] = 'dimmed_text';
} else{
$table->rowclass[] = '';
}
if (!in_array($i->get_typename(), $alreadyplugins)) {
$alreadyplugins[] = $i->get_typename();
}
}
$output .= print_table($table, true);
$instancehtml = '
![\"$strup\"](\"$imgurl/up.gif\")
";
}
else {
$updown .= "![\"$strdown\"](\"$imgurl/down.gif\")
";
}
else {
$updown .= "
' . "\n";
$row .= '
' . "\n";
if (array_key_exists($i->get('plugin'), $insane) || array_key_exists($i->get('id'), $insaneinstances)) {
$row .= '
' . "\n";
} else {
$row .= '  ? 'hide' : 'show') . '.gif)
' . "\n";
}
$table->data[] = array($i->get('name'), $i->get_name() . ' (' . $i->get('plugin') . ')', $row);
if (!in_array($i->get('plugin'), $alreadyplugins)) {
$alreadyplugins[] = $i->get('plugin');
}
}
$output .= print_table($table, true);
$instancehtml = ' ? 'hide' : 'show') . '.gif "' . $hidetitle . '")
'
.'' . "\n";
// display up/down link
$updown = '';
if ($updowncount > 1) {
$updown .= "baseurl&move=up&type=".$i->get_typename()."\">";
$updown .= "