MDL-40517 deprecatedlib: remove functions
[moodle.git] / lib / deprecatedlib.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * deprecatedlib.php - Old functions retained only for backward compatibility
20  *
21  * Old functions retained only for backward compatibility.  New code should not
22  * use any of these functions.
23  *
24  * @package    core
25  * @subpackage deprecated
26  * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
27  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
28  * @deprecated
29  */
31 defined('MOODLE_INTERNAL') || die();
33 /**
34  * Factory method that was returning moodle_session object.
35  *
36  * @deprecated since 2.6
37  * @return \core\session\manager
38  */
39 function session_get_instance() {
40     // Note: the new session manager includes all methods from the original session class.
41     static $deprecatedinstance = null;
43     debugging('session_get_instance() is deprecated, use \core\session\manager instead', DEBUG_DEVELOPER);
45     if (!$deprecatedinstance) {
46         $deprecatedinstance = new \core\session\manager();
47     }
49     return $deprecatedinstance;
50 }
52 /**
53  * Returns true if legacy session used.
54  *
55  * @deprecated since 2.6
56  * @return bool
57  */
58 function session_is_legacy() {
59     debugging('session_is_legacy() is deprecated, do not use any more', DEBUG_DEVELOPER);
60     return false;
61 }
63 /**
64  * Terminates all sessions, auth hooks are not executed.
65  * Useful in upgrade scripts.
66  *
67  * @deprecated since 2.6
68  */
69 function session_kill_all() {
70     debugging('session_kill_all() is deprecated, use \core\session\manager::kill_all_sessions() instead', DEBUG_DEVELOPER);
71     \core\session\manager::kill_all_sessions();
72 }
74 /**
75  * Mark session as accessed, prevents timeouts.
76  *
77  * @deprecated since 2.6
78  * @param string $sid
79  */
80 function session_touch($sid) {
81     debugging('session_touch() is deprecated, use \core\session\manager::touch_session() instead', DEBUG_DEVELOPER);
82     \core\session\manager::touch_session($sid);
83 }
85 /**
86  * Terminates one sessions, auth hooks are not executed.
87  *
88  * @deprecated since 2.6
89  * @param string $sid session id
90  */
91 function session_kill($sid) {
92     debugging('session_kill() is deprecated, use \core\session\manager::kill_session() instead', DEBUG_DEVELOPER);
93     \core\session\manager::kill_session($sid);
94 }
96 /**
97  * Terminates all sessions of one user, auth hooks are not executed.
98  * NOTE: This can not work for file based sessions!
99  *
100  * @deprecated since 2.6
101  * @param int $userid user id
102  */
103 function session_kill_user($userid) {
104     debugging('session_kill_user() is deprecated, use \core\session\manager::kill_user_sessions() instead', DEBUG_DEVELOPER);
105     \core\session\manager::kill_user_sessions($userid);
108 /**
109  * Session garbage collection
110  * - verify timeout for all users
111  * - kill sessions of all deleted users
112  * - kill sessions of users with disabled plugins or 'nologin' plugin
113  *
114  * @deprecated since 2.6
115  */
116 function session_gc() {
117     debugging('session_gc() is deprecated, use \core\session\manager::gc() instead', DEBUG_DEVELOPER);
118     \core\session\manager::gc();
121 /**
122  * Setup $USER object - called during login, loginas, etc.
123  *
124  * Call sync_user_enrolments() manually after log-in, or log-in-as.
125  *
126  * @deprecated since 2.6
127  * @param stdClass $user full user record object
128  * @return void
129  */
130 function session_set_user($user) {
131     debugging('session_set_user() is deprecated, use \core\session\manager::set_user() instead', DEBUG_DEVELOPER);
132     \core\session\manager::set_user($user);
135 /**
136  * Is current $USER logged-in-as somebody else?
137  * @deprecated since 2.6
138  * @return bool
139  */
140 function session_is_loggedinas() {
141     debugging('session_is_loggedinas() is deprecated, use \core\session\manager::is_loggedinas() instead', DEBUG_DEVELOPER);
142     return \core\session\manager::is_loggedinas();
145 /**
146  * Returns the $USER object ignoring current login-as session
147  * @deprecated since 2.6
148  * @return stdClass user object
149  */
150 function session_get_realuser() {
151     debugging('session_get_realuser() is deprecated, use \core\session\manager::get_realuser() instead', DEBUG_DEVELOPER);
152     return \core\session\manager::get_realuser();
155 /**
156  * Login as another user - no security checks here.
157  * @deprecated since 2.6
158  * @param int $userid
159  * @param stdClass $context
160  * @return void
161  */
162 function session_loginas($userid, $context) {
163     debugging('session_loginas() is deprecated, use \core\session\manager::loginas() instead', DEBUG_DEVELOPER);
164     \core\session\manager::loginas($userid, $context);
167 /**
168  * Minify JavaScript files.
169  *
170  * @deprecated since 2.6
171  *
172  * @param array $files
173  * @return string
174  */
175 function js_minify($files) {
176     debugging('js_minify() is deprecated, use core_minify::js_files() or core_minify::js() instead.');
177     return core_minify::js_files($files);
180 /**
181  * Minify CSS files.
182  *
183  * @deprecated since 2.6
184  *
185  * @param array $files
186  * @return string
187  */
188 function css_minify_css($files) {
189     debugging('css_minify_css() is deprecated, use core_minify::css_files() or core_minify::css() instead.');
190     return core_minify::css_files($files);
193 /**
194  * Function to call all event handlers when triggering an event
195  *
196  * @deprecated since 2.6
197  *
198  * @param string $eventname name of the event
199  * @param mixed $eventdata event data object
200  * @return int number of failed events
201  */
202 function events_trigger($eventname, $eventdata) {
203     // TODO: uncomment after conversion of all events in standard distribution
204     // debugging('events_trigger() is deprecated, please use new events instead', DEBUG_DEVELOPER);
205     return events_trigger_legacy($eventname, $eventdata);
208 /**
209  * List all core subsystems and their location
210  *
211  * This is a whitelist of components that are part of the core and their
212  * language strings are defined in /lang/en/<<subsystem>>.php. If a given
213  * plugin is not listed here and it does not have proper plugintype prefix,
214  * then it is considered as course activity module.
215  *
216  * The location is optionally dirroot relative path. NULL means there is no special
217  * directory for this subsystem. If the location is set, the subsystem's
218  * renderer.php is expected to be there.
219  *
220  * @deprecated since 2.6, use core_component::get_core_subsystems()
221  *
222  * @param bool $fullpaths false means relative paths from dirroot, use true for performance reasons
223  * @return array of (string)name => (string|null)location
224  */
225 function get_core_subsystems($fullpaths = false) {
226     global $CFG;
228     // NOTE: do not add any other debugging here, keep forever.
230     $subsystems = core_component::get_core_subsystems();
232     if ($fullpaths) {
233         return $subsystems;
234     }
236     debugging('Short paths are deprecated when using get_core_subsystems(), please fix the code to use fullpaths instead.', DEBUG_DEVELOPER);
238     $dlength = strlen($CFG->dirroot);
240     foreach ($subsystems as $k => $v) {
241         if ($v === null) {
242             continue;
243         }
244         $subsystems[$k] = substr($v, $dlength+1);
245     }
247     return $subsystems;
250 /**
251  * Lists all plugin types.
252  *
253  * @deprecated since 2.6, use core_component::get_plugin_types()
254  *
255  * @param bool $fullpaths false means relative paths from dirroot
256  * @return array Array of strings - name=>location
257  */
258 function get_plugin_types($fullpaths = true) {
259     global $CFG;
261     // NOTE: do not add any other debugging here, keep forever.
263     $types = core_component::get_plugin_types();
265     if ($fullpaths) {
266         return $types;
267     }
269     debugging('Short paths are deprecated when using get_plugin_types(), please fix the code to use fullpaths instead.', DEBUG_DEVELOPER);
271     $dlength = strlen($CFG->dirroot);
273     foreach ($types as $k => $v) {
274         if ($k === 'theme') {
275             $types[$k] = 'theme';
276             continue;
277         }
278         $types[$k] = substr($v, $dlength+1);
279     }
281     return $types;
284 /**
285  * Use when listing real plugins of one type.
286  *
287  * @deprecated since 2.6, use core_component::get_plugin_list()
288  *
289  * @param string $plugintype type of plugin
290  * @return array name=>fulllocation pairs of plugins of given type
291  */
292 function get_plugin_list($plugintype) {
294     // NOTE: do not add any other debugging here, keep forever.
296     if ($plugintype === '') {
297         $plugintype = 'mod';
298     }
300     return core_component::get_plugin_list($plugintype);
303 /**
304  * Get a list of all the plugins of a given type that define a certain class
305  * in a certain file. The plugin component names and class names are returned.
306  *
307  * @deprecated since 2.6, use core_component::get_plugin_list_with_class()
308  *
309  * @param string $plugintype the type of plugin, e.g. 'mod' or 'report'.
310  * @param string $class the part of the name of the class after the
311  *      frankenstyle prefix. e.g 'thing' if you are looking for classes with
312  *      names like report_courselist_thing. If you are looking for classes with
313  *      the same name as the plugin name (e.g. qtype_multichoice) then pass ''.
314  * @param string $file the name of file within the plugin that defines the class.
315  * @return array with frankenstyle plugin names as keys (e.g. 'report_courselist', 'mod_forum')
316  *      and the class names as values (e.g. 'report_courselist_thing', 'qtype_multichoice').
317  */
318 function get_plugin_list_with_class($plugintype, $class, $file) {
320     // NOTE: do not add any other debugging here, keep forever.
322     return core_component::get_plugin_list_with_class($plugintype, $class, $file);
325 /**
326  * Returns the exact absolute path to plugin directory.
327  *
328  * @deprecated since 2.6, use core_component::get_plugin_directory()
329  *
330  * @param string $plugintype type of plugin
331  * @param string $name name of the plugin
332  * @return string full path to plugin directory; NULL if not found
333  */
334 function get_plugin_directory($plugintype, $name) {
336     // NOTE: do not add any other debugging here, keep forever.
338     if ($plugintype === '') {
339         $plugintype = 'mod';
340     }
342     return core_component::get_plugin_directory($plugintype, $name);
345 /**
346  * Normalize the component name using the "frankenstyle" names.
347  *
348  * @deprecated since 2.6, use core_component::normalize_component()
349  *
350  * @param string $component
351  * @return array as (string)$type => (string)$plugin
352  */
353 function normalize_component($component) {
355     // NOTE: do not add any other debugging here, keep forever.
357     return core_component::normalize_component($component);
360 /**
361  * Return exact absolute path to a plugin directory.
362  *
363  * @deprecated since 2.6, use core_component::normalize_component()
364  *
365  * @param string $component name such as 'moodle', 'mod_forum'
366  * @return string full path to component directory; NULL if not found
367  */
368 function get_component_directory($component) {
370     // NOTE: do not add any other debugging here, keep forever.
372     return core_component::get_component_directory($component);
376 // === Deprecated before 2.6.0 ===
378 /**
379  * Hack to find out the GD version by parsing phpinfo output
380  *
381  * @return int GD version (1, 2, or 0)
382  */
383 function check_gd_version() {
384     // TODO: delete function in Moodle 2.7
385     debugging('check_gd_version() is deprecated, GD extension is always available now');
387     $gdversion = 0;
389     if (function_exists('gd_info')){
390         $gd_info = gd_info();
391         if (substr_count($gd_info['GD Version'], '2.')) {
392             $gdversion = 2;
393         } else if (substr_count($gd_info['GD Version'], '1.')) {
394             $gdversion = 1;
395         }
397     } else {
398         ob_start();
399         phpinfo(INFO_MODULES);
400         $phpinfo = ob_get_contents();
401         ob_end_clean();
403         $phpinfo = explode("\n", $phpinfo);
406         foreach ($phpinfo as $text) {
407             $parts = explode('</td>', $text);
408             foreach ($parts as $key => $val) {
409                 $parts[$key] = trim(strip_tags($val));
410             }
411             if ($parts[0] == 'GD Version') {
412                 if (substr_count($parts[1], '2.0')) {
413                     $parts[1] = '2.0';
414                 }
415                 $gdversion = intval($parts[1]);
416             }
417         }
418     }
420     return $gdversion;   // 1, 2 or 0
423 /**
424  * Not used any more, the account lockout handling is now
425  * part of authenticate_user_login().
426  * @deprecated
427  */
428 function update_login_count() {
429     // TODO: delete function in Moodle 2.6
430     debugging('update_login_count() is deprecated, all calls need to be removed');
433 /**
434  * Not used any more, replaced by proper account lockout.
435  * @deprecated
436  */
437 function reset_login_count() {
438     // TODO: delete function in Moodle 2.6
439     debugging('reset_login_count() is deprecated, all calls need to be removed');
442 /**
443  * Insert or update log display entry. Entry may already exist.
444  * $module, $action must be unique
445  * @deprecated
446  *
447  * @param string $module
448  * @param string $action
449  * @param string $mtable
450  * @param string $field
451  * @return void
452  *
453  */
454 function update_log_display_entry($module, $action, $mtable, $field) {
455     global $DB;
457     debugging('The update_log_display_entry() is deprecated, please use db/log.php description file instead.');
460 /**
461  * Given some text in HTML format, this function will pass it
462  * through any filters that have been configured for this context.
463  *
464  * @deprecated use the text formatting in a standard way instead (http://docs.moodle.org/dev/Output_functions)
465  *             this was abused mostly for embedding of attachments
466  * @todo final deprecation of this function in MDL-40607
467  * @param string $text The text to be passed through format filters
468  * @param int $courseid The current course.
469  * @return string the filtered string.
470  */
471 function filter_text($text, $courseid = NULL) {
472     global $CFG, $COURSE;
474     debugging('filter_text() is deprecated, use format_text(), format_string() etc instead.', DEBUG_DEVELOPER);
476     if (!$courseid) {
477         $courseid = $COURSE->id;
478     }
480     if (!$context = context_course::instance($courseid, IGNORE_MISSING)) {
481         return $text;
482     }
484     return filter_manager::instance()->filter_text($text, $context);
487 /**
488  * This function indicates that current page requires the https
489  * when $CFG->loginhttps enabled.
490  *
491  * By using this function properly, we can ensure 100% https-ized pages
492  * at our entire discretion (login, forgot_password, change_password)
493  * @deprecated use $PAGE->https_required() instead
494  * @todo final deprecation of this function in MDL-40607
495  */
496 function httpsrequired() {
497     global $PAGE;
498     debugging('httpsrequired() is deprecated use $PAGE->https_required() instead.', DEBUG_DEVELOPER);
499     $PAGE->https_required();
502 /**
503  * Given a physical path to a file, returns the URL through which it can be reached in Moodle.
504  *
505  * @deprecated use moodle_url factory methods instead
506  *
507  * @param string $path Physical path to a file
508  * @param array $options associative array of GET variables to append to the URL
509  * @param string $type (questionfile|rssfile|httpscoursefile|coursefile)
510  * @return string URL to file
511  */
512 function get_file_url($path, $options=null, $type='coursefile') {
513     global $CFG;
515     $path = str_replace('//', '/', $path);
516     $path = trim($path, '/'); // no leading and trailing slashes
518     // type of file
519     switch ($type) {
520        case 'questionfile':
521             $url = $CFG->wwwroot."/question/exportfile.php";
522             break;
523        case 'rssfile':
524             $url = $CFG->wwwroot."/rss/file.php";
525             break;
526         case 'httpscoursefile':
527             $url = $CFG->httpswwwroot."/file.php";
528             break;
529          case 'coursefile':
530         default:
531             $url = $CFG->wwwroot."/file.php";
532     }
534     if ($CFG->slasharguments) {
535         $parts = explode('/', $path);
536         foreach ($parts as $key => $part) {
537         /// anchor dash character should not be encoded
538             $subparts = explode('#', $part);
539             $subparts = array_map('rawurlencode', $subparts);
540             $parts[$key] = implode('#', $subparts);
541         }
542         $path  = implode('/', $parts);
543         $ffurl = $url.'/'.$path;
544         $separator = '?';
545     } else {
546         $path = rawurlencode('/'.$path);
547         $ffurl = $url.'?file='.$path;
548         $separator = '&amp;';
549     }
551     if ($options) {
552         foreach ($options as $name=>$value) {
553             $ffurl = $ffurl.$separator.$name.'='.$value;
554             $separator = '&amp;';
555         }
556     }
558     return $ffurl;
561 /**
562  * Return all course participant for a given course
563  *
564  * @deprecated use get_enrolled_users($context) instead.
565  * @todo final deprecation of this function in MDL-40607
566  * @param integer $courseid
567  * @return array of user
568  */
569 function get_course_participants($courseid) {
570     debugging('get_course_participants() is deprecated, use get_enrolled_users() instead.', DEBUG_DEVELOPER);
571     return get_enrolled_users(context_course::instance($courseid));
574 /**
575  * Return true if the user is a participant for a given course
576  *
577  * @deprecated use is_enrolled($context, $userid) instead.
578  * @todo final deprecation of this function in MDL-40607
579  * @param integer $userid
580  * @param integer $courseid
581  * @return boolean
582  */
583 function is_course_participant($userid, $courseid) {
584     debugging('is_course_participant() is deprecated, use is_enrolled() instead.', DEBUG_DEVELOPER);
585     return is_enrolled(context_course::instance($courseid), $userid);
588 /**
589  * Searches logs to find all enrolments since a certain date
590  *
591  * used to print recent activity
592  *
593  * @param int $courseid The course in question.
594  * @param int $timestart The date to check forward of
595  * @return object|false  {@link $USER} records or false if error.
596  */
597 function get_recent_enrolments($courseid, $timestart) {
598     global $DB;
600     debugging('get_recent_enrolments() is deprecated as it returned inaccurate results.', DEBUG_DEVELOPER);
602     $context = context_course::instance($courseid);
603     $sql = "SELECT u.id, u.firstname, u.lastname, MAX(l.time)
604               FROM {user} u, {role_assignments} ra, {log} l
605              WHERE l.time > ?
606                    AND l.course = ?
607                    AND l.module = 'course'
608                    AND l.action = 'enrol'
609                    AND ".$DB->sql_cast_char2int('l.info')." = u.id
610                    AND u.id = ra.userid
611                    AND ra.contextid ".get_related_contexts_string($context)."
612           GROUP BY u.id, u.firstname, u.lastname
613           ORDER BY MAX(l.time) ASC";
614     $params = array($timestart, $courseid);
615     return $DB->get_records_sql($sql, $params);
618 /**
619  * @deprecated use clean_param($string, PARAM_FILE) instead.
620  * @todo final deprecation of this function in MDL-40607
621  *
622  * @param string $string ?
623  * @param int $allowdots ?
624  * @return bool
625  */
626 function detect_munged_arguments($string, $allowdots=1) {
627     debugging('detect_munged_arguments() is deprecated, please use clean_param(,PARAM_FILE) instead.', DEBUG_DEVELOPER);
628     if (substr_count($string, '..') > $allowdots) {   // Sometimes we allow dots in references
629         return true;
630     }
631     if (preg_match('/[\|\`]/', $string)) {  // check for other bad characters
632         return true;
633     }
634     if (empty($string) or $string == '/') {
635         return true;
636     }
638     return false;
642 /**
643  * Unzip one zip file to a destination dir
644  * Both parameters must be FULL paths
645  * If destination isn't specified, it will be the
646  * SAME directory where the zip file resides.
647  *
648  * @global object
649  * @param string $zipfile The zip file to unzip
650  * @param string $destination The location to unzip to
651  * @param bool $showstatus_ignored Unused
652  */
653 function unzip_file($zipfile, $destination = '', $showstatus_ignored = true) {
654     global $CFG;
656     //Extract everything from zipfile
657     $path_parts = pathinfo(cleardoubleslashes($zipfile));
658     $zippath = $path_parts["dirname"];       //The path of the zip file
659     $zipfilename = $path_parts["basename"];  //The name of the zip file
660     $extension = $path_parts["extension"];    //The extension of the file
662     //If no file, error
663     if (empty($zipfilename)) {
664         return false;
665     }
667     //If no extension, error
668     if (empty($extension)) {
669         return false;
670     }
672     //Clear $zipfile
673     $zipfile = cleardoubleslashes($zipfile);
675     //Check zipfile exists
676     if (!file_exists($zipfile)) {
677         return false;
678     }
680     //If no destination, passed let's go with the same directory
681     if (empty($destination)) {
682         $destination = $zippath;
683     }
685     //Clear $destination
686     $destpath = rtrim(cleardoubleslashes($destination), "/");
688     //Check destination path exists
689     if (!is_dir($destpath)) {
690         return false;
691     }
693     $packer = get_file_packer('application/zip');
695     $result = $packer->extract_to_pathname($zipfile, $destpath);
697     if ($result === false) {
698         return false;
699     }
701     foreach ($result as $status) {
702         if ($status !== true) {
703             return false;
704         }
705     }
707     return true;
710 /**
711  * Zip an array of files/dirs to a destination zip file
712  * Both parameters must be FULL paths to the files/dirs
713  *
714  * @global object
715  * @param array $originalfiles Files to zip
716  * @param string $destination The destination path
717  * @return bool Outcome
718  */
719 function zip_files ($originalfiles, $destination) {
720     global $CFG;
722     //Extract everything from destination
723     $path_parts = pathinfo(cleardoubleslashes($destination));
724     $destpath = $path_parts["dirname"];       //The path of the zip file
725     $destfilename = $path_parts["basename"];  //The name of the zip file
726     $extension = $path_parts["extension"];    //The extension of the file
728     //If no file, error
729     if (empty($destfilename)) {
730         return false;
731     }
733     //If no extension, add it
734     if (empty($extension)) {
735         $extension = 'zip';
736         $destfilename = $destfilename.'.'.$extension;
737     }
739     //Check destination path exists
740     if (!is_dir($destpath)) {
741         return false;
742     }
744     //Check destination path is writable. TODO!!
746     //Clean destination filename
747     $destfilename = clean_filename($destfilename);
749     //Now check and prepare every file
750     $files = array();
751     $origpath = NULL;
753     foreach ($originalfiles as $file) {  //Iterate over each file
754         //Check for every file
755         $tempfile = cleardoubleslashes($file); // no doubleslashes!
756         //Calculate the base path for all files if it isn't set
757         if ($origpath === NULL) {
758             $origpath = rtrim(cleardoubleslashes(dirname($tempfile)), "/");
759         }
760         //See if the file is readable
761         if (!is_readable($tempfile)) {  //Is readable
762             continue;
763         }
764         //See if the file/dir is in the same directory than the rest
765         if (rtrim(cleardoubleslashes(dirname($tempfile)), "/") != $origpath) {
766             continue;
767         }
768         //Add the file to the array
769         $files[] = $tempfile;
770     }
772     $zipfiles = array();
773     $start = strlen($origpath)+1;
774     foreach($files as $file) {
775         $zipfiles[substr($file, $start)] = $file;
776     }
778     $packer = get_file_packer('application/zip');
780     return $packer->archive_to_pathname($zipfiles, $destpath . '/' . $destfilename);
783 /**
784  * Get the IDs for the user's groups in the given course.
785  *
786  * @global object
787  * @param int $courseid The course being examined - the 'course' table id field.
788  * @return array|bool An _array_ of groupids, or false
789  * (Was return $groupids[0] - consequences!)
790  * @deprecated use groups_get_all_groups() instead.
791  * @todo final deprecation of this function in MDL-40607
792  */
793 function mygroupid($courseid) {
794     global $USER;
796     debugging('mygroupid() is deprecated, please use groups_get_all_groups() instead.', DEBUG_DEVELOPER);
798     if ($groups = groups_get_all_groups($courseid, $USER->id)) {
799         return array_keys($groups);
800     } else {
801         return false;
802     }
806 /**
807  * Returns the current group mode for a given course or activity module
808  *
809  * Could be false, SEPARATEGROUPS or VISIBLEGROUPS    (<-- Martin)
810  *
811  * @param object $course Course Object
812  * @param object $cm Course Manager Object
813  * @return mixed $course->groupmode
814  */
815 function groupmode($course, $cm=null) {
817     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
818         return $cm->groupmode;
819     }
820     return $course->groupmode;
823 /**
824  * Sets the current group in the session variable
825  * When $SESSION->currentgroup[$courseid] is set to 0 it means, show all groups.
826  * Sets currentgroup[$courseid] in the session variable appropriately.
827  * Does not do any permission checking.
828  *
829  * @global object
830  * @param int $courseid The course being examined - relates to id field in
831  * 'course' table.
832  * @param int $groupid The group being examined.
833  * @return int Current group id which was set by this function
834  */
835 function set_current_group($courseid, $groupid) {
836     global $SESSION;
837     return $SESSION->currentgroup[$courseid] = $groupid;
841 /**
842  * Gets the current group - either from the session variable or from the database.
843  *
844  * @global object
845  * @param int $courseid The course being examined - relates to id field in
846  * 'course' table.
847  * @param bool $full If true, the return value is a full record object.
848  * If false, just the id of the record.
849  * @return int|bool
850  */
851 function get_current_group($courseid, $full = false) {
852     global $SESSION;
854     if (isset($SESSION->currentgroup[$courseid])) {
855         if ($full) {
856             return groups_get_group($SESSION->currentgroup[$courseid]);
857         } else {
858             return $SESSION->currentgroup[$courseid];
859         }
860     }
862     $mygroupid = mygroupid($courseid);
863     if (is_array($mygroupid)) {
864         $mygroupid = array_shift($mygroupid);
865         set_current_group($courseid, $mygroupid);
866         if ($full) {
867             return groups_get_group($mygroupid);
868         } else {
869             return $mygroupid;
870         }
871     }
873     if ($full) {
874         return false;
875     } else {
876         return 0;
877     }
881 /**
882  * Inndicates fatal error. This function was originally printing the
883  * error message directly, since 2.0 it is throwing exception instead.
884  * The error printing is handled in default exception handler.
885  *
886  * Old method, don't call directly in new code - use print_error instead.
887  *
888  * @param string $message The message to display to the user about the error.
889  * @param string $link The url where the user will be prompted to continue. If no url is provided the user will be directed to the site index page.
890  * @return void, always throws moodle_exception
891  */
892 function error($message, $link='') {
893     throw new moodle_exception('notlocalisederrormessage', 'error', $link, $message, 'error() is a deprecated function, please call print_error() instead of error()');
897 /**
898  * @deprecated use $PAGE->theme->name instead.
899  * @todo final deprecation of this function in MDL-40607
900  * @return string the name of the current theme.
901  */
902 function current_theme() {
903     global $PAGE;
905     debugging('current_theme() is deprecated, please use $PAGE->theme->name instead', DEBUG_DEVELOPER);
906     return $PAGE->theme->name;
909 /**
910  * Prints some red text using echo
911  *
912  * @deprecated
913  * @param string $error The text to be displayed in red
914  */
915 function formerr($error) {
916     debugging('formerr() has been deprecated. Please change your code to use $OUTPUT->error_text($string).');
917     global $OUTPUT;
918     echo $OUTPUT->error_text($error);
921 /**
922  * Return the markup for the destination of the 'Skip to main content' links.
923  * Accessibility improvement for keyboard-only users.
924  *
925  * Used in course formats, /index.php and /course/index.php
926  *
927  * @deprecated use $OUTPUT->skip_link_target() in instead.
928  * @todo final deprecation of this function in MDL-40607
929  * @return string HTML element.
930  */
931 function skip_main_destination() {
932     global $OUTPUT;
934     debugging('skip_main_destination() is deprecated, please use $OUTPUT->skip_link_target() instead.', DEBUG_DEVELOPER);
935     return $OUTPUT->skip_link_target();
938 /**
939  * Print a message in a standard themed container.
940  *
941  * @deprecated use $OUTPUT->container() instead.
942  * @todo final deprecation of this function in MDL-40607
943  * @param string $message, the content of the container
944  * @param boolean $clearfix clear both sides
945  * @param string $classes, space-separated class names.
946  * @param string $idbase
947  * @param boolean $return, return as string or just print it
948  * @return string|void Depending on value of $return
949  */
950 function print_container($message, $clearfix=false, $classes='', $idbase='', $return=false) {
951     global $OUTPUT;
953     debugging('print_container() is deprecated. Please use $OUTPUT->container() instead.', DEBUG_DEVELOPER);
954     if ($clearfix) {
955         $classes .= ' clearfix';
956     }
957     $output = $OUTPUT->container($message, $classes, $idbase);
958     if ($return) {
959         return $output;
960     } else {
961         echo $output;
962     }
965 /**
966  * Starts a container using divs
967  *
968  * @deprecated use $OUTPUT->container_start() instead.
969  * @todo final deprecation of this function in MDL-40607
970  * @param boolean $clearfix clear both sides
971  * @param string $classes, space-separated class names.
972  * @param string $idbase
973  * @param boolean $return, return as string or just print it
974  * @return string|void Based on value of $return
975  */
976 function print_container_start($clearfix=false, $classes='', $idbase='', $return=false) {
977     global $OUTPUT;
979     debugging('print_container_start() is deprecated. Please use $OUTPUT->container_start() instead.', DEBUG_DEVELOPER);
981     if ($clearfix) {
982         $classes .= ' clearfix';
983     }
984     $output = $OUTPUT->container_start($classes, $idbase);
985     if ($return) {
986         return $output;
987     } else {
988         echo $output;
989     }
992 /**
993  * Simple function to end a container (see above)
994  *
995  * @deprecated use $OUTPUT->container_end() instead.
996  * @todo final deprecation of this function in MDL-40607
997  * @param boolean $return, return as string or just print it
998  * @return string|void Based on $return
999  */
1000 function print_container_end($return=false) {
1001     global $OUTPUT;
1002     debugging('print_container_end() is deprecated. Please use $OUTPUT->container_end() instead.', DEBUG_DEVELOPER);
1003     $output = $OUTPUT->container_end();
1004     if ($return) {
1005         return $output;
1006     } else {
1007         echo $output;
1008     }
1011 /**
1012  * Print a bold message in an optional color.
1013  *
1014  * @deprecated use $OUTPUT->notification instead.
1015  * @param string $message The message to print out
1016  * @param string $style Optional style to display message text in
1017  * @param string $align Alignment option
1018  * @param bool $return whether to return an output string or echo now
1019  * @return string|bool Depending on $result
1020  */
1021 function notify($message, $classes = 'notifyproblem', $align = 'center', $return = false) {
1022     global $OUTPUT;
1024     if ($classes == 'green') {
1025         debugging('Use of deprecated class name "green" in notify. Please change to "notifysuccess".', DEBUG_DEVELOPER);
1026         $classes = 'notifysuccess'; // Backward compatible with old color system
1027     }
1029     $output = $OUTPUT->notification($message, $classes);
1030     if ($return) {
1031         return $output;
1032     } else {
1033         echo $output;
1034     }
1037 /**
1038  * Print a continue button that goes to a particular URL.
1039  *
1040  * @deprecated use $OUTPUT->continue_button() instead.
1041  * @todo final deprecation of this function in MDL-40607
1042  *
1043  * @param string $link The url to create a link to.
1044  * @param bool $return If set to true output is returned rather than echoed, default false
1045  * @return string|void HTML String if return=true nothing otherwise
1046  */
1047 function print_continue($link, $return = false) {
1048     global $CFG, $OUTPUT;
1050     debugging('print_continue() is deprecated. Please use $OUTPUT->continue_button() instead.', DEBUG_DEVELOPER);
1052     if ($link == '') {
1053         if (!empty($_SERVER['HTTP_REFERER'])) {
1054             $link = $_SERVER['HTTP_REFERER'];
1055             $link = str_replace('&', '&amp;', $link); // make it valid XHTML
1056         } else {
1057             $link = $CFG->wwwroot .'/';
1058         }
1059     }
1061     $output = $OUTPUT->continue_button($link);
1062     if ($return) {
1063         return $output;
1064     } else {
1065         echo $output;
1066     }
1069 /**
1070  * Print a standard header
1071  *
1072  * @deprecated use $PAGE methods instead.
1073  * @todo final deprecation of this function in MDL-40607
1074  * @param string  $title Appears at the top of the window
1075  * @param string  $heading Appears at the top of the page
1076  * @param string  $navigation Array of $navlinks arrays (keys: name, link, type) for use as breadcrumbs links
1077  * @param string  $focus Indicates form element to get cursor focus on load eg  inputform.password
1078  * @param string  $meta Meta tags to be added to the header
1079  * @param boolean $cache Should this page be cacheable?
1080  * @param string  $button HTML code for a button (usually for module editing)
1081  * @param string  $menu HTML code for a popup menu
1082  * @param boolean $usexml use XML for this page
1083  * @param string  $bodytags This text will be included verbatim in the <body> tag (useful for onload() etc)
1084  * @param bool    $return If true, return the visible elements of the header instead of echoing them.
1085  * @return string|void If return=true then string else void
1086  */
1087 function print_header($title='', $heading='', $navigation='', $focus='',
1088                       $meta='', $cache=true, $button='&nbsp;', $menu=null,
1089                       $usexml=false, $bodytags='', $return=false) {
1090     global $PAGE, $OUTPUT;
1092     debugging('print_header() is deprecated. Please use $PAGE methods instead.', DEBUG_DEVELOPER);
1094     $PAGE->set_title($title);
1095     $PAGE->set_heading($heading);
1096     $PAGE->set_cacheable($cache);
1097     if ($button == '') {
1098         $button = '&nbsp;';
1099     }
1100     $PAGE->set_button($button);
1101     $PAGE->set_headingmenu($menu);
1103     // TODO $menu
1105     if ($meta) {
1106         throw new coding_exception('The $meta parameter to print_header is no longer supported. '.
1107                 'You should be able to do everything you want with $PAGE->requires and other such mechanisms.');
1108     }
1109     if ($usexml) {
1110         throw new coding_exception('The $usexml parameter to print_header is no longer supported.');
1111     }
1112     if ($bodytags) {
1113         throw new coding_exception('The $bodytags parameter to print_header is no longer supported.');
1114     }
1116     $output = $OUTPUT->header();
1118     if ($return) {
1119         return $output;
1120     } else {
1121         echo $output;
1122     }
1125 /**
1126  * This version of print_header is simpler because the course name does not have to be
1127  * provided explicitly in the strings. It can be used on the site page as in courses
1128  * Eventually all print_header could be replaced by print_header_simple
1129  *
1130  * @deprecated use $PAGE methods instead.
1131  * @todo final deprecation of this function in MDL-40607
1132  * @param string $title Appears at the top of the window
1133  * @param string $heading Appears at the top of the page
1134  * @param string $navigation Premade navigation string (for use as breadcrumbs links)
1135  * @param string $focus Indicates form element to get cursor focus on load eg  inputform.password
1136  * @param string $meta Meta tags to be added to the header
1137  * @param boolean $cache Should this page be cacheable?
1138  * @param string $button HTML code for a button (usually for module editing)
1139  * @param string $menu HTML code for a popup menu
1140  * @param boolean $usexml use XML for this page
1141  * @param string $bodytags This text will be included verbatim in the <body> tag (useful for onload() etc)
1142  * @param bool   $return If true, return the visible elements of the header instead of echoing them.
1143  * @return string|void If $return=true the return string else nothing
1144  */
1145 function print_header_simple($title='', $heading='', $navigation='', $focus='', $meta='',
1146                        $cache=true, $button='&nbsp;', $menu='', $usexml=false, $bodytags='', $return=false) {
1148     global $COURSE, $CFG, $PAGE, $OUTPUT;
1150     debugging('print_header_simple() is deprecated. Please use $PAGE methods instead.', DEBUG_DEVELOPER);
1152     if ($meta) {
1153         throw new coding_exception('The $meta parameter to print_header is no longer supported. '.
1154                 'You should be able to do everything you want with $PAGE->requires and other such mechanisms.');
1155     }
1156     if ($usexml) {
1157         throw new coding_exception('The $usexml parameter to print_header is no longer supported.');
1158     }
1159     if ($bodytags) {
1160         throw new coding_exception('The $bodytags parameter to print_header is no longer supported.');
1161     }
1163     $PAGE->set_title($title);
1164     $PAGE->set_heading($heading);
1165     $PAGE->set_cacheable(true);
1166     $PAGE->set_button($button);
1168     $output = $OUTPUT->header();
1170     if ($return) {
1171         return $output;
1172     } else {
1173         echo $output;
1174     }
1177 /**
1178  * Prints a nice side block with an optional header.  The content can either
1179  * be a block of HTML or a list of text with optional icons.
1180  *
1181  * @static int $block_id Increments for each call to the function
1182  * @param string $heading HTML for the heading. Can include full HTML or just
1183  *   plain text - plain text will automatically be enclosed in the appropriate
1184  *   heading tags.
1185  * @param string $content HTML for the content
1186  * @param array $list an alternative to $content, it you want a list of things with optional icons.
1187  * @param array $icons optional icons for the things in $list.
1188  * @param string $footer Extra HTML content that gets output at the end, inside a &lt;div class="footer">
1189  * @param array $attributes an array of attribute => value pairs that are put on the
1190  * outer div of this block. If there is a class attribute ' block' gets appended to it. If there isn't
1191  * already a class, class='block' is used.
1192  * @param string $title Plain text title, as embedded in the $heading.
1193  * @deprecated use $OUTPUT->block() instead.
1194  * @todo final deprecation of this function in MDL-40607
1195  */
1196 function print_side_block($heading='', $content='', $list=NULL, $icons=NULL, $footer='', $attributes = array(), $title='') {
1197     global $OUTPUT;
1199     debugging('print_side_block() is deprecated, please use $OUTPUT->block() instead.', DEBUG_DEVELOPER);
1200     // We don't use $heading, becuse it often contains HTML that we don't want.
1201     // However, sometimes $title is not set, but $heading is.
1202     if (empty($title)) {
1203         $title = strip_tags($heading);
1204     }
1206     // Render list contents to HTML if required.
1207     if (empty($content) && $list) {
1208         $content = $OUTPUT->list_block_contents($icons, $list);
1209     }
1211     $bc = new block_contents();
1212     $bc->content = $content;
1213     $bc->footer = $footer;
1214     $bc->title = $title;
1216     if (isset($attributes['id'])) {
1217         $bc->id = $attributes['id'];
1218         unset($attributes['id']);
1219     }
1220     $bc->attributes = $attributes;
1222     echo $OUTPUT->block($bc, BLOCK_POS_LEFT); // POS LEFT may be wrong, but no way to get a better guess here.
1225 /**
1226  * Prints a basic textarea field.
1227  *
1228  * @deprecated since Moodle 2.0
1229  *
1230  * When using this function, you should
1231  *
1232  * @global object
1233  * @param bool $unused No longer used.
1234  * @param int $rows Number of rows to display  (minimum of 10 when $height is non-null)
1235  * @param int $cols Number of columns to display (minimum of 65 when $width is non-null)
1236  * @param null $width (Deprecated) Width of the element; if a value is passed, the minimum value for $cols will be 65. Value is otherwise ignored.
1237  * @param null $height (Deprecated) Height of the element; if a value is passe, the minimum value for $rows will be 10. Value is otherwise ignored.
1238  * @param string $name Name to use for the textarea element.
1239  * @param string $value Initial content to display in the textarea.
1240  * @param int $obsolete deprecated
1241  * @param bool $return If false, will output string. If true, will return string value.
1242  * @param string $id CSS ID to add to the textarea element.
1243  * @return string|void depending on the value of $return
1244  */
1245 function print_textarea($unused, $rows, $cols, $width, $height, $name, $value='', $obsolete=0, $return=false, $id='') {
1246     /// $width and height are legacy fields and no longer used as pixels like they used to be.
1247     /// However, you can set them to zero to override the mincols and minrows values below.
1249     // Disabling because there is not yet a viable $OUTPUT option for cases when mforms can't be used
1250     // debugging('print_textarea() has been deprecated. You should be using mforms and the editor element.');
1252     global $CFG;
1254     $mincols = 65;
1255     $minrows = 10;
1256     $str = '';
1258     if ($id === '') {
1259         $id = 'edit-'.$name;
1260     }
1262     if ($height && ($rows < $minrows)) {
1263         $rows = $minrows;
1264     }
1265     if ($width && ($cols < $mincols)) {
1266         $cols = $mincols;
1267     }
1269     editors_head_setup();
1270     $editor = editors_get_preferred_editor(FORMAT_HTML);
1271     $editor->use_editor($id, array('legacy'=>true));
1273     $str .= "\n".'<textarea class="form-textarea" id="'. $id .'" name="'. $name .'" rows="'. $rows .'" cols="'. $cols .'" spellcheck="true">'."\n";
1274     $str .= htmlspecialchars($value); // needed for editing of cleaned text!
1275     $str .= '</textarea>'."\n";
1277     if ($return) {
1278         return $str;
1279     }
1280     echo $str;
1283 /**
1284  * Returns a string of html with an image of a help icon linked to a help page on a number of help topics.
1285  * Should be used only with htmleditor or textarea.
1286  *
1287  * @global object
1288  * @global object
1289  * @param mixed $helptopics variable amount of params accepted. Each param may be a string or an array of arguments for
1290  *                  helpbutton.
1291  * @return string Link to help button
1292  */
1293 function editorhelpbutton(){
1294     return '';
1296     /// TODO: MDL-21215
1299 /**
1300  * Print a help button.
1301  *
1302  * Prints a special help button for html editors (htmlarea in this case)
1303  *
1304  * @todo Write code into this function! detect current editor and print correct info
1305  * @global object
1306  * @return string Only returns an empty string at the moment
1307  */
1308 function editorshortcutshelpbutton() {
1309     /// TODO: MDL-21215
1311     global $CFG;
1312     //TODO: detect current editor and print correct info
1313     return '';
1317 /**
1318  * Returns an image of an up or down arrow, used for column sorting. To avoid unnecessary DB accesses, please
1319  * provide this function with the language strings for sortasc and sortdesc.
1320  *
1321  * @deprecated use $OUTPUT->arrow() instead.
1322  * @todo final deprecation of this function in MDL-40607
1323  *
1324  * If no sort string is associated with the direction, an arrow with no alt text will be printed/returned.
1325  *
1326  * @global object
1327  * @param string $direction 'up' or 'down'
1328  * @param string $strsort The language string used for the alt attribute of this image
1329  * @param bool $return Whether to print directly or return the html string
1330  * @return string|void depending on $return
1331  *
1332  */
1333 function print_arrow($direction='up', $strsort=null, $return=false) {
1334     global $OUTPUT;
1336     debugging('print_arrow() is deprecated. Please use $OUTPUT->arrow() instead.', DEBUG_DEVELOPER);
1338     if (!in_array($direction, array('up', 'down', 'right', 'left', 'move'))) {
1339         return null;
1340     }
1342     $return = null;
1344     switch ($direction) {
1345         case 'up':
1346             $sortdir = 'asc';
1347             break;
1348         case 'down':
1349             $sortdir = 'desc';
1350             break;
1351         case 'move':
1352             $sortdir = 'asc';
1353             break;
1354         default:
1355             $sortdir = null;
1356             break;
1357     }
1359     // Prepare language string
1360     $strsort = '';
1361     if (empty($strsort) && !empty($sortdir)) {
1362         $strsort  = get_string('sort' . $sortdir, 'grades');
1363     }
1365     $return = ' <img src="'.$OUTPUT->pix_url('t/' . $direction) . '" alt="'.$strsort.'" /> ';
1367     if ($return) {
1368         return $return;
1369     } else {
1370         echo $return;
1371     }
1374 /**
1375  * Given an array of values, output the HTML for a select element with those options.
1376  *
1377  * @deprecated since Moodle 2.0
1378  *
1379  * Normally, you only need to use the first few parameters.
1380  *
1381  * @param array $options The options to offer. An array of the form
1382  *      $options[{value}] = {text displayed for that option};
1383  * @param string $name the name of this form control, as in &lt;select name="..." ...
1384  * @param string $selected the option to select initially, default none.
1385  * @param string $nothing The label for the 'nothing is selected' option. Defaults to get_string('choose').
1386  *      Set this to '' if you don't want a 'nothing is selected' option.
1387  * @param string $script if not '', then this is added to the &lt;select> element as an onchange handler.
1388  * @param string $nothingvalue The value corresponding to the $nothing option. Defaults to 0.
1389  * @param boolean $return if false (the default) the the output is printed directly, If true, the
1390  *      generated HTML is returned as a string.
1391  * @param boolean $disabled if true, the select is generated in a disabled state. Default, false.
1392  * @param int $tabindex if give, sets the tabindex attribute on the &lt;select> element. Default none.
1393  * @param string $id value to use for the id attribute of the &lt;select> element. If none is given,
1394  *      then a suitable one is constructed.
1395  * @param mixed $listbox if false, display as a dropdown menu. If true, display as a list box.
1396  *      By default, the list box will have a number of rows equal to min(10, count($options)), but if
1397  *      $listbox is an integer, that number is used for size instead.
1398  * @param boolean $multiple if true, enable multiple selections, else only 1 item can be selected. Used
1399  *      when $listbox display is enabled
1400  * @param string $class value to use for the class attribute of the &lt;select> element. If none is given,
1401  *      then a suitable one is constructed.
1402  * @return string|void If $return=true returns string, else echo's and returns void
1403  */
1404 function choose_from_menu ($options, $name, $selected='', $nothing='choose', $script='',
1405                            $nothingvalue='0', $return=false, $disabled=false, $tabindex=0,
1406                            $id='', $listbox=false, $multiple=false, $class='') {
1408     global $OUTPUT;
1409     debugging('choose_from_menu() has been deprecated. Please change your code to use html_writer::select().');
1411     if ($script) {
1412         debugging('The $script parameter has been deprecated. You must use component_actions instead', DEBUG_DEVELOPER);
1413     }
1414     $attributes = array();
1415     $attributes['disabled'] = $disabled ? 'disabled' : null;
1416     $attributes['tabindex'] = $tabindex ? $tabindex : null;
1417     $attributes['multiple'] = $multiple ? $multiple : null;
1418     $attributes['class'] = $class ? $class : null;
1419     $attributes['id'] = $id ? $id : null;
1421     $output = html_writer::select($options, $name, $selected, array($nothingvalue=>$nothing), $attributes);
1423     if ($return) {
1424         return $output;
1425     } else {
1426         echo $output;
1427     }
1430 /**
1431  * Prints a help button about a scale
1432  *
1433  * @deprecated use $OUTPUT->help_icon_scale($courseid, $scale) instead.
1434  * @todo final deprecation of this function in MDL-40607
1435  *
1436  * @global object
1437  * @param id $courseid
1438  * @param object $scale
1439  * @param boolean $return If set to true returns rather than echo's
1440  * @return string|bool Depending on value of $return
1441  */
1442 function print_scale_menu_helpbutton($courseid, $scale, $return=false) {
1443     global $OUTPUT;
1445     debugging('print_scale_menu_helpbutton() is deprecated. Please use $OUTPUT->help_icon_scale($courseid, $scale) instead.', DEBUG_DEVELOPER);
1447     $output = $OUTPUT->help_icon_scale($courseid, $scale);
1449     if ($return) {
1450         return $output;
1451     } else {
1452         echo $output;
1453     }
1456 /**
1457  * Display an standard html checkbox with an optional label
1458  *
1459  * @deprecated use html_writer::checkbox() instead.
1460  * @todo final deprecation of this function in MDL-40607
1461  *
1462  * @staticvar int $idcounter
1463  * @param string $name    The name of the checkbox
1464  * @param string $value   The valus that the checkbox will pass when checked
1465  * @param bool $checked The flag to tell the checkbox initial state
1466  * @param string $label   The label to be showed near the checkbox
1467  * @param string $alt     The info to be inserted in the alt tag
1468  * @param string $script If not '', then this is added to the checkbox element
1469  *                       as an onchange handler.
1470  * @param bool $return Whether this function should return a string or output
1471  *                     it (defaults to false)
1472  * @return string|void If $return=true returns string, else echo's and returns void
1473  */
1474 function print_checkbox($name, $value, $checked = true, $label = '', $alt = '', $script='', $return=false) {
1475     global $OUTPUT;
1477     debugging('print_checkbox() is deprecated. Please use html_writer::checkbox() instead.', DEBUG_DEVELOPER);
1479     if (!empty($script)) {
1480         debugging('The use of the $script param in print_checkbox has not been migrated into html_writer::checkbox().', DEBUG_DEVELOPER);
1481     }
1483     $output = html_writer::checkbox($name, $value, $checked, $label);
1485     if (empty($return)) {
1486         echo $output;
1487     } else {
1488         return $output;
1489     }
1493 /**
1494  * Prints the 'update this xxx' button that appears on module pages.
1495  *
1496  * @deprecated since Moodle 2.0
1497  *
1498  * @param string $cmid the course_module id.
1499  * @param string $ignored not used any more. (Used to be courseid.)
1500  * @param string $string the module name - get_string('modulename', 'xxx')
1501  * @return string the HTML for the button, if this user has permission to edit it, else an empty string.
1502  */
1503 function update_module_button($cmid, $ignored, $string) {
1504     global $CFG, $OUTPUT;
1506     // debugging('update_module_button() has been deprecated. Please change your code to use $OUTPUT->update_module_button().');
1508     //NOTE: DO NOT call new output method because it needs the module name we do not have here!
1510     if (has_capability('moodle/course:manageactivities', context_module::instance($cmid))) {
1511         $string = get_string('updatethis', '', $string);
1513         $url = new moodle_url("$CFG->wwwroot/course/mod.php", array('update' => $cmid, 'return' => true, 'sesskey' => sesskey()));
1514         return $OUTPUT->single_button($url, $string);
1515     } else {
1516         return '';
1517     }
1520 /**
1521  * Prints breadcrumb trail of links, called in theme/-/header.html
1522  *
1523  * This function has now been deprecated please use output's navbar method instead
1524  * as shown below
1525  *
1526  * <code php>
1527  * echo $OUTPUT->navbar();
1528  * </code>
1529  *
1530  * @deprecated use $OUTPUT->navbar() instead
1531  * @todo final deprecation of this function in MDL-40607
1532  * @param mixed $navigation deprecated
1533  * @param string $separator OBSOLETE, and now deprecated
1534  * @param boolean $return False to echo the breadcrumb string (default), true to return it.
1535  * @return string|void String or null, depending on $return.
1536  */
1537 function print_navigation ($navigation, $separator=0, $return=false) {
1538     global $OUTPUT,$PAGE;
1540     debugging('print_navigation() is deprecated, please update use $OUTPUT->navbar() instead.', DEBUG_DEVELOPER);
1542     $output = $OUTPUT->navbar();
1544     if ($return) {
1545         return $output;
1546     } else {
1547         echo $output;
1548     }
1551 /**
1552  * This function will build the navigation string to be used by print_header
1553  * and others.
1554  *
1555  * It automatically generates the site and course level (if appropriate) links.
1556  *
1557  * If you pass in a $cm object, the method will also generate the activity (e.g. 'Forums')
1558  * and activityinstances (e.g. 'General Developer Forum') navigation levels.
1559  *
1560  * If you want to add any further navigation links after the ones this function generates,
1561  * the pass an array of extra link arrays like this:
1562  * array(
1563  *     array('name' => $linktext1, 'link' => $url1, 'type' => $linktype1),
1564  *     array('name' => $linktext2, 'link' => $url2, 'type' => $linktype2)
1565  * )
1566  * The normal case is to just add one further link, for example 'Editing forum' after
1567  * 'General Developer Forum', with no link.
1568  * To do that, you need to pass
1569  * array(array('name' => $linktext, 'link' => '', 'type' => 'title'))
1570  * However, becuase this is a very common case, you can use a shortcut syntax, and just
1571  * pass the string 'Editing forum', instead of an array as $extranavlinks.
1572  *
1573  * At the moment, the link types only have limited significance. Type 'activity' is
1574  * recognised in order to implement the $CFG->hideactivitytypenavlink feature. Types
1575  * that are known to appear are 'home', 'course', 'activity', 'activityinstance' and 'title'.
1576  * This really needs to be documented better. In the mean time, try to be consistent, it will
1577  * enable people to customise the navigation more in future.
1578  *
1579  * When passing a $cm object, the fields used are $cm->modname, $cm->name and $cm->course.
1580  * If you get the $cm object using the function get_coursemodule_from_instance or
1581  * get_coursemodule_from_id (as recommended) then this will be done for you automatically.
1582  * If you don't have $cm->modname or $cm->name, this fuction will attempt to find them using
1583  * the $cm->module and $cm->instance fields, but this takes extra database queries, so a
1584  * warning is printed in developer debug mode.
1585  *
1586  * @deprecated Please use $PAGE->navabar methods instead.
1587  * @todo final deprecation of this function in MDL-40607
1588  * @param mixed $extranavlinks - Normally an array of arrays, keys: name, link, type. If you
1589  *      only want one extra item with no link, you can pass a string instead. If you don't want
1590  *      any extra links, pass an empty string.
1591  * @param mixed $cm deprecated
1592  * @return array Navigation array
1593  */
1594 function build_navigation($extranavlinks, $cm = null) {
1595     global $CFG, $COURSE, $DB, $SITE, $PAGE;
1597     debugging('build_navigation() is deprecated, please use $PAGE->navbar methods instead.', DEBUG_DEVELOPER);
1598     if (is_array($extranavlinks) && count($extranavlinks)>0) {
1599         foreach ($extranavlinks as $nav) {
1600             if (array_key_exists('name', $nav)) {
1601                 if (array_key_exists('link', $nav) && !empty($nav['link'])) {
1602                     $link = $nav['link'];
1603                 } else {
1604                     $link = null;
1605                 }
1606                 $PAGE->navbar->add($nav['name'],$link);
1607             }
1608         }
1609     }
1611     return(array('newnav' => true, 'navlinks' => array()));
1614 /**
1615  * @deprecated not relevant with global navigation in Moodle 2.x+
1616  * @todo remove completely in MDL-40607
1617  */
1618 function navmenu($course, $cm=NULL, $targetwindow='self') {
1619     // This function has been deprecated with the creation of the global nav in
1620     // moodle 2.0
1621     debugging('navmenu() is deprecated, it is no longer relevant with global navigation.', DEBUG_DEVELOPER);
1623     return '';
1626 /// CALENDAR MANAGEMENT  ////////////////////////////////////////////////////////////////
1629 /**
1630  * Call this function to add an event to the calendar table and to call any calendar plugins
1631  *
1632  * @param object $event An object representing an event from the calendar table.
1633  * The event will be identified by the id field. The object event should include the following:
1634  *  <ul>
1635  *    <li><b>$event->name</b> - Name for the event
1636  *    <li><b>$event->description</b> - Description of the event (defaults to '')
1637  *    <li><b>$event->format</b> - Format for the description (using formatting types defined at the top of weblib.php)
1638  *    <li><b>$event->courseid</b> - The id of the course this event belongs to (0 = all courses)
1639  *    <li><b>$event->groupid</b> - The id of the group this event belongs to (0 = no group)
1640  *    <li><b>$event->userid</b> - The id of the user this event belongs to (0 = no user)
1641  *    <li><b>$event->modulename</b> - Name of the module that creates this event
1642  *    <li><b>$event->instance</b> - Instance of the module that owns this event
1643  *    <li><b>$event->eventtype</b> - The type info together with the module info could
1644  *             be used by calendar plugins to decide how to display event
1645  *    <li><b>$event->timestart</b>- Timestamp for start of event
1646  *    <li><b>$event->timeduration</b> - Duration (defaults to zero)
1647  *    <li><b>$event->visible</b> - 0 if the event should be hidden (e.g. because the activity that created it is hidden)
1648  *  </ul>
1649  * @return int|false The id number of the resulting record or false if failed
1650  * @deprecated please use calendar_event::create() instead.
1651  * @todo final deprecation of this function in MDL-40607
1652  */
1653  function add_event($event) {
1654     global $CFG;
1655     require_once($CFG->dirroot.'/calendar/lib.php');
1657     debugging('add_event() is deprecated, please use calendar_event::create() instead.', DEBUG_DEVELOPER);
1658     $event = calendar_event::create($event);
1659     if ($event !== false) {
1660         return $event->id;
1661     }
1662     return false;
1665 /**
1666  * Call this function to update an event in the calendar table
1667  * the event will be identified by the id field of the $event object.
1668  *
1669  * @param object $event An object representing an event from the calendar table. The event will be identified by the id field.
1670  * @return bool Success
1671  * @deprecated please calendar_event->update() instead.
1672  */
1673 function update_event($event) {
1674     global $CFG;
1675     require_once($CFG->dirroot.'/calendar/lib.php');
1677     debugging('update_event() is deprecated, please use calendar_event->update() instead.', DEBUG_DEVELOPER);
1678     $event = (object)$event;
1679     $calendarevent = calendar_event::load($event->id);
1680     return $calendarevent->update($event);
1683 /**
1684  * Call this function to delete the event with id $id from calendar table.
1685  *
1686  * @param int $id The id of an event from the 'event' table.
1687  * @return bool
1688  * @deprecated please use calendar_event->delete() instead.
1689  * @todo final deprecation of this function in MDL-40607
1690  */
1691 function delete_event($id) {
1692     global $CFG;
1693     require_once($CFG->dirroot.'/calendar/lib.php');
1695     debugging('delete_event() is deprecated, please use calendar_event->delete() instead.', DEBUG_DEVELOPER);
1697     $event = calendar_event::load($id);
1698     return $event->delete();
1701 /**
1702  * Call this function to hide an event in the calendar table
1703  * the event will be identified by the id field of the $event object.
1704  *
1705  * @param object $event An object representing an event from the calendar table. The event will be identified by the id field.
1706  * @return true
1707  * @deprecated please use calendar_event->toggle_visibility(false) instead.
1708  * @todo final deprecation of this function in MDL-40607
1709  */
1710 function hide_event($event) {
1711     global $CFG;
1712     require_once($CFG->dirroot.'/calendar/lib.php');
1714     debugging('hide_event() is deprecated, please use calendar_event->toggle_visibility(false) instead.', DEBUG_DEVELOPER);
1716     $event = new calendar_event($event);
1717     return $event->toggle_visibility(false);
1720 /**
1721  * Call this function to unhide an event in the calendar table
1722  * the event will be identified by the id field of the $event object.
1723  *
1724  * @param object $event An object representing an event from the calendar table. The event will be identified by the id field.
1725  * @return true
1726  * @deprecated please use calendar_event->toggle_visibility(true) instead.
1727  * @todo final deprecation of this function in MDL-40607
1728  */
1729 function show_event($event) {
1730     global $CFG;
1731     require_once($CFG->dirroot.'/calendar/lib.php');
1733     debugging('show_event() is deprecated, please use calendar_event->toggle_visibility(true) instead.', DEBUG_DEVELOPER);
1735     $event = new calendar_event($event);
1736     return $event->toggle_visibility(true);
1739 /**
1740  * Original singleton helper function, please use static methods instead,
1741  * ex: core_text::convert()
1742  *
1743  * @deprecated since Moodle 2.2 use core_text::xxxx() instead
1744  * @see textlib
1745  * @return textlib instance
1746  */
1747 function textlib_get_instance() {
1749     debugging('textlib_get_instance() is deprecated. Please use static calling core_text::functioname() instead.', DEBUG_DEVELOPER);
1751     return new textlib();
1754 /**
1755  * Gets the generic section name for a courses section
1756  *
1757  * The global function is deprecated. Each course format can define their own generic section name
1758  *
1759  * @deprecated since 2.4
1760  * @see get_section_name()
1761  * @see format_base::get_section_name()
1762  *
1763  * @param string $format Course format ID e.g. 'weeks' $course->format
1764  * @param stdClass $section Section object from database
1765  * @return Display name that the course format prefers, e.g. "Week 2"
1766  */
1767 function get_generic_section_name($format, stdClass $section) {
1768     debugging('get_generic_section_name() is deprecated. Please use appropriate functionality from class format_base', DEBUG_DEVELOPER);
1769     return get_string('sectionname', "format_$format") . ' ' . $section->section;
1772 /**
1773  * Returns an array of sections for the requested course id
1774  *
1775  * It is usually not recommended to display the list of sections used
1776  * in course because the course format may have it's own way to do it.
1777  *
1778  * If you need to just display the name of the section please call:
1779  * get_section_name($course, $section)
1780  * {@link get_section_name()}
1781  * from 2.4 $section may also be just the field course_sections.section
1782  *
1783  * If you need the list of all sections it is more efficient to get this data by calling
1784  * $modinfo = get_fast_modinfo($courseorid);
1785  * $sections = $modinfo->get_section_info_all()
1786  * {@link get_fast_modinfo()}
1787  * {@link course_modinfo::get_section_info_all()}
1788  *
1789  * Information about one section (instance of section_info):
1790  * get_fast_modinfo($courseorid)->get_sections_info($section)
1791  * {@link course_modinfo::get_section_info()}
1792  *
1793  * @deprecated since 2.4
1794  *
1795  * @param int $courseid
1796  * @return array Array of section_info objects
1797  */
1798 function get_all_sections($courseid) {
1799     global $DB;
1800     debugging('get_all_sections() is deprecated. See phpdocs for this function', DEBUG_DEVELOPER);
1801     return get_fast_modinfo($courseid)->get_section_info_all();
1804 /**
1805  * Given a full mod object with section and course already defined, adds this module to that section.
1806  *
1807  * This function is deprecated, please use {@link course_add_cm_to_section()}
1808  * Note that course_add_cm_to_section() also updates field course_modules.section and
1809  * calls rebuild_course_cache()
1810  *
1811  * @deprecated since 2.4
1812  *
1813  * @param object $mod
1814  * @param int $beforemod An existing ID which we will insert the new module before
1815  * @return int The course_sections ID where the mod is inserted
1816  */
1817 function add_mod_to_section($mod, $beforemod = null) {
1818     debugging('Function add_mod_to_section() is deprecated, please use course_add_cm_to_section()', DEBUG_DEVELOPER);
1819     global $DB;
1820     return course_add_cm_to_section($mod->course, $mod->coursemodule, $mod->section, $beforemod);
1823 /**
1824  * Returns a number of useful structures for course displays
1825  *
1826  * Function get_all_mods() is deprecated in 2.4
1827  * Instead of:
1828  * <code>
1829  * get_all_mods($courseid, $mods, $modnames, $modnamesplural, $modnamesused);
1830  * </code>
1831  * please use:
1832  * <code>
1833  * $mods = get_fast_modinfo($courseorid)->get_cms();
1834  * $modnames = get_module_types_names();
1835  * $modnamesplural = get_module_types_names(true);
1836  * $modnamesused = get_fast_modinfo($courseorid)->get_used_module_names();
1837  * </code>
1838  *
1839  * @deprecated since 2.4
1840  *
1841  * @param int $courseid id of the course to get info about
1842  * @param array $mods (return) list of course modules
1843  * @param array $modnames (return) list of names of all module types installed and available
1844  * @param array $modnamesplural (return) list of names of all module types installed and available in the plural form
1845  * @param array $modnamesused (return) list of names of all module types used in the course
1846  */
1847 function get_all_mods($courseid, &$mods, &$modnames, &$modnamesplural, &$modnamesused) {
1848     debugging('Function get_all_mods() is deprecated. Use get_fast_modinfo() and get_module_types_names() instead. See phpdocs for details', DEBUG_DEVELOPER);
1850     global $COURSE;
1851     $modnames      = get_module_types_names();
1852     $modnamesplural= get_module_types_names(true);
1853     $modinfo = get_fast_modinfo($courseid);
1854     $mods = $modinfo->get_cms();
1855     $modnamesused = $modinfo->get_used_module_names();
1858 /**
1859  * Returns course section - creates new if does not exist yet
1860  *
1861  * This function is deprecated. To create a course section call:
1862  * course_create_sections_if_missing($courseorid, $sections);
1863  * to get the section call:
1864  * get_fast_modinfo($courseorid)->get_section_info($sectionnum);
1865  *
1866  * @see course_create_sections_if_missing()
1867  * @see get_fast_modinfo()
1868  * @deprecated since 2.4
1869  *
1870  * @param int $section relative section number (field course_sections.section)
1871  * @param int $courseid
1872  * @return stdClass record from table {course_sections}
1873  */
1874 function get_course_section($section, $courseid) {
1875     global $DB;
1876     debugging('Function get_course_section() is deprecated. Please use course_create_sections_if_missing() and get_fast_modinfo() instead.', DEBUG_DEVELOPER);
1878     if ($cw = $DB->get_record("course_sections", array("section"=>$section, "course"=>$courseid))) {
1879         return $cw;
1880     }
1881     $cw = new stdClass();
1882     $cw->course   = $courseid;
1883     $cw->section  = $section;
1884     $cw->summary  = "";
1885     $cw->summaryformat = FORMAT_HTML;
1886     $cw->sequence = "";
1887     $id = $DB->insert_record("course_sections", $cw);
1888     rebuild_course_cache($courseid, true);
1889     return $DB->get_record("course_sections", array("id"=>$id));
1892 /**
1893  * Return the start and end date of the week in Weekly course format
1894  *
1895  * It is not recommended to use this function outside of format_weeks plugin
1896  *
1897  * @deprecated since 2.4
1898  * @see format_weeks::get_section_dates()
1899  *
1900  * @param stdClass $section The course_section entry from the DB
1901  * @param stdClass $course The course entry from DB
1902  * @return stdClass property start for startdate, property end for enddate
1903  */
1904 function format_weeks_get_section_dates($section, $course) {
1905     debugging('Function format_weeks_get_section_dates() is deprecated. It is not recommended to'.
1906             ' use it outside of format_weeks plugin', DEBUG_DEVELOPER);
1907     if (isset($course->format) && $course->format === 'weeks') {
1908         return course_get_format($course)->get_section_dates($section);
1909     }
1910     return null;
1913 /**
1914  * Obtains shared data that is used in print_section when displaying a
1915  * course-module entry.
1916  *
1917  * Deprecated. Instead of:
1918  * list($content, $name) = get_print_section_cm_text($cm, $course);
1919  * use:
1920  * $content = $cm->get_formatted_content(array('overflowdiv' => true, 'noclean' => true));
1921  * $name = $cm->get_formatted_name();
1922  *
1923  * @deprecated since 2.5
1924  * @see cm_info::get_formatted_content()
1925  * @see cm_info::get_formatted_name()
1926  *
1927  * This data is also used in other areas of the code.
1928  * @param cm_info $cm Course-module data (must come from get_fast_modinfo)
1929  * @param object $course (argument not used)
1930  * @return array An array with the following values in this order:
1931  *   $content (optional extra content for after link),
1932  *   $instancename (text of link)
1933  */
1934 function get_print_section_cm_text(cm_info $cm, $course) {
1935     debugging('Function get_print_section_cm_text() is deprecated. Please use '.
1936             'cm_info::get_formatted_content() and cm_info::get_formatted_name()',
1937             DEBUG_DEVELOPER);
1938     return array($cm->get_formatted_content(array('overflowdiv' => true, 'noclean' => true)),
1939         $cm->get_formatted_name());
1942 /**
1943  * Prints the menus to add activities and resources.
1944  *
1945  * Deprecated. Please use:
1946  * $courserenderer = $PAGE->get_renderer('core', 'course');
1947  * $output = $courserenderer->course_section_add_cm_control($course, $section, $sectionreturn,
1948  *    array('inblock' => $vertical));
1949  * echo $output; // if $return argument in print_section_add_menus() set to false
1950  *
1951  * @deprecated since 2.5
1952  * @see core_course_renderer::course_section_add_cm_control()
1953  *
1954  * @param stdClass $course course object, must be the same as set on the page
1955  * @param int $section relative section number (field course_sections.section)
1956  * @param null|array $modnames (argument ignored) get_module_types_names() is used instead of argument
1957  * @param bool $vertical Vertical orientation
1958  * @param bool $return Return the menus or send them to output
1959  * @param int $sectionreturn The section to link back to
1960  * @return void|string depending on $return
1961  */
1962 function print_section_add_menus($course, $section, $modnames = null, $vertical=false, $return=false, $sectionreturn=null) {
1963     global $PAGE;
1964     debugging('Function print_section_add_menus() is deprecated. Please use course renderer '.
1965             'function course_section_add_cm_control()', DEBUG_DEVELOPER);
1966     $output = '';
1967     $courserenderer = $PAGE->get_renderer('core', 'course');
1968     $output = $courserenderer->course_section_add_cm_control($course, $section, $sectionreturn,
1969             array('inblock' => $vertical));
1970     if ($return) {
1971         return $output;
1972     } else {
1973         echo $output;
1974         return !empty($output);
1975     }
1978 /**
1979  * Produces the editing buttons for a module
1980  *
1981  * Deprecated. Please use:
1982  * $courserenderer = $PAGE->get_renderer('core', 'course');
1983  * $actions = course_get_cm_edit_actions($mod, $indent, $section);
1984  * return ' ' . $courserenderer->course_section_cm_edit_actions($actions);
1985  *
1986  * @deprecated since 2.5
1987  * @see course_get_cm_edit_actions()
1988  * @see core_course_renderer->course_section_cm_edit_actions()
1989  *
1990  * @param stdClass $mod The module to produce editing buttons for
1991  * @param bool $absolute_ignored (argument ignored) - all links are absolute
1992  * @param bool $moveselect (argument ignored)
1993  * @param int $indent The current indenting
1994  * @param int $section The section to link back to
1995  * @return string XHTML for the editing buttons
1996  */
1997 function make_editing_buttons(stdClass $mod, $absolute_ignored = true, $moveselect = true, $indent=-1, $section=null) {
1998     global $PAGE;
1999     debugging('Function make_editing_buttons() is deprecated, please see PHPdocs in '.
2000             'lib/deprecatedlib.php on how to replace it', DEBUG_DEVELOPER);
2001     if (!($mod instanceof cm_info)) {
2002         $modinfo = get_fast_modinfo($mod->course);
2003         $mod = $modinfo->get_cm($mod->id);
2004     }
2005     $actions = course_get_cm_edit_actions($mod, $indent, $section);
2007     $courserenderer = $PAGE->get_renderer('core', 'course');
2008     // The space added before the <span> is a ugly hack but required to set the CSS property white-space: nowrap
2009     // and having it to work without attaching the preceding text along with it. Hopefully the refactoring of
2010     // the course page HTML will allow this to be removed.
2011     return ' ' . $courserenderer->course_section_cm_edit_actions($actions);
2014 /**
2015  * Prints a section full of activity modules
2016  *
2017  * Deprecated. Please use:
2018  * $courserenderer = $PAGE->get_renderer('core', 'course');
2019  * echo $courserenderer->course_section_cm_list($course, $section, $sectionreturn,
2020  *     array('hidecompletion' => $hidecompletion));
2021  *
2022  * @deprecated since 2.5
2023  * @see core_course_renderer::course_section_cm_list()
2024  *
2025  * @param stdClass $course The course
2026  * @param stdClass|section_info $section The section object containing properties id and section
2027  * @param array $mods (argument not used)
2028  * @param array $modnamesused (argument not used)
2029  * @param bool $absolute (argument not used)
2030  * @param string $width (argument not used)
2031  * @param bool $hidecompletion Hide completion status
2032  * @param int $sectionreturn The section to return to
2033  * @return void
2034  */
2035 function print_section($course, $section, $mods, $modnamesused, $absolute=false, $width="100%", $hidecompletion=false, $sectionreturn=null) {
2036     global $PAGE;
2037     debugging('Function print_section() is deprecated. Please use course renderer function '.
2038             'course_section_cm_list() instead.', DEBUG_DEVELOPER);
2039     $displayoptions = array('hidecompletion' => $hidecompletion);
2040     $courserenderer = $PAGE->get_renderer('core', 'course');
2041     echo $courserenderer->course_section_cm_list($course, $section, $sectionreturn, $displayoptions);
2044 /**
2045  * Displays the list of courses with user notes
2046  *
2047  * This function is not used in core. It was replaced by block course_overview
2048  *
2049  * @deprecated since 2.5
2050  *
2051  * @param array $courses
2052  * @param array $remote_courses
2053  */
2054 function print_overview($courses, array $remote_courses=array()) {
2055     global $CFG, $USER, $DB, $OUTPUT;
2056     debugging('Function print_overview() is deprecated. Use block course_overview to display this information', DEBUG_DEVELOPER);
2058     $htmlarray = array();
2059     if ($modules = $DB->get_records('modules')) {
2060         foreach ($modules as $mod) {
2061             if (file_exists(dirname(dirname(__FILE__)).'/mod/'.$mod->name.'/lib.php')) {
2062                 include_once(dirname(dirname(__FILE__)).'/mod/'.$mod->name.'/lib.php');
2063                 $fname = $mod->name.'_print_overview';
2064                 if (function_exists($fname)) {
2065                     $fname($courses,$htmlarray);
2066                 }
2067             }
2068         }
2069     }
2070     foreach ($courses as $course) {
2071         $fullname = format_string($course->fullname, true, array('context' => context_course::instance($course->id)));
2072         echo $OUTPUT->box_start('coursebox');
2073         $attributes = array('title' => s($fullname));
2074         if (empty($course->visible)) {
2075             $attributes['class'] = 'dimmed';
2076         }
2077         echo $OUTPUT->heading(html_writer::link(
2078             new moodle_url('/course/view.php', array('id' => $course->id)), $fullname, $attributes), 3);
2079         if (array_key_exists($course->id,$htmlarray)) {
2080             foreach ($htmlarray[$course->id] as $modname => $html) {
2081                 echo $html;
2082             }
2083         }
2084         echo $OUTPUT->box_end();
2085     }
2087     if (!empty($remote_courses)) {
2088         echo $OUTPUT->heading(get_string('remotecourses', 'mnet'));
2089     }
2090     foreach ($remote_courses as $course) {
2091         echo $OUTPUT->box_start('coursebox');
2092         $attributes = array('title' => s($course->fullname));
2093         echo $OUTPUT->heading(html_writer::link(
2094             new moodle_url('/auth/mnet/jump.php', array('hostid' => $course->hostid, 'wantsurl' => '/course/view.php?id='.$course->remoteid)),
2095             format_string($course->shortname),
2096             $attributes) . ' (' . format_string($course->hostname) . ')', 3);
2097         echo $OUTPUT->box_end();
2098     }
2101 /**
2102  * This function trawls through the logs looking for
2103  * anything new since the user's last login
2104  *
2105  * This function was only used to print the content of block recent_activity
2106  * All functionality is moved into class {@link block_recent_activity}
2107  * and renderer {@link block_recent_activity_renderer}
2108  *
2109  * @deprecated since 2.5
2110  * @param stdClass $course
2111  */
2112 function print_recent_activity($course) {
2113     // $course is an object
2114     global $CFG, $USER, $SESSION, $DB, $OUTPUT;
2115     debugging('Function print_recent_activity() is deprecated. It is not recommended to'.
2116             ' use it outside of block_recent_activity', DEBUG_DEVELOPER);
2118     $context = context_course::instance($course->id);
2120     $viewfullnames = has_capability('moodle/site:viewfullnames', $context);
2122     $timestart = round(time() - COURSE_MAX_RECENT_PERIOD, -2); // better db caching for guests - 100 seconds
2124     if (!isguestuser()) {
2125         if (!empty($USER->lastcourseaccess[$course->id])) {
2126             if ($USER->lastcourseaccess[$course->id] > $timestart) {
2127                 $timestart = $USER->lastcourseaccess[$course->id];
2128             }
2129         }
2130     }
2132     echo '<div class="activitydate">';
2133     echo get_string('activitysince', '', userdate($timestart));
2134     echo '</div>';
2135     echo '<div class="activityhead">';
2137     echo '<a href="'.$CFG->wwwroot.'/course/recent.php?id='.$course->id.'">'.get_string('recentactivityreport').'</a>';
2139     echo "</div>\n";
2141     $content = false;
2143 /// Firstly, have there been any new enrolments?
2145     $users = get_recent_enrolments($course->id, $timestart);
2147     //Accessibility: new users now appear in an <OL> list.
2148     if ($users) {
2149         echo '<div class="newusers">';
2150         echo $OUTPUT->heading(get_string("newusers").':', 3);
2151         $content = true;
2152         echo "<ol class=\"list\">\n";
2153         foreach ($users as $user) {
2154             $fullname = fullname($user, $viewfullnames);
2155             echo '<li class="name"><a href="'."$CFG->wwwroot/user/view.php?id=$user->id&amp;course=$course->id\">$fullname</a></li>\n";
2156         }
2157         echo "</ol>\n</div>\n";
2158     }
2160 /// Next, have there been any modifications to the course structure?
2162     $modinfo = get_fast_modinfo($course);
2164     $changelist = array();
2166     $logs = $DB->get_records_select('log', "time > ? AND course = ? AND
2167                                             module = 'course' AND
2168                                             (action = 'add mod' OR action = 'update mod' OR action = 'delete mod')",
2169                                     array($timestart, $course->id), "id ASC");
2171     if ($logs) {
2172         $actions  = array('add mod', 'update mod', 'delete mod');
2173         $newgones = array(); // added and later deleted items
2174         foreach ($logs as $key => $log) {
2175             if (!in_array($log->action, $actions)) {
2176                 continue;
2177             }
2178             $info = explode(' ', $log->info);
2180             // note: in most cases I replaced hardcoding of label with use of
2181             // $cm->has_view() but it was not possible to do this here because
2182             // we don't necessarily have the $cm for it
2183             if ($info[0] == 'label') {     // Labels are ignored in recent activity
2184                 continue;
2185             }
2187             if (count($info) != 2) {
2188                 debugging("Incorrect log entry info: id = ".$log->id, DEBUG_DEVELOPER);
2189                 continue;
2190             }
2192             $modname    = $info[0];
2193             $instanceid = $info[1];
2195             if ($log->action == 'delete mod') {
2196                 // unfortunately we do not know if the mod was visible
2197                 if (!array_key_exists($log->info, $newgones)) {
2198                     $strdeleted = get_string('deletedactivity', 'moodle', get_string('modulename', $modname));
2199                     $changelist[$log->info] = array ('operation' => 'delete', 'text' => $strdeleted);
2200                 }
2201             } else {
2202                 if (!isset($modinfo->instances[$modname][$instanceid])) {
2203                     if ($log->action == 'add mod') {
2204                         // do not display added and later deleted activities
2205                         $newgones[$log->info] = true;
2206                     }
2207                     continue;
2208                 }
2209                 $cm = $modinfo->instances[$modname][$instanceid];
2210                 if (!$cm->uservisible) {
2211                     continue;
2212                 }
2214                 if ($log->action == 'add mod') {
2215                     $stradded = get_string('added', 'moodle', get_string('modulename', $modname));
2216                     $changelist[$log->info] = array('operation' => 'add', 'text' => "$stradded:<br /><a href=\"$CFG->wwwroot/mod/$cm->modname/view.php?id={$cm->id}\">".format_string($cm->name, true)."</a>");
2218                 } else if ($log->action == 'update mod' and empty($changelist[$log->info])) {
2219                     $strupdated = get_string('updated', 'moodle', get_string('modulename', $modname));
2220                     $changelist[$log->info] = array('operation' => 'update', 'text' => "$strupdated:<br /><a href=\"$CFG->wwwroot/mod/$cm->modname/view.php?id={$cm->id}\">".format_string($cm->name, true)."</a>");
2221                 }
2222             }
2223         }
2224     }
2226     if (!empty($changelist)) {
2227         echo $OUTPUT->heading(get_string("courseupdates").':', 3);
2228         $content = true;
2229         foreach ($changelist as $changeinfo => $change) {
2230             echo '<p class="activity">'.$change['text'].'</p>';
2231         }
2232     }
2234 /// Now display new things from each module
2236     $usedmodules = array();
2237     foreach($modinfo->cms as $cm) {
2238         if (isset($usedmodules[$cm->modname])) {
2239             continue;
2240         }
2241         if (!$cm->uservisible) {
2242             continue;
2243         }
2244         $usedmodules[$cm->modname] = $cm->modname;
2245     }
2247     foreach ($usedmodules as $modname) {      // Each module gets it's own logs and prints them
2248         if (file_exists($CFG->dirroot.'/mod/'.$modname.'/lib.php')) {
2249             include_once($CFG->dirroot.'/mod/'.$modname.'/lib.php');
2250             $print_recent_activity = $modname.'_print_recent_activity';
2251             if (function_exists($print_recent_activity)) {
2252                 // NOTE: original $isteacher (second parameter below) was replaced with $viewfullnames!
2253                 $content = $print_recent_activity($course, $viewfullnames, $timestart) || $content;
2254             }
2255         } else {
2256             debugging("Missing lib.php in lib/{$modname} - please reinstall files or uninstall the module");
2257         }
2258     }
2260     if (! $content) {
2261         echo '<p class="message">'.get_string('nothingnew').'</p>';
2262     }
2265 /**
2266  * Delete a course module and any associated data at the course level (events)
2267  * Until 1.5 this function simply marked a deleted flag ... now it
2268  * deletes it completely.
2269  *
2270  * @deprecated since 2.5
2271  *
2272  * @param int $id the course module id
2273  * @return boolean true on success, false on failure
2274  */
2275 function delete_course_module($id) {
2276     debugging('Function delete_course_module() is deprecated. Please use course_delete_module() instead.', DEBUG_DEVELOPER);
2278     global $CFG, $DB;
2280     require_once($CFG->libdir.'/gradelib.php');
2281     require_once($CFG->dirroot.'/blog/lib.php');
2283     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
2284         return true;
2285     }
2286     $modulename = $DB->get_field('modules', 'name', array('id'=>$cm->module));
2287     //delete events from calendar
2288     if ($events = $DB->get_records('event', array('instance'=>$cm->instance, 'modulename'=>$modulename))) {
2289         foreach($events as $event) {
2290             delete_event($event->id);
2291         }
2292     }
2293     //delete grade items, outcome items and grades attached to modules
2294     if ($grade_items = grade_item::fetch_all(array('itemtype'=>'mod', 'itemmodule'=>$modulename,
2295                                                    'iteminstance'=>$cm->instance, 'courseid'=>$cm->course))) {
2296         foreach ($grade_items as $grade_item) {
2297             $grade_item->delete('moddelete');
2298         }
2299     }
2300     // Delete completion and availability data; it is better to do this even if the
2301     // features are not turned on, in case they were turned on previously (these will be
2302     // very quick on an empty table)
2303     $DB->delete_records('course_modules_completion', array('coursemoduleid' => $cm->id));
2304     $DB->delete_records('course_modules_availability', array('coursemoduleid'=> $cm->id));
2305     $DB->delete_records('course_completion_criteria', array('moduleinstance' => $cm->id,
2306                                                             'criteriatype' => COMPLETION_CRITERIA_TYPE_ACTIVITY));
2308     delete_context(CONTEXT_MODULE, $cm->id);
2309     return $DB->delete_records('course_modules', array('id'=>$cm->id));
2312 /**
2313  * Prints the turn editing on/off button on course/index.php or course/category.php.
2314  *
2315  * @deprecated since 2.5
2316  *
2317  * @param integer $categoryid The id of the category we are showing, or 0 for system context.
2318  * @return string HTML of the editing button, or empty string, if this user is not allowed
2319  *      to see it.
2320  */
2321 function update_category_button($categoryid = 0) {
2322     global $CFG, $PAGE, $OUTPUT;
2323     debugging('Function update_category_button() is deprecated. Pages to view '.
2324             'and edit courses are now separate and no longer depend on editing mode.',
2325             DEBUG_DEVELOPER);
2327     // Check permissions.
2328     if (!can_edit_in_category($categoryid)) {
2329         return '';
2330     }
2332     // Work out the appropriate action.
2333     if ($PAGE->user_is_editing()) {
2334         $label = get_string('turneditingoff');
2335         $edit = 'off';
2336     } else {
2337         $label = get_string('turneditingon');
2338         $edit = 'on';
2339     }
2341     // Generate the button HTML.
2342     $options = array('categoryedit' => $edit, 'sesskey' => sesskey());
2343     if ($categoryid) {
2344         $options['id'] = $categoryid;
2345         $page = 'category.php';
2346     } else {
2347         $page = 'index.php';
2348     }
2349     return $OUTPUT->single_button(new moodle_url('/course/' . $page, $options), $label, 'get');
2352 /**
2353  * This function recursively travels the categories, building up a nice list
2354  * for display. It also makes an array that list all the parents for each
2355  * category.
2356  *
2357  * For example, if you have a tree of categories like:
2358  *   Miscellaneous (id = 1)
2359  *      Subcategory (id = 2)
2360  *         Sub-subcategory (id = 4)
2361  *   Other category (id = 3)
2362  * Then after calling this function you will have
2363  * $list = array(1 => 'Miscellaneous', 2 => 'Miscellaneous / Subcategory',
2364  *      4 => 'Miscellaneous / Subcategory / Sub-subcategory',
2365  *      3 => 'Other category');
2366  * $parents = array(2 => array(1), 4 => array(1, 2));
2367  *
2368  * If you specify $requiredcapability, then only categories where the current
2369  * user has that capability will be added to $list, although all categories
2370  * will still be added to $parents, and if you only have $requiredcapability
2371  * in a child category, not the parent, then the child catgegory will still be
2372  * included.
2373  *
2374  * If you specify the option $excluded, then that category, and all its children,
2375  * are omitted from the tree. This is useful when you are doing something like
2376  * moving categories, where you do not want to allow people to move a category
2377  * to be the child of itself.
2378  *
2379  * This function is deprecated! For list of categories use
2380  * coursecat::make_all_categories($requiredcapability, $excludeid, $separator)
2381  * For parents of one particular category use
2382  * coursecat::get($id)->get_parents()
2383  *
2384  * @deprecated since 2.5
2385  *
2386  * @param array $list For output, accumulates an array categoryid => full category path name
2387  * @param array $parents For output, accumulates an array categoryid => list of parent category ids.
2388  * @param string/array $requiredcapability if given, only categories where the current
2389  *      user has this capability will be added to $list. Can also be an array of capabilities,
2390  *      in which case they are all required.
2391  * @param integer $excludeid Omit this category and its children from the lists built.
2392  * @param object $category Not used
2393  * @param string $path Not used
2394  */
2395 function make_categories_list(&$list, &$parents, $requiredcapability = '',
2396         $excludeid = 0, $category = NULL, $path = "") {
2397     global $CFG, $DB;
2398     require_once($CFG->libdir.'/coursecatlib.php');
2400     debugging('Global function make_categories_list() is deprecated. Please use '.
2401             'coursecat::make_categories_list() and coursecat::get_parents()',
2402             DEBUG_DEVELOPER);
2404     // For categories list use just this one function:
2405     if (empty($list)) {
2406         $list = array();
2407     }
2408     $list += coursecat::make_categories_list($requiredcapability, $excludeid);
2410     // Building the list of all parents of all categories in the system is highly undesirable and hardly ever needed.
2411     // Usually user needs only parents for one particular category, in which case should be used:
2412     // coursecat::get($categoryid)->get_parents()
2413     if (empty($parents)) {
2414         $parents = array();
2415     }
2416     $all = $DB->get_records_sql('SELECT id, parent FROM {course_categories} ORDER BY sortorder');
2417     foreach ($all as $record) {
2418         if ($record->parent) {
2419             $parents[$record->id] = array_merge($parents[$record->parent], array($record->parent));
2420         } else {
2421             $parents[$record->id] = array();
2422         }
2423     }
2426 /**
2427  * Delete category, but move contents to another category.
2428  *
2429  * This function is deprecated. Please use
2430  * coursecat::get($category->id)->delete_move($newparentid, $showfeedback);
2431  *
2432  * @see coursecat::delete_move()
2433  * @deprecated since 2.5
2434  *
2435  * @param object $category
2436  * @param int $newparentid category id
2437  * @return bool status
2438  */
2439 function category_delete_move($category, $newparentid, $showfeedback=true) {
2440     global $CFG;
2441     require_once($CFG->libdir.'/coursecatlib.php');
2443     debugging('Function category_delete_move() is deprecated. Please use coursecat::delete_move() instead.');
2445     return coursecat::get($category->id)->delete_move($newparentid, $showfeedback);
2448 /**
2449  * Recursively delete category including all subcategories and courses.
2450  *
2451  * This function is deprecated. Please use
2452  * coursecat::get($category->id)->delete_full($showfeedback);
2453  *
2454  * @see coursecat::delete_full()
2455  * @deprecated since 2.5
2456  *
2457  * @param stdClass $category
2458  * @param boolean $showfeedback display some notices
2459  * @return array return deleted courses
2460  */
2461 function category_delete_full($category, $showfeedback=true) {
2462     global $CFG, $DB;
2463     require_once($CFG->libdir.'/coursecatlib.php');
2465     debugging('Function category_delete_full() is deprecated. Please use coursecat::delete_full() instead.');
2467     return coursecat::get($category->id)->delete_full($showfeedback);
2470 /**
2471  * Efficiently moves a category - NOTE that this can have
2472  * a huge impact access-control-wise...
2473  *
2474  * This function is deprecated. Please use
2475  * $coursecat = coursecat::get($category->id);
2476  * if ($coursecat->can_change_parent($newparentcat->id)) {
2477  *     $coursecat->change_parent($newparentcat->id);
2478  * }
2479  *
2480  * Alternatively you can use
2481  * $coursecat->update(array('parent' => $newparentcat->id));
2482  *
2483  * Function update() also updates field course_categories.timemodified
2484  *
2485  * @see coursecat::change_parent()
2486  * @see coursecat::update()
2487  * @deprecated since 2.5
2488  *
2489  * @param stdClass|coursecat $category
2490  * @param stdClass|coursecat $newparentcat
2491  */
2492 function move_category($category, $newparentcat) {
2493     global $CFG;
2494     require_once($CFG->libdir.'/coursecatlib.php');
2496     debugging('Function move_category() is deprecated. Please use coursecat::change_parent() instead.');
2498     return coursecat::get($category->id)->change_parent($newparentcat->id);
2501 /**
2502  * Hide course category and child course and subcategories
2503  *
2504  * This function is deprecated. Please use
2505  * coursecat::get($category->id)->hide();
2506  *
2507  * @see coursecat::hide()
2508  * @deprecated since 2.5
2509  *
2510  * @param stdClass $category
2511  * @return void
2512  */
2513 function course_category_hide($category) {
2514     global $CFG;
2515     require_once($CFG->libdir.'/coursecatlib.php');
2517     debugging('Function course_category_hide() is deprecated. Please use coursecat::hide() instead.');
2519     coursecat::get($category->id)->hide();
2522 /**
2523  * Show course category and child course and subcategories
2524  *
2525  * This function is deprecated. Please use
2526  * coursecat::get($category->id)->show();
2527  *
2528  * @see coursecat::show()
2529  * @deprecated since 2.5
2530  *
2531  * @param stdClass $category
2532  * @return void
2533  */
2534 function course_category_show($category) {
2535     global $CFG;
2536     require_once($CFG->libdir.'/coursecatlib.php');
2538     debugging('Function course_category_show() is deprecated. Please use coursecat::show() instead.');
2540     coursecat::get($category->id)->show();
2543 /**
2544  * Return specified category, default if given does not exist
2545  *
2546  * This function is deprecated.
2547  * To get the category with the specified it please use:
2548  * coursecat::get($catid, IGNORE_MISSING);
2549  * or
2550  * coursecat::get($catid, MUST_EXIST);
2551  *
2552  * To get the first available category please use
2553  * coursecat::get_default();
2554  *
2555  * class coursecat will also make sure that at least one category exists in DB
2556  *
2557  * @deprecated since 2.5
2558  * @see coursecat::get()
2559  * @see coursecat::get_default()
2560  *
2561  * @param int $catid course category id
2562  * @return object caregory
2563  */
2564 function get_course_category($catid=0) {
2565     global $DB;
2567     debugging('Function get_course_category() is deprecated. Please use coursecat::get(), see phpdocs for more details');
2569     $category = false;
2571     if (!empty($catid)) {
2572         $category = $DB->get_record('course_categories', array('id'=>$catid));
2573     }
2575     if (!$category) {
2576         // the first category is considered default for now
2577         if ($category = $DB->get_records('course_categories', null, 'sortorder', '*', 0, 1)) {
2578             $category = reset($category);
2580         } else {
2581             $cat = new stdClass();
2582             $cat->name         = get_string('miscellaneous');
2583             $cat->depth        = 1;
2584             $cat->sortorder    = MAX_COURSES_IN_CATEGORY;
2585             $cat->timemodified = time();
2586             $catid = $DB->insert_record('course_categories', $cat);
2587             // make sure category context exists
2588             context_coursecat::instance($catid);
2589             mark_context_dirty('/'.SYSCONTEXTID);
2590             fix_course_sortorder(); // Required to build course_categories.depth and .path.
2591             $category = $DB->get_record('course_categories', array('id'=>$catid));
2592         }
2593     }
2595     return $category;
2598 /**
2599  * Create a new course category and marks the context as dirty
2600  *
2601  * This function does not set the sortorder for the new category and
2602  * {@link fix_course_sortorder()} should be called after creating a new course
2603  * category
2604  *
2605  * Please note that this function does not verify access control.
2606  *
2607  * This function is deprecated. It is replaced with the method create() in class coursecat.
2608  * {@link coursecat::create()} also verifies the data, fixes sortorder and logs the action
2609  *
2610  * @deprecated since 2.5
2611  *
2612  * @param object $category All of the data required for an entry in the course_categories table
2613  * @return object new course category
2614  */
2615 function create_course_category($category) {
2616     global $DB;
2618     debugging('Function create_course_category() is deprecated. Please use coursecat::create(), see phpdocs for more details', DEBUG_DEVELOPER);
2620     $category->timemodified = time();
2621     $category->id = $DB->insert_record('course_categories', $category);
2622     $category = $DB->get_record('course_categories', array('id' => $category->id));
2624     // We should mark the context as dirty
2625     $category->context = context_coursecat::instance($category->id);
2626     $category->context->mark_dirty();
2628     return $category;
2631 /**
2632  * Returns an array of category ids of all the subcategories for a given
2633  * category.
2634  *
2635  * This function is deprecated.
2636  *
2637  * To get visible children categories of the given category use:
2638  * coursecat::get($categoryid)->get_children();
2639  * This function will return the array or coursecat objects, on each of them
2640  * you can call get_children() again
2641  *
2642  * @see coursecat::get()
2643  * @see coursecat::get_children()
2644  *
2645  * @deprecated since 2.5
2646  *
2647  * @global object
2648  * @param int $catid - The id of the category whose subcategories we want to find.
2649  * @return array of category ids.
2650  */
2651 function get_all_subcategories($catid) {
2652     global $DB;
2654     debugging('Function get_all_subcategories() is deprecated. Please use appropriate methods() of coursecat class. See phpdocs for more details',
2655             DEBUG_DEVELOPER);
2657     $subcats = array();
2659     if ($categories = $DB->get_records('course_categories', array('parent' => $catid))) {
2660         foreach ($categories as $cat) {
2661             array_push($subcats, $cat->id);
2662             $subcats = array_merge($subcats, get_all_subcategories($cat->id));
2663         }
2664     }
2665     return $subcats;
2668 /**
2669  * Gets the child categories of a given courses category
2670  *
2671  * This function is deprecated. Please use functions in class coursecat:
2672  * - coursecat::get($parentid)->has_children()
2673  * tells if the category has children (visible or not to the current user)
2674  *
2675  * - coursecat::get($parentid)->get_children()
2676  * returns an array of coursecat objects, each of them represents a children category visible
2677  * to the current user (i.e. visible=1 or user has capability to view hidden categories)
2678  *
2679  * - coursecat::get($parentid)->get_children_count()
2680  * returns number of children categories visible to the current user
2681  *
2682  * - coursecat::count_all()
2683  * returns total count of all categories in the system (both visible and not)
2684  *
2685  * - coursecat::get_default()
2686  * returns the first category (usually to be used if count_all() == 1)
2687  *
2688  * @deprecated since 2.5
2689  *
2690  * @param int $parentid the id of a course category.
2691  * @return array all the child course categories.
2692  */
2693 function get_child_categories($parentid) {
2694     global $DB;
2695     debugging('Function get_child_categories() is deprecated. Use coursecat::get_children() or see phpdocs for more details.',
2696             DEBUG_DEVELOPER);
2698     $rv = array();
2699     $sql = context_helper::get_preload_record_columns_sql('ctx');
2700     $records = $DB->get_records_sql("SELECT c.*, $sql FROM {course_categories} c ".
2701             "JOIN {context} ctx on ctx.instanceid = c.id AND ctx.contextlevel = ? WHERE c.parent = ? ORDER BY c.sortorder",
2702             array(CONTEXT_COURSECAT, $parentid));
2703     foreach ($records as $category) {
2704         context_helper::preload_from_record($category);
2705         if (!$category->visible && !has_capability('moodle/category:viewhiddencategories', context_coursecat::instance($category->id))) {
2706             continue;
2707         }
2708         $rv[] = $category;
2709     }
2710     return $rv;
2713 /**
2714  * Returns a sorted list of categories.
2715  *
2716  * When asking for $parent='none' it will return all the categories, regardless
2717  * of depth. Wheen asking for a specific parent, the default is to return
2718  * a "shallow" resultset. Pass false to $shallow and it will return all
2719  * the child categories as well.
2720  *
2721  * @deprecated since 2.5
2722  *
2723  * This function is deprecated. Use appropriate functions from class coursecat.
2724  * Examples:
2725  *
2726  * coursecat::get($categoryid)->get_children()
2727  * - returns all children of the specified category as instances of class
2728  * coursecat, which means on each of them method get_children() can be called again.
2729  * Only categories visible to the current user are returned.
2730  *
2731  * coursecat::get(0)->get_children()
2732  * - returns all top-level categories visible to the current user.
2733  *
2734  * Sort fields can be specified, see phpdocs to {@link coursecat::get_children()}
2735  *
2736  * coursecat::make_categories_list()
2737  * - returns an array of all categories id/names in the system.
2738  * Also only returns categories visible to current user and can additionally be
2739  * filetered by capability, see phpdocs to {@link coursecat::make_categories_list()}
2740  *
2741  * make_categories_options()
2742  * - Returns full course categories tree to be used in html_writer::select()
2743  *
2744  * Also see functions {@link coursecat::get_children_count()}, {@link coursecat::count_all()},
2745  * {@link coursecat::get_default()}
2746  *
2747  * The code of this deprecated function is left as it is because coursecat::get_children()
2748  * returns categories as instances of coursecat and not stdClass. Also there is no
2749  * substitute for retrieving the category with all it's subcategories. Plugin developers
2750  * may re-use the code/queries from this function in their plugins if really necessary.
2751  *
2752  * @param string $parent The parent category if any
2753  * @param string $sort the sortorder
2754  * @param bool   $shallow - set to false to get the children too
2755  * @return array of categories
2756  */
2757 function get_categories($parent='none', $sort=NULL, $shallow=true) {
2758     global $DB;
2760     debugging('Function get_categories() is deprecated. Please use coursecat::get_children() or see phpdocs for other alternatives',
2761             DEBUG_DEVELOPER);
2763     if ($sort === NULL) {
2764         $sort = 'ORDER BY cc.sortorder ASC';
2765     } elseif ($sort ==='') {
2766         // leave it as empty
2767     } else {
2768         $sort = "ORDER BY $sort";
2769     }
2771     list($ccselect, $ccjoin) = context_instance_preload_sql('cc.id', CONTEXT_COURSECAT, 'ctx');
2773     if ($parent === 'none') {
2774         $sql = "SELECT cc.* $ccselect
2775                   FROM {course_categories} cc
2776                $ccjoin
2777                 $sort";
2778         $params = array();
2780     } elseif ($shallow) {
2781         $sql = "SELECT cc.* $ccselect
2782                   FROM {course_categories} cc
2783                $ccjoin
2784                  WHERE cc.parent=?
2785                 $sort";
2786         $params = array($parent);
2788     } else {
2789         $sql = "SELECT cc.* $ccselect
2790                   FROM {course_categories} cc
2791                $ccjoin
2792                   JOIN {course_categories} ccp
2793                        ON ((cc.parent = ccp.id) OR (cc.path LIKE ".$DB->sql_concat('ccp.path',"'/%'")."))
2794                  WHERE ccp.id=?
2795                 $sort";
2796         $params = array($parent);
2797     }
2798     $categories = array();
2800     $rs = $DB->get_recordset_sql($sql, $params);
2801     foreach($rs as $cat) {
2802         context_helper::preload_from_record($cat);
2803         $catcontext = context_coursecat::instance($cat->id);
2804         if ($cat->visible || has_capability('moodle/category:viewhiddencategories', $catcontext)) {
2805             $categories[$cat->id] = $cat;
2806         }
2807     }
2808     $rs->close();
2809     return $categories;
2812 /**
2813 * Displays a course search form
2815 * This function is deprecated, please use course renderer:
2816 * $renderer = $PAGE->get_renderer('core', 'course');
2817 * echo $renderer->course_search_form($value, $format);
2819 * @deprecated since 2.5
2821 * @param string $value default value to populate the search field
2822 * @param bool $return if true returns the value, if false - outputs
2823 * @param string $format display format - 'plain' (default), 'short' or 'navbar'
2824 * @return null|string
2825 */
2826 function print_course_search($value="", $return=false, $format="plain") {
2827     global $PAGE;
2828     debugging('Function print_course_search() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2829     $renderer = $PAGE->get_renderer('core', 'course');
2830     if ($return) {
2831         return $renderer->course_search_form($value, $format);
2832     } else {
2833         echo $renderer->course_search_form($value, $format);
2834     }
2837 /**
2838  * Prints custom user information on the home page
2839  *
2840  * This function is deprecated, please use:
2841  * $renderer = $PAGE->get_renderer('core', 'course');
2842  * echo $renderer->frontpage_my_courses()
2843  *
2844  * @deprecated since 2.5
2845  */
2846 function print_my_moodle() {
2847     global $PAGE;
2848     debugging('Function print_my_moodle() is deprecated, please use course renderer function frontpage_my_courses()', DEBUG_DEVELOPER);
2850     $renderer = $PAGE->get_renderer('core', 'course');
2851     echo $renderer->frontpage_my_courses();
2854 /**
2855  * Prints information about one remote course
2856  *
2857  * This function is deprecated, it is replaced with protected function
2858  * {@link core_course_renderer::frontpage_remote_course()}
2859  * It is only used from function {@link core_course_renderer::frontpage_my_courses()}
2860  *
2861  * @deprecated since 2.5
2862  */
2863 function print_remote_course($course, $width="100%") {
2864     global $CFG, $USER;
2865     debugging('Function print_remote_course() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2867     $linkcss = '';
2869     $url = "{$CFG->wwwroot}/auth/mnet/jump.php?hostid={$course->hostid}&amp;wantsurl=/course/view.php?id={$course->remoteid}";
2871     echo '<div class="coursebox remotecoursebox clearfix">';
2872     echo '<div class="info">';
2873     echo '<div class="name"><a title="'.get_string('entercourse').'"'.
2874          $linkcss.' href="'.$url.'">'
2875         .  format_string($course->fullname) .'</a><br />'
2876         . format_string($course->hostname) . ' : '
2877         . format_string($course->cat_name) . ' : '
2878         . format_string($course->shortname). '</div>';
2879     echo '</div><div class="summary">';
2880     $options = new stdClass();
2881     $options->noclean = true;
2882     $options->para = false;
2883     $options->overflowdiv = true;
2884     echo format_text($course->summary, $course->summaryformat, $options);
2885     echo '</div>';
2886     echo '</div>';
2889 /**
2890  * Prints information about one remote host
2891  *
2892  * This function is deprecated, it is replaced with protected function
2893  * {@link core_course_renderer::frontpage_remote_host()}
2894  * It is only used from function {@link core_course_renderer::frontpage_my_courses()}
2895  *
2896  * @deprecated since 2.5
2897  */
2898 function print_remote_host($host, $width="100%") {
2899     global $OUTPUT;
2900     debugging('Function print_remote_host() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2902     $linkcss = '';
2904     echo '<div class="coursebox clearfix">';
2905     echo '<div class="info">';
2906     echo '<div class="name">';
2907     echo '<img src="'.$OUTPUT->pix_url('i/mnethost') . '" class="icon" alt="'.get_string('course').'" />';
2908     echo '<a title="'.s($host['name']).'" href="'.s($host['url']).'">'
2909         . s($host['name']).'</a> - ';
2910     echo $host['count'] . ' ' . get_string('courses');
2911     echo '</div>';
2912     echo '</div>';
2913     echo '</div>';
2916 /**
2917  * Recursive function to print out all the categories in a nice format
2918  * with or without courses included
2919  *
2920  * @deprecated since 2.5
2921  *
2922  * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5
2923  */
2924 function print_whole_category_list($category=NULL, $displaylist=NULL, $parentslist=NULL, $depth=-1, $showcourses = true, $categorycourses=NULL) {
2925     global $PAGE;
2926     debugging('Function print_whole_category_list() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2928     $renderer = $PAGE->get_renderer('core', 'course');
2929     if ($showcourses && $category) {
2930         echo $renderer->course_category($category);
2931     } else if ($showcourses) {
2932         echo $renderer->frontpage_combo_list();
2933     } else {
2934         echo $renderer->frontpage_categories_list();
2935     }
2938 /**
2939  * Prints the category information.
2940  *
2941  * @deprecated since 2.5
2942  *
2943  * This function was only used by {@link print_whole_category_list()} but now
2944  * all course category rendering is moved to core_course_renderer.
2945  *
2946  * @param stdClass $category
2947  * @param int $depth The depth of the category.
2948  * @param bool $showcourses If set to true course information will also be printed.
2949  * @param array|null $courses An array of courses belonging to the category, or null if you don't have it yet.
2950  */
2951 function print_category_info($category, $depth = 0, $showcourses = false, array $courses = null) {
2952     global $PAGE;
2953     debugging('Function print_category_info() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2955     $renderer = $PAGE->get_renderer('core', 'course');
2956     echo $renderer->course_category($category);
2959 /**
2960  * This function generates a structured array of courses and categories.
2961  *
2962  * @deprecated since 2.5
2963  *
2964  * This function is not used any more in moodle core and course renderer does not have render function for it.
2965  * Combo list on the front page is displayed as:
2966  * $renderer = $PAGE->get_renderer('core', 'course');
2967  * echo $renderer->frontpage_combo_list()
2968  *
2969  * The new class {@link coursecat} stores the information about course category tree
2970  * To get children categories use:
2971  * coursecat::get($id)->get_children()
2972  * To get list of courses use:
2973  * coursecat::get($id)->get_courses()
2974  *
2975  * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5
2976  *
2977  * @param int $id
2978  * @param int $depth
2979  */
2980 function get_course_category_tree($id = 0, $depth = 0) {
2981     global $DB, $CFG;
2982     if (!$depth) {
2983         debugging('Function get_course_category_tree() is deprecated, please use course renderer or coursecat class, see function phpdocs for more info', DEBUG_DEVELOPER);
2984     }
2986     $categories = array();
2987     $categoryids = array();
2988     $sql = context_helper::get_preload_record_columns_sql('ctx');
2989     $records = $DB->get_records_sql("SELECT c.*, $sql FROM {course_categories} c ".
2990             "JOIN {context} ctx on ctx.instanceid = c.id AND ctx.contextlevel = ? WHERE c.parent = ? ORDER BY c.sortorder",
2991             array(CONTEXT_COURSECAT, $id));
2992     foreach ($records as $category) {
2993         context_helper::preload_from_record($category);
2994         if (!$category->visible && !has_capability('moodle/category:viewhiddencategories', context_coursecat::instance($category->id))) {
2995             continue;
2996         }
2997         $categories[] = $category;
2998         $categoryids[$category->id] = $category;
2999         if (empty($CFG->maxcategorydepth) || $depth <= $CFG->maxcategorydepth) {
3000             list($category->categories, $subcategories) = get_course_category_tree($category->id, $depth+1);
3001             foreach ($subcategories as $subid=>$subcat) {
3002                 $categoryids[$subid] = $subcat;
3003             }
3004             $category->courses = array();
3005         }
3006     }
3008     if ($depth > 0) {
3009         // This is a recursive call so return the required array
3010         return array($categories, $categoryids);
3011     }
3013     if (empty($categoryids)) {
3014         // No categories available (probably all hidden).
3015         return array();
3016     }
3018     // The depth is 0 this function has just been called so we can finish it off
3020     list($ccselect, $ccjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
3021     list($catsql, $catparams) = $DB->get_in_or_equal(array_keys($categoryids));
3022     $sql = "SELECT
3023             c.id,c.sortorder,c.visible,c.fullname,c.shortname,c.summary,c.category
3024             $ccselect
3025             FROM {course} c
3026             $ccjoin
3027             WHERE c.category $catsql ORDER BY c.sortorder ASC";
3028     if ($courses = $DB->get_records_sql($sql, $catparams)) {
3029         // loop throught them
3030         foreach ($courses as $course) {
3031             if ($course->id == SITEID) {
3032                 continue;
3033             }
3034             context_helper::preload_from_record($course);
3035             if (!empty($course->visible) || has_capability('moodle/course:viewhiddencourses', context_course::instance($course->id))) {
3036                 $categoryids[$course->category]->courses[$course->id] = $course;
3037             }
3038         }
3039     }
3040     return $categories;
3043 /**
3044  * Print courses in category. If category is 0 then all courses are printed.
3045  *
3046  * @deprecated since 2.5
3047  *
3048  * To print a generic list of courses use:
3049  * $renderer = $PAGE->get_renderer('core', 'course');
3050  * echo $renderer->courses_list($courses);
3051  *
3052  * To print list of all courses:
3053  * $renderer = $PAGE->get_renderer('core', 'course');
3054  * echo $renderer->frontpage_available_courses();
3055  *
3056  * To print list of courses inside category:
3057  * $renderer = $PAGE->get_renderer('core', 'course');
3058  * echo $renderer->course_category($category); // this will also print subcategories
3059  *
3060  * @param int|stdClass $category category object or id.
3061  * @return bool true if courses found and printed, else false.
3062  */
3063 function print_courses($category) {
3064     global $CFG, $OUTPUT, $PAGE;
3065     require_once($CFG->libdir. '/coursecatlib.php');
3066     debugging('Function print_courses() is deprecated, please use course renderer', DEBUG_DEVELOPER);
3068     if (!is_object($category) && $category==0) {
3069         $courses = coursecat::get(0)->get_courses(array('recursive' => true, 'summary' => true, 'coursecontacts' => true));
3070     } else {
3071         $courses = coursecat::get($category->id)->get_courses(array('summary' => true, 'coursecontacts' => true));
3072     }
3074     if ($courses) {
3075         $renderer = $PAGE->get_renderer('core', 'course');
3076         echo $renderer->courses_list($courses);
3077     } else {
3078         echo $OUTPUT->heading(get_string("nocoursesyet"));
3079         $context = context_system::instance();
3080         if (has_capability('moodle/course:create', $context)) {
3081             $options = array();
3082             if (!empty($category->id)) {
3083                 $options['category'] = $category->id;
3084             } else {
3085                 $options['category'] = $CFG->defaultrequestcategory;
3086             }
3087             echo html_writer::start_tag('div', array('class'=>'addcoursebutton'));
3088             echo $OUTPUT->single_button(new moodle_url('/course/edit.php', $options), get_string("addnewcourse"));
3089             echo html_writer::end_tag('div');
3090             return false;
3091         }
3092     }
3093     return true;
3096 /**
3097  * Print a description of a course, suitable for browsing in a list.
3098  *
3099  * @deprecated since 2.5
3100  *
3101  * Please use course renderer to display a course information box.
3102  * $renderer = $PAGE->get_renderer('core', 'course');
3103  * echo $renderer->courses_list($courses); // will print list of courses
3104  * echo $renderer->course_info_box($course); // will print one course wrapped in div.generalbox
3105  *
3106  * @param object $course the course object.
3107  * @param string $highlightterms Ignored in this deprecated function!
3108  */
3109 function print_course($course, $highlightterms = '') {
3110     global $PAGE;
3112     debugging('Function print_course() is deprecated, please use course renderer', DEBUG_DEVELOPER);
3113     $renderer = $PAGE->get_renderer('core', 'course');
3114     // Please note, correct would be to use $renderer->coursecat_coursebox() but this function is protected.
3115     // To print list of courses use $renderer->courses_list();
3116     echo $renderer->course_info_box($course);
3119 /**
3120  * Gets an array whose keys are category ids and whose values are arrays of courses in the corresponding category.
3121  *
3122  * @deprecated since 2.5
3123  *
3124  * This function is not used any more in moodle core and course renderer does not have render function for it.
3125  * Combo list on the front page is displayed as:
3126  * $renderer = $PAGE->get_renderer('core', 'course');
3127  * echo $renderer->frontpage_combo_list()
3128  *
3129  * The new class {@link coursecat} stores the information about course category tree
3130  * To get children categories use:
3131  * coursecat::get($id)->get_children()
3132  * To get list of courses use:
3133  * coursecat::get($id)->get_courses()
3134  *
3135  * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5
3136  *
3137  * @param int $categoryid
3138  * @return array
3139  */
3140 function get_category_courses_array($categoryid = 0) {
3141     debugging('Function get_category_courses_array() is deprecated, please use methods of coursecat class', DEBUG_DEVELOPER);
3142     $tree = get_course_category_tree($categoryid);
3143     $flattened = array();
3144     foreach ($tree as $category) {
3145         get_category_courses_array_recursively($flattened, $category);
3146     }
3147     return $flattened;
3150 /**
3151  * Recursive function to help flatten the course category tree.
3152  *
3153  * @deprecated since 2.5
3154  *
3155  * Was intended to be called from {@link get_category_courses_array()}
3156  *
3157  * @param array &$flattened An array passed by reference in which to store courses for each category.
3158  * @param stdClass $category The category to get courses for.
3159  */
3160 function get_category_courses_array_recursively(array &$flattened, $category) {
3161     debugging('Function get_category_courses_array_recursively() is deprecated, please use methods of coursecat class', DEBUG_DEVELOPER);
3162     $flattened[$category->id] = $category->courses;
3163     foreach ($category->categories as $childcategory) {
3164         get_category_courses_array_recursively($flattened, $childcategory);
3165     }
3168 /**
3169  * Returns a URL based on the context of the current page.
3170  * This URL points to blog/index.php and includes filter parameters appropriate for the current page.
3171  *
3172  * @param stdclass $context
3173  * @deprecated since Moodle 2.5 MDL-27814 - please do not use this function any more.
3174  * @todo Remove this in 2.7
3175  * @return string
3176  */
3177 function blog_get_context_url($context=null) {
3178     global $CFG;
3180     debugging('Function  blog_get_context_url() is deprecated, getting params from context is not reliable for blogs.', DEBUG_DEVELOPER);
3181     $viewblogentriesurl = new moodle_url('/blog/index.php');
3183     if (empty($context)) {
3184         global $PAGE;
3185         $context = $PAGE->context;
3186     }
3188     // Change contextlevel to SYSTEM if viewing the site course
3189     if ($context->contextlevel == CONTEXT_COURSE && $context->instanceid == SITEID) {
3190         $context = context_system::instance();
3191     }
3193     $filterparam = '';
3194     $strlevel = '';
3196     switch ($context->contextlevel) {
3197         case CONTEXT_SYSTEM:
3198         case CONTEXT_BLOCK:
3199         case CONTEXT_COURSECAT:
3200             break;
3201         case CONTEXT_COURSE:
3202             $filterparam = 'courseid';
3203             $strlevel = get_string('course');
3204             break;
3205         case CONTEXT_MODULE:
3206             $filterparam = 'modid';
3207             $strlevel = $context->get_context_name();
3208             break;
3209         case CONTEXT_USER:
3210             $filterparam = 'userid';
3211             $strlevel = get_string('user');
3212             break;
3213     }
3215     if (!empty($filterparam)) {
3216         $viewblogentriesurl->param($filterparam, $context->instanceid);
3217     }
3219     return $viewblogentriesurl;
3222 /**
3223  * Retrieve course records with the course managers and other related records
3224  * that we need for print_course(). This allows print_courses() to do its job
3225  * in a constant number of DB queries, regardless of the number of courses,
3226  * role assignments, etc.
3227  *
3228  * The returned array is indexed on c.id, and each course will have
3229  * - $course->managers - array containing RA objects that include a $user obj
3230  *                       with the minimal fields needed for fullname()
3231  *
3232  * @deprecated since 2.5
3233  *
3234  * To get list of all courses with course contacts ('managers') use
3235  * coursecat::get(0)->get_courses(array('recursive' => true, 'coursecontacts' => true));
3236  *
3237  * To get list of courses inside particular category use
3238  * coursecat::get($id)->get_courses(array('coursecontacts' => true));
3239  *
3240  * Additionally you can specify sort order, offset and maximum number of courses,
3241  * see {@link coursecat::get_courses()}
3242  *
3243  * Please note that code of this function is not changed to use coursecat class because
3244  * coursecat::get_courses() returns result in slightly different format. Also note that
3245  * get_courses_wmanagers() DOES NOT check that users are enrolled in the course and
3246  * coursecat::get_courses() does.
3247  *
3248  * @global object
3249  * @global object
3250  * @global object
3251  * @uses CONTEXT_COURSE
3252  * @uses CONTEXT_SYSTEM
3253  * @uses CONTEXT_COURSECAT
3254  * @uses SITEID
3255  * @param int|string $categoryid Either the categoryid for the courses or 'all'
3256  * @param string $sort A SQL sort field and direction
3257  * @param array $fields An array of additional fields to fetch
3258  * @return array
3259  */
3260 function get_courses_wmanagers($categoryid=0, $sort="c.sortorder ASC", $fields=array()) {
3261     /*
3262      * The plan is to
3263      *
3264      * - Grab the courses JOINed w/context
3265      *
3266      * - Grab the interesting course-manager RAs
3267      *   JOINed with a base user obj and add them to each course
3268      *
3269      * So as to do all the work in 2 DB queries. The RA+user JOIN
3270      * ends up being pretty expensive if it happens over _all_
3271      * courses on a large site. (Are we surprised!?)
3272      *
3273      * So this should _never_ get called with 'all' on a large site.
3274      *
3275      */
3276     global $USER, $CFG, $DB;
3277     debugging('Function get_courses_wmanagers() is deprecated, please use coursecat::get_courses()', DEBUG_DEVELOPER);
3279     $params = array();
3280     $allcats = false; // bool flag
3281     if ($categoryid === 'all') {
3282         $categoryclause   = '';
3283         $allcats = true;
3284     } elseif (is_numeric($categoryid)) {
3285         $categoryclause = "c.category = :catid";
3286         $params['catid'] = $categoryid;
3287     } else {
3288         debugging("Could not recognise categoryid = $categoryid");
3289         $categoryclause = '';
3290     }
3292     $basefields = array('id', 'category', 'sortorder',
3293                         'shortname', 'fullname', 'idnumber',
3294                         'startdate', 'visible',
3295                         'newsitems', 'groupmode', 'groupmodeforce');
3297     if (!is_null($fields) && is_string($fields)) {
3298         if (empty($fields)) {
3299             $fields = $basefields;
3300         } else {
3301             // turn the fields from a string to an array that
3302             // get_user_courses_bycap() will like...
3303             $fields = explode(',',$fields);
3304             $fields = array_map('trim', $fields);
3305             $fields = array_unique(array_merge($basefields, $fields));
3306         }
3307     } elseif (is_array($fields)) {
3308         $fields = array_merge($basefields,$fields);
3309     }
3310     $coursefields = 'c.' .join(',c.', $fields);
3312     if (empty($sort)) {
3313         $sortstatement = "";
3314     } else {
3315         $sortstatement = "ORDER BY $sort";
3316     }
3318     $where = 'WHERE c.id != ' . SITEID;
3319     if ($categoryclause !== ''){
3320         $where = "$where AND $categoryclause";
3321     }
3323     // pull out all courses matching the cat
3324     list($ccselect, $ccjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
3325     $sql = "SELECT $coursefields $ccselect
3326               FROM {course} c
3327            $ccjoin
3328                $where
3329                $sortstatement";
3331     $catpaths = array();
3332     $catpath  = NULL;
3333     if ($courses = $DB->get_records_sql($sql, $params)) {
3334         // loop on courses materialising
3335         // the context, and prepping data to fetch the
3336         // managers efficiently later...
3337         foreach ($courses as $k => $course) {
3338             context_helper::preload_from_record($course);
3339             $coursecontext = context_course::instance($course->id);
3340             $courses[$k] = $course;
3341             $courses[$k]->managers = array();
3342             if ($allcats === false) {
3343                 // single cat, so take just the first one...
3344                 if ($catpath === NULL) {
3345                     $catpath = preg_replace(':/\d+$:', '', $coursecontext->path);
3346                 }
3347             } else {
3348                 // chop off the contextid of the course itself
3349                 // like dirname() does...
3350                 $catpaths[] = preg_replace(':/\d+$:', '', $coursecontext->path);
3351             }
3352         }
3353     } else {
3354         return array(); // no courses!
3355     }
3357     $CFG->coursecontact = trim($CFG->coursecontact);
3358     if (empty($CFG->coursecontact)) {
3359         return $courses;
3360     }
3362     $managerroles = explode(',', $CFG->coursecontact);
3363     $catctxids = '';
3364     if (count($managerroles)) {
3365         if ($allcats === true) {
3366             $catpaths  = array_unique($catpaths);
3367             $ctxids = array();
3368             foreach ($catpaths as $cpath) {
3369                 $ctxids = array_merge($ctxids, explode('/',substr($cpath,1)));
3370             }
3371             $ctxids = array_unique($ctxids);
3372             $catctxids = implode( ',' , $ctxids);
3373             unset($catpaths);
3374             unset($cpath);
3375         } else {
3376             // take the ctx path from the first course
3377             // as all categories will be the same...
3378             $catpath = substr($catpath,1);
3379             $catpath = preg_replace(':/\d+$:','',$catpath);
3380             $catctxids = str_replace('/',',',$catpath);
3381         }
3382         if ($categoryclause !== '') {
3383             $categoryclause = "AND $categoryclause";
3384         }
3385         /*
3386          * Note: Here we use a LEFT OUTER JOIN that can
3387          * "optionally" match to avoid passing a ton of context
3388          * ids in an IN() clause. Perhaps a subselect is faster.
3389          *
3390          * In any case, this SQL is not-so-nice over large sets of
3391          * courses with no $categoryclause.
3392          *
3393          */
3394         $sql = "SELECT ctx.path, ctx.instanceid, ctx.contextlevel,
3395                        r.id AS roleid, r.name AS rolename, r.shortname AS roleshortname,
3396                        rn.name AS rolecoursealias, u.id AS userid, u.firstname, u.lastname
3397                   FROM {role_assignments} ra
3398                   JOIN {context} ctx ON ra.contextid = ctx.id
3399                   JOIN {user} u ON ra.userid = u.id
3400                   JOIN {role} r ON ra.roleid = r.id
3401              LEFT JOIN {role_names} rn ON (rn.contextid = ctx.id AND rn.roleid = r.id)
3402                   LEFT OUTER JOIN {course} c
3403                        ON (ctx.instanceid=c.id AND ctx.contextlevel=".CONTEXT_COURSE.")
3404                 WHERE ( c.id IS NOT NULL";
3405         // under certain conditions, $catctxids is NULL
3406         if($catctxids == NULL){
3407             $sql .= ") ";
3408         }else{
3409             $sql .= " OR ra.contextid  IN ($catctxids) )";
3410         }
3412         $sql .= "AND ra.roleid IN ({$CFG->coursecontact})
3413                       $categoryclause
3414                 ORDER BY r.sortorder ASC, ctx.contextlevel ASC, ra.sortorder ASC";
3415         $rs = $DB->get_recordset_sql($sql, $params);
3417         // This loop is fairly stupid as it stands - might get better
3418         // results doing an initial pass clustering RAs by path.
3419         foreach($rs as $ra) {
3420             $user = new stdClass;
3421             $user->id        = $ra->userid;    unset($ra->userid);
3422             $user->firstname = $ra->firstname; unset($ra->firstname);
3423             $user->lastname  = $ra->lastname;  unset($ra->lastname);
3424             $ra->user = $user;
3425             if ($ra->contextlevel == CONTEXT_SYSTEM) {
3426                 foreach ($courses as $k => $course) {
3427                     $courses[$k]->managers[] = $ra;
3428                 }
3429             } else if ($ra->contextlevel == CONTEXT_COURSECAT) {
3430                 if ($allcats === false) {
3431                     // It always applies
3432                     foreach ($courses as $k => $course) {
3433                         $courses[$k]->managers[] = $ra;
3434                     }
3435                 } else {
3436                     foreach ($courses as $k => $course) {
3437                         $coursecontext = context_course::instance($course->id);
3438                         // Note that strpos() returns 0 as "matched at pos 0"
3439                         if (strpos($coursecontext->path, $ra->path.'/') === 0) {
3440                             // Only add it to subpaths
3441                             $courses[$k]->managers[] = $ra;
3442                         }
3443                     }
3444                 }
3445             } else { // course-level
3446                 if (!array_key_exists($ra->instanceid, $courses)) {
3447                     //this course is not in a list, probably a frontpage course
3448                     continue;
3449                 }
3450                 $courses[$ra->instanceid]->managers[] = $ra;
3451             }
3452         }
3453         $rs->close();
3454     }
3456     return $courses;
3459 /**
3460  * Converts a nested array tree into HTML ul:li [recursive]
3461  *
3462  * @deprecated since 2.5
3463  *
3464  * @param array $tree A tree array to convert
3465  * @param int $row Used in identifying the iteration level and in ul classes
3466  * @return string HTML structure
3467  */
3468 function convert_tree_to_html($tree, $row=0) {
3469     debugging('Function convert_tree_to_html() is deprecated since Moodle 2.5. Consider using class tabtree and core_renderer::render_tabtree()', DEBUG_DEVELOPER);
3471     $str = "\n".'<ul class="tabrow'.$row.'">'."\n";
3473     $first = true;
3474     $count = count($tree);
3476     foreach ($tree as $tab) {
3477         $count--;   // countdown to zero
3479         $liclass = '';
3481         if ($first && ($count == 0)) {   // Just one in the row
3482             $liclass = 'first last';
3483             $first = false;
3484         } else if ($first) {
3485             $liclass = 'first';
3486             $first = false;
3487         } else if ($count == 0) {
3488             $liclass = 'last';
3489         }
3491         if ((empty($tab->subtree)) && (!empty($tab->selected))) {
3492             $liclass .= (empty($liclass)) ? 'onerow' : ' onerow';
3493         }
3495         if ($tab->inactive || $tab->active || $tab->selected) {
3496             if ($tab->selected) {
3497                 $liclass .= (empty($liclass)) ? 'here selected' : ' here selected';
3498             } else if ($tab->active) {
3499                 $liclass .= (empty($liclass)) ? 'here active' : ' here active';
3500             }
3501         }
3503         $str .= (!empty($liclass)) ? '<li class="'.$liclass.'">' : '<li>';
3505         if ($tab->inactive || $tab->active || ($tab->selected && !$tab->linkedwhenselected)) {
3506             // The a tag is used for styling
3507             $str .= '<a class="nolink"><span>'.$tab->text.'</span></a>';
3508         } else {
3509             $str .= '<a href="'.$tab->link.'" title="'.$tab->title.'"><span>'.$tab->text.'</span></a>';
3510         }
3512         if (!empty($tab->subtree)) {
3513             $str .= convert_tree_to_html($tab->subtree, $row+1);
3514         } else if ($tab->selected) {
3515             $str .= '<div class="tabrow'.($row+1).' empty">&nbsp;</div>'."\n";
3516         }
3518         $str .= ' </li>'."\n";
3519     }
3520     $str .= '</ul>'."\n";
3522     return $str;
3525 /**
3526  * Convert nested tabrows to a nested array
3527  *
3528  * @deprecated since 2.5
3529  *
3530  * @param array $tabrows A [nested] array of tab row objects
3531  * @param string $selected The tabrow to select (by id)
3532  * @param array $inactive An array of tabrow id's to make inactive
3533  * @param array $activated An array of tabrow id's to make active
3534  * @return array The nested array
3535  */
3536 function convert_tabrows_to_tree($tabrows, $selected, $inactive, $activated) {
3538     debugging('Function convert_tabrows_to_tree() is deprecated since Moodle 2.5. Consider using class tabtree', DEBUG_DEVELOPER);
3540     // Work backwards through the rows (bottom to top) collecting the tree as we go.
3541     $tabrows = array_reverse($tabrows);
3543     $subtree = array();
3545     foreach ($tabrows as $row) {
3546         $tree = array();
3548         foreach ($row as $tab) {
3549             $tab->inactive = in_array((string)$tab->id, $inactive);
3550             $tab->active = in_array((string)$tab->id, $activated);
3551             $tab->selected = (string)$tab->id == $selected;
3553             if ($tab->active || $tab->selected) {
3554                 if ($subtree) {
3555                     $tab->subtree = $subtree;
3556                 }
3557             }
3558             $tree[] = $tab;
3559         }
3560         $subtree = $tree;
3561     }
3563     return $subtree;
3566 /**
3567  * Can handle rotated text. Whether it is safe to use the trickery in textrotate.js.
3568  *
3569  * @deprecated since 2.5 - do not use, the textrotate.js will work it out automatically
3570  * @return bool True for yes, false for no
3571  */
3572 function can_use_rotated_text() {
3573     debugging('can_use_rotated_text() is deprecated since Moodle 2.5. JS feature detection is used automatically.', DEBUG_DEVELOPER);
3574     return true;
3577 /**
3578  * Get the context instance as an object. This function will create the
3579  * context instance if it does not exist yet.
3580  *
3581  * @deprecated since 2.2, use context_course::instance() or other relevant class instead
3582  * @todo This will be deleted in Moodle 2.8, refer MDL-34472
3583  * @param integer $contextlevel The context level, for example CONTEXT_COURSE, or CONTEXT_MODULE.
3584  * @param integer $instance The instance id. For $level = CONTEXT_COURSE, this would be $course->id,
3585  *      for $level = CONTEXT_MODULE, this would be $cm->id. And so on. Defaults to 0
3586  * @param int $strictness IGNORE_MISSING means compatible mode, false returned if record not found, debug message if more found;
3587  *      MUST_EXIST means throw exception if no record or multiple records found
3588  * @return context The context object.
3589  */
3590 function get_context_instance($contextlevel, $instance = 0, $strictness = IGNORE_MISSING) {
3592     debugging('get_context_instance() is deprecated, please use context_xxxx::instance() instead.', DEBUG_DEVELOPER);
3594     $instances = (array)$instance;
3595     $contexts = array();
3597     $classname = context_helper::get_class_for_level($contextlevel);
3599     // we do not load multiple contexts any more, PAGE should be responsible for any preloading
3600     foreach ($instances as $inst) {
3601         $contexts[$inst] = $classname::instance($inst, $strictness);
3602     }
3604     if (is_array($instance)) {
3605         return $contexts;
3606     } else {
3607         return $contexts[$instance];
3608     }
3611 /**
3612  * Get a context instance as an object, from a given context id.
3613  *
3614  * @deprecated since Moodle 2.2 MDL-35009 - please do not use this function any more.
3615  * @todo MDL-34550 This will be deleted in Moodle 2.8
3616  * @see context::instance_by_id($id)
3617  * @param int $id context id
3618  * @param int $strictness IGNORE_MISSING means compatible mode, false returned if record not found, debug message if more found;
3619  *                        MUST_EXIST means throw exception if no record or multiple records found
3620  * @return context|bool the context object or false if not found.
3621  */
3622 function get_context_instance_by_id($id, $strictness = IGNORE_MISSING) {
3623     debugging('get_context_instance_by_id() is deprecated, please use context::instance_by_id($id) instead.', DEBUG_DEVELOPER);
3624     return context::instance_by_id($id, $strictness);
3627 /**
3628  * Returns system context or null if can not be created yet.
3629  *
3630  * @see context_system::instance()
3631  * @deprecated since 2.2
3632  * @param bool $cache use caching
3633  * @return context system context (null if context table not created yet)
3634  */
3635 function get_system_context($cache = true) {
3636     debugging('get_system_context() is deprecated, please use context_system::instance() instead.', DEBUG_DEVELOPER);
3637     return context_system::instance(0, IGNORE_MISSING, $cache);
3640 /**
3641  * Recursive function which, given a context, find all parent context ids,
3642  * and return the array in reverse order, i.e. parent first, then grand
3643  * parent, etc.
3644  *
3645  * @see context::get_parent_context_ids()
3646  * @deprecated since 2.2, use $context->get_parent_context_ids() instead
3647  * @param context $context
3648  * @param bool $includeself optional, defaults to false
3649  * @return array
3650  */
3651 function get_parent_contexts(context $context, $includeself = false) {
3652     debugging('get_parent_contexts() is deprecated, please use $context->get_parent_context_ids() instead.', DEBUG_DEVELOPER);
3653     return $context->get_parent_context_ids($includeself);
3656 /**
3657  * Return the id of the parent of this context, or false if there is no parent (only happens if this
3658  * is the site context.)
3659  *
3660  * @deprecated since Moodle 2.2
3661  * @see context::get_parent_context()
3662  * @param context $context
3663  * @return integer the id of the parent context.
3664  */
3665 function get_parent_contextid(context $context) {
3666     debugging('get_parent_contextid() is deprecated, please use $context->get_parent_context() instead.', DEBUG_DEVELOPER);
3668     if ($parent = $context->get_parent_context()) {
3669         return $parent->id;
3670     } else {
3671         return false;
3672     }
3675 /**
3676  * Recursive function which, given a context, find all its children contexts.
3677  *
3678  * For course category contexts it will return immediate children only categories and courses.
3679  * It will NOT recurse into courses or child categories.
3680  * If you want to do that, call it on the returned courses/categories.
3681  *
3682  * When called for a course context, it will return the modules and blocks
3683  * displayed in the course page.
3684  *
3685  * If called on a user/course/module context it _will_ populate the cache with the appropriate
3686  * contexts ;-)
3687  *
3688  * @see context::get_child_contexts()
3689  * @deprecated since 2.2
3690  * @param context $context