$DB->set_debug(true);
}
if (!empty($CFG->showcrondebugging)) {
- $CFG->debug = DEBUG_DEVELOPER;
- $CFG->debugdisplay = true;
+ set_debugging(DEBUG_DEVELOPER, true);
}
$starttime = microtime();
$CFG->early_install_lang = true;
$CFG->ostype = (stristr(PHP_OS, 'win') && !stristr(PHP_OS, 'darwin')) ? 'WINDOWS' : 'UNIX';
$CFG->dboptions = array();
+$CFG->debug = (E_ALL | E_STRICT);
+$CFG->debugdisplay = true;
+$CFG->debugdeveloper = true;
$parts = explode('/', str_replace('\\', '/', dirname(dirname(__FILE__))));
$CFG->admin = array_pop($parts);
if (function_exists('opcache_reset')) {
opcache_reset();
}
+ $cache = 0;
+
+} else {
+ $cache = 1;
}
require('../config.php');
$agreelicense = optional_param('agreelicense', 0, PARAM_BOOL);
$fetchupdates = optional_param('fetchupdates', 0, PARAM_BOOL);
$newaddonreq = optional_param('installaddonrequest', null, PARAM_RAW);
-$cache = optional_param('cache', 0, PARAM_BOOL);
// Set up PAGE.
$url = new moodle_url('/admin/index.php');
-if (!is_null($newaddonreq)) {
- // We need to set the eventual add-on installation request in the $PAGE's URL
- // so that it is stored in $SESSION->wantsurl and the admin is redirected
- // correctly once they are logged-in.
- $url->param('installaddonrequest', $newaddonreq);
-}
if ($cache) {
- $url->param('cache', $cache);
+ $url->param('cache', 1);
}
$PAGE->set_url($url);
unset($url);
+// Are we returning from an add-on installation request at moodle.org/plugins?
+if ($newaddonreq and !$cache and empty($CFG->disableonclickaddoninstall)) {
+ $target = new moodle_url('/admin/tool/installaddon/index.php', array(
+ 'installaddonrequest' => $newaddonreq,
+ 'confirm' => 0));
+ if (!isloggedin() or isguestuser()) {
+ // Login and go the the add-on tool page.
+ $SESSION->wantsurl = $target->out();
+ redirect(get_login_url());
+ }
+ redirect($target);
+}
+
$PAGE->set_pagelayout('admin'); // Set a default pagelayout
$documentationlink = '<a href="http://docs.moodle.org/en/Installation">Installation docs</a>';
$PAGE->set_heading($strinstallation);
$PAGE->set_cacheable(false);
+ /** @var core_admin_renderer $output */
$output = $PAGE->get_renderer('core', 'admin');
echo $output->install_licence_page();
die();
$PAGE->set_heading($strinstallation . ' - Moodle ' . $CFG->target_release);
$PAGE->set_cacheable(false);
+ /** @var core_admin_renderer $output */
$output = $PAGE->get_renderer('core', 'admin');
echo $output->install_environment_page($maturity, $envstatus, $environment_results, $release);
die();
}
// Detect config cache inconsistency, this happens when you switch branches on dev servers.
-if ($cache) {
- if ($CFG->version != $DB->get_field('config', 'value', array('name'=>'version'))) {
- purge_all_caches();
- redirect(new moodle_url('/admin/index.php'), 'Config cache inconsistency detected, resetting caches...');
- }
+if ($CFG->version != $DB->get_field('config', 'value', array('name'=>'version'))) {
+ purge_all_caches();
+ redirect(new moodle_url('/admin/index.php'), 'Config cache inconsistency detected, resetting caches...');
}
-if ($version > $CFG->version) { // upgrade
+if (!$cache and $version > $CFG->version) { // upgrade
// We purge all of MUC's caches here.
// Caches are disabled for upgrade by CACHE_DISABLE_ALL so we must set the first arg to true.
// This ensures a real config object is loaded and the stores will be purged.
$PAGE->set_title($stradministration);
$PAGE->set_cacheable(false);
+ /** @var core_admin_renderer $output */
$output = $PAGE->get_renderer('core', 'admin');
echo $output->upgrade_stale_php_files_page();
die();
$PAGE->set_heading($strdatabasechecking);
$PAGE->set_cacheable(false);
+ /** @var core_admin_renderer $output */
$output = $PAGE->get_renderer('core', 'admin');
echo $output->upgrade_confirm_page($a->newversion, $maturity);
die();
$PAGE->set_heading($strcurrentrelease);
$PAGE->set_cacheable(false);
+ /** @var core_admin_renderer $output */
$output = $PAGE->get_renderer('core', 'admin');
echo $output->upgrade_environment_page($release, $envstatus, $environment_results);
die();
$reloadurl = new moodle_url('/admin/index.php', array('confirmupgrade' => 1, 'confirmrelease' => 1));
+ /** @var core_admin_renderer $output */
+ $output = $PAGE->get_renderer('core', 'admin');
+
// check plugin dependencies first
$failed = array();
if (!plugin_manager::instance()->all_plugins_ok($version, $failed)) {
- $output = $PAGE->get_renderer('core', 'admin');
echo $output->unsatisfied_dependencies_page($version, $failed, $reloadurl);
die();
}
redirect($reloadurl);
}
- $output = $PAGE->get_renderer('core', 'admin');
-
$deployer = available_update_deployer::instance();
if ($deployer->enabled()) {
$deployer->initialize($reloadurl, $reloadurl);
}
// Updated human-readable release version if necessary
-if ($release <> $CFG->release) { // Update the release version
+if (!$cache and $release <> $CFG->release) { // Update the release version
set_config('release', $release);
}
-if ($branch <> $CFG->branch) { // Update the branch
+if (!$cache and $branch <> $CFG->branch) { // Update the branch
set_config('branch', $branch);
}
-if (moodle_needs_upgrading()) {
+if (!$cache and moodle_needs_upgrading()) {
if (!$PAGE->headerprinted) {
// means core upgrade or installation was not already done
if (!$confirmplugins) {
// Now we can be sure everything was upgraded and caches work fine,
// redirect if necessary to make sure caching is enabled.
-if (!$cache and !optional_param('sesskey', '', PARAM_RAW)) {
- redirect(new moodle_url($PAGE->url, array('cache' => 1)));
+if (!$cache) {
+ redirect(new moodle_url('/admin/index.php', array('cache' => 1)));
}
// Check for valid admin user - no guest autologin
set_config('registered', time());
}
-// Check if we are returning from an add-on installation request at moodle.org/plugins
-if (!is_null($newaddonreq)) {
- if (!empty($CFG->disableonclickaddoninstall)) {
- // The feature is disabled in config.php, ignore the request.
- } else {
- redirect(new moodle_url('/admin/tool/installaddon/index.php', array(
- 'installaddonrequest' => $newaddonreq,
- 'confirm' => 0)));
- }
-}
-
// setup critical warnings before printing admin tree block
$insecuredataroot = is_dataroot_insecure(true);
$SESSION->admin_critical_warning = ($insecuredataroot==INSECURE_DATAROOT_ERROR);
require_once($CFG->libdir . '/pluginlib.php');
require_once($CFG->libdir . '/filelib.php');
-admin_externalpage_setup('pluginsoverview');
-require_capability('moodle/site:config', context_system::instance());
-
$fetchremote = optional_param('fetchremote', false, PARAM_BOOL);
$updatesonly = optional_param('updatesonly', false, PARAM_BOOL);
$contribonly = optional_param('contribonly', false, PARAM_BOOL);
$delete = optional_param('delete', '', PARAM_COMPONENT);
$confirmed = optional_param('confirm', false, PARAM_BOOL);
-$output = $PAGE->get_renderer('core', 'admin');
+// NOTE: do not use admin_externalpage_setup() here because it loads
+// full admin tree which is not possible during uninstallation.
+
+require_login();
+$syscontext = context_system::instance();
+require_capability('moodle/site:config', $syscontext);
$pluginman = plugin_manager::instance();
if ($uninstall) {
require_sesskey();
+
+ if (!$confirmed) {
+ admin_externalpage_setup('pluginsoverview');
+ } else {
+ $PAGE->set_url('/admin/plugins.php');
+ $PAGE->set_context($syscontext);
+ $PAGE->set_pagelayout('maintenance');
+ $PAGE->set_popup_notification_allowed(false);
+ }
+
+ /** @var core_admin_renderer $output */
+ $output = $PAGE->get_renderer('core', 'admin');
+
$pluginfo = $pluginman->get_plugin_info($uninstall);
// Make sure we know the plugin.
if ($delete and $confirmed) {
require_sesskey();
+
+ $PAGE->set_url('/admin/plugins.php');
+ $PAGE->set_context($syscontext);
+ $PAGE->set_pagelayout('maintenance');
+ $PAGE->set_popup_notification_allowed(false);
+
+ /** @var core_admin_renderer $output */
+ $output = $PAGE->get_renderer('core', 'admin');
+
$pluginfo = $pluginman->get_plugin_info($delete);
// Make sure we know the plugin.
if (function_exists('opcache_reset')) {
opcache_reset();
}
- redirect($PAGE->url);
+ // We need to execute upgrade to make sure everything including caches is up to date.
+ redirect(new moodle_url('/admin/index.php'));
}
+admin_externalpage_setup('pluginsoverview');
+
+/** @var core_admin_renderer $output */
+$output = $PAGE->get_renderer('core', 'admin');
+
$checker = available_update_checker::instance();
// Filtering options.
print_error('cannotdeletemissingbehaviour', 'question', $thispageurl);
}
- if (!isset($behaviours[$delete])) {
+ if (!isset($behaviours[$delete]) && !get_config('qbehaviour_' . $delete, 'version')) {
print_error('unknownbehaviour', 'question', $thispageurl, $delete);
}
echo $OUTPUT->header();
echo $OUTPUT->heading(get_string('deletingbehaviour', 'question', $behaviourname));
- // Delete any configuration records.
- if (!unset_all_config_for_plugin('qbehaviour_' . $delete)) {
- echo $OUTPUT->notification(get_string('errordeletingconfig', 'admin', 'qbehaviour_' . $delete));
- }
+ // Remove this behaviour from configurations where it might appear.
if (($key = array_search($delete, $disabledbehaviours)) !== false) {
unset($disabledbehaviours[$key]);
set_config('disabledbehaviours', implode(',', $disabledbehaviours), 'question');
set_config('behavioursortorder', implode(',', $behaviourorder), 'question');
}
- // Then the tables themselves
- drop_plugin_tables($delete, core_component::get_plugin_directory('qbehaviour', $delete) . '/db/install.xml', false);
-
- // Remove event handlers and dequeue pending events
- events_uninstall('qbehaviour_' . $delete);
+ // Then uninstall the plugin.
+ uninstall_plugin('qbehaviour', $delete);
+ // Display a message.
$a = new stdClass();
$a->behaviour = $behaviourname;
$a->directory = core_component::get_plugin_directory('qbehaviour', $delete);
print_error('cannotdeletemissingqtype', 'question', $thispageurl);
}
- if (!isset($qtypes[$delete])) {
+ if (!isset($qtypes[$delete]) && !get_config('qtype_' . $delete, 'version')) {
print_error('unknownquestiontype', 'question', $thispageurl, $delete);
}
echo $OUTPUT->header();
echo $OUTPUT->heading(get_string('deletingqtype', 'question', $qtypename));
- // Delete any configuration records.
- if (!unset_all_config_for_plugin('qtype_' . $delete)) {
- echo $OUTPUT->notification(get_string('errordeletingconfig', 'admin', 'qtype_' . $delete));
- }
+ // Delete any questoin configuration records mentioning this plugin.
unset_config($delete . '_disabled', 'question');
unset_config($delete . '_sortorder', 'question');
- // Then the tables themselves
- drop_plugin_tables($delete, $qtypes[$delete]->plugin_dir() . '/db/install.xml', false);
-
- // Remove event handlers and dequeue pending events
- events_uninstall('qtype_' . $delete);
+ // Then uninstall the plugin.
+ uninstall_plugin('qtype', $delete);
$a = new stdClass();
$a->qtype = $qtypename;
public function upgrade_confirm_page($strnewversion, $maturity) {
$output = '';
- $continueurl = new moodle_url('index.php', array('confirmupgrade' => 1));
- $cancelurl = new moodle_url('index.php');
+ $continueurl = new moodle_url('/admin/index.php', array('confirmupgrade' => 1));
+ $continue = new single_button($continueurl, get_string('continue'), 'get');
+ $cancelurl = new moodle_url('/admin/index.php');
$output .= $this->header();
$output .= $this->maturity_warning($maturity);
- $output .= $this->confirm(get_string('upgradesure', 'admin', $strnewversion), $continueurl, $cancelurl);
+ $output .= $this->confirm(get_string('upgradesure', 'admin', $strnewversion), $continue, $cancelurl);
$output .= $this->footer();
return $output;
$pluginname = $pluginman->plugin_name($pluginfo->component);
+ // Do not show navigation here, they must click one of the buttons.
+ $this->page->set_pagelayout('maintenance');
+ $this->page->set_cacheable(false);
+
$output .= $this->output->header();
$output .= $this->output->heading(get_string('uninstalling', 'core_plugin', array('name' => $pluginname)));
'uninstalldeleteconfirmexternal');
}
- $output .= $this->output->confirm($confirm, $continueurl, $this->page->url);
+ // After any uninstall we must execute full upgrade to finish the cleanup!
+ $output .= $this->output->confirm($confirm, $continueurl, new moodle_url('/admin/index.php'));
$output .= $this->output->footer();
return $output;
if (!$registered) {
- $registerbutton = $this->single_button(new moodle_url('registration/register.php',
+ $registerbutton = $this->single_button(new moodle_url('/admin/registration/register.php',
array('huburl' => HUB_MOODLEORGHUBURL, 'hubname' => 'Moodle.org')),
get_string('register', 'admin'));
--- /dev/null
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Backend code for the 'make large course' tool.
+ *
+ * @package tool_generator
+ * @copyright 2013 The Open University
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class tool_generator_backend {
+ /**
+ * @var int Lowest (smallest) size index
+ */
+ const MIN_SIZE = 0;
+ /**
+ * @var int Highest (largest) size index
+ */
+ const MAX_SIZE = 5;
+ /**
+ * @var int Default size index
+ */
+ const DEFAULT_SIZE = 3;
+
+ /**
+ * @var array Number of sections in course
+ */
+ private static $paramsections = array(1, 10, 100, 500, 1000, 2000);
+ /**
+ * @var array Number of Page activities in course
+ */
+ private static $parampages = array(1, 50, 200, 1000, 5000, 10000);
+ /**
+ * @var array Number of students enrolled in course
+ */
+ private static $paramusers = array(1, 100, 1000, 10000, 50000, 100000);
+ /**
+ * Total size of small files: 1KB, 1MB, 10MB, 100MB, 1GB, 2GB.
+ *
+ * @var array Number of small files created in a single file activity
+ */
+ private static $paramsmallfilecount = array(1, 64, 128, 1024, 16384, 32768);
+ /**
+ * @var array Size of small files (to make the totals into nice numbers)
+ */
+ private static $paramsmallfilesize = array(1024, 16384, 81920, 102400, 65536, 65536);
+ /**
+ * Total size of big files: 8KB, 8MB, 80MB, 800MB, 8GB, 16GB.
+ *
+ * @var array Number of big files created as individual file activities
+ */
+ private static $parambigfilecount = array(1, 2, 5, 10, 10, 10);
+ /**
+ * @var array Size of each large file
+ */
+ private static $parambigfilesize = array(8192, 4194304, 16777216, 83886080,
+ 858993459, 1717986918);
+ /**
+ * @var array Number of forum discussions
+ */
+ private static $paramforumdiscussions = array(1, 10, 100, 500, 1000, 2000);
+ /**
+ * @var array Number of forum posts per discussion
+ */
+ private static $paramforumposts = array(2, 2, 5, 10, 10, 10);
+
+ /**
+ * @var string Course shortname
+ */
+ private $shortname;
+
+ /**
+ * @var int Size code (index in the above arrays)
+ */
+ private $size;
+
+ /**
+ * @var bool True if displaying progress
+ */
+ private $progress;
+
+ /**
+ * @var testing_data_generator Data generator
+ */
+ private $generator;
+
+ /**
+ * @var stdClass Course object
+ */
+ private $course;
+
+ /**
+ * @var int Epoch time at which last dot was displayed
+ */
+ private $lastdot;
+
+ /**
+ * @var int Epoch time at which last percentage was displayed
+ */
+ private $lastpercentage;
+
+ /**
+ * @var int Epoch time at which current step (current set of dots) started
+ */
+ private $starttime;
+
+ /**
+ * @var array Array from test user number (1...N) to userid in database
+ */
+ private $userids;
+
+ /**
+ * Constructs object ready to create course.
+ *
+ * @param string $shortname Course shortname
+ * @param int $size Size as numeric index
+ * @param bool $progress True if progress information should be displayed
+ * @return int Course id
+ * @throws coding_exception If parameters are invalid
+ */
+ public function __construct($shortname, $size, $progress = true) {
+ // Check parameter.
+ if ($size < self::MIN_SIZE || $size > self::MAX_SIZE) {
+ throw new coding_exception('Invalid size');
+ }
+
+ // Set parameters.
+ $this->shortname = $shortname;
+ $this->size = $size;
+ $this->progress = $progress;
+ }
+
+ /**
+ * Gets a list of size choices supported by this backend.
+ *
+ * @return array List of size (int) => text description for display
+ */
+ public static function get_size_choices() {
+ $options = array();
+ for ($size = self::MIN_SIZE; $size <= self::MAX_SIZE; $size++) {
+ $options[$size] = get_string('size_' . $size, 'tool_generator');
+ }
+ return $options;
+ }
+
+ /**
+ * Converts a size name into the numeric constant.
+ *
+ * @param string $sizename Size name e.g. 'L'
+ * @return int Numeric version
+ * @throws coding_exception If the size name is not known
+ */
+ public static function size_for_name($sizename) {
+ for ($size = self::MIN_SIZE; $size <= self::MAX_SIZE; $size++) {
+ if ($sizename == get_string('shortsize_' . $size, 'tool_generator')) {
+ return $size;
+ }
+ }
+ throw new coding_exception("Unknown size name '$sizename'");
+ }
+
+ /**
+ * Checks that a shortname is available (unused).
+ *
+ * @param string $shortname Proposed course shortname
+ * @return string An error message if the name is unavailable or '' if OK
+ */
+ public static function check_shortname_available($shortname) {
+ global $DB;
+ $fullname = $DB->get_field('course', 'fullname',
+ array('shortname' => $shortname), IGNORE_MISSING);
+ if ($fullname !== false) {
+ // I wanted to throw an exception here but it is not possible to
+ // use strings from moodle.php in exceptions, and I didn't want
+ // to duplicate the string in tool_generator, so I changed this to
+ // not use exceptions.
+ return get_string('shortnametaken', 'moodle', $fullname);
+ }
+ return '';
+ }
+
+ /**
+ * Runs the entire 'make' process.
+ *
+ * @return int Course id
+ */
+ public function make() {
+ global $DB, $CFG;
+ require_once($CFG->dirroot . '/lib/phpunit/classes/util.php');
+
+ raise_memory_limit(MEMORY_EXTRA);
+
+ if ($this->progress && !CLI_SCRIPT) {
+ echo html_writer::start_tag('ul');
+ }
+
+ $entirestart = microtime(true);
+
+ // Start transaction.
+ $transaction = $DB->start_delegated_transaction();
+
+ // Get generator.
+ $this->generator = phpunit_util::get_data_generator();
+
+ // Make course.
+ $this->course = $this->create_course();
+ $this->create_users();
+ $this->create_pages();
+ $this->create_small_files();
+ $this->create_big_files();
+ $this->create_forum();
+
+ // Log total time.
+ $this->log('complete', round(microtime(true) - $entirestart, 1));
+
+ if ($this->progress && !CLI_SCRIPT) {
+ echo html_writer::end_tag('ul');
+ }
+
+ // Commit transaction and finish.
+ $transaction->allow_commit();
+ return $this->course->id;
+ }
+
+ /**
+ * Creates the actual course.
+ *
+ * @return stdClass Course record
+ */
+ private function create_course() {
+ $this->log('createcourse', $this->shortname);
+ $courserecord = array('shortname' => $this->shortname,
+ 'fullname' => get_string('fullname', 'tool_generator',
+ array('size' => get_string('shortsize_' . $this->size, 'tool_generator'))),
+ 'numsections' => self::$paramsections[$this->size]);
+ return $this->generator->create_course($courserecord, array('createsections' => true));
+ }
+
+ /**
+ * Creates a number of user accounts and enrols them on the course.
+ * Note: Existing user accounts that were created by this system are
+ * reused if available.
+ */
+ private function create_users() {
+ global $DB;
+
+ // Work out total number of users.
+ $count = self::$paramusers[$this->size];
+
+ // Get existing users in order. We will 'fill up holes' in this up to
+ // the required number.
+ $this->log('checkaccounts', $count);
+ $nextnumber = 1;
+ $rs = $DB->get_recordset_select('user', $DB->sql_like('username', '?'),
+ array('tool_generator_%'), 'username', 'id, username');
+ foreach ($rs as $rec) {
+ // Extract number from username.
+ $matches = array();
+ if (!preg_match('~^tool_generator_([0-9]{6})$~', $rec->username, $matches)) {
+ continue;
+ }
+ $number = (int)$matches[1];
+
+ // Create missing users in range up to this.
+ if ($number != $nextnumber) {
+ $this->create_user_accounts($nextnumber, min($number - 1, $count));
+ } else {
+ $this->userids[$number] = (int)$rec->id;
+ }
+
+ // Stop if we've got enough users.
+ $nextnumber = $number + 1;
+ if ($number >= $count) {
+ break;
+ }
+ }
+ $rs->close();
+
+ // Create users from end of existing range.
+ if ($nextnumber <= $count) {
+ $this->create_user_accounts($nextnumber, $count);
+ }
+
+ // Assign all users to course.
+ $this->log('enrol', $count, true);
+
+ $enrolplugin = enrol_get_plugin('manual');
+ $instances = enrol_get_instances($this->course->id, true);
+ foreach ($instances as $instance) {
+ if ($instance->enrol === 'manual') {
+ break;
+ }
+ }
+ if ($instance->enrol !== 'manual') {
+ throw new coding_exception('No manual enrol plugin in course');
+ }
+ $role = $DB->get_record('role', array('shortname' => 'student'), '*', MUST_EXIST);
+
+ for ($number = 1; $number <= $count; $number++) {
+ // Enrol user.
+ $enrolplugin->enrol_user($instance, $this->userids[$number], $role->id);
+ $this->dot($number, $count);
+ }
+
+ $this->end_log();
+ }
+
+ /**
+ * Creates user accounts with a numeric range.
+ *
+ * @param int $first Number of first user
+ * @param int $last Number of last user
+ */
+ private function create_user_accounts($first, $last) {
+ $this->log('createaccounts', (object)array('from' => $first, 'to' => $last), true);
+ $count = $last - $first + 1;
+ $done = 0;
+ for ($number = $first; $number <= $last; $number++, $done++) {
+ // Work out username with 6-digit number.
+ $textnumber = (string)$number;
+ while (strlen($textnumber) < 6) {
+ $textnumber = '0' . $textnumber;
+ }
+ $username = 'tool_generator_' . $textnumber;
+
+ // Create user account.
+ $record = array('firstname' => get_string('firstname', 'tool_generator'),
+ 'lastname' => $number, 'username' => $username);
+ $user = $this->generator->create_user($record);
+ $this->userids[$number] = (int)$user->id;
+ $this->dot($done, $count);
+ }
+ $this->end_log();
+ }
+
+ /**
+ * Creates a number of Page activities.
+ */
+ private function create_pages() {
+ // Set up generator.
+ $pagegenerator = $this->generator->get_plugin_generator('mod_page');
+
+ // Create pages.
+ $number = self::$parampages[$this->size];
+ $this->log('createpages', $number, true);
+ for ($i=0; $i<$number; $i++) {
+ $record = array('course' => $this->course->id);
+ $options = array('section' => $this->get_random_section());
+ $pagegenerator->create_instance($record, $options);
+ $this->dot($i, $number);
+ }
+
+ $this->end_log();
+ }
+
+ /**
+ * Creates one resource activity with a lot of small files.
+ */
+ private function create_small_files() {
+ $count = self::$paramsmallfilecount[$this->size];
+ $this->log('createsmallfiles', $count, true);
+
+ // Create resource with default textfile only.
+ $resourcegenerator = $this->generator->get_plugin_generator('mod_resource');
+ $record = array('course' => $this->course->id,
+ 'name' => get_string('smallfiles', 'tool_generator'));
+ $options = array('section' => 0);
+ $resource = $resourcegenerator->create_instance($record, $options);
+
+ // Add files.
+ $fs = get_file_storage();
+ $context = context_module::instance($resource->cmid);
+ $filerecord = array('component' => 'mod_resource', 'filearea' => 'content',
+ 'contextid' => $context->id, 'itemid' => 0, 'filepath' => '/');
+ for ($i = 0; $i < $count; $i++) {
+ $filerecord['filename'] = 'smallfile' . $i . '.dat';
+
+ // Generate random binary data (different for each file so it
+ // doesn't compress unrealistically).
+ $data = self::get_random_binary(self::$paramsmallfilesize[$this->size]);
+
+ $fs->create_file_from_string($filerecord, $data);
+ $this->dot($i, $count);
+ }
+
+ $this->end_log();
+ }
+
+ /**
+ * Creates a string of random binary data. The start of the string includes
+ * the current time, in an attempt to avoid large-scale repetition.
+ *
+ * @param int $length Number of bytes
+ * @return Random data
+ */
+ private static function get_random_binary($length) {
+ $data = microtime(true);
+ if (strlen($data) > $length) {
+ // Use last digits of data.
+ return substr($data, -$length);
+ }
+ $length -= strlen($data);
+ for ($j=0; $j < $length; $j++) {
+ $data .= chr(rand(1, 255));
+ }
+ return $data;
+ }
+
+ /**
+ * Creates a number of resource activities with one big file each.
+ */
+ private function create_big_files() {
+ global $CFG;
+
+ // Work out how many files and how many blocks to use (up to 64KB).
+ $count = self::$parambigfilecount[$this->size];
+ $blocks = ceil(self::$parambigfilesize[$this->size] / 65536);
+ $blocksize = floor(self::$parambigfilesize[$this->size] / $blocks);
+
+ $this->log('createbigfiles', $count, true);
+
+ // Prepare temp area.
+ $tempfolder = make_temp_directory('tool_generator');
+ $tempfile = $tempfolder . '/' . rand();
+
+ // Create resources and files.
+ $fs = get_file_storage();
+ $resourcegenerator = $this->generator->get_plugin_generator('mod_resource');
+ for ($i = 0; $i < $count; $i++) {
+ // Create resource.
+ $record = array('course' => $this->course->id,
+ 'name' => get_string('bigfile', 'tool_generator', $i));
+ $options = array('section' => $this->get_random_section());
+ $resource = $resourcegenerator->create_instance($record, $options);
+
+ // Write file.
+ $handle = fopen($tempfile, 'w');
+ if (!$handle) {
+ throw new coding_exception('Failed to open temporary file');
+ }
+ for ($j = 0; $j < $blocks; $j++) {
+ $data = self::get_random_binary($blocksize);
+ fwrite($handle, $data);
+ $this->dot($i * $blocks + $j, $count * $blocks);
+ }
+ fclose($handle);
+
+ // Add file.
+ $context = context_module::instance($resource->cmid);
+ $filerecord = array('component' => 'mod_resource', 'filearea' => 'content',
+ 'contextid' => $context->id, 'itemid' => 0, 'filepath' => '/',
+ 'filename' => 'bigfile' . $i . '.dat');
+ $fs->create_file_from_pathname($filerecord, $tempfile);
+ }
+
+ unlink($tempfile);
+ $this->end_log();
+ }
+
+ /**
+ * Creates one forum activity with a bunch of posts.
+ */
+ private function create_forum() {
+ global $DB;
+
+ $discussions = self::$paramforumdiscussions[$this->size];
+ $posts = self::$paramforumposts[$this->size];
+ $totalposts = $discussions * $posts;
+
+ $this->log('createforum', $totalposts, true);
+
+ // Create empty forum.
+ $forumgenerator = $this->generator->get_plugin_generator('mod_forum');
+ $record = array('course' => $this->course->id,
+ 'name' => get_string('pluginname', 'forum'));
+ $options = array('section' => 0);
+ $forum = $forumgenerator->create_instance($record, $options);
+
+ // Add discussions and posts.
+ $sofar = 0;
+ for ($i=0; $i < $discussions; $i++) {
+ $record = array('forum' => $forum->id, 'course' => $this->course->id,
+ 'userid' => $this->get_random_user());
+ $discussion = $forumgenerator->create_discussion($record);
+ $parentid = $DB->get_field('forum_posts', 'id', array('discussion' => $discussion->id), MUST_EXIST);
+ $sofar++;
+ for ($j=0; $j < $posts - 1; $j++, $sofar++) {
+ $record = array('discussion' => $discussion->id,
+ 'userid' => $this->get_random_user(), 'parent' => $parentid);
+ $forumgenerator->create_post($record);
+ $this->dot($sofar, $totalposts);
+ }
+ }
+
+ $this->end_log();
+ }
+
+ /**
+ * Gets a random section number.
+ *
+ * @return int A section number from 1 to the number of sections
+ */
+ private function get_random_section() {
+ return rand(1, self::$paramsections[$this->size]);
+ }
+
+ /**
+ * Gets a random user id.
+ *
+ * @return int A user id for a random created user
+ */
+ private function get_random_user() {
+ return $this->userids[rand(1, self::$paramusers[$this->size])];
+ }
+
+ /**
+ * Displays information as part of progress.
+ * @param string $langstring Part of langstring (after progress_)
+ * @param mixed $a Optional lang string parameters
+ * @param bool $leaveopen If true, doesn't close LI tag (ready for dots)
+ */
+ private function log($langstring, $a = null, $leaveopen = false) {
+ if (!$this->progress) {
+ return;
+ }
+ if (CLI_SCRIPT) {
+ echo '* ';
+ } else {
+ echo html_writer::start_tag('li');
+ }
+ echo get_string('progress_' . $langstring, 'tool_generator', $a);
+ if (!$leaveopen) {
+ if (CLI_SCRIPT) {
+ echo "\n";
+ } else {
+ echo html_writer::end_tag('li');
+ }
+ } else {
+ echo ': ';
+ $this->lastdot = time();
+ $this->lastpercentage = $this->lastdot;
+ $this->starttime = microtime(true);
+ }
+ }
+
+ /**
+ * Outputs dots. There is up to one dot per second. Once a minute, it
+ * displays a percentage.
+ * @param int $number Number of completed items
+ * @param int $total Total number of items to complete
+ */
+ private function dot($number, $total) {
+ if (!$this->progress) {
+ return;
+ }
+ $now = time();
+ if ($now == $this->lastdot) {
+ return;
+ }
+ $this->lastdot = $now;
+ if (CLI_SCRIPT) {
+ echo '.';
+ } else {
+ echo ' . ';
+ }
+ if ($now - $this->lastpercentage >= 30) {
+ echo round(100.0 * $number / $total, 1) . '%';
+ $this->lastpercentage = $now;
+ }
+
+ // Update time limit so PHP doesn't time out.
+ if (!CLI_SCRIPT) {
+ set_time_limit(120);
+ }
+ }
+
+ /**
+ * Ends a log string that was started using log function with $leaveopen.
+ */
+ private function end_log() {
+ if (!$this->progress) {
+ return;
+ }
+ echo get_string('done', 'tool_generator', round(microtime(true) - $this->starttime, 1));
+ if (CLI_SCRIPT) {
+ echo "\n";
+ } else {
+ echo html_writer::end_tag('li');
+ }
+ }
+}
--- /dev/null
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
+
+defined('MOODLE_INTERNAL') || die();
+
+require_once($CFG->libdir . '/formslib.php');
+
+/**
+ * Form with options for creating large course.
+ *
+ * @package tool_generator
+ * @copyright 2013 The Open University
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class tool_generator_make_form extends moodleform {
+
+ public function definition() {
+ $mform = $this->_form;
+
+ $mform->addElement('select', 'size', get_string('size', 'tool_generator'),
+ tool_generator_backend::get_size_choices());
+ $mform->setDefault('size', tool_generator_backend::DEFAULT_SIZE);
+
+ $mform->addElement('text', 'shortname', get_string('shortnamecourse'));
+ $mform->addRule('shortname', get_string('missingshortname'), 'required', null, 'client');
+ $mform->setType('shortname', PARAM_TEXT);
+
+ $mform->addElement('submit', 'submit', get_string('createcourse', 'tool_generator'));
+ }
+
+ public function validation($data, $files) {
+ global $DB;
+ $errors = array();
+
+ // Check course doesn't already exist.
+ if (!empty($data['shortname'])) {
+ // Check shortname.
+ $error = tool_generator_backend::check_shortname_available($data['shortname']);
+ if ($error) {
+ $errors['shortname'] = $error;
+ }
+ }
+
+ return $errors;
+ }
+}
require(dirname(__FILE__) . '/../../../../config.php');
require_once(dirname(__FILE__) . '/../locallib.php');
-if (!debugging('', DEBUG_DEVELOPER)) {
+if (!$CFG->debugdeveloper) {
echo("This script is for developers only!!!\n");
exit(1);
}
--- /dev/null
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * CLI interface for creating a test course.
+ *
+ * @package tool_generator
+ * @copyright 2013 The Open University
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+define('CLI_SCRIPT', true);
+define('NO_OUTPUT_BUFFERING', true);
+
+require(dirname(__FILE__) . '/../../../../config.php');
+require_once($CFG->libdir. '/clilib.php');
+
+// CLI options.
+list($options, $unrecognized) = cli_get_params(
+ array(
+ 'help' => false,
+ 'shortname' => false,
+ 'size' => false,
+ 'bypasscheck' => false,
+ 'quiet' => false
+ ),
+ array(
+ 'h' => 'help'
+ )
+);
+
+// Display help.
+if (!empty($options['help']) || empty($options['shortname']) || empty($options['size'])) {
+ echo "
+Utility to create standard test course. (Also available in GUI interface.)
+
+Not for use on live sites; only normally works if debugging is set to DEVELOPER
+level.
+
+Options:
+--shortname Shortname of course to create (required)
+--size Size of course to create XS, S, M, L, XL, or XXL (required)
+--bypasscheck Bypasses the developer-mode check (be careful!)
+--quiet Do not show any output
+
+-h, --help Print out this help
+
+Example from Moodle root directory:
+\$ php admin/tool/generator/cli/maketestcourse.php --shortname=SIZE_S --size=S
+";
+ // Exit with error unless we're showing this because they asked for it.
+ exit(empty($options['help']) ? 1 : 0);
+}
+
+// Check debugging is set to developer level.
+if (empty($options['bypasscheck']) && !debugging('', DEBUG_DEVELOPER)) {
+ cli_error(get_string('error_notdebugging', 'tool_generator'));
+}
+
+// Get options.
+$shortname = $options['shortname'];
+$sizename = $options['size'];
+
+// Check size.
+try {
+ $size = tool_generator_backend::size_for_name($sizename);
+} catch (coding_exception $e) {
+ cli_error("Invalid size ($sizename). Use --help for help.");
+}
+
+// Check shortname.
+if ($error = tool_generator_backend::check_shortname_available($shortname)) {
+ cli_error($error);
+}
+
+// Switch to admin user account.
+session_set_user(get_admin());
+
+// Do backend code to generate course.
+$backend = new tool_generator_backend($shortname, $size, empty($options['quiet']));
+$id = $backend->make();
error('Only for admins');
}
-if (!debugging('', DEBUG_DEVELOPER)) {
+if (!$CFG->debugdeveloper) {
error('This script is for developers only!!!');
}
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
- * Strings for component 'tool_generator', language 'en', branch 'MOODLE_22_STABLE'
+ * Language strings.
*
- * @package tool
- * @subpackage generator
- * @copyright 2011 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @package tool_generator
+ * @copyright 2013 The Open University
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
+$string['bigfile'] = 'Big file {$a}';
+$string['createcourse'] = 'Create course';
+$string['creating'] = 'Creating course';
+$string['done'] = 'done ({$a}s)';
+$string['explanation'] = 'This tool creates standard test courses that include many
+sections, activities, and files.
+
+This is intended to provide a standardised measure for checking the reliability
+and performance of various system components (such as backup and restore).
+
+This test is important because there have been many cases previously where,
+faced with real-life use cases (e.g. a course with 1,000 activities), the system
+does not work.
+
+Courses created using this feature can occupy a large amount of database and
+filesystem space (tens of gigabytes). You will need to delete the courses
+(and wait for various cleanup runs) to release this space again.
+
+**Do not use this feature on a live system**. Use only on a developer server.
+(To avoid accidental use, this feature is disabled unless you have also selected
+DEVELOPER debugging level.)';
+
+$string['error_notdebugging'] = 'Not available on this server because debugging is not set to DEVELOPER';
+$string['firstname'] = 'Test course user';
+$string['fullname'] = 'Test course: {$a->size}';
+$string['maketestcourse'] = 'Make test course';
$string['pluginname'] = 'Random course generator';
+$string['progress_createcourse'] = 'Creating course {$a}';
+$string['progress_checkaccounts'] = 'Checking user accounts ({$a})';
+$string['progress_createaccounts'] = 'Creating user accounts ({$a->from} - {$a->to})';
+$string['progress_createbigfiles'] = 'Creating big files ({$a})';
+$string['progress_createforum'] = 'Creating forum ({$a} posts)';
+$string['progress_createpages'] = 'Creating pages ({$a})';
+$string['progress_createsmallfiles'] = 'Creating small files ({$a})';
+$string['progress_enrol'] = 'Enrolling users into course ({$a})';
+$string['progress_complete'] = 'Complete ({$a}s)';
+$string['shortsize_0'] = 'XS';
+$string['shortsize_1'] = 'S';
+$string['shortsize_2'] = 'M';
+$string['shortsize_3'] = 'L';
+$string['shortsize_4'] = 'XL';
+$string['shortsize_5'] = 'XXL';
+$string['size'] = 'Size of course';
+$string['size_0'] = 'XS (~10KB; create in ~1 second)';
+$string['size_1'] = 'S (~10MB; create in ~30 seconds)';
+$string['size_2'] = 'M (~100MB; create in ~5 minutes)';
+$string['size_3'] = 'L (~1GB; create in ~1 hour)';
+$string['size_4'] = 'XL (~10GB; create in ~4 hours)';
+$string['size_5'] = 'XXL (~20GB; create in ~8 hours)';
+$string['smallfiles'] = 'Small files';
--- /dev/null
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Script creates a standardised large course for testing reliability and
+ * performance.
+ *
+ * @package tool_generator
+ * @copyright 2013 The Open University
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+// Disable buffering so that the progress output displays gradually without
+// needing to call flush().
+define('NO_OUTPUT_BUFFERING', true);
+
+require('../../../config.php');
+
+require_once($CFG->libdir . '/adminlib.php');
+
+// Initialise page and check permissions.
+admin_externalpage_setup('toolgenerator');
+
+// Start page.
+echo $OUTPUT->header();
+echo $OUTPUT->heading(get_string('maketestcourse', 'tool_generator'));
+
+// Information message.
+$context = context_system::instance();
+echo $OUTPUT->box(format_text(get_string('explanation', 'tool_generator'),
+ FORMAT_MARKDOWN, array('context' => $context)));
+
+// Check debugging is set to DEVELOPER.
+if (!debugging('', DEBUG_DEVELOPER)) {
+ echo $OUTPUT->notification(get_string('error_notdebugging', 'tool_generator'));
+ echo $OUTPUT->footer();
+ exit;
+}
+
+// Set up the form.
+$mform = new tool_generator_make_form('maketestcourse.php');
+if ($data = $mform->get_data()) {
+ // Do actual work.
+ echo $OUTPUT->heading(get_string('creating', 'tool_generator'));
+ $backend = new tool_generator_backend($data->shortname, $data->size);
+ $id = $backend->make();
+
+ echo html_writer::div(
+ html_writer::link(new moodle_url('/course/view.php', array('id' => $id)),
+ get_string('continue')));
+} else {
+ // Display form.
+ $mform->display();
+}
+
+// Finish page.
+echo $OUTPUT->footer();
--- /dev/null
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Admin settings.
+ *
+ * @package tool_generator
+ * @copyright 2013 The Open University
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die;
+
+if ($hassiteconfig) {
+ $ADMIN->add('development', new admin_externalpage('toolgenerator',
+ get_string('maketestcourse', 'tool_generator'),
+ $CFG->wwwroot . '/' . $CFG->admin . '/tool/generator/maketestcourse.php'));
+}
+
--- /dev/null
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Automated unit testing. This tests the 'make large course' backend,
+ * using the 'XS' option so that it completes quickly.
+ *
+ * @package tool_generator
+ * @copyright 2013 The Open University
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class tool_generator_maketestcourse_testcase extends advanced_testcase {
+ /**
+ * Creates a small test course and checks all the components have been put in place.
+ */
+ public function test_make_xs_course() {
+ global $DB;
+
+ $this->resetAfterTest();
+ $this->setAdminUser();
+
+ // Create the XS course.
+ $backend = new tool_generator_backend('TOOL_MAKELARGECOURSE_XS', 0, false);
+ $courseid = $backend->make();
+
+ // Get course details.
+ $course = get_course($courseid);
+ $context = context_course::instance($courseid);
+ $modinfo = get_fast_modinfo($course);
+
+ // Check sections (just section 0 plus one other).
+ $this->assertEquals(2, count($modinfo->get_section_info_all()));
+
+ // Check user is enrolled.
+ $users = get_enrolled_users($context);
+ $this->assertEquals(1, count($users));
+ $this->assertEquals('tool_generator_000001', reset($users)->username);
+
+ // Check there's a page on the course.
+ $pages = $modinfo->get_instances_of('page');
+ $this->assertEquals(1, count($pages));
+
+ // Check there are small files.
+ $resources = $modinfo->get_instances_of('resource');
+ $ok = false;
+ foreach ($resources as $resource) {
+ if ($resource->sectionnum == 0) {
+ // The one in section 0 is the 'small files' resource.
+ $ok = true;
+ break;
+ }
+ }
+ $this->assertTrue($ok);
+
+ // Check it contains 2 files (the default txt and a dat file).
+ $fs = get_file_storage();
+ $resourcecontext = context_module::instance($resource->id);
+ $files = $fs->get_area_files($resourcecontext->id, 'mod_resource', 'content', false, 'filename', false);
+ $files = array_values($files);
+ $this->assertEquals(2, count($files));
+ $this->assertEquals('resource1.txt', $files[0]->get_filename());
+ $this->assertEquals('smallfile0.dat', $files[1]->get_filename());
+
+ // Check there's a single 'big' file (it's actually only 8KB).
+ $ok = false;
+ foreach ($resources as $resource) {
+ if ($resource->sectionnum == 1) {
+ $ok = true;
+ break;
+ }
+ }
+ $this->assertTrue($ok);
+
+ // Check it contains 2 files.
+ $resourcecontext = context_module::instance($resource->id);
+ $files = $fs->get_area_files($resourcecontext->id, 'mod_resource', 'content', false, 'filename', false);
+ $files = array_values($files);
+ $this->assertEquals(2, count($files));
+ $this->assertEquals('bigfile0.dat', $files[0]->get_filename());
+ $this->assertEquals('resource2.txt', $files[1]->get_filename());
+
+ // Get forum and count the number of posts on it.
+ $forums = $modinfo->get_instances_of('forum');
+ $forum = reset($forums);
+ $posts = $DB->count_records_sql("
+ SELECT
+ COUNT(1)
+ FROM
+ {forum_posts} fp
+ JOIN {forum_discussions} fd ON fd.id = fp.discussion
+ WHERE
+ fd.forum = ?", array($forum->instance));
+ $this->assertEquals(2, $posts);
+ }
+}
/**
* Version details.
*
- * @package tool
- * @subpackage generator
- * @copyright 2009 Nicolas Connault
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @package tool_generator
+ * @copyright 2013 The Open University
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
-$plugin->version = 2013050100; // The current plugin version (Date: YYYYMMDDXX)
-$plugin->requires = 2013050100; // Requires this Moodle version
-$plugin->component = 'tool_generator'; // Full name of the plugin (used for diagnostics)
-
-$plugin->maturity = MATURITY_ALPHA; // this version's maturity level
+$plugin->version = 2013080700;
+$plugin->requires = 2013080200;
+$plugin->component = 'tool_generator';
navigation_node::override_active_url(new moodle_url('/admin/tool/phpunit/index.php'));
admin_externalpage_setup('toolphpunitwebrunner');
-if (!debugging('', DEBUG_DEVELOPER)) {
+if (!$CFG->debugdeveloper) {
error('Not available on production sites, sorry.');
}
if ($code != 0) {
tool_phpunit_problem('Can not initialize database');
}
- $CFG->debug = 0; // no pesky redirect warning, we really want to redirect
+ set_debugging(DEBUG_NONE, false); // Hack: no redirect warning, we really want to redirect.
redirect(new moodle_url($PAGE->url, array('execute'=>1, 'tespath'=>$testpath, 'testclass'=>$testclass, 'sesskey'=>sesskey())), 'Reloading page');
echo $OUTPUT->footer();
die();
if ($code != 0) {
tool_phpunit_problem('Can not initialize database');
}
- $CFG->debug = 0; // no pesky redirect warning, we really want to redirect
+ set_debugging(DEBUG_NONE, false); // Hack: no redirect warning, we really want to redirect.
redirect(new moodle_url($PAGE->url, array('execute'=>1, 'tespath'=>$testpath, 'testclass'=>$testclass, 'sesskey'=>sesskey())), 'Reloading page');
die();
*/
class tool_uploadcourse_helper {
- /**
- * Remove the restore content from disk and cache.
- *
- * @return void
- */
- public static function clean_restore_content() {
- global $CFG;
-
- // There are some sloppy unclosed file handles in backup/restore code,
- // let's hope somebody unset all controllers before calling this
- // and destroy magic will close all remaining open file handles,
- // otherwise Windows will fail deleting the directory.
- gc_collect_cycles();
-
- if (!empty($CFG->keeptempdirectoriesonbackup)) {
- $cache = cache::make('tool_uploadcourse', 'helper');
- $backupids = (array) $cache->get('backupids');
- foreach ($backupids as $cachekey => $backupid) {
- $cache->delete($cachekey);
- fulldelete("$CFG->tempdir/backup/$backupid/");
- }
- $cache->delete('backupids');
- }
- }
-
/**
* Generate a shortname based on a template.
*
* Get the restore content tempdir.
*
* The tempdir is the sub directory in which the backup has been extracted.
- * This caches the result for better performance.
+ *
+ * This caches the result for better performance, but $CFG->keeptempdirectoriesonbackup
+ * needs to be enabled, otherwise the cache is ignored.
*
* @param string $backupfile path to a backup file.
* @param string $shortname shortname of a course.
$cachekey = null;
if (!empty($backupfile)) {
$backupfile = realpath($backupfile);
+ if (empty($backupfile) || !is_readable($backupfile)) {
+ $errors['cannotreadbackupfile'] = new lang_string('cannotreadbackupfile', 'tool_uploadcourse');
+ return false;
+ }
$cachekey = 'backup_path:' . $backupfile;
} else if (!empty($shortname) || is_numeric($shortname)) {
$cachekey = 'backup_sn:' . $shortname;
return false;
}
- $cache = cache::make('tool_uploadcourse', 'helper');
- if (($backupid = $cache->get($cachekey)) === false) {
- // Use false instead of null because it would consider that the cache
- // key has not been set.
- $backupid = false;
+ // If $CFG->keeptempdirectoriesonbackup is not set to true, any restore happening would
+ // automatically delete the backup directory... causing the cache to return an unexisting directory.
+ $usecache = !empty($CFG->keeptempdirectoriesonbackup);
+ if ($usecache) {
+ $cache = cache::make('tool_uploadcourse', 'helper');
+ }
+
+ // If we don't use the cache, or if we do and not set, or the directory doesn't exist any more.
+ if (!$usecache || (($backupid = $cache->get($cachekey)) === false || !is_dir("$CFG->tempdir/backup/$backupid"))) {
+
+ // Use null instead of false because it would consider that the cache key has not been set.
+ $backupid = null;
+
if (!empty($backupfile)) {
- if (!is_readable($backupfile)) {
- $errors['cannotreadbackupfile'] = new lang_string('cannotreadbackupfile', 'tool_uploadcourse');
- } else {
- // Extracting the backup file.
- $packer = get_file_packer('application/vnd.moodle.backup');
- $backupid = restore_controller::get_tempdir_name(SITEID, $USER->id);
- $path = "$CFG->tempdir/backup/$backupid/";
- $result = $packer->extract_to_pathname($backupfile, $path);
- if (!$result) {
- $errors['invalidbackupfile'] = new lang_string('invalidbackupfile', 'tool_uploadcourse');
- }
+ // Extracting the backup file.
+ $packer = get_file_packer('application/vnd.moodle.backup');
+ $backupid = restore_controller::get_tempdir_name(SITEID, $USER->id);
+ $path = "$CFG->tempdir/backup/$backupid/";
+ $result = $packer->extract_to_pathname($backupfile, $path);
+ if (!$result) {
+ $errors['invalidbackupfile'] = new lang_string('invalidbackupfile', 'tool_uploadcourse');
}
} else if (!empty($shortname) || is_numeric($shortname)) {
// Creating restore from an existing course.
new lang_string('coursetorestorefromdoesnotexist', 'tool_uploadcourse');
}
}
- $cache->set($cachekey, $backupid);
- // Store all the directories to be able to remove them in self::clean_restore_content().
- $backupids = (array) $cache->get('backupids');
- $backupids[$cachekey] = $backupid;
- $cache->set('backupids', $backupids);
+ if ($usecache) {
+ $cache->set($cachekey, $backupid);
+ }
}
+ if ($backupid === null) {
+ $backupid = false;
+ }
return $backupid;
}
$tracker->finish();
$tracker->results($total, $created, $updated, $deleted, $errors);
-
- $this->remove_restore_content();
}
/**
}
$tracker->finish();
- $this->remove_restore_content();
return $preview;
}
- /**
- * Delete the restore object.
- *
- * @return void
- */
- protected function remove_restore_content() {
- tool_uploadcourse_helper::clean_restore_content();
- }
-
/**
* Reset the current process.
*
$mform->disabledIf('options[shortnametemplate]', 'options[mode]', 'eq', tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE);
$mform->disabledIf('options[shortnametemplate]', 'options[mode]', 'eq', tool_uploadcourse_processor::MODE_UPDATE_ONLY);
+ // Restore file is not in the array options on purpose, because formslib can't handle it!
$contextid = $this->_customdata['contextid'];
$mform->addElement('hidden', 'contextid', $contextid);
$mform->setType('contextid', PARAM_INT);
- $mform->addElement('filepicker', 'options[restorefile]', get_string('templatefile', 'tool_uploadcourse'));
- $mform->addHelpButton('options[restorefile]', 'templatefile', 'tool_uploadcourse');
+ $mform->addElement('filepicker', 'restorefile', get_string('templatefile', 'tool_uploadcourse'));
+ $mform->addHelpButton('restorefile', 'templatefile', 'tool_uploadcourse');
$mform->addElement('text', 'options[templatecourse]', get_string('coursetemplatename', 'tool_uploadcourse'));
$mform->setType('options[templatecourse]', PARAM_TEXT);
$mform->closeHeaderBefore('buttonar');
}
- /**
- * Server side validation.
- * @param array $data - form data
- * @param object $files - form files
- * @return array $errors - form errors
- */
- public function validation($data, $files) {
- $errors = parent::validation($data, $files);
- $columns = $this->_customdata['columns'];
- $optype = $data['options']['mode'];
-
- // Look for other required data.
- if ($optype != tool_uploadcourse_processor::MODE_UPDATE_ONLY) {
- if (!in_array('fullname', $columns)) {
- if (isset($errors['mode'])) {
- $errors['mode'] .= ' ';
- }
- $errors['mode'] .= get_string('missingfield', 'error', 'fullname');
- }
- if (!in_array('summary', $columns)) {
- if (isset($errors['mode'])) {
- $errors['mode'] .= ' ';
- }
- $errors['mode'] .= get_string('missingfield', 'error', 'summary');
- }
- }
-
- return $errors;
- }
}
$options = (array) $form2data->options;
$defaults = (array) $form2data->defaults;
+
+ // Restorefile deserves its own logic because formslib does not really appreciate
+ // when the name of a filepicker is an array...
+ $options['restorefile'] = '';
+ if (!empty($form2data->restorefile)) {
+ $options['restorefile'] = $mform2->save_temp_file('restorefile');
+ }
$processor = new tool_uploadcourse_processor($cir, $options, $defaults);
echo $OUTPUT->header();
echo $OUTPUT->continue_button($returnurl);
}
+ // Deleting the file after processing or preview.
+ if (!empty($options['restorefile'])) {
+ @unlink($options['restorefile']);
+ }
+
} else {
$processor = new tool_uploadcourse_processor($cir, $form1data->options, array());
echo $OUTPUT->header();
}
$this->assertTrue($found);
+ // Restoring twice from the same course should work.
+ $data = array('shortname' => 'B1', 'templatecourse' => $c1->shortname, 'summary' => 'B', 'category' => 1,
+ 'fullname' => 'B1');
+ $co = new tool_uploadcourse_course($mode, $updatemode, $data);
+ $this->assertTrue($co->prepare());
+ $co->proceed();
+ $course = $DB->get_record('course', array('shortname' => 'B1'));
+ $modinfo = get_fast_modinfo($course);
+ $found = false;
+ foreach ($modinfo->get_cms() as $cmid => $cm) {
+ if ($cm->modname == 'forum' && $cm->name == $c1f1->name) {
+ $found = true;
+ break;
+ }
+ }
+ $this->assertTrue($found);
+
// Restore the time limit to prevent warning.
set_time_limit(0);
}
}
$this->assertTrue($found);
+ // Restoring twice from the same file should work.
+ $data = array('shortname' => 'B1', 'backupfile' => __DIR__ . '/fixtures/backup.mbz',
+ 'summary' => 'B', 'category' => 1, 'fullname' => 'B1');
+ $co = new tool_uploadcourse_course($mode, $updatemode, $data);
+ $this->assertTrue($co->prepare());
+ $co->proceed();
+ $course = $DB->get_record('course', array('shortname' => 'B1'));
+ $modinfo = get_fast_modinfo($course);
+ $found = false;
+ foreach ($modinfo->get_cms() as $cmid => $cm) {
+ if ($cm->modname == 'glossary' && $cm->name == 'Imported Glossary') {
+ $found = true;
+ } else if ($cm->modname == 'forum' && $cm->name == $c1f1->name) {
+ // We should not find this!
+ $this->assertTrue(false);
+ }
+ }
+ $this->assertTrue($found);
+
// Restore the time limit to prevent warning.
set_time_limit(0);
}
$bc->destroy();
unset($bc); // File logging is a mess, we can only try to rely on gc to close handles.
+ $oldcfg = isset($CFG->keeptempdirectoriesonbackup) ? $CFG->keeptempdirectoriesonbackup : false;
+ $CFG->keeptempdirectoriesonbackup = true;
+
// Checking restore dir.
$dir = tool_uploadcourse_helper::get_restore_content_dir($c1backupfile, null);
$bcinfo = backup_general_helper::get_backup_information($dir);
$this->assertFalse($dir);
$this->assertArrayHasKey('coursetorestorefromdoesnotexist', $errors);
- // Cleaning content directories.
- $oldcfg = isset($CFG->keeptempdirectoriesonbackup) ? $CFG->keeptempdirectoriesonbackup : false;
- $dir = "$CFG->tempdir/backup/$dir";
- $this->assertTrue(file_exists($dir));
-
+ // Trying again without caching. $CFG->keeptempdirectoriesonbackup is required for caching.
$CFG->keeptempdirectoriesonbackup = false;
- tool_uploadcourse_helper::clean_restore_content();
- $this->assertTrue(file_exists($dir));
- $CFG->keeptempdirectoriesonbackup = true;
- tool_uploadcourse_helper::clean_restore_content();
- $this->assertFalse(file_exists($dir));
+ // Checking restore dir.
+ $dir = tool_uploadcourse_helper::get_restore_content_dir($c1backupfile, null);
+ $dir2 = tool_uploadcourse_helper::get_restore_content_dir($c1backupfile, null);
+ $this->assertNotEquals($dir, $dir2);
+
+ // Checking with a shortname.
+ $dir = tool_uploadcourse_helper::get_restore_content_dir(null, $c1->shortname);
+ $dir2 = tool_uploadcourse_helper::get_restore_content_dir(null, $c1->shortname);
+ $this->assertNotEquals($dir, $dir2);
+
+ // Get a course that does not exist.
+ $errors = array();
+ $dir = tool_uploadcourse_helper::get_restore_content_dir(null, 'DoesNotExist', $errors);
+ $this->assertFalse($dir);
+ $this->assertArrayHasKey('coursetorestorefromdoesnotexist', $errors);
+ $dir2 = tool_uploadcourse_helper::get_restore_content_dir(null, 'DoesNotExist', $errors);
+ $this->assertEquals($dir, $dir2);
$CFG->keeptempdirectoriesonbackup = $oldcfg;
require_once($CFG->dirroot.'/course/lib.php');
// Ensure errors are well explained
-$CFG->debug = DEBUG_NORMAL;
+set_debugging(DEBUG_DEVELOPER, true);
if (!is_enabled_auth('cas')) {
error_log('[AUTH CAS] '.get_string('pluginnotenabled', 'auth_ldap'));
require_once($CFG->dirroot.'/course/lib.php');
// Ensure errors are well explained
-$CFG->debug = DEBUG_NORMAL;
+set_debugging(DEBUG_DEVELOPER, true);
if (!is_enabled_auth('ldap')) {
error_log('[AUTH LDAP] '.get_string('pluginnotenabled', 'auth_ldap'));
// Mark the UI finished.
$rc->finish_ui();
// Execute prechecks
+ $warnings = false;
if (!$rc->execute_precheck()) {
$precheckresults = $rc->get_precheck_results();
- if (is_array($precheckresults) && !empty($precheckresults['errors'])) {
- fulldelete($tempdestination);
-
- echo $OUTPUT->header();
- echo $renderer->precheck_notices($precheckresults);
- echo $OUTPUT->continue_button(new moodle_url('/course/view.php', array('id'=>$course->id)));
- echo $OUTPUT->footer();
- die();
+ if (is_array($precheckresults)) {
+ if (!empty($precheckresults['errors'])) { // If errors are found, terminate the import.
+ fulldelete($tempdestination);
+
+ echo $OUTPUT->header();
+ echo $renderer->precheck_notices($precheckresults);
+ echo $OUTPUT->continue_button(new moodle_url('/course/view.php', array('id'=>$course->id)));
+ echo $OUTPUT->footer();
+ die();
+ }
+ if (!empty($precheckresults['warnings'])) { // If warnings are found, go ahead but display warnings later.
+ $warnings = $precheckresults['warnings'];
+ }
}
- } else {
- if ($restoretarget == backup::TARGET_CURRENT_DELETING || $restoretarget == backup::TARGET_EXISTING_DELETING) {
- restore_dbops::delete_course_content($course->id);
- }
- // Execute the restore
- $rc->execute_plan();
}
+ if ($restoretarget == backup::TARGET_CURRENT_DELETING || $restoretarget == backup::TARGET_EXISTING_DELETING) {
+ restore_dbops::delete_course_content($course->id);
+ }
+ // Execute the restore.
+ $rc->execute_plan();
// Delete the temp directory now
fulldelete($tempdestination);
// Display a notification and a continue button
echo $OUTPUT->header();
- echo $OUTPUT->notification(get_string('importsuccess', 'backup'),'notifysuccess');
+ if ($warnings) {
+ echo $OUTPUT->box_start();
+ echo $OUTPUT->notification(get_string('warning'), 'notifywarning');
+ echo html_writer::start_tag('ul', array('class'=>'list'));
+ foreach ($warnings as $warning) {
+ echo html_writer::tag('li', $warning);
+ }
+ echo html_writer::end_tag('ul');
+ echo $OUTPUT->box_end();
+ }
+ echo $OUTPUT->notification(get_string('importsuccess', 'backup'), 'notifysuccess');
echo $OUTPUT->continue_button(new moodle_url('/course/view.php', array('id'=>$course->id)));
echo $OUTPUT->footer();
*/
abstract class restore_qtype_plugin extends restore_plugin {
+ /*
+ * A simple answer to id cache for a single questions answers.
+ * @var array
+ */
+ private $questionanswercache = array();
+
+ /*
+ * The id of the current question in the questionanswercache.
+ * @var int
+ */
+ private $questionanswercacheid = null;
+
/**
* Add to $paths the restore_path_elements needed
* to handle question_answers for a given question
// The question existed, we need to map the existing question_answers
} else {
- // Look in question_answers by answertext matching
- $sql = 'SELECT id
- FROM {question_answers}
- WHERE question = ?
- AND ' . $DB->sql_compare_text('answer', 255) . ' = ' . $DB->sql_compare_text('?', 255);
- $params = array($newquestionid, $data->answertext);
- $newitemid = $DB->get_field_sql($sql, $params);
-
- // Not able to find the answer, let's try cleaning the answertext
- // of all the question answers in DB as slower fallback. MDL-30018.
- if (!$newitemid) {
+ // Have we cached the current question?
+ if ($this->questionanswercacheid !== $newquestionid) {
+ // The question changed, purge and start again!
+ $this->questionanswercache = array();
$params = array('question' => $newquestionid);
$answers = $DB->get_records('question_answers', $params, '', 'id, answer');
+ $this->questionanswercacheid = $newquestionid;
+ // Cache all cleaned answers for a simple text match.
foreach ($answers as $answer) {
- // Clean in the same way than {@link xml_writer::xml_safe_utf8()}.
+ // MDL-30018: Clean in the same way as {@link xml_writer::xml_safe_utf8()}.
$clean = preg_replace('/[\x-\x8\xb-\xc\xe-\x1f\x7f]/is','', $answer->answer); // Clean CTRL chars.
$clean = preg_replace("/\r\n|\r/", "\n", $clean); // Normalize line ending.
- if ($clean === $data->answertext) {
- $newitemid = $data->id;
- }
+ $this->questionanswercache[$clean] = $answer->id;
}
}
- // If we haven't found the newitemid, something has gone really wrong, question in DB
- // is missing answers, exception
- if (!$newitemid) {
+ if (!isset($this->questionanswercache[$data->answertext])) {
+ // If we haven't found the matching answer, something has gone really wrong, the question in the DB
+ // is missing answers, throw an exception.
$info = new stdClass();
$info->filequestionid = $oldquestionid;
$info->dbquestionid = $newquestionid;
$info->answer = $data->answertext;
throw new restore_step_exception('error_question_answers_missing_in_db', $info);
}
+ $newitemid = $this->questionanswercache[$data->answertext];
}
// Create mapping (we'll use this intensively when restoring question_states. And also answerfeedback files)
$this->set_mapping('question_answer', $oldid, $newitemid);
// Iterate over aliases in the queue.
foreach ($rs as $record) {
- $info = restore_dbops::decode_backup_temp_info($record->info);
+ $info = backup_controller_dbops::decode_backup_temp_info($record->info);
// Try to pick a repository instance that should serve the alias.
$repository = $this->choose_repository($info);
global $CFG;
$dfltloglevel = backup::LOG_WARNING; // Default logging level
- if (debugging('', DEBUG_DEVELOPER)) { // Debug developer raises default logging level
+ if ($CFG->debugdeveloper) { // Debug developer raises default logging level
$dfltloglevel = backup::LOG_DEBUG;
}
// Instantiate with debugging enabled and $CFG->backup_error_log_logger_level not set
$CFG->debugdisplay = true;
- $CFG->debug = DEBUG_DEVELOPER;
unset($CFG->backup_error_log_logger_level);
$logger1 = backup_factory::get_logger_chain(backup::INTERACTIVE_YES, backup::EXECUTION_INMEDIATE, 'test');
$this->assertTrue($logger1 instanceof error_log_logger); // 1st logger is error_log_logger
if ($this->levelcol) {
$columns[$this->levelcol] = $level;
}
- $columns[$this->messagecol] = $message; //TODO: should this be cleaned?
+ $columns[$this->messagecol] = clean_param($message, PARAM_NOTAGS);
return $this->insert_log_record($this->logtable, $columns);
}
// to preserve DB logs if the whole backup/restore transaction is
// rollback
global $DB;
- return $DB->insert_record($this->logtable, $columns, false); // Don't return inserted id
+ return $DB->insert_record($table, $columns, false); // Don't return inserted id
}
}
parent::execute();
$this->controller->set_status(backup::STATUS_FINISHED_OK);
- events_trigger('course_restored', (object) array(
- 'courseid' => $this->get_courseid(), // The new course
- 'userid' => $this->get_userid(), // User doing the restore
- 'type' => $this->controller->get_type(), // backup::TYPE_* constant
- 'target' => $this->controller->get_target(), // backup::TARGET_* constant
- 'mode' => $this->controller->get_mode(), // backup::MODE_* constant
- 'operation' => $this->controller->get_operation(), // backup::OPERATION_* constant
- 'samesite' => $this->controller->is_samesite(),
+ // Trigger a course restored event.
+ $event = \core\event\course_restored::create(array(
+ 'objectid' => $this->get_courseid(),
+ 'userid' => $this->get_userid(),
+ 'context' => context_course::instance($this->get_courseid()),
+ 'other' => array('type' => $this->controller->get_type(),
+ 'target' => $this->controller->get_target(),
+ 'mode' => $this->controller->get_mode(),
+ 'operation' => $this->controller->get_operation(),
+ 'samesite' => $this->controller->is_samesite())
));
+ $event->trigger();
}
/**
defined('MOODLE_INTERNAL') || die();
-require_once(dirname(dirname(dirname(__FILE__))) . '/config.php');
require_once($CFG->libdir . '/badgeslib.php');
require_once($CFG->dirroot . '/user/selector/lib.php');
require_once($CFG->libdir . '/badgeslib.php');
require_once($CFG->libdir . '/tablelib.php');
-require_once($CFG->dirroot . '/user/filters/lib.php');
/**
* Standard HTML output renderer for badges
'class' => 'block_' . $this->name(). ' block',
'role' => $this->get_aria_role()
);
+ if ($this->hide_header()) {
+ $attributes['class'] .= ' no-header';
+ }
if ($this->instance_can_be_docked() && get_user_preferences('docked_block_instance_'.$this->instance->id, 0)) {
$attributes['class'] .= ' dock_on_load';
}
$content = '';
$moretags = new moodle_url('/tag/coursetags_more.php', array('show'=>$tagtype));
if ($tagtype == 'all') {
- $tags = coursetag_get_tags(0, 0, $this->config->tagtype, $this->config->numberoftags, 'name');
+ $tags = coursetag_get_tags(0, 0, $this->config->tagtype, $this->config->numberoftags);
} else if ($tagtype == 'course') {
- $tags = coursetag_get_tags($this->page->course->id, 0, $this->config->tagtype, $this->config->numberoftags, 'name');
+ $tags = coursetag_get_tags($this->page->course->id, 0, $this->config->tagtype, $this->config->numberoftags);
$moretags->param('courseid', $this->page->course->id);
} else if ($tagtype == 'my') {
- $tags = coursetag_get_tags(0, $USER->id, $this->config->tagtype, $this->config->numberoftags, 'name');
+ $tags = coursetag_get_tags(0, $USER->id, $this->config->tagtype, $this->config->numberoftags);
}
$tagcloud = tag_print_cloud($tags, 150, true);
if (!$tagcloud) {
* In advanced cases an array may be useful such as in situations requiring the multi-key functionality.
* @param int $strictness One of IGNORE_MISSING | MUST_EXIST
* @return mixed|false The data from the cache or false if the key did not exist within the cache.
- * @throws moodle_exception
+ * @throws coding_exception
*/
public function get($key, $strictness = IGNORE_MISSING) {
// 1. Parse the key.
}
// 5. Validate strictness.
if ($strictness === MUST_EXIST && $result === false) {
- throw new moodle_exception('Requested key did not exist in any cache stores and could not be loaded.');
+ throw new coding_exception('Requested key did not exist in any cache stores and could not be loaded.');
}
// 6. Set it to the store if we got it from the loader/datasource.
if ($setaftervalidation) {
* @return array An array of key value pairs for the items that could be retrieved from the cache.
* If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown.
* Otherwise any key that did not exist will have a data value of false within the results.
- * @throws moodle_exception
+ * @throws coding_exception
*/
public function get_many(array $keys, $strictness = IGNORE_MISSING) {
$missingkeys = array();
foreach ($result as $key => $value) {
if ($value === false) {
- $missingkeys[] = ($usingloader) ? $key : $parsedkeys[$key];
+ $missingkeys[] = $parsedkeys[$key];
}
}
if (!empty($missingkeys)) {
$resultmissing = $this->datasource->load_many_for_cache($missingkeys);
}
foreach ($resultmissing as $key => $value) {
- $pkey = ($usingloader) ? $key : $keysparsed[$key];
- $realkey = ($usingloader) ? $parsedkeys[$key] : $key;
- $result[$pkey] = $value;
+ $result[$keysparsed[$key]] = $value;
if ($value !== false) {
- $this->set($realkey, $value);
+ $this->set($key, $value);
}
}
unset($resultmissing);
if ($strictness === MUST_EXIST) {
foreach ($keys as $key) {
if (!array_key_exists($key, $fullresult)) {
- throw new moodle_exception('Not all the requested keys existed within the cache stores.');
+ throw new coding_exception('Not all the requested keys existed within the cache stores.');
}
}
}
if ($this->perfdebug) {
cache_helper::record_cache_set($this->storetype, $this->definition->get_id());
}
+ if ($this->loader !== false) {
+ // We have a loader available set it there as well.
+ // We have to let the loader do its own parsing of data as it may be unique.
+ $this->loader->set($key, $data);
+ }
if (is_object($data) && $data instanceof cacheable_object) {
$data = new cache_cached_object($data);
} else if (!is_scalar($data)) {
* Removes references where required.
*
* @param stdClass|array $data
+ * @return mixed What ever was put in but without any references.
*/
protected function unref($data) {
if ($this->definition->uses_simple_data()) {
* ... if they care that is.
*/
public function set_many(array $keyvaluearray) {
+ if ($this->loader !== false) {
+ // We have a loader available set it there as well.
+ // We have to let the loader do its own parsing of data as it may be unique.
+ $this->loader->set_many($keyvaluearray);
+ }
$data = array();
$simulatettl = $this->has_a_ttl() && !$this->store_supports_native_ttl();
$usepersistcache = $this->is_using_persist_cache();
* Returns the loader associated with this instance.
*
* @since 2.4.4
- * @return cache_loader|false
+ * @return cache|false
*/
protected function get_loader() {
return $this->loader;
* @param string|int $key The key for the data being requested.
* @param int $strictness One of IGNORE_MISSING | MUST_EXIST
* @return mixed|false The data from the cache or false if the key did not exist within the cache.
- * @throws moodle_exception
*/
public function get($key, $strictness = IGNORE_MISSING) {
if ($this->requirelockingread && $this->check_lock_state($key) === false) {
* @return array An array of key value pairs for the items that could be retrieved from the cache.
* If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown.
* Otherwise any key that did not exist will have a data value of false within the results.
- * @throws moodle_exception
+ * @throws coding_exception
*/
public function get_many(array $keys, $strictness = IGNORE_MISSING) {
if ($this->requirelockingread) {
* @todo we should support locking in the session as well. Should be pretty simple to set up.
*
* @internal don't use me directly.
+ * @method cache_store|cache_is_searchable get_store() Returns the cache store which must implement both cache_is_searchable.
*
* @package core
* @category cache
*/
const KEY_PREFIX = 'sess_';
+ /**
+ * This is the key used to track last access.
+ */
+ const LASTACCESS = '__lastaccess__';
+
/**
* Override the cache::construct method.
*
* @param cache_definition $definition
* @param cache_store $store
* @param cache_loader|cache_data_source $loader
- * @return void
*/
public function __construct(cache_definition $definition, cache_store $store, $loader = null) {
// First up copy the loadeduserid to the current user id.
$this->currentuserid = self::$loadeduserid;
parent::__construct($definition, $store, $loader);
+
+ // This will trigger check tracked user. If this gets removed a call to that will need to be added here in its place.
+ $this->set(self::LASTACCESS, cache::now());
+
if ($definition->has_invalidation_events()) {
$lastinvalidation = $this->get('lastsessioninvalidation');
if ($lastinvalidation === false) {
}
}
+ /**
+ * Sets the session id for the loader.
+ */
+ protected function set_session_id() {
+ $this->sessionid = preg_replace('#[^a-zA-Z0-9_]#', '_', session_id());
+ }
+
+ /**
+ * Returns the prefix used for all keys.
+ * @return string
+ */
+ protected function get_key_prefix() {
+ return 'u'.$this->currentuserid.'_'.$this->sessionid;
+ }
+
/**
* Parses the key turning it into a string (or array is required) suitable to be passed to the cache store.
*
* @return string|array String unless the store supports multi-identifiers in which case an array if returned.
*/
protected function parse_key($key) {
- if ($key === 'lastaccess') {
- $key = '__lastaccess__';
+ $prefix = $this->get_key_prefix();
+ if ($key === self::LASTACCESS) {
+ return $key.$prefix;
}
- return 'sess_'.parent::parse_key($key);
+ return $prefix.'_'.parent::parse_key($key);
}
/**
* Check that this cache instance is tracking the current user.
*/
protected function check_tracked_user() {
- if (isset($_SESSION['USER']->id)) {
+ if (isset($_SESSION['USER']->id) && $_SESSION['USER']->id !== null) {
// Get the id of the current user.
$new = $_SESSION['USER']->id;
} else {
// This way we don't bloat the session.
$this->purge();
// Update the session id just in case!
- $this->sessionid = session_id();
+ $this->set_session_id();
}
self::$loadeduserid = $new;
$this->currentuserid = $new;
} else if ($new !== $this->currentuserid) {
// The current user matches the loaded user but not the user last used by this cache.
- $this->purge();
+ $this->purge_current_user();
$this->currentuserid = $new;
// Update the session id just in case!
- $this->sessionid = session_id();
+ $this->set_session_id();
}
}
/**
- * Gets the session data.
- *
- * @param bool $force If true the session data will be loaded from the store again.
- * @return array An array of session data.
- */
- protected function get_session_data($force = false) {
- if ($this->sessionid === null) {
- $this->sessionid = session_id();
- }
- if (is_array($this->session) && !$force) {
- return $this->session;
- }
- $session = parent::get($this->sessionid);
- if ($session === false) {
- $session = array();
- }
- // We have to write here to ensure that the lastaccess time is recorded.
- // And also in order to ensure the session entry exists as when we save it on __destruct
- // $CFG is likely to have already been destroyed.
- $this->save_session($session);
- return $this->session;
- }
-
- /**
- * Saves the session data.
- *
- * This function also updates the last access time.
- *
- * @param array $session
- * @return bool
+ * Purges the session cache of all data belonging to the current user.
*/
- protected function save_session(array $session) {
- $session['lastaccess'] = time();
- $this->session = $session;
- return parent::set($this->sessionid, $this->session);
+ public function purge_current_user() {
+ $keys = $this->get_store()->find_all($this->get_key_prefix());
+ $this->get_store()->delete_many($keys);
}
/**
* In advanced cases an array may be useful such as in situations requiring the multi-key functionality.
* @param int $strictness One of IGNORE_MISSING | MUST_EXIST
* @return mixed|false The data from the cache or false if the key did not exist within the cache.
- * @throws moodle_exception
+ * @throws coding_exception
*/
public function get($key, $strictness = IGNORE_MISSING) {
// Check the tracked user.
// 2. Parse the key.
$parsedkey = $this->parse_key($key);
// 3. Get it from the store.
- $result = false;
- $session = $this->get_session_data();
- if (array_key_exists($parsedkey, $session)) {
- $result = $session[$parsedkey];
+ $result = $this->get_store()->get($parsedkey);
+ if ($result !== false) {
if ($result instanceof cache_ttl_wrapper) {
if ($result->has_expired()) {
$this->get_store()->delete($parsedkey);
}
}
// 4. Load if from the loader/datasource if we don't already have it.
- $setaftervalidation = false;
if ($result === false) {
if ($this->perfdebug) {
- cache_helper::record_cache_miss('**static session**', $this->get_definition()->get_id());
+ cache_helper::record_cache_miss($this->storetype, $this->get_definition()->get_id());
}
if ($this->get_loader() !== false) {
// We must pass the original (unparsed) key to the next loader in the chain.
} else if ($this->get_datasource() !== false) {
$result = $this->get_datasource()->load_for_cache($key);
}
- $setaftervalidation = ($result !== false);
+ // 5. Set it to the store if we got it from the loader/datasource.
+ if ($result !== false) {
+ $this->set($key, $result);
+ }
} else if ($this->perfdebug) {
- cache_helper::record_cache_hit('**static session**', $this->get_definition()->get_id());
+ cache_helper::record_cache_hit($this->storetype, $this->get_definition()->get_id());
}
// 5. Validate strictness.
if ($strictness === MUST_EXIST && $result === false) {
- throw new moodle_exception('Requested key did not exist in any cache stores and could not be loaded.');
- }
- // 6. Set it to the store if we got it from the loader/datasource.
- if ($setaftervalidation) {
- $this->set($key, $result);
+ throw new coding_exception('Requested key did not exist in any cache stores and could not be loaded.');
}
- // 7. Make sure we don't pass back anything that could be a reference.
+ // 6. Make sure we don't pass back anything that could be a reference.
// We don't want people modifying the data in the cache.
if (!is_scalar($result)) {
// If data is an object it will be a reference.
*/
public function set($key, $data) {
$this->check_tracked_user();
+ $loader = $this->get_loader();
+ if ($loader !== false) {
+ // We have a loader available set it there as well.
+ // We have to let the loader do its own parsing of data as it may be unique.
+ $loader->set($key, $data);
+ }
if ($this->perfdebug) {
- cache_helper::record_cache_set('**static session**', $this->get_definition()->get_id());
+ cache_helper::record_cache_set($this->storetype, $this->get_definition()->get_id());
}
if (is_object($data) && $data instanceof cacheable_object) {
$data = new cache_cached_object($data);
$data = $this->unref($data);
}
// We dont' support native TTL here as we consolidate data for sessions.
- if ($this->has_a_ttl()) {
+ if ($this->has_a_ttl() && !$this->store_supports_native_ttl()) {
$data = new cache_ttl_wrapper($data, $this->get_definition()->get_ttl());
}
- $session = $this->get_session_data();
- $session[$this->parse_key($key)] = $data;
- return $this->save_session($session);
+ return $this->get_store()->set($this->parse_key($key), $data);
}
/**
* @return bool True of success, false otherwise.
*/
public function delete($key, $recurse = true) {
- $this->check_tracked_user();
$parsedkey = $this->parse_key($key);
if ($recurse && $this->get_loader() !== false) {
// Delete from the bottom of the stack first.
$this->get_loader()->delete($key, $recurse);
}
- $session = $this->get_session_data();
- unset($session[$parsedkey]);
- return $this->save_session($session);
+ return $this->get_store()->delete($parsedkey);
}
/**
* @return array An array of key value pairs for the items that could be retrieved from the cache.
* If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown.
* Otherwise any key that did not exist will have a data value of false within the results.
- * @throws moodle_exception
+ * @throws coding_exception
*/
public function get_many(array $keys, $strictness = IGNORE_MISSING) {
$this->check_tracked_user();
- $return = array();
+ $parsedkeys = array();
+ $keymap = array();
foreach ($keys as $key) {
- $return[$key] = $this->get($key, $strictness);
+ $parsedkey = $this->parse_key($key);
+ $parsedkeys[$key] = $parsedkey;
+ $keymap[$parsedkey] = $key;
+ }
+ $result = $this->get_store()->get_many($parsedkeys);
+ $return = array();
+ $missingkeys = array();
+ $hasmissingkeys = false;
+ foreach ($result as $parsedkey => $value) {
+ $key = $keymap[$parsedkey];
+ if ($value instanceof cache_ttl_wrapper) {
+ /* @var cache_ttl_wrapper $value */
+ if ($value->has_expired()) {
+ $this->delete($keymap[$parsedkey]);
+ $value = false;
+ } else {
+ $value = $value->data;
+ }
+ }
+ if ($value instanceof cache_cached_object) {
+ /* @var cache_cached_object $value */
+ $value = $value->restore_object();
+ }
+ $return[$key] = $value;
+ if ($value === false) {
+ $hasmissingkeys = true;
+ $missingkeys[$parsedkey] = $key;
+ }
+ }
+ if ($hasmissingkeys) {
+ // We've got missing keys - we've got to check any loaders or data sources.
+ $loader = $this->get_loader();
+ $datasource = $this->get_datasource();
+ if ($loader !== false) {
+ foreach ($loader->get_many($missingkeys) as $key => $value) {
+ if ($value !== false) {
+ $return[$key] = $value;
+ unset($missingkeys[$parsedkeys[$key]]);
+ }
+ }
+ }
+ $hasmissingkeys = count($missingkeys) > 0;
+ if ($datasource !== false && $hasmissingkeys) {
+ // We're still missing keys but we've got a datasource.
+ foreach ($datasource->load_many_for_cache($missingkeys) as $key => $value) {
+ if ($value !== false) {
+ $return[$key] = $value;
+ unset($missingkeys[$parsedkeys[$key]]);
+ }
+ }
+ $hasmissingkeys = count($missingkeys) > 0;
+ }
}
+ if ($hasmissingkeys && $strictness === MUST_EXIST) {
+ throw new coding_exception('Requested key did not exist in any cache stores and could not be loaded.');
+ }
+
return $return;
+
}
/**
* @return int The number of items successfully deleted.
*/
public function delete_many(array $keys, $recurse = true) {
- $this->check_tracked_user();
$parsedkeys = array_map(array($this, 'parse_key'), $keys);
if ($recurse && $this->get_loader() !== false) {
// Delete from the bottom of the stack first.
$this->get_loader()->delete_many($keys, $recurse);
}
- $session = $this->get_session_data();
- foreach ($parsedkeys as $parsedkey) {
- unset($session[$parsedkey]);
- }
- $this->save_session($session);
- return count($keys);
+ return $this->get_store()->delete_many($parsedkeys);
}
/**
*/
public function set_many(array $keyvaluearray) {
$this->check_tracked_user();
- $session = $this->get_session_data();
- $simulatettl = $this->has_a_ttl();
+ $loader = $this->get_loader();
+ if ($loader !== false) {
+ // We have a loader available set it there as well.
+ // We have to let the loader do its own parsing of data as it may be unique.
+ $loader->set_many($keyvaluearray);
+ }
+ $data = array();
+ $definitionid = $this->get_definition()->get_ttl();
+ $simulatettl = $this->has_a_ttl() && !$this->store_supports_native_ttl();
foreach ($keyvaluearray as $key => $value) {
if (is_object($value) && $value instanceof cacheable_object) {
$value = new cache_cached_object($value);
$value = $this->unref($value);
}
if ($simulatettl) {
- $value = new cache_ttl_wrapper($value, $this->get_definition()->get_ttl());
+ $value = new cache_ttl_wrapper($value, $definitionid);
}
- $parsedkey = $this->parse_key($key);
- $session[$parsedkey] = $value;
+ $data[$key] = array(
+ 'key' => $this->parse_key($key),
+ 'value' => $value
+ );
}
if ($this->perfdebug) {
- cache_helper::record_cache_set($this->storetype, $this->get_definition()->get_id());
+ cache_helper::record_cache_set($this->storetype, $definitionid);
}
- $this->save_session($session);
- return count($keyvaluearray);
+ return $this->get_store()->set_many($data);
}
/**
* @return bool True on success, false otherwise
*/
public function purge() {
- // 1. Purge the session object.
- $this->session = array();
- // 2. Delete the record for this users session from the store.
- $this->get_store()->delete($this->sessionid);
- // 3. Optionally purge any stacked loaders in the same way.
+ $this->get_store()->purge();
if ($this->get_loader()) {
- $this->get_loader()->delete($this->sessionid);
+ $this->get_loader()->purge();
}
return true;
}
public function has($key, $tryloadifpossible = false) {
$this->check_tracked_user();
$parsedkey = $this->parse_key($key);
- $session = $this->get_session_data();
- $has = false;
- if ($this->has_a_ttl()) {
+ $store = $this->get_store();
+ if ($this->has_a_ttl() && !$this->store_supports_native_ttl()) {
// The data has a TTL and the store doesn't support it natively.
// We must fetch the data and expect a ttl wrapper.
- if (array_key_exists($parsedkey, $session)) {
- $data = $session[$parsedkey];
- $has = ($data instanceof cache_ttl_wrapper && !$data->has_expired());
- }
+ $data = $store->get($parsedkey);
+ $has = ($data instanceof cache_ttl_wrapper && !$data->has_expired());
+ } else if (!$this->store_supports_key_awareness()) {
+ // The store doesn't support key awareness, get the data and check it manually... puke.
+ // Either no TTL is set of the store supports its handling natively.
+ $data = $store->get($parsedkey);
+ $has = ($data !== false);
} else {
- $has = array_key_exists($parsedkey, $session);
+ // The store supports key awareness, this is easy!
+ // Either no TTL is set of the store supports its handling natively.
+ /* @var cache_store|cache_is_key_aware $store */
+ $has = $store->has($parsedkey);
}
if (!$has && $tryloadifpossible) {
+ $result = null;
if ($this->get_loader() !== false) {
- $result = $this->get_loader()->get($key);
+ $result = $this->get_loader()->get($parsedkey);
} else if ($this->get_datasource() !== null) {
$result = $this->get_datasource()->load_for_cache($key);
}
*/
public function has_all(array $keys) {
$this->check_tracked_user();
- $session = $this->get_session_data();
- foreach ($keys as $key) {
- $has = false;
- $parsedkey = $this->parse_key($key);
- if ($this->has_a_ttl()) {
- // The data has a TTL and the store doesn't support it natively.
- // We must fetch the data and expect a ttl wrapper.
- if (array_key_exists($parsedkey, $session)) {
- $data = $session[$parsedkey];
- $has = ($data instanceof cache_ttl_wrapper && !$data->has_expired());
+ if (($this->has_a_ttl() && !$this->store_supports_native_ttl()) || !$this->store_supports_key_awareness()) {
+ foreach ($keys as $key) {
+ if (!$this->has($key)) {
+ return false;
}
- } else {
- $has = array_key_exists($parsedkey, $session);
- }
- if (!$has) {
- return false;
}
+ return true;
}
- return true;
+ // The cache must be key aware and if support native ttl if it a ttl is set.
+ /* @var cache_store|cache_is_key_aware $store */
+ $store = $this->get_store();
+ return $store->has_all(array_map(array($this, 'parse_key'), $keys));
}
/**
* @return bool True if the cache has at least one of the given keys
*/
public function has_any(array $keys) {
- $this->check_tracked_user();
- $session = $this->get_session_data();
- foreach ($keys as $key) {
- $has = false;
- $parsedkey = $this->parse_key($key);
- if ($this->has_a_ttl()) {
- // The data has a TTL and the store doesn't support it natively.
- // We must fetch the data and expect a ttl wrapper.
- if (array_key_exists($parsedkey, $session)) {
- $data = $session[$parsedkey];
- $has = ($data instanceof cache_ttl_wrapper && !$data->has_expired());
+ if (($this->has_a_ttl() && !$this->store_supports_native_ttl()) || !$this->store_supports_key_awareness()) {
+ foreach ($keys as $key) {
+ if ($this->has($key)) {
+ return true;
}
- } else {
- $has = array_key_exists($parsedkey, $session);
- }
- if ($has) {
- return true;
}
+ return false;
}
- return false;
+ /* @var cache_store|cache_is_key_aware $store */
+ $store = $this->get_store();
+ return $store->has_any(array_map(array($this, 'parse_key'), $keys));
}
/**
$filename = $key.'.cache';
$file = $this->file_path_for_key($key);
$ttl = $this->definition->get_ttl();
+ $maxtime = 0;
if ($ttl) {
$maxtime = cache::now() - $ttl;
}
/**
* The maximum size for the store, or false if there isn't one.
- * @var bool
+ * @var bool|int
*/
protected $maxsize = false;
*/
public function initialise(cache_definition $definition) {
$this->storeid = $definition->generate_definition_hash();
- $this->store = &self::register_store_id($definition->get_id());
+ $this->store = &self::register_store_id($this->name.'-'.$definition->get_id());
$this->ttl = $definition->get_ttl();
$maxsize = $definition->get_maxsize();
if ($maxsize !== null) {
$this->maxsize = abs((int)$maxsize);
$this->storecount = count($this->store);
}
+ $this->check_ttl();
}
/**
public function get($key) {
if (isset($this->store[$key])) {
if ($this->ttl == 0) {
- return $this->store[$key][0];
+ $value = $this->store[$key][0];
+ if ($this->maxsize !== false) {
+ // Make sure the element is now in the end of array.
+ $this->set($key, $value);
+ }
+ return $value;
} else if ($this->store[$key][1] >= (cache::now() - $this->ttl)) {
return $this->store[$key][0];
+ } else {
+ // Element is present but has expired.
+ $this->check_ttl();
}
}
return false;
*/
public function get_many($keys) {
$return = array();
+ $maxtime = 0;
if ($this->ttl != 0) {
$maxtime = cache::now() - $this->ttl;
}
+ $hasexpiredelements = false;
foreach ($keys as $key) {
$return[$key] = false;
if (isset($this->store[$key])) {
if ($this->ttl == 0) {
$return[$key] = $this->store[$key][0];
+ if ($this->maxsize !== false) {
+ // Make sure the element is now in the end of array.
+ $this->set($key, $return[$key], false);
+ }
} else if ($this->store[$key][1] >= $maxtime) {
$return[$key] = $this->store[$key][0];
+ } else {
+ $hasexpiredelements = true;
}
}
}
+ if ($hasexpiredelements) {
+ // There are some elements that are present but have expired.
+ $this->check_ttl();
+ }
return $return;
}
*
* @param string $key The key to use.
* @param mixed $data The data to set.
- * @param bool $testmaxsize If set to true then we test the maxsize arg and reduce if required.
+ * @param bool $testmaxsize If set to true then we test the maxsize arg and reduce if required. If this is set to false you will
+ * need to perform these checks yourself. This allows for bulk set's to be performed and maxsize tests performed once.
* @return bool True if the operation was a success false otherwise.
*/
public function set($key, $data, $testmaxsize = true) {
$testmaxsize = ($testmaxsize && $this->maxsize !== false);
- if ($testmaxsize) {
- $increment = (!isset($this->store[$key]));
+ $increment = $this->maxsize !== false && !isset($this->store[$key]);
+ if (($this->maxsize !== false && !$increment) || $this->ttl != 0) {
+ // Make sure the element is added to the end of $this->store array.
+ unset($this->store[$key]);
}
- if ($this->ttl == 0) {
- $this->store[$key][0] = $data;
+ if ($this->ttl === 0) {
+ $this->store[$key] = array($data, 0);
} else {
$this->store[$key] = array($data, cache::now());
}
- if ($testmaxsize && $increment) {
+ if ($increment) {
$this->storecount++;
- if ($this->storecount > $this->maxsize) {
- $this->reduce_for_maxsize();
- }
+ }
+ if ($testmaxsize && $this->storecount > $this->maxsize) {
+ $this->reduce_for_maxsize();
}
return true;
}
*/
public function set_many(array $keyvaluearray) {
$count = 0;
+ $increment = 0;
foreach ($keyvaluearray as $pair) {
- $this->set($pair['key'], $pair['value'], false);
+ $key = $pair['key'];
+ $data = $pair['value'];
$count++;
+ if ($this->maxsize !== false || $this->ttl !== 0) {
+ // Make sure the element is added to the end of $this->store array.
+ $this->delete($key);
+ $increment++;
+ } else if (!isset($this->store[$key])) {
+ $increment++;
+ }
+ if ($this->ttl === 0) {
+ $this->store[$key] = array($data, 0);
+ } else {
+ $this->store[$key] = array($data, cache::now());
+ }
}
if ($this->maxsize !== false) {
- $this->storecount += $count;
+ $this->storecount += $increment;
if ($this->storecount > $this->maxsize) {
$this->reduce_for_maxsize();
}
* @return bool
*/
public function has_all(array $keys) {
+ $maxtime = 0;
if ($this->ttl != 0) {
$maxtime = cache::now() - $this->ttl;
}
* @return bool
*/
public function has_any(array $keys) {
+ $maxtime = 0;
if ($this->ttl != 0) {
$maxtime = cache::now() - $this->ttl;
}
* @return bool Returns true if the operation was a success, false otherwise.
*/
public function delete($key) {
- $result = isset($this->store[$key]);
+ if (!isset($this->store[$key])) {
+ return false;
+ }
unset($this->store[$key]);
if ($this->maxsize !== false) {
$this->storecount--;
}
- return $result;
+ return true;
}
/**
* @return int The number of items successfully deleted.
*/
public function delete_many(array $keys) {
- $count = 0;
+ // The number of items that have actually being removed.
+ $reduction = 0;
foreach ($keys as $key) {
if (isset($this->store[$key])) {
- $count++;
+ $reduction++;
}
unset($this->store[$key]);
}
if ($this->maxsize !== false) {
- $this->storecount -= $count;
+ $this->storecount -= $reduction;
}
- return $count;
+ return $reduction;
}
/**
return $this->name;
}
+ /**
+ * Removes expired elements.
+ * @return int number of removed elements
+ */
+ protected function check_ttl() {
+ if ($this->ttl === 0) {
+ return 0;
+ }
+ $maxtime = cache::now() - $this->ttl;
+ $count = 0;
+ for ($value = reset($this->store); $value !== false; $value = next($this->store)) {
+ if ($value[1] >= $maxtime) {
+ // We know that elements are sorted by ttl so no need to continue.
+ break;
+ }
+ $count++;
+ }
+ if ($count) {
+ // Remove first $count elements as they are expired.
+ $this->store = array_slice($this->store, $count, null, true);
+ if ($this->maxsize !== false) {
+ $this->storecount -= $count;
+ }
+ }
+ return $count;
+ }
+
/**
* Finds all of the keys being stored in the cache store instance.
*
* @return array
*/
public function find_all() {
+ $this->check_ttl();
return array_keys($this->store);
}
* Finds all of the keys whose keys start with the given prefix.
*
* @param string $prefix
+ * @return array An array of keys.
*/
public function find_by_prefix($prefix) {
$return = array();
}
return $return;
}
+
+ /**
+ * This store supports native TTL handling.
+ * @return bool
+ */
+ public function store_supports_native_ttl() {
+ return true;
+ }
}
* Test the maxsize option.
*/
public function test_maxsize() {
- $defid = 'phpunit/testmaxsize';
$config = cache_config_phpunittest::instance();
- $config->phpunit_add_definition($defid, array(
+ $config->phpunit_add_definition('phpunit/one', array(
'mode' => cache_store::MODE_SESSION,
'component' => 'phpunit',
- 'area' => 'testmaxsize',
+ 'area' => 'one',
'maxsize' => 3
));
- $definition = cache_definition::load($defid, $config->get_definition_by_id($defid));
- $instance = cachestore_session::initialise_test_instance($definition);
- $this->assertTrue($instance->set('key1', 'value1'));
- $this->assertTrue($instance->set('key2', 'value2'));
- $this->assertTrue($instance->set('key3', 'value3'));
+ $config->phpunit_add_definition('phpunit/two', array(
+ 'mode' => cache_store::MODE_SESSION,
+ 'component' => 'phpunit',
+ 'area' => 'two',
+ 'maxsize' => 3
+ ));
+
+ $cacheone = cache::make('phpunit', 'one');
- $this->assertTrue($instance->has('key1'));
- $this->assertTrue($instance->has('key2'));
- $this->assertTrue($instance->has('key3'));
+ $this->assertTrue($cacheone->set('key1', 'value1'));
+ $this->assertTrue($cacheone->set('key2', 'value2'));
+ $this->assertTrue($cacheone->set('key3', 'value3'));
- $this->assertTrue($instance->set('key4', 'value4'));
- $this->assertTrue($instance->set('key5', 'value5'));
+ $this->assertTrue($cacheone->has('key1'));
+ $this->assertTrue($cacheone->has('key2'));
+ $this->assertTrue($cacheone->has('key3'));
- $this->assertFalse($instance->has('key1'));
- $this->assertFalse($instance->has('key2'));
- $this->assertTrue($instance->has('key3'));
- $this->assertTrue($instance->has('key4'));
- $this->assertTrue($instance->has('key5'));
+ $this->assertTrue($cacheone->set('key4', 'value4'));
+ $this->assertTrue($cacheone->set('key5', 'value5'));
- $this->assertFalse($instance->get('key1'));
- $this->assertFalse($instance->get('key2'));
- $this->assertEquals('value3', $instance->get('key3'));
- $this->assertEquals('value4', $instance->get('key4'));
- $this->assertEquals('value5', $instance->get('key5'));
+ $this->assertFalse($cacheone->has('key1'));
+ $this->assertFalse($cacheone->has('key2'));
+ $this->assertTrue($cacheone->has('key3'));
+ $this->assertTrue($cacheone->has('key4'));
+ $this->assertTrue($cacheone->has('key5'));
+
+ $this->assertFalse($cacheone->get('key1'));
+ $this->assertFalse($cacheone->get('key2'));
+ $this->assertEquals('value3', $cacheone->get('key3'));
+ $this->assertEquals('value4', $cacheone->get('key4'));
+ $this->assertEquals('value5', $cacheone->get('key5'));
// Test adding one more.
- $this->assertTrue($instance->set('key6', 'value6'));
- $this->assertFalse($instance->get('key3'));
+ $this->assertTrue($cacheone->set('key6', 'value6'));
+ $this->assertFalse($cacheone->get('key3'));
// Test reducing and then adding to make sure we don't lost one.
- $this->assertTrue($instance->delete('key6'));
- $this->assertTrue($instance->set('key7', 'value7'));
- $this->assertEquals('value4', $instance->get('key4'));
+ $this->assertTrue($cacheone->delete('key6'));
+ $this->assertTrue($cacheone->set('key7', 'value7'));
+ $this->assertEquals('value4', $cacheone->get('key4'));
// Set the same key three times to make sure it doesn't count overrides.
for ($i = 0; $i < 3; $i++) {
- $this->assertTrue($instance->set('key8', 'value8'));
+ $this->assertTrue($cacheone->set('key8', 'value8'));
}
- $this->assertEquals('value7', $instance->get('key7'), 'Overrides are incorrectly incrementing size');
+ $this->assertEquals('value7', $cacheone->get('key7'), 'Overrides are incorrectly incrementing size');
// Test adding many.
- $this->assertEquals(3, $instance->set_many(array(
- array('key' => 'keyA', 'value' => 'valueA'),
- array('key' => 'keyB', 'value' => 'valueB'),
- array('key' => 'keyC', 'value' => 'valueC')
+ $this->assertEquals(3, $cacheone->set_many(array(
+ 'keyA' => 'valueA',
+ 'keyB' => 'valueB',
+ 'keyC' => 'valueC'
)));
$this->assertEquals(array(
'key4' => false,
'keyA' => 'valueA',
'keyB' => 'valueB',
'keyC' => 'valueC'
- ), $instance->get_many(array(
+ ), $cacheone->get_many(array(
'key4', 'key5', 'key6', 'key7', 'keyA', 'keyB', 'keyC'
)));
+
+ $cachetwo = cache::make('phpunit', 'two');
+
+ // Test adding many.
+ $this->assertEquals(3, $cacheone->set_many(array(
+ 'keyA' => 'valueA',
+ 'keyB' => 'valueB',
+ 'keyC' => 'valueC'
+ )));
+
+ $this->assertEquals(3, $cachetwo->set_many(array(
+ 'key1' => 'value1',
+ 'key2' => 'value2',
+ 'key3' => 'value3'
+ )));
+
+ $this->assertEquals(array(
+ 'keyA' => 'valueA',
+ 'keyB' => 'valueB',
+ 'keyC' => 'valueC'
+ ), $cacheone->get_many(array(
+ 'keyA', 'keyB', 'keyC'
+ )));
+
+ $this->assertEquals(array(
+ 'key1' => 'value1',
+ 'key2' => 'value2',
+ 'key3' => 'value3'
+ ), $cachetwo->get_many(array(
+ 'key1', 'key2', 'key3'
+ )));
+
+ // Test that that cache deletes element that was least recently accessed.
+ $this->assertEquals('valueA', $cacheone->get('keyA'));
+ $cacheone->set('keyD', 'valueD');
+ $this->assertEquals('valueA', $cacheone->get('keyA'));
+ $this->assertFalse($cacheone->get('keyB'));
+ $this->assertEquals(array('keyD' => 'valueD', 'keyC' => 'valueC'), $cacheone->get_many(array('keyD', 'keyC')));
+ $cacheone->set('keyE', 'valueE');
+ $this->assertFalse($cacheone->get('keyB'));
+ $this->assertFalse($cacheone->get('keyA'));
+ $this->assertEquals(array('keyA' => false, 'keyE' => 'valueE', 'keyD' => 'valueD', 'keyC' => 'valueC'),
+ $cacheone->get_many(array('keyA', 'keyE', 'keyD', 'keyC')));
+ // Overwrite keyE (moves it to the end of array), and set keyF.
+ $cacheone->set_many(array('keyE' => 'valueE', 'keyF' => 'valueF'));
+ $this->assertEquals(array('keyC' => 'valueC', 'keyE' => 'valueE', 'keyD' => false, 'keyF' => 'valueF'),
+ $cacheone->get_many(array('keyC', 'keyE', 'keyD', 'keyF')));
+ }
+
+ public function test_ttl() {
+ $config = cache_config_phpunittest::instance();
+ $config->phpunit_add_definition('phpunit/three', array(
+ 'mode' => cache_store::MODE_SESSION,
+ 'component' => 'phpunit',
+ 'area' => 'three',
+ 'maxsize' => 3,
+ 'ttl' => 3
+ ));
+
+ $cachethree = cache::make('phpunit', 'three');
+
+ // Make sure that when cache with ttl is full the elements that were added first are deleted first regardless of access time.
+ $cachethree->set('key1', 'value1');
+ $cachethree->set('key2', 'value2');
+ $cachethree->set('key3', 'value3');
+ $cachethree->set('key4', 'value4');
+ $this->assertFalse($cachethree->get('key1'));
+ $this->assertEquals('value4', $cachethree->get('key4'));
+ $cachethree->set('key5', 'value5');
+ $this->assertFalse($cachethree->get('key2'));
+ $this->assertEquals('value4', $cachethree->get('key4'));
+ $cachethree->set_many(array('key6' => 'value6', 'key7' => 'value7'));
+ $this->assertEquals(array('key3' => false, 'key4' => false, 'key5' => 'value5', 'key6' => 'value6', 'key7' => 'value7'),
+ $cachethree->get_many(array('key3', 'key4', 'key5', 'key6', 'key7')));
}
}
\ No newline at end of file
* Test the hash_key functionality.
*/
public function test_hash_key() {
- global $CFG;
-
- $currentdebugging = $CFG->debug;
-
- $CFG->debug = E_ALL;
+ $this->resetAfterTest();
+ set_debugging(DEBUG_ALL);
// First with simplekeys
$instance = cache_config_phpunittest::instance(true);
$result = cache_helper::hash_key('test/test', $definition);
$this->assertEquals(sha1($definition->generate_single_key_prefix().'-test/test'), $result);
-
- $CFG->debug = $currentdebugging;
}
}
}
/**
- * Test that multiple loaders work ok.
+ * Test that multiple application loaders work ok.
*/
- public function test_multiple_loaders() {
+ public function test_multiple_application_loaders() {
$instance = cache_config_phpunittest::instance(true);
$instance->phpunit_add_file_store('phpunittest1');
$instance->phpunit_add_file_store('phpunittest2');
$this->assertFalse($result['a']);
$this->assertEquals('B', $result['b']);
$this->assertFalse($result['c']);
+
+ // Test non-recursive deletes.
+ $this->assertTrue($cache->set('test', 'test'));
+ $this->assertSame('test', $cache->get('test'));
+ $this->assertTrue($cache->delete('test', false));
+ // We should still have it on a deeper loader.
+ $this->assertSame('test', $cache->get('test'));
+ // Test non-recusive with many functions.
+ $this->assertSame(3, $cache->set_many(array(
+ 'one' => 'one',
+ 'two' => 'two',
+ 'three' => 'three'
+ )));
+ $this->assertSame('one', $cache->get('one'));
+ $this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
+ $this->assertSame(3, $cache->delete_many(array('one', 'two', 'three'), false));
+ $this->assertSame('one', $cache->get('one'));
+ $this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
+ }
+
+ /**
+ * Test that multiple application loaders work ok.
+ */
+ public function test_multiple_session_loaders() {
+ /* @var cache_config_phpunittest $instance */
+ $instance = cache_config_phpunittest::instance(true);
+ $instance->phpunit_add_session_store('phpunittest1');
+ $instance->phpunit_add_session_store('phpunittest2');
+ $instance->phpunit_add_definition('phpunit/multi_loader', array(
+ 'mode' => cache_store::MODE_SESSION,
+ 'component' => 'phpunit',
+ 'area' => 'multi_loader'
+ ));
+ $instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest1', 3);
+ $instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest2', 2);
+
+ $cache = cache::make('phpunit', 'multi_loader');
+ $this->assertInstanceOf('cache_session', $cache);
+ $this->assertFalse($cache->get('test'));
+ $this->assertTrue($cache->set('test', 'test'));
+ $this->assertEquals('test', $cache->get('test'));
+ $this->assertTrue($cache->delete('test'));
+ $this->assertFalse($cache->get('test'));
+ $this->assertTrue($cache->set('test', 'test'));
+ $this->assertTrue($cache->purge());
+ $this->assertFalse($cache->get('test'));
+
+ // Test the many commands.
+ $this->assertEquals(3, $cache->set_many(array('a' => 'A', 'b' => 'B', 'c' => 'C')));
+ $result = $cache->get_many(array('a', 'b', 'c'));
+ $this->assertInternalType('array', $result);
+ $this->assertCount(3, $result);
+ $this->assertArrayHasKey('a', $result);
+ $this->assertArrayHasKey('b', $result);
+ $this->assertArrayHasKey('c', $result);
+ $this->assertEquals('A', $result['a']);
+ $this->assertEquals('B', $result['b']);
+ $this->assertEquals('C', $result['c']);
+ $this->assertEquals($result, $cache->get_many(array('a', 'b', 'c')));
+ $this->assertEquals(2, $cache->delete_many(array('a', 'c')));
+ $result = $cache->get_many(array('a', 'b', 'c'));
+ $this->assertInternalType('array', $result);
+ $this->assertCount(3, $result);
+ $this->assertArrayHasKey('a', $result);
+ $this->assertArrayHasKey('b', $result);
+ $this->assertArrayHasKey('c', $result);
+ $this->assertFalse($result['a']);
+ $this->assertEquals('B', $result['b']);
+ $this->assertFalse($result['c']);
+
+ // Test non-recursive deletes.
+ $this->assertTrue($cache->set('test', 'test'));
+ $this->assertSame('test', $cache->get('test'));
+ $this->assertTrue($cache->delete('test', false));
+ // We should still have it on a deeper loader.
+ $this->assertSame('test', $cache->get('test'));
+ // Test non-recusive with many functions.
+ $this->assertSame(3, $cache->set_many(array(
+ 'one' => 'one',
+ 'two' => 'two',
+ 'three' => 'three'
+ )));
+ $this->assertSame('one', $cache->get('one'));
+ $this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
+ $this->assertSame(3, $cache->delete_many(array('one', 'two', 'three'), false));
+ $this->assertSame('one', $cache->get('one'));
+ $this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
}
/**
$this->assertInstanceOf('cache_request', $cache);
$this->assertArrayHasKey('cache_is_searchable', $cache->phpunit_get_store_implements());
}
-}
+}
\ No newline at end of file
);
}
+ /**
+ * Forcefully adds a session store.
+ *
+ * @param string $name
+ */
+ public function phpunit_add_session_store($name) {
+ $this->configstores[$name] = array(
+ 'name' => $name,
+ 'plugin' => 'session',
+ 'configuration' => array(),
+ 'features' => 14,
+ 'modes' => 2,
+ 'default' => true,
+ 'class' => 'cachestore_session',
+ 'lock' => 'cachelock_file_default',
+ );
+ }
+
/**
* Forcefully injects a definition => store mapping.
*
* @return stdClass $coursecache[$courseid] return the specific course cache
*/
function calendar_get_course_cached(&$coursecache, $courseid) {
- global $COURSE, $DB;
-
if (!isset($coursecache[$courseid])) {
- if ($courseid == $COURSE->id) {
- $coursecache[$courseid] = $COURSE;
- } else {
- $coursecache[$courseid] = $DB->get_record('course', array('id'=>$courseid));
- }
+ $coursecache[$courseid] = get_course($courseid);
}
return $coursecache[$courseid];
}
--- /dev/null
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Calendar lib unit tests
+ *
+ * @package core_calendar
+ * @copyright 2013 Dan Poltawski <dan@moodle.com>
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+global $CFG;
+require_once($CFG->dirroot . '/calendar/lib.php');
+
+/**
+ * Unit tests for calendar lib
+ *
+ * @package core_calendar
+ * @copyright 2013 Dan Poltawski <dan@moodle.com>
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class core_calendar_lib_testcase extends advanced_testcase {
+
+ public function test_calendar_get_course_cached() {
+ $this->resetAfterTest(true);
+
+ // Setup some test courses.
+ $course1 = $this->getDataGenerator()->create_course();
+ $course2 = $this->getDataGenerator()->create_course();
+ $course3 = $this->getDataGenerator()->create_course();
+
+ // Load courses into cache.
+ $coursecache = null;
+ calendar_get_course_cached($coursecache, $course1->id);
+ calendar_get_course_cached($coursecache, $course2->id);
+ calendar_get_course_cached($coursecache, $course3->id);
+
+ // Verify the cache.
+ $this->assertArrayHasKey($course1->id, $coursecache);
+ $cachedcourse1 = $coursecache[$course1->id];
+ $this->assertEquals($course1->id, $cachedcourse1->id);
+ $this->assertEquals($course1->shortname, $cachedcourse1->shortname);
+ $this->assertEquals($course1->fullname, $cachedcourse1->fullname);
+
+ $this->assertArrayHasKey($course2->id, $coursecache);
+ $cachedcourse2 = $coursecache[$course2->id];
+ $this->assertEquals($course2->id, $cachedcourse2->id);
+ $this->assertEquals($course2->shortname, $cachedcourse2->shortname);
+ $this->assertEquals($course2->fullname, $cachedcourse2->fullname);
+
+ $this->assertArrayHasKey($course3->id, $coursecache);
+ $cachedcourse3 = $coursecache[$course3->id];
+ $this->assertEquals($course3->id, $cachedcourse3->id);
+ $this->assertEquals($course3->shortname, $cachedcourse3->shortname);
+ $this->assertEquals($course3->fullname, $cachedcourse3->fullname);
+ }
+}
$cohort->id = $DB->insert_record('cohort', $cohort);
- events_trigger('cohort_added', $cohort);
+ $event = \core\event\cohort_created::create(array(
+ 'context' => context::instance_by_id($cohort->contextid),
+ 'objectid' => $cohort->id,
+ ));
+ $event->add_record_snapshot('cohort', $cohort);
+ $event->trigger();
return $cohort->id;
}
$cohort->timemodified = time();
$DB->update_record('cohort', $cohort);
- events_trigger('cohort_updated', $cohort);
+ $event = \core\event\cohort_updated::create(array(
+ 'context' => context::instance_by_id($cohort->contextid),
+ 'objectid' => $cohort->id,
+ ));
+ $event->add_record_snapshot('cohort', $cohort);
+ $event->trigger();
}
/**
$DB->delete_records('cohort_members', array('cohortid'=>$cohort->id));
$DB->delete_records('cohort', array('id'=>$cohort->id));
- events_trigger('cohort_deleted', $cohort);
+ $event = \core\event\cohort_deleted::create(array(
+ 'context' => context::instance_by_id($cohort->contextid),
+ 'objectid' => $cohort->id,
+ ));
+ $event->add_record_snapshot('cohort', $cohort);
+ $event->trigger();
}
/**
$record->timeadded = time();
$DB->insert_record('cohort_members', $record);
- events_trigger('cohort_member_added', (object)array('cohortid'=>$cohortid, 'userid'=>$userid));
+ $cohort = $DB->get_record('cohort', array('id' => $cohortid), '*', MUST_EXIST);
+
+ $event = \core\event\cohort_member_added::create(array(
+ 'context' => context::instance_by_id($cohort->contextid),
+ 'objectid' => $cohortid,
+ 'relateduserid' => $userid,
+ ));
+ $event->add_record_snapshot('cohort', $cohort);
+ $event->trigger();
}
/**
global $DB;
$DB->delete_records('cohort_members', array('cohortid'=>$cohortid, 'userid'=>$userid));
- events_trigger('cohort_member_removed', (object)array('cohortid'=>$cohortid, 'userid'=>$userid));
+ $cohort = $DB->get_record('cohort', array('id' => $cohortid), '*', MUST_EXIST);
+
+ $event = \core\event\cohort_member_removed::create(array(
+ 'context' => context::instance_by_id($cohort->contextid),
+ 'objectid' => $cohortid,
+ 'relateduserid' => $userid,
+ ));
+ $event->add_record_snapshot('cohort', $cohort);
+ $event->trigger();
}
/**
$this->assertNotEmpty($newcohort->timecreated);
$this->assertSame($newcohort->component, '');
$this->assertSame($newcohort->timecreated, $newcohort->timemodified);
+ }
+
+ public function test_cohort_add_cohort_missing_name() {
+ $cohort = new stdClass();
+ $cohort->contextid = context_system::instance()->id;
+ $cohort->name = null;
+ $cohort->idnumber = 'testid';
+ $cohort->description = 'test cohort desc';
+ $cohort->descriptionformat = FORMAT_HTML;
+
+ $this->setExpectedException('coding_exception', 'Missing cohort name in cohort_add_cohort().');
+ cohort_add_cohort($cohort);
+ }
+
+ public function test_cohort_add_cohort_event() {
+ $this->resetAfterTest();
+
+ // Setup cohort data structure.
+ $cohort = new stdClass();
+ $cohort->contextid = context_system::instance()->id;
+ $cohort->name = 'test cohort';
+ $cohort->idnumber = 'testid';
+ $cohort->description = 'test cohort desc';
+ $cohort->descriptionformat = FORMAT_HTML;
- try {
- $cohort = new stdClass();
- $cohort->contextid = context_system::instance()->id;
- $cohort->name = null;
- $cohort->idnumber = 'testid';
- $cohort->description = 'test cohort desc';
- $cohort->descriptionformat = FORMAT_HTML;
- cohort_add_cohort($cohort);
-
- $this->fail('Exception expected when trying to add cohort without name');
- } catch (Exception $e) {
- $this->assertInstanceOf('coding_exception', $e);
- }
+ // Catch Events.
+ $sink = $this->redirectEvents();
+
+ // Perform the add operation.
+ $id = cohort_add_cohort($cohort);
+
+ // Capture the event.
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $this->assertCount(1, $events);
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\cohort_created', $event);
+ $this->assertEquals('cohort', $event->objecttable);
+ $this->assertEquals($id, $event->objectid);
+ $this->assertEquals($cohort->contextid, $event->contextid);
+ $this->assertEquals($cohort, $event->get_record_snapshot('cohort', $id));
+ $this->assertEventLegacyData($cohort, $event);
}
public function test_cohort_update_cohort() {
$this->assertLessThanOrEqual(time(), $newcohort->timemodified);
}
+ public function test_cohort_update_cohort_event() {
+ global $DB;
+
+ $this->resetAfterTest();
+
+ // Setup the cohort data structure.
+ $cohort = new stdClass();
+ $cohort->contextid = context_system::instance()->id;
+ $cohort->name = 'test cohort';
+ $cohort->idnumber = 'testid';
+ $cohort->description = 'test cohort desc';
+ $cohort->descriptionformat = FORMAT_HTML;
+ $id = cohort_add_cohort($cohort);
+ $this->assertNotEmpty($id);
+
+ $cohort->name = 'test cohort 2';
+
+ // Catch Events.
+ $sink = $this->redirectEvents();
+
+ // Peform the update.
+ cohort_update_cohort($cohort);
+
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $this->assertCount(1, $events);
+ $event = $events[0];
+ $updatedcohort = $DB->get_record('cohort', array('id'=>$id));
+ $this->assertInstanceOf('\core\event\cohort_updated', $event);
+ $this->assertEquals('cohort', $event->objecttable);
+ $this->assertEquals($updatedcohort->id, $event->objectid);
+ $this->assertEquals($updatedcohort->contextid, $event->contextid);
+ $this->assertEquals($cohort, $event->get_record_snapshot('cohort', $id));
+ $this->assertEventLegacyData($cohort, $event);
+ }
+
public function test_cohort_delete_cohort() {
global $DB;
$this->assertFalse($DB->record_exists('cohort', array('id'=>$cohort->id)));
}
+ public function test_cohort_delete_cohort_event() {
+
+ $this->resetAfterTest();
+
+ $cohort = $this->getDataGenerator()->create_cohort();
+
+ // Capture the events.
+ $sink = $this->redirectEvents();
+
+ // Perform the delete.
+ cohort_delete_cohort($cohort);
+
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event structure.
+ $this->assertCount(1, $events);
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\cohort_deleted', $event);
+ $this->assertEquals('cohort', $event->objecttable);
+ $this->assertEquals($cohort->id, $event->objectid);
+ $this->assertEquals($cohort, $event->get_record_snapshot('cohort', $cohort->id));
+ $this->assertEventLegacyData($cohort, $event);
+ }
+
public function test_cohort_delete_category() {
global $DB;
$this->assertTrue($DB->record_exists('cohort_members', array('cohortid'=>$cohort->id, 'userid'=>$user->id)));
}
+ public function test_cohort_add_member_event() {
+ global $USER;
+ $this->resetAfterTest();
+
+ // Setup the data.
+ $cohort = $this->getDataGenerator()->create_cohort();
+ $user = $this->getDataGenerator()->create_user();
+
+ // Capture the events.
+ $sink = $this->redirectEvents();
+
+ // Peform the add member operation.
+ cohort_add_member($cohort->id, $user->id);
+
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $this->assertCount(1, $events);
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\cohort_member_added', $event);
+ $this->assertEquals('cohort', $event->objecttable);
+ $this->assertEquals($cohort->id, $event->objectid);
+ $this->assertEquals($user->id, $event->relateduserid);
+ $this->assertEquals($USER->id, $event->userid);
+ $this->assertEventLegacyData((object) array('cohortid' => $cohort->id, 'userid' => $user->id), $event);
+ }
+
public function test_cohort_remove_member() {
global $DB;
$this->assertFalse($DB->record_exists('cohort_members', array('cohortid'=>$cohort->id, 'userid'=>$user->id)));
}
+ public function test_cohort_remove_member_event() {
+ global $USER;
+ $this->resetAfterTest();
+
+ // Setup the data.
+ $cohort = $this->getDataGenerator()->create_cohort();
+ $user = $this->getDataGenerator()->create_user();
+ cohort_add_member($cohort->id, $user->id);
+
+ // Capture the events.
+ $sink = $this->redirectEvents();
+
+ // Peform the remove operation.
+ cohort_remove_member($cohort->id, $user->id);
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $this->assertCount(1, $events);
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\cohort_member_removed', $event);
+ $this->assertEquals('cohort', $event->objecttable);
+ $this->assertEquals($cohort->id, $event->objectid);
+ $this->assertEquals($user->id, $event->relateduserid);
+ $this->assertEquals($USER->id, $event->userid);
+ $this->assertEventLegacyData((object) array('cohortid' => $cohort->id, 'userid' => $user->id), $event);
+ }
+
public function test_cohort_is_member() {
global $DB;
// $CFG->debugusers = '2';
//
// Prevent theme caching
-// $CFG->themerev = -1; // NOT FOR PRODUCTION SERVERS!
+// $CFG->themedesignermode = true; // NOT FOR PRODUCTION SERVERS!
//
// Prevent JS caching
-// $CFG->jsrev = -1; // NOT FOR PRODUCTION SERVERS!
+// $CFG->cachejs = false; // NOT FOR PRODUCTION SERVERS!
//
// Prevent core_string_manager application caching
// $CFG->langstringcache = false; // NOT FOR PRODUCTION SERVERS!
$aggregation->setMethod($data->role_aggregation);
$aggregation->save();
- // Log changes.
- add_to_log($course->id, 'course', 'completion updated', 'completion.php?id='.$course->id);
+ // Trigger an event for course module completion changed.
+ $event = \core\event\course_completion_updated::create(
+ array(
+ 'courseid' => $course->id,
+ 'context' => context_course::instance($course->id)
+ )
+ );
+ $event->trigger();
// Redirect to the course main page.
$url = new moodle_url('/course/view.php', array('id' => $course->id));
print_error('confirmsesskeybad', 'error');
}
- // OK checks done, delete the course now.
-
- add_to_log(SITEID, "course", "delete", "view.php?id=$course->id", "$course->fullname (ID $course->id)");
-
$strdeletingcourse = get_string("deletingcourse", "", $courseshortname);
$PAGE->navbar->add($strdeletingcourse);
require_once("../config.php");
require_once("lib.php");
+require_once($CFG->libdir . '/formslib.php');
require_once($CFG->libdir . '/conditionlib.php');
$id = required_param('id', PARAM_INT); // course_sections.id
$context = context_course::instance($course->id);
require_capability('moodle/course:update', $context);
-// get section_info object with all availability options
+// Get section_info object with all availability options.
$sectioninfo = get_fast_modinfo($course)->get_section_info($sectionnum);
$editoroptions = array('context'=>$context ,'maxfiles' => EDITOR_UNLIMITED_FILES, 'maxbytes'=>$CFG->maxbytes, 'trusttext'=>false, 'noclean'=>true);
$mform->set_data(convert_to_array($sectioninfo));
if ($mform->is_cancelled()){
- // form cancelled, return to course
+ // Form cancelled, return to course.
redirect(course_get_url($course, $section, array('sr' => $sectionreturn)));
} else if ($data = $mform->get_data()) {
- // data submitted and validated, update and return to course
+ // Data submitted and validated, update and return to course.
$DB->update_record('course_sections', $data);
rebuild_course_cache($course->id, true);
if (isset($data->section)) {
- // usually edit form does not change relative section number but just in case
+ // Usually edit form does not change relative section number but just in case.
$sectionnum = $data->section;
}
if (!empty($CFG->enableavailability)) {
- // Update grade and completion conditions
+ // Update grade and completion conditions.
$sectioninfo = get_fast_modinfo($course)->get_section_info($sectionnum);
condition_info_section::update_section_from_form($sectioninfo, $data);
rebuild_course_cache($course->id, true);
}
course_get_format($course->id)->update_section_format_options($data);
- add_to_log($course->id, "course", "editsection", "editsection.php?id=$id", "$sectionnum");
+ // Set section info, as this might not be present in form_data.
+ if (!isset($data->section)) {
+ $data->section = $sectionnum;
+ }
+ // Trigger an event for course section update.
+ $event = \core\event\course_section_updated::create(
+ array(
+ 'objectid' => $data->id,
+ 'courseid' => $course->id,
+ 'context' => $context,
+ 'other' => array('sectionnum' => $data->section)
+ )
+ );
+ $event->trigger();
+
$PAGE->navigation->clear_cache();
redirect(course_get_url($course, $section, array('sr' => $sectionreturn)));
}
-// the edit form is displayed for the first time or there was a validation
-// error on the previous step. Display the edit form:
+// The edit form is displayed for the first time or if there was validation error on the previous step.
$sectionname = get_section_name($course, $sectionnum);
$stredit = get_string('edita', '', " $sectionname");
$strsummaryof = get_string('summaryof', '', " $sectionname");
// When on a section page, we only display the general section title, if title is not the default one
$hasnamesecpg = ($onsectionpage && ($section->section == 0 && !is_null($section->name)));
+ $classes = ' accesshide';
if ($hasnamenotsecpg || $hasnamesecpg) {
- $o.= $this->output->heading($this->section_title($section, $course), 3, 'sectionname');
+ $classes = '';
}
+ $o.= $this->output->heading($this->section_title($section, $course), 3, 'sectionname' . $classes);
$o.= html_writer::start_tag('div', array('class' => 'summary'));
$o.= $this->format_summary_text($section);
require_once($CFG->libdir.'/completionlib.php');
require_once($CFG->libdir.'/filelib.php');
-require_once($CFG->dirroot.'/course/dnduploadlib.php');
require_once($CFG->dirroot.'/course/format/lib.php');
define('COURSE_MAX_LOGS_PER_PAGE', 1000); // records
$mod[$seq]->extraclasses = $info->extraclasses;
}
if (!empty($info->iconurl)) {
- $mod[$seq]->iconurl = $info->iconurl;
+ // Convert URL to string as it's easier to store. Also serialized object contains \0 byte and can not be written to Postgres DB.
+ $url = new moodle_url($info->iconurl);
+ $mod[$seq]->iconurl = $url->out(false);
}
if (!empty($info->onclick)) {
$mod[$seq]->onclick = $info->onclick;
array('class' => 'editing_'. $actionname, 'data-action' => $actionname, 'data-nextgroupmode' => $nextgroupmode)
);
} else {
- $actions[$actionname] = new pix_icon($groupimage, $forcedgrouptitle, 'moodle', array('title' => '', 'class' => 'iconsmall'));
+ $actions[$actionname] = new pix_icon($groupimage, $forcedgrouptitle, 'moodle', array('class' => 'iconsmall'));
}
}
* @return bool success
*/
function move_courses($courseids, $categoryid) {
- global $CFG, $DB, $OUTPUT;
+ global $DB;
if (empty($courseids)) {
- // nothing to do
+ // Nothing to do.
return;
}
- if (!$category = $DB->get_record('course_categories', array('id'=>$categoryid))) {
+ if (!$category = $DB->get_record('course_categories', array('id' => $categoryid))) {
return false;
}
$i = 1;
foreach ($courseids as $courseid) {
- if ($course = $DB->get_record('course', array('id'=>$courseid), 'id, category')) {
+ if ($dbcourse = $DB->get_record('course', array('id' => $courseid))) {
$course = new stdClass();
$course->id = $courseid;
$course->category = $category->id;
$course->sortorder = $category->sortorder + MAX_COURSES_IN_CATEGORY - $i++;
if ($category->visible == 0) {
- // hide the course when moving into hidden category,
- // do not update the visibleold flag - we want to get to previous state if somebody unhides the category
+ // Hide the course when moving into hidden category, do not update the visibleold flag - we want to get
+ // to previous state if somebody unhides the category.
$course->visible = 0;
}
$DB->update_record('course', $course);
- add_to_log($course->id, "course", "move", "edit.php?id=$course->id", $course->id);
- $context = context_course::instance($course->id);
+ // Store the context.
+ $context = context_course::instance($course->id);
+
+ // Update the course object we are passing to the event.
+ $dbcourse->category = $course->category;
+ $dbcourse->sortorder = $course->sortorder;
+
+ // Trigger a course updated event.
+ $event = \core\event\course_updated::create(array(
+ 'objectid' => $course->id,
+ 'context' => $context,
+ 'other' => array('shortname' => $dbcourse->shortname,
+ 'fullname' => $dbcourse->fullname)
+ ));
+ $event->add_record_snapshot('course', $dbcourse);
+ $event->set_legacy_logdata(array($course->id, 'course', 'move', 'edit.php?id=' . $course->id, $course->id));
+ $event->trigger();
+
$context->update_moved($newparent);
}
}
* @return object new course instance
*/
function create_course($data, $editoroptions = NULL) {
- global $CFG, $DB;
+ global $DB;
//check the categoryid - must be given for all new courses
$category = $DB->get_record('course_categories', array('id'=>$data->category), '*', MUST_EXIST);
// set up enrolments
enrol_course_updated(true, $course, $data);
- add_to_log(SITEID, 'course', 'new', 'view.php?id='.$course->id, $data->fullname.' (ID '.$course->id.')');
-
- // Trigger events
- events_trigger('course_created', $course);
+ // Trigger a course created event.
+ $event = \core\event\course_created::create(array(
+ 'objectid' => $course->id,
+ 'context' => context_course::instance($course->id),
+ 'other' => array('shortname' => $course->shortname,
+ 'fullname' => $course->fullname)
+ ));
+ $event->add_record_snapshot('course', $course);
+ $event->trigger();
return $course;
}
* @return void
*/
function update_course($data, $editoroptions = NULL) {
- global $CFG, $DB;
+ global $DB;
$data->timemodified = time();
// update enrol settings
enrol_course_updated(false, $course, $data);
- add_to_log($course->id, "course", "update", "edit.php?id=$course->id", $course->id);
-
- // Trigger events
- events_trigger('course_updated', $course);
+ // Trigger a course updated event.
+ $event = \core\event\course_updated::create(array(
+ 'objectid' => $course->id,
+ 'context' => $context,
+ 'other' => array('shortname' => $course->shortname,
+ 'fullname' => $course->fullname)
+ ));
+ $event->add_record_snapshot('course', $course);
+ $event->set_legacy_logdata(array($course->id, 'course', 'update', 'edit.php?id=' . $course->id, $course->id));
+ $event->trigger();
if ($oldcourse->format !== $course->format) {
// Remove all options stored for the previous format
* @return bool
*/
function include_course_ajax($course, $usedmodules = array(), $enabledmodules = null, $config = null) {
- global $PAGE, $SITE;
+ global $CFG, $PAGE, $SITE;
// Ensure that ajax should be included
if (!course_ajax_enabled($course)) {
'markedthistopic',
'move',
'movesection',
+ 'movecontent',
+ 'tocontent',
+ 'emptydragdropregion'
), 'moodle');
// Include format-specific strings
}
// Load drag and drop upload AJAX.
+ require_once($CFG->dirroot.'/course/dnduploadlib.php');
dndupload_add_to_course($course, $enabledmodules);
return true;
<?php
-// Allows a teacher/admin to login as another user (in stealth mode)
+// Allows a teacher/admin to login as another user (in stealth mode).
require_once('../config.php');
require_once('lib.php');
$url = new moodle_url('/course/loginas.php', array('id'=>$id));
$PAGE->set_url($url);
-/// Reset user back to their real self if needed, for security reasons you need to log out and log in again
+// Reset user back to their real self if needed, for security reasons you need to log out and log in again.
if (session_is_loggedinas()) {
require_sesskey();
require_logout();
redirect(get_login_url());
}
-///-------------------------------------
-/// We are trying to log in as this user in the first place
-
-$userid = required_param('user', PARAM_INT); // login as this user
+// Try log in as this user.
+$userid = required_param('user', PARAM_INT);
require_sesskey();
$course = $DB->get_record('course', array('id'=>$id), '*', MUST_EXIST);
-/// User must be logged in
+// User must be logged in.
$systemcontext = context_system::instance();
$coursecontext = context_course::instance($course->id);
$context = $coursecontext;
}
-/// Login as this user and return to course home page.
-$oldfullname = fullname($USER, true);
+// Login as this user and return to course home page.
session_loginas($userid, $context);
$newfullname = fullname($USER, true);
-add_to_log($course->id, "course", "loginas", "../user/view.php?id=$course->id&user=$userid", "$oldfullname -> $newfullname");
-
$strloginas = get_string('loginas');
$strloggedinas = get_string('loggedinas', '', $newfullname);
$params = array('id' => $course->id, 'visible' => $visible, 'visibleold' => $visible, 'timemodified' => time());
$DB->update_record('course', $params);
cache_helper::purge_by_event('changesincourse');
- add_to_log($course->id, "course", ($visible ? 'show' : 'hide'), "edit.php?id=$course->id", $course->id);
+
+ // Update the course object we pass to the event class.
+ $course->visible = $params['visible'];
+ $course->visibleold = $params['visibleold'];
+ $course->timemodified = $params['timemodified'];
+
+ // Trigger a course updated event.
+ $event = \core\event\course_updated::create(array(
+ 'objectid' => $course->id,
+ 'context' => $coursecontext,
+ 'other' => array('shortname' => $course->shortname,
+ 'fullname' => $course->fullname)
+ ));
+ $event->add_record_snapshot('course', $course);
+ $event->set_legacy_logdata(array($course->id, 'course', ($visible ? 'show' : 'hide'), 'edit.php?id=' . $course->id, $course->id));
+ $event->trigger();
}
if ((!empty($moveup) or !empty($movedown)) && confirm_sesskey()) {
$DB->set_field('course', 'sortorder', $swapcourse->sortorder, array('id' => $movecourse->id));
$DB->set_field('course', 'sortorder', $movecourse->sortorder, array('id' => $swapcourse->id));
cache_helper::purge_by_event('changesincourse');
- add_to_log($movecourse->id, "course", "move", "edit.php?id=$movecourse->id", $movecourse->id);
+
+ // Update $movecourse's sortorder.
+ $movecourse->sortorder = $swapcourse->sortorder;
+
+ // Trigger a course updated event.
+ $event = \core\event\course_updated::create(array(
+ 'objectid' => $movecourse->id,
+ 'context' => context_course::instance($movecourse->id),
+ 'other' => array('shortname' => $movecourse->shortname,
+ 'fullname' => $movecourse->fullname)
+ ));
+ $event->add_record_snapshot('course', $movecourse);
+ $event->set_legacy_logdata(array($movecourse->id, 'course', 'move', 'edit.php?id=' . $movecourse->id, $movecourse->id));
+ $event->trigger();
}
}
$eventcount = $DB->count_records('event', array('instance' => $assign->id, 'modulename' => 'assign'));
$this->assertEmpty($eventcount);
}
+
+ /**
+ * Test that triggering a course_created event works as expected.
+ */
+ public function test_course_created_event() {
+ $this->resetAfterTest();
+
+ // Catch the events.
+ $sink = $this->redirectEvents();
+
+ // Create the course.
+ $course = $this->getDataGenerator()->create_course();
+
+ // Capture the event.
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\course_created', $event);
+ $this->assertEquals('course', $event->objecttable);
+ $this->assertEquals($course->id, $event->objectid);
+ $this->assertEquals(context_course::instance($course->id)->id, $event->contextid);
+ $this->assertEquals($course, $event->get_record_snapshot('course', $course->id));
+ $this->assertEquals('course_created', $event->get_legacy_eventname());
+ $this->assertEventLegacyData($course, $event);
+ $expectedlog = array(SITEID, 'course', 'new', 'view.php?id=' . $course->id, $course->fullname . ' (ID ' . $course->id . ')');
+ $this->assertEventLegacyLogData($expectedlog, $event);
+ }
+
+ /**
+ * Test that triggering a course_updated event works as expected.
+ */
+ public function test_course_updated_event() {
+ global $DB;
+
+ $this->resetAfterTest();
+
+ // Create a course.
+ $course = $this->getDataGenerator()->create_course();
+
+ // Create a category we are going to move this course to.
+ $category = $this->getDataGenerator()->create_category();
+
+ // Catch the update events.
+ $sink = $this->redirectEvents();
+
+ // Keep track of the old sortorder.
+ $sortorder = $course->sortorder;
+
+ // Call update_course which will trigger a course_updated event.
+ update_course($course);
+
+ // Return the updated course information from the DB.
+ $updatedcourse = $DB->get_record('course', array('id' => $course->id), '*', MUST_EXIST);
+
+ // Now move the course to the category, this will also trigger an event.
+ move_courses(array($course->id), $category->id);
+
+ // Return the moved course information from the DB.
+ $movedcourse = $DB->get_record('course', array('id' => $course->id), '*', MUST_EXIST);
+
+ // Now we want to set the sortorder back to what it was before fix_course_sortorder() was called. The reason for
+ // this is because update_course() and move_courses() call fix_course_sortorder() which alters the sort order in
+ // the DB, but it does not set the value of the sortorder for the course object passed to the event.
+ $updatedcourse->sortorder = $sortorder;
+ $movedcourse->sortorder = $category->sortorder + MAX_COURSES_IN_CATEGORY - 1;
+
+ // Capture the events.
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the events.
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\course_updated', $event);
+ $this->assertEquals('course', $event->objecttable);
+ $this->assertEquals($updatedcourse->id, $event->objectid);
+ $this->assertEquals(context_course::instance($updatedcourse->id)->id, $event->contextid);
+ $this->assertEquals($updatedcourse, $event->get_record_snapshot('course', $updatedcourse->id));
+ $this->assertEquals('course_updated', $event->get_legacy_eventname());
+ $this->assertEventLegacyData($updatedcourse, $event);
+ $expectedlog = array($updatedcourse->id, 'course', 'update', 'edit.php?id=' . $course->id, $course->id);
+ $this->assertEventLegacyLogData($expectedlog, $event);
+
+ $event = $events[1];
+ $this->assertInstanceOf('\core\event\course_updated', $event);
+ $this->assertEquals('course', $event->objecttable);
+ $this->assertEquals($movedcourse->id, $event->objectid);
+ $this->assertEquals(context_course::instance($movedcourse->id)->id, $event->contextid);
+ $this->assertEquals($movedcourse, $event->get_record_snapshot('course', $movedcourse->id));
+ $this->assertEquals('course_updated', $event->get_legacy_eventname());
+ $this->assertEventLegacyData($movedcourse, $event);
+ $expectedlog = array($movedcourse->id, 'course', 'move', 'edit.php?id=' . $movedcourse->id, $movedcourse->id);
+ $this->assertEventLegacyLogData($expectedlog, $event);
+ }
+
+ /**
+ * Test that triggering a course_deleted event works as expected.
+ */
+ public function test_course_deleted_event() {
+ $this->resetAfterTest();
+
+ // Create the course.
+ $course = $this->getDataGenerator()->create_course();
+
+ // Save the course context before we delete the course.
+ $coursecontext = context_course::instance($course->id);
+
+ // Catch the update event.
+ $sink = $this->redirectEvents();
+
+ // Call delete_course() which will trigger the course_deleted event and the course_content_deleted
+ // event. This function prints out data to the screen, which we do not want during a PHPUnit test,
+ // so use ob_start and ob_end_clean to prevent this.
+ ob_start();
+ delete_course($course);
+ ob_end_clean();
+
+ // Capture the event.
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $event = $events[1];
+ $this->assertInstanceOf('\core\event\course_deleted', $event);
+ $this->assertEquals('course', $event->objecttable);
+ $this->assertEquals($course->id, $event->objectid);
+ $this->assertEquals($coursecontext->id, $event->contextid);
+ $this->assertEquals($course, $event->get_record_snapshot('course', $course->id));
+ $this->assertEquals('course_deleted', $event->get_legacy_eventname());
+ // The legacy data also passed the context in the course object.
+ $course->context = $coursecontext;
+ $this->assertEventLegacyData($course, $event);
+ $expectedlog = array(SITEID, 'course', 'delete', 'view.php?id=' . $course->id, $course->fullname . '(ID ' . $course->id . ')');
+ $this->assertEventLegacyLogData($expectedlog, $event);
+ }
+
+ /**
+ * Test that triggering a course_content_deleted event works as expected.
+ */
+ public function test_course_content_deleted_event() {
+ global $DB;
+
+ $this->resetAfterTest();
+
+ // Create the course.
+ $course = $this->getDataGenerator()->create_course();
+
+ // Get the course from the DB. The data generator adds some extra properties, such as
+ // numsections, to the course object which will fail the assertions later on.
+ $course = $DB->get_record('course', array('id' => $course->id), '*', MUST_EXIST);
+
+ // Save the course context before we delete the course.
+ $coursecontext = context_course::instance($course->id);
+
+ // Catch the update event.
+ $sink = $this->redirectEvents();
+
+ // Call remove_course_contents() which will trigger the course_content_deleted event.
+ // This function prints out data to the screen, which we do not want during a PHPUnit
+ // test, so use ob_start and ob_end_clean to prevent this.
+ ob_start();
+ remove_course_contents($course->id);
+ ob_end_clean();
+
+ // Capture the event.
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\course_content_deleted', $event);
+ $this->assertEquals('course', $event->objecttable);
+ $this->assertEquals($course->id, $event->objectid);
+ $this->assertEquals($coursecontext->id, $event->contextid);
+ $this->assertEquals($course, $event->get_record_snapshot('course', $course->id));
+ $this->assertEquals('course_content_removed', $event->get_legacy_eventname());
+ // The legacy data also passed the context and options in the course object.
+ $course->context = $coursecontext;
+ $course->options = array();
+ $this->assertEventLegacyData($course, $event);
+ }
+
+ /**
+ * Test that triggering a course_category_deleted event works as expected.
+ */
+ public function test_course_category_deleted_event() {
+ $this->resetAfterTest();
+
+ // Create a category.
+ $category = $this->getDataGenerator()->create_category();
+
+ // Save the context before it is deleted.
+ $categorycontext = context_coursecat::instance($category->id);
+
+ // Catch the update event.
+ $sink = $this->redirectEvents();
+
+ // Delete the category.
+ $category->delete_full();
+
+ // Capture the event.
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\course_category_deleted', $event);
+ $this->assertEquals('course_categories', $event->objecttable);
+ $this->assertEquals($category->id, $event->objectid);
+ $this->assertEquals($categorycontext->id, $event->contextid);
+ $this->assertEquals('course_category_deleted', $event->get_legacy_eventname());
+ $this->assertEventLegacyData($category, $event);
+ $expectedlog = array(SITEID, 'category', 'delete', 'index.php', $category->name . '(ID ' . $category->id . ')');
+ $this->assertEventLegacyLogData($expectedlog, $event);
+
+ // Create two categories.
+ $category = $this->getDataGenerator()->create_category();
+ $category2 = $this->getDataGenerator()->create_category();
+
+ // Save the context before it is moved and then deleted.
+ $category2context = context_coursecat::instance($category2->id);
+
+ // Catch the update event.
+ $sink = $this->redirectEvents();
+
+ // Move the category.
+ $category2->delete_move($category->id);
+
+ // Capture the event.
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\course_category_deleted', $event);
+ $this->assertEquals('course_categories', $event->objecttable);
+ $this->assertEquals($category2->id, $event->objectid);
+ $this->assertEquals($category2context->id, $event->contextid);
+ $this->assertEquals('course_category_deleted', $event->get_legacy_eventname());
+ $this->assertEventLegacyData($category2, $event);
+ $expectedlog = array(SITEID, 'category', 'delete', 'index.php', $category2->name . '(ID ' . $category2->id . ')');
+ $this->assertEventLegacyLogData($expectedlog, $event);
+ }
+
+ /**
+ * Test that triggering a course_restored event works as expected.
+ */
+ public function test_course_restored_event() {
+ global $CFG;
+
+ // Get the necessary files to perform backup and restore.
+ require_once($CFG->dirroot . '/backup/util/includes/backup_includes.php');
+ require_once($CFG->dirroot . '/backup/util/includes/restore_includes.php');
+
+ $this->resetAfterTest();
+
+ // Set to admin user.
+ $this->setAdminUser();
+
+ // The user id is going to be 2 since we are the admin user.
+ $userid = 2;
+
+ // Create a course.
+ $course = $this->getDataGenerator()->create_course();
+
+ // Create backup file and save it to the backup location.
+ $bc = new backup_controller(backup::TYPE_1COURSE, $course->id, backup::FORMAT_MOODLE,
+ backup::INTERACTIVE_NO, backup::MODE_GENERAL, $userid);
+ $bc->execute_plan();
+ $results = $bc->get_results();
+ $file = $results['backup_destination'];
+ $fp = get_file_packer();
+ $filepath = $CFG->dataroot . '/temp/backup/test-restore-course-event';
+ $file->extract_to_pathname($fp, $filepath);
+ $bc->destroy();
+ unset($bc);
+
+ // Now we want to catch the restore course event.
+ $sink = $this->redirectEvents();
+
+ // Now restore the course to trigger the event.
+ $rc = new restore_controller('test-restore-course-event', $course->id, backup::INTERACTIVE_NO,
+ backup::MODE_GENERAL, $userid, backup::TARGET_NEW_COURSE);
+ $rc->execute_precheck();
+ $rc->execute_plan();
+
+ // Capture the event.
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\course_restored', $event);
+ $this->assertEquals('course', $event->objecttable);
+ $this->assertEquals($rc->get_courseid(), $event->objectid);
+ $this->assertEquals(context_course::instance($rc->get_courseid())->id, $event->contextid);
+ $this->assertEquals('course_restored', $event->get_legacy_eventname());
+ $legacydata = (object) array(
+ 'courseid' => $rc->get_courseid(),
+ 'userid' => $rc->get_userid(),
+ 'type' => $rc->get_type(),
+ 'target' => $rc->get_target(),
+ 'mode' => $rc->get_mode(),
+ 'operation' => $rc->get_operation(),
+ 'samesite' => $rc->is_samesite()
+ );
+ $this->assertEventLegacyData($legacydata, $event);
+
+ // Destroy the resource controller since we are done using it.
+ $rc->destroy();
+ unset($rc);
+
+ // Clear the time limit, otherwise PHPUnit complains.
+ set_time_limit(0);
+ }
+
+ /**
+ * Test that triggering a course_section_updated event works as expected.
+ */
+ public function test_course_section_updated_event() {
+ global $DB;
+
+ $this->resetAfterTest();
+
+ // Create the course with sections.
+ $course = $this->getDataGenerator()->create_course(array('numsections' => 10), array('createsections' => true));
+ $sections = $DB->get_records('course_sections', array('course' => $course->id));
+
+ $coursecontext = context_course::instance($course->id);
+
+ $section = array_pop($sections);
+ $section->name = 'Test section';
+ $section->summary = 'Test section summary';
+ $DB->update_record('course_sections', $section);
+
+ // Trigger an event for course section update.
+ $event = \core\event\course_section_updated::create(
+ array(
+ 'objectid' => $section->id,
+ 'courseid' => $course->id,
+ 'context' => context_course::instance($course->id)
+ )
+ );
+ $event->add_record_snapshot('course_sections', $section);
+ // Trigger and catch event.
+ $sink = $this->redirectEvents();
+ $event->trigger();
+ $events = $sink->get_events();
+ $sink->close();
+
+ // Validate the event.
+ $event = $events[0];
+ $this->assertInstanceOf('\core\event\course_section_updated', $event);
+ $this->assertEquals('course_sections', $event->objecttable);
+ $this->assertEquals($section->id, $event->objectid);
+ $this->assertEquals($course->id, $event->courseid);
+ $this->assertEquals($coursecontext->id, $event->contextid);
+ $expecteddesc = 'Course ' . $event->courseid . ' section ' . $event->other['sectionnum'] . ' updated by user ' . $event->userid;
+ $this->assertEquals($expecteddesc, $event->get_description());
+ $this->assertEquals($section, $event->get_record_snapshot('course_sections', $event->objectid));
+ $id = $section->id;
+ $sectionnum = $section->section;
+ $expectedlegacydata = array($course->id, "course", "editsection", 'editsection.php?id=' . $id, $sectionnum);
+ $this->assertEventLegacyLogData($expectedlegacydata, $event);
+ }
}
resources.addClass(CSS.SECTION);
sectionnode.one('.'+CSS.CONTENT+' div.'+CSS.SUMMARY).insert(resources, 'after');
}
+ resources.setAttribute('data-draggroups', this.groups.join(' '));
// Define empty ul as droptarget, so that item could be moved to empty list
var tar = new Y.DD.Drop({
node: resources,
}
$roleid = $rolemap[$fields[1]];
- if (empty($fields[2]) or !$user = $DB->get_record("user", array("idnumber"=>$fields[2]))) {
- $trace->output("Unknown user idnumber in field 3 - ignoring line $line", 1);
+ if (empty($fields[2]) or !$user = $DB->get_record("user", array("idnumber"=>$fields[2], 'deleted'=>0))) {
+ $trace->output("Unknown user idnumber or deleted user in field 3 - ignoring line $line", 1);
continue;
}
require_once("$CFG->libdir/clilib.php");
// Ensure errors are well explained.
-$CFG->debug = DEBUG_DEVELOPER;
+set_debugging(DEBUG_DEVELOPER, true);
if (!enrol_is_enabled('ldap')) {
cli_error(get_string('pluginnotenabled', 'enrol_ldap'), 2);
$this->assertTrue(enrol_user_sees_own_courses());
$this->assertEquals($reads, $DB->perf_get_reads());
}
+
+ public function test_enrol_get_shared_courses() {
+ $this->resetAfterTest();
+
+ $user1 = $this->getDataGenerator()->create_user();
+ $user2 = $this->getDataGenerator()->create_user();
+ $user3 = $this->getDataGenerator()->create_user();
+
+ $course1 = $this->getDataGenerator()->create_course();
+ $this->getDataGenerator()->enrol_user($user1->id, $course1->id);
+ $this->getDataGenerator()->enrol_user($user2->id, $course1->id);
+
+ $course2 = $this->getDataGenerator()->create_course();
+ $this->getDataGenerator()->enrol_user($user1->id, $course2->id);
+
+ // Test that user1 and user2 have courses in common.
+ $this->assertTrue(enrol_get_shared_courses($user1, $user2, false, true));
+ // Test that user1 and user3 have no courses in common.
+ $this->assertFalse(enrol_get_shared_courses($user1, $user3, false, true));
+
+ // Test retrieving the courses in common.
+ $sharedcourses = enrol_get_shared_courses($user1, $user2, true);
+
+ // Only should be one shared course.
+ $this->assertCount(1, $sharedcourses);
+ $sharedcourse = array_shift($sharedcourses);
+ // It should be course 1.
+ $this->assertEquals($sharedcourse->id, $course1->id);
+ }
}
.enrolpanel .container .header h2 {font-size:90%;text-align:center;margin:5px;}
.enrolpanel .container .header .close {width:25px;height:15px;position:absolute;top:5px;right:1em;cursor:pointer;background:url("sprite.png") no-repeat scroll 0 0 transparent;}
.enrolpanel .container .content {}
-.enrolpanel .container .content input {margin:5px;font-size:10px;}
\ No newline at end of file
+.enrolpanel .container .content input {margin:5px;font-size:10px;}
+.enrolpanel.roleassign.visible .container {width:auto;}
var roles = this.user.get(CONTAINER).one('.col_role .roles');
var x = roles.getX() + 10;
var y = roles.getY() + this.user.get(CONTAINER).get('offsetHeight') - 10;
- this.get('elementNode').setStyle('left', x).setStyle('top', y);
+ if ( Y.one(document.body).hasClass('dir-rtl') ) {
+ this.get('elementNode').setStyle('right', x - 20).setStyle('top', y);
+ } else {
+ this.get('elementNode').setStyle('left', x).setStyle('top', y);
+ }
this.get('elementNode').addClass('visible');
this.escCloseEvent = Y.on('key', this.hide, document.body, 'down:27', this);
this.displayed = true;
public static function get_files_parameters() {
return new external_function_parameters(
array(
- 'contextid' => new external_value(PARAM_INT, 'context id'),
- 'component' => new external_value(PARAM_TEXT, 'component'),
- 'filearea' => new external_value(PARAM_TEXT, 'file area'),
- 'itemid' => new external_value(PARAM_INT, 'associated id'),
- 'filepath' => new external_value(PARAM_PATH, 'file path'),
- 'filename' => new external_value(PARAM_FILE, 'file name'),
- 'modified' => new external_value(PARAM_INT, 'timestamp to return files changed after this time.', VALUE_DEFAULT, null)
+ 'contextid' => new external_value(PARAM_INT, 'context id Set to -1 to use contextlevel and instanceid.'),
+ 'component' => new external_value(PARAM_TEXT, 'component'),
+ 'filearea' => new external_value(PARAM_TEXT, 'file area'),
+ 'itemid' => new external_value(PARAM_INT, 'associated id'),
+ 'filepath' => new external_value(PARAM_PATH, 'file path'),
+ 'filename' => new external_value(PARAM_FILE, 'file name'),
+ 'modified' => new external_value(PARAM_INT, 'timestamp to return files changed after this time.', VALUE_DEFAULT, null),
+ 'contextlevel' => new external_value(PARAM_ALPHA, 'The context level for the file location.', VALUE_DEFAULT, null),
+ 'instanceid' => new external_value(PARAM_INT, 'The instance id for where the file is located.', VALUE_DEFAULT, null)
+
)
);
}
* @param string $filepath file path
* @param string $filename file name
* @param int $modified timestamp to return files changed after this time.
+ * @param string $contextlevel The context level for the file location.
+ * @param int $instanceid The instance id for where the file is located.
* @return array
* @since Moodle 2.2
*/
- public static function get_files($contextid, $component, $filearea, $itemid, $filepath, $filename, $modified = null) {
- global $CFG, $USER, $OUTPUT;
- $fileinfo = self::validate_parameters(self::get_files_parameters(), array(
- 'contextid'=>$contextid, 'component'=>$component, 'filearea'=>$filearea,
- 'itemid'=>$itemid, 'filepath'=>$filepath, 'filename'=>$filename, 'modified'=>$modified));
+ public static function get_files($contextid, $component, $filearea, $itemid, $filepath, $filename, $modified = null,
+ $contextlevel = null, $instanceid = null) {
+
+ $parameters = array(
+ 'contextid' => $contextid,
+ 'component' => $component,
+ 'filearea' => $filearea,
+ 'itemid' => $itemid,
+ 'filepath' => $filepath,
+ 'filename' => $filename,
+ 'modified' => $modified,
+ 'contextlevel' => $contextlevel,
+ 'instanceid' => $instanceid);
+ $fileinfo = self::validate_parameters(self::get_files_parameters(), $parameters);
$browser = get_file_browser();
- if (empty($fileinfo['contextid'])) {
- $context = context_system::instance();
+ // We need to preserve backwards compatibility. Zero will use the system context and minus one will
+ // use the addtional parameters to determine the context.
+ // TODO MDL-40489 get_context_from_params should handle this logic.
+ if ($fileinfo['contextid'] == 0) {
+ $context = context_system::instance();
} else {
- $context = context::instance_by_id($fileinfo['contextid']);
+ if ($fileinfo['contextid'] == -1) {
+ $fileinfo['contextid'] = null;
+ }
+ $context = self::get_context_from_params($fileinfo);
}
+ self::validate_context($context);
+
if (empty($fileinfo['component'])) {
$fileinfo['component'] = null;
}
$return['parents'] = array();
$return['files'] = array();
$list = array();
+
if ($file = $browser->get_file_info(
$context, $fileinfo['component'], $fileinfo['filearea'], $fileinfo['itemid'],
$fileinfo['filepath'], $fileinfo['filename'])) {
$file = $browser->get_file_info($context, $component, $filearea, $itemid, $filepath, $filename);
$this->assertNotEmpty($file);
}
+
+ public function test_get_files() {
+ global $USER, $DB;
+
+ $this->resetAfterTest();
+
+ $this->setAdminUser();
+ $USER->email = 'test@moodle.com';
+
+ $course = $this->getDataGenerator()->create_course();
+ $record = new stdClass();
+ $record->course = $course->id;
+ $record->name = "Mod data upload test";
+
+ $record->intro = "Some intro of some sort";
+
+ $module = $this->getDataGenerator()->create_module('data', $record);
+
+ $field = data_get_field_new('file', $module);
+
+ $fielddetail = new stdClass();
+ $fielddetail->d = $module->id;
+ $fielddetail->mode = 'add';
+ $fielddetail->type = 'file';
+ $fielddetail->sesskey = sesskey();
+ $fielddetail->name = 'Upload file';
+ $fielddetail->description = 'Some description';
+ $fielddetail->param3 = '0';
+
+ $field->define_field($fielddetail);
+ $field->insert_field();
+ $recordid = data_add_record($module);
+
+ $timemodified = $DB->get_field('data_records', 'timemodified', array('id' => $recordid));
+
+ $datacontent = array();
+ $datacontent['fieldid'] = $field->field->id;
+ $datacontent['recordid'] = $recordid;
+ $datacontent['content'] = 'Simple4.txt';
+
+ $contentid = $DB->insert_record('data_content', $datacontent);
+
+ $context = context_module::instance($module->id);
+ $usercontext = context_user::instance($USER->id);
+ $component = 'mod_data';
+ $filearea = 'content';
+ $itemid = $contentid;
+ $filename = $datacontent['content'];
+ $filecontent = base64_encode("Let us create a nice simple file.");
+
+ $filerecord = array();
+ $filerecord['contextid'] = $context->id;
+ $filerecord['component'] = $component;
+ $filerecord['filearea'] = $filearea;
+ $filerecord['itemid'] = $itemid;
+ $filerecord['filepath'] = '/';
+ $filerecord['filename'] = $filename;
+
+ $fs = get_file_storage();
+ $file = $fs->create_file_from_string($filerecord, $filecontent);
+
+ $filename = '';
+ $testfilelisting = core_files_external::get_files($context->id, $component, $filearea, $itemid, '/', $filename);
+
+ $testdata = array();
+ $testdata['parents'] = array();
+ $testdata['parents']['0'] = array('contextid' => 1,
+ 'component' => null,
+ 'filearea' => null,
+ 'itemid' => null,
+ 'filepath' => null,
+ 'filename' => 'System');
+ $testdata['parents']['1'] = array('contextid' => 3,
+ 'component' => null,
+ 'filearea' => null,
+ 'itemid' => null,
+ 'filepath' => null,
+ 'filename' => 'Miscellaneous');
+ $testdata['parents']['2'] = array('contextid' => 15,
+ 'component' => null,
+ 'filearea' => null,
+ 'itemid' => null,
+ 'filepath' => null,
+ 'filename' => 'Test course 1');
+ $testdata['parents']['3'] = array('contextid' => 20,
+ 'component' => null,
+ 'filearea' => null,
+ 'itemid' => null,
+ 'filepath' => null,
+ 'filename' => 'Mod data upload test (Database)');
+ $testdata['parents']['4'] = array('contextid' => 20,
+ 'component' => 'mod_data',
+ 'filearea' => 'content',
+ 'itemid' => null,
+ 'filepath' => null,
+ 'filename' => 'Fields');
+ $testdata['files'] = array();
+ $testdata['files']['0'] = array('contextid' => 20,
+ 'component' => 'mod_data',
+ 'filearea' => 'content',
+ 'itemid' => 1,
+ 'filepath' => '/',
+ 'filename' => 'Simple4.txt',
+ 'url' => 'http://www.example.com/moodle/pluginfile.php/20/mod_data/content/1/Simple4.txt',
+ 'isdir' => null,
+ 'timemodified' => $timemodified);
+
+ $this->assertEquals($testfilelisting, $testdata);
+
+ // Try again but without the context.
+ $nocontext = -1;
+ $modified = 0;
+ $contextlevel = 'module';
+ $instanceid = $module->id;
+ $testfilelisting = core_files_external::get_files($nocontext, $component, $filearea, $itemid, '/', $filename, $modified, $contextlevel, $instanceid);
+ $this->assertEquals($testfilelisting, $testdata);
+ }
}
$group = $DB->get_record('groups', array('id'=>$groupid), '*', MUST_EXIST);
}
- //check if the user a participant of the group course
- if (!is_enrolled(context_course::instance($group->courseid), $userid)) {
+ // Check if the user a participant of the group course.
+ $context = context_course::instance($group->courseid);
+ if (!is_enrolled($context, $userid)) {
return false;
}
$DB->insert_record('groups_members', $member);
- //update group info
+ // Update group info, and group object.
$DB->set_field('groups', 'timemodified', $member->timeadded, array('id'=>$groupid));
-
- //trigger groups events
- $eventdata = new stdClass();
- $eventdata->groupid = $groupid;
- $eventdata->userid = $userid;
- $eventdata->component = $member->component;
- $eventdata->itemid = $member->itemid;
- events_trigger('groups_member_added', $eventdata);
+ $group->timemodified = $member->timeadded;
+
+ // Trigger group event.
+ $params = array(
+ 'context' => $context,
+ 'objectid' => $groupid,
+ 'relateduserid' => $userid,
+ 'other' => array(
+ 'component' => $member->component,
+ 'itemid' => $member->itemid
+ )
+ );
+ $event = \core\event\group_member_added::create($params);
+ $event->add_record_snapshot('groups', $group);
+ $event->trigger();
return true;
}
if (is_object($userorid)) {
$userid = $userorid->id;
- $user = $userorid;
} else {
$userid = $userorid;
- $user = $DB->get_record('user', array('id'=>$userid), '*', MUST_EXIST);
}
if (is_object($grouporid)) {
$DB->delete_records('groups_members', array('groupid'=>$groupid, 'userid'=>$userid));
- //update group info
- $DB->set_field('groups', 'timemodified', time(), array('id'=>$groupid));
-
- //trigger groups events
- $eventdata = new stdClass();
- $eventdata->groupid = $groupid;
- $eventdata->userid = $userid;
- events_trigger('groups_member_removed', $eventdata);
+ // Update group info.
+ $time = time();
+ $DB->set_field('groups', 'timemodified', $time, array('id' => $groupid));
+ $group->timemodified = $time;
+
+ // Trigger group event.
+ $params = array(
+ 'context' => context_course::instance($group->courseid),
+ 'objectid' => $groupid,
+ 'relateduserid' => $userid
+ );
+ $event = \core\event\group_member_removed::create($params);
+ $event->add_record_snapshot('groups', $group);
+ $event->trigger();
return true;
}
// Invalidate the grouping cache for the course
cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($course->id));
- //trigger groups events
- events_trigger('groups_group_created', $group);
+ // Trigger group event.
+ $params = array(
+ 'context' => $context,
+ 'objectid' => $group->id
+ );
+ $event = \core\event\group_created::create($params);
+ $event->add_record_snapshot('groups', $group);
+ $event->trigger();
return $group->id;
}
}
$id = $DB->insert_record('groupings', $data);
-
- //trigger groups events
$data->id = $id;
if ($editoroptions !== null) {
// Invalidate the grouping cache for the course
cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($data->courseid));
- events_trigger('groups_grouping_created', $data);
+ // Trigger group event.
+ $params = array(
+ 'context' => context_course::instance($data->courseid),
+ 'objectid' => $id
+ );
+ $event = \core\event\grouping_created::create($params);
+ $event->set_legacy_eventdata($data);
+ $event->trigger();
return $id;
}
groups_update_group_icon($group, $data, $editform);
}
- //trigger groups events
- events_trigger('groups_group_updated', $group);
-
+ // Trigger group event.
+ $params = array(
+ 'context' => $context,
+ 'objectid' => $group->id
+ );
+ $event = \core\event\group_updated::create($params);
+ $event->add_record_snapshot('groups', $group);
+ $event->trigger();
return true;
}
// Invalidate the group data.
cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($data->courseid));
- //trigger groups events
- events_trigger('groups_grouping_updated', $data);
+ // Trigger group event.
+ $params = array(
+ 'context' => context_course::instance($data->courseid),
+ 'objectid' => $data->id
+ );
+ $event = \core\event\grouping_updated::create($params);
+ $event->set_legacy_eventdata($data);
+ $event->trigger();
return true;
}
// Invalidate the grouping cache for the course
cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($group->courseid));
- //trigger groups events
- events_trigger('groups_group_deleted', $group);
+ // Trigger group event.
+ $params = array(
+ 'context' => $context,
+ 'objectid' => $groupid
+ );
+ $event = \core\event\group_deleted::create($params);
+ $event->add_record_snapshot('groups', $group);
+ $event->trigger();
return true;
}
// Invalidate the grouping cache for the course
cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($grouping->courseid));
- //trigger groups events
- events_trigger('groups_grouping_deleted', $grouping);
+ // Trigger group event.
+ $params = array(
+ 'context' => $context,
+ 'objectid' => $groupingid
+ );
+ $event = \core\event\grouping_deleted::create($params);
+ $event->add_record_snapshot('groupings', $grouping);
+ $event->trigger();
return true;
}
return false;
}
- $params = array('courseid'=>$courseid);
+ // Select * so that the function groups_remove_member() gets the whole record.
+ $groups = $DB->get_recordset('groups', array('courseid' => $courseid));
+ foreach ($groups as $group) {
+ if ($userid) {
+ $userids = array($userid);
+ } else {
+ $userids = $DB->get_fieldset_select('groups_members', 'userid', 'groupid = :groupid', array('groupid' => $group->id));
+ }
- if ($userid) {
- $usersql = "AND userid = :userid";
- $params['userid'] = $userid;
- } else {
- $usersql = "";
+ foreach ($userids as $id) {
+ groups_remove_member($group, $id);
+ }
}
- $groupssql = "SELECT id FROM {groups} g WHERE g.courseid = :courseid";
- $DB->delete_records_select('groups_members', "groupid IN ($groupssql) $usersql", $params);
-
- //trigger groups events
+ // TODO MDL-41312 Remove events_trigger_legacy('groups_members_removed').
+ // This event is kept here for backwards compatibility, because it cannot be
+ // translated to a new event as it is wrong.
$eventdata = new stdClass();
$eventdata->courseid = $courseid;
$eventdata->userid = $userid;
- events_trigger('groups_members_removed', $eventdata);
+ events_trigger_legacy('groups_members_removed', $eventdata);
if ($showfeedback) {
echo $OUTPUT->notification(get_string('deleted').' - '.get_string('groupmembers', 'group'), 'notifysuccess');
global $DB, $OUTPUT;
$groupssql = "SELECT id FROM {groups} g WHERE g.courseid = ?";
- $DB->delete_records_select('groupings_groups', "groupid IN ($groupssql)", array($courseid));
+ $results = $DB->get_recordset_select('groupings_groups', "groupid IN ($groupssql)",
+ array($courseid), '', 'groupid, groupingid');
+
+ foreach ($results as $result) {
+ groups_unassign_grouping($result->groupingid, $result->groupid, false);
+ }
// Invalidate the grouping cache for the course
cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($courseid));
- //trigger groups events
- events_trigger('groups_groupings_groups_removed', $courseid);
+ // TODO MDL-41312 Remove events_trigger_legacy('groups_groupings_groups_removed').
+ // This event is kept here for backwards compatibility, because it cannot be
+ // translated to a new event as it is wrong.
+ events_trigger_legacy('groups_groupings_groups_removed', $courseid);
// no need to show any feedback here - we delete usually first groupings and then groups
function groups_delete_groups($courseid, $showfeedback=false) {
global $CFG, $DB, $OUTPUT;
- // delete any uses of groups
- // Any associated files are deleted as part of groups_delete_groupings_groups
- groups_delete_groupings_groups($courseid, $showfeedback);
- groups_delete_group_members($courseid, 0, $showfeedback);
-
- // delete group pictures and descriptions
- $context = context_course::instance($courseid);
- $fs = get_file_storage();
- $fs->delete_area_files($context->id, 'group');
-
- // delete group calendar events
- $groupssql = "SELECT id FROM {groups} g WHERE g.courseid = ?";
- $DB->delete_records_select('event', "groupid IN ($groupssql)", array($courseid));
-
- $context = context_course::instance($courseid);
- $fs = get_file_storage();
- $fs->delete_area_files($context->id, 'group');
-
- $DB->delete_records('groups', array('courseid'=>$courseid));
+ $groups = $DB->get_recordset('groups', array('courseid' => $courseid));
+ foreach ($groups as $group) {
+ groups_delete_group($group);
+ }
// Invalidate the grouping cache for the course
cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($courseid));
- // trigger groups events
- events_trigger('groups_groups_deleted', $courseid);
+ // TODO MDL-41312 Remove events_trigger_legacy('groups_groups_deleted').
+ // This event is kept here for backwards compatibility, because it cannot be
+ // translated to a new event as it is wrong.
+ events_trigger_legacy('groups_groups_deleted', $courseid);
if ($showfeedback) {
echo $OUTPUT->notification(get_string('deleted').' - '.get_string('groups', 'group'), 'notifysuccess');
function groups_delete_groupings($courseid, $showfeedback=false) {
global $DB, $OUTPUT;
- // delete any uses of groupings
- $sql = "DELETE FROM {groupings_groups}
- WHERE groupingid in (SELECT id FROM {groupings} g WHERE g.courseid = ?)";
- $DB->execute($sql, array($courseid));
-
- // remove the default groupingid from course
- $DB->set_field('course', 'defaultgroupingid', 0, array('id'=>$courseid));
- // remove the groupingid from all course modules
- $DB->set_field('course_modules', 'groupingid', 0, array('course'=>$courseid));
-
- // Delete all files associated with groupings for this course
- $context = context_course::instance($courseid);
- $fs = get_file_storage();
- $fs->delete_area_files($context->id, 'grouping');
-
- $DB->delete_records('groupings', array('courseid'=>$courseid));
+ $groupings = $DB->get_recordset_select('groupings', 'courseid = ?', array($courseid));
+ foreach ($groupings as $grouping) {
+ groups_delete_grouping($grouping);
+ }
- // Invalidate the grouping cache for the course
+ // Invalidate the grouping cache for the course.
cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($courseid));
- // trigger groups events
- events_trigger('groups_groupings_deleted', $courseid);
+ // TODO MDL-41312 Remove events_trigger_legacy('groups_groupings_deleted').
+ // This event is kept here for backwards compatibility, because it cannot be
+ // translated to a new event as it is wrong.
+ events_trigger_legacy('groups_groupings_deleted', $courseid);
if ($showfeedback) {
echo $OUTPUT->notification(get_string('deleted').' - '.get_string('groupings', 'group'), 'notifysuccess');
--- /dev/null
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Unit tests for group lib.
+ *
+ * @package core_group
+ * @copyright 2013 Frédéric Massart
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+
+global $CFG;
+require_once($CFG->dirroot . '/group/lib.php');
+
+/**
+ * Group lib testcase.
+ *
+ * @package core_group
+ * @copyright 2013 Frédéric Massart
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class core_group_lib_testcase extends advanced_testcase {
+
+ public function test_member_added_event() {
+ $this->resetAfterTest();
+
+ $this->setAdminUser();
+ $course = $this->getDataGenerator()->create_course();
+ $user = $this->getDataGenerator()->create_user();
+ $group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+ $this->getDataGenerator()->enrol_user($user->id, $course->id);
+
+ $sink = $this->redirectEvents();
+ groups_add_member($group->id, $user->id, 'mod_workshop', '123');
+ $events = $sink->get_events();
+ $this->assertCount(1, $events);
+ $event = reset($events);
+
+ $expected = new stdClass();
+ $expected->groupid = $group->id;
+ $expected->userid = $user->id;
+ $expected->component = 'mod_workshop';
+ $expected->itemid = '123';
+ $this->assertEventLegacyData($expected, $event);
+ $this->assertSame('groups_member_added', $event->get_legacy_eventname());
+ $this->assertInstanceOf('\core\event\group_member_added', $event);
+ $this->assertEquals($user->id, $event->relateduserid);
+ $this->assertEquals(context_course::instance($course->id), $event->get_context());
+ $this->assertEquals($group->id, $event->objectid);
+ }
+
+ public function test_member_removed_event() {
+ $this->resetAfterTest();
+
+ $this->setAdminUser();
+ $course = $this->getDataGenerator()->create_course();
+ $user = $this->getDataGenerator()->create_user();
+ $group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+ $this->getDataGenerator()->enrol_user($user->id, $course->id);
+ $this->getDataGenerator()->create_group_member(array('userid' => $user->id, 'groupid' => $group->id));
+
+ $sink = $this->redirectEvents();
+ groups_remove_member($group->id, $user->id);
+ $events = $sink->get_events();
+ $this->assertCount(1, $events);
+ $event = reset($events);
+
+ $expected = new stdClass();
+ $expected->groupid = $group->id;
+ $expected->userid = $user->id;
+ $this->assertEventLegacyData($expected, $event);
+ $this->assertSame('groups_member_removed', $event->get_legacy_eventname());
+ $this->assertInstanceOf('\core\event\group_member_removed', $event);
+ $this->assertEquals($user->id, $event->relateduserid);
+ $this->assertEquals(context_course::instance($course->id), $event->get_context());
+ $this->assertEquals($group->id, $event->objectid);
+ }
+
+ public function test_group_created_event() {
+ $this->resetAfterTest();
+
+ $this->setAdminUser();
+ $course = $this->getDataGenerator()->create_course();
+
+ $sink = $this->redirectEvents();
+ $group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+ $events = $sink->get_events();
+ $this->assertCount(1, $events);
+ $event = reset($events);
+
+ $this->assertInstanceOf('\core\event\group_created', $event);
+ $this->assertEventLegacyData($group, $event);
+ $this->assertSame('groups_group_created', $event->get_legacy_eventname());
+ $this->assertEquals(context_course::instance($course->id), $event->get_context());
+ $this->assertEquals($group->id, $event->objectid);
+ }
+
+ public function test_grouping_created_event() {
+ $this->resetAfterTest();
+
+ $this->setAdminUser();
+ $course = $this->getDataGenerator()->create_course();
+
+ $sink = $this->redirectEvents();
+ $group = $this->getDataGenerator()->create_grouping(array('courseid' => $course->id));
+ $events = $sink->get_events();
+ $this->assertCount(1, $events);
+ $event = reset($events);
+
+ $this->assertInstanceOf('\core\event\grouping_created', $event);
+
+ // 'Repairing' the object for comparison because of type of variables being wrong.
+ $group->id = (int) $group->id;
+ $group->timemodified = (int) $group->timemodified;
+ $group->timecreated = (int) $group->timecreated;
+ unset($group->idnumber);
+ unset($group->configdata);
+ $this->assertEventLegacyData($group, $event);
+ $this->assertSame('groups_grouping_created', $event->get_legacy_eventname());
+
+ $this->assertEquals(context_course::instance($course->id), $event->get_context());
+ $this->assertEquals($group->id, $event->objectid);
+ }
+
+ public function test_group_updated_event() {
+ $this->resetAfterTest();
+
+ $course = $this->getDataGenerator()->create_course();
+ $group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+
+ $sink = $this->redirectEvents();
+ $data = new stdClass();
+ $data->id = $group->id;
+ $data->courseid = $course->id;
+ $data->name = 'Backend team';
+ groups_update_group($data);
+ $events = $sink->get_events();
+ $this->assertCount(1, $events);
+ $event = reset($events);
+
+ $this->assertInstanceOf('\core\event\group_updated', $event);
+ $group->name = $data->name;
+ $this->assertEventLegacyData($group, $event);
+ $this->assertSame('groups_group_updated', $event->get_legacy_eventname());
+ $this->assertEquals(context_course::instance($course->id), $event->get_context());
+ $this->assertEquals($group->id, $event->objectid);
+ }
+
+ public function test_grouping_updated_event() {
+ $this->resetAfterTest();
+
+ $course = $this->getDataGenerator()->create_course();
+ $group = $this->getDataGenerator()->create_grouping(array('courseid' => $course->id));
+
+ $sink = $this->redirectEvents();
+ $data = new stdClass();
+ $data->id = $group->id;
+ $data->courseid = $course->id;
+ $data->name = 'Backend team';
+ $mostaccuratetimemodified = time();
+ groups_update_grouping($data);
+ $events = $sink->get_events();
+ $this->assertCount(1, $events);
+ $event = reset($events);
+
+ $this->assertInstanceOf('\core\event\grouping_updated', $event);
+
+ // 'Repairing' the object for comparison because of type of variables being wrong.
+ $data->id = (int) $group->id;
+ $data->timemodified = $mostaccuratetimemodified;
+ $this->assertEventLegacyData($data, $event);
+ $this->assertSame('groups_grouping_updated', $event->get_legacy_eventname());
+
+ $this->assertEquals(context_course::instance($course->id), $event->get_context());
+ $this->assertEquals($group->id, $event->objectid);
+ }
+
+ public function test_group_deleted_event() {
+ $this->resetAfterTest();
+
+ $course = $this->getDataGenerator()->create_course();
+ $group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+
+ $sink = $this->redirectEvents();
+ groups_delete_group($group->id);
+ $events = $sink->get_events();
+ $this->assertCount(1, $events);
+ $event = reset($events);
+
+ $this->assertInstanceOf('\core\event\group_deleted', $event);
+ $this->assertEventLegacyData($group, $event);
+ $this->assertSame('groups_group_deleted', $event->get_legacy_eventname());
+ $this->assertEquals(context_course::instance($course->id), $event->get_context());
+ $this->assertEquals($group->id, $event->objectid);
+ }
+
+ public function test_grouping_deleted_event() {
+ $this->resetAfterTest();
+
+ $course = $this->getDataGenerator()->create_course();
+ $group = $this->getDataGenerator()->create_grouping(array('courseid' => $course->id));
+
+ $sink = $this->redirectEvents();
+ groups_delete_grouping($group->id);
+ $events = $sink->get_events();
+ $this->assertCount(1, $events);
+ $event = reset($events);
+
+ $this->assertInstanceOf('\core\event\grouping_deleted', $event);
+ $this->assertEventLegacyData($group, $event);
+ $this->assertSame('groups_grouping_deleted', $event->get_legacy_eventname());
+ $this->assertEquals(context_course::instance($course->id), $event->get_context());
+ $this->assertEquals($group->id, $event->objectid);
+ }
+
+ public function test_groups_delete_group_members() {
+ global $DB;
+ $this->resetAfterTest();
+
+ $course = $this->getDataGenerator()->create_course();
+ $user1 = $this->getDataGenerator()->create_user();
+ $user2 = $this->getDataGenerator()->create_user();
+ $this->getDataGenerator()->enrol_user($user1->id, $course->id);
+ $this->getDataGenerator()->enrol_user($user2->id, $course->id);
+ $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+ $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+
+ // Test deletion of all the users.
+ $this->getDataGenerator()->create_group_member(array('groupid' => $group1->id, 'userid' => $user1->id));
+ $this->getDataGenerator()->create_group_member(array('groupid' => $group2->id, 'userid' => $user1->id));
+ $this->getDataGenerator()->create_group_member(array('groupid' => $group1->id, 'userid' => $user2->id));
+
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user1->id)));
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group2->id, 'userid' => $user1->id)));
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user2->id)));
+ groups_delete_group_members($course->id);
+ $this->assertFalse($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user1->id)));
+ $this->assertFalse($DB->record_exists('groups_members', array('groupid' => $group2->id, 'userid' => $user1->id)));
+ $this->assertFalse($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user2->id)));
+
+ // Test deletion of a specific user.
+ $this->getDataGenerator()->create_group_member(array('groupid' => $group1->id, 'userid' => $user1->id));
+ $this->getDataGenerator()->create_group_member(array('groupid' => $group2->id, 'userid' => $user1->id));
+ $this->getDataGenerator()->create_group_member(array('groupid' => $group1->id, 'userid' => $user2->id));
+
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user1->id)));
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group2->id, 'userid' => $user1->id)));
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user2->id)));
+ groups_delete_group_members($course->id, $user2->id);
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user1->id)));
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group2->id, 'userid' => $user1->id)));
+ $this->assertFalse($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user2->id)));
+ }
+
+ public function test_groups_remove_member() {
+ global $DB;
+ $this->resetAfterTest();
+
+ $course = $this->getDataGenerator()->create_course();
+ $user1 = $this->getDataGenerator()->create_user();
+ $user2 = $this->getDataGenerator()->create_user();
+ $this->getDataGenerator()->enrol_user($user1->id, $course->id);
+ $this->getDataGenerator()->enrol_user($user2->id, $course->id);
+ $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+ $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+
+ $this->getDataGenerator()->create_group_member(array('groupid' => $group1->id, 'userid' => $user1->id));
+ $this->getDataGenerator()->create_group_member(array('groupid' => $group2->id, 'userid' => $user1->id));
+ $this->getDataGenerator()->create_group_member(array('groupid' => $group1->id, 'userid' => $user2->id));
+
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user1->id)));
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group2->id, 'userid' => $user1->id)));
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user2->id)));
+ groups_remove_member($group1->id, $user1->id);
+ $this->assertFalse($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user1->id)));
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group2->id, 'userid' => $user1->id)));
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user2->id)));
+ groups_remove_member($group1->id, $user2->id);
+ $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $group2->id, 'userid' => $user1->id)));
+ $this->assertFalse($DB->record_exists('groups_members', array('groupid' => $group1->id, 'userid' => $user2->id)));
+ groups_remove_member($group2->id, $user1->id);
+ $this->assertFalse($DB->record_exists('groups_members', array('groupid' => $group2->id, 'userid' => $user1->id)));
+ }
+
+ public function test_groups_delete_groupings_groups() {
+ global $DB;
+ $this->resetAfterTest();
+
+ $course = $this->getDataGenerator()->create_course();
+ $course2 = $this->getDataGenerator()->create_course();
+ $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+ $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
+ $group1c2 = $this->getDataGenerator()->create_group(array('courseid' => $course2->id));
+ $grouping1 = $this->getDataGenerator()->create_grouping(array('courseid' => $course->id));
+ $grouping2 = $this->getDataGenerator()->create_grouping(array('courseid' => $course->id));
+ $grouping1c2 = $this->getDataGenerator()->create_grouping(array('courseid' =>
