MDL-45295 blocks: added a bit more info to upgrade.txt
[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  * Add an entry to the legacy log table.
35  *
36  * @deprecated since 2.7 use new events instead
37  *
38  * @param    int     $courseid  The course id
39  * @param    string  $module  The module name  e.g. forum, journal, resource, course, user etc
40  * @param    string  $action  'view', 'update', 'add' or 'delete', possibly followed by another word to clarify.
41  * @param    string  $url     The file and parameters used to see the results of the action
42  * @param    string  $info    Additional description information
43  * @param    int     $cm      The course_module->id if there is one
44  * @param    int|stdClass $user If log regards $user other than $USER
45  * @return void
46  */
47 function add_to_log($courseid, $module, $action, $url='', $info='', $cm=0, $user=0) {
48     debugging('add_to_log() has been deprecated, please rewrite your code to the new events API', DEBUG_DEVELOPER);
50     // This is a nasty hack that allows us to put all the legacy stuff into legacy storage,
51     // this way we may move all the legacy settings there too.
52     $manager = get_log_manager();
53     if (method_exists($manager, 'legacy_add_to_log')) {
54         $manager->legacy_add_to_log($courseid, $module, $action, $url, $info, $cm, $user);
55     }
56 }
58 /**
59  * Adds a file upload to the log table so that clam can resolve the filename to the user later if necessary
60  *
61  * @deprecated since 2.7 - use new file picker instead
62  *
63  * @param string $newfilepath
64  * @param stdClass $course
65  * @param bool $nourl
66  */
67 function clam_log_upload($newfilepath, $course=null, $nourl=false) {
68     debugging('clam_log_upload() is not supposed to be used any more, use new file picker instead', DEBUG_DEVELOPER);
69 }
71 /**
72  * This function logs to error_log and to the log table that an infected file has been found and what's happened to it.
73  *
74  * @deprecated since 2.7 - use new file picker instead
75  *
76  * @param string $oldfilepath
77  * @param string $newfilepath
78  * @param int $userid The user
79  */
80 function clam_log_infected($oldfilepath='', $newfilepath='', $userid=0) {
81     debugging('clam_log_infected() is not supposed to be used any more, use new file picker instead', DEBUG_DEVELOPER);
82 }
84 /**
85  * Some of the modules allow moving attachments (glossary), in which case we need to hunt down an original log and change the path.
86  *
87  * @deprecated since 2.7 - use new file picker instead
88  *
89  * @param string $oldpath
90  * @param string $newpath
91  * @param boolean $update
92  */
93 function clam_change_log($oldpath, $newpath, $update=true) {
94     debugging('clam_change_log() is not supposed to be used any more, use new file picker instead', DEBUG_DEVELOPER);
95 }
97 /**
98  * Replaces the given file with a string.
99  *
100  * @deprecated since 2.7 - infected files are now deleted in file picker
101  *
102  * @param string $file
103  * @return boolean
104  */
105 function clam_replace_infected_file($file) {
106     debugging('clam_change_log() is not supposed to be used any more', DEBUG_DEVELOPER);
107     return false;
110 /**
111  * Checks whether the password compatibility library will work with the current
112  * version of PHP. This cannot be done using PHP version numbers since the fix
113  * has been backported to earlier versions in some distributions.
114  *
115  * See https://github.com/ircmaxell/password_compat/issues/10 for more details.
116  *
117  * @deprecated since 2.7 PHP 5.4.x should be always compatible.
118  *
119  * @return bool always returns false
120  */
121 function password_compat_not_supported() {
122     debugging('Do not use password_compat_not_supported() - bcrypt is now always available', DEBUG_DEVELOPER);
123     return false;
126 /**
127  * Factory method that was returning moodle_session object.
128  *
129  * @deprecated since 2.6
130  * @return \core\session\manager
131  */
132 function session_get_instance() {
133     // Note: the new session manager includes all methods from the original session class.
134     static $deprecatedinstance = null;
136     debugging('session_get_instance() is deprecated, use \core\session\manager instead', DEBUG_DEVELOPER);
138     if (!$deprecatedinstance) {
139         $deprecatedinstance = new \core\session\manager();
140     }
142     return $deprecatedinstance;
145 /**
146  * Returns true if legacy session used.
147  *
148  * @deprecated since 2.6
149  * @return bool
150  */
151 function session_is_legacy() {
152     debugging('session_is_legacy() is deprecated, do not use any more', DEBUG_DEVELOPER);
153     return false;
156 /**
157  * Terminates all sessions, auth hooks are not executed.
158  * Useful in upgrade scripts.
159  *
160  * @deprecated since 2.6
161  */
162 function session_kill_all() {
163     debugging('session_kill_all() is deprecated, use \core\session\manager::kill_all_sessions() instead', DEBUG_DEVELOPER);
164     \core\session\manager::kill_all_sessions();
167 /**
168  * Mark session as accessed, prevents timeouts.
169  *
170  * @deprecated since 2.6
171  * @param string $sid
172  */
173 function session_touch($sid) {
174     debugging('session_touch() is deprecated, use \core\session\manager::touch_session() instead', DEBUG_DEVELOPER);
175     \core\session\manager::touch_session($sid);
178 /**
179  * Terminates one sessions, auth hooks are not executed.
180  *
181  * @deprecated since 2.6
182  * @param string $sid session id
183  */
184 function session_kill($sid) {
185     debugging('session_kill() is deprecated, use \core\session\manager::kill_session() instead', DEBUG_DEVELOPER);
186     \core\session\manager::kill_session($sid);
189 /**
190  * Terminates all sessions of one user, auth hooks are not executed.
191  * NOTE: This can not work for file based sessions!
192  *
193  * @deprecated since 2.6
194  * @param int $userid user id
195  */
196 function session_kill_user($userid) {
197     debugging('session_kill_user() is deprecated, use \core\session\manager::kill_user_sessions() instead', DEBUG_DEVELOPER);
198     \core\session\manager::kill_user_sessions($userid);
201 /**
202  * Setup $USER object - called during login, loginas, etc.
203  *
204  * Call sync_user_enrolments() manually after log-in, or log-in-as.
205  *
206  * @deprecated since 2.6
207  * @param stdClass $user full user record object
208  * @return void
209  */
210 function session_set_user($user) {
211     debugging('session_set_user() is deprecated, use \core\session\manager::set_user() instead', DEBUG_DEVELOPER);
212     \core\session\manager::set_user($user);
215 /**
216  * Is current $USER logged-in-as somebody else?
217  * @deprecated since 2.6
218  * @return bool
219  */
220 function session_is_loggedinas() {
221     debugging('session_is_loggedinas() is deprecated, use \core\session\manager::is_loggedinas() instead', DEBUG_DEVELOPER);
222     return \core\session\manager::is_loggedinas();
225 /**
226  * Returns the $USER object ignoring current login-as session
227  * @deprecated since 2.6
228  * @return stdClass user object
229  */
230 function session_get_realuser() {
231     debugging('session_get_realuser() is deprecated, use \core\session\manager::get_realuser() instead', DEBUG_DEVELOPER);
232     return \core\session\manager::get_realuser();
235 /**
236  * Login as another user - no security checks here.
237  * @deprecated since 2.6
238  * @param int $userid
239  * @param stdClass $context
240  * @return void
241  */
242 function session_loginas($userid, $context) {
243     debugging('session_loginas() is deprecated, use \core\session\manager::loginas() instead', DEBUG_DEVELOPER);
244     \core\session\manager::loginas($userid, $context);
247 /**
248  * Minify JavaScript files.
249  *
250  * @deprecated since 2.6
251  *
252  * @param array $files
253  * @return string
254  */
255 function js_minify($files) {
256     debugging('js_minify() is deprecated, use core_minify::js_files() or core_minify::js() instead.');
257     return core_minify::js_files($files);
260 /**
261  * Minify CSS files.
262  *
263  * @deprecated since 2.6
264  *
265  * @param array $files
266  * @return string
267  */
268 function css_minify_css($files) {
269     debugging('css_minify_css() is deprecated, use core_minify::css_files() or core_minify::css() instead.');
270     return core_minify::css_files($files);
273 /**
274  * Function to call all event handlers when triggering an event
275  *
276  * @deprecated since 2.6
277  *
278  * @param string $eventname name of the event
279  * @param mixed $eventdata event data object
280  * @return int number of failed events
281  */
282 function events_trigger($eventname, $eventdata) {
283     debugging('events_trigger() is deprecated, please use new events instead', DEBUG_DEVELOPER);
284     return events_trigger_legacy($eventname, $eventdata);
287 /**
288  * List all core subsystems and their location
289  *
290  * This is a whitelist of components that are part of the core and their
291  * language strings are defined in /lang/en/<<subsystem>>.php. If a given
292  * plugin is not listed here and it does not have proper plugintype prefix,
293  * then it is considered as course activity module.
294  *
295  * The location is optionally dirroot relative path. NULL means there is no special
296  * directory for this subsystem. If the location is set, the subsystem's
297  * renderer.php is expected to be there.
298  *
299  * @deprecated since 2.6, use core_component::get_core_subsystems()
300  *
301  * @param bool $fullpaths false means relative paths from dirroot, use true for performance reasons
302  * @return array of (string)name => (string|null)location
303  */
304 function get_core_subsystems($fullpaths = false) {
305     global $CFG;
307     // NOTE: do not add any other debugging here, keep forever.
309     $subsystems = core_component::get_core_subsystems();
311     if ($fullpaths) {
312         return $subsystems;
313     }
315     debugging('Short paths are deprecated when using get_core_subsystems(), please fix the code to use fullpaths instead.', DEBUG_DEVELOPER);
317     $dlength = strlen($CFG->dirroot);
319     foreach ($subsystems as $k => $v) {
320         if ($v === null) {
321             continue;
322         }
323         $subsystems[$k] = substr($v, $dlength+1);
324     }
326     return $subsystems;
329 /**
330  * Lists all plugin types.
331  *
332  * @deprecated since 2.6, use core_component::get_plugin_types()
333  *
334  * @param bool $fullpaths false means relative paths from dirroot
335  * @return array Array of strings - name=>location
336  */
337 function get_plugin_types($fullpaths = true) {
338     global $CFG;
340     // NOTE: do not add any other debugging here, keep forever.
342     $types = core_component::get_plugin_types();
344     if ($fullpaths) {
345         return $types;
346     }
348     debugging('Short paths are deprecated when using get_plugin_types(), please fix the code to use fullpaths instead.', DEBUG_DEVELOPER);
350     $dlength = strlen($CFG->dirroot);
352     foreach ($types as $k => $v) {
353         if ($k === 'theme') {
354             $types[$k] = 'theme';
355             continue;
356         }
357         $types[$k] = substr($v, $dlength+1);
358     }
360     return $types;
363 /**
364  * Use when listing real plugins of one type.
365  *
366  * @deprecated since 2.6, use core_component::get_plugin_list()
367  *
368  * @param string $plugintype type of plugin
369  * @return array name=>fulllocation pairs of plugins of given type
370  */
371 function get_plugin_list($plugintype) {
373     // NOTE: do not add any other debugging here, keep forever.
375     if ($plugintype === '') {
376         $plugintype = 'mod';
377     }
379     return core_component::get_plugin_list($plugintype);
382 /**
383  * Get a list of all the plugins of a given type that define a certain class
384  * in a certain file. The plugin component names and class names are returned.
385  *
386  * @deprecated since 2.6, use core_component::get_plugin_list_with_class()
387  *
388  * @param string $plugintype the type of plugin, e.g. 'mod' or 'report'.
389  * @param string $class the part of the name of the class after the
390  *      frankenstyle prefix. e.g 'thing' if you are looking for classes with
391  *      names like report_courselist_thing. If you are looking for classes with
392  *      the same name as the plugin name (e.g. qtype_multichoice) then pass ''.
393  * @param string $file the name of file within the plugin that defines the class.
394  * @return array with frankenstyle plugin names as keys (e.g. 'report_courselist', 'mod_forum')
395  *      and the class names as values (e.g. 'report_courselist_thing', 'qtype_multichoice').
396  */
397 function get_plugin_list_with_class($plugintype, $class, $file) {
399     // NOTE: do not add any other debugging here, keep forever.
401     return core_component::get_plugin_list_with_class($plugintype, $class, $file);
404 /**
405  * Returns the exact absolute path to plugin directory.
406  *
407  * @deprecated since 2.6, use core_component::get_plugin_directory()
408  *
409  * @param string $plugintype type of plugin
410  * @param string $name name of the plugin
411  * @return string full path to plugin directory; NULL if not found
412  */
413 function get_plugin_directory($plugintype, $name) {
415     // NOTE: do not add any other debugging here, keep forever.
417     if ($plugintype === '') {
418         $plugintype = 'mod';
419     }
421     return core_component::get_plugin_directory($plugintype, $name);
424 /**
425  * Normalize the component name using the "frankenstyle" names.
426  *
427  * @deprecated since 2.6, use core_component::normalize_component()
428  *
429  * @param string $component
430  * @return array as (string)$type => (string)$plugin
431  */
432 function normalize_component($component) {
434     // NOTE: do not add any other debugging here, keep forever.
436     return core_component::normalize_component($component);
439 /**
440  * Return exact absolute path to a plugin directory.
441  *
442  * @deprecated since 2.6, use core_component::normalize_component()
443  *
444  * @param string $component name such as 'moodle', 'mod_forum'
445  * @return string full path to component directory; NULL if not found
446  */
447 function get_component_directory($component) {
449     // NOTE: do not add any other debugging here, keep forever.
451     return core_component::get_component_directory($component);
455 // === Deprecated before 2.6.0 ===
457 /**
458  * Hack to find out the GD version by parsing phpinfo output
459  *
460  * @return int GD version (1, 2, or 0)
461  */
462 function check_gd_version() {
463     // TODO: delete function in Moodle 2.7
464     debugging('check_gd_version() is deprecated, GD extension is always available now');
466     $gdversion = 0;
468     if (function_exists('gd_info')){
469         $gd_info = gd_info();
470         if (substr_count($gd_info['GD Version'], '2.')) {
471             $gdversion = 2;
472         } else if (substr_count($gd_info['GD Version'], '1.')) {
473             $gdversion = 1;
474         }
476     } else {
477         ob_start();
478         phpinfo(INFO_MODULES);
479         $phpinfo = ob_get_contents();
480         ob_end_clean();
482         $phpinfo = explode("\n", $phpinfo);
485         foreach ($phpinfo as $text) {
486             $parts = explode('</td>', $text);
487             foreach ($parts as $key => $val) {
488                 $parts[$key] = trim(strip_tags($val));
489             }
490             if ($parts[0] == 'GD Version') {
491                 if (substr_count($parts[1], '2.0')) {
492                     $parts[1] = '2.0';
493                 }
494                 $gdversion = intval($parts[1]);
495             }
496         }
497     }
499     return $gdversion;   // 1, 2 or 0
502 /**
503  * Not used any more, the account lockout handling is now
504  * part of authenticate_user_login().
505  * @deprecated
506  */
507 function update_login_count() {
508     // TODO: delete function in Moodle 2.6
509     debugging('update_login_count() is deprecated, all calls need to be removed');
512 /**
513  * Not used any more, replaced by proper account lockout.
514  * @deprecated
515  */
516 function reset_login_count() {
517     // TODO: delete function in Moodle 2.6
518     debugging('reset_login_count() is deprecated, all calls need to be removed');
521 /**
522  * Insert or update log display entry. Entry may already exist.
523  * $module, $action must be unique
524  * @deprecated
525  *
526  * @param string $module
527  * @param string $action
528  * @param string $mtable
529  * @param string $field
530  * @return void
531  *
532  */
533 function update_log_display_entry($module, $action, $mtable, $field) {
534     global $DB;
536     debugging('The update_log_display_entry() is deprecated, please use db/log.php description file instead.');
539 /**
540  * @deprecated use the text formatting in a standard way instead (http://docs.moodle.org/dev/Output_functions)
541  *             this was abused mostly for embedding of attachments
542  */
543 function filter_text($text, $courseid = NULL) {
544     throw new coding_exception('filter_text() can not be used anymore, use format_text(), format_string() etc instead.');
547 /**
548  * @deprecated use $PAGE->https_required() instead
549  */
550 function httpsrequired() {
551     throw new coding_exception('httpsrequired() can not be used any more use $PAGE->https_required() instead.');
554 /**
555  * Given a physical path to a file, returns the URL through which it can be reached in Moodle.
556  *
557  * @deprecated use moodle_url factory methods instead
558  *
559  * @param string $path Physical path to a file
560  * @param array $options associative array of GET variables to append to the URL
561  * @param string $type (questionfile|rssfile|httpscoursefile|coursefile)
562  * @return string URL to file
563  */
564 function get_file_url($path, $options=null, $type='coursefile') {
565     global $CFG;
567     $path = str_replace('//', '/', $path);
568     $path = trim($path, '/'); // no leading and trailing slashes
570     // type of file
571     switch ($type) {
572        case 'questionfile':
573             $url = $CFG->wwwroot."/question/exportfile.php";
574             break;
575        case 'rssfile':
576             $url = $CFG->wwwroot."/rss/file.php";
577             break;
578         case 'httpscoursefile':
579             $url = $CFG->httpswwwroot."/file.php";
580             break;
581          case 'coursefile':
582         default:
583             $url = $CFG->wwwroot."/file.php";
584     }
586     if ($CFG->slasharguments) {
587         $parts = explode('/', $path);
588         foreach ($parts as $key => $part) {
589         /// anchor dash character should not be encoded
590             $subparts = explode('#', $part);
591             $subparts = array_map('rawurlencode', $subparts);
592             $parts[$key] = implode('#', $subparts);
593         }
594         $path  = implode('/', $parts);
595         $ffurl = $url.'/'.$path;
596         $separator = '?';
597     } else {
598         $path = rawurlencode('/'.$path);
599         $ffurl = $url.'?file='.$path;
600         $separator = '&amp;';
601     }
603     if ($options) {
604         foreach ($options as $name=>$value) {
605             $ffurl = $ffurl.$separator.$name.'='.$value;
606             $separator = '&amp;';
607         }
608     }
610     return $ffurl;
613 /**
614  * @deprecated use get_enrolled_users($context) instead.
615  */
616 function get_course_participants($courseid) {
617     throw new coding_exception('get_course_participants() can not be used any more, use get_enrolled_users() instead.');
620 /**
621  * @deprecated use is_enrolled($context, $userid) instead.
622  */
623 function is_course_participant($userid, $courseid) {
624     throw new coding_exception('is_course_participant() can not be used any more, use is_enrolled() instead.');
627 /**
628  * Searches logs to find all enrolments since a certain date
629  *
630  * used to print recent activity
631  *
632  * @param int $courseid The course in question.
633  * @param int $timestart The date to check forward of
634  * @return object|false  {@link $USER} records or false if error.
635  */
636 function get_recent_enrolments($courseid, $timestart) {
637     global $DB;
639     debugging('get_recent_enrolments() is deprecated as it returned inaccurate results.', DEBUG_DEVELOPER);
641     $context = context_course::instance($courseid);
642     $sql = "SELECT u.id, u.firstname, u.lastname, MAX(l.time)
643               FROM {user} u, {role_assignments} ra, {log} l
644              WHERE l.time > ?
645                    AND l.course = ?
646                    AND l.module = 'course'
647                    AND l.action = 'enrol'
648                    AND ".$DB->sql_cast_char2int('l.info')." = u.id
649                    AND u.id = ra.userid
650                    AND ra.contextid ".get_related_contexts_string($context)."
651           GROUP BY u.id, u.firstname, u.lastname
652           ORDER BY MAX(l.time) ASC";
653     $params = array($timestart, $courseid);
654     return $DB->get_records_sql($sql, $params);
657 /**
658  * @deprecated use clean_param($string, PARAM_FILE) instead.
659  */
660 function detect_munged_arguments($string, $allowdots=1) {
661     throw new coding_exception('detect_munged_arguments() can not be used any more, please use clean_param(,PARAM_FILE) instead.');
665 /**
666  * Unzip one zip file to a destination dir
667  * Both parameters must be FULL paths
668  * If destination isn't specified, it will be the
669  * SAME directory where the zip file resides.
670  *
671  * @global object
672  * @param string $zipfile The zip file to unzip
673  * @param string $destination The location to unzip to
674  * @param bool $showstatus_ignored Unused
675  */
676 function unzip_file($zipfile, $destination = '', $showstatus_ignored = true) {
677     global $CFG;
679     //Extract everything from zipfile
680     $path_parts = pathinfo(cleardoubleslashes($zipfile));
681     $zippath = $path_parts["dirname"];       //The path of the zip file
682     $zipfilename = $path_parts["basename"];  //The name of the zip file
683     $extension = $path_parts["extension"];    //The extension of the file
685     //If no file, error
686     if (empty($zipfilename)) {
687         return false;
688     }
690     //If no extension, error
691     if (empty($extension)) {
692         return false;
693     }
695     //Clear $zipfile
696     $zipfile = cleardoubleslashes($zipfile);
698     //Check zipfile exists
699     if (!file_exists($zipfile)) {
700         return false;
701     }
703     //If no destination, passed let's go with the same directory
704     if (empty($destination)) {
705         $destination = $zippath;
706     }
708     //Clear $destination
709     $destpath = rtrim(cleardoubleslashes($destination), "/");
711     //Check destination path exists
712     if (!is_dir($destpath)) {
713         return false;
714     }
716     $packer = get_file_packer('application/zip');
718     $result = $packer->extract_to_pathname($zipfile, $destpath);
720     if ($result === false) {
721         return false;
722     }
724     foreach ($result as $status) {
725         if ($status !== true) {
726             return false;
727         }
728     }
730     return true;
733 /**
734  * Zip an array of files/dirs to a destination zip file
735  * Both parameters must be FULL paths to the files/dirs
736  *
737  * @global object
738  * @param array $originalfiles Files to zip
739  * @param string $destination The destination path
740  * @return bool Outcome
741  */
742 function zip_files ($originalfiles, $destination) {
743     global $CFG;
745     //Extract everything from destination
746     $path_parts = pathinfo(cleardoubleslashes($destination));
747     $destpath = $path_parts["dirname"];       //The path of the zip file
748     $destfilename = $path_parts["basename"];  //The name of the zip file
749     $extension = $path_parts["extension"];    //The extension of the file
751     //If no file, error
752     if (empty($destfilename)) {
753         return false;
754     }
756     //If no extension, add it
757     if (empty($extension)) {
758         $extension = 'zip';
759         $destfilename = $destfilename.'.'.$extension;
760     }
762     //Check destination path exists
763     if (!is_dir($destpath)) {
764         return false;
765     }
767     //Check destination path is writable. TODO!!
769     //Clean destination filename
770     $destfilename = clean_filename($destfilename);
772     //Now check and prepare every file
773     $files = array();
774     $origpath = NULL;
776     foreach ($originalfiles as $file) {  //Iterate over each file
777         //Check for every file
778         $tempfile = cleardoubleslashes($file); // no doubleslashes!
779         //Calculate the base path for all files if it isn't set
780         if ($origpath === NULL) {
781             $origpath = rtrim(cleardoubleslashes(dirname($tempfile)), "/");
782         }
783         //See if the file is readable
784         if (!is_readable($tempfile)) {  //Is readable
785             continue;
786         }
787         //See if the file/dir is in the same directory than the rest
788         if (rtrim(cleardoubleslashes(dirname($tempfile)), "/") != $origpath) {
789             continue;
790         }
791         //Add the file to the array
792         $files[] = $tempfile;
793     }
795     $zipfiles = array();
796     $start = strlen($origpath)+1;
797     foreach($files as $file) {
798         $zipfiles[substr($file, $start)] = $file;
799     }
801     $packer = get_file_packer('application/zip');
803     return $packer->archive_to_pathname($zipfiles, $destpath . '/' . $destfilename);
806 /**
807  * @deprecated use groups_get_all_groups() instead.
808  */
809 function mygroupid($courseid) {
810     throw new coding_exception('mygroupid() can not be used any more, please use groups_get_all_groups() instead.');
814 /**
815  * Returns the current group mode for a given course or activity module
816  *
817  * Could be false, SEPARATEGROUPS or VISIBLEGROUPS    (<-- Martin)
818  *
819  * @param object $course Course Object
820  * @param object $cm Course Manager Object
821  * @return mixed $course->groupmode
822  */
823 function groupmode($course, $cm=null) {
825     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
826         return $cm->groupmode;
827     }
828     return $course->groupmode;
831 /**
832  * Sets the current group in the session variable
833  * When $SESSION->currentgroup[$courseid] is set to 0 it means, show all groups.
834  * Sets currentgroup[$courseid] in the session variable appropriately.
835  * Does not do any permission checking.
836  *
837  * @global object
838  * @param int $courseid The course being examined - relates to id field in
839  * 'course' table.
840  * @param int $groupid The group being examined.
841  * @return int Current group id which was set by this function
842  */
843 function set_current_group($courseid, $groupid) {
844     global $SESSION;
845     return $SESSION->currentgroup[$courseid] = $groupid;
849 /**
850  * Gets the current group - either from the session variable or from the database.
851  *
852  * @global object
853  * @param int $courseid The course being examined - relates to id field in
854  * 'course' table.
855  * @param bool $full If true, the return value is a full record object.
856  * If false, just the id of the record.
857  * @return int|bool
858  */
859 function get_current_group($courseid, $full = false) {
860     global $SESSION;
862     if (isset($SESSION->currentgroup[$courseid])) {
863         if ($full) {
864             return groups_get_group($SESSION->currentgroup[$courseid]);
865         } else {
866             return $SESSION->currentgroup[$courseid];
867         }
868     }
870     $mygroupid = mygroupid($courseid);
871     if (is_array($mygroupid)) {
872         $mygroupid = array_shift($mygroupid);
873         set_current_group($courseid, $mygroupid);
874         if ($full) {
875             return groups_get_group($mygroupid);
876         } else {
877             return $mygroupid;
878         }
879     }
881     if ($full) {
882         return false;
883     } else {
884         return 0;
885     }
888 /**
889  * Filter a user list and return only the users that can see the course module based on
890  * groups/permissions etc. It is assumed that the users are pre-filtered to those who are enrolled in the course.
891  *
892  * @category group
893  * @param stdClass|cm_info $cm The course module
894  * @param array $users An array of users, indexed by userid
895  * @return array A filtered list of users that can see the module, indexed by userid.
896  * @deprecated Since Moodle 2.8
897  */
898 function groups_filter_users_by_course_module_visible($cm, $users) {
899     debugging('groups_filter_users_by_course_module_visible() is deprecated. ' .
900             'Replace with a call to \core_availability\info_module::filter_user_list(), ' .
901             'which does basically the same thing but includes other restrictions such ' .
902             'as profile restrictions.', DEBUG_DEVELOPER);
903     if (empty($users)) {
904         return $users;
905     }
906     // Since this function allows stdclass, let's play it safe and ensure we
907     // do have a cm_info.
908     if (!($cm instanceof cm_info)) {
909         $modinfo = get_fast_modinfo($cm->course);
910         $cm = $modinfo->get_cm($cm->id);
911     }
912     $info = new \core_availability\info_module($cm);
913     return $info->filter_user_list($users);
916 /**
917  * Determine if a course module is currently visible to a user
918  *
919  * Deprecated (it was never very useful as it only took into account the
920  * groupmembersonly option and no other way of hiding activities). Always
921  * returns true.
922  *
923  * @category group
924  * @param stdClass|cm_info $cm The course module
925  * @param int $userid The user to check against the group.
926  * @return bool True
927  * @deprecated Since Moodle 2.8
928  */
929 function groups_course_module_visible($cm, $userid=null) {
930     debugging('groups_course_module_visible() is deprecated and always returns ' .
931             'true; use $cm->uservisible to decide whether the current user can ' .
932             'access an activity.', DEBUG_DEVELOPER);
933     return true;
936 /**
937  * Inndicates fatal error. This function was originally printing the
938  * error message directly, since 2.0 it is throwing exception instead.
939  * The error printing is handled in default exception handler.
940  *
941  * Old method, don't call directly in new code - use print_error instead.
942  *
943  * @param string $message The message to display to the user about the error.
944  * @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.
945  * @return void, always throws moodle_exception
946  */
947 function error($message, $link='') {
948     throw new moodle_exception('notlocalisederrormessage', 'error', $link, $message, 'error() is a deprecated function, please call print_error() instead of error()');
952 /**
953  * @deprecated use $PAGE->theme->name instead.
954  */
955 function current_theme() {
956     throw new coding_exception('current_theme() can not be used any more, please use $PAGE->theme->name instead');
959 /**
960  * Prints some red text using echo
961  *
962  * @deprecated
963  * @param string $error The text to be displayed in red
964  */
965 function formerr($error) {
966     debugging('formerr() has been deprecated. Please change your code to use $OUTPUT->error_text($string).');
967     global $OUTPUT;
968     echo $OUTPUT->error_text($error);
971 /**
972  * @deprecated use $OUTPUT->skip_link_target() in instead.
973  */
974 function skip_main_destination() {
975     throw new coding_exception('skip_main_destination() can not be used any more, please use $OUTPUT->skip_link_target() instead.');
978 /**
979  * @deprecated use $OUTPUT->container() instead.
980  */
981 function print_container($message, $clearfix=false, $classes='', $idbase='', $return=false) {
982     throw new coding_exception('print_container() can not be used any more. Please use $OUTPUT->container() instead.');
985 /**
986  * @deprecated use $OUTPUT->container_start() instead.
987  */
988 function print_container_start($clearfix=false, $classes='', $idbase='', $return=false) {
989     throw new coding_exception('print_container_start() can not be used any more. Please use $OUTPUT->container_start() instead.');
992 /**
993  * @deprecated use $OUTPUT->container_end() instead.
994  */
995 function print_container_end($return=false) {
996     throw new coding_exception('print_container_end() can not be used any more. Please use $OUTPUT->container_end() instead.');
999 /**
1000  * Print a bold message in an optional color.
1001  *
1002  * @deprecated use $OUTPUT->notification instead.
1003  * @param string $message The message to print out
1004  * @param string $style Optional style to display message text in
1005  * @param string $align Alignment option
1006  * @param bool $return whether to return an output string or echo now
1007  * @return string|bool Depending on $result
1008  */
1009 function notify($message, $classes = 'notifyproblem', $align = 'center', $return = false) {
1010     global $OUTPUT;
1012     if ($classes == 'green') {
1013         debugging('Use of deprecated class name "green" in notify. Please change to "notifysuccess".', DEBUG_DEVELOPER);
1014         $classes = 'notifysuccess'; // Backward compatible with old color system
1015     }
1017     $output = $OUTPUT->notification($message, $classes);
1018     if ($return) {
1019         return $output;
1020     } else {
1021         echo $output;
1022     }
1025 /**
1026  * @deprecated use $OUTPUT->continue_button() instead.
1027  */
1028 function print_continue($link, $return = false) {
1029     throw new coding_exception('print_continue() can not be used any more. Please use $OUTPUT->continue_button() instead.');
1032 /**
1033  * @deprecated use $PAGE methods instead.
1034  */
1035 function print_header($title='', $heading='', $navigation='', $focus='',
1036                       $meta='', $cache=true, $button='&nbsp;', $menu=null,
1037                       $usexml=false, $bodytags='', $return=false) {
1039     throw new coding_exception('print_header() can not be used any more. Please use $PAGE methods instead.');
1042 /**
1043  * @deprecated use $PAGE methods instead.
1044  */
1045 function print_header_simple($title='', $heading='', $navigation='', $focus='', $meta='',
1046                        $cache=true, $button='&nbsp;', $menu='', $usexml=false, $bodytags='', $return=false) {
1048     throw new coding_exception('print_header_simple() can not be used any more. Please use $PAGE methods instead.');
1051 /**
1052  * @deprecated use $OUTPUT->block() instead.
1053  */
1054 function print_side_block($heading='', $content='', $list=NULL, $icons=NULL, $footer='', $attributes = array(), $title='') {
1055     throw new coding_exception('print_side_block() can not be used any more, please use $OUTPUT->block() instead.');
1058 /**
1059  * Prints a basic textarea field.
1060  *
1061  * @deprecated since Moodle 2.0
1062  *
1063  * When using this function, you should
1064  *
1065  * @global object
1066  * @param bool $unused No longer used.
1067  * @param int $rows Number of rows to display  (minimum of 10 when $height is non-null)
1068  * @param int $cols Number of columns to display (minimum of 65 when $width is non-null)
1069  * @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.
1070  * @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.
1071  * @param string $name Name to use for the textarea element.
1072  * @param string $value Initial content to display in the textarea.
1073  * @param int $obsolete deprecated
1074  * @param bool $return If false, will output string. If true, will return string value.
1075  * @param string $id CSS ID to add to the textarea element.
1076  * @return string|void depending on the value of $return
1077  */
1078 function print_textarea($unused, $rows, $cols, $width, $height, $name, $value='', $obsolete=0, $return=false, $id='') {
1079     /// $width and height are legacy fields and no longer used as pixels like they used to be.
1080     /// However, you can set them to zero to override the mincols and minrows values below.
1082     // Disabling because there is not yet a viable $OUTPUT option for cases when mforms can't be used
1083     // debugging('print_textarea() has been deprecated. You should be using mforms and the editor element.');
1085     global $CFG;
1087     $mincols = 65;
1088     $minrows = 10;
1089     $str = '';
1091     if ($id === '') {
1092         $id = 'edit-'.$name;
1093     }
1095     if ($height && ($rows < $minrows)) {
1096         $rows = $minrows;
1097     }
1098     if ($width && ($cols < $mincols)) {
1099         $cols = $mincols;
1100     }
1102     editors_head_setup();
1103     $editor = editors_get_preferred_editor(FORMAT_HTML);
1104     $editor->use_editor($id, array('legacy'=>true));
1106     $str .= "\n".'<textarea class="form-textarea" id="'. $id .'" name="'. $name .'" rows="'. $rows .'" cols="'. $cols .'" spellcheck="true">'."\n";
1107     $str .= htmlspecialchars($value); // needed for editing of cleaned text!
1108     $str .= '</textarea>'."\n";
1110     if ($return) {
1111         return $str;
1112     }
1113     echo $str;
1116 /**
1117  * Returns a string of html with an image of a help icon linked to a help page on a number of help topics.
1118  * Should be used only with htmleditor or textarea.
1119  *
1120  * @global object
1121  * @global object
1122  * @param mixed $helptopics variable amount of params accepted. Each param may be a string or an array of arguments for
1123  *                  helpbutton.
1124  * @return string Link to help button
1125  */
1126 function editorhelpbutton(){
1127     return '';
1129     /// TODO: MDL-21215
1132 /**
1133  * Print a help button.
1134  *
1135  * Prints a special help button for html editors (htmlarea in this case)
1136  *
1137  * @todo Write code into this function! detect current editor and print correct info
1138  * @global object
1139  * @return string Only returns an empty string at the moment
1140  */
1141 function editorshortcutshelpbutton() {
1142     /// TODO: MDL-21215
1144     global $CFG;
1145     //TODO: detect current editor and print correct info
1146     return '';
1150 /**
1151  * Returns an image of an up or down arrow, used for column sorting. To avoid unnecessary DB accesses, please
1152  * provide this function with the language strings for sortasc and sortdesc.
1153  *
1154  * @deprecated use $OUTPUT->arrow() instead.
1155  * @todo final deprecation of this function once MDL-45448 is resolved
1156  *
1157  * If no sort string is associated with the direction, an arrow with no alt text will be printed/returned.
1158  *
1159  * @global object
1160  * @param string $direction 'up' or 'down'
1161  * @param string $strsort The language string used for the alt attribute of this image
1162  * @param bool $return Whether to print directly or return the html string
1163  * @return string|void depending on $return
1164  *
1165  */
1166 function print_arrow($direction='up', $strsort=null, $return=false) {
1167     global $OUTPUT;
1169     debugging('print_arrow() is deprecated. Please use $OUTPUT->arrow() instead.', DEBUG_DEVELOPER);
1171     if (!in_array($direction, array('up', 'down', 'right', 'left', 'move'))) {
1172         return null;
1173     }
1175     $return = null;
1177     switch ($direction) {
1178         case 'up':
1179             $sortdir = 'asc';
1180             break;
1181         case 'down':
1182             $sortdir = 'desc';
1183             break;
1184         case 'move':
1185             $sortdir = 'asc';
1186             break;
1187         default:
1188             $sortdir = null;
1189             break;
1190     }
1192     // Prepare language string
1193     $strsort = '';
1194     if (empty($strsort) && !empty($sortdir)) {
1195         $strsort  = get_string('sort' . $sortdir, 'grades');
1196     }
1198     $return = ' <img src="'.$OUTPUT->pix_url('t/' . $direction) . '" alt="'.$strsort.'" /> ';
1200     if ($return) {
1201         return $return;
1202     } else {
1203         echo $return;
1204     }
1207 /**
1208  * Given an array of values, output the HTML for a select element with those options.
1209  *
1210  * @deprecated since Moodle 2.0
1211  *
1212  * Normally, you only need to use the first few parameters.
1213  *
1214  * @param array $options The options to offer. An array of the form
1215  *      $options[{value}] = {text displayed for that option};
1216  * @param string $name the name of this form control, as in &lt;select name="..." ...
1217  * @param string $selected the option to select initially, default none.
1218  * @param string $nothing The label for the 'nothing is selected' option. Defaults to get_string('choose').
1219  *      Set this to '' if you don't want a 'nothing is selected' option.
1220  * @param string $script if not '', then this is added to the &lt;select> element as an onchange handler.
1221  * @param string $nothingvalue The value corresponding to the $nothing option. Defaults to 0.
1222  * @param boolean $return if false (the default) the the output is printed directly, If true, the
1223  *      generated HTML is returned as a string.
1224  * @param boolean $disabled if true, the select is generated in a disabled state. Default, false.
1225  * @param int $tabindex if give, sets the tabindex attribute on the &lt;select> element. Default none.
1226  * @param string $id value to use for the id attribute of the &lt;select> element. If none is given,
1227  *      then a suitable one is constructed.
1228  * @param mixed $listbox if false, display as a dropdown menu. If true, display as a list box.
1229  *      By default, the list box will have a number of rows equal to min(10, count($options)), but if
1230  *      $listbox is an integer, that number is used for size instead.
1231  * @param boolean $multiple if true, enable multiple selections, else only 1 item can be selected. Used
1232  *      when $listbox display is enabled
1233  * @param string $class value to use for the class attribute of the &lt;select> element. If none is given,
1234  *      then a suitable one is constructed.
1235  * @return string|void If $return=true returns string, else echo's and returns void
1236  */
1237 function choose_from_menu ($options, $name, $selected='', $nothing='choose', $script='',
1238                            $nothingvalue='0', $return=false, $disabled=false, $tabindex=0,
1239                            $id='', $listbox=false, $multiple=false, $class='') {
1241     global $OUTPUT;
1242     debugging('choose_from_menu() has been deprecated. Please change your code to use html_writer::select().');
1244     if ($script) {
1245         debugging('The $script parameter has been deprecated. You must use component_actions instead', DEBUG_DEVELOPER);
1246     }
1247     $attributes = array();
1248     $attributes['disabled'] = $disabled ? 'disabled' : null;
1249     $attributes['tabindex'] = $tabindex ? $tabindex : null;
1250     $attributes['multiple'] = $multiple ? $multiple : null;
1251     $attributes['class'] = $class ? $class : null;
1252     $attributes['id'] = $id ? $id : null;
1254     $output = html_writer::select($options, $name, $selected, array($nothingvalue=>$nothing), $attributes);
1256     if ($return) {
1257         return $output;
1258     } else {
1259         echo $output;
1260     }
1263 /**
1264  * @deprecated use $OUTPUT->help_icon_scale($courseid, $scale) instead.
1265  */
1266 function print_scale_menu_helpbutton($courseid, $scale, $return=false) {
1267     throw new coding_exception('print_scale_menu_helpbutton() can not be used any more. '.
1268         'Please use $OUTPUT->help_icon_scale($courseid, $scale) instead.');
1271 /**
1272  * @deprecated use html_writer::checkbox() instead.
1273  */
1274 function print_checkbox($name, $value, $checked = true, $label = '', $alt = '', $script='', $return=false) {
1275     throw new coding_exception('print_checkbox() can not be used any more. Please use html_writer::checkbox() instead.');
1278 /**
1279  * Prints the 'update this xxx' button that appears on module pages.
1280  *
1281  * @deprecated since Moodle 2.0
1282  *
1283  * @param string $cmid the course_module id.
1284  * @param string $ignored not used any more. (Used to be courseid.)
1285  * @param string $string the module name - get_string('modulename', 'xxx')
1286  * @return string the HTML for the button, if this user has permission to edit it, else an empty string.
1287  */
1288 function update_module_button($cmid, $ignored, $string) {
1289     global $CFG, $OUTPUT;
1291     // debugging('update_module_button() has been deprecated. Please change your code to use $OUTPUT->update_module_button().');
1293     //NOTE: DO NOT call new output method because it needs the module name we do not have here!
1295     if (has_capability('moodle/course:manageactivities', context_module::instance($cmid))) {
1296         $string = get_string('updatethis', '', $string);
1298         $url = new moodle_url("$CFG->wwwroot/course/mod.php", array('update' => $cmid, 'return' => true, 'sesskey' => sesskey()));
1299         return $OUTPUT->single_button($url, $string);
1300     } else {
1301         return '';
1302     }
1305 /**
1306  * @deprecated use $OUTPUT->navbar() instead
1307  */
1308 function print_navigation ($navigation, $separator=0, $return=false) {
1309     throw new coding_exception('print_navigation() can not be used any more, please update use $OUTPUT->navbar() instead.');
1312 /**
1313  * @deprecated Please use $PAGE->navabar methods instead.
1314  */
1315 function build_navigation($extranavlinks, $cm = null) {
1316     throw new coding_exception('build_navigation() can not be used any more, please use $PAGE->navbar methods instead.');
1319 /**
1320  * @deprecated not relevant with global navigation in Moodle 2.x+
1321  */
1322 function navmenu($course, $cm=NULL, $targetwindow='self') {
1323     throw new coding_exception('navmenu() can not be used any more, it is no longer relevant with global navigation.');
1326 /// CALENDAR MANAGEMENT  ////////////////////////////////////////////////////////////////
1329 /**
1330  * @deprecated please use calendar_event::create() instead.
1331  */
1332  function add_event($event) {
1333     throw new coding_exception('add_event() can not be used any more, please use calendar_event::create() instead.');
1336 /**
1337  * Call this function to update an event in the calendar table
1338  * the event will be identified by the id field of the $event object.
1339  *
1340  * @param object $event An object representing an event from the calendar table. The event will be identified by the id field.
1341  * @return bool Success
1342  * @deprecated please calendar_event->update() instead.
1343  */
1344 function update_event($event) {
1345     global $CFG;
1346     require_once($CFG->dirroot.'/calendar/lib.php');
1348     debugging('update_event() is deprecated, please use calendar_event->update() instead.', DEBUG_DEVELOPER);
1349     $event = (object)$event;
1350     $calendarevent = calendar_event::load($event->id);
1351     return $calendarevent->update($event);
1354 /**
1355  * @deprecated please use calendar_event->delete() instead.
1356  */
1357 function delete_event($id) {
1358     throw new coding_exception('delete_event() can not be used any more, please use '.
1359         'calendar_event->delete() instead.');
1362 /**
1363  * @deprecated please use calendar_event->toggle_visibility(false) instead.
1364  */
1365 function hide_event($event) {
1366     throw new coding_exception('hide_event() can not be used any more, please use '.
1367         'calendar_event->toggle_visibility(false) instead.');
1370 /**
1371  * @deprecated please use calendar_event->toggle_visibility(true) instead.
1372  */
1373 function show_event($event) {
1374     throw new coding_exception('show_event() can not be used any more, please use '.
1375         'calendar_event->toggle_visibility(true) instead.');
1378 /**
1379  * Original singleton helper function, please use static methods instead,
1380  * ex: core_text::convert()
1381  *
1382  * @deprecated since Moodle 2.2 use core_text::xxxx() instead
1383  * @see textlib
1384  * @return textlib instance
1385  */
1386 function textlib_get_instance() {
1388     debugging('textlib_get_instance() is deprecated. Please use static calling core_text::functioname() instead.', DEBUG_DEVELOPER);
1390     return new textlib();
1393 /**
1394  * Gets the generic section name for a courses section
1395  *
1396  * The global function is deprecated. Each course format can define their own generic section name
1397  *
1398  * @deprecated since 2.4
1399  * @see get_section_name()
1400  * @see format_base::get_section_name()
1401  *
1402  * @param string $format Course format ID e.g. 'weeks' $course->format
1403  * @param stdClass $section Section object from database
1404  * @return Display name that the course format prefers, e.g. "Week 2"
1405  */
1406 function get_generic_section_name($format, stdClass $section) {
1407     debugging('get_generic_section_name() is deprecated. Please use appropriate functionality from class format_base', DEBUG_DEVELOPER);
1408     return get_string('sectionname', "format_$format") . ' ' . $section->section;
1411 /**
1412  * Returns an array of sections for the requested course id
1413  *
1414  * It is usually not recommended to display the list of sections used
1415  * in course because the course format may have it's own way to do it.
1416  *
1417  * If you need to just display the name of the section please call:
1418  * get_section_name($course, $section)
1419  * {@link get_section_name()}
1420  * from 2.4 $section may also be just the field course_sections.section
1421  *
1422  * If you need the list of all sections it is more efficient to get this data by calling
1423  * $modinfo = get_fast_modinfo($courseorid);
1424  * $sections = $modinfo->get_section_info_all()
1425  * {@link get_fast_modinfo()}
1426  * {@link course_modinfo::get_section_info_all()}
1427  *
1428  * Information about one section (instance of section_info):
1429  * get_fast_modinfo($courseorid)->get_sections_info($section)
1430  * {@link course_modinfo::get_section_info()}
1431  *
1432  * @deprecated since 2.4
1433  *
1434  * @param int $courseid
1435  * @return array Array of section_info objects
1436  */
1437 function get_all_sections($courseid) {
1438     global $DB;
1439     debugging('get_all_sections() is deprecated. See phpdocs for this function', DEBUG_DEVELOPER);
1440     return get_fast_modinfo($courseid)->get_section_info_all();
1443 /**
1444  * Given a full mod object with section and course already defined, adds this module to that section.
1445  *
1446  * This function is deprecated, please use {@link course_add_cm_to_section()}
1447  * Note that course_add_cm_to_section() also updates field course_modules.section and
1448  * calls rebuild_course_cache()
1449  *
1450  * @deprecated since 2.4
1451  *
1452  * @param object $mod
1453  * @param int $beforemod An existing ID which we will insert the new module before
1454  * @return int The course_sections ID where the mod is inserted
1455  */
1456 function add_mod_to_section($mod, $beforemod = null) {
1457     debugging('Function add_mod_to_section() is deprecated, please use course_add_cm_to_section()', DEBUG_DEVELOPER);
1458     global $DB;
1459     return course_add_cm_to_section($mod->course, $mod->coursemodule, $mod->section, $beforemod);
1462 /**
1463  * Returns a number of useful structures for course displays
1464  *
1465  * Function get_all_mods() is deprecated in 2.4
1466  * Instead of:
1467  * <code>
1468  * get_all_mods($courseid, $mods, $modnames, $modnamesplural, $modnamesused);
1469  * </code>
1470  * please use:
1471  * <code>
1472  * $mods = get_fast_modinfo($courseorid)->get_cms();
1473  * $modnames = get_module_types_names();
1474  * $modnamesplural = get_module_types_names(true);
1475  * $modnamesused = get_fast_modinfo($courseorid)->get_used_module_names();
1476  * </code>
1477  *
1478  * @deprecated since 2.4
1479  *
1480  * @param int $courseid id of the course to get info about
1481  * @param array $mods (return) list of course modules
1482  * @param array $modnames (return) list of names of all module types installed and available
1483  * @param array $modnamesplural (return) list of names of all module types installed and available in the plural form
1484  * @param array $modnamesused (return) list of names of all module types used in the course
1485  */
1486 function get_all_mods($courseid, &$mods, &$modnames, &$modnamesplural, &$modnamesused) {
1487     debugging('Function get_all_mods() is deprecated. Use get_fast_modinfo() and get_module_types_names() instead. See phpdocs for details', DEBUG_DEVELOPER);
1489     global $COURSE;
1490     $modnames      = get_module_types_names();
1491     $modnamesplural= get_module_types_names(true);
1492     $modinfo = get_fast_modinfo($courseid);
1493     $mods = $modinfo->get_cms();
1494     $modnamesused = $modinfo->get_used_module_names();
1497 /**
1498  * Returns course section - creates new if does not exist yet
1499  *
1500  * This function is deprecated. To create a course section call:
1501  * course_create_sections_if_missing($courseorid, $sections);
1502  * to get the section call:
1503  * get_fast_modinfo($courseorid)->get_section_info($sectionnum);
1504  *
1505  * @see course_create_sections_if_missing()
1506  * @see get_fast_modinfo()
1507  * @deprecated since 2.4
1508  *
1509  * @param int $section relative section number (field course_sections.section)
1510  * @param int $courseid
1511  * @return stdClass record from table {course_sections}
1512  */
1513 function get_course_section($section, $courseid) {
1514     global $DB;
1515     debugging('Function get_course_section() is deprecated. Please use course_create_sections_if_missing() and get_fast_modinfo() instead.', DEBUG_DEVELOPER);
1517     if ($cw = $DB->get_record("course_sections", array("section"=>$section, "course"=>$courseid))) {
1518         return $cw;
1519     }
1520     $cw = new stdClass();
1521     $cw->course   = $courseid;
1522     $cw->section  = $section;
1523     $cw->summary  = "";
1524     $cw->summaryformat = FORMAT_HTML;
1525     $cw->sequence = "";
1526     $id = $DB->insert_record("course_sections", $cw);
1527     rebuild_course_cache($courseid, true);
1528     return $DB->get_record("course_sections", array("id"=>$id));
1531 /**
1532  * Return the start and end date of the week in Weekly course format
1533  *
1534  * It is not recommended to use this function outside of format_weeks plugin
1535  *
1536  * @deprecated since 2.4
1537  * @see format_weeks::get_section_dates()
1538  *
1539  * @param stdClass $section The course_section entry from the DB
1540  * @param stdClass $course The course entry from DB
1541  * @return stdClass property start for startdate, property end for enddate
1542  */
1543 function format_weeks_get_section_dates($section, $course) {
1544     debugging('Function format_weeks_get_section_dates() is deprecated. It is not recommended to'.
1545             ' use it outside of format_weeks plugin', DEBUG_DEVELOPER);
1546     if (isset($course->format) && $course->format === 'weeks') {
1547         return course_get_format($course)->get_section_dates($section);
1548     }
1549     return null;
1552 /**
1553  * Obtains shared data that is used in print_section when displaying a
1554  * course-module entry.
1555  *
1556  * Deprecated. Instead of:
1557  * list($content, $name) = get_print_section_cm_text($cm, $course);
1558  * use:
1559  * $content = $cm->get_formatted_content(array('overflowdiv' => true, 'noclean' => true));
1560  * $name = $cm->get_formatted_name();
1561  *
1562  * @deprecated since 2.5
1563  * @see cm_info::get_formatted_content()
1564  * @see cm_info::get_formatted_name()
1565  *
1566  * This data is also used in other areas of the code.
1567  * @param cm_info $cm Course-module data (must come from get_fast_modinfo)
1568  * @param object $course (argument not used)
1569  * @return array An array with the following values in this order:
1570  *   $content (optional extra content for after link),
1571  *   $instancename (text of link)
1572  */
1573 function get_print_section_cm_text(cm_info $cm, $course) {
1574     debugging('Function get_print_section_cm_text() is deprecated. Please use '.
1575             'cm_info::get_formatted_content() and cm_info::get_formatted_name()',
1576             DEBUG_DEVELOPER);
1577     return array($cm->get_formatted_content(array('overflowdiv' => true, 'noclean' => true)),
1578         $cm->get_formatted_name());
1581 /**
1582  * Prints the menus to add activities and resources.
1583  *
1584  * Deprecated. Please use:
1585  * $courserenderer = $PAGE->get_renderer('core', 'course');
1586  * $output = $courserenderer->course_section_add_cm_control($course, $section, $sectionreturn,
1587  *    array('inblock' => $vertical));
1588  * echo $output; // if $return argument in print_section_add_menus() set to false
1589  *
1590  * @deprecated since 2.5
1591  * @see core_course_renderer::course_section_add_cm_control()
1592  *
1593  * @param stdClass $course course object, must be the same as set on the page
1594  * @param int $section relative section number (field course_sections.section)
1595  * @param null|array $modnames (argument ignored) get_module_types_names() is used instead of argument
1596  * @param bool $vertical Vertical orientation
1597  * @param bool $return Return the menus or send them to output
1598  * @param int $sectionreturn The section to link back to
1599  * @return void|string depending on $return
1600  */
1601 function print_section_add_menus($course, $section, $modnames = null, $vertical=false, $return=false, $sectionreturn=null) {
1602     global $PAGE;
1603     debugging('Function print_section_add_menus() is deprecated. Please use course renderer '.
1604             'function course_section_add_cm_control()', DEBUG_DEVELOPER);
1605     $output = '';
1606     $courserenderer = $PAGE->get_renderer('core', 'course');
1607     $output = $courserenderer->course_section_add_cm_control($course, $section, $sectionreturn,
1608             array('inblock' => $vertical));
1609     if ($return) {
1610         return $output;
1611     } else {
1612         echo $output;
1613         return !empty($output);
1614     }
1617 /**
1618  * Produces the editing buttons for a module
1619  *
1620  * Deprecated. Please use:
1621  * $courserenderer = $PAGE->get_renderer('core', 'course');
1622  * $actions = course_get_cm_edit_actions($mod, $indent, $section);
1623  * return ' ' . $courserenderer->course_section_cm_edit_actions($actions);
1624  *
1625  * @deprecated since 2.5
1626  * @see course_get_cm_edit_actions()
1627  * @see core_course_renderer->course_section_cm_edit_actions()
1628  *
1629  * @param stdClass $mod The module to produce editing buttons for
1630  * @param bool $absolute_ignored (argument ignored) - all links are absolute
1631  * @param bool $moveselect (argument ignored)
1632  * @param int $indent The current indenting
1633  * @param int $section The section to link back to
1634  * @return string XHTML for the editing buttons
1635  */
1636 function make_editing_buttons(stdClass $mod, $absolute_ignored = true, $moveselect = true, $indent=-1, $section=null) {
1637     global $PAGE;
1638     debugging('Function make_editing_buttons() is deprecated, please see PHPdocs in '.
1639             'lib/deprecatedlib.php on how to replace it', DEBUG_DEVELOPER);
1640     if (!($mod instanceof cm_info)) {
1641         $modinfo = get_fast_modinfo($mod->course);
1642         $mod = $modinfo->get_cm($mod->id);
1643     }
1644     $actions = course_get_cm_edit_actions($mod, $indent, $section);
1646     $courserenderer = $PAGE->get_renderer('core', 'course');
1647     // The space added before the <span> is a ugly hack but required to set the CSS property white-space: nowrap
1648     // and having it to work without attaching the preceding text along with it. Hopefully the refactoring of
1649     // the course page HTML will allow this to be removed.
1650     return ' ' . $courserenderer->course_section_cm_edit_actions($actions);
1653 /**
1654  * Prints a section full of activity modules
1655  *
1656  * Deprecated. Please use:
1657  * $courserenderer = $PAGE->get_renderer('core', 'course');
1658  * echo $courserenderer->course_section_cm_list($course, $section, $sectionreturn,
1659  *     array('hidecompletion' => $hidecompletion));
1660  *
1661  * @deprecated since 2.5
1662  * @see core_course_renderer::course_section_cm_list()
1663  *
1664  * @param stdClass $course The course
1665  * @param stdClass|section_info $section The section object containing properties id and section
1666  * @param array $mods (argument not used)
1667  * @param array $modnamesused (argument not used)
1668  * @param bool $absolute (argument not used)
1669  * @param string $width (argument not used)
1670  * @param bool $hidecompletion Hide completion status
1671  * @param int $sectionreturn The section to return to
1672  * @return void
1673  */
1674 function print_section($course, $section, $mods, $modnamesused, $absolute=false, $width="100%", $hidecompletion=false, $sectionreturn=null) {
1675     global $PAGE;
1676     debugging('Function print_section() is deprecated. Please use course renderer function '.
1677             'course_section_cm_list() instead.', DEBUG_DEVELOPER);
1678     $displayoptions = array('hidecompletion' => $hidecompletion);
1679     $courserenderer = $PAGE->get_renderer('core', 'course');
1680     echo $courserenderer->course_section_cm_list($course, $section, $sectionreturn, $displayoptions);
1683 /**
1684  * Displays the list of courses with user notes
1685  *
1686  * This function is not used in core. It was replaced by block course_overview
1687  *
1688  * @deprecated since 2.5
1689  *
1690  * @param array $courses
1691  * @param array $remote_courses
1692  */
1693 function print_overview($courses, array $remote_courses=array()) {
1694     global $CFG, $USER, $DB, $OUTPUT;
1695     debugging('Function print_overview() is deprecated. Use block course_overview to display this information', DEBUG_DEVELOPER);
1697     $htmlarray = array();
1698     if ($modules = $DB->get_records('modules')) {
1699         foreach ($modules as $mod) {
1700             if (file_exists(dirname(dirname(__FILE__)).'/mod/'.$mod->name.'/lib.php')) {
1701                 include_once(dirname(dirname(__FILE__)).'/mod/'.$mod->name.'/lib.php');
1702                 $fname = $mod->name.'_print_overview';
1703                 if (function_exists($fname)) {
1704                     $fname($courses,$htmlarray);
1705                 }
1706             }
1707         }
1708     }
1709     foreach ($courses as $course) {
1710         $fullname = format_string($course->fullname, true, array('context' => context_course::instance($course->id)));
1711         echo $OUTPUT->box_start('coursebox');
1712         $attributes = array('title' => s($fullname));
1713         if (empty($course->visible)) {
1714             $attributes['class'] = 'dimmed';
1715         }
1716         echo $OUTPUT->heading(html_writer::link(
1717             new moodle_url('/course/view.php', array('id' => $course->id)), $fullname, $attributes), 3);
1718         if (array_key_exists($course->id,$htmlarray)) {
1719             foreach ($htmlarray[$course->id] as $modname => $html) {
1720                 echo $html;
1721             }
1722         }
1723         echo $OUTPUT->box_end();
1724     }
1726     if (!empty($remote_courses)) {
1727         echo $OUTPUT->heading(get_string('remotecourses', 'mnet'));
1728     }
1729     foreach ($remote_courses as $course) {
1730         echo $OUTPUT->box_start('coursebox');
1731         $attributes = array('title' => s($course->fullname));
1732         echo $OUTPUT->heading(html_writer::link(
1733             new moodle_url('/auth/mnet/jump.php', array('hostid' => $course->hostid, 'wantsurl' => '/course/view.php?id='.$course->remoteid)),
1734             format_string($course->shortname),
1735             $attributes) . ' (' . format_string($course->hostname) . ')', 3);
1736         echo $OUTPUT->box_end();
1737     }
1740 /**
1741  * This function trawls through the logs looking for
1742  * anything new since the user's last login
1743  *
1744  * This function was only used to print the content of block recent_activity
1745  * All functionality is moved into class {@link block_recent_activity}
1746  * and renderer {@link block_recent_activity_renderer}
1747  *
1748  * @deprecated since 2.5
1749  * @param stdClass $course
1750  */
1751 function print_recent_activity($course) {
1752     // $course is an object
1753     global $CFG, $USER, $SESSION, $DB, $OUTPUT;
1754     debugging('Function print_recent_activity() is deprecated. It is not recommended to'.
1755             ' use it outside of block_recent_activity', DEBUG_DEVELOPER);
1757     $context = context_course::instance($course->id);
1759     $viewfullnames = has_capability('moodle/site:viewfullnames', $context);
1761     $timestart = round(time() - COURSE_MAX_RECENT_PERIOD, -2); // better db caching for guests - 100 seconds
1763     if (!isguestuser()) {
1764         if (!empty($USER->lastcourseaccess[$course->id])) {
1765             if ($USER->lastcourseaccess[$course->id] > $timestart) {
1766                 $timestart = $USER->lastcourseaccess[$course->id];
1767             }
1768         }
1769     }
1771     echo '<div class="activitydate">';
1772     echo get_string('activitysince', '', userdate($timestart));
1773     echo '</div>';
1774     echo '<div class="activityhead">';
1776     echo '<a href="'.$CFG->wwwroot.'/course/recent.php?id='.$course->id.'">'.get_string('recentactivityreport').'</a>';
1778     echo "</div>\n";
1780     $content = false;
1782 /// Firstly, have there been any new enrolments?
1784     $users = get_recent_enrolments($course->id, $timestart);
1786     //Accessibility: new users now appear in an <OL> list.
1787     if ($users) {
1788         echo '<div class="newusers">';
1789         echo $OUTPUT->heading(get_string("newusers").':', 3);
1790         $content = true;
1791         echo "<ol class=\"list\">\n";
1792         foreach ($users as $user) {
1793             $fullname = fullname($user, $viewfullnames);
1794             echo '<li class="name"><a href="'."$CFG->wwwroot/user/view.php?id=$user->id&amp;course=$course->id\">$fullname</a></li>\n";
1795         }
1796         echo "</ol>\n</div>\n";
1797     }
1799 /// Next, have there been any modifications to the course structure?
1801     $modinfo = get_fast_modinfo($course);
1803     $changelist = array();
1805     $logs = $DB->get_records_select('log', "time > ? AND course = ? AND
1806                                             module = 'course' AND
1807                                             (action = 'add mod' OR action = 'update mod' OR action = 'delete mod')",
1808                                     array($timestart, $course->id), "id ASC");
1810     if ($logs) {
1811         $actions  = array('add mod', 'update mod', 'delete mod');
1812         $newgones = array(); // added and later deleted items
1813         foreach ($logs as $key => $log) {
1814             if (!in_array($log->action, $actions)) {
1815                 continue;
1816             }
1817             $info = explode(' ', $log->info);
1819             // note: in most cases I replaced hardcoding of label with use of
1820             // $cm->has_view() but it was not possible to do this here because
1821             // we don't necessarily have the $cm for it
1822             if ($info[0] == 'label') {     // Labels are ignored in recent activity
1823                 continue;
1824             }
1826             if (count($info) != 2) {
1827                 debugging("Incorrect log entry info: id = ".$log->id, DEBUG_DEVELOPER);
1828                 continue;
1829             }
1831             $modname    = $info[0];
1832             $instanceid = $info[1];
1834             if ($log->action == 'delete mod') {
1835                 // unfortunately we do not know if the mod was visible
1836                 if (!array_key_exists($log->info, $newgones)) {
1837                     $strdeleted = get_string('deletedactivity', 'moodle', get_string('modulename', $modname));
1838                     $changelist[$log->info] = array ('operation' => 'delete', 'text' => $strdeleted);
1839                 }
1840             } else {
1841                 if (!isset($modinfo->instances[$modname][$instanceid])) {
1842                     if ($log->action == 'add mod') {
1843                         // do not display added and later deleted activities
1844                         $newgones[$log->info] = true;
1845                     }
1846                     continue;
1847                 }
1848                 $cm = $modinfo->instances[$modname][$instanceid];
1849                 if (!$cm->uservisible) {
1850                     continue;
1851                 }
1853                 if ($log->action == 'add mod') {
1854                     $stradded = get_string('added', 'moodle', get_string('modulename', $modname));
1855                     $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>");
1857                 } else if ($log->action == 'update mod' and empty($changelist[$log->info])) {
1858                     $strupdated = get_string('updated', 'moodle', get_string('modulename', $modname));
1859                     $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>");
1860                 }
1861             }
1862         }
1863     }
1865     if (!empty($changelist)) {
1866         echo $OUTPUT->heading(get_string("courseupdates").':', 3);
1867         $content = true;
1868         foreach ($changelist as $changeinfo => $change) {
1869             echo '<p class="activity">'.$change['text'].'</p>';
1870         }
1871     }
1873 /// Now display new things from each module
1875     $usedmodules = array();
1876     foreach($modinfo->cms as $cm) {
1877         if (isset($usedmodules[$cm->modname])) {
1878             continue;
1879         }
1880         if (!$cm->uservisible) {
1881             continue;
1882         }
1883         $usedmodules[$cm->modname] = $cm->modname;
1884     }
1886     foreach ($usedmodules as $modname) {      // Each module gets it's own logs and prints them
1887         if (file_exists($CFG->dirroot.'/mod/'.$modname.'/lib.php')) {
1888             include_once($CFG->dirroot.'/mod/'.$modname.'/lib.php');
1889             $print_recent_activity = $modname.'_print_recent_activity';
1890             if (function_exists($print_recent_activity)) {
1891                 // NOTE: original $isteacher (second parameter below) was replaced with $viewfullnames!
1892                 $content = $print_recent_activity($course, $viewfullnames, $timestart) || $content;
1893             }
1894         } else {
1895             debugging("Missing lib.php in lib/{$modname} - please reinstall files or uninstall the module");
1896         }
1897     }
1899     if (! $content) {
1900         echo '<p class="message">'.get_string('nothingnew').'</p>';
1901     }
1904 /**
1905  * Delete a course module and any associated data at the course level (events)
1906  * Until 1.5 this function simply marked a deleted flag ... now it
1907  * deletes it completely.
1908  *
1909  * @deprecated since 2.5
1910  *
1911  * @param int $id the course module id
1912  * @return boolean true on success, false on failure
1913  */
1914 function delete_course_module($id) {
1915     debugging('Function delete_course_module() is deprecated. Please use course_delete_module() instead.', DEBUG_DEVELOPER);
1917     global $CFG, $DB;
1919     require_once($CFG->libdir.'/gradelib.php');
1920     require_once($CFG->dirroot.'/blog/lib.php');
1922     if (!$cm = $DB->get_record('course_modules', array('id'=>$id))) {
1923         return true;
1924     }
1925     $modulename = $DB->get_field('modules', 'name', array('id'=>$cm->module));
1926     //delete events from calendar
1927     if ($events = $DB->get_records('event', array('instance'=>$cm->instance, 'modulename'=>$modulename))) {
1928         foreach($events as $event) {
1929             delete_event($event->id);
1930         }
1931     }
1932     //delete grade items, outcome items and grades attached to modules
1933     if ($grade_items = grade_item::fetch_all(array('itemtype'=>'mod', 'itemmodule'=>$modulename,
1934                                                    'iteminstance'=>$cm->instance, 'courseid'=>$cm->course))) {
1935         foreach ($grade_items as $grade_item) {
1936             $grade_item->delete('moddelete');
1937         }
1938     }
1939     // Delete completion and availability data; it is better to do this even if the
1940     // features are not turned on, in case they were turned on previously (these will be
1941     // very quick on an empty table)
1942     $DB->delete_records('course_modules_completion', array('coursemoduleid' => $cm->id));
1943     $DB->delete_records('course_completion_criteria', array('moduleinstance' => $cm->id,
1944                                                             'criteriatype' => COMPLETION_CRITERIA_TYPE_ACTIVITY));
1946     delete_context(CONTEXT_MODULE, $cm->id);
1947     return $DB->delete_records('course_modules', array('id'=>$cm->id));
1950 /**
1951  * Prints the turn editing on/off button on course/index.php or course/category.php.
1952  *
1953  * @deprecated since 2.5
1954  *
1955  * @param integer $categoryid The id of the category we are showing, or 0 for system context.
1956  * @return string HTML of the editing button, or empty string, if this user is not allowed
1957  *      to see it.
1958  */
1959 function update_category_button($categoryid = 0) {
1960     global $CFG, $PAGE, $OUTPUT;
1961     debugging('Function update_category_button() is deprecated. Pages to view '.
1962             'and edit courses are now separate and no longer depend on editing mode.',
1963             DEBUG_DEVELOPER);
1965     // Check permissions.
1966     if (!can_edit_in_category($categoryid)) {
1967         return '';
1968     }
1970     // Work out the appropriate action.
1971     if ($PAGE->user_is_editing()) {
1972         $label = get_string('turneditingoff');
1973         $edit = 'off';
1974     } else {
1975         $label = get_string('turneditingon');
1976         $edit = 'on';
1977     }
1979     // Generate the button HTML.
1980     $options = array('categoryedit' => $edit, 'sesskey' => sesskey());
1981     if ($categoryid) {
1982         $options['id'] = $categoryid;
1983         $page = 'category.php';
1984     } else {
1985         $page = 'index.php';
1986     }
1987     return $OUTPUT->single_button(new moodle_url('/course/' . $page, $options), $label, 'get');
1990 /**
1991  * This function recursively travels the categories, building up a nice list
1992  * for display. It also makes an array that list all the parents for each
1993  * category.
1994  *
1995  * For example, if you have a tree of categories like:
1996  *   Miscellaneous (id = 1)
1997  *      Subcategory (id = 2)
1998  *         Sub-subcategory (id = 4)
1999  *   Other category (id = 3)
2000  * Then after calling this function you will have
2001  * $list = array(1 => 'Miscellaneous', 2 => 'Miscellaneous / Subcategory',
2002  *      4 => 'Miscellaneous / Subcategory / Sub-subcategory',
2003  *      3 => 'Other category');
2004  * $parents = array(2 => array(1), 4 => array(1, 2));
2005  *
2006  * If you specify $requiredcapability, then only categories where the current
2007  * user has that capability will be added to $list, although all categories
2008  * will still be added to $parents, and if you only have $requiredcapability
2009  * in a child category, not the parent, then the child catgegory will still be
2010  * included.
2011  *
2012  * If you specify the option $excluded, then that category, and all its children,
2013  * are omitted from the tree. This is useful when you are doing something like
2014  * moving categories, where you do not want to allow people to move a category
2015  * to be the child of itself.
2016  *
2017  * This function is deprecated! For list of categories use
2018  * coursecat::make_all_categories($requiredcapability, $excludeid, $separator)
2019  * For parents of one particular category use
2020  * coursecat::get($id)->get_parents()
2021  *
2022  * @deprecated since 2.5
2023  *
2024  * @param array $list For output, accumulates an array categoryid => full category path name
2025  * @param array $parents For output, accumulates an array categoryid => list of parent category ids.
2026  * @param string/array $requiredcapability if given, only categories where the current
2027  *      user has this capability will be added to $list. Can also be an array of capabilities,
2028  *      in which case they are all required.
2029  * @param integer $excludeid Omit this category and its children from the lists built.
2030  * @param object $category Not used
2031  * @param string $path Not used
2032  */
2033 function make_categories_list(&$list, &$parents, $requiredcapability = '',
2034         $excludeid = 0, $category = NULL, $path = "") {
2035     global $CFG, $DB;
2036     require_once($CFG->libdir.'/coursecatlib.php');
2038     debugging('Global function make_categories_list() is deprecated. Please use '.
2039             'coursecat::make_categories_list() and coursecat::get_parents()',
2040             DEBUG_DEVELOPER);
2042     // For categories list use just this one function:
2043     if (empty($list)) {
2044         $list = array();
2045     }
2046     $list += coursecat::make_categories_list($requiredcapability, $excludeid);
2048     // Building the list of all parents of all categories in the system is highly undesirable and hardly ever needed.
2049     // Usually user needs only parents for one particular category, in which case should be used:
2050     // coursecat::get($categoryid)->get_parents()
2051     if (empty($parents)) {
2052         $parents = array();
2053     }
2054     $all = $DB->get_records_sql('SELECT id, parent FROM {course_categories} ORDER BY sortorder');
2055     foreach ($all as $record) {
2056         if ($record->parent) {
2057             $parents[$record->id] = array_merge($parents[$record->parent], array($record->parent));
2058         } else {
2059             $parents[$record->id] = array();
2060         }
2061     }
2064 /**
2065  * Delete category, but move contents to another category.
2066  *
2067  * This function is deprecated. Please use
2068  * coursecat::get($category->id)->delete_move($newparentid, $showfeedback);
2069  *
2070  * @see coursecat::delete_move()
2071  * @deprecated since 2.5
2072  *
2073  * @param object $category
2074  * @param int $newparentid category id
2075  * @return bool status
2076  */
2077 function category_delete_move($category, $newparentid, $showfeedback=true) {
2078     global $CFG;
2079     require_once($CFG->libdir.'/coursecatlib.php');
2081     debugging('Function category_delete_move() is deprecated. Please use coursecat::delete_move() instead.');
2083     return coursecat::get($category->id)->delete_move($newparentid, $showfeedback);
2086 /**
2087  * Recursively delete category including all subcategories and courses.
2088  *
2089  * This function is deprecated. Please use
2090  * coursecat::get($category->id)->delete_full($showfeedback);
2091  *
2092  * @see coursecat::delete_full()
2093  * @deprecated since 2.5
2094  *
2095  * @param stdClass $category
2096  * @param boolean $showfeedback display some notices
2097  * @return array return deleted courses
2098  */
2099 function category_delete_full($category, $showfeedback=true) {
2100     global $CFG, $DB;
2101     require_once($CFG->libdir.'/coursecatlib.php');
2103     debugging('Function category_delete_full() is deprecated. Please use coursecat::delete_full() instead.');
2105     return coursecat::get($category->id)->delete_full($showfeedback);
2108 /**
2109  * Efficiently moves a category - NOTE that this can have
2110  * a huge impact access-control-wise...
2111  *
2112  * This function is deprecated. Please use
2113  * $coursecat = coursecat::get($category->id);
2114  * if ($coursecat->can_change_parent($newparentcat->id)) {
2115  *     $coursecat->change_parent($newparentcat->id);
2116  * }
2117  *
2118  * Alternatively you can use
2119  * $coursecat->update(array('parent' => $newparentcat->id));
2120  *
2121  * Function update() also updates field course_categories.timemodified
2122  *
2123  * @see coursecat::change_parent()
2124  * @see coursecat::update()
2125  * @deprecated since 2.5
2126  *
2127  * @param stdClass|coursecat $category
2128  * @param stdClass|coursecat $newparentcat
2129  */
2130 function move_category($category, $newparentcat) {
2131     global $CFG;
2132     require_once($CFG->libdir.'/coursecatlib.php');
2134     debugging('Function move_category() is deprecated. Please use coursecat::change_parent() instead.');
2136     return coursecat::get($category->id)->change_parent($newparentcat->id);
2139 /**
2140  * Hide course category and child course and subcategories
2141  *
2142  * This function is deprecated. Please use
2143  * coursecat::get($category->id)->hide();
2144  *
2145  * @see coursecat::hide()
2146  * @deprecated since 2.5
2147  *
2148  * @param stdClass $category
2149  * @return void
2150  */
2151 function course_category_hide($category) {
2152     global $CFG;
2153     require_once($CFG->libdir.'/coursecatlib.php');
2155     debugging('Function course_category_hide() is deprecated. Please use coursecat::hide() instead.');
2157     coursecat::get($category->id)->hide();
2160 /**
2161  * Show course category and child course and subcategories
2162  *
2163  * This function is deprecated. Please use
2164  * coursecat::get($category->id)->show();
2165  *
2166  * @see coursecat::show()
2167  * @deprecated since 2.5
2168  *
2169  * @param stdClass $category
2170  * @return void
2171  */
2172 function course_category_show($category) {
2173     global $CFG;
2174     require_once($CFG->libdir.'/coursecatlib.php');
2176     debugging('Function course_category_show() is deprecated. Please use coursecat::show() instead.');
2178     coursecat::get($category->id)->show();
2181 /**
2182  * Return specified category, default if given does not exist
2183  *
2184  * This function is deprecated.
2185  * To get the category with the specified it please use:
2186  * coursecat::get($catid, IGNORE_MISSING);
2187  * or
2188  * coursecat::get($catid, MUST_EXIST);
2189  *
2190  * To get the first available category please use
2191  * coursecat::get_default();
2192  *
2193  * class coursecat will also make sure that at least one category exists in DB
2194  *
2195  * @deprecated since 2.5
2196  * @see coursecat::get()
2197  * @see coursecat::get_default()
2198  *
2199  * @param int $catid course category id
2200  * @return object caregory
2201  */
2202 function get_course_category($catid=0) {
2203     global $DB;
2205     debugging('Function get_course_category() is deprecated. Please use coursecat::get(), see phpdocs for more details');
2207     $category = false;
2209     if (!empty($catid)) {
2210         $category = $DB->get_record('course_categories', array('id'=>$catid));
2211     }
2213     if (!$category) {
2214         // the first category is considered default for now
2215         if ($category = $DB->get_records('course_categories', null, 'sortorder', '*', 0, 1)) {
2216             $category = reset($category);
2218         } else {
2219             $cat = new stdClass();
2220             $cat->name         = get_string('miscellaneous');
2221             $cat->depth        = 1;
2222             $cat->sortorder    = MAX_COURSES_IN_CATEGORY;
2223             $cat->timemodified = time();
2224             $catid = $DB->insert_record('course_categories', $cat);
2225             // make sure category context exists
2226             context_coursecat::instance($catid);
2227             mark_context_dirty('/'.SYSCONTEXTID);
2228             fix_course_sortorder(); // Required to build course_categories.depth and .path.
2229             $category = $DB->get_record('course_categories', array('id'=>$catid));
2230         }
2231     }
2233     return $category;
2236 /**
2237  * Create a new course category and marks the context as dirty
2238  *
2239  * This function does not set the sortorder for the new category and
2240  * {@link fix_course_sortorder()} should be called after creating a new course
2241  * category
2242  *
2243  * Please note that this function does not verify access control.
2244  *
2245  * This function is deprecated. It is replaced with the method create() in class coursecat.
2246  * {@link coursecat::create()} also verifies the data, fixes sortorder and logs the action
2247  *
2248  * @deprecated since 2.5
2249  *
2250  * @param object $category All of the data required for an entry in the course_categories table
2251  * @return object new course category
2252  */
2253 function create_course_category($category) {
2254     global $DB;
2256     debugging('Function create_course_category() is deprecated. Please use coursecat::create(), see phpdocs for more details', DEBUG_DEVELOPER);
2258     $category->timemodified = time();
2259     $category->id = $DB->insert_record('course_categories', $category);
2260     $category = $DB->get_record('course_categories', array('id' => $category->id));
2262     // We should mark the context as dirty
2263     $category->context = context_coursecat::instance($category->id);
2264     $category->context->mark_dirty();
2266     return $category;
2269 /**
2270  * Returns an array of category ids of all the subcategories for a given
2271  * category.
2272  *
2273  * This function is deprecated.
2274  *
2275  * To get visible children categories of the given category use:
2276  * coursecat::get($categoryid)->get_children();
2277  * This function will return the array or coursecat objects, on each of them
2278  * you can call get_children() again
2279  *
2280  * @see coursecat::get()
2281  * @see coursecat::get_children()
2282  *
2283  * @deprecated since 2.5
2284  *
2285  * @global object
2286  * @param int $catid - The id of the category whose subcategories we want to find.
2287  * @return array of category ids.
2288  */
2289 function get_all_subcategories($catid) {
2290     global $DB;
2292     debugging('Function get_all_subcategories() is deprecated. Please use appropriate methods() of coursecat class. See phpdocs for more details',
2293             DEBUG_DEVELOPER);
2295     $subcats = array();
2297     if ($categories = $DB->get_records('course_categories', array('parent' => $catid))) {
2298         foreach ($categories as $cat) {
2299             array_push($subcats, $cat->id);
2300             $subcats = array_merge($subcats, get_all_subcategories($cat->id));
2301         }
2302     }
2303     return $subcats;
2306 /**
2307  * Gets the child categories of a given courses category
2308  *
2309  * This function is deprecated. Please use functions in class coursecat:
2310  * - coursecat::get($parentid)->has_children()
2311  * tells if the category has children (visible or not to the current user)
2312  *
2313  * - coursecat::get($parentid)->get_children()
2314  * returns an array of coursecat objects, each of them represents a children category visible
2315  * to the current user (i.e. visible=1 or user has capability to view hidden categories)
2316  *
2317  * - coursecat::get($parentid)->get_children_count()
2318  * returns number of children categories visible to the current user
2319  *
2320  * - coursecat::count_all()
2321  * returns total count of all categories in the system (both visible and not)
2322  *
2323  * - coursecat::get_default()
2324  * returns the first category (usually to be used if count_all() == 1)
2325  *
2326  * @deprecated since 2.5
2327  *
2328  * @param int $parentid the id of a course category.
2329  * @return array all the child course categories.
2330  */
2331 function get_child_categories($parentid) {
2332     global $DB;
2333     debugging('Function get_child_categories() is deprecated. Use coursecat::get_children() or see phpdocs for more details.',
2334             DEBUG_DEVELOPER);
2336     $rv = array();
2337     $sql = context_helper::get_preload_record_columns_sql('ctx');
2338     $records = $DB->get_records_sql("SELECT c.*, $sql FROM {course_categories} c ".
2339             "JOIN {context} ctx on ctx.instanceid = c.id AND ctx.contextlevel = ? WHERE c.parent = ? ORDER BY c.sortorder",
2340             array(CONTEXT_COURSECAT, $parentid));
2341     foreach ($records as $category) {
2342         context_helper::preload_from_record($category);
2343         if (!$category->visible && !has_capability('moodle/category:viewhiddencategories', context_coursecat::instance($category->id))) {
2344             continue;
2345         }
2346         $rv[] = $category;
2347     }
2348     return $rv;
2351 /**
2352  * Returns a sorted list of categories.
2353  *
2354  * When asking for $parent='none' it will return all the categories, regardless
2355  * of depth. Wheen asking for a specific parent, the default is to return
2356  * a "shallow" resultset. Pass false to $shallow and it will return all
2357  * the child categories as well.
2358  *
2359  * @deprecated since 2.5
2360  *
2361  * This function is deprecated. Use appropriate functions from class coursecat.
2362  * Examples:
2363  *
2364  * coursecat::get($categoryid)->get_children()
2365  * - returns all children of the specified category as instances of class
2366  * coursecat, which means on each of them method get_children() can be called again.
2367  * Only categories visible to the current user are returned.
2368  *
2369  * coursecat::get(0)->get_children()
2370  * - returns all top-level categories visible to the current user.
2371  *
2372  * Sort fields can be specified, see phpdocs to {@link coursecat::get_children()}
2373  *
2374  * coursecat::make_categories_list()
2375  * - returns an array of all categories id/names in the system.
2376  * Also only returns categories visible to current user and can additionally be
2377  * filetered by capability, see phpdocs to {@link coursecat::make_categories_list()}
2378  *
2379  * make_categories_options()
2380  * - Returns full course categories tree to be used in html_writer::select()
2381  *
2382  * Also see functions {@link coursecat::get_children_count()}, {@link coursecat::count_all()},
2383  * {@link coursecat::get_default()}
2384  *
2385  * The code of this deprecated function is left as it is because coursecat::get_children()
2386  * returns categories as instances of coursecat and not stdClass. Also there is no
2387  * substitute for retrieving the category with all it's subcategories. Plugin developers
2388  * may re-use the code/queries from this function in their plugins if really necessary.
2389  *
2390  * @param string $parent The parent category if any
2391  * @param string $sort the sortorder
2392  * @param bool   $shallow - set to false to get the children too
2393  * @return array of categories
2394  */
2395 function get_categories($parent='none', $sort=NULL, $shallow=true) {
2396     global $DB;
2398     debugging('Function get_categories() is deprecated. Please use coursecat::get_children() or see phpdocs for other alternatives',
2399             DEBUG_DEVELOPER);
2401     if ($sort === NULL) {
2402         $sort = 'ORDER BY cc.sortorder ASC';
2403     } elseif ($sort ==='') {
2404         // leave it as empty
2405     } else {
2406         $sort = "ORDER BY $sort";
2407     }
2409     list($ccselect, $ccjoin) = context_instance_preload_sql('cc.id', CONTEXT_COURSECAT, 'ctx');
2411     if ($parent === 'none') {
2412         $sql = "SELECT cc.* $ccselect
2413                   FROM {course_categories} cc
2414                $ccjoin
2415                 $sort";
2416         $params = array();
2418     } elseif ($shallow) {
2419         $sql = "SELECT cc.* $ccselect
2420                   FROM {course_categories} cc
2421                $ccjoin
2422                  WHERE cc.parent=?
2423                 $sort";
2424         $params = array($parent);
2426     } else {
2427         $sql = "SELECT cc.* $ccselect
2428                   FROM {course_categories} cc
2429                $ccjoin
2430                   JOIN {course_categories} ccp
2431                        ON ((cc.parent = ccp.id) OR (cc.path LIKE ".$DB->sql_concat('ccp.path',"'/%'")."))
2432                  WHERE ccp.id=?
2433                 $sort";
2434         $params = array($parent);
2435     }
2436     $categories = array();
2438     $rs = $DB->get_recordset_sql($sql, $params);
2439     foreach($rs as $cat) {
2440         context_helper::preload_from_record($cat);
2441         $catcontext = context_coursecat::instance($cat->id);
2442         if ($cat->visible || has_capability('moodle/category:viewhiddencategories', $catcontext)) {
2443             $categories[$cat->id] = $cat;
2444         }
2445     }
2446     $rs->close();
2447     return $categories;
2450 /**
2451 * Displays a course search form
2453 * This function is deprecated, please use course renderer:
2454 * $renderer = $PAGE->get_renderer('core', 'course');
2455 * echo $renderer->course_search_form($value, $format);
2457 * @deprecated since 2.5
2459 * @param string $value default value to populate the search field
2460 * @param bool $return if true returns the value, if false - outputs
2461 * @param string $format display format - 'plain' (default), 'short' or 'navbar'
2462 * @return null|string
2463 */
2464 function print_course_search($value="", $return=false, $format="plain") {
2465     global $PAGE;
2466     debugging('Function print_course_search() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2467     $renderer = $PAGE->get_renderer('core', 'course');
2468     if ($return) {
2469         return $renderer->course_search_form($value, $format);
2470     } else {
2471         echo $renderer->course_search_form($value, $format);
2472     }
2475 /**
2476  * Prints custom user information on the home page
2477  *
2478  * This function is deprecated, please use:
2479  * $renderer = $PAGE->get_renderer('core', 'course');
2480  * echo $renderer->frontpage_my_courses()
2481  *
2482  * @deprecated since 2.5
2483  */
2484 function print_my_moodle() {
2485     global $PAGE;
2486     debugging('Function print_my_moodle() is deprecated, please use course renderer function frontpage_my_courses()', DEBUG_DEVELOPER);
2488     $renderer = $PAGE->get_renderer('core', 'course');
2489     echo $renderer->frontpage_my_courses();
2492 /**
2493  * Prints information about one remote course
2494  *
2495  * This function is deprecated, it is replaced with protected function
2496  * {@link core_course_renderer::frontpage_remote_course()}
2497  * It is only used from function {@link core_course_renderer::frontpage_my_courses()}
2498  *
2499  * @deprecated since 2.5
2500  */
2501 function print_remote_course($course, $width="100%") {
2502     global $CFG, $USER;
2503     debugging('Function print_remote_course() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2505     $linkcss = '';
2507     $url = "{$CFG->wwwroot}/auth/mnet/jump.php?hostid={$course->hostid}&amp;wantsurl=/course/view.php?id={$course->remoteid}";
2509     echo '<div class="coursebox remotecoursebox clearfix">';
2510     echo '<div class="info">';
2511     echo '<div class="name"><a title="'.get_string('entercourse').'"'.
2512          $linkcss.' href="'.$url.'">'
2513         .  format_string($course->fullname) .'</a><br />'
2514         . format_string($course->hostname) . ' : '
2515         . format_string($course->cat_name) . ' : '
2516         . format_string($course->shortname). '</div>';
2517     echo '</div><div class="summary">';
2518     $options = new stdClass();
2519     $options->noclean = true;
2520     $options->para = false;
2521     $options->overflowdiv = true;
2522     echo format_text($course->summary, $course->summaryformat, $options);
2523     echo '</div>';
2524     echo '</div>';
2527 /**
2528  * Prints information about one remote host
2529  *
2530  * This function is deprecated, it is replaced with protected function
2531  * {@link core_course_renderer::frontpage_remote_host()}
2532  * It is only used from function {@link core_course_renderer::frontpage_my_courses()}
2533  *
2534  * @deprecated since 2.5
2535  */
2536 function print_remote_host($host, $width="100%") {
2537     global $OUTPUT;
2538     debugging('Function print_remote_host() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2540     $linkcss = '';
2542     echo '<div class="coursebox clearfix">';
2543     echo '<div class="info">';
2544     echo '<div class="name">';
2545     echo '<img src="'.$OUTPUT->pix_url('i/mnethost') . '" class="icon" alt="'.get_string('course').'" />';
2546     echo '<a title="'.s($host['name']).'" href="'.s($host['url']).'">'
2547         . s($host['name']).'</a> - ';
2548     echo $host['count'] . ' ' . get_string('courses');
2549     echo '</div>';
2550     echo '</div>';
2551     echo '</div>';
2554 /**
2555  * Recursive function to print out all the categories in a nice format
2556  * with or without courses included
2557  *
2558  * @deprecated since 2.5
2559  *
2560  * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5
2561  */
2562 function print_whole_category_list($category=NULL, $displaylist=NULL, $parentslist=NULL, $depth=-1, $showcourses = true, $categorycourses=NULL) {
2563     global $PAGE;
2564     debugging('Function print_whole_category_list() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2566     $renderer = $PAGE->get_renderer('core', 'course');
2567     if ($showcourses && $category) {
2568         echo $renderer->course_category($category);
2569     } else if ($showcourses) {
2570         echo $renderer->frontpage_combo_list();
2571     } else {
2572         echo $renderer->frontpage_categories_list();
2573     }
2576 /**
2577  * Prints the category information.
2578  *
2579  * @deprecated since 2.5
2580  *
2581  * This function was only used by {@link print_whole_category_list()} but now
2582  * all course category rendering is moved to core_course_renderer.
2583  *
2584  * @param stdClass $category
2585  * @param int $depth The depth of the category.
2586  * @param bool $showcourses If set to true course information will also be printed.
2587  * @param array|null $courses An array of courses belonging to the category, or null if you don't have it yet.
2588  */
2589 function print_category_info($category, $depth = 0, $showcourses = false, array $courses = null) {
2590     global $PAGE;
2591     debugging('Function print_category_info() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2593     $renderer = $PAGE->get_renderer('core', 'course');
2594     echo $renderer->course_category($category);
2597 /**
2598  * This function generates a structured array of courses and categories.
2599  *
2600  * @deprecated since 2.5
2601  *
2602  * This function is not used any more in moodle core and course renderer does not have render function for it.
2603  * Combo list on the front page is displayed as:
2604  * $renderer = $PAGE->get_renderer('core', 'course');
2605  * echo $renderer->frontpage_combo_list()
2606  *
2607  * The new class {@link coursecat} stores the information about course category tree
2608  * To get children categories use:
2609  * coursecat::get($id)->get_children()
2610  * To get list of courses use:
2611  * coursecat::get($id)->get_courses()
2612  *
2613  * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5
2614  *
2615  * @param int $id
2616  * @param int $depth
2617  */
2618 function get_course_category_tree($id = 0, $depth = 0) {
2619     global $DB, $CFG;
2620     if (!$depth) {
2621         debugging('Function get_course_category_tree() is deprecated, please use course renderer or coursecat class, see function phpdocs for more info', DEBUG_DEVELOPER);
2622     }
2624     $categories = array();
2625     $categoryids = array();
2626     $sql = context_helper::get_preload_record_columns_sql('ctx');
2627     $records = $DB->get_records_sql("SELECT c.*, $sql FROM {course_categories} c ".
2628             "JOIN {context} ctx on ctx.instanceid = c.id AND ctx.contextlevel = ? WHERE c.parent = ? ORDER BY c.sortorder",
2629             array(CONTEXT_COURSECAT, $id));
2630     foreach ($records as $category) {
2631         context_helper::preload_from_record($category);
2632         if (!$category->visible && !has_capability('moodle/category:viewhiddencategories', context_coursecat::instance($category->id))) {
2633             continue;
2634         }
2635         $categories[] = $category;
2636         $categoryids[$category->id] = $category;
2637         if (empty($CFG->maxcategorydepth) || $depth <= $CFG->maxcategorydepth) {
2638             list($category->categories, $subcategories) = get_course_category_tree($category->id, $depth+1);
2639             foreach ($subcategories as $subid=>$subcat) {
2640                 $categoryids[$subid] = $subcat;
2641             }
2642             $category->courses = array();
2643         }
2644     }
2646     if ($depth > 0) {
2647         // This is a recursive call so return the required array
2648         return array($categories, $categoryids);
2649     }
2651     if (empty($categoryids)) {
2652         // No categories available (probably all hidden).
2653         return array();
2654     }
2656     // The depth is 0 this function has just been called so we can finish it off
2658     list($ccselect, $ccjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
2659     list($catsql, $catparams) = $DB->get_in_or_equal(array_keys($categoryids));
2660     $sql = "SELECT
2661             c.id,c.sortorder,c.visible,c.fullname,c.shortname,c.summary,c.category
2662             $ccselect
2663             FROM {course} c
2664             $ccjoin
2665             WHERE c.category $catsql ORDER BY c.sortorder ASC";
2666     if ($courses = $DB->get_records_sql($sql, $catparams)) {
2667         // loop throught them
2668         foreach ($courses as $course) {
2669             if ($course->id == SITEID) {
2670                 continue;
2671             }
2672             context_helper::preload_from_record($course);
2673             if (!empty($course->visible) || has_capability('moodle/course:viewhiddencourses', context_course::instance($course->id))) {
2674                 $categoryids[$course->category]->courses[$course->id] = $course;
2675             }
2676         }
2677     }
2678     return $categories;
2681 /**
2682  * Print courses in category. If category is 0 then all courses are printed.
2683  *
2684  * @deprecated since 2.5
2685  *
2686  * To print a generic list of courses use:
2687  * $renderer = $PAGE->get_renderer('core', 'course');
2688  * echo $renderer->courses_list($courses);
2689  *
2690  * To print list of all courses:
2691  * $renderer = $PAGE->get_renderer('core', 'course');
2692  * echo $renderer->frontpage_available_courses();
2693  *
2694  * To print list of courses inside category:
2695  * $renderer = $PAGE->get_renderer('core', 'course');
2696  * echo $renderer->course_category($category); // this will also print subcategories
2697  *
2698  * @param int|stdClass $category category object or id.
2699  * @return bool true if courses found and printed, else false.
2700  */
2701 function print_courses($category) {
2702     global $CFG, $OUTPUT, $PAGE;
2703     require_once($CFG->libdir. '/coursecatlib.php');
2704     debugging('Function print_courses() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2706     if (!is_object($category) && $category==0) {
2707         $courses = coursecat::get(0)->get_courses(array('recursive' => true, 'summary' => true, 'coursecontacts' => true));
2708     } else {
2709         $courses = coursecat::get($category->id)->get_courses(array('summary' => true, 'coursecontacts' => true));
2710     }
2712     if ($courses) {
2713         $renderer = $PAGE->get_renderer('core', 'course');
2714         echo $renderer->courses_list($courses);
2715     } else {
2716         echo $OUTPUT->heading(get_string("nocoursesyet"));
2717         $context = context_system::instance();
2718         if (has_capability('moodle/course:create', $context)) {
2719             $options = array();
2720             if (!empty($category->id)) {
2721                 $options['category'] = $category->id;
2722             } else {
2723                 $options['category'] = $CFG->defaultrequestcategory;
2724             }
2725             echo html_writer::start_tag('div', array('class'=>'addcoursebutton'));
2726             echo $OUTPUT->single_button(new moodle_url('/course/edit.php', $options), get_string("addnewcourse"));
2727             echo html_writer::end_tag('div');
2728             return false;
2729         }
2730     }
2731     return true;
2734 /**
2735  * Print a description of a course, suitable for browsing in a list.
2736  *
2737  * @deprecated since 2.5
2738  *
2739  * Please use course renderer to display a course information box.
2740  * $renderer = $PAGE->get_renderer('core', 'course');
2741  * echo $renderer->courses_list($courses); // will print list of courses
2742  * echo $renderer->course_info_box($course); // will print one course wrapped in div.generalbox
2743  *
2744  * @param object $course the course object.
2745  * @param string $highlightterms Ignored in this deprecated function!
2746  */
2747 function print_course($course, $highlightterms = '') {
2748     global $PAGE;
2750     debugging('Function print_course() is deprecated, please use course renderer', DEBUG_DEVELOPER);
2751     $renderer = $PAGE->get_renderer('core', 'course');
2752     // Please note, correct would be to use $renderer->coursecat_coursebox() but this function is protected.
2753     // To print list of courses use $renderer->courses_list();
2754     echo $renderer->course_info_box($course);
2757 /**
2758  * Gets an array whose keys are category ids and whose values are arrays of courses in the corresponding category.
2759  *
2760  * @deprecated since 2.5
2761  *
2762  * This function is not used any more in moodle core and course renderer does not have render function for it.
2763  * Combo list on the front page is displayed as:
2764  * $renderer = $PAGE->get_renderer('core', 'course');
2765  * echo $renderer->frontpage_combo_list()
2766  *
2767  * The new class {@link coursecat} stores the information about course category tree
2768  * To get children categories use:
2769  * coursecat::get($id)->get_children()
2770  * To get list of courses use:
2771  * coursecat::get($id)->get_courses()
2772  *
2773  * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5
2774  *
2775  * @param int $categoryid
2776  * @return array
2777  */
2778 function get_category_courses_array($categoryid = 0) {
2779     debugging('Function get_category_courses_array() is deprecated, please use methods of coursecat class', DEBUG_DEVELOPER);
2780     $tree = get_course_category_tree($categoryid);
2781     $flattened = array();
2782     foreach ($tree as $category) {
2783         get_category_courses_array_recursively($flattened, $category);
2784     }
2785     return $flattened;
2788 /**
2789  * Recursive function to help flatten the course category tree.
2790  *
2791  * @deprecated since 2.5
2792  *
2793  * Was intended to be called from {@link get_category_courses_array()}
2794  *
2795  * @param array &$flattened An array passed by reference in which to store courses for each category.
2796  * @param stdClass $category The category to get courses for.
2797  */
2798 function get_category_courses_array_recursively(array &$flattened, $category) {
2799     debugging('Function get_category_courses_array_recursively() is deprecated, please use methods of coursecat class', DEBUG_DEVELOPER);
2800     $flattened[$category->id] = $category->courses;
2801     foreach ($category->categories as $childcategory) {
2802         get_category_courses_array_recursively($flattened, $childcategory);
2803     }
2806 /**
2807  * Returns a URL based on the context of the current page.
2808  * This URL points to blog/index.php and includes filter parameters appropriate for the current page.
2809  *
2810  * @param stdclass $context
2811  * @deprecated since Moodle 2.5 MDL-27814 - please do not use this function any more.
2812  * @todo Remove this in 2.7
2813  * @return string
2814  */
2815 function blog_get_context_url($context=null) {
2816     global $CFG;
2818     debugging('Function  blog_get_context_url() is deprecated, getting params from context is not reliable for blogs.', DEBUG_DEVELOPER);
2819     $viewblogentriesurl = new moodle_url('/blog/index.php');
2821     if (empty($context)) {
2822         global $PAGE;
2823         $context = $PAGE->context;
2824     }
2826     // Change contextlevel to SYSTEM if viewing the site course
2827     if ($context->contextlevel == CONTEXT_COURSE && $context->instanceid == SITEID) {
2828         $context = context_system::instance();
2829     }
2831     $filterparam = '';
2832     $strlevel = '';
2834     switch ($context->contextlevel) {
2835         case CONTEXT_SYSTEM:
2836         case CONTEXT_BLOCK:
2837         case CONTEXT_COURSECAT:
2838             break;
2839         case CONTEXT_COURSE:
2840             $filterparam = 'courseid';
2841             $strlevel = get_string('course');
2842             break;
2843         case CONTEXT_MODULE:
2844             $filterparam = 'modid';
2845             $strlevel = $context->get_context_name();
2846             break;
2847         case CONTEXT_USER:
2848             $filterparam = 'userid';
2849             $strlevel = get_string('user');
2850             break;
2851     }
2853     if (!empty($filterparam)) {
2854         $viewblogentriesurl->param($filterparam, $context->instanceid);
2855     }
2857     return $viewblogentriesurl;
2860 /**
2861  * Retrieve course records with the course managers and other related records
2862  * that we need for print_course(). This allows print_courses() to do its job
2863  * in a constant number of DB queries, regardless of the number of courses,
2864  * role assignments, etc.
2865  *
2866  * The returned array is indexed on c.id, and each course will have
2867  * - $course->managers - array containing RA objects that include a $user obj
2868  *                       with the minimal fields needed for fullname()
2869  *
2870  * @deprecated since 2.5
2871  *
2872  * To get list of all courses with course contacts ('managers') use
2873  * coursecat::get(0)->get_courses(array('recursive' => true, 'coursecontacts' => true));
2874  *
2875  * To get list of courses inside particular category use
2876  * coursecat::get($id)->get_courses(array('coursecontacts' => true));
2877  *
2878  * Additionally you can specify sort order, offset and maximum number of courses,
2879  * see {@link coursecat::get_courses()}
2880  *
2881  * Please note that code of this function is not changed to use coursecat class because
2882  * coursecat::get_courses() returns result in slightly different format. Also note that
2883  * get_courses_wmanagers() DOES NOT check that users are enrolled in the course and
2884  * coursecat::get_courses() does.
2885  *
2886  * @global object
2887  * @global object
2888  * @global object
2889  * @uses CONTEXT_COURSE
2890  * @uses CONTEXT_SYSTEM
2891  * @uses CONTEXT_COURSECAT
2892  * @uses SITEID
2893  * @param int|string $categoryid Either the categoryid for the courses or 'all'
2894  * @param string $sort A SQL sort field and direction
2895  * @param array $fields An array of additional fields to fetch
2896  * @return array
2897  */
2898 function get_courses_wmanagers($categoryid=0, $sort="c.sortorder ASC", $fields=array()) {
2899     /*
2900      * The plan is to
2901      *
2902      * - Grab the courses JOINed w/context
2903      *
2904      * - Grab the interesting course-manager RAs
2905      *   JOINed with a base user obj and add them to each course
2906      *
2907      * So as to do all the work in 2 DB queries. The RA+user JOIN
2908      * ends up being pretty expensive if it happens over _all_
2909      * courses on a large site. (Are we surprised!?)
2910      *
2911      * So this should _never_ get called with 'all' on a large site.
2912      *
2913      */
2914     global $USER, $CFG, $DB;
2915     debugging('Function get_courses_wmanagers() is deprecated, please use coursecat::get_courses()', DEBUG_DEVELOPER);
2917     $params = array();
2918     $allcats = false; // bool flag
2919     if ($categoryid === 'all') {
2920         $categoryclause   = '';
2921         $allcats = true;
2922     } elseif (is_numeric($categoryid)) {
2923         $categoryclause = "c.category = :catid";
2924         $params['catid'] = $categoryid;
2925     } else {
2926         debugging("Could not recognise categoryid = $categoryid");
2927         $categoryclause = '';
2928     }
2930     $basefields = array('id', 'category', 'sortorder',
2931                         'shortname', 'fullname', 'idnumber',
2932                         'startdate', 'visible',
2933                         'newsitems', 'groupmode', 'groupmodeforce');
2935     if (!is_null($fields) && is_string($fields)) {
2936         if (empty($fields)) {
2937             $fields = $basefields;
2938         } else {
2939             // turn the fields from a string to an array that
2940             // get_user_courses_bycap() will like...
2941             $fields = explode(',',$fields);
2942             $fields = array_map('trim', $fields);
2943             $fields = array_unique(array_merge($basefields, $fields));
2944         }
2945     } elseif (is_array($fields)) {
2946         $fields = array_merge($basefields,$fields);
2947     }
2948     $coursefields = 'c.' .join(',c.', $fields);
2950     if (empty($sort)) {
2951         $sortstatement = "";
2952     } else {
2953         $sortstatement = "ORDER BY $sort";
2954     }
2956     $where = 'WHERE c.id != ' . SITEID;
2957     if ($categoryclause !== ''){
2958         $where = "$where AND $categoryclause";
2959     }
2961     // pull out all courses matching the cat
2962     list($ccselect, $ccjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
2963     $sql = "SELECT $coursefields $ccselect
2964               FROM {course} c
2965            $ccjoin
2966                $where
2967                $sortstatement";
2969     $catpaths = array();
2970     $catpath  = NULL;
2971     if ($courses = $DB->get_records_sql($sql, $params)) {
2972         // loop on courses materialising
2973         // the context, and prepping data to fetch the
2974         // managers efficiently later...
2975         foreach ($courses as $k => $course) {
2976             context_helper::preload_from_record($course);
2977             $coursecontext = context_course::instance($course->id);
2978             $courses[$k] = $course;
2979             $courses[$k]->managers = array();
2980             if ($allcats === false) {
2981                 // single cat, so take just the first one...
2982                 if ($catpath === NULL) {
2983                     $catpath = preg_replace(':/\d+$:', '', $coursecontext->path);
2984                 }
2985             } else {
2986                 // chop off the contextid of the course itself
2987                 // like dirname() does...
2988                 $catpaths[] = preg_replace(':/\d+$:', '', $coursecontext->path);
2989             }
2990         }
2991     } else {
2992         return array(); // no courses!
2993     }
2995     $CFG->coursecontact = trim($CFG->coursecontact);
2996     if (empty($CFG->coursecontact)) {
2997         return $courses;
2998     }
3000     $managerroles = explode(',', $CFG->coursecontact);
3001     $catctxids = '';
3002     if (count($managerroles)) {
3003         if ($allcats === true) {
3004             $catpaths  = array_unique($catpaths);
3005             $ctxids = array();
3006             foreach ($catpaths as $cpath) {
3007                 $ctxids = array_merge($ctxids, explode('/',substr($cpath,1)));
3008             }
3009             $ctxids = array_unique($ctxids);
3010             $catctxids = implode( ',' , $ctxids);
3011             unset($catpaths);
3012             unset($cpath);
3013         } else {
3014             // take the ctx path from the first course
3015             // as all categories will be the same...
3016             $catpath = substr($catpath,1);
3017             $catpath = preg_replace(':/\d+$:','',$catpath);
3018             $catctxids = str_replace('/',',',$catpath);
3019         }
3020         if ($categoryclause !== '') {
3021             $categoryclause = "AND $categoryclause";
3022         }
3023         /*
3024          * Note: Here we use a LEFT OUTER JOIN that can
3025          * "optionally" match to avoid passing a ton of context
3026          * ids in an IN() clause. Perhaps a subselect is faster.
3027          *
3028          * In any case, this SQL is not-so-nice over large sets of
3029          * courses with no $categoryclause.
3030          *
3031          */
3032         $sql = "SELECT ctx.path, ctx.instanceid, ctx.contextlevel,
3033                        r.id AS roleid, r.name AS rolename, r.shortname AS roleshortname,
3034                        rn.name AS rolecoursealias, u.id AS userid, u.firstname, u.lastname
3035                   FROM {role_assignments} ra
3036                   JOIN {context} ctx ON ra.contextid = ctx.id
3037                   JOIN {user} u ON ra.userid = u.id
3038                   JOIN {role} r ON ra.roleid = r.id
3039              LEFT JOIN {role_names} rn ON (rn.contextid = ctx.id AND rn.roleid = r.id)
3040                   LEFT OUTER JOIN {course} c
3041                        ON (ctx.instanceid=c.id AND ctx.contextlevel=".CONTEXT_COURSE.")
3042                 WHERE ( c.id IS NOT NULL";
3043         // under certain conditions, $catctxids is NULL
3044         if($catctxids == NULL){
3045             $sql .= ") ";
3046         }else{
3047             $sql .= " OR ra.contextid  IN ($catctxids) )";
3048         }
3050         $sql .= "AND ra.roleid IN ({$CFG->coursecontact})
3051                       $categoryclause
3052                 ORDER BY r.sortorder ASC, ctx.contextlevel ASC, ra.sortorder ASC";
3053         $rs = $DB->get_recordset_sql($sql, $params);
3055         // This loop is fairly stupid as it stands - might get better
3056         // results doing an initial pass clustering RAs by path.
3057         foreach($rs as $ra) {
3058             $user = new stdClass;
3059             $user->id        = $ra->userid;    unset($ra->userid);
3060             $user->firstname = $ra->firstname; unset($ra->firstname);
3061             $user->lastname  = $ra->lastname;  unset($ra->lastname);
3062             $ra->user = $user;
3063             if ($ra->contextlevel == CONTEXT_SYSTEM) {
3064                 foreach ($courses as $k => $course) {
3065                     $courses[$k]->managers[] = $ra;
3066                 }
3067             } else if ($ra->contextlevel == CONTEXT_COURSECAT) {
3068                 if ($allcats === false) {
3069                     // It always applies
3070                     foreach ($courses as $k => $course) {
3071                         $courses[$k]->managers[] = $ra;
3072                     }
3073                 } else {
3074                     foreach ($courses as $k => $course) {
3075                         $coursecontext = context_course::instance($course->id);
3076                         // Note that strpos() returns 0 as "matched at pos 0"
3077                         if (strpos($coursecontext->path, $ra->path.'/') === 0) {
3078                             // Only add it to subpaths
3079                             $courses[$k]->managers[] = $ra;
3080                         }
3081                     }
3082                 }
3083             } else { // course-level
3084                 if (!array_key_exists($ra->instanceid, $courses)) {
3085                     //this course is not in a list, probably a frontpage course
3086                     continue;
3087                 }
3088                 $courses[$ra->instanceid]->managers[] = $ra;
3089             }
3090         }
3091         $rs->close();
3092     }
3094     return $courses;
3097 /**
3098  * Converts a nested array tree into HTML ul:li [recursive]
3099  *
3100  * @deprecated since 2.5
3101  *
3102  * @param array $tree A tree array to convert
3103  * @param int $row Used in identifying the iteration level and in ul classes
3104  * @return string HTML structure
3105  */
3106 function convert_tree_to_html($tree, $row=0) {
3107     debugging('Function convert_tree_to_html() is deprecated since Moodle 2.5. Consider using class tabtree and core_renderer::render_tabtree()', DEBUG_DEVELOPER);
3109     $str = "\n".'<ul class="tabrow'.$row.'">'."\n";
3111     $first = true;
3112     $count = count($tree);
3114     foreach ($tree as $tab) {
3115         $count--;   // countdown to zero
3117         $liclass = '';
3119         if ($first && ($count == 0)) {   // Just one in the row
3120             $liclass = 'first last';
3121             $first = false;
3122         } else if ($first) {
3123             $liclass = 'first';
3124             $first = false;
3125         } else if ($count == 0) {
3126             $liclass = 'last';
3127         }
3129         if ((empty($tab->subtree)) && (!empty($tab->selected))) {
3130             $liclass .= (empty($liclass)) ? 'onerow' : ' onerow';
3131         }
3133         if ($tab->inactive || $tab->active || $tab->selected) {
3134             if ($tab->selected) {
3135                 $liclass .= (empty($liclass)) ? 'here selected' : ' here selected';
3136             } else if ($tab->active) {
3137                 $liclass .= (empty($liclass)) ? 'here active' : ' here active';
3138             }
3139         }
3141         $str .= (!empty($liclass)) ? '<li class="'.$liclass.'">' : '<li>';
3143         if ($tab->inactive || $tab->active || ($tab->selected && !$tab->linkedwhenselected)) {
3144             // The a tag is used for styling
3145             $str .= '<a class="nolink"><span>'.$tab->text.'</span></a>';
3146         } else {
3147             $str .= '<a href="'.$tab->link.'" title="'.$tab->title.'"><span>'.$tab->text.'</span></a>';
3148         }
3150         if (!empty($tab->subtree)) {
3151             $str .= convert_tree_to_html($tab->subtree, $row+1);
3152         } else if ($tab->selected) {
3153             $str .= '<div class="tabrow'.($row+1).' empty">&nbsp;</div>'."\n";
3154         }
3156         $str .= ' </li>'."\n";
3157     }
3158     $str .= '</ul>'."\n";
3160     return $str;
3163 /**
3164  * Convert nested tabrows to a nested array
3165  *
3166  * @deprecated since 2.5
3167  *
3168  * @param array $tabrows A [nested] array of tab row objects
3169  * @param string $selected The tabrow to select (by id)
3170  * @param array $inactive An array of tabrow id's to make inactive
3171  * @param array $activated An array of tabrow id's to make active
3172  * @return array The nested array
3173  */
3174 function convert_tabrows_to_tree($tabrows, $selected, $inactive, $activated) {
3176     debugging('Function convert_tabrows_to_tree() is deprecated since Moodle 2.5. Consider using class tabtree', DEBUG_DEVELOPER);
3178     // Work backwards through the rows (bottom to top) collecting the tree as we go.
3179     $tabrows = array_reverse($tabrows);
3181     $subtree = array();
3183     foreach ($tabrows as $row) {
3184         $tree = array();
3186         foreach ($row as $tab) {
3187             $tab->inactive = in_array((string)$tab->id, $inactive);
3188             $tab->active = in_array((string)$tab->id, $activated);
3189             $tab->selected = (string)$tab->id == $selected;
3191             if ($tab->active || $tab->selected) {
3192                 if ($subtree) {
3193                     $tab->subtree = $subtree;
3194                 }
3195             }
3196             $tree[] = $tab;
3197         }
3198         $subtree = $tree;
3199     }
3201     return $subtree;
3204 /**
3205  * Can handle rotated text. Whether it is safe to use the trickery in textrotate.js.
3206  *
3207  * @deprecated since 2.5 - do not use, the textrotate.js will work it out automatically
3208  * @return bool True for yes, false for no
3209  */
3210 function can_use_rotated_text() {
3211     debugging('can_use_rotated_text() is deprecated since Moodle 2.5. JS feature detection is used automatically.', DEBUG_DEVELOPER);
3212     return true;
3215 /**
3216  * Get the context instance as an object. This function will create the
3217  * context instance if it does not exist yet.
3218  *
3219  * @deprecated since 2.2, use context_course::instance() or other relevant class instead
3220  * @todo This will be deleted in Moodle 2.8, refer MDL-34472
3221  * @param integer $contextlevel The context level, for example CONTEXT_COURSE, or CONTEXT_MODULE.
3222  * @param integer $instance The instance id. For $level = CONTEXT_COURSE, this would be $course->id,
3223  *      for $level = CONTEXT_MODULE, this would be $cm->id. And so on. Defaults to 0
3224  * @param int $strictness IGNORE_MISSING means compatible mode, false returned if record not found, debug message if more found;
3225  *      MUST_EXIST means throw exception if no record or multiple records found
3226  * @return context The context object.
3227  */
3228 function get_context_instance($contextlevel, $instance = 0, $strictness = IGNORE_MISSING) {
3230     debugging('get_context_instance() is deprecated, please use context_xxxx::instance() instead.', DEBUG_DEVELOPER);
3232     $instances = (array)$instance;
3233     $contexts = array();
3235     $classname = context_helper::get_class_for_level($contextlevel);
3237     // we do not load multiple contexts any more, PAGE should be responsible for any preloading
3238     foreach ($instances as $inst) {
3239         $contexts[$inst] = $classname::instance($inst, $strictness);
3240     }
3242     if (is_array($instance)) {
3243         return $contexts;
3244     } else {
3245         return $contexts[$instance];
3246     }
3249 /**
3250  * Get a context instance as an object, from a given context id.
3251  *
3252  * @deprecated since Moodle 2.2 MDL-35009 - please do not use this function any more.
3253  * @todo MDL-34550 This will be deleted in Moodle 2.8
3254  * @see context::instance_by_id($id)
3255  * @param int $id context id
3256  * @param int $strictness IGNORE_MISSING means compatible mode, false returned if record not found, debug message if more found;
3257  *                        MUST_EXIST means throw exception if no record or multiple records found
3258  * @return context|bool the context object or false if not found.
3259  */
3260 function get_context_instance_by_id($id, $strictness = IGNORE_MISSING) {
3261     debugging('get_context_instance_by_id() is deprecated, please use context::instance_by_id($id) instead.', DEBUG_DEVELOPER);
3262     return context::instance_by_id($id, $strictness);
3265 /**
3266  * Returns system context or null if can not be created yet.
3267  *
3268  * @see context_system::instance()
3269  * @deprecated since 2.2
3270  * @param bool $cache use caching
3271  * @return context system context (null if context table not created yet)
3272  */
3273 function get_system_context($cache = true) {
3274     debugging('get_system_context() is deprecated, please use context_system::instance() instead.', DEBUG_DEVELOPER);
3275     return context_system::instance(0, IGNORE_MISSING, $cache);
3278 /**
3279  * Recursive function which, given a context, find all parent context ids,
3280  * and return the array in reverse order, i.e. parent first, then grand
3281  * parent, etc.
3282  *
3283  * @see context::get_parent_context_ids()
3284  * @deprecated since 2.2, use $context->get_parent_context_ids() instead
3285  * @param context $context
3286  * @param bool $includeself optional, defaults to false
3287  * @return array
3288  */
3289 function get_parent_contexts(context $context, $includeself = false) {
3290     debugging('get_parent_contexts() is deprecated, please use $context->get_parent_context_ids() instead.', DEBUG_DEVELOPER);
3291     return $context->get_parent_context_ids($includeself);
3294 /**
3295  * Return the id of the parent of this context, or false if there is no parent (only happens if this
3296  * is the site context.)
3297  *
3298  * @deprecated since Moodle 2.2
3299  * @see context::get_parent_context()
3300  * @param context $context
3301  * @return integer the id of the parent context.
3302  */
3303 function get_parent_contextid(context $context) {
3304     debugging('get_parent_contextid() is deprecated, please use $context->get_parent_context() instead.', DEBUG_DEVELOPER);
3306     if ($parent = $context->get_parent_context()) {
3307         return $parent->id;
3308     } else {
3309         return false;
3310     }
3313 /**
3314  * Recursive function which, given a context, find all its children contexts.
3315  *
3316  * For course category contexts it will return immediate children only categories and courses.
3317  * It will NOT recurse into courses or child categories.
3318  * If you want to do that, call it on the returned courses/categories.
3319  *
3320  * When called for a course context, it will return the modules and blocks
3321  * displayed in the course page.
3322  *
3323  * If called on a user/course/module context it _will_ populate the cache with the appropriate
3324  * contexts ;-)
3325  *
3326  * @see context::get_child_contexts()
3327  * @deprecated since 2.2
3328  * @param context $context
3329  * @return array Array of child records
3330  */
3331 function get_child_contexts(context $context) {
3332     debugging('get_child_contexts() is deprecated, please use $context->get_child_contexts() instead.', DEBUG_DEVELOPER);
3333     return $context->get_child_contexts();
3336 /**
3337  * Precreates all contexts including all parents.
3338  *
3339  * @see context_helper::create_instances()
3340  * @deprecated since 2.2
3341  * @param int $contextlevel empty means all
3342  * @param bool $buildpaths update paths and depths
3343  * @return void
3344  */
3345 function create_contexts($contextlevel = null, $buildpaths = true) {
3346     debugging('create_contexts() is deprecated, please use context_helper::create_instances() instead.', DEBUG_DEVELOPER);
3347     context_helper::create_instances($contextlevel, $buildpaths);
3350 /**
3351  * Remove stale context records.
3352  *
3353  * @see context_helper::cleanup_instances()
3354  * @deprecated since 2.2
3355  * @return bool
3356  */
3357 function cleanup_contexts() {
3358     debugging('cleanup_contexts() is deprecated, please use context_helper::cleanup_instances() instead.', DEBUG_DEVELOPER);
3359     context_helper::cleanup_instances();
3360     return true;
3363 /**
3364  * Populate context.path and context.depth where missing.
3365  *
3366  * @see context_helper::build_all_paths()
3367  * @deprecated since 2.2
3368  * @param bool $force force a complete rebuild of the path and depth fields, defaults to false
3369  * @return void
3370  */
3371 function build_context_path($force = false) {
3372     debugging('build_context_path() is deprecated, please use context_helper::build_all_paths() instead.', DEBUG_DEVELOPER);
3373     context_helper::build_all_paths($force);
3376 /**
3377  * Rebuild all related context depth and path caches.
3378  *
3379  * @see context::reset_paths()
3380  * @deprecated since 2.2
3381  * @param array $fixcontexts array of contexts, strongtyped
3382  * @return void
3383  */
3384 function rebuild_contexts(array $fixcontexts) {
3385     debugging('rebuild_contexts() is deprecated, please use $context->reset_paths(true) instead.', DEBUG_DEVELOPER);
3386     foreach ($fixcontexts as $fixcontext) {
3387         $fixcontext->reset_paths(false);
3388     }
3389     context_helper::build_all_paths(false);
3392 /**
3393  * Preloads all contexts relating to a course: course, modules. Block contexts
3394  * are no longer loaded here. The contexts for all the blocks on the current
3395  * page are now efficiently loaded by {@link block_manager::load_blocks()}.
3396  *
3397  * @deprecated since Moodle 2.2
3398  * @see context_helper::preload_course()
3399  * @param int $courseid Course ID
3400  * @return void
3401  */
3402 function preload_course_contexts($courseid) {
3403     debugging('preload_course_contexts() is deprecated, please use context_helper::preload_course() instead.', DEBUG_DEVELOPER);
3404     context_helper::preload_course($courseid);
3407 /**
3408  * Update the path field of the context and all dep. subcontexts that follow
3409  *
3410  * Update the path field of the context and
3411  * all the dependent subcontexts that follow
3412  * the move.
3413  *
3414  * The most important thing here is to be as
3415  * DB efficient as possible. This op can have a
3416  * massive impact in the DB.
3417  *
3418  * @deprecated since Moodle 2.2
3419  * @see context::update_moved()
3420  * @param context $context context obj
3421  * @param context $newparent new parent obj
3422  * @return void
3423  */
3424 function context_moved(context $context, context $newparent) {
3425     debugging('context_moved() is deprecated, please use context::update_moved() instead.', DEBUG_DEVELOPER);
3426     $context->update_moved($newparent);
3429 /**
3430  * Extracts the relevant capabilities given a contextid.
3431  * All case based, example an instance of forum context.
3432  * Will fetch all forum related capabilities, while course contexts
3433  * Will fetch all capabilities
3434  *
3435  * capabilities
3436  * `name` varchar(150) NOT NULL,
3437  * `captype` varchar(50) NOT NULL,
3438  * `contextlevel` int(10) NOT NULL,
3439  * `component` varchar(100) NOT NULL,
3440  *
3441  * @see context::get_capabilities()
3442  * @deprecated since 2.2
3443  * @param context $context
3444  * @return array
3445  */
3446 function fetch_context_capabilities(context $context) {
3447     debugging('fetch_context_capabilities() is deprecated, please use $context->get_capabilities() instead.', DEBUG_DEVELOPER);
3448     return $context->get_capabilities();
3451 /**
3452  * Preloads context information from db record and strips the cached info.
3453  * The db request has to contain both the $join and $select from context_instance_preload_sql()
3454  *
3455  * @deprecated since 2.2
3456  * @see context_helper::preload_from_record()
3457  * @param stdClass $rec
3458  * @return void (modifies $rec)
3459  */
3460 function context_instance_preload(stdClass $rec) {
3461     debugging('context_instance_preload() is deprecated, please use context_helper::preload_from_record() instead.', DEBUG_DEVELOPER);
3462     context_helper::preload_from_record($rec);
3465 /**
3466  * Returns context level name
3467  *
3468  * @deprecated since 2.2
3469  * @see context_helper::get_level_name()
3470  * @param integer $contextlevel $context->context level. One of the CONTEXT_... constants.
3471  * @return string the name for this type of context.
3472  */
3473 function get_contextlevel_name($contextlevel) {
3474     debugging('get_contextlevel_name() is deprecated, please use context_helper::get_level_name() instead.', DEBUG_DEVELOPER);
3475     return context_helper::get_level_name($contextlevel);
3478 /**
3479  * Prints human readable context identifier.
3480  *
3481  * @deprecated since 2.2
3482  * @see context::get_context_name()
3483  * @param context $context the context.
3484  * @param boolean $withprefix whether to prefix the name of the context with the
3485  *      type of context, e.g. User, Course, Forum, etc.
3486  * @param boolean $short whether to user the short name of the thing. Only applies
3487  *      to course contexts
3488  * @return string the human readable context name.
3489  */
3490 function print_context_name(context $context, $withprefix = true, $short = false) {
3491     debugging('print_context_name() is deprecated, please use $context->get_context_name() instead.', DEBUG_DEVELOPER);
3492     return $context->get_context_name($withprefix, $short);
3495 /**
3496  * Mark a context as dirty (with timestamp) so as to force reloading of the context.
3497  *
3498  * @deprecated since 2.2, use $context->mark_dirty() instead
3499  * @see context::mark_dirty()
3500  * @param string $path context path
3501  */
3502 function mark_context_dirty($path) {
3503     global $CFG, $USER, $ACCESSLIB_PRIVATE;
3504     debugging('mark_context_dirty() is deprecated, please use $context->mark_dirty() instead.', DEBUG_DEVELOPER);
3506     if (during_initial_install()) {
3507         return;
3508     }
3510     // only if it is a non-empty string
3511     if (is_string($path) && $path !== '') {
3512         set_cache_flag('accesslib/dirtycontexts', $path, 1, time()+$CFG->sessiontimeout);
3513         if (isset($ACCESSLIB_PRIVATE->dirtycontexts)) {
3514             $ACCESSLIB_PRIVATE->dirtycontexts[$path] = 1;
3515         } else {
3516             if (CLI_SCRIPT) {
3517                 $ACCESSLIB_PRIVATE->dirtycontexts = array($path => 1);
3518             } else {
3519                 if (isset($USER->access['time'])) {
3520                     $ACCESSLIB_PRIVATE->dirtycontexts = get_cache_flags('accesslib/dirtycontexts', $USER->access['time']-2);
3521                 } else {
3522                     $ACCESSLIB_PRIVATE->dirtycontexts = array($path => 1);
3523                 }
3524                 // flags not loaded yet, it will be done later in $context->reload_if_dirty()
3525             }
3526         }
3527     }
3530 /**
3531  * Remove a context record and any dependent entries,
3532  * removes context from static context cache too
3533  *
3534  * @deprecated since Moodle 2.2
3535  * @see context_helper::delete_instance() or context::delete_content()
3536  * @param int $contextlevel
3537  * @param int $instanceid
3538  * @param bool $deleterecord false means keep record for now
3539  * @return bool returns true or throws an exception
3540  */
3541 function delete_context($contextlevel, $instanceid, $deleterecord = true) {
3542     if ($deleterecord) {
3543         debugging('delete_context() is deprecated, please use context_helper::delete_instance() instead.', DEBUG_DEVELOPER);
3544         context_helper::delete_instance($contextlevel, $instanceid);
3545     } else {
3546         debugging('delete_context() is deprecated, please use $context->delete_content() instead.', DEBUG_DEVELOPER);
3547         $classname = context_helper::get_class_for_level($contextlevel);
3548         if ($context = $classname::instance($instanceid, IGNORE_MISSING)) {
3549             $context->delete_content();
3550         }
3551     }
3553     return true;
3556 /**
3557  * Get a URL for a context, if there is a natural one. For example, for
3558  * CONTEXT_COURSE, this is the course page. For CONTEXT_USER it is the
3559  * user profile page.
3560  *
3561  * @deprecated since 2.2
3562  * @see context::get_url()
3563  * @param context $context the context
3564  * @return moodle_url
3565  */
3566 function get_context_url(context $context) {
3567     debugging('get_context_url() is deprecated, please use $context->get_url() instead.', DEBUG_DEVELOPER);
3568     return $context->get_url();
3571 /**
3572  * Is this context part of any course? if yes return course context,
3573  * if not return null or throw exception.
3574  *
3575  * @deprecated since 2.2
3576  * @see context::get_course_context()
3577  * @param context $context
3578  * @return context_course context of the enclosing course, null if not found or exception
3579  */
3580 function get_course_context(context $context) {
3581     debugging('get_course_context() is deprecated, please use $context->get_course_context(true) instead.', DEBUG_DEVELOPER);
3582     return $context->get_course_context(true);
3585 /**
3586  * Get an array of courses where cap requested is available
3587  * and user is enrolled, this can be relatively slow.
3588  *
3589  * @deprecated since 2.2
3590  * @see enrol_get_users_courses()
3591  * @param int    $userid A user id. By default (null) checks the permissions of the current user.
3592  * @param string $cap - name of the capability
3593  * @param array  $accessdata_ignored
3594  * @param bool   $doanything_ignored
3595  * @param string $sort - sorting fields - prefix each fieldname with "c."
3596  * @param array  $fields - additional fields you are interested in...
3597  * @param int    $limit_ignored
3598  * @return array $courses - ordered array of course objects - see notes above
3599  */
3600 function get_user_courses_bycap($userid, $cap, $accessdata_ignored, $doanything_ignored, $sort = 'c.sortorder ASC', $fields = null, $limit_ignored = 0) {
3602     debugging('get_user_courses_bycap() is deprecated, please use enrol_get_users_courses() instead.', DEBUG_DEVELOPER);
3603     $courses = enrol_get_users_courses($userid, true, $fields, $sort);
3604     foreach ($courses as $id=>$course) {
3605         $context = context_course::instance($id);
3606         if (!has_capability($cap, $context, $userid)) {
3607             unset($courses[$id]);
3608         }
3609     }
3611     return $courses;
3614 /**
3615  * This is really slow!!! do not use above course context level
3616  *
3617  * @deprecated since Moodle 2.2
3618  * @param int $roleid
3619  * @param context $context
3620  * @return array
3621  */
3622 function get_role_context_caps($roleid, context $context) {
3623     global $DB;
3624     debugging('get_role_context_caps() is deprecated, it is really slow. Don\'t use it.', DEBUG_DEVELOPER);
3626     // This is really slow!!!! - do not use above course context level.
3627     $result = array();
3628     $result[$context->id] = array();
3630     // First emulate the parent context capabilities merging into context.
3631     $searchcontexts = array_reverse($context->get_parent_context_ids(true));
3632     foreach ($searchcontexts as $cid) {
3633         if ($capabilities = $DB->get_records('role_capabilities', array('roleid'=>$roleid, 'contextid'=>$cid))) {
3634             foreach ($capabilities as $cap) {
3635                 if (!array_key_exists($cap->capability, $result[$context->id])) {
3636                     $result[$context->id][$cap->capability] = 0;
3637                 }
3638                 $result[$context->id][$cap->capability] += $cap->permission;
3639             }
3640         }
3641     }
3643     // Now go through the contexts below given context.
3644     $searchcontexts = array_keys($context->get_child_contexts());
3645     foreach ($searchcontexts as $cid) {
3646         if ($capabilities = $DB->get_records('role_capabilities', array('roleid'=>$roleid, 'contextid'=>$cid))) {
3647             foreach ($capabilities as $cap) {
3648                 if (!array_key_exists($cap->contextid, $result)) {
3649                     $result[$cap->contextid] = array();
3650                 }
3651                 $result[$cap->contextid][$cap->capability] = $cap->permission;
3652             }
3653         }
3654     }
3656     return $result;
3659 /**
3660  * Returns current course id or false if outside of course based on context parameter.
3661  *
3662  * @see context::get_course_context()
3663  * @deprecated since 2.2
3664  * @param context $context
3665  * @return int|bool related course id or false
3666  */
3667 function get_courseid_from_context(context $context) {
3668     debugging('get_courseid_from_context() is deprecated, please use $context->get_course_context(false) instead.', DEBUG_DEVELOPER);
3669     if ($coursecontext = $context->get_course_context(false)) {
3670         return $coursecontext->instanceid;
3671     } else {
3672         return false;
3673     }
3676 /**
3677  * Preloads context information together with instances.
3678  * Use context_instance_preload() to strip the context info from the record and cache the context instance.
3679  *
3680  * If you are using this methid, you should have something like this:
3681  *
3682  *    list($ctxselect, $ctxjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
3683  *
3684  * To prevent the use of this deprecated function, replace the line above with something similar to this:
3685  *
3686  *    $ctxselect = ', ' . context_helper::get_preload_record_columns_sql('ctx');
3687  *                                                                        ^
3688  *    $ctxjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = c.id AND ctx.contextlevel = :contextlevel)";
3689  *                                    ^       ^                ^        ^
3690  *    $params = array('contextlevel' => CONTEXT_COURSE);
3691  *                                      ^
3692  * @see context_helper:;get_preload_record_columns_sql()
3693  * @deprecated since 2.2
3694  * @param string $joinon for example 'u.id'
3695  * @param string $contextlevel context level of instance in $joinon
3696  * @param string $tablealias context table alias
3697  * @return array with two values - select and join part
3698  */
3699 function context_instance_preload_sql($joinon, $contextlevel, $tablealias) {
3700     debugging('context_instance_preload_sql() is deprecated, please use context_helper::get_preload_record_columns_sql() instead.', DEBUG_DEVELOPER);